release: v1.0.322

Co-authored-by: Michael Wilson <roflmuffin@users.noreply.github.com>
Co-authored-by: root <root@ns3203586.ip-146-59-53.eu>

.clang-format

@@ -38,7 +38,7 @@ BraceWrapping:
   SplitEmptyNamespace: true
 
 PointerAlignment: Left
-SortIncludes: CaseSensitive
+SortIncludes: Never
 IncludeBlocks: Regroup
 IncludeCategories:
   # External headers in <> with extension or /

.devcontainer/linux/devcontainer.json

@@ -1,11 +1,20 @@
 {
   "name": "SteamRT Sniper SDK",
   "image": "registry.gitlab.steamos.cloud/steamrt/sniper/sdk:latest",
-  "customizations": { 
+  "updateContentCommand": "git submodule update --init --recursive",
+  "postCreateCommand": "cmake -S . -B build -DCMAKE_BUILD_TYPE=RelWithDebInfo && cmake --build build -j$(nproc)",
+  "customizations": {
     "vscode": {
       "extensions": [
-        "ms-vscode.cpptools"
+        "ms-dotnettools.csdevkit",
+        "ms-vscode.cpptools",
+        "ms-vscode.cpptools-extension-pack",
+        "GitHub.copilot",
+        "jeff-hykin.better-cpp-syntax"
       ]
     }
+  },
+  "features": {
+    "ghcr.io/devcontainers/features/dotnet": "8.0"
   }
-}
+}

.github/workflows/build-and-publish.yml

@@ -0,0 +1,270 @@
+name: Build & Publish
+
+env:
+  BUILD_TYPE: Release
+
+# Remove default permissions of GITHUB_TOKEN for security
+# https://docs.github.com/en/actions/using-jobs/assigning-permissions-to-jobs
+permissions: {}
+
+on:
+  push:
+    paths-ignore:
+      - "docfx/**"
+    branches: ["main"]
+    tags:
+      - "v*"
+  pull_request:
+    branches: ["main"]
+
+jobs:
+  setup:
+    runs-on: ubuntu-latest
+    outputs:
+      gitversion_semver: ${{ steps.gitversion.outputs.semVer }}
+      gitversion_fullsemver: ${{ steps.gitversion.outputs.fullSemVer }}
+      gitversion_assemblysemver: ${{ steps.gitversion.outputs.assemblySemVer }}
+      gitversion_informationalversion: ${{ steps.gitversion.outputs.informationalVersion }}
+    steps:
+    - name: Install GitVersion
+      uses: gittools/actions/gitversion/setup@v1
+      with:
+        versionSpec: 6.0.x
+
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+
+    - name: Execute GitVersion
+      id: gitversion
+      uses: gittools/actions/gitversion/execute@v1
+      with:
+        useConfigFile: true
+
+  build_windows:
+    needs: setup
+    runs-on: windows-latest
+    steps:
+      - name: Prepare env
+        shell: bash
+        run: | 
+          echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV
+          echo "SEMVER=${{ needs.setup.outputs.gitversion_semver }}" >> $GITHUB_ENV
+
+      - name: Visual Studio environment
+        shell: cmd
+        run: |
+          :: See https://github.com/microsoft/vswhere/wiki/Find-VC
+          for /f "usebackq delims=*" %%i in (`vswhere -latest -property installationPath`) do (
+            call "%%i"\Common7\Tools\vsdevcmd.bat -arch=x64 -host_arch=x64
+          )
+
+          :: Loop over all environment variables and make them global.
+          for /f "delims== tokens=1,2" %%a in ('set') do (
+            echo>>"%GITHUB_ENV%" %%a=%%b
+          )
+
+      - uses: actions/checkout@v4
+        with:
+          submodules: "recursive"
+
+      - name: Build
+        run: |
+          mkdir -p build
+          cd build
+          cmake -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} ..
+          cmake --build . --config ${{env.BUILD_TYPE}} -- /m:16
+
+      - name: Clean build directory
+        run: |
+          mkdir -p build/addons/counterstrikesharp/bin/win64
+          mv build/${{env.BUILD_TYPE}}/*.dll build/addons/counterstrikesharp/bin/win64
+          mkdir build/output/
+          mv build/addons build/output
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: counterstrikesharp-windows-${{ needs.setup.outputs.gitversion_semver }}
+          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:
+      image: registry.gitlab.steamos.cloud/steamrt/sniper/sdk:latest
+    steps:
+      - name: Prepare env
+        shell: bash
+        run: |
+          echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV
+          echo "SEMVER=${{ needs.setup.outputs.gitversion_semver }}" >> $GITHUB_ENV
+
+      - uses: actions/checkout@v4
+        with:
+          submodules: "recursive"
+
+      - name: Build
+        run: |
+          mkdir -p build
+          cd build
+          cmake -G Ninja -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} ..
+          cmake --build . --config ${{env.BUILD_TYPE}} -- -j16
+
+      - name: Clean build directory
+        run: |
+          mkdir build/output/
+          mv build/addons build/output
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: counterstrikesharp-linux-${{ needs.setup.outputs.gitversion_semver }}
+          path: build/output/
+
+  build_managed:
+    needs: setup
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    steps:
+      - name: Prepare env
+        shell: bash
+        run: echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV
+
+      # We don't need expensive submodules for the managed side.
+      - uses: actions/checkout@v4
+
+      - name: Build runtime v${{ needs.setup.outputs.gitversion_semver }}
+        uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: "8.0.x"
+
+      - name: Install dependencies
+        run: dotnet restore managed/CounterStrikeSharp.sln
+
+      - name: Run tests
+        run: dotnet test --logger trx --results-directory "TestResults-${{ needs.setup.outputs.gitversion_semver }}" managed/CounterStrikeSharp.API.Tests/CounterStrikeSharp.API.Tests.csproj
+
+      - name: Upload dotnet test results
+        uses: actions/upload-artifact@v4
+        with:
+          name: test-results-${{ needs.setup.outputs.gitversion_semver }}
+          path: TestResults-${{ needs.setup.outputs.gitversion_semver }}
+        if: ${{ always() }}
+
+      - name: Publish artifacts
+        run: |
+          dotnet publish -c Release \
+          /p:Version=${{ needs.setup.outputs.gitversion_semver }} \
+          /p:AssemblyVersion=${{ needs.setup.outputs.gitversion_assemblySemver }} \
+          /p:InformationalVersion=${{ needs.setup.outputs.gitversion_informationalversion }} \
+          managed/CounterStrikeSharp.API
+          
+          dotnet pack -c Release \
+          /p:Version=${{ needs.setup.outputs.gitversion_semver }} \
+          /p:AssemblyVersion=${{ needs.setup.outputs.gitversion_assemblySemver }} \
+          /p:InformationalVersion=${{ needs.setup.outputs.gitversion_informationalversion }} \
+          managed/CounterStrikeSharp.API
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: counterstrikesharp-api-${{ needs.setup.outputs.gitversion_semver }}
+          path: managed/CounterStrikeSharp.API/bin/Release
+
+  publish:
+    if: ${{ github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v') && github.repository == 'roflmuffin/CounterStrikeSharp' }}
+    permissions:
+      contents: write
+    needs: ["setup", "build_linux", "build_windows", "build_managed"]
+    runs-on: ubuntu-latest
+    steps:
+      - name: Prepare env
+        shell: bash
+        run: echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV
+
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: counterstrikesharp-windows-${{ needs.setup.outputs.gitversion_semver }}
+          path: build/windows
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: counterstrikesharp-linux-${{ needs.setup.outputs.gitversion_semver }}
+          path: build/linux
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: counterstrikesharp-api-${{ needs.setup.outputs.gitversion_semver }}
+          path: build/api
+
+      # TODO: This stuff should really be in a matrix
+      - name: Add API to Artifacts
+        run: |
+          mkdir -p build/linux/addons/counterstrikesharp/api
+          mkdir -p 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-linux-${{ needs.setup.outputs.gitversion_semver }}.zip *)
+          (cd build/windows && zip -qq -r ../../counterstrikesharp-windows-${{ needs.setup.outputs.gitversion_semver }}.zip *)
+
+      - name: Add dotnet runtime
+        run: |
+          mkdir -p build/linux/addons/counterstrikesharp/dotnet
+          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
+
+          mkdir -p build/windows/addons/counterstrikesharp/dotnet
+          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-linux-${{ needs.setup.outputs.gitversion_semver }}.zip *)
+          (cd build/windows && zip -qq -r ../../counterstrikesharp-with-runtime-windows-${{ needs.setup.outputs.gitversion_semver }}.zip *)
+      
+      - name: Generate a changelog
+        uses: orhun/git-cliff-action@v4
+        id: git-cliff
+        with:
+            config: cliff.toml
+            args: --current -s footer
+
+      - name: Release
+        id: release
+        uses: softprops/action-gh-release@v1
+        with:
+          append_body: true
+          body: |
+            ${{ steps.git-cliff.outputs.content }}
+
+            Please refer to [CHANGELOG.md](https://github.com/roflmuffin/CounterStrikeSharp/blob/${{ github.ref_name }}/CHANGELOG.md) for details.
+          files: |
+            counterstrikesharp-windows-${{ needs.setup.outputs.gitversion_semver }}.zip
+            counterstrikesharp-with-runtime-windows-${{ needs.setup.outputs.gitversion_semver }}.zip
+            counterstrikesharp-linux-${{ needs.setup.outputs.gitversion_semver }}.zip
+            counterstrikesharp-with-runtime-linux-${{ needs.setup.outputs.gitversion_semver }}.zip
+
+      - name: Publish NuGet package
+        run: |
+          dotnet nuget push build/api/CounterStrikeSharp.API.${{ needs.setup.outputs.gitversion_semver }}.nupkg --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate
+          dotnet nuget push build/api/CounterStrikeSharp.API.${{ needs.setup.outputs.gitversion_semver }}.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.setup.outputs.gitversion_semver }}](${{ steps.release.outputs.url }})
+
+            ${{ steps.git-cliff.outputs.content }}
+
+            Please refer to [CHANGELOG.md](https://github.com/roflmuffin/CounterStrikeSharp/blob/${{ github.ref_name }}/CHANGELOG.md) for details.

.github/workflows/cmake-single-platform.yml

@@ -1,248 +0,0 @@
-name: Build & Publish
-
-on:
-  push:
-    paths-ignore:
-      - "docfx/**"
-    branches: ["main", "dev"]
-  pull_request:
-    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: |
-          :: See https://github.com/microsoft/vswhere/wiki/Find-VC
-          for /f "usebackq delims=*" %%i in (`vswhere -latest -property installationPath`) do (
-            call "%%i"\Common7\Tools\vsdevcmd.bat -arch=x64 -host_arch=x64
-          )
-
-          :: Loop over all environment variables and make them global.
-          for /f "delims== tokens=1,2" %%a in ('set') do (
-            echo>>"%GITHUB_ENV%" %%a=%%b
-          )
-
-      - uses: actions/checkout@v3
-        with:
-          submodules: "recursive"
-
-      - name: Build
-        run: |
-          mkdir -p build
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} ..
-          cmake --build . --config ${{env.BUILD_TYPE}} -- /m:16
-
-      - name: Clean build directory
-        run: |
-          mkdir -p build/addons/counterstrikesharp/bin/win64
-          mv build/${{env.BUILD_TYPE}}/*.dll build/addons/counterstrikesharp/bin/win64
-          mkdir build/output/
-          mv build/addons build/output
-
-      - uses: actions/upload-artifact@v3
-        with:
-          name: counterstrikesharp-build-windows-${{ env.GITHUB_SHA_SHORT }}
-          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:
-      image: registry.gitlab.steamos.cloud/steamrt/sniper/sdk: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
-
-      - uses: actions/checkout@v3
-        with:
-          submodules: "recursive"
-
-      - name: Build
-        run: |
-          mkdir -p build
-          cd build
-          cmake -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}} ..
-          cmake --build . --config ${{env.BUILD_TYPE}} -- -j16
-
-      - name: Clean build directory
-        run: |
-          mkdir build/output/
-          mv build/addons build/output
-
-      - uses: actions/upload-artifact@v3
-        with:
-          name: counterstrikesharp-build-linux-${{ env.GITHUB_SHA_SHORT }}
-          path: build/output/
-
-  build_managed:
-    needs: setup
-    permissions:
-      contents: write
-    runs-on: ubuntu-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
-
-      # We don't need expensive submodules for the managed side.
-      - uses: actions/checkout@v3
-
-      - name: Build runtime v${{ env.BUILD_NUMBER }}
-        uses: actions/setup-dotnet@v3
-        with:
-          dotnet-version: "8.0.x"
-
-      - name: Install dependencies
-        run: dotnet restore managed/CounterStrikeSharp.sln
-
-      - name: Run tests
-        run: dotnet test --logger trx --results-directory "TestResults-${{ env.GITHUB_SHA_SHORT }}" managed/CounterStrikeSharp.API.Tests/CounterStrikeSharp.API.Tests.csproj
-
-      - name: Upload dotnet test results
-        uses: actions/upload-artifact@v3
-        with:
-          name: test-results-${{ env.GITHUB_SHA_SHORT }}
-          path: TestResults-${{ env.GITHUB_SHA_SHORT }}
-        if: ${{ always() }}
-
-      - 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
-
-      - uses: actions/upload-artifact@v3
-        with:
-          name: counterstrikesharp-build-api-${{ env.GITHUB_SHA_SHORT }}
-          path: managed/CounterStrikeSharp.API/bin/Release
-
-  publish:
-    if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }}
-    permissions:
-      contents: write
-    needs: ["setup", "build_linux", "build_windows", "build_managed"]
-    runs-on: ubuntu-latest
-    steps:
-      - name: Prepare env
-        shell: bash
-        run: echo "GITHUB_SHA_SHORT=${GITHUB_SHA::7}" >> $GITHUB_ENV
-
-      - uses: actions/download-artifact@v3
-        with:
-          name: counterstrikesharp-build-windows-${{ env.GITHUB_SHA_SHORT }}
-          path: build/windows
-
-      - uses: actions/download-artifact@v3
-        with:
-          name: counterstrikesharp-build-linux-${{ env.GITHUB_SHA_SHORT }}
-          path: build/linux
-
-      - uses: actions/download-artifact@v3
-        with:
-          name: counterstrikesharp-build-api-${{ env.GITHUB_SHA_SHORT }}
-          path: build/api
-
-      # TODO: This stuff should really be in a matrix
-      - name: Add API to Artifacts
-        run: |
-          mkdir -p build/linux/addons/counterstrikesharp/api
-          mkdir -p 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.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/c1371dc2-eed2-47be-9af3-ae060dbe3c7d/bd509e0a87629764ed47608466d183e6/aspnetcore-runtime-8.0.3-linux-x64.tar.gz \
-          | tar xvz -C build/linux/addons/counterstrikesharp/dotnet
-
-          mkdir -p build/windows/addons/counterstrikesharp/dotnet
-          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.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.setup.outputs.buildnumber }}
-          files: |
-            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.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.setup.outputs.buildnumber }}) at ${{ steps.release.outputs.url }}"

.github/workflows/lint-code.yaml

@@ -0,0 +1,25 @@
+name: Code format checks
+
+on:
+  pull_request:
+    paths:
+      - '.github/workflows/**'
+      - 'src/**'
+      - '.clang-format'
+  push:
+    paths:
+      - '.github/workflows/**'
+      - 'src/**'
+      - '.clang-format'
+
+jobs:
+  lint:
+    name: Lint code with clang-format
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: jidicula/clang-format-action@4726374d1aa3c6aecf132e5197e498979588ebc8
+        with:
+          clang-format-version: '20'
+          check-path: 'src'
+          exclude-regex: '(sdk|\.proto)'

.github/workflows/publish-docs.yml

@@ -2,6 +2,7 @@ on:
   push:
     branches:
       - main
+  workflow_dispatch:  
 
 permissions:
   contents: read
@@ -22,10 +23,10 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Dotnet Setup
-        uses: actions/setup-dotnet@v3
+        uses: actions/setup-dotnet@v4
         with:
           dotnet-version: 8.x
 
@@ -34,13 +35,13 @@ jobs:
       - run: docfx docfx/docfx.json
 
       - name: Setup Pages
-        uses: actions/configure-pages@v3
+        uses: actions/configure-pages@v4
 
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v2
+        uses: actions/upload-pages-artifact@v3
         with:
           path: "docfx/_site"
 
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v2
+        uses: actions/deploy-pages@v4

CMakeLists.txt

@@ -83,6 +83,9 @@ set(SOURCE_FILES
     src/scripting/natives/natives_schema.cpp
     src/scripting/natives/natives_entities.cpp
     src/scripting/natives/natives_voice.cpp
+    src/scripting/natives/natives_metamod.cpp
+    src/scripting/natives/natives_cvariant.cpp
+    src/scripting/natives/natives_cutil.cpp
     src/core/managers/entity_manager.cpp
     src/core/managers/entity_manager.h
     src/core/managers/chat_manager.cpp

Dockerfile

@@ -0,0 +1,17 @@
+FROM registry.gitlab.steamos.cloud/steamrt/sniper/sdk:latest
+
+WORKDIR /workspace
+
+RUN apt update && apt install -y \
+    clang-16 \
+    cmake \
+    ninja-build \
+    git \
+    zlib1g-dev \
+    libssl-dev \
+    libprotobuf-dev \
+    protobuf-compiler \
+    pkg-config \
+    curl && \
+    ln -sf /usr/bin/clang-16 /usr/bin/clang && \
+    ln -sf /usr/bin/clang++-16 /usr/bin/clang++

GitVersion.yml

@@ -0,0 +1 @@
+workflow: GitHubFlow/v1

cliff.toml

@@ -0,0 +1,85 @@
+# git-cliff ~ configuration file
+# https://git-cliff.org/docs/configuration
+
+[remote.github]
+owner = "roflmuffin"
+repo = "CounterStrikeSharp"
+# token = ""
+
+[changelog]
+# A Tera template to be rendered for each release in the changelog.
+# See https://keats.github.io/tera/docs/#introduction
+body = """
+## What's Changed
+
+{%- if version %} in {{ version }}{%- endif -%}
+{% for commit in commits %}
+  * {{ commit.message | split(pat="\n") | first | trim }}\
+    {% if commit.remote.username and commit.remote.username != remote.github.owner %} by \
+      [@{{ commit.remote.username }}](https://github.com/{{ commit.remote.username }}) \
+    {%- endif -%}
+    {% if commit.remote.pr_number %} in \
+      [#{{ commit.remote.pr_number }}]({{ self::remote_url() }}/pull/{{ commit.remote.pr_number }})\
+    {%- endif %}
+    {%- if commit.id %} ([{{ commit.id | truncate(length=7, end="") }}]({{ self::remote_url()}}/commit/{{ commit.id }})){%- endif -%}
+    
+{%- endfor -%}
+
+{%- if github -%}
+{% if github.contributors | filter(attribute="is_first_time", value=true) | length != 0 %}
+  {% raw %}\n{% endraw -%}
+  ## New Contributors
+{%- endif %}\
+{% for contributor in github.contributors | filter(attribute="is_first_time", value=true) %}
+  * [@{{ contributor.username }}](https://github.com/{{ contributor.username }}) made their first contribution
+    {%- if contributor.pr_number %} in \
+      [#{{ contributor.pr_number }}]({{ self::remote_url() }}/pull/{{ contributor.pr_number }}) \
+    {%- endif %}
+{%- endfor -%}
+{%- endif -%}
+
+{% if version %}
+    
+{% else -%}
+  {% raw %}\n{% endraw %}
+{% endif %}
+
+{%- macro remote_url() -%}
+  https://github.com/{{ remote.github.owner }}/{{ remote.github.repo }}
+{%- endmacro -%}
+"""
+# Remove leading and trailing whitespaces from the changelog's body.
+trim = true
+# A Tera template to be rendered as the changelog's footer.
+# See https://keats.github.io/tera/docs/#introduction
+footer = """
+<!-- generated by git-cliff -->
+"""
+# An array of regex based postprocessors to modify the changelog.
+# Replace the placeholder `<REPO>` with a URL.
+postprocessors = []
+
+[git]
+# Parse commits according to the conventional commits specification.
+# See https://www.conventionalcommits.org
+conventional_commits = false
+# Exclude commits that do not match the conventional commits specification.
+filter_unconventional = true
+# Split commits on newlines, treating each line as an individual commit.
+split_commits = false
+# An array of regex based parsers to modify commit messages prior to further processing.
+commit_preprocessors = [
+    { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "" },
+    { pattern = '\[no ci\]', replace = "" }
+  ]
+commit_parsers = [
+    { message = "^release:", skip = true }
+]
+# Exclude commits that are not matched by any commit parser.
+filter_commits = false
+# Order releases topologically instead of chronologically.
+topo_order = false
+# Order of commits in each group/release within the changelog.
+# Allowed values: newest, oldest
+sort_commits = "newest"
+tag_pattern = "v[0-9]+\\.[0-9]+\\.[0-9]+"

configs/addons/counterstrikesharp/gamedata/gamedata.json

@@ -56,8 +56,8 @@
   "GiveNamedItem": {
     "signatures": {
       "library": "server",
-      "windows": "48 89 5C 24 ? 48 89 74 24 ? 55 57 41 ? 41 ? 41 ? 48 ? ? ? ? 48 ? ? ? ? ? ? 4D ? ? 48",
-      "linux": "55 48 89 E5 41 57 41 56 49 89 D6 41 55 49 89 CD 41 54 49 89 F4 53 48 89 FB 48 8D 3D"
+      "windows": "48 89 5C 24 ? 48 89 74 24 ? 55 57 41 55 41 56 41 57 48 8D AC 24",
+      "linux": "55 48 89 E5 41 57 41 56 49 89 F6 41 55 4D 89 C5 41 54 49 89 D4"
     }
   },
   "UTIL_Remove": {
@@ -71,7 +71,7 @@
     "signatures": {
       "library": "server",
       "windows": "44 89 4C 24 20 44 88 44 24 18",
-      "linux": "55 48 89 E5 41 57 41 56 49 89 F6 41 55 4D 89 C5"
+      "linux": "55 48 89 E5 41 57 41 56 49 89 F6 41 55 4D 89 C5 41 54 49 89 FC"
     }
   },
   "CBaseModelEntity_SetModel": {
@@ -84,15 +84,15 @@
   "CCSPlayer_WeaponServices_CanUse": {
     "signatures": {
       "library": "server",
-      "windows": "48 89 5C 24 ? 48 89 6C 24 ? 56 57 41 56 48 83 EC 30 48 8B 01",
-      "linux": "55 48 8D 15 ? ? ? ? 48 89 E5 41 55 49 89 FD 41 54 49 89 F4"
+      "windows": "48 89 5C 24 ? 48 89 6C 24 ? 48 89 74 24 ? 57 48 83 EC ? 48 8B 01 48 8B F2",
+      "linux": "55 48 8D 15 ? ? ? ? 48 89 E5 41 55 49 89 F5 41 54 49 89 FC 53 48 83 EC ? 48 8B 07 48 8B 80 ? ? ? ? 48 39 D0 0F 85 ? ? ? ? 80 BF"
     }
   },
   "CCSPlayer_ItemServices_CanAcquire": {
     "signatures": {
       "library": "server",
-      "windows": "48 8B C4 44 89 40 ? 48 89 50 ? 48 89 48",
-      "linux": "55 48 89 E5 41 57 41 56 41 55 49 89 CD 41 54 53 48 83 EC"
+      "windows": "44 89 44 24 ? 48 89 54 24 ? 48 89 4C 24 ? 55 56 57 41 54 41 55 41 56 41 57 48 8B EC",
+      "linux": "55 48 89 E5 41 57 41 56 48 8D 45 ? 41 55 41 54 53 48 89 CB"
     }
   },
   "GetCSWeaponDataFromKey": {
@@ -133,6 +133,12 @@
       "linux": "55 48 89 E5 41 57 41 56 41 55 41 54 49 89 FC 53 48 81 EC 88 00 00 00 48 8D 05 ? ? ? ?"
     }
   },
+  "CCSGameRules_FindPickerEntity": {
+    "offsets": {
+      "windows": 27,
+      "linux": 28
+    }
+  },
   "UTIL_CreateEntityByName": {
     "signatures": {
       "library": "server",
@@ -147,6 +153,13 @@
       "linux": "48 85 FF 74 ? 55 48 89 E5 41 56"
     }
   },
+  "CBaseEntity_EmitSoundFilter": {
+    "signatures": {
+      "library": "server",
+      "windows": "48 89 5C 24 08 48 89 6C 24 10 48 89 74 24 18 48 89 7C 24 20 41 56 48 83 EC 30 48 8B EA",
+      "linux": "55 48 89 E5 41 56 49 89 D6 41 55 41 89 F5 41 54 48"
+    }
+  },
   "CEntityInstance_AcceptInput": {
     "signatures": {
       "library": "server",
@@ -170,8 +183,8 @@
   },
   "CBasePlayerPawn_CommitSuicide": {
     "offsets": {
-      "windows": 377,
-      "linux": 377
+      "windows": 380,
+      "linux": 380
     }
   },
   "CBasePlayerPawn_RemovePlayerItem": {
@@ -253,5 +266,18 @@
       "windows": 2,
       "linux": 0
     }
+  },
+  "CheckTransmit": {
+    "signatures": {
+      "library": "server",
+      "windows": "48 8B C4 4C 89 48 ? 44 89 40 ? 48 89 50 ? 48 89 48 ? 55",
+      "linux": "55 48 89 E5 41 57 49 89 CF 41 56 41 55 41 54 53 48 81 EC"
+    }
+  },
+  "CheckTransmitPlayerSlot": {
+    "offsets": {
+      "windows": 584,
+      "linux": 584
+    }
   }
 }

docfx/docs/features/game-events.md

@@ -54,6 +54,9 @@ The specific subclass of `GameEvent` will provide strongly typed parameters from
 
 These event properties are mutable so you can update them as normal and they will update in the event instance.
 
+> [!CAUTION]
+> `GameEvent` instances and their properties will cease to exist after the event listener function is called, which means that you will encounter errors when accessing properties in timers and functions like `Server.NextFrame()`. You should store the value of properties in variables before calling functions like `Server.NextFrame()` so you can read the data safely.
+
 ## Preventing Broadcast
 
 You can modify a game event so that it does not get broadcast to clients by modifying the `bool info.DontBroadcast` property. e.g.

docfx/docs/guides/auto-build-and-deploy.md

@@ -0,0 +1,99 @@
+---
+title: Automatically build/deploy your changes
+description: Automatically build and deploy plugin changes to a remote development server as you work.
+---
+
+# Automatically build and deploy your changes
+
+<sup>Adapted from the
+[original guide](https://github.com/uFloppyDisk/create-cssharp-plugin/blob/c8fca43f86a61a5e874624f2f3ed39c5271c9a55/templates/standard-plugin/docs/auto-live-hot-reloading.md).
+</sup>
+
+During development of your plugin, you may find yourself repeating a workflow
+similar to the following:
+1. Make a change to your plugin
+2. Run your build task (ex. `dotnet build`)
+3. Upload plugin DLLs to your server using an FTP client
+4. Alt-tab to the game
+5. Test your changes
+6. Repeat
+
+Iterating on your plugin this way is painfully slow and impacts your productivity.
+Below, you will find a guide and recommendations on how to setup your dev environment
+to watch for file changes and automatically update plugin files on your server as you work.
+By following this guide, your new workflow should look like this:
+1. Make a change to your plugin
+2. Alt-tab to the game
+3. Test your changes
+4. Repeat
+
+> [!CAUTION]
+> Exercise caution when developing your plugin while using this workflow.
+> Build time errors are mostly caught by .NET SDK before files are committed
+> but incomplete implementation may lead to issues such as server crashes.
+> Avoid using this workflow on a production server meant for players.
+
+## Setup
+
+#### 1. Build plugin on file changes
+
+The `dotnet` CLI, included with the .NET SDK, offers a convenient command for
+automatically watching for source file changes. If you have access to the `dotnet`
+CLI, run the following command to start watching your source code.
+```shell
+dotnet watch build --project path/to/projectName.csproj
+```
+<sup>By default, `dotnet watch` executes the `dotnet run` command on file changes
+so specifying `build` as the first argument is required.</sup>
+
+Your plugin will now build automatically on file change. By default, your builds
+should be placed in `bin/<config>/<framework>` in the same directory as your `.csproj`.
+
+```txt
+projectDirectory
+├── projectName.csproj
+├── bin
+│   └── Debug
+│       └── net8.0
+│           └── PLUGIN BUILDS HERE
+```
+
+> [!TIP]
+> You can have your plugin build to a more convenient location by setting the
+> `<OutDir>` build property in your `.csproj` file.
+> Example: `<OutDir>./build/$(MSBuildProjectName)</OutDir>`
+
+
+#### 2. Setup automatic uploads
+
+##### Using WinSCP (Windows only)
+Once connected to your server:
+1. Go to the `Commands` tab at the top of the WinSCP window
+and click `Keep Remote Directory up to Date`.
+2. Select the plugin build directory containing your DLLs.
+3. Select the plugin destination.
+(`csgo/addons/counterstrikesharp/plugins/<projectName>`)
+4. Click `Start`
+
+> [!IMPORTANT]
+> **For WSL users:**
+> Applications running on Windows, such as WinSCP, cannot watch your Linux subsystem for file
+> changes. Try using [this workaround](#using-winscp-while-developing-in-wsl) or consider
+> moving development to Windows.
+
+##### Using `lsyncd` (Linux)
+> **TODO:** in-depth guide for setting up lsyncd
+
+Learn more about `lsyncd`: https://github.com/lsyncd/lsyncd
+
+___
+
+#### Using WinSCP while developing in WSL
+Run the following watch command in place of the one mentioned in
+[Step 1](#1-build-plugin-on-file-changes) to build to a directory in your Windows filesystem
+```shell
+dotnet watch build --project path/to/<projectName>.csproj --property:OutDir=/mnt/<drive-letter>/some/path/<projectName>`
+```
+and have [WinSCP in Step 2](#2-setup-automatic-uploads) watch that path instead.
+
+[Learn about Windows filesystem mounts in WSL](https://blogs.windows.com/windowsdeveloper/2016/07/22/fun-with-the-windows-subsystem-for-linux/#Working%20with%20Windows%20files:~:text=Working%20with%20Windows%20files)

docfx/docs/guides/getting-started.md

@@ -10,7 +10,7 @@ In this guide you will learn how to install CounterStrikeSharp onto your vanilla
 If you're more of a visual person, here is a <a href="https://www.youtube.com/watch?v=FlsKzStHJuY" target="_blank">Youtube video</a> that covers everything.
 
 ## Prerequisites
-- <a href="https://www.sourcemm.net/downloads.php/?branch=master" target="_blank">Metamod: Source 2.X Dev Build</a>
+- <a href="https://www.metamodsource.net/downloads.php/?branch=master" target="_blank">Metamod: Source 2.X Dev Build</a>
 - <a href="https://github.com/roflmuffin/CounterStrikeSharp/releases" target="_blank">CounterStrikeSharp With Runtime</a>
 
 ## Installing Metamod

docfx/docs/guides/toc.yml

@@ -6,3 +6,9 @@
 
 - name: Dependency Injection
   href: dependency-injection.md
+
+- name: Referencing Players
+  href: referencing-players.md
+
+- name: Automatically build and deploy your changes
+  href: auto-build-and-deploy.md

docfx/docs/reference/toc.yml

@@ -1,5 +1,2 @@
 - name: Core Configuration
-  href: core-configuration.md
-
-- name: Referencing Players
-  href: referencing-players.md
+  href: core-configuration.md

examples/WithCheckTransmit/README.md

@@ -0,0 +1,2 @@
+# With CheckTransmit
+This example shows how to work with the `CheckTransmit` listener.

examples/WithCheckTransmit/WithCheckTransmit.csproj

@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\managed\CounterStrikeSharp.API\CounterStrikeSharp.API.csproj" />
+  </ItemGroup>
+
+</Project>

examples/WithCheckTransmit/WithCheckTransmitPlugin.cs

@@ -0,0 +1,115 @@
+using CounterStrikeSharp.API;
+using CounterStrikeSharp.API.Core;
+using CounterStrikeSharp.API.Core.Attributes;
+
+namespace WithCheckTransmit;
+
+[MinimumApiVersion(276)]
+public class WithCheckTransmitPlugin : BasePlugin
+{
+    public override string ModuleName => "Example: With CheckTransmit";
+    public override string ModuleVersion => "1.0.0";
+    public override string ModuleAuthor => "CounterStrikeSharp & Contributors";
+    public override string ModuleDescription => "A simple plugin that uses the CheckTransmit listener!";
+
+    private Dictionary<int, bool> ShouldSeeDoors = new Dictionary<int, bool>();
+
+    public override void Load(bool hotReload)
+    {
+        // This command is related to the following example.
+        AddCommand("nodoors", "Toggle door transmit", (player, info) =>
+        {
+            if (player == null)
+                return;
+
+            if (ShouldSeeDoors.ContainsKey(player.Slot))
+            {
+                ShouldSeeDoors[player.Slot] = !ShouldSeeDoors[player.Slot];
+            } else
+            {
+                ShouldSeeDoors.Add(player.Slot, false);
+            }
+
+            info.ReplyToCommand($"You should {(ShouldSeeDoors[player.Slot] ? "see" : "not see")} doors");
+        });
+
+        // In this example, we will hide every door for players that have enabled the option with the command 'nodoors'
+        RegisterListener<Listeners.CheckTransmit>((CCheckTransmitInfoList infoList) =>
+        {
+            // Get the list of the currently available doors (prop_door_rotating)
+            IEnumerable<CPropDoorRotating> doors = Utilities.FindAllEntitiesByDesignerName<CPropDoorRotating>("prop_door_rotating");
+
+            // Do nothing if there is none.
+            if (!doors.Any())
+                return;
+
+            // Go through every received info
+            foreach ((CCheckTransmitInfo info, CCSPlayerController? player) in infoList)
+            {
+                // If no player is found, we can continue
+                if (player == null)
+                    continue;
+
+                // Otherwise, lets do the work:
+
+                // Check if we should clear or not:
+
+                // If we have no data saved for this player, then we should not continue
+                if (!ShouldSeeDoors.ContainsKey(player.Slot))
+                    continue;
+
+                // If this value is true, then this player should see doors
+                if (ShouldSeeDoors[player.Slot])
+                    continue;
+
+                // Otherwise, lets remove the door entity indexes from the info list so they won't be transmitted
+                foreach (CPropDoorRotating door in doors)
+                {
+                    info.TransmitEntities.Remove(door);
+                }
+
+                // NOTE: this is a barebone example, saving data and doing sanity checks is up to you.
+            }
+        });
+
+        // In this example, we will hide other players in the same team as the player.
+        // NOTE: 'Hiding' players requires extra work to do, killing non-transmitted players results in crash.
+        RegisterListener<Listeners.CheckTransmit>((CCheckTransmitInfoList infoList) =>
+        {
+            // Get the list of the current players, we only work with this value later on
+            List<CCSPlayerController> players = Utilities.GetPlayers();
+
+            // Go through every received info
+            foreach ((CCheckTransmitInfo info, CCSPlayerController? player) in infoList)
+            {
+                // If no player is found, we can continue
+                if (player == null)
+                    continue;
+
+                // Otherwise, lets do the work:
+
+                // as an example, lets hide everyone for this player who is in the same team.
+                IEnumerable<CCSPlayerController> targetPlayers = players.Where(p =>
+                    // is the player and its pawn valid
+                    p.IsValid && p.Pawn.IsValid &&
+
+                    // we shouldn't hide ourselves
+                    p.Slot != player.Slot &&
+
+                    // is the player is in the same team
+                    p.Team == player.Team &&
+
+                    // is alive
+                    p.PlayerPawn.Value?.LifeState == (byte)LifeState_t.LIFE_ALIVE
+                );
+
+                foreach (CCSPlayerController targetPlayer in targetPlayers)
+                {
+                    // Calling 'Remove' will clear the entity index of the target player pawn from the transmission list
+                    // so it won't be transmitted for the 'player'.
+                    info.TransmitEntities.Remove(targetPlayer.Pawn);
+                }
+            }
+        });
+    }
+}

examples/WithConfig/WithConfigPlugin.cs

@@ -1,38 +1,60 @@
-using System.Text.Json.Serialization;
-using CounterStrikeSharp.API.Core;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace WithConfig;
-
-public class SampleConfig : BasePluginConfig
-{
-    [JsonPropertyName("ChatPrefix")] public string ChatPrefix { get; set; } = "My Cool Plugin";
-
-    [JsonPropertyName("ChatInterval")] public float ChatInterval { get; set; } = 60;
-}
-
-[MinimumApiVersion(80)]
-public class WithConfigPlugin : BasePlugin, IPluginConfig<SampleConfig>
-{
-    public override string ModuleName => "Example: With Config";
-    public override string ModuleVersion => "1.0.0";
-
-    public SampleConfig Config { get; set; }
-
-    public void OnConfigParsed(SampleConfig config)
-    {
-        // Do manual verification of the config and override any invalid values 
-        if (config.ChatInterval > 60)
-        {
-            config.ChatInterval = 60;
-        }
-
-        if (config.ChatPrefix.Length > 25)
-        {
-            throw new Exception($"Invalid value has been set to config value 'ChatPrefix': {config.ChatPrefix}");
-        }
-
-        // Once we've validated the config, we can set it to the instance
-        Config = config;
-    }
-}
+using System.Text.Json.Serialization;
+using CounterStrikeSharp.API.Core;
+using CounterStrikeSharp.API.Core.Attributes;
+using CounterStrikeSharp.API.Core.Attributes.Registration;
+using CounterStrikeSharp.API.Modules.Admin;
+using CounterStrikeSharp.API.Modules.Commands;
+using CounterStrikeSharp.API.Modules.Config;
+using CounterStrikeSharp.API.Modules.Extensions;
+
+namespace WithConfig;
+
+public class SampleConfig : BasePluginConfig
+{
+    [JsonPropertyName("ChatPrefix")] public string ChatPrefix { get; set; } = "My Cool Plugin";
+
+    [JsonPropertyName("ChatInterval")] public float ChatInterval { get; set; } = 60;
+}
+
+[MinimumApiVersion(80)]
+public class WithConfigPlugin : BasePlugin, IPluginConfig<SampleConfig>
+{
+    public override string ModuleName => "Example: With Config";
+    public override string ModuleVersion => "1.0.0";
+
+    public SampleConfig Config { get; set; }
+
+    public void OnConfigParsed(SampleConfig config)
+    {
+        // Do manual verification of the config and override any invalid values
+        if (config.ChatInterval > 60)
+        {
+            config.ChatInterval = 60;
+        }
+
+        if (config.ChatPrefix.Length > 25)
+        {
+            throw new Exception($"Invalid value has been set to config value 'ChatPrefix': {config.ChatPrefix}");
+        }
+
+        // Once we've validated the config, we can set it to the instance
+        Config = config;
+    }
+
+    [ConsoleCommand("css_reload_config", "Reloads the plugin config")]
+    public void OnReloadConfig(CCSPlayerController? player, CommandInfo commandInfo)
+    {
+        commandInfo.ReplyToCommand("Chat Interval before reload: " + Config.ChatInterval);
+        Config.Reload();
+        commandInfo.ReplyToCommand("Chat Interval after reload: " + Config.ChatInterval);
+    }
+
+    [ConsoleCommand("css_reset_config", "Resets the plugin config")]
+    public void OnResetConfig(CCSPlayerController? player, CommandInfo commandInfo)
+    {
+        commandInfo.ReplyToCommand("Chat Interval before reset: " + Config.ChatInterval);
+        Config.ChatInterval = 60;
+        Config.Update();
+        commandInfo.ReplyToCommand("Chat Interval after reset: " + Config.ChatInterval);
+    }
+}

makefiles/shared.cmake

@@ -11,7 +11,7 @@ set(CMAKE_CONFIGURATION_TYPES "Debug;Release" CACHE STRING
     FORCE
 )
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 20)
 
 if(LINUX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
@@ -35,10 +35,10 @@ else()
     add_definitions(-DGITHUB_SHA="Local")
 endif()
 
-if(DEFINED ENV{BUILD_NUMBER})
-    add_definitions(-DBUILD_NUMBER="$ENV{BUILD_NUMBER}")
+if(DEFINED ENV{SEMVER})
+    add_definitions(-DSEMVER="$ENV{SEMVER}")
 else()
-    add_definitions(-DBUILD_NUMBER="0")
+    add_definitions(-DSEMVER="Local")
 endif()
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
@@ -58,7 +58,6 @@ include_directories(
     ${SOURCESDK}/public/tier1
     ${SOURCESDK}/public/entity2
     ${SOURCESDK}/public/game/server
-    ${SOURCESDK}/public/entity2
     ${SOURCESDK}/public/schemasystem
     ${METAMOD_DIR}/core
     ${METAMOD_DIR}/core/sourcehook

managed/CounterStrikeSharp.API/Core/API.cs

@@ -206,6 +206,150 @@ namespace CounterStrikeSharp.API.Core
 			}
 		}
 
+        public static void ReplicateConvar(int clientslot, string convarname, string convarvalue){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(clientslot);
+			ScriptContext.GlobalScriptContext.Push(convarname);
+			ScriptContext.GlobalScriptContext.Push(convarvalue);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0xC8728BEC);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			}
+		}
+
+        public static string GetStringFromSymbolLarge(IntPtr pointer){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(pointer);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x600A804B);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			return (string)ScriptContext.GlobalScriptContext.GetResult(typeof(string));
+			}
+		}
+
+        public static uint GetVariantType(IntPtr pvariant){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(pvariant);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x7AC3DA1C);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			return (uint)ScriptContext.GlobalScriptContext.GetResult(typeof(uint));
+			}
+		}
+
+        public static int GetVariantInt(IntPtr pvariant){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(pvariant);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x78156617);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			return (int)ScriptContext.GlobalScriptContext.GetResult(typeof(int));
+			}
+		}
+
+        public static uint GetVariantUint(IntPtr pvariant){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(pvariant);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x7AC49FA2);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			return (uint)ScriptContext.GlobalScriptContext.GetResult(typeof(uint));
+			}
+		}
+
+        public static float GetVariantFloat(IntPtr pvariant){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(pvariant);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0xD20595B4);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			return (float)ScriptContext.GlobalScriptContext.GetResult(typeof(float));
+			}
+		}
+
+        public static string GetVariantString(IntPtr pvariant){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(pvariant);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x41C49F71);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			return (string)ScriptContext.GlobalScriptContext.GetResult(typeof(string));
+			}
+		}
+
+        public static bool GetVariantBool(IntPtr pvariant){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(pvariant);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x7ABC76EA);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			return (bool)ScriptContext.GlobalScriptContext.GetResult(typeof(bool));
+			}
+		}
+
+        public static void SetVariantInt(IntPtr pvariant, int value){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(pvariant);
+			ScriptContext.GlobalScriptContext.Push(value);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x801EC403);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			}
+		}
+
+        public static void SetVariantUint(IntPtr pvariant, uint value){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(pvariant);
+			ScriptContext.GlobalScriptContext.Push(value);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x83EC7436);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			}
+		}
+
+        public static void SetVariantFloat(IntPtr pvariant, float value){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(pvariant);
+			ScriptContext.GlobalScriptContext.Push(value);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x266E8A0);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			}
+		}
+
+        public static void SetVariantString(IntPtr pvariant, string value){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(pvariant);
+			ScriptContext.GlobalScriptContext.Push(value);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x2450A3E5);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			}
+		}
+
+        public static void SetVariantBool(IntPtr pvariant, bool value){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(pvariant);
+			ScriptContext.GlobalScriptContext.Push(value);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x83F1967E);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			}
+		}
+
         public static T DynamicHookGetReturn<T>(IntPtr hook, int datatype){
 			lock (ScriptContext.GlobalScriptContext.Lock) {
 			ScriptContext.GlobalScriptContext.Reset();
@@ -768,6 +912,21 @@ namespace CounterStrikeSharp.API.Core
 			}
 		}
 
+        public static uint EmitSoundFilter(ulong filtermask, uint ent, string sound, float volume, float pitch){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(filtermask);
+			ScriptContext.GlobalScriptContext.Push(ent);
+			ScriptContext.GlobalScriptContext.Push(sound);
+			ScriptContext.GlobalScriptContext.Push(volume);
+			ScriptContext.GlobalScriptContext.Push(pitch);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x43C4A2B3);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			return (uint)ScriptContext.GlobalScriptContext.GetResult(typeof(uint));
+			}
+		}
+
         public static void HookEvent(string name, InputArgument callback, bool ispost){
 			lock (ScriptContext.GlobalScriptContext.Lock) {
 			ScriptContext.GlobalScriptContext.Reset();
@@ -1160,6 +1319,17 @@ namespace CounterStrikeSharp.API.Core
 			}
 		}
 
+        public static IntPtr MetaFactory(string interfacename){
+			lock (ScriptContext.GlobalScriptContext.Lock) {
+			ScriptContext.GlobalScriptContext.Reset();
+			ScriptContext.GlobalScriptContext.Push(interfacename);
+			ScriptContext.GlobalScriptContext.SetIdentifier(0x61521EF3);
+			ScriptContext.GlobalScriptContext.Invoke();
+			ScriptContext.GlobalScriptContext.CheckErrors();
+			return (IntPtr)ScriptContext.GlobalScriptContext.GetResult(typeof(IntPtr));
+			}
+		}
+
         public static short GetSchemaOffset(string classname, string propname){
 			lock (ScriptContext.GlobalScriptContext.Lock) {
 			ScriptContext.GlobalScriptContext.Reset();

managed/CounterStrikeSharp.API/Core/Attributes/Registration/ListenerHandlerAttribute.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace CounterStrikeSharp.API.Core.Attributes.Registration;
+
+[AttributeUsage(AttributeTargets.Method)]
+public class ListenerHandlerAttribute<T> : Attribute
+    where T: Delegate
+{
+}

managed/CounterStrikeSharp.API/Core/BasePlugin.cs

@@ -396,20 +396,26 @@ namespace CounterStrikeSharp.API.Core
         }
 
         /// <summary>
-        /// Registers all game event handlers that are decorated with the <see cref="GameEventHandlerAttribute"/> attribute.
+        /// Registers all game event handlers that are decorated with the <see cref="GameEventHandlerAttribute"/> and <see cref="ListenerHandlerAttribute{T}"/> attribute.
         /// </summary>
         /// <param name="instance">The instance of the object where the event handlers are defined.</param>
         public void RegisterAttributeHandlers(object instance)
         {
-            var eventHandlers = instance.GetType()
-                .GetMethods()
+            var methods = instance.GetType().GetMethods();
+
+            var eventHandlers = methods
                 .Where(method => method.GetCustomAttribute<GameEventHandlerAttribute>() != null)
                 .Where(method =>
                     method.GetParameters().FirstOrDefault()?.ParameterType.IsSubclassOf(typeof(GameEvent)) == true)
                 .ToArray();
+            
+            var listenerHandlers = methods
+                .Where(method => method.GetCustomAttribute(typeof(ListenerHandlerAttribute<>)) != null)
+                .ToArray();
 
-            var method = typeof(BasePlugin).GetMethod("RegisterEventHandlerInternal", BindingFlags.NonPublic |
+            var registerEvent = typeof(BasePlugin).GetMethod(nameof(RegisterEventHandlerInternal), BindingFlags.NonPublic |
                 BindingFlags.Instance)!;
+            var registerListener = GetType().GetMethod(nameof(RegisterListener))!;
 
             foreach (var eventHandler in eventHandlers)
             {
@@ -421,8 +427,22 @@ namespace CounterStrikeSharp.API.Core
                 var actionType = typeof(GameEventHandler<>).MakeGenericType(parameterType);
                 var action = Delegate.CreateDelegate(actionType, instance, eventHandler);
 
-                var generic = method.MakeGenericMethod(parameterType);
-                generic.Invoke(this, new object[] { eventName, action, hookMode == HookMode.Post });
+                var registerEventGeneric = registerEvent.MakeGenericMethod(parameterType);
+                registerEventGeneric.Invoke(this, [eventName, action, hookMode == HookMode.Post]);
+            }
+
+            foreach (var listnerHandler in listenerHandlers)
+            {
+                var attribute = listnerHandler.GetCustomAttribute(typeof(ListenerHandlerAttribute<>))!;
+                var listenerType = attribute.GetType().GetGenericArguments().First();
+
+                if (listenerType.GetCustomAttribute<ListenerNameAttribute>() == null)
+                    throw new ArgumentException("Listener of type T is invalid and does not have a name attribute",
+                        listenerType.Name);
+
+                var listenerDelegate = Delegate.CreateDelegate(listenerType, instance, listnerHandler); 
+
+                registerListener.MakeGenericMethod(listenerType).Invoke(this, [listenerDelegate]);
             }
         }
 

managed/CounterStrikeSharp.API/Core/FunctionReference.cs

@@ -15,6 +15,7 @@
  */
 
 using System.Collections.Concurrent;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
@@ -26,7 +27,7 @@ namespace CounterStrikeSharp.API.Core
     /// </summary>
     public enum FunctionLifetime
     {
-        /// <summary>Delegate will be removed after the first invocation.</summary> 
+        /// <summary>Delegate will be removed after the first invocation.</summary>
         SingleUse,
 
         /// <summary>Delegate will remain in memory for the lifetime of the application (or until <see cref="FunctionReference.Remove"/> is called).</summary>
@@ -57,7 +58,7 @@ namespace CounterStrikeSharp.API.Core
             _targetMethod = method;
             _nativeCallback = CreateWrappedCallback();
         }
-        
+
         /// <summary>
         /// <inheritdoc cref="FunctionLifetime"/>
         /// </summary>
@@ -73,6 +74,25 @@ namespace CounterStrikeSharp.API.Core
 
         private unsafe CallbackDelegate CreateWrappedCallback()
         {
+            var methodName = _targetMethod.Method.DeclaringType?.FullName + "." + _targetMethod.Method.Name;
+            var profileName = "ScriptCallback::Execute::" + _targetMethod.Method.Name;
+
+            var stackTrace = new StackTrace(2, true);
+            var firstUserFrame = stackTrace.GetFrames()?.FirstOrDefault(frame =>
+            {
+                var declaring = frame.GetMethod()?.DeclaringType?.FullName;
+                return declaring != null &&
+                       !declaring.StartsWith("CounterStrikeSharp") &&
+                       !declaring.Contains("SafeExecutor") &&
+                       !declaring.Contains("FunctionReference");
+            });
+
+            string caller = firstUserFrame != null
+                ? $"{firstUserFrame.GetMethod()?.DeclaringType?.FullName}.{firstUserFrame.GetMethod()?.Name} @ {firstUserFrame.GetFileName()}:{firstUserFrame.GetFileLineNumber()}"
+                : "Unknown (no user frame)";
+
+            Helpers.RegisterCallbackTrace(methodName, 1, profileName, caller);
+
             return context =>
             {
                 try
@@ -176,4 +196,4 @@ namespace CounterStrikeSharp.API.Core
             }
         }
     }
-}
+}

managed/CounterStrikeSharp.API/Core/Helpers.cs

@@ -29,5 +29,8 @@ namespace CounterStrikeSharp.API.Core
         [SecurityCritical]
         [DllImport(dllPath, EntryPoint = "InvokeNative")]
         public static extern void InvokeNative(IntPtr ptr);
+
+        [DllImport(dllPath, EntryPoint = "RegisterCallbackTrace")]
+        public static extern void RegisterCallbackTrace(string name, int count, string profile, string callerStack);
     }
-}
+}

managed/CounterStrikeSharp.API/Core/Listeners.g.cs

@@ -163,5 +163,18 @@ namespace CounterStrikeSharp.API.Core
         /// <param name="manifest">Resource Manifest</param>
         [ListenerName("OnServerPrecacheResources")]
         public delegate void OnServerPrecacheResources(ResourceManifest manifest);
+
+        /// <summary>
+        /// Called when checking transmit on entities.
+        /// </summary>
+        /// <param name="infoList">Transmit info list</param>
+        [ListenerName("CheckTransmit")]
+        public delegate void CheckTransmit([CastFrom(typeof(nint))]CCheckTransmitInfoList infoList);
+
+        /// <summary>
+        /// Called when all metamod plugins are loaded.
+        /// </summary>
+        [ListenerName("OnMetamodAllPluginsLoaded")]
+        public delegate void OnMetamodAllPluginsLoaded();
     }
-}
+}

managed/CounterStrikeSharp.API/Core/Model/CBaseEntity.cs

@@ -12,15 +12,17 @@ public partial class CBaseEntity
     public void Teleport(Vector? position = null, QAngle? angles = null, Vector? velocity = null)
     {
         Guard.IsValidEntity(this);
-    
+
         if (position == null && angles == null && velocity == null)
             throw new ArgumentNullException("No valid argument");
-    
+
         nint _position = position?.Handle ?? 0;
         nint _angles = angles?.Handle ?? 0;
         nint _velocity = velocity?.Handle ?? 0;
-    
-        VirtualFunction.CreateVoid<IntPtr, IntPtr, IntPtr, IntPtr>(Handle, GameData.GetOffset("CBaseEntity_Teleport"))(Handle, _position, _angles, _velocity);
+        nint _handle = Handle;
+
+        VirtualFunction.CreateVoid<IntPtr, IntPtr, IntPtr, IntPtr>(_handle, GameData.GetOffset("CBaseEntity_Teleport"))(_handle, _position,
+            _angles, _velocity);
     }
 
     /// <exception cref="InvalidOperationException">Entity is not valid</exception>
@@ -48,4 +50,25 @@ public partial class CBaseEntity
 
         return (T)Activator.CreateInstance(typeof(T), Marshal.ReadIntPtr(SubclassID.Handle + 4));
     }
+
+    /// <summary>
+    /// Emit a soundevent to all players.
+    /// </summary>
+    /// <param name="soundEventName">The name of the soundevent to emit.</param>
+    /// <param name="recipients">The recipients of the soundevent.</param>
+    /// <param name="volume">The volume of the soundevent.</param>
+    /// <param name="pitch">The pitch of the soundevent.</param>
+    /// <returns>The sound event guid.</returns>
+    public uint EmitSound(string soundEventName, RecipientFilter? recipients = null, float volume = 1f, float pitch = 0)
+    {
+        Guard.IsValidEntity(this);
+        
+        if (recipients == null)
+        {
+            recipients = new RecipientFilter();
+            recipients.AddAllPlayers();
+        }
+
+        return NativeAPI.EmitSoundFilter(recipients.GetRecipientMask(), this.Index, soundEventName, volume, pitch);
+    }
 }

managed/CounterStrikeSharp.API/Core/Model/CCSGameRules.cs

@@ -16,6 +16,7 @@
 
 using CounterStrikeSharp.API.Modules.Entities.Constants;
 using CounterStrikeSharp.API.Modules.Memory;
+using CounterStrikeSharp.API.Modules.Utils;
 
 namespace CounterStrikeSharp.API.Core;
 
@@ -28,4 +29,33 @@ public partial class CCSGameRules
     {
         VirtualFunctions.TerminateRound(Handle, roundEndReason, delay, 0, 0);
     }
-}
+
+    public T? FindPickerEntity<T>(CBasePlayerController player)
+        where T : CBaseEntity
+    {
+        VirtualFunctionWithReturn<CCSGameRules, CBasePlayerController, CBaseEntity?> CCSGameRules_FindPickerEntity = new (Handle, GameData.GetOffset("CCSGameRules_FindPickerEntity"));
+        CBaseEntity? entity = CCSGameRules_FindPickerEntity.Invoke(this, player);
+
+        if (entity == null || !entity.IsValid)
+        {
+            return null;
+        }
+
+        return entity.As<T>();
+    }
+
+    public CCSPlayerController? GetClientAimTarget(CCSPlayerController player)
+    {
+        CCSPlayerPawn? pawn = FindPickerEntity<CCSPlayerPawn>(player);
+
+        if (pawn == null || !pawn.IsValid)
+            return null;
+
+        if (pawn.DesignerName == "player")
+        {
+            return pawn.OriginalController.Value;
+        }
+
+        return null;
+    }
+}

managed/CounterStrikeSharp.API/Core/Model/CCSPlayerController.cs

@@ -340,4 +340,16 @@ public partial class CCSPlayerController
             NativeAPI.SetClientVoiceFlags(Handle, (Byte)value);
         }
     }
+
+    [Obsolete(
+        "You are trying to call Teleport on a non-physical player. Maybe you mean Pawn? (See: https://docs.cssharp.dev/docs/guides/referencing-players.html#controllers--pawns)")]
+    public new void Teleport(Vector? position = null, QAngle? angles = null, Vector? velocity = null)
+    {
+        base.Teleport(position, angles, velocity);
+    }
+
+    public void ReplicateConVar(string conVar, string value)
+    {
+        NativeAPI.ReplicateConvar(Slot, conVar, value);
+    }
 }

managed/CounterStrikeSharp.API/Core/Model/CCheckTransmitInfo.cs

@@ -0,0 +1,106 @@
+/*
+ *  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
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  CounterStrikeSharp is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
+ */
+
+using System.Collections;
+using System.Runtime.InteropServices;
+
+namespace CounterStrikeSharp.API.Core
+{
+    [StructLayout(LayoutKind.Explicit)]
+    public struct CCheckTransmitInfo
+    {
+        /// <summary>
+        /// Entity n is already marked for transmission
+        /// </summary>
+        [FieldOffset(0x0)]
+        public CFixedBitVecBase TransmitEntities;
+
+        /// <summary>
+        /// Entity n is always send even if not in PVS (HLTV and Replay only)
+        /// </summary>
+        [FieldOffset(0x8)]
+        public CFixedBitVecBase TransmitAlways;
+    };
+
+    public sealed class CCheckTransmitInfoList : NativeObject, IReadOnlyList<(CCheckTransmitInfo info, CCSPlayerController? player)>
+    {
+        private int CheckTransmitPlayerSlotOffset = GameData.GetOffset("CheckTransmitPlayerSlot");
+
+        private unsafe nint* Inner => (nint*)base.Handle;
+
+        public unsafe int Count { get => (int)(*(this.Inner + 1)); }
+
+        public unsafe CCheckTransmitInfoList(IntPtr pointer) : base(pointer)
+            { }
+
+        /// <summary>
+        /// Get transmit info for the given index.
+        /// </summary>
+        /// <param name="index">Index of the info you want to retrieve from the list, should be between 0 and '<see cref="Count"/>' - 1</param>
+        /// <returns></returns>
+        public (CCheckTransmitInfo info, CCSPlayerController? player) this[int index]
+        {
+            get
+            {
+                var (transmit, slot) = this.Get(index);
+                CCSPlayerController? player = Utilities.GetPlayerFromSlot(slot);
+                return (transmit, player);
+            }
+        }
+
+        /// <summary>
+        /// Get transmit info for the given index.
+        /// </summary>
+        /// <param name="index">Index of the info you want to retrieve from the list, should be between 0 and '<see cref="Count"/>' - 1</param>
+        /// <returns></returns>
+        private unsafe (CCheckTransmitInfo, int) Get(int index)
+        {
+            if (index < 0 || index >= this.Count)
+            {
+                throw new ArgumentOutOfRangeException("index");
+            }
+
+            // 'base.Handle' holds the pointer for our 'CCheckTransmitInfoList' wrapper class
+
+            // Get the pointer to the array of 'CCheckTransmitInfo'
+            nint* infoListPtr = *(nint**)this.Inner; // Dereference 'Inner' to get the pointer to the array
+
+            // Access the specific 'CCheckTransmitInfo*'
+            nint infoPtr = *(infoListPtr + index);
+
+            // Retrieve the 'CCheckTransmitInfo' from the pointer
+            CCheckTransmitInfo info = Marshal.PtrToStructure<CCheckTransmitInfo>(infoPtr);
+
+            // Get player slot from the 'infoPtr' using the 'CheckTransmitPlayerSlotOffset' offset
+            int playerSlot = *(int*)((byte*)infoPtr + CheckTransmitPlayerSlotOffset);
+
+            return (info, playerSlot);
+        }
+
+        public IEnumerator<(CCheckTransmitInfo, CCSPlayerController?)> GetEnumerator()
+        {
+            for (int i = 0; i < this.Count; i++)
+            {
+                yield return this[i];
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return this.GetEnumerator();
+        }
+    }
+}

managed/CounterStrikeSharp.API/Core/Model/CFixedBitVecBase.cs

@@ -0,0 +1,81 @@
+/*
+ *  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
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  CounterStrikeSharp is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
+ */
+
+using System.Runtime.InteropServices;
+
+namespace CounterStrikeSharp.API.Core
+{
+    // credits: qstage
+    [StructLayout(LayoutKind.Sequential)]
+    public unsafe struct CFixedBitVecBase
+    {
+        private const int LOG2_BITS_PER_INT = 5;
+        private const int BITS_PER_INT = 32;
+
+        private readonly uint* m_Ints;
+
+        public void Add(CEntityInstance entityInstance) => Write(entityInstance.Index);
+
+        public void Add(int bitNum) => Write(bitNum);
+
+        public void Add(uint bitNum) => Write(bitNum);
+
+        public void Remove(CEntityInstance entityInstance) => Clear(entityInstance.Index);
+
+        public void Remove(int bitNum) => Clear(bitNum);
+
+        public void Remove(uint bitNum) => Clear(bitNum);
+
+        public bool Contains(CEntityInstance entityInstance) => Contains(entityInstance.Index);
+
+        public bool Contains(uint bitNum) => Contains((int)bitNum);
+
+        private void Clear(uint bitNum) => Clear((int)bitNum);
+
+        private void Write(uint bitNum) => Write((int)bitNum);
+
+        private void Clear(int bitNum)
+        {
+            if (!(bitNum >= 0 && bitNum < Utilities.MaxEdicts))
+                return;
+
+            uint* pInt = m_Ints + BitVec_Int(bitNum);
+            *pInt &= ~(uint)BitVec_Bit(bitNum);
+        }
+
+        private void Write(int bitNum)
+        {
+            if (!(bitNum >= 0 && bitNum < Utilities.MaxEdicts))
+                return;
+
+            uint* pInt = m_Ints + BitVec_Int(bitNum);
+            *pInt |= (uint)BitVec_Bit(bitNum);
+        }
+
+        public bool Contains(int bitNum)
+        {
+            if (!(bitNum >= 0 && bitNum < Utilities.MaxEdicts))
+                return false;
+
+            uint* pInt = m_Ints + BitVec_Int(bitNum);
+            return (*pInt & (uint)BitVec_Bit(bitNum)) != 0;
+        }
+
+        private int BitVec_Int(int bitNum) => bitNum >> LOG2_BITS_PER_INT;
+
+        private int BitVec_Bit(int bitNum) => 1 << (bitNum & (BITS_PER_INT - 1));
+    }
+}

managed/CounterStrikeSharp.API/Core/Model/CTakeDamageInfo.cs

@@ -0,0 +1,32 @@
+using System.Runtime.InteropServices;
+
+namespace CounterStrikeSharp.API.Core;
+
+public partial class CTakeDamageInfo
+{
+    /// <summary>
+    /// Retrieves the hitgroup
+    /// </summary>
+    /// <returns>
+    /// Returns a <see cref="HitGroup_t"/> enumeration representing the player's current hit group,
+    /// or <see cref="HitGroup_t.HITGROUP_INVALID"/> if the hit group cannot be determined.
+    /// </returns>
+    public HitGroup_t GetHitGroup()
+    {
+        IntPtr v4 = Marshal.ReadIntPtr(Handle, 0x78);
+
+        if (v4 == nint.Zero)
+        {
+            return HitGroup_t.HITGROUP_INVALID;
+        }
+
+        IntPtr v1 = Marshal.ReadIntPtr(v4, 16);
+
+        if (v1 == nint.Zero)
+        {
+            return HitGroup_t.HITGROUP_GENERIC;
+        }
+
+        return (HitGroup_t)Marshal.ReadInt32(v1, 56);
+    }
+}

managed/CounterStrikeSharp.API/Core/Model/CUtlSymbolLarge.cs

@@ -0,0 +1,18 @@
+namespace CounterStrikeSharp.API.Core;
+
+public class CUtlSymbolLarge : NativeObject
+{
+    public CUtlSymbolLarge(IntPtr pointer) : base(pointer)
+    {
+    }
+
+    public bool IsValid => Handle != IntPtr.Zero;
+
+    public string String
+    {
+        get
+        {
+            return NativeAPI.GetStringFromSymbolLarge(Handle);
+        }
+    }
+}

managed/CounterStrikeSharp.API/Core/Model/CVariant.cs

@@ -1,13 +1,56 @@
-namespace CounterStrikeSharp.API.Core;
+using System.Reflection.Metadata;
 
-/// <summary>
-/// Placeholder for CVariant
-/// <see href="https://github.com/alliedmodders/hl2sdk/blob/cs2/public/variant.h"/>
-/// <remarks>A lot of entity outputs do not use this value</remarks>
-/// </summary>
+namespace CounterStrikeSharp.API.Core;
+
 public class CVariant : NativeObject
 {
     public CVariant(IntPtr pointer) : base(pointer)
     {
+    }
+
+    public bool IsValid => Handle != IntPtr.Zero;
+
+    public fieldtype_t FieldType => (fieldtype_t)NativeAPI.GetVariantType(Handle);
+
+    public T Get<T>()
+    {
+        var type = typeof(T);
+        object result = type switch
+        {
+            _ when type == typeof(float) => NativeAPI.GetVariantFloat(Handle),
+            _ when type == typeof(int) => NativeAPI.GetVariantInt(Handle),
+            _ when type == typeof(uint) => NativeAPI.GetVariantUint(Handle),
+            _ when type == typeof(string) => NativeAPI.GetVariantString(Handle),
+            _ when type == typeof(bool) => NativeAPI.GetVariantBool(Handle),
+            _ => throw new NotSupportedException(),
+        };
+
+        return (T)result;
+    }
+
+    public void Set<T>(T value)
+    {
+        var type = typeof(T);
+        switch (type)
+        {
+            case var _ when value is float f:
+                NativeAPI.SetVariantFloat(Handle, f);
+            break;
+            case var _ when value is int i:
+                NativeAPI.SetVariantInt(Handle, i);
+            break;
+            case var _ when value is uint ui:
+                NativeAPI.SetVariantUint(Handle, ui);
+            break;
+            case var _ when value is bool b:
+                NativeAPI.SetVariantBool(Handle, b);
+            break;
+            case var _ when value is string s:
+                NativeAPI.SetVariantString(Handle, s);
+            break;
+
+            default:
+            throw new NotSupportedException();
+        }
     }
-}
+}

managed/CounterStrikeSharp.API/Core/Model/NetworkedVector.cs

@@ -17,7 +17,7 @@ public partial class NetworkedVector<T> : NativeObject, IReadOnlyCollection<T>
     }
 
     public unsafe uint Size => Unsafe.Read<uint>((void*)Handle);
-    
+
     public unsafe int Count => NativeAPI.GetNetworkVectorSize(Handle);
 
     public T this[int index]
@@ -28,7 +28,7 @@ public partial class NetworkedVector<T> : NativeObject, IReadOnlyCollection<T>
             {
                 throw new NotSupportedException("Networked vectors currently only support CHandle<T>");
             }
-            
+
             return (T)Activator.CreateInstance(typeof(T), NativeAPI.GetNetworkVectorElementAt(Handle, index));
         }
     }
@@ -50,4 +50,4 @@ public partial class NetworkedVector<T> : NativeObject, IReadOnlyCollection<T>
     {
         return GetEnumerator();
     }
-}
+}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseAnimGraph.g.cs

@@ -58,4 +58,8 @@ public partial class CBaseAnimGraph : CBaseModelEntity
 	[SchemaMember("CBaseAnimGraph", "m_bRagdollClientSide")]
 	public ref bool RagdollClientSide => ref Schema.GetRef<bool>(this.Handle, "CBaseAnimGraph", "m_bRagdollClientSide");
 
+	// m_nLastDestructiblePartDestroyedAnimgraphSetTick
+	[SchemaMember("CBaseAnimGraph", "m_nLastDestructiblePartDestroyedAnimgraphSetTick")]
+	public ref Int32 LastDestructiblePartDestroyedAnimgraphSetTick => ref Schema.GetRef<Int32>(this.Handle, "CBaseAnimGraph", "m_nLastDestructiblePartDestroyedAnimgraphSetTick");
+
 }

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseCSGrenadeProjectile.g.cs

@@ -78,12 +78,8 @@ public partial class CBaseCSGrenadeProjectile : CBaseGrenade
 	[SchemaMember("CBaseCSGrenadeProjectile", "m_nTicksAtZeroVelocity")]
 	public ref Int32 TicksAtZeroVelocity => ref Schema.GetRef<Int32>(this.Handle, "CBaseCSGrenadeProjectile", "m_nTicksAtZeroVelocity");
 
-	// m_bHasEverHitPlayer
-	[SchemaMember("CBaseCSGrenadeProjectile", "m_bHasEverHitPlayer")]
-	public ref bool HasEverHitPlayer => ref Schema.GetRef<bool>(this.Handle, "CBaseCSGrenadeProjectile", "m_bHasEverHitPlayer");
-
-	// m_bClearFromPlayers
-	[SchemaMember("CBaseCSGrenadeProjectile", "m_bClearFromPlayers")]
-	public ref bool ClearFromPlayers => ref Schema.GetRef<bool>(this.Handle, "CBaseCSGrenadeProjectile", "m_bClearFromPlayers");
+	// m_bHasEverHitEnemy
+	[SchemaMember("CBaseCSGrenadeProjectile", "m_bHasEverHitEnemy")]
+	public ref bool HasEverHitEnemy => ref Schema.GetRef<bool>(this.Handle, "CBaseCSGrenadeProjectile", "m_bHasEverHitEnemy");
 
 }

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseCombatCharacter.g.cs

@@ -30,10 +30,6 @@ public partial class CBaseCombatCharacter : CBaseFlex
 	[SchemaMember("CBaseCombatCharacter", "m_impactEnergyScale")]
 	public ref float ImpactEnergyScale => ref Schema.GetRef<float>(this.Handle, "CBaseCombatCharacter", "m_impactEnergyScale");
 
-	// m_LastHitGroup
-	[SchemaMember("CBaseCombatCharacter", "m_LastHitGroup")]
-	public ref HitGroup_t LastHitGroup => ref Schema.GetRef<HitGroup_t>(this.Handle, "CBaseCombatCharacter", "m_LastHitGroup");
-
 	// m_bApplyStressDamage
 	[SchemaMember("CBaseCombatCharacter", "m_bApplyStressDamage")]
 	public ref bool ApplyStressDamage => ref Schema.GetRef<bool>(this.Handle, "CBaseCombatCharacter", "m_bApplyStressDamage");

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBaseModelEntity.g.cs

@@ -26,6 +26,34 @@ public partial class CBaseModelEntity : CBaseEntity
 	[SchemaMember("CBaseModelEntity", "m_CHitboxComponent")]
 	public CHitboxComponent CHitboxComponent => Schema.GetDeclaredClass<CHitboxComponent>(this.Handle, "CBaseModelEntity", "m_CHitboxComponent");
 
+	// m_nDestructiblePartInitialStateDestructed0
+	[SchemaMember("CBaseModelEntity", "m_nDestructiblePartInitialStateDestructed0")]
+	public ref HitGroup_t DestructiblePartInitialStateDestructed0 => ref Schema.GetRef<HitGroup_t>(this.Handle, "CBaseModelEntity", "m_nDestructiblePartInitialStateDestructed0");
+
+	// m_nDestructiblePartInitialStateDestructed1
+	[SchemaMember("CBaseModelEntity", "m_nDestructiblePartInitialStateDestructed1")]
+	public ref HitGroup_t DestructiblePartInitialStateDestructed1 => ref Schema.GetRef<HitGroup_t>(this.Handle, "CBaseModelEntity", "m_nDestructiblePartInitialStateDestructed1");
+
+	// m_nDestructiblePartInitialStateDestructed2
+	[SchemaMember("CBaseModelEntity", "m_nDestructiblePartInitialStateDestructed2")]
+	public ref HitGroup_t DestructiblePartInitialStateDestructed2 => ref Schema.GetRef<HitGroup_t>(this.Handle, "CBaseModelEntity", "m_nDestructiblePartInitialStateDestructed2");
+
+	// m_nDestructiblePartInitialStateDestructed3
+	[SchemaMember("CBaseModelEntity", "m_nDestructiblePartInitialStateDestructed3")]
+	public ref HitGroup_t DestructiblePartInitialStateDestructed3 => ref Schema.GetRef<HitGroup_t>(this.Handle, "CBaseModelEntity", "m_nDestructiblePartInitialStateDestructed3");
+
+	// m_nDestructiblePartInitialStateDestructed4
+	[SchemaMember("CBaseModelEntity", "m_nDestructiblePartInitialStateDestructed4")]
+	public ref HitGroup_t DestructiblePartInitialStateDestructed4 => ref Schema.GetRef<HitGroup_t>(this.Handle, "CBaseModelEntity", "m_nDestructiblePartInitialStateDestructed4");
+
+	// m_nLastHitDestructiblePartIndex
+	[SchemaMember("CBaseModelEntity", "m_nLastHitDestructiblePartIndex")]
+	public ref Int32 LastHitDestructiblePartIndex => ref Schema.GetRef<Int32>(this.Handle, "CBaseModelEntity", "m_nLastHitDestructiblePartIndex");
+
+	// m_LastHitGroup
+	[SchemaMember("CBaseModelEntity", "m_LastHitGroup")]
+	public ref HitGroup_t LastHitGroup => ref Schema.GetRef<HitGroup_t>(this.Handle, "CBaseModelEntity", "m_LastHitGroup");
+
 	// m_flDissolveStartTime
 	[SchemaMember("CBaseModelEntity", "m_flDissolveStartTime")]
 	public ref float DissolveStartTime => ref Schema.GetRef<float>(this.Handle, "CBaseModelEntity", "m_flDissolveStartTime");
@@ -68,7 +96,7 @@ public partial class CBaseModelEntity : CBaseEntity
 
 	// m_Collision
 	[SchemaMember("CBaseModelEntity", "m_Collision")]
-	public CCollisionProperty Collision => Schema.GetDeclaredClass<CCollisionProperty>(this.Handle, "CBaseModelEntity", "m_Collision");
+	public new CCollisionProperty Collision => Schema.GetDeclaredClass<CCollisionProperty>(this.Handle, "CBaseModelEntity", "m_Collision");
 
 	// m_Glow
 	[SchemaMember("CBaseModelEntity", "m_Glow")]

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBasePlayerController.g.cs

@@ -82,10 +82,6 @@ public partial class CBasePlayerController : CBaseEntity
 	[SchemaMember("CBasePlayerController", "m_bPredict")]
 	public ref bool Predict => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerController", "m_bPredict");
 
-	// m_bAutoKickDisabled
-	[SchemaMember("CBasePlayerController", "m_bAutoKickDisabled")]
-	public ref bool AutoKickDisabled => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerController", "m_bAutoKickDisabled");
-
 	// m_bIsLowViolence
 	[SchemaMember("CBasePlayerController", "m_bIsLowViolence")]
 	public ref bool IsLowViolence => ref Schema.GetRef<bool>(this.Handle, "CBasePlayerController", "m_bIsLowViolence");

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBasePropDoor.g.cs

@@ -52,7 +52,7 @@ public partial class CBasePropDoor : CDynamicProp
 
 	// m_hBlocker
 	[SchemaMember("CBasePropDoor", "m_hBlocker")]
-	public CHandle<CBaseEntity> Blocker => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBasePropDoor", "m_hBlocker");
+	public new CHandle<CBaseEntity> Blocker => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CBasePropDoor", "m_hBlocker");
 
 	// m_bFirstBlocked
 	[SchemaMember("CBasePropDoor", "m_bFirstBlocked")]

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBeam.g.cs

@@ -88,7 +88,7 @@ public partial class CBeam : CBaseModelEntity
 
 	// m_fSpeed
 	[SchemaMember("CBeam", "m_fSpeed")]
-	public ref float Speed => ref Schema.GetRef<float>(this.Handle, "CBeam", "m_fSpeed");
+	public new ref float Speed => ref Schema.GetRef<float>(this.Handle, "CBeam", "m_fSpeed");
 
 	// m_flFrame
 	[SchemaMember("CBeam", "m_flFrame")]

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBodyComponentPoint.g.cs

@@ -20,6 +20,6 @@ public partial class CBodyComponentPoint : CBodyComponent
 
 	// m_sceneNode
 	[SchemaMember("CBodyComponentPoint", "m_sceneNode")]
-	public CGameSceneNode SceneNode => Schema.GetDeclaredClass<CGameSceneNode>(this.Handle, "CBodyComponentPoint", "m_sceneNode");
+	public new CGameSceneNode SceneNode => Schema.GetDeclaredClass<CGameSceneNode>(this.Handle, "CBodyComponentPoint", "m_sceneNode");
 
 }

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBreachCharge.g.cs

@@ -1,21 +0,0 @@
-// <auto-generated />
-#nullable enable
-#pragma warning disable CS1591
-
-using System;
-using System.Diagnostics;
-using System.Drawing;
-using CounterStrikeSharp;
-using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Memory;
-using CounterStrikeSharp.API.Modules.Utils;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace CounterStrikeSharp.API.Core;
-
-public partial class CBreachCharge : CCSWeaponBase
-{
-    public CBreachCharge (IntPtr pointer) : base(pointer) {}
-
-}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBreachChargeProjectile.g.cs

@@ -1,21 +0,0 @@
-// <auto-generated />
-#nullable enable
-#pragma warning disable CS1591
-
-using System;
-using System.Diagnostics;
-using System.Drawing;
-using CounterStrikeSharp;
-using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Memory;
-using CounterStrikeSharp.API.Modules.Utils;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace CounterStrikeSharp.API.Core;
-
-public partial class CBreachChargeProjectile : CBaseGrenade
-{
-    public CBreachChargeProjectile (IntPtr pointer) : base(pointer) {}
-
-}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBumpMine.g.cs

@@ -1,21 +0,0 @@
-// <auto-generated />
-#nullable enable
-#pragma warning disable CS1591
-
-using System;
-using System.Diagnostics;
-using System.Drawing;
-using CounterStrikeSharp;
-using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Memory;
-using CounterStrikeSharp.API.Modules.Utils;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace CounterStrikeSharp.API.Core;
-
-public partial class CBumpMine : CCSWeaponBase
-{
-    public CBumpMine (IntPtr pointer) : base(pointer) {}
-
-}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CBumpMineProjectile.g.cs

@@ -1,21 +0,0 @@
-// <auto-generated />
-#nullable enable
-#pragma warning disable CS1591
-
-using System;
-using System.Diagnostics;
-using System.Drawing;
-using CounterStrikeSharp;
-using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Memory;
-using CounterStrikeSharp.API.Modules.Utils;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace CounterStrikeSharp.API.Core;
-
-public partial class CBumpMineProjectile : CBaseGrenade
-{
-    public CBumpMineProjectile (IntPtr pointer) : base(pointer) {}
-
-}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSGameRules.g.cs

@@ -286,10 +286,6 @@ public partial class CCSGameRules : CTeamplayRules
 	[SchemaMember("CCSGameRules", "m_flNextRespawnWave")]
 	public Span<float> NextRespawnWave => Schema.GetFixedArray<float>(this.Handle, "CCSGameRules", "m_flNextRespawnWave", 32);
 
-	// m_nServerQuestID
-	[SchemaMember("CCSGameRules", "m_nServerQuestID")]
-	public ref Int32 ServerQuestID => ref Schema.GetRef<Int32>(this.Handle, "CCSGameRules", "m_nServerQuestID");
-
 	// m_vMinimapMins
 	[SchemaMember("CCSGameRules", "m_vMinimapMins")]
 	public Vector MinimapMins => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSGameRules", "m_vMinimapMins");
@@ -306,6 +302,10 @@ public partial class CCSGameRules : CTeamplayRules
 	[SchemaMember("CCSGameRules", "m_bSpawnedTerrorHuntHeavy")]
 	public ref bool SpawnedTerrorHuntHeavy => ref Schema.GetRef<bool>(this.Handle, "CCSGameRules", "m_bSpawnedTerrorHuntHeavy");
 
+	// m_ullLocalMatchID
+	[SchemaMember("CCSGameRules", "m_ullLocalMatchID")]
+	public ref UInt64 UllLocalMatchID => ref Schema.GetRef<UInt64>(this.Handle, "CCSGameRules", "m_ullLocalMatchID");
+
 	// m_nEndMatchMapGroupVoteTypes
 	[SchemaMember("CCSGameRules", "m_nEndMatchMapGroupVoteTypes")]
 	public Span<Int32> EndMatchMapGroupVoteTypes => Schema.GetFixedArray<Int32>(this.Handle, "CCSGameRules", "m_nEndMatchMapGroupVoteTypes", 10);

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSPlayerController.g.cs

@@ -42,6 +42,10 @@ public partial class CCSPlayerController : CBasePlayerController
 	[SchemaMember("CCSPlayerController", "m_bHasCommunicationAbuseMute")]
 	public ref bool HasCommunicationAbuseMute => ref Schema.GetRef<bool>(this.Handle, "CCSPlayerController", "m_bHasCommunicationAbuseMute");
 
+	// m_uiCommunicationMuteFlags
+	[SchemaMember("CCSPlayerController", "m_uiCommunicationMuteFlags")]
+	public ref UInt32 UiCommunicationMuteFlags => ref Schema.GetRef<UInt32>(this.Handle, "CCSPlayerController", "m_uiCommunicationMuteFlags");
+
 	// m_szCrosshairCodes
 	[SchemaMember("CCSPlayerController", "m_szCrosshairCodes")]
 	public string CrosshairCodes
@@ -98,6 +102,10 @@ public partial class CCSPlayerController : CBasePlayerController
 	[SchemaMember("CCSPlayerController", "m_bRemoveAllItemsOnNextRoundReset")]
 	public ref bool RemoveAllItemsOnNextRoundReset => ref Schema.GetRef<bool>(this.Handle, "CCSPlayerController", "m_bRemoveAllItemsOnNextRoundReset");
 
+	// m_flLastJoinTeamTime
+	[SchemaMember("CCSPlayerController", "m_flLastJoinTeamTime")]
+	public ref float LastJoinTeamTime => ref Schema.GetRef<float>(this.Handle, "CCSPlayerController", "m_flLastJoinTeamTime");
+
 	// m_szClan
 	[SchemaMember("CCSPlayerController", "m_szClan")]
 	public string Clan
@@ -158,6 +166,10 @@ public partial class CCSPlayerController : CBasePlayerController
 	[SchemaMember("CCSPlayerController", "m_unActiveQuestId")]
 	public ref UInt16 ActiveQuestId => ref Schema.GetRef<UInt16>(this.Handle, "CCSPlayerController", "m_unActiveQuestId");
 
+	// m_rtActiveMissionPeriod
+	[SchemaMember("CCSPlayerController", "m_rtActiveMissionPeriod")]
+	public ref UInt32 RtActiveMissionPeriod => ref Schema.GetRef<UInt32>(this.Handle, "CCSPlayerController", "m_rtActiveMissionPeriod");
+
 	// m_unPlayerTvControlFlags
 	[SchemaMember("CCSPlayerController", "m_unPlayerTvControlFlags")]
 	public ref UInt32 PlayerTvControlFlags => ref Schema.GetRef<UInt32>(this.Handle, "CCSPlayerController", "m_unPlayerTvControlFlags");
@@ -174,6 +186,10 @@ public partial class CCSPlayerController : CBasePlayerController
 	[SchemaMember("CCSPlayerController", "m_uiAbandonRecordedReason")]
 	public ref UInt32 UiAbandonRecordedReason => ref Schema.GetRef<UInt32>(this.Handle, "CCSPlayerController", "m_uiAbandonRecordedReason");
 
+	// m_eNetworkDisconnectionReason
+	[SchemaMember("CCSPlayerController", "m_eNetworkDisconnectionReason")]
+	public ref UInt32 NetworkDisconnectionReason => ref Schema.GetRef<UInt32>(this.Handle, "CCSPlayerController", "m_eNetworkDisconnectionReason");
+
 	// m_bCannotBeKicked
 	[SchemaMember("CCSPlayerController", "m_bCannotBeKicked")]
 	public ref bool CannotBeKicked => ref Schema.GetRef<bool>(this.Handle, "CCSPlayerController", "m_bCannotBeKicked");
@@ -290,9 +306,17 @@ public partial class CCSPlayerController : CBasePlayerController
 	[SchemaMember("CCSPlayerController", "m_iRoundsWon")]
 	public ref Int32 RoundsWon => ref Schema.GetRef<Int32>(this.Handle, "CCSPlayerController", "m_iRoundsWon");
 
-	// m_vecKills
-	[SchemaMember("CCSPlayerController", "m_vecKills")]
-	public NetworkedVector<EKillTypes_t> Kills => Schema.GetDeclaredClass<NetworkedVector<EKillTypes_t>>(this.Handle, "CCSPlayerController", "m_vecKills");
+	// m_recentKillQueue
+	[SchemaMember("CCSPlayerController", "m_recentKillQueue")]
+	public Span<byte> RecentKillQueue => Schema.GetFixedArray<byte>(this.Handle, "CCSPlayerController", "m_recentKillQueue", 8);
+
+	// m_nFirstKill
+	[SchemaMember("CCSPlayerController", "m_nFirstKill")]
+	public ref byte FirstKill => ref Schema.GetRef<byte>(this.Handle, "CCSPlayerController", "m_nFirstKill");
+
+	// m_nKillCount
+	[SchemaMember("CCSPlayerController", "m_nKillCount")]
+	public ref byte KillCount => ref Schema.GetRef<byte>(this.Handle, "CCSPlayerController", "m_nKillCount");
 
 	// m_bMvpNoMusic
 	[SchemaMember("CCSPlayerController", "m_bMvpNoMusic")]
@@ -370,4 +394,8 @@ public partial class CCSPlayerController : CBasePlayerController
 	[SchemaMember("CCSPlayerController", "m_nNonSuspiciousHitStreak")]
 	public ref UInt32 NonSuspiciousHitStreak => ref Schema.GetRef<UInt32>(this.Handle, "CCSPlayerController", "m_nNonSuspiciousHitStreak");
 
+	// m_bFireBulletsSeedSynchronized
+	[SchemaMember("CCSPlayerController", "m_bFireBulletsSeedSynchronized")]
+	public ref bool FireBulletsSeedSynchronized => ref Schema.GetRef<bool>(this.Handle, "CCSPlayerController", "m_bFireBulletsSeedSynchronized");
+
 }

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSPlayer_MovementServices.g.cs

@@ -18,10 +18,6 @@ public partial class CCSPlayer_MovementServices : CPlayer_MovementServices_Human
 {
     public CCSPlayer_MovementServices (IntPtr pointer) : base(pointer) {}
 
-	// m_flMaxFallVelocity
-	[SchemaMember("CCSPlayer_MovementServices", "m_flMaxFallVelocity")]
-	public ref float MaxFallVelocity => ref Schema.GetRef<float>(this.Handle, "CCSPlayer_MovementServices", "m_flMaxFallVelocity");
-
 	// m_vecLadderNormal
 	[SchemaMember("CCSPlayer_MovementServices", "m_vecLadderNormal")]
 	public Vector LadderNormal => Schema.GetDeclaredClass<Vector>(this.Handle, "CCSPlayer_MovementServices", "m_vecLadderNormal");
@@ -142,14 +138,6 @@ public partial class CCSPlayer_MovementServices : CPlayer_MovementServices_Human
 	[SchemaMember("CCSPlayer_MovementServices", "m_flJumpPressedTime")]
 	public ref float JumpPressedTime => ref Schema.GetRef<float>(this.Handle, "CCSPlayer_MovementServices", "m_flJumpPressedTime");
 
-	// m_flJumpUntil
-	[SchemaMember("CCSPlayer_MovementServices", "m_flJumpUntil")]
-	public ref float JumpUntil => ref Schema.GetRef<float>(this.Handle, "CCSPlayer_MovementServices", "m_flJumpUntil");
-
-	// m_flJumpVel
-	[SchemaMember("CCSPlayer_MovementServices", "m_flJumpVel")]
-	public ref float JumpVel => ref Schema.GetRef<float>(this.Handle, "CCSPlayer_MovementServices", "m_flJumpVel");
-
 	// m_fStashGrenadeParameterWhen
 	[SchemaMember("CCSPlayer_MovementServices", "m_fStashGrenadeParameterWhen")]
 	public ref float StashGrenadeParameterWhen => ref Schema.GetRef<float>(this.Handle, "CCSPlayer_MovementServices", "m_fStashGrenadeParameterWhen");
@@ -182,4 +170,12 @@ public partial class CCSPlayer_MovementServices : CPlayer_MovementServices_Human
 	[SchemaMember("CCSPlayer_MovementServices", "m_flMaxJumpHeightLastJump")]
 	public ref float MaxJumpHeightLastJump => ref Schema.GetRef<float>(this.Handle, "CCSPlayer_MovementServices", "m_flMaxJumpHeightLastJump");
 
+	// m_flStaminaAtJumpStart
+	[SchemaMember("CCSPlayer_MovementServices", "m_flStaminaAtJumpStart")]
+	public ref float StaminaAtJumpStart => ref Schema.GetRef<float>(this.Handle, "CCSPlayer_MovementServices", "m_flStaminaAtJumpStart");
+
+	// m_flAccumulatedJumpError
+	[SchemaMember("CCSPlayer_MovementServices", "m_flAccumulatedJumpError")]
+	public ref float AccumulatedJumpError => ref Schema.GetRef<float>(this.Handle, "CCSPlayer_MovementServices", "m_flAccumulatedJumpError");
+
 }

managed/CounterStrikeSharp.API/Core/Schema/Classes/CCSWeaponBase.g.cs

@@ -86,10 +86,6 @@ public partial class CCSWeaponBase : CBasePlayerWeapon
 	[SchemaMember("CCSWeaponBase", "m_flLastTimeInAir")]
 	public ref float LastTimeInAir => ref Schema.GetRef<float>(this.Handle, "CCSWeaponBase", "m_flLastTimeInAir");
 
-	// m_flLastDeployTime
-	[SchemaMember("CCSWeaponBase", "m_flLastDeployTime")]
-	public ref float LastDeployTime => ref Schema.GetRef<float>(this.Handle, "CCSWeaponBase", "m_flLastDeployTime");
-
 	// m_nLastEmptySoundCmdNum
 	[SchemaMember("CCSWeaponBase", "m_nLastEmptySoundCmdNum")]
 	public ref Int32 LastEmptySoundCmdNum => ref Schema.GetRef<Int32>(this.Handle, "CCSWeaponBase", "m_nLastEmptySoundCmdNum");
@@ -222,6 +218,10 @@ public partial class CCSWeaponBase : CBasePlayerWeapon
 	[SchemaMember("CCSWeaponBase", "m_nextPrevOwnerTouchTime")]
 	public ref float NextPrevOwnerTouchTime => ref Schema.GetRef<float>(this.Handle, "CCSWeaponBase", "m_nextPrevOwnerTouchTime");
 
+	// m_nextPrevOwnerUseTime
+	[SchemaMember("CCSWeaponBase", "m_nextPrevOwnerUseTime")]
+	public ref float NextPrevOwnerUseTime => ref Schema.GetRef<float>(this.Handle, "CCSWeaponBase", "m_nextPrevOwnerUseTime");
+
 	// m_hPrevOwner
 	[SchemaMember("CCSWeaponBase", "m_hPrevOwner")]
 	public CHandle<CCSPlayerPawn> PrevOwner => Schema.GetDeclaredClass<CHandle<CCSPlayerPawn>>(this.Handle, "CCSWeaponBase", "m_hPrevOwner");

managed/CounterStrikeSharp.API/Core/Schema/Classes/CDamageRecord.g.cs

@@ -58,6 +58,10 @@ public partial class CDamageRecord : NativeObject
 	[SchemaMember("CDamageRecord", "m_RecipientXuid")]
 	public ref UInt64 RecipientXuid => ref Schema.GetRef<UInt64>(this.Handle, "CDamageRecord", "m_RecipientXuid");
 
+	// m_iBulletsDamage
+	[SchemaMember("CDamageRecord", "m_iBulletsDamage")]
+	public ref Int32 BulletsDamage => ref Schema.GetRef<Int32>(this.Handle, "CDamageRecord", "m_iBulletsDamage");
+
 	// m_iDamage
 	[SchemaMember("CDamageRecord", "m_iDamage")]
 	public ref Int32 Damage => ref Schema.GetRef<Int32>(this.Handle, "CDamageRecord", "m_iDamage");

managed/CounterStrikeSharp.API/Core/Schema/Classes/CEnvBeam.g.cs

@@ -36,7 +36,7 @@ public partial class CEnvBeam : CBeam
 
 	// m_iszEndEntity
 	[SchemaMember("CEnvBeam", "m_iszEndEntity")]
-	public string EndEntity
+	public new string EndEntity
 	{
 		get { return Schema.GetUtf8String(this.Handle, "CEnvBeam", "m_iszEndEntity"); }
 		set { Schema.SetString(this.Handle, "CEnvBeam", "m_iszEndEntity", value); }
@@ -56,7 +56,7 @@ public partial class CEnvBeam : CBeam
 
 	// m_speed
 	[SchemaMember("CEnvBeam", "m_speed")]
-	public ref Int32 Speed => ref Schema.GetRef<Int32>(this.Handle, "CEnvBeam", "m_speed");
+	public new ref Int32 Speed => ref Schema.GetRef<Int32>(this.Handle, "CEnvBeam", "m_speed");
 
 	// m_restrike
 	[SchemaMember("CEnvBeam", "m_restrike")]

managed/CounterStrikeSharp.API/Core/Schema/Classes/CEnvLaser.g.cs

@@ -44,6 +44,6 @@ public partial class CEnvLaser : CBeam
 
 	// m_flStartFrame
 	[SchemaMember("CEnvLaser", "m_flStartFrame")]
-	public ref float StartFrame => ref Schema.GetRef<float>(this.Handle, "CEnvLaser", "m_flStartFrame");
+	public new ref float StartFrame => ref Schema.GetRef<float>(this.Handle, "CEnvLaser", "m_flStartFrame");
 
 }

managed/CounterStrikeSharp.API/Core/Schema/Classes/CEnvSoundscape.g.cs

@@ -14,7 +14,7 @@ using CounterStrikeSharp.API.Core.Attributes;
 
 namespace CounterStrikeSharp.API.Core;
 
-public partial class CEnvSoundscape : CServerOnlyEntity
+public partial class CEnvSoundscape : CBaseEntity
 {
     public CEnvSoundscape (IntPtr pointer) : base(pointer) {}
 
@@ -26,14 +26,6 @@ public partial class CEnvSoundscape : CServerOnlyEntity
 	[SchemaMember("CEnvSoundscape", "m_flRadius")]
 	public ref float Radius => ref Schema.GetRef<float>(this.Handle, "CEnvSoundscape", "m_flRadius");
 
-	// m_soundscapeName
-	[SchemaMember("CEnvSoundscape", "m_soundscapeName")]
-	public string SoundscapeName
-	{
-		get { return Schema.GetUtf8String(this.Handle, "CEnvSoundscape", "m_soundscapeName"); }
-		set { Schema.SetString(this.Handle, "CEnvSoundscape", "m_soundscapeName", value); }
-	}
-
 	// m_soundEventName
 	[SchemaMember("CEnvSoundscape", "m_soundEventName")]
 	public string SoundEventName
@@ -54,10 +46,6 @@ public partial class CEnvSoundscape : CServerOnlyEntity
 	[SchemaMember("CEnvSoundscape", "m_soundscapeEntityListId")]
 	public ref Int32 SoundscapeEntityListId => ref Schema.GetRef<Int32>(this.Handle, "CEnvSoundscape", "m_soundscapeEntityListId");
 
-	// m_soundEventHash
-	[SchemaMember("CEnvSoundscape", "m_soundEventHash")]
-	public ref UInt32 SoundEventHash => ref Schema.GetRef<UInt32>(this.Handle, "CEnvSoundscape", "m_soundEventHash");
-
 	// m_positionNames
 	[SchemaMember("CEnvSoundscape", "m_positionNames")]
 	public Span<string> PositionNames => Schema.GetFixedArray<string>(this.Handle, "CEnvSoundscape", "m_positionNames", 8);
@@ -70,4 +58,16 @@ public partial class CEnvSoundscape : CServerOnlyEntity
 	[SchemaMember("CEnvSoundscape", "m_bDisabled")]
 	public ref bool Disabled => ref Schema.GetRef<bool>(this.Handle, "CEnvSoundscape", "m_bDisabled");
 
+	// m_soundscapeName
+	[SchemaMember("CEnvSoundscape", "m_soundscapeName")]
+	public string SoundscapeName
+	{
+		get { return Schema.GetUtf8String(this.Handle, "CEnvSoundscape", "m_soundscapeName"); }
+		set { Schema.SetString(this.Handle, "CEnvSoundscape", "m_soundscapeName", value); }
+	}
+
+	// m_soundEventHash
+	[SchemaMember("CEnvSoundscape", "m_soundEventHash")]
+	public ref UInt32 SoundEventHash => ref Schema.GetRef<UInt32>(this.Handle, "CEnvSoundscape", "m_soundEventHash");
+
 }

managed/CounterStrikeSharp.API/Core/Schema/Classes/CFish.g.cs

@@ -64,7 +64,7 @@ public partial class CFish : CBaseAnimGraph
 
 	// m_speed
 	[SchemaMember("CFish", "m_speed")]
-	public ref float Speed => ref Schema.GetRef<float>(this.Handle, "CFish", "m_speed");
+	public new ref float Speed => ref Schema.GetRef<float>(this.Handle, "CFish", "m_speed");
 
 	// m_desiredSpeed
 	[SchemaMember("CFish", "m_desiredSpeed")]

managed/CounterStrikeSharp.API/Core/Schema/Classes/CFishPool.g.cs

@@ -32,7 +32,7 @@ public partial class CFishPool : CBaseEntity
 
 	// m_waterLevel
 	[SchemaMember("CFishPool", "m_waterLevel")]
-	public ref float WaterLevel => ref Schema.GetRef<float>(this.Handle, "CFishPool", "m_waterLevel");
+	public new ref float WaterLevel => ref Schema.GetRef<float>(this.Handle, "CFishPool", "m_waterLevel");
 
 	// m_isDormant
 	[SchemaMember("CFishPool", "m_isDormant")]

managed/CounterStrikeSharp.API/Core/Schema/Classes/CFists.g.cs

@@ -1,49 +0,0 @@
-// <auto-generated />
-#nullable enable
-#pragma warning disable CS1591
-
-using System;
-using System.Diagnostics;
-using System.Drawing;
-using CounterStrikeSharp;
-using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Memory;
-using CounterStrikeSharp.API.Modules.Utils;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace CounterStrikeSharp.API.Core;
-
-public partial class CFists : CCSWeaponBase
-{
-    public CFists (IntPtr pointer) : base(pointer) {}
-
-	// m_bPlayingUninterruptableAct
-	[SchemaMember("CFists", "m_bPlayingUninterruptableAct")]
-	public ref bool PlayingUninterruptableAct => ref Schema.GetRef<bool>(this.Handle, "CFists", "m_bPlayingUninterruptableAct");
-
-	// m_nUninterruptableActivity
-	[SchemaMember("CFists", "m_nUninterruptableActivity")]
-	public ref PlayerAnimEvent_t UninterruptableActivity => ref Schema.GetRef<PlayerAnimEvent_t>(this.Handle, "CFists", "m_nUninterruptableActivity");
-
-	// m_bRestorePrevWep
-	[SchemaMember("CFists", "m_bRestorePrevWep")]
-	public ref bool RestorePrevWep => ref Schema.GetRef<bool>(this.Handle, "CFists", "m_bRestorePrevWep");
-
-	// m_hWeaponBeforePrevious
-	[SchemaMember("CFists", "m_hWeaponBeforePrevious")]
-	public CHandle<CBasePlayerWeapon> WeaponBeforePrevious => Schema.GetDeclaredClass<CHandle<CBasePlayerWeapon>>(this.Handle, "CFists", "m_hWeaponBeforePrevious");
-
-	// m_hWeaponPrevious
-	[SchemaMember("CFists", "m_hWeaponPrevious")]
-	public CHandle<CBasePlayerWeapon> WeaponPrevious => Schema.GetDeclaredClass<CHandle<CBasePlayerWeapon>>(this.Handle, "CFists", "m_hWeaponPrevious");
-
-	// m_bDelayedHardPunchIncoming
-	[SchemaMember("CFists", "m_bDelayedHardPunchIncoming")]
-	public ref bool DelayedHardPunchIncoming => ref Schema.GetRef<bool>(this.Handle, "CFists", "m_bDelayedHardPunchIncoming");
-
-	// m_bDestroyAfterTaunt
-	[SchemaMember("CFists", "m_bDestroyAfterTaunt")]
-	public ref bool DestroyAfterTaunt => ref Schema.GetRef<bool>(this.Handle, "CFists", "m_bDestroyAfterTaunt");
-
-}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CFuncMover.g.cs

@@ -44,7 +44,7 @@ public partial class CFuncMover : CBaseModelEntity
 
 	// m_eMoveType
 	[SchemaMember("CFuncMover", "m_eMoveType")]
-	public ref CFuncMoverMove_t MoveType => ref Schema.GetRef<CFuncMoverMove_t>(this.Handle, "CFuncMover", "m_eMoveType");
+	public new ref CFuncMoverMove_t MoveType => ref Schema.GetRef<CFuncMoverMove_t>(this.Handle, "CFuncMover", "m_eMoveType");
 
 	// m_bIsReversing
 	[SchemaMember("CFuncMover", "m_bIsReversing")]
@@ -52,7 +52,7 @@ public partial class CFuncMover : CBaseModelEntity
 
 	// m_vTarget
 	[SchemaMember("CFuncMover", "m_vTarget")]
-	public Vector Target => Schema.GetDeclaredClass<Vector>(this.Handle, "CFuncMover", "m_vTarget");
+	public new Vector Target => Schema.GetDeclaredClass<Vector>(this.Handle, "CFuncMover", "m_vTarget");
 
 	// m_flStartSpeed
 	[SchemaMember("CFuncMover", "m_flStartSpeed")]

managed/CounterStrikeSharp.API/Core/Schema/Classes/CInstancedSceneEntity.g.cs

@@ -44,6 +44,6 @@ public partial class CInstancedSceneEntity : CSceneEntity
 
 	// m_hTarget
 	[SchemaMember("CInstancedSceneEntity", "m_hTarget")]
-	public CHandle<CBaseEntity> Target => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CInstancedSceneEntity", "m_hTarget");
+	public new CHandle<CBaseEntity> Target => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CInstancedSceneEntity", "m_hTarget");
 
 }

managed/CounterStrikeSharp.API/Core/Schema/Classes/CLogicMeasureMovement.g.cs

@@ -52,7 +52,7 @@ public partial class CLogicMeasureMovement : CLogicalEntity
 
 	// m_hTarget
 	[SchemaMember("CLogicMeasureMovement", "m_hTarget")]
-	public CHandle<CBaseEntity> Target => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CLogicMeasureMovement", "m_hTarget");
+	public new CHandle<CBaseEntity> Target => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CLogicMeasureMovement", "m_hTarget");
 
 	// m_hTargetReference
 	[SchemaMember("CLogicMeasureMovement", "m_hTargetReference")]

managed/CounterStrikeSharp.API/Core/Schema/Classes/CMapInfo.g.cs

@@ -50,4 +50,8 @@ public partial class CMapInfo : CPointEntity
 	[SchemaMember("CMapInfo", "m_bFadePlayerVisibilityFarZ")]
 	public ref bool FadePlayerVisibilityFarZ => ref Schema.GetRef<bool>(this.Handle, "CMapInfo", "m_bFadePlayerVisibilityFarZ");
 
+	// m_bRainTraceToSkyEnabled
+	[SchemaMember("CMapInfo", "m_bRainTraceToSkyEnabled")]
+	public ref bool RainTraceToSkyEnabled => ref Schema.GetRef<bool>(this.Handle, "CMapInfo", "m_bRainTraceToSkyEnabled");
+
 }

managed/CounterStrikeSharp.API/Core/Schema/Classes/CMelee.g.cs

@@ -1,21 +0,0 @@
-// <auto-generated />
-#nullable enable
-#pragma warning disable CS1591
-
-using System;
-using System.Diagnostics;
-using System.Drawing;
-using CounterStrikeSharp;
-using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Memory;
-using CounterStrikeSharp.API.Modules.Utils;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace CounterStrikeSharp.API.Core;
-
-public partial class CMelee : CCSWeaponBase
-{
-    public CMelee (IntPtr pointer) : base(pointer) {}
-
-}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CPointEntityFinder.g.cs

@@ -20,7 +20,7 @@ public partial class CPointEntityFinder : CBaseEntity
 
 	// m_hEntity
 	[SchemaMember("CPointEntityFinder", "m_hEntity")]
-	public CHandle<CBaseEntity> Entity => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CPointEntityFinder", "m_hEntity");
+	public new CHandle<CBaseEntity> Entity => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CPointEntityFinder", "m_hEntity");
 
 	// m_iFilterName
 	[SchemaMember("CPointEntityFinder", "m_iFilterName")]

managed/CounterStrikeSharp.API/Core/Schema/Classes/CPointWorldText.g.cs

@@ -34,6 +34,14 @@ public partial class CPointWorldText : CModelPointEntity
 		set { Schema.SetStringBytes(this.Handle, "CPointWorldText", "m_FontName", value, 64); }
 	}
 
+	// m_BackgroundMaterialName
+	[SchemaMember("CPointWorldText", "m_BackgroundMaterialName")]
+	public string BackgroundMaterialName
+	{
+		get { return Schema.GetString(this.Handle, "CPointWorldText", "m_BackgroundMaterialName"); }
+		set { Schema.SetStringBytes(this.Handle, "CPointWorldText", "m_BackgroundMaterialName", value, 64); }
+	}
+
 	// m_bEnabled
 	[SchemaMember("CPointWorldText", "m_bEnabled")]
 	public ref bool Enabled => ref Schema.GetRef<bool>(this.Handle, "CPointWorldText", "m_bEnabled");
@@ -54,6 +62,22 @@ public partial class CPointWorldText : CModelPointEntity
 	[SchemaMember("CPointWorldText", "m_flDepthOffset")]
 	public ref float DepthOffset => ref Schema.GetRef<float>(this.Handle, "CPointWorldText", "m_flDepthOffset");
 
+	// m_bDrawBackground
+	[SchemaMember("CPointWorldText", "m_bDrawBackground")]
+	public ref bool DrawBackground => ref Schema.GetRef<bool>(this.Handle, "CPointWorldText", "m_bDrawBackground");
+
+	// m_flBackgroundBorderWidth
+	[SchemaMember("CPointWorldText", "m_flBackgroundBorderWidth")]
+	public ref float BackgroundBorderWidth => ref Schema.GetRef<float>(this.Handle, "CPointWorldText", "m_flBackgroundBorderWidth");
+
+	// m_flBackgroundBorderHeight
+	[SchemaMember("CPointWorldText", "m_flBackgroundBorderHeight")]
+	public ref float BackgroundBorderHeight => ref Schema.GetRef<float>(this.Handle, "CPointWorldText", "m_flBackgroundBorderHeight");
+
+	// m_flBackgroundWorldToUV
+	[SchemaMember("CPointWorldText", "m_flBackgroundWorldToUV")]
+	public ref float BackgroundWorldToUV => ref Schema.GetRef<float>(this.Handle, "CPointWorldText", "m_flBackgroundWorldToUV");
+
 	// m_Color
 	[SchemaMember("CPointWorldText", "m_Color")]
 	public Color Color

managed/CounterStrikeSharp.API/Core/Schema/Classes/CPostProcessingVolume.g.cs

@@ -60,7 +60,7 @@ public partial class CPostProcessingVolume : CBaseTrigger
 
 	// m_bMaster
 	[SchemaMember("CPostProcessingVolume", "m_bMaster")]
-	public ref bool Master => ref Schema.GetRef<bool>(this.Handle, "CPostProcessingVolume", "m_bMaster");
+	public new ref bool Master => ref Schema.GetRef<bool>(this.Handle, "CPostProcessingVolume", "m_bMaster");
 
 	// m_bExposureControl
 	[SchemaMember("CPostProcessingVolume", "m_bExposureControl")]

managed/CounterStrikeSharp.API/Core/Schema/Classes/CRagdollManager.g.cs

@@ -30,4 +30,8 @@ public partial class CRagdollManager : CBaseEntity
 	[SchemaMember("CRagdollManager", "m_bSaveImportant")]
 	public ref bool SaveImportant => ref Schema.GetRef<bool>(this.Handle, "CRagdollManager", "m_bSaveImportant");
 
+	// m_bCanTakeDamage
+	[SchemaMember("CRagdollManager", "m_bCanTakeDamage")]
+	public ref bool CanTakeDamage => ref Schema.GetRef<bool>(this.Handle, "CRagdollManager", "m_bCanTakeDamage");
+
 }

managed/CounterStrikeSharp.API/Core/Schema/Classes/CScriptedSequence.g.cs

@@ -68,7 +68,7 @@ public partial class CScriptedSequence : CBaseEntity
 
 	// m_iszEntity
 	[SchemaMember("CScriptedSequence", "m_iszEntity")]
-	public string Entity
+	public new string Entity
 	{
 		get { return Schema.GetUtf8String(this.Handle, "CScriptedSequence", "m_iszEntity"); }
 		set { Schema.SetString(this.Handle, "CScriptedSequence", "m_iszEntity", value); }

managed/CounterStrikeSharp.API/Core/Schema/Classes/CSensorGrenade.g.cs

@@ -1,21 +0,0 @@
-// <auto-generated />
-#nullable enable
-#pragma warning disable CS1591
-
-using System;
-using System.Diagnostics;
-using System.Drawing;
-using CounterStrikeSharp;
-using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Memory;
-using CounterStrikeSharp.API.Modules.Utils;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace CounterStrikeSharp.API.Core;
-
-public partial class CSensorGrenade : CBaseCSGrenade
-{
-    public CSensorGrenade (IntPtr pointer) : base(pointer) {}
-
-}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CSensorGrenadeProjectile.g.cs

@@ -1,33 +0,0 @@
-// <auto-generated />
-#nullable enable
-#pragma warning disable CS1591
-
-using System;
-using System.Diagnostics;
-using System.Drawing;
-using CounterStrikeSharp;
-using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Memory;
-using CounterStrikeSharp.API.Modules.Utils;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace CounterStrikeSharp.API.Core;
-
-public partial class CSensorGrenadeProjectile : CBaseCSGrenadeProjectile
-{
-    public CSensorGrenadeProjectile (IntPtr pointer) : base(pointer) {}
-
-	// m_fExpireTime
-	[SchemaMember("CSensorGrenadeProjectile", "m_fExpireTime")]
-	public ref float ExpireTime => ref Schema.GetRef<float>(this.Handle, "CSensorGrenadeProjectile", "m_fExpireTime");
-
-	// m_fNextDetectPlayerSound
-	[SchemaMember("CSensorGrenadeProjectile", "m_fNextDetectPlayerSound")]
-	public ref float NextDetectPlayerSound => ref Schema.GetRef<float>(this.Handle, "CSensorGrenadeProjectile", "m_fNextDetectPlayerSound");
-
-	// m_hDisplayGrenade
-	[SchemaMember("CSensorGrenadeProjectile", "m_hDisplayGrenade")]
-	public CHandle<CBaseEntity> DisplayGrenade => Schema.GetDeclaredClass<CHandle<CBaseEntity>>(this.Handle, "CSensorGrenadeProjectile", "m_hDisplayGrenade");
-
-}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CSmokeGrenadeProjectile.g.cs

@@ -42,6 +42,14 @@ public partial class CSmokeGrenadeProjectile : CBaseCSGrenadeProjectile
 	[SchemaMember("CSmokeGrenadeProjectile", "m_VoxelFrameData")]
 	public NetworkedVector<byte> VoxelFrameData => Schema.GetDeclaredClass<NetworkedVector<byte>>(this.Handle, "CSmokeGrenadeProjectile", "m_VoxelFrameData");
 
+	// m_nVoxelFrameDataSize
+	[SchemaMember("CSmokeGrenadeProjectile", "m_nVoxelFrameDataSize")]
+	public ref Int32 VoxelFrameDataSize => ref Schema.GetRef<Int32>(this.Handle, "CSmokeGrenadeProjectile", "m_nVoxelFrameDataSize");
+
+	// m_nVoxelUpdate
+	[SchemaMember("CSmokeGrenadeProjectile", "m_nVoxelUpdate")]
+	public ref Int32 VoxelUpdate => ref Schema.GetRef<Int32>(this.Handle, "CSmokeGrenadeProjectile", "m_nVoxelUpdate");
+
 	// m_flLastBounce
 	[SchemaMember("CSmokeGrenadeProjectile", "m_flLastBounce")]
 	public ref float LastBounce => ref Schema.GetRef<float>(this.Handle, "CSmokeGrenadeProjectile", "m_flLastBounce");

managed/CounterStrikeSharp.API/Core/Schema/Classes/CTablet.g.cs

@@ -1,21 +0,0 @@
-// <auto-generated />
-#nullable enable
-#pragma warning disable CS1591
-
-using System;
-using System.Diagnostics;
-using System.Drawing;
-using CounterStrikeSharp;
-using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Memory;
-using CounterStrikeSharp.API.Modules.Utils;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace CounterStrikeSharp.API.Core;
-
-public partial class CTablet : CCSWeaponBase
-{
-    public CTablet (IntPtr pointer) : base(pointer) {}
-
-}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CTriggerPhysics.g.cs

@@ -20,7 +20,7 @@ public partial class CTriggerPhysics : CBaseTrigger
 
 	// m_gravityScale
 	[SchemaMember("CTriggerPhysics", "m_gravityScale")]
-	public ref float GravityScale => ref Schema.GetRef<float>(this.Handle, "CTriggerPhysics", "m_gravityScale");
+	public new ref float GravityScale => ref Schema.GetRef<float>(this.Handle, "CTriggerPhysics", "m_gravityScale");
 
 	// m_linearLimit
 	[SchemaMember("CTriggerPhysics", "m_linearLimit")]

managed/CounterStrikeSharp.API/Core/Schema/Classes/CTriggerTripWire.g.cs

@@ -1,21 +0,0 @@
-// <auto-generated />
-#nullable enable
-#pragma warning disable CS1591
-
-using System;
-using System.Diagnostics;
-using System.Drawing;
-using CounterStrikeSharp;
-using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Memory;
-using CounterStrikeSharp.API.Modules.Utils;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace CounterStrikeSharp.API.Core;
-
-public partial class CTriggerTripWire : CBaseTrigger
-{
-    public CTriggerTripWire (IntPtr pointer) : base(pointer) {}
-
-}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CTripWireFire.g.cs

@@ -1,21 +0,0 @@
-// <auto-generated />
-#nullable enable
-#pragma warning disable CS1591
-
-using System;
-using System.Diagnostics;
-using System.Drawing;
-using CounterStrikeSharp;
-using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Memory;
-using CounterStrikeSharp.API.Modules.Utils;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace CounterStrikeSharp.API.Core;
-
-public partial class CTripWireFire : CBaseCSGrenade
-{
-    public CTripWireFire (IntPtr pointer) : base(pointer) {}
-
-}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CTripWireFireProjectile.g.cs

@@ -1,21 +0,0 @@
-// <auto-generated />
-#nullable enable
-#pragma warning disable CS1591
-
-using System;
-using System.Diagnostics;
-using System.Drawing;
-using CounterStrikeSharp;
-using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Memory;
-using CounterStrikeSharp.API.Modules.Utils;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace CounterStrikeSharp.API.Core;
-
-public partial class CTripWireFireProjectile : CBaseGrenade
-{
-    public CTripWireFireProjectile (IntPtr pointer) : base(pointer) {}
-
-}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CWeaponShield.g.cs

@@ -1,33 +0,0 @@
-// <auto-generated />
-#nullable enable
-#pragma warning disable CS1591
-
-using System;
-using System.Diagnostics;
-using System.Drawing;
-using CounterStrikeSharp;
-using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Memory;
-using CounterStrikeSharp.API.Modules.Utils;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace CounterStrikeSharp.API.Core;
-
-public partial class CWeaponShield : CCSWeaponBaseGun
-{
-    public CWeaponShield (IntPtr pointer) : base(pointer) {}
-
-	// m_flBulletDamageAbsorbed
-	[SchemaMember("CWeaponShield", "m_flBulletDamageAbsorbed")]
-	public ref float BulletDamageAbsorbed => ref Schema.GetRef<float>(this.Handle, "CWeaponShield", "m_flBulletDamageAbsorbed");
-
-	// m_flLastBulletHitSoundTime
-	[SchemaMember("CWeaponShield", "m_flLastBulletHitSoundTime")]
-	public ref float LastBulletHitSoundTime => ref Schema.GetRef<float>(this.Handle, "CWeaponShield", "m_flLastBulletHitSoundTime");
-
-	// m_flDisplayHealth
-	[SchemaMember("CWeaponShield", "m_flDisplayHealth")]
-	public ref float DisplayHealth => ref Schema.GetRef<float>(this.Handle, "CWeaponShield", "m_flDisplayHealth");
-
-}

managed/CounterStrikeSharp.API/Core/Schema/Classes/CWeaponZoneRepulsor.g.cs

@@ -1,21 +0,0 @@
-// <auto-generated />
-#nullable enable
-#pragma warning disable CS1591
-
-using System;
-using System.Diagnostics;
-using System.Drawing;
-using CounterStrikeSharp;
-using CounterStrikeSharp.API.Modules.Events;
-using CounterStrikeSharp.API.Modules.Entities;
-using CounterStrikeSharp.API.Modules.Memory;
-using CounterStrikeSharp.API.Modules.Utils;
-using CounterStrikeSharp.API.Core.Attributes;
-
-namespace CounterStrikeSharp.API.Core;
-
-public partial class CWeaponZoneRepulsor : CCSWeaponBaseGun
-{
-    public CWeaponZoneRepulsor (IntPtr pointer) : base(pointer) {}
-
-}

managed/CounterStrikeSharp.API/Core/Schema/Enums/CSPlayerBlockingUseAction_t.g.cs

@@ -13,17 +13,9 @@ public enum CSPlayerBlockingUseAction_t : uint
 	k_CSPlayerBlockingUseAction_DefusingWithKit = 0x2,
 	k_CSPlayerBlockingUseAction_HostageGrabbing = 0x3,
 	k_CSPlayerBlockingUseAction_HostageDropping = 0x4,
-	k_CSPlayerBlockingUseAction_OpeningSafe = 0x5,
-	k_CSPlayerBlockingUseAction_EquippingParachute = 0x6,
-	k_CSPlayerBlockingUseAction_EquippingHeavyArmor = 0x7,
-	k_CSPlayerBlockingUseAction_EquippingContract = 0x8,
-	k_CSPlayerBlockingUseAction_EquippingTabletUpgrade = 0x9,
-	k_CSPlayerBlockingUseAction_TakingOffHeavyArmor = 0xA,
-	k_CSPlayerBlockingUseAction_PayingToOpenDoor = 0xB,
-	k_CSPlayerBlockingUseAction_CancelingSpawnRappelling = 0xC,
-	k_CSPlayerBlockingUseAction_EquippingExoJump = 0xD,
-	k_CSPlayerBlockingUseAction_PickingUpBumpMine = 0xE,
-	k_CSPlayerBlockingUseAction_MapLongUseEntity_Pickup = 0xF,
-	k_CSPlayerBlockingUseAction_MapLongUseEntity_Place = 0x10,
-	k_CSPlayerBlockingUseAction_MaxCount = 0x11,
+	k_CSPlayerBlockingUseAction_EquippingHeavyArmor = 0x5,
+	k_CSPlayerBlockingUseAction_TakingOffHeavyArmor = 0x6,
+	k_CSPlayerBlockingUseAction_MapLongUseEntity_Pickup = 0x7,
+	k_CSPlayerBlockingUseAction_MapLongUseEntity_Place = 0x8,
+	k_CSPlayerBlockingUseAction_MaxCount = 0x9,
 }

managed/CounterStrikeSharp.API/Core/Schema/Enums/CSWeaponType.g.cs

@@ -8,7 +8,7 @@ namespace CounterStrikeSharp.API.Core;
 
 public enum CSWeaponType : uint
 {
-	WEAPONTYPE_KNIFE = 0x0,
+  WEAPONTYPE_KNIFE = 0x0,
 	WEAPONTYPE_PISTOL = 0x1,
 	WEAPONTYPE_SUBMACHINEGUN = 0x2,
 	WEAPONTYPE_RIFLE = 0x3,

managed/CounterStrikeSharp.API/Core/Schema/Enums/EContributionScoreFlag_t.g.cs

@@ -0,0 +1,14 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+
+namespace CounterStrikeSharp.API.Core;
+
+public enum EContributionScoreFlag_t : byte
+{
+	k_EContributionScoreFlag_Default = 0x0,
+	k_EContributionScoreFlag_Objective = 0x1,
+	k_EContributionScoreFlag_Bullets = 0x2,
+}

managed/CounterStrikeSharp.API/Core/Schema/Enums/EDestructiblePartDamagePassThroughType.g.cs

@@ -0,0 +1,13 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+
+namespace CounterStrikeSharp.API.Core;
+
+public enum EDestructiblePartDamagePassThroughType : uint
+{
+	Normal = 0x0,
+	Absorb = 0x1,
+}

managed/CounterStrikeSharp.API/Core/Schema/Enums/EIKEndEffectorRotationFixUpMode.g.cs

@@ -0,0 +1,16 @@
+// <auto-generated />
+#nullable enable
+#pragma warning disable CS1591
+
+using System;
+
+namespace CounterStrikeSharp.API.Core;
+
+public enum EIKEndEffectorRotationFixUpMode : uint
+{
+	None = 0x0,
+	MatchTargetOrientation = 0x1,
+	LookAtTargetForward = 0x2,
+	MaintainParentOrientation = 0x3,
+	Count = 0x4,
+}

managed/CounterStrikeSharp.API/Core/Schema/Enums/GrenadeType_t.g.cs

@@ -13,7 +13,5 @@ public enum GrenadeType_t : uint
 	GRENADE_TYPE_FIRE = 0x2,
 	GRENADE_TYPE_DECOY = 0x3,
 	GRENADE_TYPE_SMOKE = 0x4,
-	GRENADE_TYPE_SENSOR = 0x5,
-	GRENADE_TYPE_SNOWBALL = 0x6,
-	GRENADE_TYPE_TOTAL = 0x7,
+	GRENADE_TYPE_TOTAL = 0x5,
 }

managed/CounterStrikeSharp.API/Core/ScriptContext.cs

@@ -25,6 +25,7 @@
 
 using System;
 using System.Collections.Concurrent;
+using System.Diagnostics;
 using System.Runtime.InteropServices;
 using System.Security;
 using System.Text;

managed/CounterStrikeSharp.API/CounterStrikeSharp.API.csproj

@@ -39,6 +39,7 @@
         <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"/>
+        <PackageReference Include="Tomlyn" Version="0.19.0"/>
     </ItemGroup>
     <ItemGroup>
         <Folder Include="Core\Schema\"/>
@@ -59,9 +60,9 @@
     </PropertyGroup>
     <Target Name="SetSourceRevisionId" BeforeTargets="InitializeSourceControlInformation">
         <Exec
-                Command="git describe --long --always --exclude=* --abbrev=7"
-                ConsoleToMSBuild="True"
-                IgnoreExitCode="False"
+            Command="git describe --long --always --exclude=* --abbrev=7"
+            ConsoleToMSBuild="True"
+            IgnoreExitCode="False"
         >
             <Output PropertyName="SourceRevisionId" TaskParameter="ConsoleOutput"/>
         </Exec>

managed/CounterStrikeSharp.API/Modules/Commands/Targeting/Target.cs

@@ -2,7 +2,9 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
+using CounterStrikeSharp.API.Core;
 using CounterStrikeSharp.API.Modules.Entities;
+using CounterStrikeSharp.API.Modules.Memory;
 using CounterStrikeSharp.API.Modules.Utils;
 
 namespace CounterStrikeSharp.API.Modules.Commands.Targeting;
@@ -12,7 +14,9 @@ public class Target
     private TargetType Type { get; }
     private string Raw { get; }
     private string Slug { get; }
-    
+
+    internal CCSGameRulesProxy? _gameRulesEntity = null;
+
     public static readonly IReadOnlyDictionary<string, TargetType> TargetTypeMap = new Dictionary<string, TargetType>(StringComparer.OrdinalIgnoreCase)
     {
         { "@all", TargetType.GroupAll },
@@ -22,6 +26,7 @@ public class Target
         { "@dead", TargetType.GroupDead },
         { "@!me", TargetType.GroupNotMe },
         { "@me", TargetType.PlayerMe },
+        { "@aim", TargetType.PlayerAim },
         { "@ct", TargetType.TeamCt },
         { "@t", TargetType.TeamT },
         { "@spec", TargetType.TeamSpec }
@@ -31,7 +36,7 @@ public class Target
     private static bool ConstTargetType(string target, out TargetType targetType)
     {
         targetType = TargetType.Invalid;
-        if (!target.StartsWith("@"))
+        if (!target.StartsWith('@'))
         {
             return false;
         }
@@ -45,13 +50,13 @@ public class Target
     {
         targetType = TargetType.Invalid;
         slug = null!;
-        if (!target.StartsWith("#"))
+        if (!target.StartsWith('#'))
         {
             return false;
         }
-        
+
         slug = target.TrimStart('#');
-        if (slug.StartsWith("STEAM")) targetType = TargetType.IdSteamEscaped;
+        if (slug.StartsWith("STEAM") && slug.Contains(':')) targetType = TargetType.IdSteamEscaped;
         else if (!ulong.TryParse(slug, out _)) targetType = TargetType.ExplicitName;
         else if (slug.Length == 17) targetType = TargetType.IdSteam64;
         else targetType = TargetType.IdUserid;
@@ -80,48 +85,39 @@ public class Target
         }
     }
 
-    private bool TargetPredicate(CCSPlayerController player, CCSPlayerController? caller)
+    private bool TargetPredicate(CCSPlayerController player, CCSPlayerController? caller, CCSGameRules? gameRules = null)
     {
-        switch (Type)
+        return Type switch
         {
-            case TargetType.TeamCt:
-                return player.TeamNum == (byte)CsTeam.CounterTerrorist;
-            case TargetType.TeamT:
-                return player.TeamNum == (byte)CsTeam.Terrorist;
-            case TargetType.TeamSpec:
-                return player.TeamNum == (byte)CsTeam.Spectator;
-            case TargetType.GroupAll:
-                return !player.IsHLTV;
-            case TargetType.GroupBots:
-                return player.IsBot;
-            case TargetType.GroupHumans:
-                return !player.IsBot && !player.IsHLTV;
-            case TargetType.GroupAlive:
-                return player.PlayerPawn is { IsValid: true, Value.LifeState: (byte)LifeState_t.LIFE_ALIVE };
-            case TargetType.GroupDead:
-                return player.PlayerPawn is { IsValid: true, Value.LifeState: (byte)LifeState_t.LIFE_DEAD or (byte)LifeState_t.LIFE_DYING };
-            case TargetType.GroupNotMe:
-                return player.SteamID != caller?.SteamID;
-            case TargetType.PlayerMe:
-                return player.SteamID == caller?.SteamID;
-            case TargetType.IdUserid:
-                return player.UserId.ToString() == Slug;
-            case TargetType.IdSteamEscaped:
-                return ((SteamID)player.SteamID).SteamId2 == Slug;
-            case TargetType.IdSteam64:
-                return ((SteamID)player.SteamID).SteamId64.ToString() == Slug;
-            case TargetType.ExplicitName:
-            case TargetType.ImplicitName:
-                return player.PlayerName.Contains(Slug, StringComparison.OrdinalIgnoreCase);
-            default:
-                return false;
-        }
+            TargetType.PlayerAim => caller != null && player == gameRules!.GetClientAimTarget(caller),
+            TargetType.TeamCt => player.Team == CsTeam.CounterTerrorist,
+            TargetType.TeamT => player.Team == CsTeam.Terrorist,
+            TargetType.TeamSpec => player.Team == CsTeam.Spectator,
+            TargetType.GroupAll => !player.IsHLTV,
+            TargetType.GroupBots => player.IsBot,
+            TargetType.GroupHumans => !player.IsBot && !player.IsHLTV,
+            TargetType.GroupAlive => player.PlayerPawn is { IsValid: true, Value.LifeState: (byte)LifeState_t.LIFE_ALIVE },
+            TargetType.GroupDead => player.PlayerPawn is { IsValid: true, Value.LifeState: (byte)LifeState_t.LIFE_DEAD or (byte)LifeState_t.LIFE_DYING },
+            TargetType.GroupNotMe => player.SteamID != caller?.SteamID,
+            TargetType.PlayerMe => player.SteamID == caller?.SteamID,
+            TargetType.IdUserid => player.UserId.ToString() == Slug,
+            TargetType.IdSteamEscaped when player.SteamID != 0 => (SteamID)player.SteamID == (SteamID)Slug,
+            TargetType.IdSteam64 => player.SteamID.ToString() == Slug,
+            TargetType.ExplicitName or TargetType.ImplicitName => player.PlayerName.Contains(Slug, StringComparison.OrdinalIgnoreCase),
+            _ => false
+        };
     }
 
     public TargetResult GetTarget(CCSPlayerController? caller)
     {
-        var players = Utilities.GetPlayers().Where(player => TargetPredicate(player, caller)).ToList();
-        
-        return new TargetResult() { Players = players };
+        if (Type == TargetType.PlayerAim)
+        {
+            if (_gameRulesEntity == null || !_gameRulesEntity.IsValid)
+            {
+                _gameRulesEntity = Utilities.FindAllEntitiesByDesignerName<CCSGameRulesProxy>("cs_gamerules").FirstOrDefault();
+            }
+        }
+
+        return new TargetResult() { Players = Utilities.GetPlayers().Where(player => TargetPredicate(player, caller, _gameRulesEntity?.GameRules)).ToList() };
     }
 }

managed/CounterStrikeSharp.API/Modules/Commands/Targeting/TargetType.cs

@@ -14,6 +14,7 @@ public enum TargetType
     GroupNotMe, // @!me
 
     PlayerMe, // @me
+    PlayerAim, // @aim
 
     IdUserid, // #4
     IdSteamEscaped, // "#STEAM_0:1:8614"
@@ -22,4 +23,4 @@ public enum TargetType
     ExplicitName, // #name
     ImplicitName, // name
     Invalid
-}
+}

managed/CounterStrikeSharp.API/Modules/Config/ConfigManager.cs

@@ -14,18 +14,21 @@
  *  along with CounterStrikeSharp.  If not, see <https://www.gnu.org/licenses/>. *
  */
 
-using System;
-using System.IO;
 using System.Reflection;
 using System.Text;
 using System.Text.Json;
-
-using CounterStrikeSharp.API.Core;
 using CounterStrikeSharp.API.Core.Logging;
 using Microsoft.Extensions.Logging;
+using Tomlyn;
 
 namespace CounterStrikeSharp.API.Modules.Config
 {
+    enum ConfigType
+    {
+        Json,
+        Toml
+    }
+
     public static class ConfigManager
     {
         private static readonly DirectoryInfo? _rootDir;
@@ -33,47 +36,59 @@ namespace CounterStrikeSharp.API.Modules.Config
         private static readonly string _pluginConfigsFolderPath;
         private static ILogger _logger = CoreLogging.Factory.CreateLogger("ConfigManager");
 
+        internal static JsonSerializerOptions JsonSerializerOptions { get; } = new()
+        {
+            WriteIndented = true,
+            ReadCommentHandling = JsonCommentHandling.Skip
+        };
+
+        internal static TomlModelOptions TomlModelOptions { get; } = new()
+        {
+            ConvertPropertyName = name => name
+        };
+
         static ConfigManager()
         {
             _rootDir = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.Parent;
             _pluginConfigsFolderPath = Path.Combine(_rootDir.FullName, "configs", "plugins");
         }
 
-        public static T Load<T>(string pluginName) where T : IBasePluginConfig, new()
+        public static T Load<T>(string pluginName) where T : class, IBasePluginConfig, new()
         {
             string directoryPath = Path.Combine(_pluginConfigsFolderPath, pluginName);
-            string configPath = Path.Combine(directoryPath, $"{pluginName}.json");
-            string exampleConfigPath = Path.Combine(directoryPath, $"{pluginName}.example.json");
+            string configPath = Path.Combine(directoryPath, $"{pluginName}");
+            string exampleConfigPath = Path.Combine(directoryPath, $"{pluginName}.example");
 
-            T config = (T)Activator.CreateInstance(typeof(T))!;
+            string[] configFilePaths =
+            [
+                $"{configPath}.toml",
+                $"{configPath}.json",
+            ];
 
-            if (!File.Exists(configPath) && !File.Exists(exampleConfigPath))
+            foreach (var path in configFilePaths)
             {
-                try
+                if (File.Exists(path))
                 {
-                    if (!Directory.Exists(directoryPath))
-                    {
-                        Directory.CreateDirectory(directoryPath);
-                    }
+                    return Deserialize<T>(path);
+                }
+            }
 
-                    StringBuilder builder = new StringBuilder();
-                    builder.Append(
-                        $"// This configuration was automatically generated by CounterStrikeSharp for plugin '{pluginName}', at {DateTimeOffset.Now:yyyy/MM/dd hh:mm:ss}\n");
-                    builder.Append(JsonSerializer.Serialize<T>(config,
-                        new JsonSerializerOptions { WriteIndented = true }));
-                    File.WriteAllText(configPath, builder.ToString());
-                    return config;
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Failed to generate configuration file for {PluginName}", pluginName);
-                }
-            } else if (File.Exists(exampleConfigPath) && !File.Exists(configPath))
+            string[] exampleFilePaths =
+            [
+                $"{exampleConfigPath}.toml",
+                $"{exampleConfigPath}.json"
+            ];
+
+            foreach (var path in exampleFilePaths)
             {
+                if (!File.Exists(path)) continue;
+
                 try
                 {
                     _logger.LogInformation("Copying example configuration file for {PluginName}", pluginName);
-                    File.Copy(exampleConfigPath, configPath);
+                    var destPath = Path.Combine(directoryPath, Path.GetFileName(path).Replace(".example", ""));
+                    File.Copy(path, destPath);
+                    return Deserialize<T>(destPath);
                 }
                 catch (Exception ex)
                 {
@@ -83,14 +98,58 @@ namespace CounterStrikeSharp.API.Modules.Config
 
             try
             {
-                config = JsonSerializer.Deserialize<T>(File.ReadAllText(configPath), new JsonSerializerOptions() { ReadCommentHandling = JsonCommentHandling.Skip })!;
+                if (!Directory.Exists(directoryPath))
+                {
+                    Directory.CreateDirectory(directoryPath);
+                }
+
+                var config = new T();
+                var output = Serialize(config, ConfigType.Json, pluginName);
+                File.WriteAllText(Path.Combine(directoryPath, $"{pluginName}.json"), output);
+
+                return config;
             }
             catch (Exception ex)
             {
-                _logger.LogError(ex, "Failed to parse configuration file for {PluginName}", pluginName);
+                _logger.LogError(ex, "Failed to generate configuration file for {PluginName}", pluginName);
+                return new T();
+            }
+        }
+
+        private static T Deserialize<T>(string path) where T : class, IBasePluginConfig, new()
+        {
+            switch (Path.GetExtension(path))
+            {
+                case ".toml":
+                    return Toml.ToModel<T>(File.ReadAllText(path), options: TomlModelOptions);
+                case ".json":
+                    return JsonSerializer.Deserialize<T>(File.ReadAllText(path), JsonSerializerOptions)!;
             }
 
-            return config;
+            throw new NotSupportedException("Unsupported configuration file format");
+        }
+
+        private static string Serialize<T>(T config, ConfigType configType, string pluginName) where T : class, IBasePluginConfig, new()
+        {
+            StringBuilder builder = new StringBuilder();
+            string comment =
+                $"This configuration was automatically generated by CounterStrikeSharp for plugin '{pluginName}', at {DateTimeOffset.Now:yyyy/MM/dd hh:mm:ss}\n";
+
+            switch (configType)
+            {
+                case ConfigType.Json:
+                    builder.Append($"// {comment}");
+                    builder.Append(JsonSerializer.Serialize<T>(config, JsonSerializerOptions));
+                    break;
+                case ConfigType.Toml:
+                    builder.Append($"# {comment}");
+                    builder.Append(Toml.FromModel(config, options: TomlModelOptions));
+                    break;
+                default:
+                    throw new NotSupportedException("Unsupported configuration file format");
+            }
+
+            return builder.ToString();
         }
     }
-}
+}

managed/CounterStrikeSharp.API/Modules/Cvars/FakeConVar.cs

@@ -72,6 +72,16 @@ public class FakeConVar<T> where T : IComparable<T>
 
         try
         {
+            var argString = args.ArgString;
+            
+            if (typeof(T) == typeof(string))
+            {
+                if (argString.Length >= 2 && argString.StartsWith('"') && argString.EndsWith('"'))
+                {
+                    argString = argString.Substring(1, argString.Length - 2);
+                }
+            }
+            
             // TODO(dotnet8): Replace with IParsable<T>
             bool success = true;
             T parsedValue = default(T);
@@ -80,11 +90,11 @@ public class FakeConVar<T> where T : IComparable<T>
             {
                 try
                 {
-                    parsedValue = (T)converter.ConvertFromString(args.ArgString);
+                    parsedValue = (T)converter.ConvertFromString(argString);
                 }
                 catch
                 {
-                    success = typeof(T) == typeof(bool) && TryConvertCustomBoolean(args.ArgString, out parsedValue);
+                    success = typeof(T) == typeof(bool) && TryConvertCustomBoolean(argString, out parsedValue);
                 }
             }
 
@@ -137,4 +147,4 @@ public class FakeConVar<T> where T : IComparable<T>
         _value = value;
         ValueChanged?.Invoke(this, _value);
     }
-}
+}

managed/CounterStrikeSharp.API/Modules/Events/EventPlayerChat.cs

@@ -0,0 +1,41 @@
+using System;
+using CounterStrikeSharp.API.Core;
+using CounterStrikeSharp.API.Core.Attributes;
+using CounterStrikeSharp.API.Modules.Entities;
+
+namespace CounterStrikeSharp.API.Modules.Events
+{
+    [EventName("player_chat")]
+    public class EventPlayerChat : GameEvent
+    {
+        public EventPlayerChat(IntPtr pointer) : base(pointer){}
+        public EventPlayerChat(bool force) : base("player_chat", force){}
+
+        /// <summary>
+        /// If this chat message was sent to team only
+        /// </summary>
+        public bool Teamonly
+        {
+            get => Get<bool>("teamonly");
+            set => Set<bool>("teamonly", value);
+        }
+
+        /// <summary>
+        /// The user ID of the player who sent the chat message
+        /// </summary>
+        public int Userid
+        {
+            get => Get<int>("userid");
+            set => Set<int>("userid", value);
+        }
+
+        /// <summary>
+        /// The text content of the chat message
+        /// </summary>
+        public string Text
+        {
+            get => Get<string>("text");
+            set => Set<string>("text", value);
+        }
+    }
+}

managed/CounterStrikeSharp.API/Modules/Extensions/PluginConfigExtensions.cs

@@ -0,0 +1,125 @@
+using System.Text.Json;
+using System.Reflection;
+using System.Runtime.Serialization;
+using CounterStrikeSharp.API.Modules.Config;
+using Tomlyn;
+
+namespace CounterStrikeSharp.API.Modules.Extensions;
+
+public static class PluginConfigExtensions
+{
+    public static JsonSerializerOptions JsonSerializerOptions => ConfigManager.JsonSerializerOptions;
+
+    /// <summary>
+    /// Gets the configuration file path
+    /// </summary>
+    /// <typeparam name="T">Type of the plugin configuration.</typeparam>
+    /// <param name="_">Current configuration instance</param>
+    public static string GetConfigPath<T>(this T _) where T : BasePluginConfig, new()
+    {
+        string assemblyName = typeof(T).Assembly.GetName().Name ?? string.Empty;
+
+        string[] configFilePaths =
+        [
+            Path.Combine(Server.GameDirectory, "csgo", "addons", "counterstrikesharp", "configs", "plugins", assemblyName,
+                $"{assemblyName}.json"),
+            Path.Combine(Server.GameDirectory, "csgo", "addons", "counterstrikesharp", "configs", "plugins", assemblyName,
+                $"{assemblyName}.toml"),
+        ];
+
+        foreach (var path in configFilePaths)
+        {
+            if (File.Exists(path))
+            {
+                return path;
+            }
+        }
+
+        return configFilePaths[0];
+    }
+
+    /// <summary>
+    /// Updates the configuration file
+    /// </summary>
+    /// <typeparam name="T">Type of the plugin configuration.</typeparam>
+    /// <param name="config">Current configuration instance</param>
+    public static void Update<T>(this T config) where T : BasePluginConfig, new()
+    {
+        var configPath = config.GetConfigPath();
+
+        try
+        {
+            using var stream = new FileStream(configPath, FileMode.Create, FileAccess.Write, FileShare.None);
+            using var writer = new StreamWriter(stream);
+
+            switch (Path.GetExtension(configPath))
+            {
+                case ".json":
+                {
+                    writer.Write(JsonSerializer.Serialize(config, ConfigManager.JsonSerializerOptions));
+                    break;
+                }
+                case ".toml":
+                    writer.Write(Toml.FromModel(config, ConfigManager.TomlModelOptions));
+                    break;
+                default:
+                    throw new NotSupportedException($"Configuration file type '{Path.GetExtension(configPath)}' is not supported.");
+            }
+
+
+        }
+        catch (Exception ex)
+        {
+            throw new Exception($"Failed to update configuration file at '{configPath}'.", ex);
+        }
+    }
+
+    /// <summary>
+    /// Reloads the configuration file and updates current configuration instance.
+    /// </summary>
+    /// <typeparam name="T">Type of the plugin configuration.</typeparam>
+    /// <param name="config">Current configuration instance</param>
+    public static void Reload<T>(this T config) where T : BasePluginConfig, new()
+    {
+        var configPath = config.GetConfigPath();
+
+        try
+        {
+            if (!File.Exists(configPath))
+            {
+                throw new FileNotFoundException($"Configuration file '{configPath} not found.");
+            }
+
+            var configContent = File.ReadAllText(configPath);
+
+            T? newConfig = null;
+            switch (Path.GetExtension(configPath))
+            {
+                case ".json":
+                    newConfig = JsonSerializer.Deserialize<T>(configContent, ConfigManager.JsonSerializerOptions)
+                                ?? throw new JsonException($"Deserialization failed for configuration file '{configPath}'.");
+                    break;
+                case ".toml":
+                    newConfig = Toml.ToModel<T>(configContent, options: ConfigManager.TomlModelOptions);
+                    break;
+            }
+
+            if (newConfig is null)
+            {
+                throw new SerializationException($"Deserialization failed for configuration file '{configPath}'.");
+            }
+
+            foreach (var property in typeof(T).GetProperties(BindingFlags.Instance | BindingFlags.Public))
+            {
+                if (property.CanWrite)
+                {
+                    property.SetValue(config, property.GetValue(newConfig));
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            throw new Exception($"Failed to reload configuration file at '{configPath}'.", ex);
+        }
+    }
+}