chore: bump hl2sdk (#408 )

fix: fix startup server listener
feat: expose TargetTypeMap
2025-12-06 16:06:37 -08:00 · 2024-04-11 18:15:50 +10:00 · 2024-04-11 16:14:16 +10:00 · 2024-04-11 15:34:01 +10:00 · 2024-04-11 14:26:21 +10:00 · 2024-04-11 14:20:24 +10:00
133 changed files with 5729 additions and 2189 deletions
--- a/.github/workflows/cmake-single-platform.yml
+++ b/.github/workflows/cmake-single-platform.yml
@@ -3,22 +3,46 @@ name: Build & Publish
 on:
  push:
    paths-ignore:
-      - 'docfx/**'
-    branches: [ "main", "dev" ]
+      - "docfx/**"
+    branches: ["main", "dev"]
  pull_request:
-    branches: [ "main", "dev" ]
+    branches: ["main", "dev"]

 env:
  BUILD_TYPE: Release

 jobs:
+  setup:
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    outputs:
+      buildnumber: ${{ steps.buildnumber.outputs.build_number }}
+    steps:
+      - name: Generate build number
+        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
+        id: buildnumber
+        uses: onyxmueller/build-tag-number@v1
+        with:
+          token: ${{secrets.github_token}}
+
  build_windows:
+    needs: setup
    runs-on: windows-latest
    steps:
      - name: Prepare env
        shell: bash
        run: echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV

+      - name: Fallback build number
+        if: ${{ github.event_name == 'pull_request' || github.ref != 'refs/heads/main' }}
+        shell: bash
+        run: echo "BUILD_NUMBER=0" >> $GITHUB_ENV
+
+      - name: Main build number
+        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
+        run: echo "BUILD_NUMBER=${{ needs.setup.outputs.buildnumber }}" >> $GITHUB_ENV
+
      - name: Visual Studio environment
        shell: cmd
        run: |
@@ -34,7 +58,7 @@ jobs:

      - uses: actions/checkout@v3
        with:
-          submodules: 'recursive'
+          submodules: "recursive"

      - name: Build
        run: |
@@ -56,6 +80,7 @@ jobs:
          path: build/output/

  build_linux:
+    needs: setup
    runs-on: ubuntu-latest
    # Could not figure out how to run in a container only on some matrix paths, so I've split it out into its own build.
    container:
@@ -65,9 +90,18 @@ jobs:
        shell: bash
        run: echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV

+      - name: Fallback build number
+        if: ${{ github.event_name == 'pull_request' || github.ref != 'refs/heads/main' }}
+        shell: bash
+        run: echo "BUILD_NUMBER=0" >> $GITHUB_ENV
+
+      - name: Main build number
+        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
+        run: echo "BUILD_NUMBER=${{ needs.setup.outputs.buildnumber }}" >> $GITHUB_ENV
+
      - uses: actions/checkout@v3
        with:
-          submodules: 'recursive'
+          submodules: "recursive"

      - name: Build
        run: |
@@ -87,11 +121,10 @@ jobs:
          path: build/output/

  build_managed:
+    needs: setup
    permissions:
      contents: write
    runs-on: ubuntu-latest
-    outputs:
-      buildnumber: ${{ steps.buildnumber.outputs.build_number }}
    steps:
      - name: Prepare env
        shell: bash
@@ -102,20 +135,17 @@ jobs:
        shell: bash
        run: echo "BUILD_NUMBER=0" >> $GITHUB_ENV

+      - name: Main build number
+        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
+        run: echo "BUILD_NUMBER=${{ needs.setup.outputs.buildnumber }}" >> $GITHUB_ENV
+
      # We don't need expensive submodules for the managed side.
      - uses: actions/checkout@v3

-      - name: Generate build number
-        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
-        id: buildnumber
-        uses: onyxmueller/build-tag-number@v1
-        with:
-          token: ${{secrets.github_token}}
-
      - name: Build runtime v${{ env.BUILD_NUMBER }}
        uses: actions/setup-dotnet@v3
        with:
-          dotnet-version: '7.0.x'
+          dotnet-version: "8.0.x"

      - name: Install dependencies
        run: dotnet restore managed/CounterStrikeSharp.sln
@@ -133,7 +163,7 @@ jobs:
      - name: Publish artifacts
        run: |
          dotnet publish -c Release /p:Version=1.0.${{ env.BUILD_NUMBER }} managed/CounterStrikeSharp.API
-          dotnet pack -c Release /p:Version=1.0.${{ env.BUILD_NUMBER }} managed/CounterStrikeSharp.API   
+          dotnet pack -c Release /p:Version=1.0.${{ env.BUILD_NUMBER }} managed/CounterStrikeSharp.API

      - uses: actions/upload-artifact@v3
        with:
@@ -144,7 +174,7 @@ jobs:
    if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
    permissions:
      contents: write
-    needs: [ "build_linux", "build_windows", "build_managed" ]
+    needs: ["setup", "build_linux", "build_windows", "build_managed"]
    runs-on: ubuntu-latest
    steps:
      - name: Prepare env
@@ -171,49 +201,48 @@ jobs:
        run: |
          mkdir -p build/linux/addons/counterstrikesharp/api
          mkdir -p build/windows/addons/counterstrikesharp/api
-          cp -r build/api/net7.0/publish/* build/linux/addons/counterstrikesharp/api
-          cp -r build/api/net7.0/publish/* build/windows/addons/counterstrikesharp/api
+          cp -r build/api/net8.0/publish/* build/linux/addons/counterstrikesharp/api
+          cp -r build/api/net8.0/publish/* build/windows/addons/counterstrikesharp/api

      - name: Zip Builds
        run: |
-          (cd build/linux && zip -qq -r ../../counterstrikesharp-build-${{ needs.build_managed.outputs.buildnumber }}-linux-${{ env.GITHUB_SHA_SHORT }}.zip *)
-          (cd build/windows && zip -qq -r ../../counterstrikesharp-build-${{ needs.build_managed.outputs.buildnumber }}-windows-${{ env.GITHUB_SHA_SHORT }}.zip *)
+          (cd build/linux && zip -qq -r ../../counterstrikesharp-build-${{ needs.setup.outputs.buildnumber }}-linux-${{ env.GITHUB_SHA_SHORT }}.zip *)
+          (cd build/windows && zip -qq -r ../../counterstrikesharp-build-${{ needs.setup.outputs.buildnumber }}-windows-${{ env.GITHUB_SHA_SHORT }}.zip *)

      - name: Add dotnet runtime
        run: |
          mkdir -p build/linux/addons/counterstrikesharp/dotnet
-          curl -s -L https://download.visualstudio.microsoft.com/download/pr/dc2c0a53-85a8-4fda-a283-fa28adb5fbe2/8ccade5bc400a5bb40cd9240f003b45c/aspnetcore-runtime-7.0.11-linux-x64.tar.gz \
+          curl -s -L https://download.visualstudio.microsoft.com/download/pr/c1371dc2-eed2-47be-9af3-ae060dbe3c7d/bd509e0a87629764ed47608466d183e6/aspnetcore-runtime-8.0.3-linux-x64.tar.gz \
          | tar xvz -C build/linux/addons/counterstrikesharp/dotnet
-          mv build/linux/addons/counterstrikesharp/dotnet/shared/Microsoft.NETCore.App/7.0.11/* build/linux/addons/counterstrikesharp/dotnet/shared/Microsoft.NETCore.App/
-          
+
          mkdir -p build/windows/addons/counterstrikesharp/dotnet
-          curl -s -L https://download.visualstudio.microsoft.com/download/pr/a99861c8-2e00-4587-aaef-60366ca77307/a44ceec2c5d34165ae881600f52edc43/aspnetcore-runtime-7.0.11-win-x64.zip -o dotnet.zip
+          curl -s -L https://download.visualstudio.microsoft.com/download/pr/086d1dd6-57a5-437a-a1ef-549cf702fb48/dd4a8fe6c53a1016a414d6f2925c1323/aspnetcore-runtime-8.0.3-win-x64.zip -o dotnet.zip
          unzip -qq dotnet.zip -d build/windows/addons/counterstrikesharp/dotnet

      - name: Zip Builds
        run: |
-          (cd build/linux && zip -qq -r ../../counterstrikesharp-with-runtime-build-${{ needs.build_managed.outputs.buildnumber }}-linux-${{ env.GITHUB_SHA_SHORT }}.zip *)
-          (cd build/windows && zip -qq -r ../../counterstrikesharp-with-runtime-build-${{ needs.build_managed.outputs.buildnumber }}-windows-${{ env.GITHUB_SHA_SHORT }}.zip *)
+          (cd build/linux && zip -qq -r ../../counterstrikesharp-with-runtime-build-${{ needs.setup.outputs.buildnumber }}-linux-${{ env.GITHUB_SHA_SHORT }}.zip *)
+          (cd build/windows && zip -qq -r ../../counterstrikesharp-with-runtime-build-${{ needs.setup.outputs.buildnumber }}-windows-${{ env.GITHUB_SHA_SHORT }}.zip *)

      - name: Release
        id: release
        uses: softprops/action-gh-release@v1
        with:
-          tag_name: v${{ needs.build_managed.outputs.buildnumber }}
+          tag_name: v${{ needs.setup.outputs.buildnumber }}
          files: |
-            counterstrikesharp-build-${{ needs.build_managed.outputs.buildnumber }}-windows-${{ env.GITHUB_SHA_SHORT }}.zip
-            counterstrikesharp-with-runtime-build-${{ needs.build_managed.outputs.buildnumber }}-windows-${{ env.GITHUB_SHA_SHORT }}.zip
-            counterstrikesharp-build-${{ needs.build_managed.outputs.buildnumber }}-linux-${{ env.GITHUB_SHA_SHORT }}.zip
-            counterstrikesharp-with-runtime-build-${{ needs.build_managed.outputs.buildnumber }}-linux-${{ env.GITHUB_SHA_SHORT }}.zip
+            counterstrikesharp-build-${{ needs.setup.outputs.buildnumber }}-windows-${{ env.GITHUB_SHA_SHORT }}.zip
+            counterstrikesharp-with-runtime-build-${{ needs.setup.outputs.buildnumber }}-windows-${{ env.GITHUB_SHA_SHORT }}.zip
+            counterstrikesharp-build-${{ needs.setup.outputs.buildnumber }}-linux-${{ env.GITHUB_SHA_SHORT }}.zip
+            counterstrikesharp-with-runtime-build-${{ needs.setup.outputs.buildnumber }}-linux-${{ env.GITHUB_SHA_SHORT }}.zip

      - name: Publish NuGet package
        run: |
-          dotnet nuget push build/api/CounterStrikeSharp.API.1.0.${{ needs.build_managed.outputs.buildnumber }}.nupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate
-          dotnet nuget push build/api/CounterStrikeSharp.API.1.0.${{ needs.build_managed.outputs.buildnumber }}.snupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate
+          dotnet nuget push build/api/CounterStrikeSharp.API.1.0.${{ needs.setup.outputs.buildnumber }}.nupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate
+          dotnet nuget push build/api/CounterStrikeSharp.API.1.0.${{ needs.setup.outputs.buildnumber }}.snupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate

      - name: Send Notification to Discord
        env:
          DISCORD_WEBHOOK: ${{ secrets.DISCORD_WEBHOOK }}
        uses: Ilshidur/action-discord@0.3.2
        with:
-          args: "A new release of CS# has been tagged (v${{ needs.build_managed.outputs.buildnumber }}) at ${{ steps.release.outputs.url }}"
+          args: "A new release of CS# has been tagged (v${{ needs.setup.outputs.buildnumber }}) at ${{ steps.release.outputs.url }}"
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,6 @@
 .ccls-cache/
 .cmake/
-cmake-build-debug*/
+cmake-build-*/
 .kdev4/
 .vscode/
 generated/
--- a/.gitmodules
+++ b/.gitmodules
@@ -14,12 +14,12 @@
 [submodule "libraries/dyncall"]
 	path = libraries/dyncall
 	url = https://github.com/LWJGL-CI/dyncall
-[submodule "libraries/GameTracking-CS2"]
-	path = libraries/GameTracking-CS2
-	url = https://github.com/SteamDatabase/GameTracking-CS2
 [submodule "libraries/DynoHook"]
 	path = libraries/DynoHook
 	url = https://github.com/qubka/DynoHook
 [submodule "libraries/asmjit"]
 	path = libraries/asmjit
 	url = https://github.com/asmjit/asmjit
+[submodule "libraries/Protobufs"]
+	path = libraries/Protobufs
+	url = https://github.com/SteamDatabase/Protobufs
--- a/ACKNOWLEDGEMENTS.md
+++ b/ACKNOWLEDGEMENTS.md
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -49,6 +49,8 @@ SET(SOURCE_FILES
    src/core/managers/event_manager.cpp
    src/core/timer_system.h
    src/core/timer_system.cpp
+    src/core/tick_scheduler.h
+    src/core/tick_scheduler.cpp
    src/scripting/autonative.h
    src/scripting/natives/natives_engine.cpp
    src/core/engine_trace.h
@@ -68,7 +70,6 @@ SET(SOURCE_FILES
    src/core/memory_module.h
    src/core/memory_module.cpp
    src/core/cs2_sdk/interfaces/cgameresourceserviceserver.h
-    src/core/cs2_sdk/interfaces/cschemasystem.h
    src/core/cs2_sdk/interfaces/cs2_interfaces.h
    src/core/cs2_sdk/interfaces/cs2_interfaces.cpp
    src/core/cs2_sdk/schema.h
@@ -90,6 +91,8 @@ SET(SOURCE_FILES
    src/core/managers/voice_manager.cpp
    src/core/managers/voice_manager.h
    src/scripting/natives/natives_dynamichooks.cpp
+    src/core/game_system.h
+    src/core/game_system.cpp
 )


@@ -101,8 +104,8 @@ if (LINUX)
    )
 endif()

-set(PROTO_DIRS -I${CMAKE_CURRENT_SOURCE_DIR}/libraries/GameTracking-CS2/Protobufs)
-file(GLOB PROTOS "${CMAKE_CURRENT_SOURCE_DIR}/libraries/GameTracking-CS2/Protobufs/*.proto")
+set(PROTO_DIRS -I${CMAKE_CURRENT_SOURCE_DIR}/libraries/Protobufs/csgo)
+file(GLOB PROTOS "${CMAKE_CURRENT_SOURCE_DIR}/libraries/Protobufs/csgo/*.proto")

 ## Generate protobuf source & headers
 if (LINUX)
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -0,0 +1,103 @@
+# Contributing to CounterStrikeSharp
+
+We'd love for you to contribute to CS# to make it better than it is today!
+
+Here are the guidelines we'd like you to follow:
+
+ - [Question or Problem?](#question)
+ - [Issues and Bugs](#issue)
+ - [Submission Guidelines](#submit)
+ - [Coding Format](#format)
+
+## <a name="question"></a> Got a Question or Problem?
+
+If you have questions about how to contribute to CounterStrikeSharp, please join our [Discord][discord] server.
+
+## <a name="issue"></a> Found an Issue?
+
+If you find a bug in the source code or a mistake in the documentation, you can help us by
+submitting an issue to our [GitHub Repository][github]. Even better you can submit a Pull Request
+with a fix.
+
+**Please see the [Submission Guidelines](#submit) below.**
+
+## <a name="submit"></a> Submission Guidelines
+
+### Submitting an Issue
+Before you submit your issue please search the archive, maybe your question was already answered.
+
+If your issue appears to be a bug and hasn't been reported, open a new issue. Help us to maximize
+the effort we can spend fixing issues and adding new features, by not reporting duplicate issues.
+Providing the following information will increase the chances of your issue being dealt with
+quickly:
+
+* **Overview of the Issue** - if an error is being thrown a stack trace helps
+* **Operating System** - is this a problem with a specific OS (Windows or Linux)?
+* **Reproduce the Error** - provide details, if possible, on how to reproduce the error
+* **Related Issues** - has a similar issue been reported before?
+* **Suggest a Fix** - if you can't fix the bug yourself, perhaps you can point to what might be causing the problem (line of code or commit)
+
+### Submitting a Pull Request
+Before you submit your pull request consider the following guidelines:
+
+* Search [GitHub](https://github.com/roflmuffin/CounterStrikeSharp/pulls) for an open or closed Pull Request
+  that relates to your submission. You don't want to duplicate effort.
+* If adding a feature or enhancement, we recommend you first [start a discussion for
+  it](https://github.com/roflmuffin/CounterStrikeSharp/discussions) before submitting a Pull Request.
+* [Fork](https://help.github.com/articles/fork-a-repo/) this repo.
+* [Clone](https://help.github.com/articles/cloning-a-repository/) your copy.
+    ```shell
+    git clone https://github.com/YOUR_USERNAME/CounterStrikeSharp.git
+    cd CounterStrikeSharp/
+    ```
+* After cloning, set a new remote [upstream](https://help.github.com/articles/configuring-a-remote-for-a-fork/) (this helps to keep your fork up to date)
+    
+    ```shell
+    git remote add upstream https://github.com/roflmuffin/CounterStrikeSharp.git
+    ```
+
+* Make your changes in a new git branch:
+
+    ```shell
+    git checkout -b my-fix-branch master
+    ```
+
+* Create your patch and run appropriate tests.
+* Commit your changes using a descriptive commit message that uses the imperative, present tense: "change" not "changed" nor "changes".
+
+    ```shell
+    git commit -a
+    ```
+  Note: the optional commit `-a` command line option will automatically "add" and "rm" edited files.
+
+* Push your branch to GitHub:
+
+    ```shell
+    git push origin my-fix-branch
+    ```
+
+In GitHub, send a pull request to `CounterStrikeSharp:master`.
+If we suggest changes, then:
+
+* Make the required updates.
+* Re-run CounterStrikeSharp to ensure everything is still working & tests are passing.
+* Commit your changes to your branch (e.g. `my-fix-branch`).
+* Push the changes to your GitHub repository (this will update your Pull Request).
+
+If the PR gets too outdated we may ask you to rebase and force push to update the PR:
+
+```shell
+git fetch upstream
+git rebase upstream/master
+git push origin my-fix-branch -f
+```
+
+That's it! Thank you for your contribution!
+
+#### After your pull request is merged
+
+After your pull request is merged, you can safely delete your branch and pull the changes
+from the main (upstream) repository.
+
+[github]: https://github.com/roflmuffin/CounterStrikeSharp
+[discord]: https://discord.gg/eAZU3guKWU
--- a/README.md
+++ b/README.md
@@ -1,6 +1,6 @@
 # CounterStrikeSharp

-CounterStrikeSharp is a server side modding framework for Counter-Strike: Global Offensive. This project attempts to implement a .NET Core scripting layer on top of a Metamod Source Plugin, allowing developers to create plugins that interact with the game server in a modern language (C#) to facilitate the creation of maintainable and testable code.
+CounterStrikeSharp is a server side modding framework for Counter-Strike 2. This project implements a .NET 8 scripting layer on top of a Metamod Source Plugin, allowing developers to create plugins that interact with the game server in a modern language (C#) to facilitate the creation of maintainable and testable code.

 [Come and join our Discord](https://discord.gg/eAZU3guKWU)

@@ -18,14 +18,12 @@ Detailed installation instructions can be found in the [docs](https://docs.cssha

 ## What works?

-_(Note, these were features in the previous VSP.NET project, but have not been implemented yet in this project)_
-
 These features are the core of the platform and work pretty well/have a low risk of causing issues.

 - [x] Console Commands, Server Commands (e.g. css_mycommand)
 - [x] Chat Commands with `!` and `/` prefixes (e.g. !mycommand)
- [ ] **(In Progress)** Console Variables
- [x] Game Event Handlers & Custom Events (e.g. player_death)
+- [x] Fake Console Variables (commands which mimic ConVar behaviour as these have not been fully reverse engineered) 
+- [x] Game Event Handlers & Firing of Events (e.g. player_death)
  - [x] Basic event value get/set (string, bool, int32, float)
  - [x] Complex event values get/set (ehandle, pawn, player controller)
 - [x] Game Tick Based Timers (e.g. repeating map timers)
@@ -34,7 +32,7 @@ These features are the core of the platform and work pretty well/have a low risk
  - [x] Client Listeners (e.g. connect, disconnect, put in server)
  - [x] OnMapStart
  - [x] OnTick
- [x] Server Information (current map, game time, tick rate, model precaching)
+- [x] Server Information (current map, game time)
 - [x] Schema System Access (access player values like current weapon, money, location etc.)

 ## Links
--- a/configs/addons/counterstrikesharp/configs/core.example.json
+++ b/configs/addons/counterstrikesharp/configs/core.example.json
@@ -3,5 +3,6 @@
    "SilentChatTrigger": [ "/" ],
    "FollowCS2ServerGuidelines": true,
    "PluginHotReloadEnabled": true,
+    "PluginAutoLoadEnabled": true,
    "ServerLanguage": "en"
 }
--- a/configs/addons/counterstrikesharp/gamedata/gamedata.json
+++ b/configs/addons/counterstrikesharp/gamedata/gamedata.json
@@ -28,8 +28,8 @@
  },
  "CCSPlayerController_Respawn": {
    "offsets": {
-        "windows": 245,
-        "linux": 247
+        "windows": 244,
+        "linux": 246
    }
  },
  "CBasePlayerController_SetPawn": {
@@ -206,5 +206,18 @@
      "windows": "\\x4C\\x89\\x4C\\x24\\x20\\x53\\x55\\x57\\x41\\x54\\x41\\x56\\x48\\x81\\xEC",
      "linux": "\\x55\\x48\\x89\\xE5\\x41\\x57\\x41\\x56\\x41\\x55\\x41\\x54\\x49\\x89\\xD4\\x53\\x48\\x89\\xF3\\x48\\x83\\xEC\\x58"
    }
+  },
+  "IGameSystem_InitAllSystems_pFirst": {
+    "signatures": {
+      "library": "server",
+      "windows": "\\x48\\x8B\\x1D\\x2A\\x2A\\x2A\\x2A\\x48\\x85\\xDB\\x0F\\x84\\x2A\\x2A\\x2A\\x2A\\xBE\\x2A\\x2A\\x2A\\x2A\\x0F\\x1F\\x00\\x48\\x8B\\x7B\\x10",
+      "linux": "\\x4C\\x8B\\x35\\x2A\\x2A\\x2A\\x2A\\x4D\\x85\\xF6\\x75\\x2D\\xE9\\x2A\\x2A\\x2A\\x2A\\x0F\\x1F\\x40\\x00\\x48\\x8B\\x05"
+    }
+  },
+  "CEntityResourceManifest_AddResource": {
+    "offsets": {
+      "windows": 2,
+      "linux": 2
+    }
  }
 }
--- a/configs/addons/counterstrikesharp/shared/README.md
+++ b/configs/addons/counterstrikesharp/shared/README.md
@@ -0,0 +1 @@
+This folder should contain any shared APIs, in the same DLL structure as the plugins folder (MySharedApi/MySharedApi.dll)
--- a/docfx/docs/features/shared-plugin-api.md
+++ b/docfx/docs/features/shared-plugin-api.md
@@ -0,0 +1,67 @@
+---
+title: Shared Plugin API (Capabilities)
+description: How to add inter-plugin communication to CounterStrikeSharp plugins.
+---
+
+# Shared Plugin API
+
+How to expose and use shared plugin APIs between multiple plugins.
+
+## Creating a Contract Library
+
+Inter-plugin communication requires a contract/shared library that simply exposes the shape of the API, using simple interfaces. e.g.
+
+```csharp
+public interface IBalanceHandler
+{
+    decimal Balance { get; }
+
+    // These are just here to show that you can have methods on your shared types.
+    // You could also add a Setter to the Balance property.
+    public decimal Add(decimal amount);
+    public decimal Subtract(decimal amount);
+}
+```
+
+This library ideally should not contain any business logic, and simply define the schema for callers.
+
+This library should be placed in the `shared` subfolder, in the same folder layout as the plugins folder. So if a contract DLL is named `MySharedApi.dll` its file path should be: `shared/MySharedApi/MySharedApi.dll`.
+
+## Creating a Capability
+
+A capability can be declared with a simple static variable in your plugin class. A `PlayerCapability` is a player specific capability, and a `PluginCapability` is generic functionality that a plugin can expose.
+
+```csharp
+public static PlayerCapability<IBalanceHandler> BalanceCapability { get; } = new("myplugin:balance");
+
+public static PluginCapability<IBalanceService> BalanceServiceCapability { get; } = new("myplugin:balance_service");
+```
+
+For every plugin that wishes to use this new "Balance API", they must ensure they create a capability using the shared API interface (`IBalanceHandler`), as well as use the same name (`myplugin:balance`).
+
+## Registering a Capability
+
+If you are the plugin that is expected to provide the basis of the API (i.e. you are providing a currency/balance plugin which does nothing except store users balances), then you will need to provide the implementation that other callers will use. This is done through the use of static members on the `Capabilities` class:
+
+```csharp
+// Player capabilities are given the calling player context
+Capabilities.RegisterPlayerCapability(BalanceCapability, player => new BalanceHandler(player));
+
+// Plugin capabilities can simply return an instance of the interface
+Capabilities.RegisterPluginCapability(BalanceServiceCapability, () => new BalanceService());
+```
+
+### Using Capabilities
+
+To utilise a capability, simply call the `.Get()` method provided on the static capability you declared earlier, i.e.
+
+```csharp
+var balance = BalanceCapability.Get(player);
+var balanceService = BalanceServiceCapability.Get();
+
+if (balance == null) return;
+
+balance.Add(500);
+```
+
+This value _MUST_ be checked for null, as if there are no plugins providing implementations for a given capability, this method will return null, and you must handle this flow in your plugin.
--- a/docfx/docs/features/toc.yml
+++ b/docfx/docs/features/toc.yml
@@ -9,3 +9,6 @@

 - name: Global Listeners
  href: global-listeners.md
+
+- name: Shared Plugin API
+  href: shared-plugin-api.md
--- a/docfx/docs/guides/hello-world-plugin.md
+++ b/docfx/docs/guides/hello-world-plugin.md
@@ -9,7 +9,7 @@ How to write your first plugin for CounterStrikeSharp

 ## Creating a New Project

-First, ensure you have the relevant .NET 7.0 SDK for your platform installed on your machine. You can find the links to the latest downloads on the <a href="https://dotnet.microsoft.com/en-us/download/dotnet/7.0" target="_blank"> official Microsoft download page</a>.
+First, ensure you have the relevant .NET 8.0 SDK for your platform installed on your machine. You can find the links to the latest downloads on the <a href="https://dotnet.microsoft.com/en-us/download/dotnet/8.0" target="_blank"> official Microsoft download page</a>.

 ### Creating a Class Library

@@ -25,7 +25,7 @@ Use your IDE (Visual Studio/Rider) to add a reference to the `CounterStrikeSharp
 <Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
@@ -65,7 +65,7 @@ public class HelloWorldPlugin : BasePlugin
 }
 ```

-Now build your project using your ide or the `dotnet build` command. You should now have a built binary file in your `bin/Debug/net7.0` subdirectory in the project.
+Now build your project using your ide or the `dotnet build` command. You should now have a built binary file in your `bin/Debug/net8.0` subdirectory in the project.

 ### Installing your Plugin

--- a/docfx/docs/reference/core-configuration.md
+++ b/docfx/docs/reference/core-configuration.md
@@ -33,6 +33,10 @@ receive a ban.

 When enabled, plugins are automatically reloaded when their .dll file is updated.

+## PluginAutoLoadEnabled
+
+When enabled, plugins are automatically loaded from the plugins directory on server start.
+
 ## ServerLanguage

 Configures the default language to use for server commands & messages. The format for the culture name based on RFC 4646 is `languagecode2-country`/`regioncode2`, where `languagecode2` is the two-letter language code and `country/regioncode2` is the two-letter subculture code. Examples include `ja-JP` for Japanese (Japan) and `en-US` for English (United States). Defaults to "en".
--- a/docfx/examples/WithSharedTypes.md
+++ b/docfx/examples/WithSharedTypes.md
@@ -0,0 +1,11 @@
+[!INCLUDE [WithSharedTypes](../../examples/WithSharedTypes/README.md)]
+
+<a href="https://github.com/roflmuffin/CounterStrikeSharp/tree/main/examples/WithSharedTypes" class="btn btn-secondary">View project on Github <i class="bi bi-github"></i></a>
+
+[!code-csharp[](../../examples/WithSharedTypes/WithSharedTypesPlugin.cs)]
+
+[!INCLUDE [WithSharedTypesConsumer](../../examples/WithSharedTypesConsumer/README.md)]
+
+<a href="https://github.com/roflmuffin/CounterStrikeSharp/tree/main/examples/WithSharedTypesConsumer" class="btn btn-secondary">View project on Github <i class="bi bi-github"></i></a>
+
+[!code-csharp[](../../examples/WithSharedTypesConsumer/WithSharedTypesConsumerPlugin.cs)]
--- a/docfx/examples/toc.yml
+++ b/docfx/examples/toc.yml
@@ -15,6 +15,8 @@ items:
    href: WithGameEventHandlers.md
  - name: Database (Dapper)
    href: WithDatabase.md
+  - name: Shared Plugin Types
+    href: WithSharedTypes.md
  - name: Translations
    href: WithTranslations.md
  - name: Voice Overrides
--- a/examples/HelloWorld/HelloWorld.csproj
+++ b/examples/HelloWorld/HelloWorld.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
--- a/examples/MySharedTypes.Contracts/MySharedTypes.Contracts/IBalanceHandler.cs
+++ b/examples/MySharedTypes.Contracts/MySharedTypes.Contracts/IBalanceHandler.cs
@@ -0,0 +1,11 @@
+namespace MySharedTypes.Contracts;
+
+public interface IBalanceHandler
+{
+    decimal Balance { get; }
+
+    // These are just here to show that you can have methods on your shared types.
+    // You could also add a Setter to the Balance property.
+    public decimal Add(decimal amount);
+    public decimal Subtract(decimal amount);
+}
--- a/examples/MySharedTypes.Contracts/MySharedTypes.Contracts/IBalanceService.cs
+++ b/examples/MySharedTypes.Contracts/MySharedTypes.Contracts/IBalanceService.cs
@@ -0,0 +1,6 @@
+namespace MySharedTypes.Contracts;
+
+public interface IBalanceService
+{
+    public void ClearAllBalances();
+}
--- a/examples/MySharedTypes.Contracts/MySharedTypes.Contracts/MySharedTypes.Contracts.csproj
+++ b/examples/MySharedTypes.Contracts/MySharedTypes.Contracts/MySharedTypes.Contracts.csproj
@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+    </PropertyGroup>
+</Project>
--- a/examples/WarcraftPlugin/WarcraftPlugin.csproj
+++ b/examples/WarcraftPlugin/WarcraftPlugin.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
+    <TargetFramework>net8.0</TargetFramework>
    <OutputType>Library</OutputType>
    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
--- a/examples/WithCommands/WithCommands.csproj
+++ b/examples/WithCommands/WithCommands.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
--- a/examples/WithConfig/WithConfig.csproj
+++ b/examples/WithConfig/WithConfig.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
--- a/examples/WithDatabaseDapper/WithDatabaseDapper.csproj
+++ b/examples/WithDatabaseDapper/WithDatabaseDapper.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
--- a/examples/WithDependencyInjection/WithDependencyInjection.csproj
+++ b/examples/WithDependencyInjection/WithDependencyInjection.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
--- a/examples/WithEntityOutputHooks/WithEntityOutputHooks.csproj
+++ b/examples/WithEntityOutputHooks/WithEntityOutputHooks.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
--- a/examples/WithFakeConvars/WithFakeConvars.csproj
+++ b/examples/WithFakeConvars/WithFakeConvars.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
--- a/examples/WithFakeConvars/WithFakeConvarsPlugin.cs
+++ b/examples/WithFakeConvars/WithFakeConvarsPlugin.cs
@@ -6,7 +6,7 @@ using CounterStrikeSharp.API.Modules.Cvars.Validators;

 namespace WithFakeConvars;

-[MinimumApiVersion(168)]
+[MinimumApiVersion(175)]
 public class WithFakeConvarsPlugin : BasePlugin
 {
    public override string ModuleName => "Example: With Fake Convars";
@@ -55,4 +55,4 @@ public class WithFakeConvarsPlugin : BasePlugin
        
        RegisterFakeConVars(typeof(ConVars));
    }
-}
+}
--- a/examples/WithGameEventHandlers/WithGameEventHandlers.csproj
+++ b/examples/WithGameEventHandlers/WithGameEventHandlers.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
--- a/examples/WithSharedTypes/BalanceHandler.cs
+++ b/examples/WithSharedTypes/BalanceHandler.cs
@@ -0,0 +1,33 @@
+using CounterStrikeSharp.API.Core;
+using MySharedTypes.Contracts;
+
+namespace WithSharedTypes;
+
+public class BalanceHandler : IBalanceHandler
+{
+    private readonly CCSPlayerController _player;
+
+    // This could be a database, a file, or a dictionary like this.
+    internal static readonly Dictionary<CCSPlayerController, decimal> Balances = new();
+
+    public BalanceHandler(CCSPlayerController player)
+    {
+        _player = player;
+    }
+
+    public decimal Balance
+    {
+        get => Balances.TryGetValue(_player, out var balance) ? balance : 0;
+        set => Balances[_player] = value;
+    }
+
+    public decimal Add(decimal amount)
+    {
+        return Balance += amount;
+    }
+
+    public decimal Subtract(decimal amount)
+    {
+        return Balance -= amount;
+    }
+}
--- a/examples/WithSharedTypes/BalanceService.cs
+++ b/examples/WithSharedTypes/BalanceService.cs
@@ -0,0 +1,11 @@
+using MySharedTypes.Contracts;
+
+namespace WithSharedTypes;
+
+public class BalanceService : IBalanceService
+{
+    public void ClearAllBalances()
+    {
+        BalanceHandler.Balances.Clear();
+    }
+}
--- a/examples/WithSharedTypes/README.md
+++ b/examples/WithSharedTypes/README.md
@@ -0,0 +1,5 @@
+# With Shared Types (Capabilities)
+
+An example plugin that exposes a balance contract library, to use as a shared library between multiple plugins.
+
+This allows one plugin to expose a capability for a player or plugin, and other plugins to use the exposed API.
--- a/examples/WithSharedTypes/WithSharedTypes.csproj
+++ b/examples/WithSharedTypes/WithSharedTypes.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+        <CopyLocalLockFileAssemblies>false</CopyLocalLockFileAssemblies>
+    </PropertyGroup>
+    <ItemGroup>
+      <ProjectReference Include="..\..\managed\CounterStrikeSharp.API\CounterStrikeSharp.API.csproj" />
+      <ProjectReference Include="..\MySharedTypes.Contracts\MySharedTypes.Contracts\MySharedTypes.Contracts.csproj" />
+    </ItemGroup>
+</Project>
--- a/examples/WithSharedTypes/WithSharedTypesPlugin.cs
+++ b/examples/WithSharedTypes/WithSharedTypesPlugin.cs
@@ -0,0 +1,57 @@
+using CounterStrikeSharp.API.Core;
+using CounterStrikeSharp.API.Core.Attributes;
+using CounterStrikeSharp.API.Core.Capabilities;
+using MySharedTypes.Contracts;
+
+namespace WithSharedTypes;
+
+[MinimumApiVersion(184)]
+public class WithSharedTypesPlugin : BasePlugin
+{
+    public override string ModuleName => "Example: Shared Types";
+    public override string ModuleVersion => "1.0.0";
+    public override string ModuleAuthor => "CounterStrikeSharp & Contributors";
+    public override string ModuleDescription => "A simple plugin that shares types between multiple plugins";
+
+    // Declares a player capability, that stores some sort of functionality for a player.
+    // In this case, it's a balance handler, which is used to store a player's balance.
+    // Note that we use the same name for the capability as the one in the other plugin.
+    // IBalanceHandler is defined in MySharedTypes.Contracts, which is a shared library and placed in the `shared/` subfolder.
+    public static PlayerCapability<IBalanceHandler> BalanceCapability { get; } = new("myplugin:balance");
+    
+    // Declares a player capability of a primitive type, in this case, a decimal.
+    public static PlayerCapability<Decimal> BalanceCapabilityDecimal { get; } = new("myplugin:balance_decimal");
+    
+    // Plugin capabilities are similar to player capabilities, but they are not tied to a player, and are just generic APIs
+    // that are exposed by a plugin. In this case, we expose a balance service, which is used to clear all balances.
+    public static PluginCapability<IBalanceService> BalanceServiceCapability { get; } = new("myplugin:balance_service");
+
+    public override void Load(bool hotReload)
+    {
+        // Register the capability implementations here. Note that plugins don't need to register an implementation if it is already implemented in another plugin.
+        Capabilities.RegisterPlayerCapability(BalanceCapability, player => new BalanceHandler(player));
+        Capabilities.RegisterPluginCapability(BalanceServiceCapability, () => new BalanceService());
+        Capabilities.RegisterPlayerCapability(BalanceCapabilityDecimal, (player) => new BalanceHandler(player).Balance);
+
+        AddCommand("css_balance", "Gets your current balance", (player, info) =>
+        {
+            if (player == null) return;
+            player.PrintToChat($"Your balance is {BalanceCapability.Get(player)?.Balance}");
+        });
+
+        AddCommand("css_give", "Gives you money", (player, info) =>
+        {
+            if (player == null) return;
+
+            var balance = BalanceCapability.Get(player);
+            if (balance == null) return;
+
+            balance.Add(100);
+            player.PrintToChat($"Your balance is now {balance.Balance}");
+        });
+    }
+
+    public override void Unload(bool hotReload)
+    {
+    }
+}
--- a/examples/WithSharedTypesConsumer/README.md
+++ b/examples/WithSharedTypesConsumer/README.md
@@ -0,0 +1,2 @@
+# With Shared Types (Consumer Plugin)
+Uses the decimal balance shared library.
--- a/examples/WithSharedTypesConsumer/WithSharedTypesConsumer.csproj
+++ b/examples/WithSharedTypesConsumer/WithSharedTypesConsumer.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+        <CopyLocalLockFileAssemblies>false</CopyLocalLockFileAssemblies>
+    </PropertyGroup>
+    <ItemGroup>
+      <ProjectReference Include="..\..\managed\CounterStrikeSharp.API\CounterStrikeSharp.API.csproj" />
+      <ProjectReference Include="..\MySharedTypes.Contracts\MySharedTypes.Contracts\MySharedTypes.Contracts.csproj" />
+    </ItemGroup>
+</Project>
--- a/examples/WithSharedTypesConsumer/WithSharedTypesConsumerPlugin.cs
+++ b/examples/WithSharedTypesConsumer/WithSharedTypesConsumerPlugin.cs
@@ -0,0 +1,56 @@
+using CounterStrikeSharp.API.Core;
+using CounterStrikeSharp.API.Core.Attributes;
+using CounterStrikeSharp.API.Core.Capabilities;
+using CounterStrikeSharp.API.Core.Plugin;
+using MySharedTypes.Contracts;
+
+namespace WithSharedTypesConsumer;
+
+[MinimumApiVersion(184)]
+public class WithSharedTypesConsumerPlugin : BasePlugin
+{
+    public override string ModuleName => "Example: Shared Types (Consumer)";
+    public override string ModuleVersion => "1.0.0";
+    public override string ModuleAuthor => "CounterStrikeSharp & Contributors";
+    public override string ModuleDescription => "A simple plugin that utilises the balance api from another plugin";
+
+    public static PlayerCapability<IBalanceHandler> BalanceCapability { get; } = new("myplugin:balance");
+    public static PlayerCapability<Decimal> BalanceCapabilityDecimal { get; } = new("myplugin:balance_decimal");
+
+    public static PluginCapability<IBalanceService> BalanceServiceCapability { get; } = new("myplugin:balance_service");
+    
+    public override void Load(bool hotReload)
+    {
+        AddCommand("css_subtract", "Subtracts 50 from your balance", (player, info) =>
+        {
+            if (player == null) return;
+            var balance = BalanceCapability.Get(player);
+            if (balance == null) return;
+            balance.Subtract(50);
+            player.PrintToChat($"Your balance is now {balance.Balance}");
+        });
+        
+        AddCommand("css_clearbalances", "Clears all balances", (player, info) =>
+        {
+            if (player == null) return;
+            var service = BalanceServiceCapability.Get();
+            if (service == null) return;
+
+            service.ClearAllBalances();
+
+            var balance = BalanceCapability.Get(player);
+            if (balance == null) return;
+            player.PrintToChat($"Your balance is now {balance.Balance}");
+        });
+        
+        AddCommand("css_decimalbalance", "Gets your current balance", (player, info) =>
+        {
+            if (player == null) return;
+            player.PrintToChat($"Your balance is {BalanceCapabilityDecimal.Get(player)}");
+        });
+    }
+
+    public override void Unload(bool hotReload)
+    {
+    }
+}
--- a/examples/WithTranslations/WithTranslations.csproj
+++ b/examples/WithTranslations/WithTranslations.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
--- a/examples/WithVoiceOverrides/WithVoiceOverrides.csproj
+++ b/examples/WithVoiceOverrides/WithVoiceOverrides.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
        <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
--- a/libraries/GameTracking-CS2
+++ b/libraries/GameTracking-CS2
--- a/libraries/Protobufs
+++ b/libraries/Protobufs
--- a/libraries/hl2sdk-cs2
+++ b/libraries/hl2sdk-cs2
--- a/libraries/moodycamel/concurrentqueue.h
+++ b/libraries/moodycamel/concurrentqueue.h
--- a/makefiles/shared.cmake
+++ b/makefiles/shared.cmake
@@ -29,6 +29,18 @@ set(SOURCESDK_LIB ${SOURCESDK}/lib)

 add_definitions(-DMETA_IS_SOURCE2)

+if(DEFINED ENV{GITHUB_SHA_SHORT})
+    add_definitions(-DGITHUB_SHA="$ENV{GITHUB_SHA_SHORT}")
+else()
+    add_definitions(-DGITHUB_SHA="Local")
+endif()
+
+if(DEFINED ENV{BUILD_NUMBER})
+    add_definitions(-DBUILD_NUMBER="$ENV{BUILD_NUMBER}")
+else()
+    add_definitions(-DBUILD_NUMBER="0")
+endif()
+
 include_directories(
    ${SOURCESDK}
    ${SOURCESDK}/thirdparty/protobuf-3.21.8/src
@@ -43,6 +55,7 @@ include_directories(
    ${SOURCESDK}/public/entity2
    ${SOURCESDK}/public/game/server
    ${SOURCESDK}/public/entity2
+    ${SOURCESDK}/public/schemasystem
    ${METAMOD_DIR}/core
    ${METAMOD_DIR}/core/sourcehook
    libraries/dyncall/dynload
@@ -51,6 +64,7 @@ include_directories(
    libraries/tl
    libraries/funchook/include
    libraries/DynoHook/src
+    libraries/moodycamel
    libraries
 )

--- a/managed/CounterStrikeSharp.API.Tests/AdminTests.cs
+++ b/managed/CounterStrikeSharp.API.Tests/AdminTests.cs
@@ -102,9 +102,18 @@ public class AdminTests
    [Fact]
    public void ShouldAddCommandPermissionOverridesAtRuntime()
    {
-        Assert.False(AdminManager.CommandIsOverriden("runtime_command"));
-        AdminManager.AddPermissionOverride("runtime_command", "@runtime/override");
-        Assert.True(AdminManager.CommandIsOverriden("runtime_command"));
-        Assert.Equal("@runtime/override", AdminManager.GetPermissionOverrides("runtime_command").Single());
+        Assert.False(AdminManager.CommandIsOverriden("runtime_command_a"));
+        AdminManager.AddPermissionOverride("runtime_command_a", "@runtime/override");
+        Assert.True(AdminManager.CommandIsOverriden("runtime_command_a"));
+        Assert.Equal("@runtime/override", AdminManager.GetPermissionOverrides("runtime_command_a").Single());
+    }
+
+    [Fact]
+    public void ShouldAddCommandPermissionOverridesWithEmpty()
+    {
+        Assert.False(AdminManager.CommandIsOverriden("runtime_command_b"));
+        AdminManager.AddPermissionOverride("runtime_command_b");
+        Assert.True(AdminManager.CommandIsOverriden("runtime_command_b"));
+        Assert.False(AdminManager.GetPermissionOverrides("runtime_command_b").Any());
    }
 }
--- a/managed/CounterStrikeSharp.API.Tests/CounterStrikeSharp.API.Tests.csproj
+++ b/managed/CounterStrikeSharp.API.Tests/CounterStrikeSharp.API.Tests.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>

--- a/managed/CounterStrikeSharp.API/Api.cs
+++ b/managed/CounterStrikeSharp.API/Api.cs
@@ -13,4 +13,14 @@ public class Api
    {
        return Assembly.GetAssembly(typeof(BasePlugin))!.GetName().Version!.Build;
    }
+    
+    /// <summary>
+    /// Returns the assembly version of CounterStrikeSharp running on the server as a string including git commit hash
+    /// </summary>
+    /// <example>1.0.0+9d8b6be</example>
+    public static string GetVersionString()
+    {
+        return Assembly.GetAssembly(typeof(BasePlugin))!.GetCustomAttribute<AssemblyInformationalVersionAttribute>()!
+            .InformationalVersion;
+    }
 }
--- a/managed/CounterStrikeSharp.API/ApiCompat/v151.dll
+++ b/managed/CounterStrikeSharp.API/ApiCompat/v151.dll
--- a/managed/CounterStrikeSharp.API/ApiCompat/v202.dll
+++ b/managed/CounterStrikeSharp.API/ApiCompat/v202.dll
--- a/managed/CounterStrikeSharp.API/CompatibilitySuppressions.xml
+++ b/managed/CounterStrikeSharp.API/CompatibilitySuppressions.xml
--- a/managed/CounterStrikeSharp.API/Core/API.cs
+++ b/managed/CounterStrikeSharp.API/Core/API.cs
@@ -315,16 +315,6 @@ namespace CounterStrikeSharp.API.Core
 			}
 		}

-        public static float GetGameFrameTime(){
-			lock (ScriptContext.GlobalScriptContext.Lock) {
-			ScriptContext.GlobalScriptContext.Reset();
-			ScriptContext.GlobalScriptContext.SetIdentifier(0x97E331CA);
-			ScriptContext.GlobalScriptContext.Invoke();
-			ScriptContext.GlobalScriptContext.CheckErrors();
-			return (float)ScriptContext.GlobalScriptContext.GetResult(typeof(float));
-			}
-		}
-
        public static double GetEngineTime(){
 			lock (ScriptContext.GlobalScriptContext.Lock) {
 			ScriptContext.GlobalScriptContext.Reset();
@@ -512,6 +502,17 @@ namespace CounterStrikeSharp.API.Core
 			}
 		}

+        public static void QueueTaskForFrame(int tick, InputArgument callback){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(tick);
+			ScriptContext.GlobalScriptContext.Push((InputArgument)callback);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x2F92C340);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			}
+		}
+
        public static void QueueTaskForNextWorldUpdate(InputArgument callback){
 			lock (ScriptContext.GlobalScriptContext.Lock) {
 			ScriptContext.GlobalScriptContext.Reset();
@@ -749,6 +750,16 @@ namespace CounterStrikeSharp.API.Core
 			}
 		}

+        public static void FreeEvent(IntPtr gameevent){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(gameevent);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x7E8B60C2);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			}
+		}
+
        public static void FireEvent(IntPtr gameevent, bool dontbroadcast){
 			lock (ScriptContext.GlobalScriptContext.Lock) {
 			ScriptContext.GlobalScriptContext.Reset();
@@ -1085,6 +1096,16 @@ namespace CounterStrikeSharp.API.Core
 			}
 		}

+        public static void RemoveAllNetworkVectorElements(IntPtr vec){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(vec);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x67206C08);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			}
+		}
+
        public static short GetSchemaOffset(string classname, string propname){
 			lock (ScriptContext.GlobalScriptContext.Lock) {
 			ScriptContext.GlobalScriptContext.Reset();
--- a/managed/CounterStrikeSharp.API/Core/Application.cs
+++ b/managed/CounterStrikeSharp.API/Core/Application.cs
@@ -106,13 +106,13 @@ namespace CounterStrikeSharp.API.Core
        [RequiresPermissions("@css/generic")]
        private void OnCSSCommand(CCSPlayerController? caller, CommandInfo info)
        {
-            var currentVersion = Api.GetVersion();
+            var versionString = $"v{Api.GetVersion()} ({Api.GetVersionString()})";

            info.ReplyToCommand(
                "  CounterStrikeSharp was created and is maintained by Michael \"roflmuffin\" Wilson.\n" +
                "  Counter-Strike Sharp uses code borrowed from SourceMod, Source.Python, FiveM, Saul Rennison, source2gen and CS2Fixes.\n" +
                "  See ACKNOWLEDGEMENTS.md for more information.\n" +
-                "  Current API Version: " + currentVersion);
+                "  Current API Version: " + versionString);
            return;
        }

@@ -130,11 +130,11 @@ namespace CounterStrikeSharp.API.Core
                    {
                        var sb = new StringBuilder();
                        sb.AppendFormat("  [#{0}:{1}]: \"{2}\" ({3})", plugin.PluginId,
-                            plugin.State.ToString().ToUpper(), plugin.Plugin.ModuleName,
-                            plugin.Plugin.ModuleVersion);
-                        if (!string.IsNullOrEmpty(plugin.Plugin.ModuleAuthor))
+                            plugin.State.ToString().ToUpper(), plugin.Plugin?.ModuleName ?? "Unknown",
+                            plugin.Plugin?.ModuleVersion ?? "Unknown");
+                        if (!string.IsNullOrEmpty(plugin.Plugin?.ModuleAuthor))
                            sb.AppendFormat(" by {0}", plugin.Plugin.ModuleAuthor);
-                        if (!string.IsNullOrEmpty(plugin.Plugin.ModuleDescription))
+                        if (!string.IsNullOrEmpty(plugin.Plugin?.ModuleDescription))
                        {
                            sb.Append("\n");
                            sb.Append("    ");
@@ -175,6 +175,8 @@ namespace CounterStrikeSharp.API.Core
                        try
                        {
                            _pluginManager.LoadPlugin(path);
+                            plugin = _pluginContextQueryHandler.FindPluginByModulePath(path);
+                            plugin.Plugin.OnAllPluginsLoaded(false);
                        }
                        catch (Exception e)
                        {
@@ -185,6 +187,7 @@ namespace CounterStrikeSharp.API.Core
                    else
                    {
                        plugin.Load(false);
+                        plugin.Plugin.OnAllPluginsLoaded(false);
                    }

                    break;
@@ -233,6 +236,7 @@ namespace CounterStrikeSharp.API.Core

                    plugin.Unload(true);
                    plugin.Load(true);
+                    plugin.Plugin.OnAllPluginsLoaded(true);
                    break;
                }

--- a/managed/CounterStrikeSharp.API/Core/BasePlugin.cs
+++ b/managed/CounterStrikeSharp.API/Core/BasePlugin.cs
@@ -73,6 +73,10 @@ namespace CounterStrikeSharp.API.Core
        public virtual void Unload(bool hotReload)
        {
        }
+        
+        public virtual void OnAllPluginsLoaded(bool hotReload)
+        {
+        }

        public class CallbackSubscriber : IDisposable
        {
@@ -118,9 +122,6 @@ namespace CounterStrikeSharp.API.Core
        public readonly Dictionary<Delegate, CallbackSubscriber> CommandListeners =
            new Dictionary<Delegate, CallbackSubscriber>();

-        public readonly Dictionary<Delegate, CallbackSubscriber> ConvarChangeHandlers =
-            new Dictionary<Delegate, CallbackSubscriber>();
-
        public readonly Dictionary<Delegate, CallbackSubscriber> Listeners =
            new Dictionary<Delegate, CallbackSubscriber>();

@@ -155,7 +156,23 @@ namespace CounterStrikeSharp.API.Core
            var name = typeof(T).GetCustomAttribute<EventNameAttribute>()?.Name;
            RegisterEventHandlerInternal(name, handler, hookMode == HookMode.Post);
        }
+        
+        /// <summary>
+        /// De-registers a game event handler.
+        /// </summary>
+        /// <inheritdoc cref="RegisterEventHandler{T}"/>
+        public void DeregisterEventHandler<T>(GameEventHandler<T> handler, HookMode hookMode = HookMode.Post) where T : GameEvent
+        {
+            var name = typeof(T).GetCustomAttribute<EventNameAttribute>()!.Name;
+            
+            if (!Handlers.TryGetValue(handler, out var subscriber)) return;

+            NativeAPI.UnhookEvent(name, subscriber.GetInputArgument(), hookMode == HookMode.Post);
+            FunctionReference.Remove(subscriber.GetReferenceIdentifier());
+            Handlers.Remove(handler);
+        }
+
+        [Obsolete("Use the generic version of this method")]
        public void DeregisterEventHandler(string name, Delegate handler, bool post)
        {
            if (!Handlers.TryGetValue(handler, out var subscriber)) return;
@@ -183,6 +200,12 @@ namespace CounterStrikeSharp.API.Core
            CommandManager.RegisterCommand(definition);
        }

+        /// <summary>
+        /// Adds a command listener which will be called before or after the command is executed on the server by a player.
+        /// </summary>
+        /// <param name="name">Name of the command, e.g. `jointeam`</param>
+        /// <param name="handler">Code to run when command is executed. Return <see cref="HookResult.Handled"/> or higher to prevent command execution.</param>
+        /// <param name="mode">Whether to hook before or after the command is executed.</param>
        public void AddCommandListener(string? name, CommandInfo.CommandListenerCallback handler, HookMode mode = HookMode.Pre)
        {
            var wrappedHandler = new Func<int, IntPtr, HookResult>((i, ptr) =>
@@ -198,6 +221,11 @@ namespace CounterStrikeSharp.API.Core
            CommandListeners[handler] = subscriber;
        }

+        /// <summary>
+        /// Removes a server command.
+        /// </summary>
+        /// <param name="name">The name of the command.</param>
+        /// <param name="handler">The callback function to be invoked when the command is executed.</param>
        public void RemoveCommand(string name, CommandInfo.CommandCallback handler)
        {
            if (CommandHandlers.ContainsKey(handler))
@@ -211,6 +239,10 @@ namespace CounterStrikeSharp.API.Core
            }
        }

+        /// <summary>
+        /// Remove a command listener.
+        /// </summary>
+        /// <inheritdoc cref="AddCommandListener"/>
        public void RemoveCommandListener(string name, CommandInfo.CommandListenerCallback handler, HookMode mode)
        {
            if (CommandListeners.ContainsKey(handler))
@@ -224,39 +256,24 @@ namespace CounterStrikeSharp.API.Core
            }
        }

-        /*
-
-        public void HookConVarChange(ConVar convar, ConVar.ConVarChangedCallback handler)
-        {
-            var wrappedHandler = new Action<IntPtr, string, string>((ptr, oldVal, newVal) =>
-            {
-                handler?.Invoke(new ConVar(ptr), oldVal, newVal);
-            });
-
-            var subscriber = new CallbackSubscriber(convar, handler, wrappedHandler);
-            NativeAPI.HookConvarChange(convar.Handle, subscriber.GetInputArgument());
-            ConvarChangeHandlers[handler] = subscriber;
-        }
-
-        public void UnhookConVarChange(ConVar convar, ConVar.ConVarChangedCallback handler)
-        {
-            if (ConvarChangeHandlers.ContainsKey(handler))
-            {
-                var subscriber = ConvarChangeHandlers[handler];
-
-                NativeAPI.UnhookConvarChange(convar.Handle, subscriber.GetInputArgument());
-                FunctionReference.Remove(subscriber.GetReferenceIdentifier());
-                CommandHandlers.Remove(handler);
-            }
-        }*/
-
-        // Adds global listener, e.g. OnTick, OnClientConnect
+        /// <summary>
+        /// Registers a global listener, e.g. <see cref="Listeners.OnTick"/>, <see cref="Listeners.OnClientConnect"/>.
+        /// </summary>
+        /// <param name="handler"></param>
+        /// <typeparam name="T">Listener delegate type</typeparam>
+        /// <exception cref="ArgumentException">Invalid listener <see cref="T"/> provided</exception>
+        /// <example>
+        /// <code lang="C#">
+        /// RegisterListener&lt;Listeners.OnTick&gt;(OnTick);
+        /// </code>
+        /// </example>
        public void RegisterListener<T>(T handler) where T : Delegate
        {
            var listenerName = typeof(T).GetCustomAttribute<ListenerNameAttribute>()?.Name;
            if (string.IsNullOrEmpty(listenerName))
            {
-                throw new Exception("Listener of type T is invalid and does not have a name attribute");
+                throw new ArgumentException("Listener of type T is invalid and does not have a name attribute",
+                    nameof(T));
            }

            var parameterTypes = typeof(T).GetMethod("Invoke").GetParameters().Select(p => p.ParameterType).ToArray();
@@ -287,6 +304,34 @@ namespace CounterStrikeSharp.API.Core
            Listeners[handler] = subscriber;
        }

+        /// <summary>
+        /// Removes a global listener.
+        /// </summary>
+        /// <param name="handler"></param>
+        /// <typeparam name="T"></typeparam>
+        /// <exception cref="ArgumentException">Invalid listener <see cref="T"/> provided</exception>
+        public void RemoveListener<T>(T handler) where T : Delegate
+        {
+            var listenerName = typeof(T).GetCustomAttribute<ListenerNameAttribute>()?.Name;
+            if (string.IsNullOrEmpty(listenerName))
+            {
+                throw new ArgumentException("Listener of type T is invalid and does not have a name attribute",
+                    nameof(T));
+            }
+            
+            if (!Listeners.TryGetValue(handler, out var subscriber)) return;
+            
+            NativeAPI.RemoveListener(listenerName, subscriber.GetInputArgument());
+            FunctionReference.Remove(subscriber.GetReferenceIdentifier());
+            Listeners.Remove(handler);
+        }
+
+        /// <summary>
+        /// Removes a global listener.
+        /// </summary>
+        /// <param name="name"></param>
+        /// <param name="handler"></param>
+        [Obsolete("Use the generic version of this method")]
        public void RemoveListener(string name, Delegate handler)
        {
            if (!Listeners.TryGetValue(handler, out var subscriber)) return;
@@ -296,6 +341,14 @@ namespace CounterStrikeSharp.API.Core
            Listeners.Remove(handler);
        }

+        /// <summary>
+        /// Adds a timer that will call the given callback after the specified amount of seconds.
+        /// By default will only run once unless the <see cref="TimerFlags.REPEAT"/> flag is set.
+        /// </summary>
+        /// <param name="interval">Interval/Delay in seconds</param>
+        /// <param name="callback">Code to run when timer elapses</param>
+        /// <param name="flags">Controls if the timer is a one-off, repeat or stops on map change etc.</param>
+        /// <returns>An instance of the <see cref="Timer"/></returns>
        public Timer AddTimer(float interval, Action callback, TimerFlags? flags = null)
        {
            var timer = new Timer(interval, callback, flags ?? 0);
@@ -303,7 +356,11 @@ namespace CounterStrikeSharp.API.Core
            return timer;
        }

-
+        /// <summary>
+        /// Registers all attribute handlers on the given instance.
+        /// Can be used to register event handlers, console commands, entity outputs etc. from classes that are not derived from `BasePlugin`.
+        /// </summary>
+        /// <param name="instance"></param>
        public void RegisterAllAttributes(object instance)
        {
            this.RegisterAttributeHandlers(instance);
@@ -338,7 +395,7 @@ namespace CounterStrikeSharp.API.Core
        }

        /// <summary>
-        /// Registers all game event handlers that are decorated with the `[GameEventHandler]` attribute.
+        /// Registers all game event handlers that are decorated with the <see cref="GameEventHandlerAttribute"/> attribute.
        /// </summary>
        /// <param name="instance">The instance of the object where the event handlers are defined.</param>
        public void RegisterAttributeHandlers(object instance)
@@ -368,6 +425,10 @@ namespace CounterStrikeSharp.API.Core
            }
        }

+        /// <summary>
+        /// Registers all console command handlers that are decorated with the <see cref="ConsoleCommandAttribute"/> attribute.
+        /// </summary>
+        /// <param name="instance">The instance of the object where the console command handlers are defined.</param>
        public void RegisterConsoleCommandAttributeHandlers(object instance)
        {
            var eventHandlers = instance.GetType()
@@ -395,6 +456,10 @@ namespace CounterStrikeSharp.API.Core
            }
        }

+        /// <summary>
+        /// Registers all entity output handlers that are decorated with the <see cref="EntityOutputHookAttribute"/> attribute.
+        /// </summary>
+        /// <param name="instance">The instance of the object where entity output hook handlers are defined.</param>
        public void RegisterEntityOutputAttributeHandlers(object instance)
        {
            var handlers = instance.GetType()
@@ -449,6 +514,12 @@ namespace CounterStrikeSharp.API.Core
            RegisterFakeConVars(instance.GetType(), instance);
        }

+        /// <summary>
+        /// Hooks an <a href="https://developer.valvesoftware.com/wiki/Inputs_and_Outputs">entity output</a>.
+        /// </summary>
+        /// <param name="classname">Classname to hook, or `*` for wildcard</param>
+        /// <param name="outputName">Output name to hook, or `*` for wildcard</param>
+        /// <param name="handler">Handler to call</param>
        public void HookEntityOutput(string classname, string outputName, EntityIO.EntityOutputHandler handler, HookMode mode = HookMode.Pre)
        {
            var subscriber = new CallbackSubscriber(handler, handler,
@@ -458,6 +529,10 @@ namespace CounterStrikeSharp.API.Core
            EntityOutputHooks[handler] = subscriber;
        }

+        /// <summary>
+        /// Unhooks an entity output.
+        /// </summary>
+        /// <inheritdoc cref="HookEntityOutput"/>
        public void UnhookEntityOutput(string classname, string outputName, EntityIO.EntityOutputHandler handler, HookMode mode = HookMode.Pre)
        {
            if (!EntityOutputHooks.TryGetValue(handler, out var subscriber)) return;
@@ -467,6 +542,12 @@ namespace CounterStrikeSharp.API.Core
            EntityOutputHooks.Remove(handler);
        }

+        /// <summary>
+        /// Hooks an entity output for a single entity instance.
+        /// </summary>
+        /// <param name="entityInstance">Entity instance to hook</param>
+        /// <param name="outputName">Output name to hook, or `*` for wildcard</param>
+        /// <param name="handler">Handler to call</param>
        public void HookSingleEntityOutput(CEntityInstance entityInstance, string outputName, EntityIO.EntityOutputHandler handler)
        {
            // since we wrap around the plugin handler we need to do this to ensure that the plugin callback is only called
@@ -490,6 +571,10 @@ namespace CounterStrikeSharp.API.Core
            EntitySingleOutputHooks[handler] = new EntityIO.EntityOutputCallback(entityInstance.DesignerName, outputName, internalHandler);
        }

+        /// <summary>
+        /// Unhooks an entity output for a single entity instance.
+        /// </summary>
+        /// <inheritdoc cref="HookSingleEntityOutput"/>
        public void UnhookSingleEntityOutput(CEntityInstance entityInstance, string outputName, EntityIO.EntityOutputHandler handler)
        {
            UnhookSingleEntityOutputInternal(entityInstance.DesignerName, outputName, handler);
@@ -528,10 +613,6 @@ namespace CounterStrikeSharp.API.Core
                subscriber.Dispose();
            }

-            foreach (var kv in ConvarChangeHandlers)
-            {
-            }
-
            foreach (var subscriber in Listeners.Values)
            {
                subscriber.Dispose();
--- a/managed/CounterStrikeSharp.API/Core/Capabilities/Capabilities.cs
+++ b/managed/CounterStrikeSharp.API/Core/Capabilities/Capabilities.cs
@@ -0,0 +1,25 @@
+namespace CounterStrikeSharp.API.Core.Capabilities;
+
+public static class Capabilities
+{
+    public static void RegisterPluginCapability<T>(PluginCapability<T> capability, Func<T> supplier)
+    {
+        if (!PluginCapability<T>.Providers.ContainsKey(capability.Name))
+        {
+            PluginCapability<T>.Providers.Add(capability.Name, new());
+        }
+
+        PluginCapability<T>.Providers[capability.Name].Add(supplier);
+    }
+
+    public static void RegisterPlayerCapability<T>(PlayerCapability<T> capability,
+        Func<CCSPlayerController, T> supplier)
+    {
+        if (!PlayerCapability<T>.Providers.ContainsKey(capability.Name))
+        {
+            PlayerCapability<T>.Providers.Add(capability.Name, new());
+        }
+
+        PlayerCapability<T>.Providers[capability.Name].Add(supplier);
+    }
+}
--- a/managed/CounterStrikeSharp.API/Core/Capabilities/PlayerCapability.cs
+++ b/managed/CounterStrikeSharp.API/Core/Capabilities/PlayerCapability.cs
@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+
+namespace CounterStrikeSharp.API.Core.Capabilities;
+
+public sealed class PlayerCapability<T>
+{
+    public string Name { get; }
+    internal static readonly Dictionary<string, List<Func<CCSPlayerController, T>>> Providers = new();
+
+    public PlayerCapability(string name)
+    {
+        Name = name;
+    }
+
+    public T? Get(CCSPlayerController entity)
+    {
+        foreach (var provider in Providers[Name])
+        {
+            return provider(entity);
+        }
+
+        return default;
+    }
+}
--- a/managed/CounterStrikeSharp.API/Core/Capabilities/PluginCapability.cs
+++ b/managed/CounterStrikeSharp.API/Core/Capabilities/PluginCapability.cs
@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+
+namespace CounterStrikeSharp.API.Core.Capabilities;
+
+public sealed class PluginCapability<T>
+{
+    public string Name { get; }
+    internal static readonly Dictionary<string, List<Func<T>>> Providers = new();
+
+    public PluginCapability(string name)
+    {
+        Name = name;
+    }
+
+    public T? Get()
+    {
+        foreach (var provider in Providers[Name])
+        {
+            return provider();
+        }
+
+        return default;
+    }
+}
--- a/managed/CounterStrikeSharp.API/Core/Commands/CommandManager.cs
+++ b/managed/CounterStrikeSharp.API/Core/Commands/CommandManager.cs
@@ -106,6 +106,11 @@ public class CommandManager : ICommandManager

                    foreach (var attr in permissionsToCheck)
                    {
+                        if (attr.Permissions.Count == 0)
+                        {
+                            continue;
+                        }
+
                        attr.Command = name;
                        if (!attr.CanExecuteCommand(caller))
                        {
--- a/managed/CounterStrikeSharp.API/Core/CoreConfig.cs
+++ b/managed/CounterStrikeSharp.API/Core/CoreConfig.cs
@@ -50,6 +50,9 @@ namespace CounterStrikeSharp.API.Core
        [JsonPropertyName("PluginHotReloadEnabled")]
        public bool PluginHotReloadEnabled { get; set; } = true;
        
+        [JsonPropertyName("PluginAutoLoadEnabled")]
+        public bool PluginAutoLoadEnabled { get; set; } = true;
+        
        [JsonPropertyName("ServerLanguage")]
        public string ServerLanguage { get; set; } = "en";
    }
@@ -95,7 +98,13 @@ namespace CounterStrikeSharp.API.Core
        /// </summary>
        public static bool PluginHotReloadEnabled => _coreConfig.PluginHotReloadEnabled;
        
+        /// <summary>
+        /// When enabled, plugins are automatically loaded from the plugins directory on server start.
+        /// </summary>
+        public static bool PluginAutoLoadEnabled => _coreConfig.PluginAutoLoadEnabled;
+        
        public static string ServerLanguage => _coreConfig.ServerLanguage;
+        
    }

    public partial class CoreConfig : IStartupService
--- a/managed/CounterStrikeSharp.API/Core/FunctionReference.cs
+++ b/managed/CounterStrikeSharp.API/Core/FunctionReference.cs
@@ -14,10 +14,9 @@
 *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
 */

-using System;
-using System.Collections.Generic;
-using System.Linq;
+using System.Collections.Concurrent;
 using System.Runtime.InteropServices;
+using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;

 namespace CounterStrikeSharp.API.Core
@@ -29,140 +28,149 @@ namespace CounterStrikeSharp.API.Core
    {
        /// <summary>Delegate will be removed after the first invocation.</summary> 
        SingleUse,
-        /// <summary>Delegate will remain in memory for the lifetime of the application.</summary>
+
+        /// <summary>Delegate will remain in memory for the lifetime of the application (or until <see cref="FunctionReference.Remove"/> is called).</summary>
        Permanent
    }
-    
+
+    /// <summary>
+    /// Represents a reference to a function that can be called from native code.
+    /// </summary>
    public class FunctionReference
    {
-        private readonly Delegate m_method;
-        
-        public FunctionLifetime Lifetime { get; set; } = FunctionLifetime.Permanent;
-
        public unsafe delegate void CallbackDelegate(fxScriptContext* context);
-        private CallbackDelegate s_callback;

-        private FunctionReference(Delegate method)
+        private static readonly ConcurrentDictionary<int, FunctionReference> IdToFunctionReferencesMap = new();
+        private static readonly ConcurrentDictionary<Delegate, FunctionReference> TargetMethodToFunctionReferencesMap = new();
+
+        private static readonly object ReferenceCounterLock = new();
+        private static int _referenceCounter;
+
+        private readonly Delegate _targetMethod;
+        private readonly CallbackDelegate _nativeCallback;
+
+        private readonly TaskCompletionSource _taskCompletionSource = new();
+
+        private FunctionReference(Delegate method, FunctionLifetime lifetime)
        {
-            m_method = method;
-
-            unsafe
-            {
-                var dg = new CallbackDelegate((fxScriptContext* context) =>
-                {
-                    try
-                    {
-                        var scriptContext = new ScriptContext(context);
-
-                        if (method.Method.GetParameters().FirstOrDefault()?.ParameterType == typeof(ScriptContext))
-                        {
-                            var returnO = m_method.DynamicInvoke(scriptContext);
-                            if (returnO != null)
-                            {
-                                scriptContext.SetResult(returnO, context);
-                            }
-
-                            return;
-                        }
-
-                        var paramsList = method.Method.GetParameters().Select((x, i) =>
-                        {
-                            var param = method.Method.GetParameters()[i];
-                            object obj = null;
-                            if (typeof(NativeObject).IsAssignableFrom(param.ParameterType))
-                            {
-                                obj = Activator.CreateInstance(param.ParameterType,
-                                    new[] { scriptContext.GetArgument(typeof(IntPtr), i) });
-                            }
-                            else
-                            {
-                                obj = scriptContext.GetArgument(param.ParameterType, i);
-                            }
-
-                            return obj;
-                        }).ToArray();
-
-                        var returnObj = m_method.DynamicInvoke(paramsList);
-
-                        if (returnObj != null)
-                        {
-                            scriptContext.SetResult(returnObj, context);
-                        }
-                    }
-                    catch (Exception e)
-                    {
-                        Application.Instance.Logger.LogError(e, "Error invoking callback");
-                    }
-                    finally
-                    {
-                        if (Lifetime == FunctionLifetime.SingleUse)
-                        {
-                            Remove(Identifier);
-                            if (references.ContainsKey(m_method))
-                                references.Remove(m_method);
-                        }
-                    }
-                });
-                s_callback = dg;
-            }
-
+            Lifetime = lifetime;
+            _targetMethod = method;
+            _nativeCallback = CreateWrappedCallback();
        }
+        
+        /// <summary>
+        /// <inheritdoc cref="FunctionLifetime"/>
+        /// </summary>
+        public FunctionLifetime Lifetime { get; }
+
+        /// <summary>
+        /// For <see cref="FunctionLifetime.SingleUse"/> function references, this task will complete when
+        /// the function has finished invoking.
+        /// </summary>
+        public Task CompletionTask => _taskCompletionSource.Task;

        public int Identifier { get; private set; }

-        public static FunctionReference Create(Delegate method)
+        private unsafe CallbackDelegate CreateWrappedCallback()
        {
-            if (references.ContainsKey(method))
+            return context =>
            {
-                return references[method];
+                try
+                {
+                    var scriptContext = new ScriptContext(context);
+
+                    // Allow for manual handling of the script context
+                    if (_targetMethod.Method.GetParameters().FirstOrDefault()?.ParameterType == typeof(ScriptContext))
+                    {
+                        var returnValue = _targetMethod.DynamicInvoke(scriptContext);
+                        if (returnValue != null)
+                        {
+                            scriptContext.SetResult(returnValue, context);
+                        }
+
+                        return;
+                    }
+
+                    var parameterList = _targetMethod.Method.GetParameters().Select((_, i) =>
+                    {
+                        var parameter = _targetMethod.Method.GetParameters()[i];
+                        return scriptContext.GetArgument(parameter.ParameterType, i);
+                    }).ToArray();
+
+                    var returnObj = _targetMethod.DynamicInvoke(parameterList);
+
+                    if (returnObj != null)
+                    {
+                        scriptContext.SetResult(returnObj, context);
+                    }
+                }
+                catch (Exception e)
+                {
+                    Application.Instance.Logger.LogError(e, "Error invoking callback");
+                }
+                finally
+                {
+                    if (Lifetime == FunctionLifetime.SingleUse)
+                    {
+                        RemoveSelf();
+                    }
+
+                    _taskCompletionSource.TrySetResult();
+                }
+            };
+        }
+
+        public static FunctionReference Create(Delegate method, FunctionLifetime lifetime = FunctionLifetime.Permanent)
+        {
+            // We always want to create a new reference if the lifetime is single use.
+            if (lifetime == FunctionLifetime.Permanent && TargetMethodToFunctionReferencesMap.TryGetValue(method, out var existingReference))
+            {
+                return existingReference;
            }

-            var reference = new FunctionReference(method);
+            var reference = new FunctionReference(method, lifetime);
            var referenceId = Register(reference);

            reference.Identifier = referenceId;
-            
+
            return reference;
        }

-        private static Dictionary<int, FunctionReference> ms_references = new Dictionary<int, FunctionReference>();
-        private static int ms_referenceId;
-
-        private static Dictionary<Delegate, FunctionReference> references =
-            new Dictionary<Delegate, FunctionReference>();

        private static int Register(FunctionReference reference)
        {
-            var thisRefId = ms_referenceId;
-            ms_references[thisRefId] = reference;
-            references[reference.m_method] = reference;
-
-            unchecked { ms_referenceId++; }
-
-            return thisRefId;
-        }
-
-        public static FunctionReference Get(int reference)
-        {
-            if (ms_references.ContainsKey(reference))
+            lock (ReferenceCounterLock)
            {
-                return ms_references[reference];
-            }
+                var thisRefId = _referenceCounter;
+                IdToFunctionReferencesMap[thisRefId] = reference;
+                TargetMethodToFunctionReferencesMap[reference._targetMethod] = reference;

-            return null;
+                unchecked
+                {
+                    _referenceCounter++;
+                }
+
+                return thisRefId;
+            }
        }
-        
-        public IntPtr GetFunctionPointer()
+
+        public IntPtr GetFunctionPointer() => Marshal.GetFunctionPointerForDelegate(_nativeCallback);
+
+        private void RemoveSelf()
        {
-            IntPtr cb = Marshal.GetFunctionPointerForDelegate(s_callback);
-            return cb;
+            Remove(Identifier);
        }

        public static void Remove(int reference)
        {
-            if (ms_references.TryGetValue(reference, out var funcRef))
+            if (IdToFunctionReferencesMap.TryGetValue(reference, out var functionReference))
            {
-                ms_references.Remove(reference);
+                if (TargetMethodToFunctionReferencesMap.ContainsKey(functionReference._targetMethod))
+                {
+                    TargetMethodToFunctionReferencesMap.Remove(functionReference._targetMethod, out _);
+                }
+
+                IdToFunctionReferencesMap.Remove(reference, out _);

                Application.Instance.Logger.LogDebug("Removing function/callback reference: {Reference}", reference);
            }
--- a/managed/CounterStrikeSharp.API/Core/GameEvents.g.cs
+++ b/managed/CounterStrikeSharp.API/Core/GameEvents.g.cs
@@ -7119,6 +7119,15 @@ namespace CounterStrikeSharp.API.Core
                }
            }

+            [EventName("warmup_end")]
+            public class EventWarmupEnd : GameEvent
+            {
+                public EventWarmupEnd(IntPtr pointer) : base(pointer){}
+                public EventWarmupEnd(bool force) : base("warmup_end", force){}
+
+                
+            }
+
            [EventName("weapon_fire")]
            public class EventWeaponFire : GameEvent
            {
--- a/managed/CounterStrikeSharp.API/Core/Hosting/IScriptHostConfiguration.cs
+++ b/managed/CounterStrikeSharp.API/Core/Hosting/IScriptHostConfiguration.cs
@@ -18,6 +18,12 @@ public interface IScriptHostConfiguration
    /// </summary>
    string PluginPath { get; }
    
+    /// <summary>
+    /// Gets the absolute path to the directory that contains CounterStrikeSharp plugin shared APIS.
+    /// e.g. /game/csgo/addons/counterstrikesharp/shared
+    /// </summary>
+    string SharedPath { get; }
+    
    /// <summary>
    /// Gets the absolute path to the directory that contains CounterStrikeSharp configs.
    /// e.g. /game/csgo/addons/counterstrikesharp/configs
--- a/managed/CounterStrikeSharp.API/Core/Hosting/ScriptHostConfiguration.cs
+++ b/managed/CounterStrikeSharp.API/Core/Hosting/ScriptHostConfiguration.cs
@@ -7,12 +7,14 @@ internal sealed class ScriptHostConfiguration : IScriptHostConfiguration
 {
    public string RootPath { get; }
    public string PluginPath { get; }
+    public string SharedPath { get; }
    public string ConfigsPath { get; }
    public string GameDataPath { get; }

    public ScriptHostConfiguration(IHostEnvironment hostEnvironment)
    {
        RootPath = Path.Join(new[] { hostEnvironment.ContentRootPath });
+        SharedPath = Path.Join(new[] { hostEnvironment.ContentRootPath, "shared" });
        PluginPath = Path.Join(new[] { hostEnvironment.ContentRootPath, "plugins" });
        ConfigsPath = Path.Join(new[] { hostEnvironment.ContentRootPath, "configs" });
        GameDataPath = Path.Join(new[] { hostEnvironment.ContentRootPath, "gamedata" });
--- a/managed/CounterStrikeSharp.API/Core/IPlugin.cs
+++ b/managed/CounterStrikeSharp.API/Core/IPlugin.cs
@@ -28,17 +28,23 @@ namespace CounterStrikeSharp.API.Core
    public interface IPlugin : IDisposable
    {
        /// <summary>
-        /// Name of the plugin.
+        /// Name of the plugin as it will appear in the plugin list.
        /// </summary>
        string ModuleName { get; }

        /// <summary>
-        /// Module version.
+        /// Module version as it will appear in the plugin list.
        /// </summary>
        string ModuleVersion { get; }

+        /// <summary>
+        /// Author of the plugin as it will appear in the plugin list.
+        /// </summary>
        string ModuleAuthor { get; }

+        /// <summary>
+        /// Brief description of the plugin as it will appear in the plugin list.
+        /// </summary>
        string ModuleDescription { get; }

        /// <summary>
@@ -53,12 +59,23 @@ namespace CounterStrikeSharp.API.Core
        /// </summary>
        void Unload(bool hotReload);

+        /// <summary>
+        /// Will be called by CounterStrikeSharp after all plugins have been loaded.
+        /// This will also be called for convenience after a reload or a late l oad, so that you don't have to handle
+        /// re-wiring everything.
+        /// </summary>
+        /// <param name="hotReload"></param>
+        void OnAllPluginsLoaded(bool hotReload);
+
+        /// <summary>
+        /// The path to the plugin's DLL file.
+        /// </summary>
        string ModulePath { get; internal set; }

        ILogger Logger { get; set; }
-        
+
        IStringLocalizer Localizer { get; set; }
-        
+
        ICommandManager CommandManager { get; set; }

        void RegisterAllAttributes(object instance);
--- a/managed/CounterStrikeSharp.API/Core/Listeners.g.cs
+++ b/managed/CounterStrikeSharp.API/Core/Listeners.g.cs
@@ -2,6 +2,7 @@
 using System;
 using CounterStrikeSharp.API.Core.Attributes;
 using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Utils;

 namespace CounterStrikeSharp.API.Core
 {
@@ -154,5 +155,13 @@ namespace CounterStrikeSharp.API.Core
        /// <param name="simulating"><see langword="true"/> if simulating, <see langword="false"/> otherwise</param>
        [ListenerName("OnServerPreWorldUpdate")]
        public delegate void OnServerPreWorldUpdate(bool simulating);
+
+
+        /// <summary>
+        /// Called when the server precaching resources (only when initial startup / changing map).
+        /// </summary>
+        /// <param name="manifest">Resource Manifest</param>
+        [ListenerName("OnServerPrecacheResources")]
+        public delegate void OnServerPrecacheResources(ResourceManifest manifest);
    }
-}
+}
--- a/managed/CounterStrikeSharp.API/Core/Model/CBaseEntity.cs
+++ b/managed/CounterStrikeSharp.API/Core/Model/CBaseEntity.cs
@@ -8,10 +8,14 @@ namespace CounterStrikeSharp.API.Core;
 public partial class CBaseEntity
 {
    /// <exception cref="InvalidOperationException">Entity is not valid</exception>
-    public void Teleport(Vector position, QAngle angles, Vector velocity)
+    public void Teleport(Vector? position = null, QAngle? angles = null, Vector? velocity = null)
    {
        Guard.IsValidEntity(this);

+        position ??= AbsOrigin!;
+        angles ??= AbsRotation!;
+        velocity ??= AbsVelocity;
+        
        VirtualFunction.CreateVoid<IntPtr, IntPtr, IntPtr, IntPtr>(Handle, GameData.GetOffset("CBaseEntity_Teleport"))(
            Handle, position.Handle, angles.Handle, velocity.Handle);
    }
@@ -39,6 +43,6 @@ public partial class CBaseEntity
    {
        Guard.IsValidEntity(this);

-        return (T) Activator.CreateInstance(typeof(T), Marshal.ReadIntPtr(SubclassID.Handle + 4));
+        return (T)Activator.CreateInstance(typeof(T), Marshal.ReadIntPtr(SubclassID.Handle + 4));
    }
 }
--- a/managed/CounterStrikeSharp.API/Core/Model/CCSGameRules.cs
+++ b/managed/CounterStrikeSharp.API/Core/Model/CCSGameRules.cs
@@ -26,6 +26,6 @@ public partial class CCSGameRules
    /// </summary>
    public void TerminateRound(float delay, RoundEndReason roundEndReason)
    {
-        VirtualFunctions.TerminateRound(Handle, roundEndReason, delay);
+        VirtualFunctions.TerminateRound(Handle, roundEndReason, delay, 0, 0);
    }
 }
--- a/managed/CounterStrikeSharp.API/Core/Model/CCSPlayerController.cs
+++ b/managed/CounterStrikeSharp.API/Core/Model/CCSPlayerController.cs
@@ -75,6 +75,7 @@ public partial class CCSPlayerController
            Userid = this
        };
        @event.FireEventToClient(this);
+        @event.Free();
    }

    /// <summary>
--- a/managed/CounterStrikeSharp.API/Core/Model/NetworkedVector.cs
+++ b/managed/CounterStrikeSharp.API/Core/Model/NetworkedVector.cs
@@ -33,6 +33,11 @@ public partial class NetworkedVector<T> : NativeObject, IReadOnlyCollection<T>
        }
    }

+    public void RemoveAll()
+    {
+        NativeAPI.RemoveAllNetworkVectorElements(Handle);
+    }
+
    public IEnumerator<T> GetEnumerator()
    {
        for (int i = 0; i < Count; i++)
--- a/managed/CounterStrikeSharp.API/Core/Plugin/Host/PluginManager.cs
+++ b/managed/CounterStrikeSharp.API/Core/Plugin/Host/PluginManager.cs
@@ -1,7 +1,11 @@
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
+using System.Runtime.Loader;
+using CounterStrikeSharp.API.Core.Capabilities;
 using CounterStrikeSharp.API.Core.Commands;
 using CounterStrikeSharp.API.Core.Hosting;
+using McMaster.NETCore.Plugins;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;

@@ -14,8 +18,11 @@ public class PluginManager : IPluginManager
    private readonly ICommandManager _commandManager;
    private readonly IServiceProvider _serviceProvider;
    private readonly ILogger<PluginManager> _logger;
+    private readonly Dictionary<string, Assembly> _sharedAssemblies = new();
+    private bool _loadedSharedLibs = false;

-    public PluginManager(IScriptHostConfiguration scriptHostConfiguration, ICommandManager commandManager, ILogger<PluginManager> logger, IServiceProvider serviceProvider, IServiceScopeFactory serviceScopeFactory)
+    public PluginManager(IScriptHostConfiguration scriptHostConfiguration, ICommandManager commandManager,
+        ILogger<PluginManager> logger, IServiceProvider serviceProvider, IServiceScopeFactory serviceScopeFactory)
    {
        _scriptHostConfiguration = scriptHostConfiguration;
        _commandManager = commandManager;
@@ -23,6 +30,36 @@ public class PluginManager : IPluginManager
        _serviceProvider = serviceProvider;
    }

+    private void LoadLibrary(string path)
+    {
+        var loader = PluginLoader.CreateFromAssemblyFile(path, new[] { typeof(IPlugin), typeof(PluginCapability<>), typeof(PlayerCapability<>) },
+            config => { config.PreferSharedTypes = true; });
+        var assembly = loader.LoadDefaultAssembly();
+
+        _sharedAssemblies[assembly.GetName().FullName] = assembly;
+    }
+
+    private void LoadSharedLibraries()
+    {
+        var sharedDirectory = Directory.GetDirectories(_scriptHostConfiguration.SharedPath);
+        var sharedAssemblyPaths = sharedDirectory
+            .Select(dir => Path.Combine(dir, Path.GetFileName(dir) + ".dll"))
+            .Where(File.Exists)
+            .ToArray();
+        
+        foreach (var sharedAssemblyPath in sharedAssemblyPaths)
+        {
+            try
+            {
+                LoadLibrary(sharedAssemblyPath);
+            }
+            catch (Exception e)
+            {
+                _logger.LogError(e, "Failed to load shared assembly from {Path}", sharedAssemblyPath);
+            }
+        }
+    }
+
    public void Load()
    {
        var pluginDirectories = Directory.GetDirectories(_scriptHostConfiguration.PluginPath);
@@ -31,15 +68,46 @@ public class PluginManager : IPluginManager
            .Where(File.Exists)
            .ToArray();

-        foreach (var path in pluginAssemblyPaths)
+        AssemblyLoadContext.Default.Resolving += (context, name) =>
+        {
+            if (!_loadedSharedLibs)
+            {
+                LoadSharedLibraries();
+                _loadedSharedLibs = true;
+            }
+
+            if (!_sharedAssemblies.TryGetValue(name.FullName, out var assembly))
+            {
+                return null;
+            }
+
+            return assembly;
+        };
+
+        if (CoreConfig.PluginAutoLoadEnabled)
+        {
+            foreach (var path in pluginAssemblyPaths)
+            {
+                try
+                {
+                    LoadPlugin(path);
+                }
+                catch (Exception e)
+                {
+                    _logger.LogError(e, "Failed to load plugin from {Path}", path);
+                }
+            }
+        }
+        
+        foreach (var plugin in _loadedPluginContexts)
        {
            try
            {
-                LoadPlugin(path);
+                plugin.Plugin?.OnAllPluginsLoaded(false);
            }
            catch (Exception e)
            {
-                _logger.LogError(e, "Failed to load plugin from {Path}", path);
+                _logger.LogError(e, "OnAllPluginsLoaded failed");
            }
        }
    }
@@ -51,7 +119,8 @@ public class PluginManager : IPluginManager

    public void LoadPlugin(string path)
    {
-        var plugin = new PluginContext(_serviceProvider, _commandManager, _scriptHostConfiguration, path, _loadedPluginContexts.Select(x => x.PluginId).DefaultIfEmpty(0).Max() + 1);
+        var plugin = new PluginContext(_serviceProvider, _commandManager, _scriptHostConfiguration, path,
+            _loadedPluginContexts.Select(x => x.PluginId).DefaultIfEmpty(0).Max() + 1);
        _loadedPluginContexts.Add(plugin);
        plugin.Load();
    }
--- a/managed/CounterStrikeSharp.API/Core/Plugin/PluginContext.cs
+++ b/managed/CounterStrikeSharp.API/Core/Plugin/PluginContext.cs
@@ -18,6 +18,7 @@ using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
 using CounterStrikeSharp.API.Core.Attributes;
+using CounterStrikeSharp.API.Core.Capabilities;
 using CounterStrikeSharp.API.Core.Commands;
 using CounterStrikeSharp.API.Core.Hosting;
 using CounterStrikeSharp.API.Core.Logging;
@@ -64,7 +65,7 @@ namespace CounterStrikeSharp.API.Core.Plugin
            _hostConfiguration = hostConfiguration;
            _path = path;
            PluginId = id;
-
+            
            Loader = PluginLoader.CreateFromAssemblyFile(path,
                new[]
                {
@@ -76,7 +77,7 @@ namespace CounterStrikeSharp.API.Core.Plugin
                    config.IsUnloadable = true;
                    config.PreferSharedTypes = true;
                });
-
+            
            if (CoreConfig.PluginHotReloadEnabled)
            {
                _fileWatcher = new FileSystemWatcher
@@ -110,6 +111,7 @@ namespace CounterStrikeSharp.API.Core.Plugin
                Loader = eventargs.Loader;
                Unload(hotReload: true);
                Load(hotReload: true);
+                Plugin.OnAllPluginsLoaded(hotReload: true);
            });
            
            return Task.CompletedTask;
@@ -118,12 +120,12 @@ namespace CounterStrikeSharp.API.Core.Plugin
        public void Load(bool hotReload = false)
        {
            if (State == PluginState.Loaded) return;
-
+            
            using (Loader.EnterContextualReflection())
            {
                var defaultAssembly = Loader.LoadDefaultAssembly();

-                Type pluginType = defaultAssembly.GetTypes()
+                Type pluginType = defaultAssembly.GetExportedTypes()
                    .FirstOrDefault(t => typeof(IPlugin).IsAssignableFrom(t));

                if (pluginType == null) throw new Exception("Unable to find plugin in assembly");
--- a/managed/CounterStrikeSharp.API/Core/Schema/Classes/CC4.g.cs
+++ b/managed/CounterStrikeSharp.API/Core/Schema/Classes/CC4.g.cs
@@ -62,8 +62,4 @@ public partial class CC4 : CCSWeaponBase
 	[SchemaMember("CC4", "m_bBombPlanted")]
 	public ref bool BombPlanted => ref Schema.GetRef<bool>(this.Handle, "CC4", "m_bBombPlanted");

-	// m_bDroppedFromDeath
-	[SchemaMember("CC4", "m_bDroppedFromDeath")]
-	public ref bool DroppedFromDeath => ref Schema.GetRef<bool>(this.Handle, "CC4", "m_bDroppedFromDeath");
-
 }
--- a/managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGameRules.g.cs
+++ b/managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGameRules.g.cs
@@ -450,6 +450,10 @@ public partial class CCSGameRules : CTeamplayRules
 	[SchemaMember("CCSGameRules", "m_arrSelectedHostageSpawnIndices")]
 	public NetworkedVector<Int32> SelectedHostageSpawnIndices => Schema.GetDeclaredClass<NetworkedVector<Int32>>(this.Handle, "CCSGameRules", "m_arrSelectedHostageSpawnIndices");

+	// m_nSpawnPointsRandomSeed
+	[SchemaMember("CCSGameRules", "m_nSpawnPointsRandomSeed")]
+	public ref Int32 SpawnPointsRandomSeed => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nSpawnPointsRandomSeed");
+
 	// m_bFirstConnected
 	[SchemaMember("CCSGameRules", "m_bFirstConnected")]
 	public ref bool FirstConnected => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bFirstConnected");
@@ -686,14 +690,26 @@ public partial class CCSGameRules : CTeamplayRules
 	[SchemaMember("CCSGameRules", "m_TerroristSpawnPointsMasterList")]
 	public NetworkedVector<SpawnPoint?> TerroristSpawnPointsMasterList => Schema.GetDeclaredClass<NetworkedVector<SpawnPoint?>>(this.Handle, "CCSGameRules", "m_TerroristSpawnPointsMasterList");

+	// m_bRespawningAllRespawnablePlayers
+	[SchemaMember("CCSGameRules", "m_bRespawningAllRespawnablePlayers")]
+	public ref bool RespawningAllRespawnablePlayers => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bRespawningAllRespawnablePlayers");
+
 	// m_iNextCTSpawnPoint
 	[SchemaMember("CCSGameRules", "m_iNextCTSpawnPoint")]
 	public ref Int32 NextCTSpawnPoint => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iNextCTSpawnPoint");

+	// m_flCTSpawnPointUsedTime
+	[SchemaMember("CCSGameRules", "m_flCTSpawnPointUsedTime")]
+	public ref float CTSpawnPointUsedTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flCTSpawnPointUsedTime");
+
 	// m_iNextTerroristSpawnPoint
 	[SchemaMember("CCSGameRules", "m_iNextTerroristSpawnPoint")]
 	public ref Int32 NextTerroristSpawnPoint => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_iNextTerroristSpawnPoint");

+	// m_flTerroristSpawnPointUsedTime
+	[SchemaMember("CCSGameRules", "m_flTerroristSpawnPointUsedTime")]
+	public ref float TerroristSpawnPointUsedTime => ref Schema.GetRef<float>(this.Handle, "CCSGameRules", "m_flTerroristSpawnPointUsedTime");
+
 	// m_CTSpawnPoints
 	[SchemaMember("CCSGameRules", "m_CTSpawnPoints")]
 	public NetworkedVector<SpawnPoint?> CTSpawnPoints => Schema.GetDeclaredClass<NetworkedVector<SpawnPoint?>>(this.Handle, "CCSGameRules", "m_CTSpawnPoints");
@@ -878,10 +894,6 @@ public partial class CCSGameRules : CTeamplayRules
 	[SchemaMember("CCSGameRules", "m_nRoundStartCount")]
 	public ref byte RoundStartCount => ref Schema.GetRef<byte>(this.Handle, "CCSGameRules", "m_nRoundStartCount");

-	// m_nRoundStartTicks
-	[SchemaMember("CCSGameRules", "m_nRoundStartTicks")]
-	public NetworkedVector<Int32> RoundStartTicks => Schema.GetDeclaredClass<NetworkedVector<Int32>>(this.Handle, "CCSGameRules", "m_nRoundStartTicks");
-
 	// m_flLastPerfSampleTime
 	[SchemaMember("CCSGameRules", "m_flLastPerfSampleTime")]
 	public ref double LastPerfSampleTime => ref Schema.GetRef<double>(this.Handle, "CCSGameRules", "m_flLastPerfSampleTime");
--- a/managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSPlayerController.g.cs
+++ b/managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSPlayerController.g.cs
@@ -294,6 +294,22 @@ public partial class CCSPlayerController : CBasePlayerController
 	[SchemaMember("CCSPlayerController", "m_vecKills")]
 	public NetworkedVector<EKillTypes_t> Kills => Schema.GetDeclaredClass<NetworkedVector<EKillTypes_t>>(this.Handle, "CCSPlayerController", "m_vecKills");

+	// m_bMvpNoMusic
+	[SchemaMember("CCSPlayerController", "m_bMvpNoMusic")]
+	public ref bool MvpNoMusic => ref Schema.GetRef<bool>(this.Handle, "CCSPlayerController", "m_bMvpNoMusic");
+
+	// m_eMvpReason
+	[SchemaMember("CCSPlayerController", "m_eMvpReason")]
+	public ref Int32 MvpReason => ref Schema.GetRef<Int32>(this.Handle, "CCSPlayerController", "m_eMvpReason");
+
+	// m_iMusicKitID
+	[SchemaMember("CCSPlayerController", "m_iMusicKitID")]
+	public ref Int32 MusicKitID => ref Schema.GetRef<Int32>(this.Handle, "CCSPlayerController", "m_iMusicKitID");
+
+	// m_iMusicKitMVPs
+	[SchemaMember("CCSPlayerController", "m_iMusicKitMVPs")]
+	public ref Int32 MusicKitMVPs => ref Schema.GetRef<Int32>(this.Handle, "CCSPlayerController", "m_iMusicKitMVPs");
+
 	// m_iMVPs
 	[SchemaMember("CCSPlayerController", "m_iMVPs")]
 	public ref Int32 MVPs => ref Schema.GetRef<Int32>(this.Handle, "CCSPlayerController", "m_iMVPs");
--- a/managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSPlayerPawnBase.g.cs
+++ b/managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSPlayerPawnBase.g.cs
@@ -202,13 +202,9 @@ public partial class CCSPlayerPawnBase : CBasePlayerPawn
 	[SchemaMember("CCSPlayerPawnBase", "m_iShouldHaveCash")]
 	public ref Int32 ShouldHaveCash => ref Schema.GetRef<Int32>(this.Handle, "CCSPlayerPawnBase", "m_iShouldHaveCash");

-	// m_bInvalidSteamLogonDelayed
-	[SchemaMember("CCSPlayerPawnBase", "m_bInvalidSteamLogonDelayed")]
-	public ref bool InvalidSteamLogonDelayed => ref Schema.GetRef<bool>(this.Handle, "CCSPlayerPawnBase", "m_bInvalidSteamLogonDelayed");
-
-	// m_flLastAction
-	[SchemaMember("CCSPlayerPawnBase", "m_flLastAction")]
-	public ref float LastAction => ref Schema.GetRef<float>(this.Handle, "CCSPlayerPawnBase", "m_flLastAction");
+	// m_flIdleTimeSinceLastAction
+	[SchemaMember("CCSPlayerPawnBase", "m_flIdleTimeSinceLastAction")]
+	public ref float IdleTimeSinceLastAction => ref Schema.GetRef<float>(this.Handle, "CCSPlayerPawnBase", "m_flIdleTimeSinceLastAction");

 	// m_flNameChangeHistory
 	[SchemaMember("CCSPlayerPawnBase", "m_flNameChangeHistory")]
--- a/managed/CounterStrikeSharp.API/Core/Schema/Classes/CPlantedC4.g.cs
+++ b/managed/CounterStrikeSharp.API/Core/Schema/Classes/CPlantedC4.g.cs
@@ -114,10 +114,6 @@ public partial class CPlantedC4 : CBaseAnimGraph
 	[SchemaMember("CPlantedC4", "m_flNextBotBeepTime")]
 	public ref float NextBotBeepTime => ref Schema.GetRef<float>(this.Handle, "CPlantedC4", "m_flNextBotBeepTime");

-	// m_bPlantedAfterPickup
-	[SchemaMember("CPlantedC4", "m_bPlantedAfterPickup")]
-	public ref bool PlantedAfterPickup => ref Schema.GetRef<bool>(this.Handle, "CPlantedC4", "m_bPlantedAfterPickup");
-
 	// m_angCatchUpToPlayerEye
 	[SchemaMember("CPlantedC4", "m_angCatchUpToPlayerEye")]
 	public QAngle CatchUpToPlayerEye => Schema.GetDeclaredClass<QAngle>(this.Handle, "CPlantedC4", "m_angCatchUpToPlayerEye");
--- a/managed/CounterStrikeSharp.API/Core/Schema/Enums/PulseValueType_t.g.cs
+++ b/managed/CounterStrikeSharp.API/Core/Schema/Enums/PulseValueType_t.g.cs
@@ -25,5 +25,6 @@ public enum PulseValueType_t : uint
 	PVAL_CURSOR_FLOW = 0xD,
 	PVAL_ANY = 0xE,
 	PVAL_SCHEMA_ENUM = 0xF,
-	PVAL_COUNT = 0x10,
+	PVAL_PANORAMA_PANEL_HANDLE = 0x10,
+	PVAL_COUNT = 0x11,
 }
--- a/managed/CounterStrikeSharp.API/CounterStrikeSharp.API.csproj
+++ b/managed/CounterStrikeSharp.API/CounterStrikeSharp.API.csproj
@@ -1,62 +1,73 @@
 <Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <TargetFramework>net7.0</TargetFramework>
-    <EnableDynamicLoading>true</EnableDynamicLoading>
-    <GenerateDocumentationFile>true</GenerateDocumentationFile>
-    <GenerateCompatibilitySuppressionFile>true</GenerateCompatibilitySuppressionFile>
-    <EnablePackageValidation>true</EnablePackageValidation>
-    <NoWarn>$(NoWarn);CS1591;CP0003</NoWarn>
-    <Nullable>enable</Nullable>
-	<GenerateCompatibilitySuppressionFile>true</GenerateCompatibilitySuppressionFile>
-    <Authors>Roflmuffin</Authors>
-    <Description>Official server side runtime assembly for CounterStrikeSharp</Description>
-    <PackageProjectUrl>http://docs.cssharp.dev/</PackageProjectUrl>
-    <RepositoryUrl>https://github.com/roflmuffin/CounterStrikeSharp</RepositoryUrl>
-    <PackageLicenseExpression>GPL-3.0-only</PackageLicenseExpression>
-    <PublishRepositoryUrl>true</PublishRepositoryUrl>
-    <IncludeSymbols>true</IncludeSymbols>
-    <SymbolPackageFormat>snupkg</SymbolPackageFormat>
-  </PropertyGroup>
-  <PropertyGroup>
-    <ApiCompatValidateAssemblies>true</ApiCompatValidateAssemblies>
-    <ApiCompatContractAssembly>.\ApiCompat\v151.dll</ApiCompatContractAssembly>
-  </PropertyGroup>
-  <ItemGroup>
-    <None Remove="Modules\Commands\CommandInfo" />
-    <None Remove="Modules\Disabled\**" />
-  </ItemGroup>
-  <ItemGroup>
-    <PackageReference Include="McMaster.NETCore.Plugins" Version="1.4.0" />
-    <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
-    <PackageReference Include="Microsoft.DotNet.ApiCompat.Task" Version="7.0.404" />
-    <PackageReference Include="Microsoft.Extensions.Hosting" Version="7.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="7.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Localization.Abstractions" Version="7.0.3" />
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="7.0.0" />
-    <PackageReference Include="Scrutor" Version="4.2.2" />
-    <PackageReference Include="Serilog.Extensions.Logging" Version="7.0.0" />
-    <PackageReference Include="Serilog.Sinks.Console" Version="5.0.0" />
-    <PackageReference Include="Serilog.Sinks.File" Version="5.0.0" />
-    <PackageReference Include="System.Data.DataSetExtensions" Version="4.5.0" />
-  </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Core\Schema\" />
-    <Folder Include="Modules\Errors" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Remove="Modules\Disabled\**" />
-  </ItemGroup>
-  <ItemGroup>
-    <EmbeddedResource Remove="Modules\Disabled\**" />
-  </ItemGroup>
-  <PropertyGroup />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
-    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-  </PropertyGroup>
-<!--  <Target Name="PreBuild" BeforeTargets="PreBuildEvent">-->
-<!--    <Exec Command="dotnet run &#45;&#45;project ../../tooling/CodeGen.Natives" />-->
-<!--  </Target>-->
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <EnableDynamicLoading>true</EnableDynamicLoading>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+        <GenerateCompatibilitySuppressionFile>true</GenerateCompatibilitySuppressionFile>
+        <EnablePackageValidation>true</EnablePackageValidation>
+        <NoWarn>$(NoWarn);CS1591;CP0003</NoWarn>
+        <Nullable>enable</Nullable>
+        <Authors>Roflmuffin</Authors>
+        <Description>Official server side runtime assembly for CounterStrikeSharp</Description>
+        <PackageProjectUrl>http://docs.cssharp.dev/</PackageProjectUrl>
+        <RepositoryUrl>https://github.com/roflmuffin/CounterStrikeSharp</RepositoryUrl>
+        <PackageLicenseExpression>GPL-3.0-only</PackageLicenseExpression>
+        <PublishRepositoryUrl>true</PublishRepositoryUrl>
+        <IncludeSymbols>true</IncludeSymbols>
+        <SymbolPackageFormat>snupkg</SymbolPackageFormat>
+        <SourceControlInformationFeatureSupported>true</SourceControlInformationFeatureSupported>
+        <!-- <GenerateCompatibilitySuppressionFile>true</GenerateCompatibilitySuppressionFile> -->
+    </PropertyGroup>
+    <PropertyGroup>
+        <ApiCompatValidateAssemblies>true</ApiCompatValidateAssemblies>
+        <ApiCompatContractAssembly>.\ApiCompat\v202.dll</ApiCompatContractAssembly>
+    </PropertyGroup>
+    <ItemGroup>
+        <None Remove="Modules\Commands\CommandInfo"/>
+        <None Remove="Modules\Disabled\**"/>
+    </ItemGroup>
+    <ItemGroup>
+        <PackageReference Include="McMaster.NETCore.Plugins" Version="1.4.0"/>
+        <PackageReference Include="Microsoft.CSharp" Version="4.7.0"/>
+        <PackageReference Include="Microsoft.DotNet.ApiCompat.Task" Version="8.0.203"/>
+        <PackageReference Include="Microsoft.Extensions.Hosting" Version="8.0.0"/>
+        <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="8.0.0"/>
+        <PackageReference Include="Microsoft.Extensions.Localization.Abstractions" Version="8.0.3"/>
+        <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.0"/>
+        <PackageReference Include="Scrutor" Version="4.2.2"/>
+        <PackageReference Include="Serilog.Extensions.Logging" Version="8.0.0"/>
+        <PackageReference Include="Serilog.Sinks.Console" Version="5.0.0"/>
+        <PackageReference Include="Serilog.Sinks.File" Version="5.0.0"/>
+        <PackageReference Include="System.Data.DataSetExtensions" Version="4.5.0"/>
+    </ItemGroup>
+    <ItemGroup>
+        <Folder Include="Core\Schema\"/>
+        <Folder Include="Modules\Errors"/>
+    </ItemGroup>
+    <ItemGroup>
+        <Compile Remove="Modules\Disabled\**"/>
+    </ItemGroup>
+    <ItemGroup>
+        <EmbeddedResource Remove="Modules\Disabled\**"/>
+    </ItemGroup>
+    <PropertyGroup/>
+    <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    </PropertyGroup>
+    <Target Name="SetSourceRevisionId" BeforeTargets="InitializeSourceControlInformation">
+        <Exec
+                Command="git describe --long --always --exclude=* --abbrev=7"
+                ConsoleToMSBuild="True"
+                IgnoreExitCode="False"
+        >
+            <Output PropertyName="SourceRevisionId" TaskParameter="ConsoleOutput"/>
+        </Exec>
+    </Target>
+
+    <!--  <Target Name="PreBuild" BeforeTargets="PreBuildEvent">-->
+    <!--    <Exec Command="dotnet run &#45;&#45;project ../../tooling/CodeGen.Natives" />-->
+    <!--  </Target>-->
 </Project>
--- a/managed/CounterStrikeSharp.API/GlobalUsings.cs
+++ b/managed/CounterStrikeSharp.API/GlobalUsings.cs
@@ -1,5 +1,7 @@
 // Global using directives

 global using System;
+global using System.Linq;
 global using System.IO;
+global using System.Collections.Generic;
 global using CounterStrikeSharp.API.Core;
--- a/managed/CounterStrikeSharp.API/Modules/Admin/AdminCommandOverrides.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Admin/AdminCommandOverrides.cs
@@ -62,7 +62,7 @@ namespace CounterStrikeSharp.API.Modules.Admin
        {
            CommandOverrides.TryGetValue(commandName, out var overrideDef);
            if (overrideDef == null) return false;
-            return overrideDef.Enabled && overrideDef?.Flags.Count() > 0;
+            return overrideDef.Enabled;
        }

        /// <summary>
--- a/managed/CounterStrikeSharp.API/Modules/Admin/AdminPermissions.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Admin/AdminPermissions.cs
@@ -132,7 +132,6 @@ namespace CounterStrikeSharp.API.Modules.Admin
                foreach (var adminDef in adminsFromFile.Values)
                {
                    adminDef.InitalizeFlags();
-                    Console.WriteLine($"Domains: {adminDef.Flags.Count}");

                    if (SteamID.TryParse(adminDef.Identity, out var steamId))
                    {
--- a/managed/CounterStrikeSharp.API/Modules/Commands/CommandInfo.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Commands/CommandInfo.cs
@@ -23,6 +23,10 @@ namespace CounterStrikeSharp.API.Modules.Commands
    {
        public delegate void CommandCallback(CCSPlayerController? player, CommandInfo commandInfo);
        
+        /// <summary>
+        /// Command listener callback.
+        /// <returns>If returning <see cref="HookResult.Handled"/> or higher, will prevent the command from executing.</returns>
+        /// </summary>
        public delegate HookResult CommandListenerCallback(CCSPlayerController? player, CommandInfo commandInfo);

        public CCSPlayerController? CallingPlayer { get; }
--- a/managed/CounterStrikeSharp.API/Modules/Commands/Targeting/Target.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Commands/Targeting/Target.cs
@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System.Collections.Frozen;
+using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using CounterStrikeSharp.API.Modules.Entities;
@@ -12,7 +13,7 @@ public class Target
    private string Raw { get; }
    private string Slug { get; }
    
-    private static readonly Dictionary<string, TargetType> TargetTypeMap = new(StringComparer.OrdinalIgnoreCase)
+    public static readonly IReadOnlyDictionary<string, TargetType> TargetTypeMap = new Dictionary<string, TargetType>(StringComparer.OrdinalIgnoreCase)
    {
        { "@all", TargetType.GroupAll },
        { "@bots", TargetType.GroupBots },
@@ -24,7 +25,7 @@ public class Target
        { "@ct", TargetType.TeamCt },
        { "@t", TargetType.TeamT },
        { "@spec", TargetType.TeamSpec }
-    };
+    }.ToFrozenDictionary();


    private static bool ConstTargetType(string target, out TargetType targetType)
--- a/managed/CounterStrikeSharp.API/Modules/Entities/Constants/CollisionGroup.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Entities/Constants/CollisionGroup.cs
@@ -18,34 +18,37 @@ namespace CounterStrikeSharp.API.Modules.Entities.Constants
 {
    public enum CollisionGroup
    {
-		COLLISION_GROUP_NONE  = 0,
-        COLLISION_GROUP_DEBRIS,			// Collides with nothing but world and static stuff
-        COLLISION_GROUP_DEBRIS_TRIGGER, // Same as debris, but hits triggers
-        COLLISION_GROUP_INTERACTIVE_DEBRIS,	// Collides with everything except other interactive debris or debris
-        COLLISION_GROUP_INTERACTIVE,	// Collides with everything except interactive debris or debris
+        COLLISION_GROUP_NONE = 0,
+        COLLISION_GROUP_NEVER,
+        COLLISION_GROUP_TRIGGER,
+        COLLISION_GROUP_CONDITIONALLY_SOLID,
+        COLLISION_GROUP_DEFAULT,
+        COLLISION_GROUP_DEBRIS, // Collides with nothing but world and static stuff
+        COLLISION_GROUP_INTERACTIVE_DEBRIS, // Collides with everything except other interactive debris or debris
+        COLLISION_GROUP_INTERACTIVE, // Collides with everything except interactive debris or debris
        COLLISION_GROUP_PLAYER,
        COLLISION_GROUP_BREAKABLE_GLASS,
        COLLISION_GROUP_VEHICLE,
-        COLLISION_GROUP_PLAYER_MOVEMENT,  // For HL2, same as Collision_Group_Player, for
-        // TF2, this filters out other players and CBaseObjects
-        COLLISION_GROUP_NPC,			// Generic NPC group
-        COLLISION_GROUP_IN_VEHICLE,		// for any entity inside a vehicle
-        COLLISION_GROUP_WEAPON,			// for any weapons that need collision detection
-        COLLISION_GROUP_VEHICLE_CLIP,	// vehicle clip brush to restrict vehicle movement
-        COLLISION_GROUP_PROJECTILE,		// Projectiles!
-        COLLISION_GROUP_DOOR_BLOCKER,	// Blocks entities not permitted to get near moving doors
-        COLLISION_GROUP_PASSABLE_DOOR,	// Doors that the player shouldn't collide with
-        COLLISION_GROUP_DISSOLVING,		// Things that are dissolving are in this group
-        COLLISION_GROUP_PUSHAWAY,		// Nonsolid on client and server, pushaway in player code
+        COLLISION_GROUP_PLAYER_MOVEMENT, // For HL2, same as Collision_Group_Player, for

-        COLLISION_GROUP_NPC_ACTOR,		// Used so NPCs in scripts ignore the player.
-        COLLISION_GROUP_NPC_SCRIPTED,	// USed for NPCs in scripts that should not collide with each other
+        // TF2, this filters out other players and CBaseObjects
+        COLLISION_GROUP_NPC, // Generic NPC group
+        COLLISION_GROUP_IN_VEHICLE, // for any entity inside a vehicle
+        COLLISION_GROUP_WEAPON, // for any weapons that need collision detection
+        COLLISION_GROUP_VEHICLE_CLIP, // vehicle clip brush to restrict vehicle movement
+        COLLISION_GROUP_PROJECTILE, // Projectiles!
+        COLLISION_GROUP_DOOR_BLOCKER, // Blocks entities not permitted to get near moving doors
+        COLLISION_GROUP_PASSABLE_DOOR, // Doors that the player shouldn't collide with
+        COLLISION_GROUP_DISSOLVING, // Things that are dissolving are in this group
+        COLLISION_GROUP_PUSHAWAY, // Nonsolid on client and server, pushaway in player code
+
+        COLLISION_GROUP_NPC_ACTOR, // Used so NPCs in scripts ignore the player.
+        COLLISION_GROUP_NPC_SCRIPTED, // USed for NPCs in scripts that should not collide with each other
        COLLISION_GROUP_PZ_CLIP,


-
-        COLLISION_GROUP_DEBRIS_BLOCK_PROJECTILE, // Only collides with bullets
+        COLLISION_GROUP_PROPS,

        LAST_SHARED_COLLISION_GROUP
-	}
+    }
 }
--- a/managed/CounterStrikeSharp.API/Modules/Events/GameEvent.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Events/GameEvent.cs
@@ -32,12 +32,16 @@ namespace CounterStrikeSharp.API.Modules.Events

    public class GameEvent : NativeObject
    {
+        // Used to track freeable state for manually created events.
+        private bool _freeable = false;
+        
        public GameEvent(IntPtr pointer) : base(pointer)
        {
        }
        
        public GameEvent(string name, bool force) : this(NativeAPI.CreateEvent(name, force))
        {
+            _freeable = true;
        }
        
        public string EventName => NativeAPI.GetEventName(Handle);
@@ -121,8 +125,28 @@ namespace CounterStrikeSharp.API.Modules.Events

        protected void SetEntityIndex(string name, int value) => NativeAPI.SetEventEntityIndex(Handle, name, value);

-        public void FireEvent(bool dontBroadcast) => NativeAPI.FireEvent(Handle, dontBroadcast);
-        
+        public void FireEvent(bool dontBroadcast)
+        {
+            NativeAPI.FireEvent(Handle, dontBroadcast);
+            _freeable = false;
+        }
+
        public void FireEventToClient(CCSPlayerController player) => NativeAPI.FireEventToClient(Handle, (int)player.Index);
+        
+        /// <summary>
+        /// Used to manually free the event.
+        /// <remarks>If <see cref="FireEvent"/> is called, Free will be called automatically.</remarks>
+        /// </summary>
+        public void Free()
+        {
+            if (!_freeable)
+            {
+                throw new InvalidOperationException("Event is not able to be freed.");
+            }
+            
+            NativeAPI.FreeEvent(Handle);
+
+            _freeable = false;
+        }
    }
 }
--- a/managed/CounterStrikeSharp.API/Modules/Memory/DynamicFunctions/DynamicHook.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Memory/DynamicFunctions/DynamicHook.cs
@@ -1,4 +1,4 @@
-using System;
+using System;
 using CounterStrikeSharp.API.Core;

 namespace CounterStrikeSharp.API.Modules.Memory.DynamicFunctions;
@@ -14,7 +14,13 @@ public class DynamicHook : NativeObject
        return NativeAPI.DynamicHookGetParam<T>(Handle, (int)typeof(T).ToValidDataType(), index);
    }

+    [Obsolete("Use GetReturn<T>() instead")]
    public T GetReturn<T>(int index)
+    {
+        return GetReturn<T>();
+    }
+    
+    public T GetReturn<T>()
    {
        return NativeAPI.DynamicHookGetReturn<T>(Handle, (int)typeof(T).ToValidDataType());
    }
@@ -28,4 +34,4 @@ public class DynamicHook : NativeObject
    {
        NativeAPI.DynamicHookSetReturn(Handle, (int)typeof(T).ToValidDataType(), value);
    }
-}
+}
--- a/managed/CounterStrikeSharp.API/Modules/Memory/VirtualFunctions.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Memory/VirtualFunctions.cs
@@ -46,10 +46,10 @@ public static class VirtualFunctions

    public static Action<IntPtr, string> SetModel = SetModelFunc.Invoke;

-    public static MemoryFunctionVoid<nint, RoundEndReason, float> TerminateRoundFunc =
+    public static MemoryFunctionVoid<nint, RoundEndReason, float, nint, byte> TerminateRoundFunc =
        new(GameData.GetSignature("CCSGameRules_TerminateRound"));

-    public static Action<IntPtr, RoundEndReason, float> TerminateRound = TerminateRoundFunc.Invoke;
+    public static Action<IntPtr, RoundEndReason, float, nint, byte> TerminateRound = TerminateRoundFunc.Invoke;

    public static MemoryFunctionWithReturn<string, int, IntPtr> UTIL_CreateEntityByNameFunc =
        new(GameData.GetSignature("UTIL_CreateEntityByName"));
--- a/managed/CounterStrikeSharp.API/Modules/Menu/BaseMenu.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Menu/BaseMenu.cs
@@ -28,22 +28,35 @@ public enum PostSelectAction
 public abstract class BaseMenu : IMenu
 {
    public string Title { get; set; }
+
    public List<ChatMenuOption> MenuOptions { get; } = new();
    public PostSelectAction PostSelectAction { get; set; } = PostSelectAction.Reset;
-     
+    public bool ExitButton { get; set; } = true;
+
    protected BaseMenu(string title)
    {
        Title = title;
    }
-        
-    public virtual ChatMenuOption AddMenuOption(string display, Action<CCSPlayerController, ChatMenuOption> onSelect, bool disabled = false)
+
+    public virtual ChatMenuOption AddMenuOption(string display, Action<CCSPlayerController, ChatMenuOption> onSelect,
+        bool disabled = false)
    {
        var option = new ChatMenuOption(display, disabled, onSelect);
        MenuOptions.Add(option);
        return option;
    }
+
+    public abstract void Open(CCSPlayerController player);
+
+    public void OpenToAll()
+    {
+        foreach (var player in Utilities.GetPlayers())
+        {
+            Open(player);
+        }
+    }
 }
-    
+
 // This must be called ChatMenuOption to maintain backwards compatibility with the old API
 public class ChatMenuOption
 {
@@ -76,8 +89,8 @@ public abstract class BaseMenuInstance : IMenuInstance
    }

    protected bool HasPrevButton => Page > 0;
-    protected bool HasNextButton => CurrentOffset + NumPerPage < Menu.MenuOptions.Count;
-    protected int MenuItemsPerPage => NumPerPage + 2 - (HasNextButton ? 1 : 0) - (HasPrevButton ? 1 : 0);
+    protected bool HasNextButton => Menu.MenuOptions.Count > NumPerPage && CurrentOffset + NumPerPage < Menu.MenuOptions.Count;
+    protected virtual int MenuItemsPerPage => NumPerPage;

    public virtual void Display()
    {
@@ -113,7 +126,7 @@ public abstract class BaseMenuInstance : IMenuInstance
        if (menuItemIndex >= 0 && menuItemIndex < Menu.MenuOptions.Count)
        {
            var menuOption = Menu.MenuOptions[menuItemIndex];
-                
+
            if (!menuOption.Disabled)
            {
                menuOption.OnSelect(Player, menuOption);
@@ -141,8 +154,8 @@ public abstract class BaseMenuInstance : IMenuInstance
        Page = 0;
        PrevPageOffsets.Clear();
    }
-        
-    public void Close()
+
+    public virtual void Close()
    {
        MenuManager.CloseActiveMenu(Player);
    }
--- a/managed/CounterStrikeSharp.API/Modules/Menu/CenterHtmlMenu.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Menu/CenterHtmlMenu.cs
@@ -21,17 +21,43 @@ namespace CounterStrikeSharp.API.Modules.Menu;

 public class CenterHtmlMenu : BaseMenu
 {
+    private readonly BasePlugin? _plugin;
+    public string TitleColor { get; set; } = "yellow";
+    public string EnabledColor { get; set; } = "green";
+    public string DisabledColor { get; set; } = "grey";
+    public string PrevPageColor { get; set; } = "yellow";
+    public string NextPageColor { get; set; } = "yellow";
+    public string CloseColor { get; set; } = "red";
+
+    public CenterHtmlMenu(string title, BasePlugin plugin) : base(ModifyTitle(title))
+    {
+        _plugin = plugin;
+    }
+    
+    [Obsolete("Use the constructor that takes a BasePlugin")]
    public CenterHtmlMenu(string title) : base(ModifyTitle(title))
    {
    }
+
+    public override void Open(CCSPlayerController player)
+    {
+        if (_plugin == null)
+        {
+            throw new InvalidOperationException("This method is unsupported with the CenterHtmlMenu constructor used." +
+                                                "Please provide a BasePlugin in the constructor.");
+        }; 
        
-    public override ChatMenuOption AddMenuOption(string display, Action<CCSPlayerController, ChatMenuOption> onSelect, bool disabled = false)
+        MenuManager.OpenCenterHtmlMenu(_plugin, player, this);
+    }
+
+    public override ChatMenuOption AddMenuOption(string display, Action<CCSPlayerController, ChatMenuOption> onSelect,
+        bool disabled = false)
    {
        var option = new ChatMenuOption(ModifyOptionDisplay(display), disabled, onSelect);
        MenuOptions.Add(option);
        return option;
    }
-        
+
    private static string ModifyTitle(string title)
    {
        if (title.Length > 32)
@@ -59,14 +85,15 @@ public class CenterHtmlMenuInstance : BaseMenuInstance
 {
    private readonly BasePlugin _plugin;
    public override int NumPerPage => 5; // one less than the actual number of items per page to avoid truncated options
-        
+    protected override int MenuItemsPerPage => (Menu.ExitButton ? 0 : 1) + ((HasPrevButton && HasNextButton) ? NumPerPage - 1 : NumPerPage);
+
    public CenterHtmlMenuInstance(BasePlugin plugin, CCSPlayerController player, IMenu menu) : base(player, menu)
    {
        _plugin = plugin;
        RemoveOnTickListener();
        plugin.RegisterListener<Core.Listeners.OnTick>(Display);
    }
-        
+
    public override void Display()
    {
        if (MenuManager.GetActiveMenu(Player) != this)
@@ -74,45 +101,53 @@ public class CenterHtmlMenuInstance : BaseMenuInstance
            Reset();
            return;
        }
-            
+
+        if (Menu is not CenterHtmlMenu centerHtmlMenu)
+        {
+            return;
+        }
+
        var builder = new StringBuilder();
-        builder.Append($"<b><font color='yellow'>{Menu.Title}</font></b>");
+        builder.Append($"<b><font color='{centerHtmlMenu.TitleColor}'>{centerHtmlMenu.Title}</font></b>");
        builder.AppendLine("<br>");

        var keyOffset = 1;

-        for (var i = CurrentOffset; i < Math.Min(CurrentOffset + MenuItemsPerPage, Menu.MenuOptions.Count); i++)
+        for (var i = CurrentOffset; i < Math.Min(CurrentOffset + MenuItemsPerPage, centerHtmlMenu.MenuOptions.Count); i++)
        {
-            var option = Menu.MenuOptions[i];
-            string color = option.Disabled ? "grey" : "green";
+            var option = centerHtmlMenu.MenuOptions[i];
+            string color = option.Disabled ? centerHtmlMenu.DisabledColor : centerHtmlMenu.EnabledColor;
            builder.Append($"<font color='{color}'>!{keyOffset++}</font> {option.Text}");
            builder.AppendLine("<br>");
        }
-            
+
        if (HasPrevButton)
        {
-            builder.AppendFormat("<font color='yellow'>!7</font> &#60;- Prev");
+            builder.AppendFormat($"<font color='{centerHtmlMenu.PrevPageColor}'>!7</font> &#60;- Prev");
            builder.AppendLine("<br>");
        }

        if (HasNextButton)
        {
-            builder.AppendFormat("<font color='yellow'>!8</font> -> Next");
+            builder.AppendFormat($"<font color='{centerHtmlMenu.NextPageColor}'>!8</font> -> Next");
            builder.AppendLine("<br>");
        }

-        builder.AppendFormat("<font color='red'>!9</font> -> Close");
-        builder.AppendLine("<br>");
+        if (centerHtmlMenu.ExitButton)
+        {
+            builder.AppendFormat($"<font color='{centerHtmlMenu.CloseColor}'>!9</font> -> Close");
+            builder.AppendLine("<br>");
+        }

        var currentPageText = builder.ToString();
        Player.PrintToCenterHtml(currentPageText);
    }

-    public override void Reset()
+    public override void Close()
    {
-        base.Reset();
+        base.Close();
        RemoveOnTickListener();
-            
+
        // Send a blank message to clear the menu
        Player.PrintToCenterHtml(" ");
    }
--- a/managed/CounterStrikeSharp.API/Modules/Menu/ChatMenu.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Menu/ChatMenu.cs
@@ -18,10 +18,22 @@ using CounterStrikeSharp.API.Modules.Utils;

 namespace CounterStrikeSharp.API.Modules.Menu;

-public class ChatMenu: BaseMenu
+public class ChatMenu : BaseMenu
 {
+    public char TitleColor { get; set; } = ChatColors.Yellow;
+    public char EnabledColor { get; set; } = ChatColors.Green;
+    public char DisabledColor { get; set; } = ChatColors.Grey;
+    public char PrevPageColor { get; set; } = ChatColors.Yellow;
+    public char NextPageColor { get; set; } = ChatColors.Yellow;
+    public char CloseColor { get; set; } = ChatColors.Red;
    public ChatMenu(string title) : base(title)
    {
+        ExitButton = false;
+    }
+    
+    public override void Open(CCSPlayerController player)
+    {
+        MenuManager.OpenChatMenu(player, this);
    }
 }

@@ -33,29 +45,35 @@ public class ChatMenuInstance : BaseMenuInstance

    public override void Display()
    {
-        Player.PrintToChat(Menu.Title);
+        if (Menu is not ChatMenu chatMenu)
+        {
+            return;
+        }
+
+        Player.PrintToChat($" {chatMenu.TitleColor} {chatMenu.Title}");
        Player.PrintToChat("---");

        var keyOffset = 1;
-
-        for (var i = CurrentOffset;
-             i < Math.Min(CurrentOffset + MenuItemsPerPage, Menu.MenuOptions.Count);
-             i++)
+        for (var i = CurrentOffset; i < Math.Min(CurrentOffset + MenuItemsPerPage, Menu.MenuOptions.Count); i++)
        {
            var option = Menu.MenuOptions[i];
-
-            Player.PrintToChat(
-                $" {(option.Disabled ? ChatColors.Grey : ChatColors.Green)} !{keyOffset++} {ChatColors.Default}{option.Text}");
+            char color = option.Disabled ? chatMenu.DisabledColor : chatMenu.EnabledColor;
+            Player.PrintToChat($" {color} !{keyOffset++} {ChatColors.Default}{option.Text}");
        }

        if (HasPrevButton)
        {
-            Player.PrintToChat($" {ChatColors.Yellow}!7 {ChatColors.Default}-> Prev");
+            Player.PrintToChat($" {chatMenu.PrevPageColor}!7 {ChatColors.Default}-> Prev");
        }
            
        if (HasNextButton)
        {
-            Player.PrintToChat($" {ChatColors.Yellow}!8 {ChatColors.Default}-> Next");
+            Player.PrintToChat($" {chatMenu.NextPageColor}!8 {ChatColors.Default}-> Next");
+        }
+
+        if (Menu.ExitButton)
+        {
+            Player.PrintToChat($" {chatMenu.CloseColor}!9 {ChatColors.Default}-> Close");
        }
    }
 }
--- a/managed/CounterStrikeSharp.API/Modules/Menu/ConsoleMenu.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Menu/ConsoleMenu.cs
@@ -21,6 +21,11 @@ public class ConsoleMenu : BaseMenu
    public ConsoleMenu(string title) : base(title)
    {
    }
+
+    public override void Open(CCSPlayerController player)
+    {
+        MenuManager.OpenConsoleMenu(player, this);
+    }
 }

 public class ConsoleMenuInstance : BaseMenuInstance
@@ -42,7 +47,7 @@ public class ConsoleMenuInstance : BaseMenuInstance
        {
            var option = Menu.MenuOptions[i];

-            Player.PrintToConsole($"{(option.Disabled ? "[Enabled]" : "[Disabled] - ")} css_{keyOffset++} {option.Text}");
+            Player.PrintToConsole($"{(option.Disabled ? "[Disabled] - " : "[Enabled]")} css_{keyOffset++} {option.Text}");
        }
            
        if (HasPrevButton)
@@ -54,5 +59,10 @@ public class ConsoleMenuInstance : BaseMenuInstance
        {
            Player.PrintToConsole("css_8 -> Next");
        }
+        
+        if (Menu.ExitButton)
+        {
+            Player.PrintToConsole("css_9 -> Close");
+        }
    }
 }
--- a/managed/CounterStrikeSharp.API/Modules/Menu/IMenu.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Menu/IMenu.cs
@@ -20,15 +20,18 @@ namespace CounterStrikeSharp.API.Modules.Menu;

 public interface IMenu
 {
-    public string Title { get; set; }
-    public List<ChatMenuOption> MenuOptions { get; }
-    public PostSelectAction PostSelectAction
+    string Title { get; set; }
+    List<ChatMenuOption> MenuOptions { get; }
+    PostSelectAction PostSelectAction
    {
        get { throw new NotImplementedException(); }
        set { throw new NotImplementedException(); }
    }
+    bool ExitButton { get; set; }
        
-    public ChatMenuOption AddMenuOption(string display, Action<CCSPlayerController, ChatMenuOption> onSelect, bool disabled = false);
+    ChatMenuOption AddMenuOption(string display, Action<CCSPlayerController, ChatMenuOption> onSelect, bool disabled = false);
+    void Open(CCSPlayerController player);
+    void OpenToAll();
 }

 public interface IMenuInstance
--- a/managed/CounterStrikeSharp.API/Modules/Menu/MenuManager.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Menu/MenuManager.cs
@@ -41,7 +41,7 @@ public static class MenuManager

        ActiveMenus.Remove(player.Handle);
    }
-
+    
    public static void OpenChatMenu(CCSPlayerController player, ChatMenu menu)
    {
        CloseActiveMenu(player);
@@ -49,7 +49,7 @@ public static class MenuManager
        ActiveMenus[player.Handle] = new ChatMenuInstance(player, menu);
        ActiveMenus[player.Handle].Display();
    }
-
+    
    public static void OpenCenterHtmlMenu(BasePlugin plugin, CCSPlayerController player, CenterHtmlMenu menu)
    {
        CloseActiveMenu(player);
@@ -57,7 +57,7 @@ public static class MenuManager
        ActiveMenus[player.Handle] = new CenterHtmlMenuInstance(plugin, player, menu);
        ActiveMenus[player.Handle].Display();
    }
-
+    
    public static void OpenConsoleMenu(CCSPlayerController player, ConsoleMenu menu)
    {
        CloseActiveMenu(player);
--- a/managed/CounterStrikeSharp.API/Modules/Utils/Angle.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Utils/Angle.cs
@@ -14,9 +14,6 @@
 *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
 */

-using System;
-using CounterStrikeSharp.API.Core;
-
 namespace CounterStrikeSharp.API.Modules.Utils
 {
    /// <summary>
@@ -30,6 +27,8 @@ namespace CounterStrikeSharp.API.Modules.Utils
    /// </summary>
    public class Angle : NativeObject
    {
+        public static readonly Angle Zero = new();
+        
        public Angle(IntPtr pointer) : base(pointer)
        {
        }
@@ -46,8 +45,6 @@ namespace CounterStrikeSharp.API.Modules.Utils
            this.Y = y ?? 0;
            this.Z = z ?? 0;
        }
-        
-        

        #region Accessors

@@ -366,15 +363,15 @@ namespace CounterStrikeSharp.API.Modules.Utils
            return this.IsEqualTol(v, 0.01f);
        }

-        public override string ToString()
-        {
-            return $"{X:n2} {Y:n2} {Z:n2}";
-        }
-
        #endregion

        protected override void OnDispose()
        {
        }*/
+        
+        public override string ToString()
+        {
+            return $"{X:n2} {Y:n2} {Z:n2}";
+        }
    }
 }
--- a/managed/CounterStrikeSharp.API/Modules/Utils/QAngle.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Utils/QAngle.cs
@@ -14,14 +14,14 @@
 *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
 */

-using System;
 using System.Runtime.CompilerServices;
-using CounterStrikeSharp.API.Core;

 namespace CounterStrikeSharp.API.Modules.Utils
 {
    public class QAngle : NativeObject
    {
+        public static readonly QAngle Zero = new();
+        
        public QAngle(IntPtr pointer) : base(pointer)
        {
        }
--- a/managed/CounterStrikeSharp.API/Modules/Utils/ResourceManifest.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Utils/ResourceManifest.cs
@@ -0,0 +1,20 @@
+using CounterStrikeSharp.API.Modules.Memory;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace CounterStrikeSharp.API.Modules.Utils
+{
+    public class ResourceManifest : NativeObject
+    {
+        private Action<nint, string> _AddResource;
+        public ResourceManifest(nint pointer) : base(pointer)
+        {
+            _AddResource = VirtualFunction.CreateVoid<nint, string>(Handle, GameData.GetOffset("CEntityResourceManifest_AddResource"));
+        }
+
+        public void AddResource(string resourcePath) => _AddResource(Handle, resourcePath);
+    }
+}
--- a/managed/CounterStrikeSharp.API/Modules/Utils/Vector.cs
+++ b/managed/CounterStrikeSharp.API/Modules/Utils/Vector.cs
@@ -1,4 +1,4 @@
-/*
+/*
 *  This file is part of CounterStrikeSharp.
 *  CounterStrikeSharp is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
@@ -14,11 +14,7 @@
 *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
 */

-using System;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using CounterStrikeSharp.API.Core;
-using CounterStrikeSharp.API.Modules.Utils;

 namespace CounterStrikeSharp.API.Modules.Utils
 {
@@ -33,11 +29,12 @@ namespace CounterStrikeSharp.API.Modules.Utils
    /// </summary>
    public class Vector : NativeObject
    {
+        public static readonly Vector Zero = new();
+        
        public Vector(IntPtr pointer) : base(pointer)
        {
        }

-
        public Vector(float? x = null, float? y = null, float? z = null) : this(NativeAPI.VectorNew())
        {
            this.X = x ?? 0;
@@ -75,7 +72,7 @@ namespace CounterStrikeSharp.API.Modules.Utils
        {
            this.X += vector.X;
            this.Y += vector.Y;
-            this.Z = this.Z = vector.Z;
+            this.Z += vector.Z;
        }

        
--- a/managed/CounterStrikeSharp.API/Server.cs
+++ b/managed/CounterStrikeSharp.API/Server.cs
@@ -19,6 +19,7 @@ using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices;
+using System.Threading.Tasks;
 using CounterStrikeSharp.API.Core;
 using CounterStrikeSharp.API.Modules.Memory;
 using CounterStrikeSharp.API.Modules.Utils;
@@ -27,19 +28,77 @@ namespace CounterStrikeSharp.API
 {
    public class Server
    {
-        public static float TickInterval => NativeAPI.GetTickInterval();
+        /// <summary>
+        /// Duration of a single game tick in seconds, based on a 64 tick server (hard coded in CS2).
+        /// </summary>
+        public static float TickInterval => 0.015625f;

+        /// <summary>
+        /// Executes a command on the server, as if it was entered from the console.
+        /// </summary>
+        /// <param name="command"></param>
        public static void ExecuteCommand(string command) => NativeAPI.IssueServerCommand(command);

        public static string MapName => NativeAPI.GetMapName();
-        // public static void PrintToConsole(string message) => NativeAPI.PrintToConsole(message);

+        /// <summary>
+        /// Returns the total time the server has been running in seconds.
+        /// </summary>
+        /// <remarks>Does not increment when server is hibernating</remarks>
        public static double TickedTime => NativeAPI.GetTickedTime();
+        
+        /// <summary>
+        /// Returns the current map time in seconds, as an interval of the server's tick interval.
+        /// e.g. 70.046875 would represent 70 seconds of map time and the 4483rd tick of the server (70.046875 / 0.015625).
+        /// </summary>
+        /// <remarks>Increments even when server is hibernating</remarks>
        public static float CurrentTime => NativeAPI.GetCurrentTime();
+        
+        /// <summary>
+        /// Returns the current map tick count.
+        /// CS2 is a 64 tick server, so the value will increment by 64 every second.
+        /// </summary>
        public static int TickCount => NativeAPI.GetTickCount();
-        public static float GameFrameTime => NativeAPI.GetGameFrameTime();
+        
+        /// <summary>
+        /// Returns the total time the server has been running in seconds.
+        /// </summary>
+        /// <remarks>Increments even when server is hibernating</remarks>
        public static double EngineTime => NativeAPI.GetEngineTime();
+        
        public static void PrecacheModel(string name) => NativeAPI.PrecacheModel(name);
+        
+        /// <summary>
+        /// <inheritdoc cref="RunOnTick"/>
+        /// Returns Task that completes once the synchronous task has been completed.
+        /// </summary>
+        public static Task RunOnTickAsync(int tick, Action task)
+        {
+            var functionReference = FunctionReference.Create(task, FunctionLifetime.SingleUse);
+            NativeAPI.QueueTaskForFrame(tick, functionReference);
+            return functionReference.CompletionTask;
+        }
+        
+        /// <summary>
+        /// Queue a task to be executed on the specified tick.
+        /// See <see cref="TickCount"/> to retrieve the current tick.
+        /// <remarks>Does not execute if the server is hibernating.</remarks>
+        /// </summary>
+        public static void RunOnTick(int tick, Action task)
+        {
+            RunOnTickAsync(tick, task);
+        }
+
+        /// <summary>
+        /// <inheritdoc cref="NextFrame"/>
+        /// Returns Task that completes once the synchronous task has been completed.
+        /// </summary>
+        public static Task NextFrameAsync(Action task)
+        {
+            var functionReference = FunctionReference.Create(task, FunctionLifetime.SingleUse);
+            NativeAPI.QueueTaskForNextFrame(functionReference);
+            return functionReference.CompletionTask;
+        }

        /// <summary>
        /// Queue a task to be executed on the next game frame.
@@ -47,9 +106,18 @@ namespace CounterStrikeSharp.API
        /// </summary>
        public static void NextFrame(Action task)
        {
-            var functionReference = FunctionReference.Create(task);
-            functionReference.Lifetime = FunctionLifetime.SingleUse;
-            NativeAPI.QueueTaskForNextFrame(functionReference);
+            NextFrameAsync(task);
+        }
+        
+        /// <summary>
+        /// <inheritdoc cref="NextWorldUpdate"/>
+        /// Returns Task that completes once the synchronous task has been completed.
+        /// </summary>
+        public static Task NextWorldUpdateAsync(Action task)
+        {
+            var functionReference = FunctionReference.Create(task, FunctionLifetime.SingleUse);
+            NativeAPI.QueueTaskForNextWorldUpdate(functionReference);
+            return functionReference.CompletionTask;
        }
        
        /// <summary>
@@ -59,9 +127,7 @@ namespace CounterStrikeSharp.API
        /// <param name="task"></param>
        public static void NextWorldUpdate(Action task)
        {
-            var functionReference = FunctionReference.Create(task);
-            functionReference.Lifetime = FunctionLifetime.SingleUse;
-            NativeAPI.QueueTaskForNextWorldUpdate(functionReference);
+            NextWorldUpdateAsync(task);
        }

        public static void PrintToChatAll(string message)
--- a/managed/CounterStrikeSharp.SchemaGen/CounterStrikeSharp.SchemaGen.csproj
+++ b/managed/CounterStrikeSharp.SchemaGen/CounterStrikeSharp.SchemaGen.csproj
@@ -2,7 +2,7 @@

    <PropertyGroup>
        <OutputType>Exe</OutputType>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net8.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
--- a/managed/CounterStrikeSharp.SchemaGen/Schema/server.json
+++ b/managed/CounterStrikeSharp.SchemaGen/Schema/server.json
@@ -10654,13 +10654,6 @@
            "category": 0,
            "name": "bool"
          }
-        },
-        {
-          "name": "m_bDroppedFromDeath",
-          "type": {
-            "category": 0,
-            "name": "bool"
-          }
        }
      ],
      "parent": "CCSWeaponBase"
@@ -12803,6 +12796,13 @@
            "name": "CUtlVector< int32 >"
          }
        },
+        {
+          "name": "m_nSpawnPointsRandomSeed",
+          "type": {
+            "category": 0,
+            "name": "int32"
+          }
+        },
        {
          "name": "m_bFirstConnected",
          "type": {
@@ -13237,6 +13237,13 @@
            "name": "CUtlVector< SpawnPoint* >"
          }
        },
+        {
+          "name": "m_bRespawningAllRespawnablePlayers",
+          "type": {
+            "category": 0,
+            "name": "bool"
+          }
+        },
        {
          "name": "m_iNextCTSpawnPoint",
          "type": {
@@ -13244,6 +13251,13 @@
            "name": "int32"
          }
        },
+        {
+          "name": "m_flCTSpawnPointUsedTime",
+          "type": {
+            "category": 0,
+            "name": "float32"
+          }
+        },
        {
          "name": "m_iNextTerroristSpawnPoint",
          "type": {
@@ -13251,6 +13265,13 @@
            "name": "int32"
          }
        },
+        {
+          "name": "m_flTerroristSpawnPointUsedTime",
+          "type": {
+            "category": 0,
+            "name": "float32"
+          }
+        },
        {
          "name": "m_CTSpawnPoints",
          "type": {
@@ -13611,18 +13632,6 @@
            "name": "uint8"
          }
        },
-        {
-          "name": "m_nRoundStartTicks",
-          "type": {
-            "atomic": 2,
-            "category": 4,
-            "inner": {
-              "category": 0,
-              "name": "int32"
-            },
-            "name": "CUtlVector< int32 >"
-          }
-        },
        {
          "name": "m_flLastPerfSampleTime",
          "type": {
@@ -14294,6 +14303,34 @@
            "name": "CNetworkUtlVectorBase< EKillTypes_t >"
          }
        },
+        {
+          "name": "m_bMvpNoMusic",
+          "type": {
+            "category": 0,
+            "name": "bool"
+          }
+        },
+        {
+          "name": "m_eMvpReason",
+          "type": {
+            "category": 0,
+            "name": "int32"
+          }
+        },
+        {
+          "name": "m_iMusicKitID",
+          "type": {
+            "category": 0,
+            "name": "int32"
+          }
+        },
+        {
+          "name": "m_iMusicKitMVPs",
+          "type": {
+            "category": 0,
+            "name": "int32"
+          }
+        },
        {
          "name": "m_iMVPs",
          "type": {
@@ -15339,17 +15376,10 @@
          }
        },
        {
-          "name": "m_bInvalidSteamLogonDelayed",
+          "name": "m_flIdleTimeSinceLastAction",
          "type": {
            "category": 0,
-            "name": "bool"
-          }
-        },
-        {
-          "name": "m_flLastAction",
-          "type": {
-            "category": 5,
-            "name": "GameTime_t"
+            "name": "float32"
          }
        },
        {
@@ -42189,13 +42219,6 @@
            "name": "GameTime_t"
          }
        },
-        {
-          "name": "m_bPlantedAfterPickup",
-          "type": {
-            "category": 0,
-            "name": "bool"
-          }
-        },
        {
          "name": "m_angCatchUpToPlayerEye",
          "type": {
@@ -97606,8 +97629,12 @@
          "value": 15
        },
        {
-          "name": "PVAL_COUNT",
+          "name": "PVAL_PANORAMA_PANEL_HANDLE",
          "value": 16
+        },
+        {
+          "name": "PVAL_COUNT",
+          "value": 17
        }
      ]
    },
--- a/managed/CounterStrikeSharp.sln
+++ b/managed/CounterStrikeSharp.sln
@@ -34,6 +34,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WithVoiceOverrides", "..\ex
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WithFakeConvars", "..\examples\WithFakeConvars\WithFakeConvars.csproj", "{1309954E-FAF7-47A5-9FF9-C7263B33E4E3}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WithSharedTypes", "..\examples\WithSharedTypes\WithSharedTypes.csproj", "{4E5289B5-E81D-421C-B340-B98B6FFE09D1}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MySharedTypes.Contracts", "..\examples\MySharedTypes.Contracts\MySharedTypes.Contracts\MySharedTypes.Contracts.csproj", "{A37676EA-CF2F-424D-85A1-C359D07A679D}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WithSharedTypesConsumer", "..\examples\WithSharedTypesConsumer\WithSharedTypesConsumer.csproj", "{76AD7BB0-A096-4336-83E2-B32CAE4E9933}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -100,10 +106,22 @@ Global
 		{6FA3107D-42AF-42A0-BF51-2230D13268B5}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{6FA3107D-42AF-42A0-BF51-2230D13268B5}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{6FA3107D-42AF-42A0-BF51-2230D13268B5}.Release|Any CPU.Build.0 = Release|Any CPU
+		{4E5289B5-E81D-421C-B340-B98B6FFE09D1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{4E5289B5-E81D-421C-B340-B98B6FFE09D1}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{4E5289B5-E81D-421C-B340-B98B6FFE09D1}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{4E5289B5-E81D-421C-B340-B98B6FFE09D1}.Release|Any CPU.Build.0 = Release|Any CPU
 		{1309954E-FAF7-47A5-9FF9-C7263B33E4E3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{1309954E-FAF7-47A5-9FF9-C7263B33E4E3}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{1309954E-FAF7-47A5-9FF9-C7263B33E4E3}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{1309954E-FAF7-47A5-9FF9-C7263B33E4E3}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A37676EA-CF2F-424D-85A1-C359D07A679D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A37676EA-CF2F-424D-85A1-C359D07A679D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A37676EA-CF2F-424D-85A1-C359D07A679D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A37676EA-CF2F-424D-85A1-C359D07A679D}.Release|Any CPU.Build.0 = Release|Any CPU
+		{76AD7BB0-A096-4336-83E2-B32CAE4E9933}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{76AD7BB0-A096-4336-83E2-B32CAE4E9933}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{76AD7BB0-A096-4336-83E2-B32CAE4E9933}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{76AD7BB0-A096-4336-83E2-B32CAE4E9933}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{57E64289-5D69-4AA1-BEF0-D0D96A55EE8F} = {7DF99C35-881D-4FF2-B1C9-246BD3DECB9A}
@@ -117,6 +135,9 @@ Global
 		{31EABE0B-871F-497B-BF36-37FFC6FAD15F} = {7DF99C35-881D-4FF2-B1C9-246BD3DECB9A}
 		{BB44E08E-CCA8-4E22-A132-11B2F69D1890} = {7DF99C35-881D-4FF2-B1C9-246BD3DECB9A}
 		{6FA3107D-42AF-42A0-BF51-2230D13268B5} = {7DF99C35-881D-4FF2-B1C9-246BD3DECB9A}
+		{4E5289B5-E81D-421C-B340-B98B6FFE09D1} = {7DF99C35-881D-4FF2-B1C9-246BD3DECB9A}
 		{1309954E-FAF7-47A5-9FF9-C7263B33E4E3} = {7DF99C35-881D-4FF2-B1C9-246BD3DECB9A}
+		{A37676EA-CF2F-424D-85A1-C359D07A679D} = {7DF99C35-881D-4FF2-B1C9-246BD3DECB9A}
+		{76AD7BB0-A096-4336-83E2-B32CAE4E9933} = {7DF99C35-881D-4FF2-B1C9-246BD3DECB9A}
 	EndGlobalSection
 EndGlobal
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Michael Wilson	ad6e1ca2e2	chore: bump hl2sdk (#408 )	2024-04-11 18:15:50 +10:00
Michael Wilson	2564ef9f39	fix: fix startup server listener	2024-04-11 16:14:16 +10:00
Michael Wilson	83a341d3cf	feat: expose TargetTypeMap	2024-04-11 15:34:01 +10:00
Michael Wilson	534fc42444	fix: bad commit	2024-04-11 14:26:21 +10:00
Michael Wilson	41355d05fa	docs: add more comments to base plugin	2024-04-11 14:20:24 +10:00
luxury fabka	d9da15be83	Add teleport overloads (#399 ) Co-authored-by: Michael Wilson <roflmuffin@users.noreply.github.com>	2024-04-11 00:48:55 +00:00
B3none	75e2f6e8aa	[no ci] Rename ACKNOWLEDGEMENTS to ACKNOWLEDGEMENTS.md (#401 )	2024-04-10 16:34:15 +10:00
Michael Wilson	37b34e1d41	[no ci] add basic contributing guide	2024-04-08 10:02:18 +10:00
WidovV	5ce04649fd	Add CenterHtmlMenu button colors (#398 )	2024-04-06 21:43:38 +10:00
Michael Wilson	7b7202fe8a	[no ci] Update README.md	2024-04-05 11:54:53 +10:00
Michael Wilson	cadb817ed2	fix: mark center html menu constructor as obsolete, throw error (#396 )	2024-04-04 09:33:22 +10:00
luxury fabka	211516cce5	added `Open` method to each menu type (#385 ) Co-authored-by: Michael Wilson <roflmuffin@users.noreply.github.com> Co-authored-by: Roflmuffin <shortguy014@gmail.com>	2024-04-01 18:04:12 +10:00
Roflmuffin	ab211a42e6	[skip ci] chore: update ApiCompat to v202, disable suppression file	2024-03-26 12:46:42 +10:00
Roflmuffin	696ecadee4	fix: bad vector math	2024-03-26 12:16:53 +10:00
Roflmuffin	e4d598dba8	fix: main version number	2024-03-25 17:15:31 +10:00
Michael Wilson	5c67d88844	feat: improve version stamping (#389 )	2024-03-25 17:11:16 +10:00
Michael Wilson	9d8b6beae6	.NET8 Upgrade (#261 ) Co-authored-by: Frederik St-Onge <frederik.stonge@gmail.com> Co-authored-by: B3none <24966460+B3none@users.noreply.github.com>	2024-03-25 14:16:32 +10:00
ipsvn	39604b7ad7	Fix backwards compatibility in DynamicHook (#388 )	2024-03-22 23:04:09 +10:00
luxury fabka	1b1f1d04dd	minor menu changes (#373 ) Co-authored-by: Michael Wilson <roflmuffin@users.noreply.github.com> Co-authored-by: Roflmuffin <shortguy014@gmail.com>	2024-03-18 05:00:31 +00:00
Ian Lucas	dbc348c1bf	Add `RemoveAll` method to `NetworkedVector` class (#380 )	2024-03-18 14:56:29 +10:00
Michael Wilson	d295589c44	fix: update collision groups (#376 )	2024-03-13 16:10:42 +10:00
Michael Wilson	16767fd494	feat: add `Server.RunOnTick` method which allows tick scheduling (#374 )	2024-03-11 23:08:54 +10:00
roflmuffin	36a97bfffd	fix: disable autoload plugin but allow shared library loading	2024-03-09 15:29:45 +10:00
roflmuffin	178f7472c6	feat: add `PluginAutoLoadEnabled` config option closes #370	2024-03-09 14:29:43 +10:00
luxury fabka	cba5144bbf	remove unused arguments (#334 ) Co-authored-by: Michael Wilson <roflmuffin@users.noreply.github.com>	2024-03-08 05:08:33 +00:00
roflmuffin	0de951cb6f	fix: allows game events to be freed, frees event in print to center html closes #346	2024-03-08 10:39:59 +10:00
Michael Wilson	c3d44a87bc	feat: use concurrent queue for next frame & world update tasks (#365 )	2024-03-06 21:08:22 +10:00
B3none	bd3c0c76e3	[no ci] Update minimum api version for shared api docs (#364 )	2024-03-06 15:42:34 +10:00
Yarukon	656c0e3a84	Fix TerminateRound params (#363 )	2024-03-04 10:59:02 +00:00
Michael Wilson	40c842149c	fix: add error handling to `OnAllPluginsLoaded`	2024-03-04 17:21:50 +10:00
roflmuffin	64d1c0a9f4	chore: remove erroneous log	2024-03-04 16:56:49 +10:00
roflmuffin	a6de51c444	fix: use concurrent dictionary for function reference	2024-03-04 13:41:18 +10:00
roflmuffin	2535ac0575	feat: add assembly name lazy loading of shared libraries	2024-03-04 12:15:37 +10:00
Michael Wilson	bc61323315	chore: migrate to protobufs submodule (#362 )	2024-03-04 10:48:52 +10:00
roflmuffin	241817b7f2	feat: update game events dump from Feb 14 update	2024-03-04 10:34:58 +10:00
BuSheeZy	fbcdce34fc	fix: allow empty overrides to skip checks (#357 ) Co-authored-by: Michael Wilson <roflmuffin@users.noreply.github.com>	2024-03-04 00:13:17 +00:00
Michael Wilson	daf0d25f36	Shared Plugin APIs/Capabilities (#253 ) Co-authored-by: B3none <ablackham2000@gmail.com> Co-authored-by: B3none <24966460+B3none@users.noreply.github.com>	2024-03-04 09:45:34 +10:00
Yarukon	12485be29f	Adding the proper way to do resource precache (#358 )	2024-03-02 15:10:37 +10:00
Roflmuffin	983d91491d	fix: update gamedata	2024-02-29 12:01:01 +10:00
BuSheeZy	71507b1e25	fix: allow using an empty flag array in overrides (#351 ) Co-authored-by: Ryan Bucshon <busheezy@users.noreply.github.com> Co-authored-by: Michael Wilson <roflmuffin@users.noreply.github.com>	2024-02-29 01:35:21 +00:00
B3none	cfe14b35fe	[no ci] Bump the min api version in the fake convars example plugin (#350 )	2024-02-28 15:08:23 +10:00
				`@@ -0,0 +1 @@`
				`This folder should contain any shared APIs, in the same DLL structure as the plugins folder (MySharedApi/MySharedApi.dll)`