game.maxplayers was obsolete

Co-authored-by: lzk <124214523+lzk228@users.noreply.github.com>

.editorconfig

@@ -115,6 +115,8 @@ csharp_new_line_before_finally = true
 csharp_new_line_before_members_in_object_initializers = false
 csharp_new_line_before_open_brace = all
 csharp_new_line_between_query_expression_clauses = true
+resharper_csharp_place_simple_embedded_statement_on_same_line = never
+resharper_csharp_keep_existing_embedded_arrangement = false
 
 # Indentation preferences
 #csharp_indent_block_contents = true
@@ -194,7 +196,7 @@ csharp_preserve_single_line_blocks = true
 #dotnet_naming_style.begins_with_i.word_separator =
 #dotnet_naming_style.begins_with_i.capitalization = pascal_case
 
-
+dotnet_diagnostic.IDE0055.severity = warning
 
 dotnet_naming_rule.constants_rule.severity = warning
 dotnet_naming_rule.constants_rule.style = upper_camel_case_style

.envrc

@@ -0,0 +1,4 @@
+if ! has nix_direnv_version || ! nix_direnv_version 2.3.0; then
+    source_url "https://raw.githubusercontent.com/nix-community/nix-direnv/2.3.0/direnvrc" "sha256-Dmd+j63L84wuzgyjITIfSxSD57Tx7v51DMxVZOsiUD8="
+fi
+use flake

.github/CODEOWNERS

@@ -2,3 +2,6 @@
 
 # Ping for all PRs
 * @Morb0
+
+# Ping for all PRs that include translations/editing fluent strings
+*.ftl @ficcialfaint

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,5 +1,5 @@
 name: "Сообщить о проблеме"
-description: "Если что-то работает не так, как ожидалось"
+description: "Если что-то работает не так, как ожидалось."
 labels: ["triage"]
 body:
   - type: textarea
@@ -14,7 +14,7 @@ body:
     id: reproduction
     attributes:
       label: "Шаги воспроизведения"
-      description: "Если применимо, опишите шаги для воспроизведения проблемы"
+      description: "Если приемлемо, опишите шаги для воспроизведения проблемы"
       placeholder: |
         1. Открыть интерфейс консоли
         2. Нажать кнопку "Старт"
@@ -25,5 +25,5 @@ body:
     attributes:
       label: "Скриншоты"
       description: |
-        Если применимо, добавьте скриншоты, чтобы помочь объяснить вашу проблему
-        **Подсказка**: Вы можете прикрепить изображения, щелкнув по этой области, чтобы выделить ее, а затем перетащив в нее файлы
+        Если приемлемо, добавьте скриншоты, чтобы помочь объяснить вашу проблему
+        **Подсказка**: Вы можете прикрепить изображения щелкнув по области ниже, чтобы выделить её, а затем перетащив в нее файлы

.github/ISSUE_TEMPLATE/config.yml

@@ -4,4 +4,4 @@ contact_links:
     about: Свои предложения можете оставлять в соответствующем канале Discord.
   - name: Сообщить об уязвимости
     url: https://discord.station14.ru
-    about: Пожалуйста, сообщайте о серьезных эксплойтах и уязвимостях безопасности Morty#7384 в Discord.
+    about: Пожалуйста, сообщайте о серьезных эксплойтах и уязвимостях безопасности Morty#7384 (369476049836310528) в Discord.

.github/ISSUE_TEMPLATE/toolshed-feature-request.md

@@ -0,0 +1,18 @@
+---
+name: Toolshed feature request
+about: Suggest a feature for Toolshed (for game admins/developers)
+title: "[TOOLSHED REQUEST]"
+labels: Toolshed
+assignees: moonheart08
+
+---
+
+**Is your feature request related to a problem/bug? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the command you'd like**
+A clear and concise description of what you want and what it should do.
+If you're a technical user (i.e. programmer) including type signatures is helpful.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,27 +1,36 @@
-<!-- Текст между стрелками - это комментарии - они не будут видны в вашем PR. -->
+<!-- ЭТО ШАБЛОН ВАШЕГО PULL REQUEST. Текст между стрелками - это комментарии - они не будут видны в PR. -->
 
-## Описание PR <!-- Опишите здесь ваш Pull Request. Что он изменяет? На что еще это может повлиять? -->
+## Описание PR
+<!-- Ниже опишите ваш Pull Request. Что он изменяет? На что еще это может повлиять? Постарайтесь описать все внесённые вами изменения! -->
 
-**Скриншоты**
+**Медиа**
 <!-- Если приемлемо, добавьте скриншоты для демонстрации вашего PR. Если ваш PR представляет собой визуальное изменение, добавьте
 скриншоты, иначе он может быть закрыт. -->
 
+**Проверки**
+<!-- Выполнение всех следующих действий, если это приемлемо для вида изменений сильно ускорит разбор вашего PR -->
+- [ ] PR полностью завершён и мне не нужна помощь чтобы его закончить.
+- [ ] Я внимательно просмотрел все свои изменения и багов в них не нашёл.
+- [ ] Я запускал локальный сервер со своими изменениями и всё протестировал.
+- [ ] Я добавил скриншот/видео демонстрации PR в игре, **или** этот PR этого не требует.
+
 **Изменения**
 <!--
-Здесь вы можете написать список изменений, который будет автоматически добавлен в игру, когда ваш PR будет принят
-Для записей в списке изменений есть 4 значка: add, remove, tweak, fix. Думаю, вы сможете разобраться с остальным.
+Здесь вы можете написать список изменений, который будет автоматически добавлен в игру, когда ваш PR будет принят.
 
-Вы можете поставить свое имя после символа :cl:, чтобы изменить имя, которое будет отображаться в журнале изменений (в противном случае будет использоваться ваше имя пользователя GitHub)
-Например: :cl: PJB
+В журнал изменений следует помещать только то, что действительно важно игрокам.
 
-Как правило, в журналы изменений следует помещать только то, что действительно важно игрокам. Вещи вроде "Переработана система X, изменения не должны быть видны" не должны быть в журнале изменений.
+В списке изменений тип значка не является часть предложения, поэтому явно указывайте - Добавлен, Удалён, Изменён.
+плохо: - add: Новый инструмент для инженеров
+хорошо: - add: Добавлен новый инструмент для инженеров
+
+Вы можете указать своё имя после символа :cl: именно оно будет отображаться в журнале изменений (иначе будет использоваться ваше имя на GitHub)
+Например: :cl: Ian
 
-При написании списка изменений не считайте суффикс типа записи (например, add) "частью" предложения:
-плохо: - add: новый инструмент для инженеров
-хорошо: - add: добавлен новый инструмент для инженеров
 -->
 
 :cl:
 - add: Добавлено веселье!
 - remove: Убрано веселье!
-
+- tweak: Изменено веселье!
+- fix: Исправлено веселье!

.github/workflows/benchmarks.yml

@@ -0,0 +1,47 @@
+name: Benchmarks
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0 8 * * *'
+
+concurrency: benchmarks
+
+jobs:
+  benchmark:
+    name: Run Benchmarks
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3.6.0
+      with:
+        submodules: 'recursive'
+    - name: Get Engine version
+      run: |
+        cd RobustToolbox
+        git fetch --depth=1
+        echo "::set-output name=out::$(git rev-parse HEAD)"
+      id: engine_version
+    - name: Run script on centcomm
+      uses: appleboy/ssh-action@master
+      with:
+        host: centcomm.spacestation14.io
+        username: robust-benchmark-runner
+        key: ${{ secrets.CENTCOMM_ROBUST_BENCHMARK_RUNNER_KEY }}
+        command_timeout: 100000m
+        script: |
+          mkdir benchmark_run_content_${{ github.sha }}
+          cd benchmark_run_content_${{ github.sha }}
+          git clone https://github.com/space-wizards/space-station-14.git repo_dir --recursive
+          cd repo_dir
+          git checkout ${{ github.sha }}
+          cd Content.Benchmarks
+          dotnet restore
+          export ROBUST_BENCHMARKS_ENABLE_SQL=1
+          export ROBUST_BENCHMARKS_SQL_ADDRESS="${{ secrets.BENCHMARKS_WRITE_ADDRESS }}"
+          export ROBUST_BENCHMARKS_SQL_PORT="${{ secrets.BENCHMARKS_WRITE_PORT }}"
+          export ROBUST_BENCHMARKS_SQL_USER="${{ secrets.BENCHMARKS_WRITE_USER }}"
+          export ROBUST_BENCHMARKS_SQL_PASSWORD="${{ secrets.BENCHMARKS_WRITE_PASSWORD  }}"
+          export ROBUST_BENCHMARKS_SQL_DATABASE="content_benchmarks"
+          export GITHUB_SHA="${{ github.sha }}"
+          dotnet run --filter '*' --configuration Release
+          cd ../../..
+          rm -rf benchmark_run_content_${{ github.sha }}

.github/workflows/build-docfx.yml

@@ -0,0 +1,41 @@
+name: Build & Publish Docfx
+
+on:
+  schedule:
+    - cron: "0 0 * * 0"
+
+jobs:
+  docfx:
+   runs-on: ubuntu-latest
+   steps:
+    - uses: actions/checkout@v3.6.0
+    - name: Setup submodule
+      run: |
+        git submodule update --init --recursive
+    - name: Pull engine updates
+      uses: space-wizards/submodule-dependency@v0.1.5
+    - name: Update Engine Submodules
+      run: |
+        cd RobustToolbox/
+        git submodule update --init --recursive
+    - name: Setup .NET Core
+      uses: actions/setup-dotnet@v3.2.0
+      with:
+        dotnet-version: 7.0.x
+
+    - name: Install dependencies
+      run: dotnet restore
+
+    - name: Build Project
+      run: dotnet build --no-restore /p:WarningsAsErrors=nullable
+
+    - name: Build DocFX
+      uses: nikeee/docfx-action@v1.0.0
+      with:
+        args: Content.Docfx/docfx.json
+
+    - name: Publish Docfx Documentation on GitHub Pages
+      uses: maxheld83/ghpages@master
+      env:
+        BUILD_DIR: Content.Docfx/_content-site
+        GH_PAT: ${{ secrets.GH_PAT }}

.github/workflows/build-map-renderer.yml

@@ -0,0 +1,57 @@
+name: Build & Test Map Renderer
+
+on:
+  push:
+    branches: [ master, staging, trying ]
+  merge_group:
+  pull_request:
+    types: [ opened, reopened, synchronize, ready_for_review ]
+    branches: [ master ]
+
+jobs:
+  build:
+    if: github.actor != 'PJBot' && github.event.pull_request.draft == false
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: Checkout Master
+        uses: actions/checkout@v3.6.0
+
+      - name: Setup Submodule
+        run: |
+          git submodule update --init --recursive
+
+      - name: Pull engine updates
+        uses: space-wizards/submodule-dependency@v0.1.5
+
+      - name: Update Engine Submodules
+        run: |
+          cd RobustToolbox/
+          git submodule update --init --recursive
+
+      - name: Setup .NET Core
+        uses: actions/setup-dotnet@v3.2.0
+        with:
+          dotnet-version: 7.0.x
+
+      - name: Install dependencies
+        run: dotnet restore
+
+      - name: Build Project
+        run: dotnet build Content.MapRenderer --configuration Release --no-restore /p:WarningsAsErrors=nullable /m
+
+      - name: Run Map Renderer
+        run: dotnet run --project Content.MapRenderer Dev
+
+  ci-success:
+    name: Build & Test Debug
+    needs:
+      - build
+    runs-on: ubuntu-latest
+    steps:
+      - name: CI succeeded
+        run: exit 0

.github/workflows/build-test-debug.yml

@@ -2,30 +2,15 @@ name: Build & Test Debug
 
 on:
   push:
-    branches: [ master ]
-    paths:
-      - '**.cs'
-      - '**.csproj'
-      - '**.sln'
-      - '**.git**'
-      - '**.yml'
-      # no docs on which one of these is supposed to work, so
-      # why not just do both
-      - 'RobustToolbox'
-      - 'RobustToolbox/**'
+    branches: [ master, staging, trying ]
+  merge_group:
   pull_request:
+    types: [ opened, reopened, synchronize, ready_for_review ]
     branches: [ master ]
-    paths:
-      - '**.cs'
-      - '**.csproj'
-      - '**.sln'
-      - '**.git**'
-      - '**.yml'
-      - 'RobustToolbox'
-      - 'RobustToolbox/**'
 
 jobs:
   build:
+    if: github.actor != 'IanComradeBot' && github.event.pull_request.draft == false
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest]
@@ -34,7 +19,7 @@ jobs:
 
     steps:
     - name: Checkout Master
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3.6.0
 
     - name: Setup Submodule
       run: |
@@ -49,21 +34,29 @@ jobs:
         git submodule update --init --recursive
 
     - name: Setup .NET Core
-      uses: actions/setup-dotnet@v1
+      uses: actions/setup-dotnet@v3.2.0
       with:
-        dotnet-version: 6.0.x
+        dotnet-version: 7.0.x
 
     - name: Install dependencies
       run: dotnet restore
 
     - name: Build Project
-      run: dotnet build --configuration Debug --no-restore /p:WarningsAsErrors=nullable /m
+      run: dotnet build --configuration DebugOpt --no-restore /p:WarningsAsErrors=nullable /m
 
     - name: Run Content.Tests
-      run: dotnet test --no-build Content.Tests/Content.Tests.csproj -- NUnit.ConsoleOut=0
+      run: dotnet test --no-build --configuration DebugOpt Content.Tests/Content.Tests.csproj -- NUnit.ConsoleOut=0
 
     - name: Run Content.IntegrationTests
       shell: pwsh
       run: |
         $env:DOTNET_gcServer=1
-        dotnet test --no-build Content.IntegrationTests/Content.IntegrationTests.csproj -- NUnit.ConsoleOut=0
+        dotnet test --no-build --configuration DebugOpt Content.IntegrationTests/Content.IntegrationTests.csproj -- NUnit.ConsoleOut=0 NUnit.MapWarningTo=Failed
+  ci-success:
+    name: Build & Test Debug
+    needs:
+      - build
+    runs-on: ubuntu-latest
+    steps:
+      - name: CI succeeded
+        run: exit 0

.github/workflows/build-test-release.yml

@@ -2,30 +2,15 @@ name: Build & Test Release
 
 on:
   push:
-    branches: [ master ]
-    paths:
-      - '**.cs'
-      - '**.csproj'
-      - '**.sln'
-      - '**.git**'
-      - '**.yml'
-      # no docs on which one of these is supposed to work, so
-      # why not just do both
-      - 'RobustToolbox'
-      - 'RobustToolbox/**'
+    branches: [ master, staging, trying ]
+  merge_group:
   pull_request:
+    types: [ opened, reopened, synchronize, ready_for_review ]
     branches: [ master ]
-    paths:
-      - '**.cs'
-      - '**.csproj'
-      - '**.sln'
-      - '**.git**'
-      - '**.yml'
-      - 'RobustToolbox'
-      - 'RobustToolbox/**'
 
 jobs:
   build:
+    if: github.actor != 'IanComradeBot' && github.event.pull_request.draft == false
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest]
@@ -34,7 +19,7 @@ jobs:
 
     steps:
     - name: Checkout Master
-      uses: actions/checkout@v2
+      uses: actions/checkout@v3.6.0
 
     - name: Setup Submodule
       run: |
@@ -49,21 +34,29 @@ jobs:
         git submodule update --init --recursive
 
     - name: Setup .NET Core
-      uses: actions/setup-dotnet@v1
+      uses: actions/setup-dotnet@v3.2.0
       with:
-        dotnet-version: 6.0.x
+        dotnet-version: 7.0.x
 
     - name: Install dependencies
       run: dotnet restore
 
     - name: Build Project
-      run: dotnet build --configuration Release --no-restore /p:WarningsAsErrors=nullable /m
+      run: dotnet build --configuration Tools --no-restore /p:WarningsAsErrors=nullable /m
 
     - name: Run Content.Tests
-      run: dotnet test --no-build Content.Tests/Content.Tests.csproj -- NUnit.ConsoleOut=0
+      run: dotnet test --configuration Tools --no-build Content.Tests/Content.Tests.csproj -- NUnit.ConsoleOut=0
 
     - name: Run Content.IntegrationTests
       shell: pwsh
       run: |
         $env:DOTNET_gcServer=1
-        dotnet test --no-build Content.IntegrationTests/Content.IntegrationTests.csproj -- NUnit.ConsoleOut=0
+        dotnet test --configuration Tools --no-build Content.IntegrationTests/Content.IntegrationTests.csproj -- NUnit.ConsoleOut=0 NUnit.MapWarningTo=Failed
+  ci-success:
+    name: Build & Test Release
+    needs:
+      - build
+    runs-on: ubuntu-latest
+    steps:
+      - name: CI succeeded
+        run: exit 0

.github/workflows/conflict-labeler.yml

@@ -8,6 +8,7 @@ on:
 
 jobs:
   Label:
+    if: github.actor != 'IanComradeBot'
     runs-on: ubuntu-latest
     steps:
       - name: Check for Merge Conflicts

.github/workflows/labeler-approve.yml

@@ -1,11 +1,13 @@
 name: "Labels: Approve"
 
 on:
-  pull_request_target:
+  pull_request_review:
     types: [submitted]
 
 jobs:
   remove_label:
+    permissions:
+      pull-requests: write
     if: github.event.review.state == 'approved'
     runs-on: ubuntu-latest
     steps:

.github/workflows/labeler-changes.yml

@@ -0,0 +1,19 @@
+name: "Labels: Changes"
+
+on:
+  pull_request_review:
+    types: [submitted]
+
+jobs:
+  update_label:
+    permissions:
+      pull-requests: write
+    if: github.event.review.state == 'changes_requested'
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions-ecosystem/action-add-labels@v1
+      with:
+        labels: "Status: Awaiting Changes"
+    - uses: actions-ecosystem/action-remove-labels@v1
+      with:
+        labels: "Status: Needs Review"

.github/workflows/labeler-pr.yml

@@ -5,6 +5,7 @@ on:
 
 jobs:
   labeler:
+    if: github.actor != 'IanComradeBot'
     runs-on: ubuntu-latest
     steps:
     - uses: actions/labeler@v3

.github/workflows/no-submodule-update.yml

@@ -0,0 +1,14 @@
+name: No submodule update checker
+
+on:
+  pull_request:
+    paths:
+      - 'RobustToolbox'
+
+jobs:
+  this_aint_right:
+    name: Submodule update in pr found
+    runs-on: ubuntu-latest
+    steps:
+      - name: Fail
+        run: exit 1

.github/workflows/publish.yml

@@ -13,13 +13,33 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+#    - name: Install dependencies
+#      run: sudo apt-get install -y python3-paramiko
+
+    - uses: actions/checkout@v3.6.0
       with:
         submodules: 'recursive'
+
+    # Corvax-Secrets-Start
+    - name: Setup secrets
+      env:
+        SSH_KEY: ${{ secrets.SECRETS_PRIVATE_KEY }}
+      if: ${{ env.SSH_KEY != '' }}
+      run: |
+        mkdir ~/.ssh
+        echo "${{ secrets.SECRETS_PRIVATE_KEY }}" > ~/.ssh/id_rsa
+        chmod 600 ~/.ssh/id_rsa
+        echo "HOST *" > ~/.ssh/config
+        echo "StrictHostKeyChecking no" >> ~/.ssh/config
+        git -c submodule.Secrets.update=checkout submodule update --init
+        cp -R Secrets/Prototypes Resources/Prototypes/CorvaxSecrets
+        cp -R Secrets/ServerPrototypes Resources/Prototypes/CorvaxSecretsServer
+    # Corvax-Secrets-End
+
     - name: Setup .NET Core
-      uses: actions/setup-dotnet@v1
+      uses: actions/setup-dotnet@v3.2.0
       with:
-        dotnet-version: 6.0.100
+        dotnet-version: 7.0.x
 
     - name: Get Engine Tag
       run: |
@@ -40,19 +60,31 @@ jobs:
         mv release/*.zip "release/${{ github.sha }}"
 
     - name: Upload files to mothership
-      uses: appleboy/scp-action@master
+      uses: burnett01/rsync-deployments@5.2
       with:
-        host: 108.61.171.191
-        username: deployer
-        key: ${{ secrets.BUILDS_SSH_KEY }}
-        source: "release/${{ github.sha }}"
-        target: "/var/www/builds.station14.ru/syndicate/builds/"
-        strip_components: 1
+        switches: -avzr --ignore-existing
+        path: "release/${{ github.sha }}"
+        remote_path: ${{ secrets.BUILDS_PATH }}
+        remote_host: ${{ secrets.BUILDS_HOST }}
+        remote_user: ${{ secrets.BUILDS_USERNAME }}
+        remote_key: ${{ secrets.BUILDS_SSH_KEY }}
 
     - name: Update manifest JSON
       uses: appleboy/ssh-action@master
       with:
-        host: 108.61.171.191
-        username: deployer
+        host: ${{ secrets.BUILDS_HOST }}
+        username: ${{ secrets.BUILDS_USERNAME }}
         key: ${{ secrets.BUILDS_SSH_KEY }}
         script: node ~/scripts/push_to_manifest.js -fork syndicate -id ${{ github.sha }}
+
+#    - name: Publish changelog (Discord)
+#      run: Tools/actions_changelogs_since_last_run.py
+#      env:
+#        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+#        DISCORD_WEBHOOK_URL: ${{ secrets.CHANGELOG_DISCORD_WEBHOOK }}
+#        TRANSLATION_API_URL: ${{ secrets.CHANGELOG_TRANSLATION_API_URL }}
+#
+#    - name: Publish changelog (RSS)
+#      run: Tools/actions_changelog_rss.py
+#      env:
+#        CHANGELOG_RSS_KEY: ${{ secrets.CHANGELOG_RSS_KEY }}

.github/workflows/rsi-diff.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3.6.0
 
       - name: Get changed files
         id: files

.github/workflows/test-packaging.yml

@@ -2,7 +2,7 @@
 
 on:
   push:
-    branches: [ master ]
+    branches: [ master, staging, trying ]
     paths:
       - '**.cs'
       - '**.csproj'
@@ -13,7 +13,9 @@ on:
       # why not just do both
       - 'RobustToolbox'
       - 'RobustToolbox/**'
+  merge_group:
   pull_request:
+    types: [ opened, reopened, synchronize, ready_for_review ]
     branches: [ master ]
     paths:
       - '**.cs'
@@ -26,11 +28,13 @@ on:
 
 jobs:
   build:
+    name: Test Packaging
+    if: github.actor != 'IanComradeBot' && github.event.pull_request.draft == false
     runs-on: ubuntu-latest
 
     steps:
       - name: Checkout Master
-        uses: actions/checkout@v2
+        uses: actions/checkout@v3.6.0
 
       - name: Setup Submodule
         run: |
@@ -43,11 +47,25 @@ jobs:
         run: |
           cd RobustToolbox/
           git submodule update --init --recursive
+          
+      # Corvax-Secrets-Start
+      - name: Setup secrets
+        env:
+          SSH_KEY: ${{ secrets.SECRETS_PRIVATE_KEY }}
+        if: ${{ env.SSH_KEY != '' }}
+        run: |
+          mkdir ~/.ssh
+          echo "${{ secrets.SECRETS_PRIVATE_KEY }}" > ~/.ssh/id_rsa
+          chmod 600 ~/.ssh/id_rsa
+          echo "HOST *" > ~/.ssh/config
+          echo "StrictHostKeyChecking no" >> ~/.ssh/config
+          git -c submodule.Secrets.update=checkout submodule update --init
+      # Corvax-Secrets-End
 
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
+        uses: actions/setup-dotnet@v3.2.0
         with:
-          dotnet-version: 6.0.x
+          dotnet-version: 7.0.x
 
       - name: Install dependencies
         run: dotnet restore

.github/workflows/update-wiki.yml

@@ -1,6 +1,7 @@
 name: Update Wiki
 
 on:
+  workflow_dispatch:
   push:
     branches: [ master, jsondump ]
     paths:
@@ -18,54 +19,54 @@ jobs:
     name: Build and Publish JSON blobs to wiki
     runs-on: ubuntu-latest
 
-    steps:    
+    steps:
     - name: Checkout Master
-      uses: actions/checkout@v2
-      
+      uses: actions/checkout@v3.6.0
+
     - name: Setup Submodule
       run: |
         git submodule update --init --recursive
-    
+
     - name: Pull Engine Updates
       uses: space-wizards/submodule-dependency@v0.1.5
-    
+
     - name: Update Engine Submodules
       run: |
         cd RobustToolbox/
         git submodule update --init --recursive
-    
+
     - name: Setup .NET Core
-      uses: actions/setup-dotnet@v1
+      uses: actions/setup-dotnet@v3.2.0
       with:
-        dotnet-version: 6.0.100
-   
+        dotnet-version: 7.0.x
+
     - name: Install Dependencies
       run: dotnet restore
-    
+
     - name: Build Project
       run: dotnet build --configuration Release --no-restore /p:WarningsAsErrors=nullable /m
-    
+
     - name: Generate JSON blobs for prototypes
       run: dotnet ./bin/Content.Server/Content.Server.dll --cvar autogen.destination_file=prototypes.json
       continue-on-error: true
-    
+
     - name: Upload chem_prototypes.json to wiki
       uses: jtmullen/mediawiki-edit-action@v0.1.1
       with:
         wiki_text_file: ./bin/Content.Server/data/chem_prototypes.json
         edit_summary: Update chem_prototypes.json via GitHub Actions
         page_name: "${{ secrets.WIKI_PAGE_ROOT }}/chem_prototypes.json"
-        api_url: https://wiki.station14.ru/api.php
+        api_url: ${{ secrets.WIKI_ROOT_URL }}/api.php
         username: ${{ secrets.WIKI_BOT_USER }}
         password: ${{ secrets.WIKI_BOT_PASS }}
-    
+
     - name: Upload react_prototypes.json to wiki
       uses: jtmullen/mediawiki-edit-action@v0.1.1
       with:
         wiki_text_file: ./bin/Content.Server/data/react_prototypes.json
         edit_summary: Update react_prototypes.json via GitHub Actions
         page_name: "${{ secrets.WIKI_PAGE_ROOT }}/react_prototypes.json"
-        api_url: https://wiki.station14.ru/api.php
+        api_url: ${{ secrets.WIKI_ROOT_URL }}/api.php
         username: ${{ secrets.WIKI_BOT_USER }}
         password: ${{ secrets.WIKI_BOT_PASS }}
 

.github/workflows/validate-rgas.yml

@@ -0,0 +1,38 @@
+name: RGA schema validator
+on:
+  push:
+    branches: [ master, staging, trying ]
+  merge_group:
+  pull_request:
+    types: [ opened, reopened, synchronize, ready_for_review ]
+
+jobs:
+  yaml-schema-validation:
+    name: YAML RGA schema validator
+    if: github.actor != 'IanComradeBot' && github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3.6.0
+    - name: Setup Submodule
+      run: git submodule update --init
+    # Corvax-Secrets-Start
+    - name: Setup secrets
+      env:
+        SSH_KEY: ${{ secrets.SECRETS_PRIVATE_KEY }}
+      if: ${{ env.SSH_KEY != '' }}
+      run: |
+        mkdir ~/.ssh
+        echo "${{ secrets.SECRETS_PRIVATE_KEY }}" > ~/.ssh/id_rsa
+        chmod 600 ~/.ssh/id_rsa
+        echo "HOST *" > ~/.ssh/config
+        echo "StrictHostKeyChecking no" >> ~/.ssh/config
+        git -c submodule.Secrets.update=checkout submodule update --init
+    # Corvax-Secrets-End
+    - name: Pull engine updates
+      uses: space-wizards/submodule-dependency@v0.1.5
+    - uses: PaulRitter/yaml-schema-validator@v1
+      with:
+        schema: RobustToolbox/Schemas/rga.yml
+        path_pattern: .*attributions.ya?ml$
+        validators_path: RobustToolbox/Schemas/rga_validators.py
+        validators_requirements: RobustToolbox/Schemas/rga_requirements.txt

.github/workflows/validate-rsis.yml

@@ -1,18 +1,39 @@
 name: RSI Validator
 
 on:
-  pull_request: 
+  push:
+    branches: [ staging, trying ]
+  merge_group:
+  pull_request:
     paths:
       - '**.rsi/**'
+
 jobs:
   validate_rsis:
     name: Validate RSIs
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - name: Parse files
-        uses: space-wizards/json-schema-validator@v1.0.2
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          json_schema: .github/rsi-schema.json
-          json_path_pattern: .*meta.json$
+      - uses: actions/checkout@v3.6.0
+      - name: Setup Submodule
+        run: git submodule update --init
+      # Corvax-Secrets-Start
+      - name: Setup secrets
+        env:
+          SSH_KEY: ${{ secrets.SECRETS_PRIVATE_KEY }}
+        if: ${{ env.SSH_KEY != '' }}
+        run: |
+          mkdir ~/.ssh
+          echo "${{ secrets.SECRETS_PRIVATE_KEY }}" > ~/.ssh/id_rsa
+          chmod 600 ~/.ssh/id_rsa
+          echo "HOST *" > ~/.ssh/config
+          echo "StrictHostKeyChecking no" >> ~/.ssh/config
+          git -c submodule.Secrets.update=checkout submodule update --init
+      # Corvax-Secrets-End
+      - name: Pull engine updates
+        uses: space-wizards/submodule-dependency@v0.1.5
+      - name: Install Python dependencies
+        run: |
+          pip3 install --ignore-installed --user pillow jsonschema
+      - name: Validate RSIs
+        run: |
+          python3 RobustToolbox/Schemas/validate_rsis.py Resources/

.github/workflows/validate_mapfiles.yml

@@ -0,0 +1,38 @@
+name: Map file schema validator
+on:
+  push:
+    branches: [ master, staging, trying ]
+  merge_group:
+  pull_request:
+    types: [ opened, reopened, synchronize, ready_for_review ]
+
+jobs:
+  yaml-schema-validation:
+    name: YAML map schema validator
+    if: github.actor != 'IanComradeBot' && github.event.pull_request.draft == false
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3.6.0
+    - name: Setup Submodule
+      run: git submodule update --init
+    # Corvax-Secrets-Start
+    - name: Setup secrets
+      env:
+        SSH_KEY: ${{ secrets.SECRETS_PRIVATE_KEY }}
+      if: ${{ env.SSH_KEY != '' }}
+      run: |
+        mkdir ~/.ssh
+        echo "${{ secrets.SECRETS_PRIVATE_KEY }}" > ~/.ssh/id_rsa
+        chmod 600 ~/.ssh/id_rsa
+        echo "HOST *" > ~/.ssh/config
+        echo "StrictHostKeyChecking no" >> ~/.ssh/config
+        git -c submodule.Secrets.update=checkout submodule update --init
+    # Corvax-Secrets-End
+    - name: Pull engine updates
+      uses: space-wizards/submodule-dependency@v0.1.5
+    - uses: PaulRitter/yaml-schema-validator@v1
+      with:
+        schema: RobustToolbox/Schemas/mapfile.yml
+        path_pattern: .*Resources/Maps/.*
+        validators_path: RobustToolbox/Schemas/mapfile_validators.py
+        validators_requirements: RobustToolbox/Schemas/mapfile_requirements.txt

.github/workflows/yaml-linter.yml

@@ -1,12 +1,19 @@
 name: YAML Linter
 
-on: [pull_request, push]
+on:
+  push:
+    branches: [ master, staging, trying ]
+  merge_group:
+  pull_request:
+    types: [ opened, reopened, synchronize, ready_for_review ]
 
 jobs:
   build:
+    name: YAML Linter
+    if: github.actor != 'IanComradeBot' && github.event.pull_request.draft == false
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3.6.0
       - name: Setup submodule
         run: |
           git submodule update --init --recursive
@@ -17,9 +24,9 @@ jobs:
           cd RobustToolbox/
           git submodule update --init --recursive
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v1
+        uses: actions/setup-dotnet@v3.2.0
         with:
-          dotnet-version: 6.0.100
+          dotnet-version: 7.0.x
       - name: Install dependencies
         run: dotnet restore
       - name: Build

.gitignore

@@ -10,6 +10,10 @@
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs
 
+# Secret
+Resources/Prototypes/CorvaxSecrets
+Resources/Prototypes/CorvaxSecretsServer
+
 # Build results
 [Dd]ebug/
 [Dd]ebugPublic/
@@ -301,3 +305,7 @@ Resources/MapImages
 /Content.Docfx/api/
 /Content.Docfx/*site
 
+*.bak
+
+# Direnv stuff
+.direnv/

.gitmodules

@@ -1,4 +1,9 @@
 [submodule "RobustToolbox"]
 	path = RobustToolbox
 	url = https://github.com/space-wizards/RobustToolbox.git
-	branch = master
+	branch = master
+[submodule "Secrets"]
+	path = Secrets
+	url = git@gitlab.com:Morbo/corvax-secrets.git
+	branch = master
+	update = none

.run/Content Server+Client.run.xml

@@ -4,4 +4,4 @@
     <toRun name="Content.Server" type="DotNetProject" />
     <method v="2" />
   </configuration>
-</component>
+</component>

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "omnisharp.analyzeOpenDocumentsOnly": true
+}

BuildChecker/BuildChecker.csproj

@@ -32,6 +32,12 @@ https://docs.microsoft.com/en-us/visualstudio/msbuild/msbuild
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <OutputPath>bin\Release\</OutputPath>
   </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Tools|AnyCPU' ">
+    <OutputPath>bin\Tools\</OutputPath>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'DebugOpt|AnyCPU' ">
+    <OutputPath>bin\DebugOpt\</OutputPath>
+  </PropertyGroup>
   <Target Name="Build">
     <Exec Command="$(Python) git_helper.py" CustomErrorRegularExpression="^Error" />
   </Target>

CHANGES.md

@@ -11,10 +11,15 @@ Main changes of this downstream:
   * Gravity generator fixture shape on top decreased
 - Custom sprites
   * Floor tiles
+  * Clothing
+  * Some objects
 - Custom clothing
   * Disco Elysium suits
   * [BIG SHOT] glasses
-  * Special Operations Officer [Custom]
-- Custom maps
-  * Construction station
-- Custom tools for locale update and merging
+  * Special Operations Officer [Author]
+- Custom tools for locale update and merging (/Tools/ss14_ru/)
+- Station goals
+- Sponsor rewards
+- Increased role timers
+- Custom roles
+  * Internal affairs agent

Content.Benchmarks/ColorInterpolateBenchmark.cs

@@ -5,6 +5,7 @@ using System.Runtime.Intrinsics.X86;
 using System;
 using System.Runtime.CompilerServices;
 using BenchmarkDotNet.Attributes;
+using Robust.Shared.Analyzers;
 using Robust.Shared.Maths;
 using Robust.Shared.Random;
 using SysVector4 = System.Numerics.Vector4;
@@ -12,7 +13,8 @@ using SysVector4 = System.Numerics.Vector4;
 namespace Content.Benchmarks
 {
     [DisassemblyDiagnoser]
-    public sealed class ColorInterpolateBenchmark
+    [Virtual]
+    public class ColorInterpolateBenchmark
     {
 #if NETCOREAPP
         private const MethodImplOptions AggressiveOpt = MethodImplOptions.AggressiveOptimization;

Content.Benchmarks/ComponentFetchBenchmark.cs

@@ -1,12 +1,14 @@
 using System;
 using System.Collections.Generic;
 using BenchmarkDotNet.Attributes;
+using Robust.Shared.Analyzers;
 using Robust.Shared.Utility;
 
 namespace Content.Benchmarks
 {
     [SimpleJob]
-    public sealed class ComponentFetchBenchmark
+    [Virtual]
+    public class ComponentFetchBenchmark
     {
         [Params(5000)] public int NEnt { get; set; }
 

Content.Benchmarks/Content.Benchmarks.csproj

@@ -8,7 +8,7 @@
     <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
     <OutputType>Exe</OutputType>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <LangVersion>10</LangVersion>
+    <LangVersion>11</LangVersion>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
@@ -19,10 +19,10 @@
     <ProjectReference Include="..\Content.Shared\Content.Shared.csproj" />
     <ProjectReference Include="..\Content.Tests\Content.Tests.csproj" />
     <ProjectReference Include="..\Content.IntegrationTests\Content.IntegrationTests.csproj" />
+    <ProjectReference Include="..\RobustToolbox\Robust.Benchmarks\Robust.Benchmarks.csproj" />
     <ProjectReference Include="..\RobustToolbox\Robust.Client\Robust.Client.csproj" />
     <ProjectReference Include="..\RobustToolbox\Robust.Server\Robust.Server.csproj" />
     <ProjectReference Include="..\RobustToolbox\Robust.Shared.Maths\Robust.Shared.Maths.csproj" />
     <ProjectReference Include="..\RobustToolbox\Robust.Shared\Robust.Shared.csproj" />
   </ItemGroup>
-  <Import Project="..\RobustToolbox\MSBuild\Robust.Analyzers.targets" />
 </Project>

Content.Benchmarks/DependencyInjectBenchmark.cs

@@ -6,7 +6,8 @@ namespace Content.Benchmarks
 {
     // To actually run this benchmark you'll have to make DependencyCollection public so it's accessible.
 
-    public sealed class DependencyInjectBenchmark
+    [Virtual]
+    public class DependencyInjectBenchmark
     {
         [Params(InjectMode.Reflection, InjectMode.DynamicMethod)]
         public InjectMode Mode { get; set; }

Content.Benchmarks/DeviceNetworkingBenchmark.cs

@@ -0,0 +1,142 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using Content.IntegrationTests;
+using Content.IntegrationTests.Pair;
+using Content.IntegrationTests.Tests.DeviceNetwork;
+using Content.Server.DeviceNetwork;
+using Content.Server.DeviceNetwork.Systems;
+using Robust.Shared;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+
+namespace Content.Benchmarks;
+
+[Virtual]
+[MemoryDiagnoser]
+public class DeviceNetworkingBenchmark
+{
+    private TestPair _pair = default!;
+    private DeviceNetworkTestSystem _deviceNetTestSystem = default!;
+    private DeviceNetworkSystem _deviceNetworkSystem = default!;
+    private EntityUid _sourceEntity;
+    private EntityUid _sourceWirelessEntity;
+    private readonly List<EntityUid> _targetEntities = new();
+    private readonly List<EntityUid> _targetWirelessEntities = new();
+
+
+    private NetworkPayload _payload = default!;
+
+    [TestPrototypes]
+    private const string Prototypes = @"
+- type: entity
+  name: DummyNetworkDevicePrivate
+  id: DummyNetworkDevicePrivate
+  components:
+    - type: DeviceNetwork
+      transmitFrequency: 100
+      receiveFrequency: 100
+      deviceNetId: Private
+- type: entity
+  name: DummyWirelessNetworkDevice
+  id: DummyWirelessNetworkDevice
+  components:
+    - type: DeviceNetwork
+      transmitFrequency: 100
+      receiveFrequency: 100
+      deviceNetId: Wireless
+    - type: WirelessNetworkConnection
+      range: 100
+        ";
+
+    //public static IEnumerable<int> EntityCountSource { get; set; }
+
+    //[ParamsSource(nameof(EntityCountSource))]
+    public int EntityCount = 500;
+
+    [GlobalSetup]
+    public async Task SetupAsync()
+    {
+        ProgramShared.PathOffset = "../../../../";
+        PoolManager.Startup(typeof(DeviceNetworkingBenchmark).Assembly);
+        _pair = await PoolManager.GetServerClient();
+        var server = _pair.Server;
+
+        await server.WaitPost(() =>
+        {
+            var entityManager = server.InstanceDependencyCollection.Resolve<IEntityManager>();
+            _deviceNetworkSystem = entityManager.EntitySysManager.GetEntitySystem<DeviceNetworkSystem>();
+            _deviceNetTestSystem = entityManager.EntitySysManager.GetEntitySystem<DeviceNetworkTestSystem>();
+
+            var testValue = "test";
+            _payload = new NetworkPayload
+            {
+                ["Test"] = testValue,
+                ["testnumber"] = 1,
+                ["testbool"] = true
+            };
+
+            _sourceEntity = entityManager.SpawnEntity("DummyNetworkDevicePrivate", MapCoordinates.Nullspace);
+            _sourceWirelessEntity = entityManager.SpawnEntity("DummyWirelessNetworkDevice", MapCoordinates.Nullspace);
+
+            for (var i = 0; i < EntityCount; i++)
+            {
+                _targetEntities.Add(entityManager.SpawnEntity("DummyNetworkDevicePrivate", MapCoordinates.Nullspace));
+                _targetWirelessEntities.Add(entityManager.SpawnEntity("DummyWirelessNetworkDevice", MapCoordinates.Nullspace));
+            }
+        });
+    }
+
+    [GlobalCleanup]
+    public async Task Cleanup()
+    {
+        await _pair.DisposeAsync();
+        PoolManager.Shutdown();
+    }
+
+    [Benchmark(Baseline = true, Description = "Entity Events")]
+    public async Task EventSentBaseline()
+    {
+        var server = _pair.Server;
+
+        _pair.Server.Post(() =>
+        {
+            foreach (var entity in _targetEntities)
+            {
+                _deviceNetTestSystem.SendBaselineTestEvent(entity);
+            }
+        });
+
+        await server.WaitRunTicks(1);
+        await server.WaitIdleAsync();
+    }
+
+    [Benchmark(Description = "Device Net Broadcast No Connection Checks")]
+    public async Task DeviceNetworkBroadcastNoConnectionChecks()
+    {
+        var server = _pair.Server;
+
+        _pair.Server.Post(() =>
+        {
+            _deviceNetworkSystem.QueuePacket(_sourceEntity, null, _payload, 100);
+        });
+
+        await server.WaitRunTicks(1);
+        await server.WaitIdleAsync();
+    }
+
+    [Benchmark(Description = "Device Net Broadcast Wireless Connection Checks")]
+    public async Task DeviceNetworkBroadcastWirelessConnectionChecks()
+    {
+        var server = _pair.Server;
+
+        _pair.Server.Post(() =>
+        {
+            _deviceNetworkSystem.QueuePacket(_sourceWirelessEntity, null, _payload, 100);
+        });
+
+        await server.WaitRunTicks(1);
+        await server.WaitIdleAsync();
+    }
+}

Content.Benchmarks/DynamicTreeBenchmark.cs

@@ -1,13 +1,15 @@
 using BenchmarkDotNet.Attributes;
+using Robust.Shared.Analyzers;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics;
 
 namespace Content.Benchmarks
 {
     [SimpleJob, MemoryDiagnoser]
-    public sealed class DynamicTreeBenchmark
+    [Virtual]
+    public class DynamicTreeBenchmark
     {
-        private static readonly Box2[] _aabbs1 =
+        private static readonly Box2[] Aabbs1 =
         {
             ((Box2) default).Enlarged(1), //2x2 square
             ((Box2) default).Enlarged(2), //4x4 square
@@ -37,11 +39,11 @@ namespace Content.Benchmarks
         public void Setup()
         {
             _b2Tree = new B2DynamicTree<int>();
-            _tree = new DynamicTree<int>((in int value) => _aabbs1[value], capacity: 16);
+            _tree = new DynamicTree<int>((in int value) => Aabbs1[value], capacity: 16);
 
-            for (var i = 0; i < _aabbs1.Length; i++)
+            for (var i = 0; i < Aabbs1.Length; i++)
             {
-                var aabb = _aabbs1[i];
+                var aabb = Aabbs1[i];
                 _b2Tree.CreateProxy(aabb, i);
                 _tree.Add(i);
             }

Content.Benchmarks/EntityFetchBenchmark.cs

@@ -1,12 +1,14 @@
 using System;
 using System.Collections.Generic;
 using BenchmarkDotNet.Attributes;
+using Robust.Shared.Analyzers;
 using Robust.Shared.Utility;
 
 namespace Content.Benchmarks
 {
     [SimpleJob]
-    public sealed class EntityFetchBenchmark
+    [Virtual]
+    public class EntityFetchBenchmark
     {
         [Params(1000)] public int N { get; set; }
 
@@ -187,9 +189,7 @@ namespace Content.Benchmarks
             public TEntity GetEntity(TEntityUid entityUid)
             {
                 if (!TryGetEntity(entityUid, out var entity))
-                {
-                    throw new ArgumentException();
-                }
+                    throw new ArgumentException($"Failed to get entity {entityUid} from storage.");
 
                 return entity;
             }
@@ -198,7 +198,7 @@ namespace Content.Benchmarks
         private sealed class GenEntityStorage : EntityStorage<GenEntity, GenEntityUid>
         {
             private (int generation, GenEntity entity)[] _entities = new (int, GenEntity)[1];
-            private readonly List<int> _availableSlots = new() {0};
+            private readonly List<int> _availableSlots = new() { 0 };
 
             public override bool TryGetEntity(GenEntityUid entityUid, out GenEntity entity)
             {

Content.Benchmarks/EntityManagerGetAllComponents.cs

@@ -1,5 +1,6 @@
 using BenchmarkDotNet.Attributes;
 using Moq;
+using Robust.Shared.Analyzers;
 using Robust.Shared.Exceptions;
 using Robust.Shared.GameObjects;
 using Robust.Shared.IoC;
@@ -9,7 +10,8 @@ using Robust.Shared.Reflection;
 
 namespace Content.Benchmarks
 {
-    public sealed class EntityManagerGetAllComponents
+    [Virtual]
+    public partial class EntityManagerGetAllComponents
     {
         private IEntityManager _entityManager;
 
@@ -46,7 +48,7 @@ namespace Content.Benchmarks
             var componentFactory = new Mock<IComponentFactory>();
             componentFactory.Setup(p => p.GetComponent<DummyComponent>()).Returns(new DummyComponent());
             componentFactory.Setup(p => p.GetRegistration(It.IsAny<DummyComponent>())).Returns(dummyReg);
-            componentFactory.Setup(p => p.GetAllRefTypes()).Returns(new[] {CompIdx.Index<DummyComponent>()});
+            componentFactory.Setup(p => p.GetAllRefTypes()).Returns(new[] { CompIdx.Index<DummyComponent>() });
 
             IoCManager.RegisterInstance<IComponentFactory>(componentFactory.Object);
 
@@ -85,7 +87,7 @@ namespace Content.Benchmarks
             return count;
         }
 
-        private sealed class DummyComponent : Component
+        private sealed partial class DummyComponent : Component
         {
         }
     }

Content.Benchmarks/MapLoadBenchmark.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using Content.IntegrationTests;
+using Content.IntegrationTests.Pair;
+using Content.Server.Maps;
+using Robust.Server.GameObjects;
+using Robust.Shared;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+using Robust.Shared.Prototypes;
+
+namespace Content.Benchmarks;
+
+[Virtual]
+public class MapLoadBenchmark
+{
+    private TestPair _pair = default!;
+    private MapLoaderSystem _mapLoader = default!;
+    private IMapManager _mapManager = default!;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        ProgramShared.PathOffset = "../../../../";
+        PoolManager.Startup(null);
+
+        _pair = PoolManager.GetServerClient().GetAwaiter().GetResult();
+        var server = _pair.Server;
+
+        Paths = server.ResolveDependency<IPrototypeManager>()
+            .EnumeratePrototypes<GameMapPrototype>()
+            .ToDictionary(x => x.ID, x => x.MapPath.ToString());
+
+        _mapLoader = server.ResolveDependency<IEntitySystemManager>().GetEntitySystem<MapLoaderSystem>();
+        _mapManager = server.ResolveDependency<IMapManager>();
+    }
+
+    [GlobalCleanup]
+    public async Task Cleanup()
+    {
+        await _pair.DisposeAsync();
+        PoolManager.Shutdown();
+    }
+
+    public static IEnumerable<string> MapsSource { get; set; }
+
+    [ParamsSource(nameof(MapsSource))]
+    public string Map;
+
+    public Dictionary<string, string> Paths;
+
+    [Benchmark]
+    public async Task LoadMap()
+    {
+        var mapPath = Paths[Map];
+        var server = _pair.Server;
+        await server.WaitPost(() =>
+        {
+            var success = _mapLoader.TryLoad(new MapId(10), mapPath, out _);
+            if (!success)
+                throw new Exception("Map load failed");
+        });
+    }
+
+    [IterationCleanup]
+    public void IterationCleanup()
+    {
+        var server = _pair.Server;
+        server.WaitPost(() =>
+        {
+            _mapManager.DeleteMap(new MapId(10));
+        }).Wait();
+    }
+}

Content.Benchmarks/NetSerializerIntBenchmark.cs

@@ -2,17 +2,19 @@
 using System.Buffers.Binary;
 using System.IO;
 using BenchmarkDotNet.Attributes;
+using Robust.Shared.Analyzers;
 
 namespace Content.Benchmarks
 {
     [SimpleJob]
-    public sealed class NetSerializerIntBenchmark
+    [Virtual]
+    public class NetSerializerIntBenchmark
     {
         private MemoryStream _writeStream;
         private MemoryStream _readStream;
-        private ushort _x16 = 5;
-        private uint _x32 = 5;
-        private ulong _x64 = 5;
+        private readonly ushort _x16 = 5;
+        private readonly uint _x32 = 5;
+        private readonly ulong _x64 = 5;
         private ushort _read16;
         private uint _read32;
         private ulong _read64;
@@ -22,7 +24,7 @@ namespace Content.Benchmarks
         {
             _writeStream = new MemoryStream(64);
             _readStream = new MemoryStream();
-            _readStream.Write(new byte[]{0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8});
+            _readStream.Write(new byte[] { 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8 });
         }
 
         [Benchmark]

Content.Benchmarks/NetSerializerStringBenchmark.cs

@@ -7,13 +7,15 @@ using System.Text.Unicode;
 using BenchmarkDotNet.Attributes;
 using Lidgren.Network;
 using NetSerializer;
+using Robust.Shared.Analyzers;
 
 namespace Content.Benchmarks
 {
     // Code for the *Slow and *Unsafe implementations taken from NetSerializer, licensed under the MIT license.
 
     [MemoryDiagnoser]
-    public sealed class NetSerializerStringBenchmark
+    [Virtual]
+    public class NetSerializerStringBenchmark
     {
         private const int StringByteBufferLength = 256;
         private const int StringCharBufferLength = 128;
@@ -46,7 +48,7 @@ namespace Content.Benchmarks
         public void BenchReadCore()
         {
             _inputStream.Position = 0;
-            ReadPrimitiveCore(_inputStream, out string _);
+            ReadPrimitiveCore(_inputStream, out _);
         }
 
         [Benchmark]
@@ -60,7 +62,7 @@ namespace Content.Benchmarks
         public void BenchReadUnsafe()
         {
             _inputStream.Position = 0;
-            ReadPrimitiveUnsafe(_inputStream, out string _);
+            ReadPrimitiveUnsafe(_inputStream, out _);
         }
 
         [Benchmark]
@@ -74,329 +76,356 @@ namespace Content.Benchmarks
         public void BenchReadSlow()
         {
             _inputStream.Position = 0;
-            ReadPrimitiveSlow(_inputStream, out string _);
+            ReadPrimitiveSlow(_inputStream, out _);
         }
 
-		public static void WritePrimitiveCore(Stream stream, string value)
-		{
-			if (value == null)
-			{
-				Primitives.WritePrimitive(stream, (uint)0);
-				return;
-			}
+        public static void WritePrimitiveCore(Stream stream, string value)
+        {
+            if (value == null)
+            {
+                Primitives.WritePrimitive(stream, (uint) 0);
+                return;
+            }
 
-			if (value.Length == 0)
-			{
-				Primitives.WritePrimitive(stream, (uint)1);
-				return;
-			}
+            if (value.Length == 0)
+            {
+                Primitives.WritePrimitive(stream, (uint) 1);
+                return;
+            }
 
-			Span<byte> buf = stackalloc byte[StringByteBufferLength];
+            Span<byte> buf = stackalloc byte[StringByteBufferLength];
 
-			var totalChars = value.Length;
-			var totalBytes = Encoding.UTF8.GetByteCount(value);
+            var totalChars = value.Length;
+            var totalBytes = Encoding.UTF8.GetByteCount(value);
 
-			Primitives.WritePrimitive(stream, (uint)totalBytes + 1);
-			Primitives.WritePrimitive(stream, (uint)totalChars);
+            Primitives.WritePrimitive(stream, (uint) totalBytes + 1);
+            Primitives.WritePrimitive(stream, (uint) totalChars);
 
-			var totalRead = 0;
-			ReadOnlySpan<char> span = value;
-			for (;;)
-			{
-				var finalChunk = totalRead + totalChars >= totalChars;
-				Utf8.FromUtf16(span, buf, out var read, out var wrote, isFinalBlock: finalChunk);
-				stream.Write(buf.Slice(0, wrote));
-				totalRead += read;
-				if (read >= totalChars)
-				{
-					break;
-				}
+            var totalRead = 0;
+            ReadOnlySpan<char> span = value;
+            while (true)
+            {
+                var finalChunk = totalRead + totalChars >= totalChars;
+                Utf8.FromUtf16(span, buf, out var read, out var wrote, isFinalBlock: finalChunk);
+                stream.Write(buf[0..wrote]);
+                totalRead += read;
+                if (read >= totalChars)
+                {
+                    break;
+                }
 
-				span = span[read..];
-				totalChars -= read;
-			}
-		}
+                span = span[read..];
+                totalChars -= read;
+            }
+        }
 
-		private static readonly SpanAction<char, (int, Stream)> _stringSpanRead = StringSpanRead;
+        public static void ReadPrimitiveCore(Stream stream, out string value)
+        {
+            Primitives.ReadPrimitive(stream, out uint totalBytes);
 
-		public static void ReadPrimitiveCore(Stream stream, out string value)
-		{
-			Primitives.ReadPrimitive(stream, out uint totalBytes);
+            if (totalBytes == 0)
+            {
+                value = null;
+                return;
+            }
 
-			if (totalBytes == 0)
-			{
-				value = null;
-				return;
-			}
+            if (totalBytes == 1)
+            {
+                value = string.Empty;
+                return;
+            }
 
-			if (totalBytes == 1)
-			{
-				value = string.Empty;
-				return;
-			}
-
-			totalBytes -= 1;
+            totalBytes -= 1;
 
             Primitives.ReadPrimitive(stream, out uint totalChars);
 
-			value = string.Create((int) totalChars, ((int) totalBytes, stream), _stringSpanRead);
-		}
+            value = string.Create((int) totalChars, ((int) totalBytes, stream), StringSpanRead);
+        }
 
-		private static void StringSpanRead(Span<char> span, (int totalBytes, Stream stream) tuple)
-		{
-			Span<byte> buf = stackalloc byte[StringByteBufferLength];
+        private static void StringSpanRead(Span<char> span, (int totalBytes, Stream stream) tuple)
+        {
+            Span<byte> buf = stackalloc byte[StringByteBufferLength];
 
-			// ReSharper disable VariableHidesOuterVariable
-			var (totalBytes, stream) = tuple;
-			// ReSharper restore VariableHidesOuterVariable
+            // ReSharper disable VariableHidesOuterVariable
+            var (totalBytes, stream) = tuple;
+            // ReSharper restore VariableHidesOuterVariable
 
-			var totalBytesRead = 0;
-			var totalCharsRead = 0;
-			var writeBufStart = 0;
+            var totalBytesRead = 0;
+            var totalCharsRead = 0;
+            var writeBufStart = 0;
 
-			while (totalBytesRead < totalBytes)
-			{
-				var bytesLeft = totalBytes - totalBytesRead;
-				var bytesReadLeft = Math.Min(buf.Length, bytesLeft);
-				var writeSlice = buf.Slice(writeBufStart, bytesReadLeft - writeBufStart);
-				var bytesInBuffer = stream.Read(writeSlice);
-				if (bytesInBuffer == 0) throw new EndOfStreamException();
+            while (totalBytesRead < totalBytes)
+            {
+                var bytesLeft = totalBytes - totalBytesRead;
+                var bytesReadLeft = Math.Min(buf.Length, bytesLeft);
+                var writeSlice = buf[writeBufStart..(bytesReadLeft - writeBufStart)];
+                var bytesInBuffer = stream.Read(writeSlice);
+                if (bytesInBuffer == 0) throw new EndOfStreamException();
 
-				var readFromStream = bytesInBuffer + writeBufStart;
-				var final = readFromStream == bytesLeft;
-				var status = Utf8.ToUtf16(buf[..readFromStream], span[totalCharsRead..], out var bytesRead, out var charsRead, isFinalBlock: final);
+                var readFromStream = bytesInBuffer + writeBufStart;
+                var final = readFromStream == bytesLeft;
+                var status = Utf8.ToUtf16(buf[..readFromStream], span[totalCharsRead..], out var bytesRead, out var charsRead, isFinalBlock: final);
 
-				totalBytesRead += bytesRead;
-				totalCharsRead += charsRead;
-				writeBufStart = 0;
+                totalBytesRead += bytesRead;
+                totalCharsRead += charsRead;
+                writeBufStart = 0;
 
-				if (status == OperationStatus.DestinationTooSmall)
-				{
-					// Malformed data?
-					throw new InvalidDataException();
-				}
+                if (status == OperationStatus.DestinationTooSmall)
+                {
+                    // Malformed data?
+                    throw new InvalidDataException();
+                }
 
-				if (status == OperationStatus.NeedMoreData)
-				{
-					// We got cut short in the middle of a multi-byte UTF-8 sequence.
-					// So we need to move it to the bottom of the span, then read the next bit *past* that.
-					// This copy should be fine because we're only ever gonna be copying up to 4 bytes
-					// from the end of the buffer to the start.
-					// So no chance of overlap.
-					buf[bytesRead..].CopyTo(buf);
-					writeBufStart = bytesReadLeft - bytesRead;
-					continue;
-				}
+                if (status == OperationStatus.NeedMoreData)
+                {
+                    // We got cut short in the middle of a multi-byte UTF-8 sequence.
+                    // So we need to move it to the bottom of the span, then read the next bit *past* that.
+                    // This copy should be fine because we're only ever gonna be copying up to 4 bytes
+                    // from the end of the buffer to the start.
+                    // So no chance of overlap.
+                    buf[bytesRead..].CopyTo(buf);
+                    writeBufStart = bytesReadLeft - bytesRead;
+                    continue;
+                }
 
-				Debug.Assert(status == OperationStatus.Done);
-			}
-		}
+                Debug.Assert(status == OperationStatus.Done);
+            }
+        }
 
-		public static void WritePrimitiveSlow(Stream stream, string value)
-		{
-			if (value == null)
-			{
-                Primitives.WritePrimitive(stream, (uint)0);
-				return;
-			}
-			else if (value.Length == 0)
-			{
-                Primitives.WritePrimitive(stream, (uint)1);
-				return;
-			}
+        public static void WritePrimitiveSlow(Stream stream, string value)
+        {
+            if (value == null)
+            {
+                Primitives.WritePrimitive(stream, (uint) 0);
+                return;
+            }
+            else if (value.Length == 0)
+            {
+                Primitives.WritePrimitive(stream, (uint) 1);
+                return;
+            }
 
-			var encoding = new UTF8Encoding(false, true);
+            var encoding = new UTF8Encoding(false, true);
 
-			int len = encoding.GetByteCount(value);
+            var len = encoding.GetByteCount(value);
 
-            Primitives.WritePrimitive(stream, (uint)len + 1);
-			Primitives.WritePrimitive(stream, (uint)value.Length);
+            Primitives.WritePrimitive(stream, (uint) len + 1);
+            Primitives.WritePrimitive(stream, (uint) value.Length);
 
-			var buf = new byte[len];
+            var buf = new byte[len];
 
-			encoding.GetBytes(value, 0, value.Length, buf, 0);
+            encoding.GetBytes(value, 0, value.Length, buf, 0);
 
-			stream.Write(buf, 0, len);
-		}
+            stream.Write(buf, 0, len);
+        }
 
-		public static void ReadPrimitiveSlow(Stream stream, out string value)
-		{
-			uint len;
-			Primitives.ReadPrimitive(stream, out len);
+        public static void ReadPrimitiveSlow(Stream stream, out string value)
+        {
+            Primitives.ReadPrimitive(stream, out uint len);
 
-			if (len == 0)
-			{
-				value = null;
-				return;
-			}
-			else if (len == 1)
-			{
-				value = string.Empty;
-				return;
-			}
+            if (len == 0)
+            {
+                value = null;
+                return;
+            }
+            else if (len == 1)
+            {
+                value = string.Empty;
+                return;
+            }
 
-			uint totalChars;
-            Primitives.ReadPrimitive(stream, out totalChars);
+            Primitives.ReadPrimitive(stream, out uint _);
 
-			len -= 1;
+            len -= 1;
 
-			var encoding = new UTF8Encoding(false, true);
+            var encoding = new UTF8Encoding(false, true);
 
-			var buf = new byte[len];
+            var buf = new byte[len];
 
-			int l = 0;
+            var l = 0;
 
-			while (l < len)
-			{
-				int r = stream.Read(buf, l, (int)len - l);
-				if (r == 0)
-					throw new EndOfStreamException();
-				l += r;
-			}
+            while (l < len)
+            {
+                var r = stream.Read(buf, l, (int) len - l);
+                if (r == 0)
+                    throw new EndOfStreamException();
+                l += r;
+            }
 
-			value = encoding.GetString(buf);
-		}
+            value = encoding.GetString(buf);
+        }
 
-        sealed class StringHelper
-		{
-			public StringHelper()
-			{
-				this.Encoding = new UTF8Encoding(false, true);
-			}
+        private sealed class StringHelper
+        {
+            public StringHelper()
+            {
+                Encoding = new UTF8Encoding(false, true);
+            }
 
-			Encoder m_encoder;
-			Decoder m_decoder;
+            private Encoder _encoder;
+            private Decoder _decoder;
 
-			byte[] m_byteBuffer;
-			char[] m_charBuffer;
+            private byte[] _byteBuffer;
+            private char[] _charBuffer;
 
-			public UTF8Encoding Encoding { get; private set; }
-			public Encoder Encoder { get { if (m_encoder == null) m_encoder = this.Encoding.GetEncoder(); return m_encoder; } }
-			public Decoder Decoder { get { if (m_decoder == null) m_decoder = this.Encoding.GetDecoder(); return m_decoder; } }
+            public UTF8Encoding Encoding { get; private set; }
+            public Encoder Encoder
+            {
+                get
+                {
+                    _encoder ??= Encoding.GetEncoder();
+                    return _encoder;
+                }
+            }
+            public Decoder Decoder
+            {
+                get
+                {
+                    _decoder ??= Encoding.GetDecoder();
+                    return _decoder;
+                }
+            }
 
-			public byte[] ByteBuffer { get { if (m_byteBuffer == null) m_byteBuffer = new byte[StringByteBufferLength]; return m_byteBuffer; } }
-			public char[] CharBuffer { get { if (m_charBuffer == null) m_charBuffer = new char[StringCharBufferLength]; return m_charBuffer; } }
-		}
+            public byte[] ByteBuffer
+            {
+                get
+                {
+                    _byteBuffer ??= new byte[StringByteBufferLength];
+                    return _byteBuffer;
+                }
+            }
+            public char[] CharBuffer
+            {
+                get
+                {
+                    _charBuffer ??= new char[StringCharBufferLength];
+                    return _charBuffer;
+                }
+            }
+        }
 
-		[ThreadStatic]
-		static StringHelper s_stringHelper;
+        [ThreadStatic]
+        private static StringHelper _stringHelper;
 
-		public unsafe static void WritePrimitiveUnsafe(Stream stream, string value)
-		{
-			if (value == null)
-			{
-				Primitives.WritePrimitive(stream, (uint)0);
-				return;
-			}
-			else if (value.Length == 0)
-			{
-                Primitives.WritePrimitive(stream, (uint)1);
-				return;
-			}
+        public static unsafe void WritePrimitiveUnsafe(Stream stream, string value)
+        {
+            if (value == null)
+            {
+                Primitives.WritePrimitive(stream, (uint) 0);
+                return;
+            }
+            else if (value.Length == 0)
+            {
+                Primitives.WritePrimitive(stream, (uint) 1);
+                return;
+            }
 
-			var helper = s_stringHelper;
-			if (helper == null)
-				s_stringHelper = helper = new StringHelper();
+            var helper = _stringHelper;
+            if (helper == null)
+                _stringHelper = helper = new StringHelper();
 
-			var encoder = helper.Encoder;
-			var buf = helper.ByteBuffer;
+            var encoder = helper.Encoder;
+            var buf = helper.ByteBuffer;
 
-			int totalChars = value.Length;
-			int totalBytes;
+            var totalChars = value.Length;
+            int totalBytes;
 
-			fixed (char* ptr = value)
-				totalBytes = encoder.GetByteCount(ptr, totalChars, true);
+            fixed (char* ptr = value)
+                totalBytes = encoder.GetByteCount(ptr, totalChars, true);
 
-			Primitives.WritePrimitive(stream, (uint)totalBytes + 1);
-			Primitives.WritePrimitive(stream, (uint)totalChars);
+            Primitives.WritePrimitive(stream, (uint) totalBytes + 1);
+            Primitives.WritePrimitive(stream, (uint) totalChars);
 
-			int p = 0;
-			bool completed = false;
+            var p = 0;
+            var completed = false;
 
-			while (completed == false)
-			{
-				int charsConverted;
-				int bytesConverted;
+            while (completed == false)
+            {
+                int charsConverted;
+                int bytesConverted;
 
-				fixed (char* src = value)
-				fixed (byte* dst = buf)
-				{
-					encoder.Convert(src + p, totalChars - p, dst, buf.Length, true,
-						out charsConverted, out bytesConverted, out completed);
-				}
+                fixed (char* src = value)
+                fixed (byte* dst = buf)
+                {
+                    encoder.Convert(src + p, totalChars - p, dst, buf.Length, true,
+                        out charsConverted, out bytesConverted, out completed);
+                }
 
-				stream.Write(buf, 0, bytesConverted);
+                stream.Write(buf, 0, bytesConverted);
 
-				p += charsConverted;
-			}
-		}
+                p += charsConverted;
+            }
+        }
 
-		public static void ReadPrimitiveUnsafe(Stream stream, out string value)
-		{
-			uint totalBytes;
-			Primitives.ReadPrimitive(stream, out totalBytes);
+        public static void ReadPrimitiveUnsafe(Stream stream, out string value)
+        {
+            Primitives.ReadPrimitive(stream, out uint totalBytes);
 
-			if (totalBytes == 0)
-			{
-				value = null;
-				return;
-			}
-			else if (totalBytes == 1)
-			{
-				value = string.Empty;
-				return;
-			}
+            if (totalBytes == 0)
+            {
+                value = null;
+                return;
+            }
+            else if (totalBytes == 1)
+            {
+                value = string.Empty;
+                return;
+            }
 
-			totalBytes -= 1;
+            totalBytes -= 1;
 
-			uint totalChars;
-			Primitives.ReadPrimitive(stream, out totalChars);
+            Primitives.ReadPrimitive(stream, out uint totalChars);
 
-			var helper = s_stringHelper;
-			if (helper == null)
-				s_stringHelper = helper = new StringHelper();
+            var helper = _stringHelper;
+            if (helper == null)
+                _stringHelper = helper = new StringHelper();
 
-			var decoder = helper.Decoder;
-			var buf = helper.ByteBuffer;
-			char[] chars;
-			if (totalChars <= StringCharBufferLength)
-				chars = helper.CharBuffer;
-			else
-				chars = new char[totalChars];
+            var decoder = helper.Decoder;
+            var buf = helper.ByteBuffer;
+            char[] chars;
+            if (totalChars <= StringCharBufferLength)
+                chars = helper.CharBuffer;
+            else
+                chars = new char[totalChars];
 
-			int streamBytesLeft = (int)totalBytes;
+            var streamBytesLeft = (int) totalBytes;
 
-			int cp = 0;
+            var cp = 0;
 
-			while (streamBytesLeft > 0)
-			{
-				int bytesInBuffer = stream.Read(buf, 0, Math.Min(buf.Length, streamBytesLeft));
-				if (bytesInBuffer == 0)
-					throw new EndOfStreamException();
+            while (streamBytesLeft > 0)
+            {
+                var bytesInBuffer = stream.Read(buf, 0, Math.Min(buf.Length, streamBytesLeft));
+                if (bytesInBuffer == 0)
+                    throw new EndOfStreamException();
 
-				streamBytesLeft -= bytesInBuffer;
-				bool flush = streamBytesLeft == 0 ? true : false;
+                streamBytesLeft -= bytesInBuffer;
+                var flush = streamBytesLeft == 0;
 
-				bool completed = false;
+                var completed = false;
 
-				int p = 0;
+                var p = 0;
 
-				while (completed == false)
-				{
-					int charsConverted;
-					int bytesConverted;
+                while (completed == false)
+                {
+                    decoder.Convert(
+                        buf,
+                        p,
+                        bytesInBuffer - p,
+                        chars,
+                        cp,
+                        (int) totalChars - cp,
+                        flush,
+                        out var bytesConverted,
+                        out var charsConverted,
+                        out completed
+                    );
 
-					decoder.Convert(buf, p, bytesInBuffer - p,
-						chars, cp, (int)totalChars - cp,
-						flush,
-						out bytesConverted, out charsConverted, out completed);
+                    p += bytesConverted;
+                    cp += charsConverted;
+                }
+            }
 
-					p += bytesConverted;
-					cp += charsConverted;
-				}
-			}
-
-			value = new string(chars, 0, (int)totalChars);
-		}
+            value = new string(chars, 0, (int) totalChars);
+        }
     }
 }

Content.Benchmarks/Program.cs

@@ -1,12 +1,44 @@
-using BenchmarkDotNet.Running;
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Running;
+using Content.IntegrationTests;
+using Content.Server.Maps;
+#if DEBUG
+using BenchmarkDotNet.Configs;
+#else
+using Robust.Benchmarks.Configs;
+#endif
+using Robust.Shared.Prototypes;
 
 namespace Content.Benchmarks
 {
     internal static class Program
     {
+
         public static void Main(string[] args)
         {
-            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
+            MainAsync(args).GetAwaiter().GetResult();
+        }
+
+        public static async Task MainAsync(string[] args)
+        {
+            PoolManager.Startup(typeof(Program).Assembly);
+            var pair = await PoolManager.GetServerClient();
+            var gameMaps = pair.Server.ResolveDependency<IPrototypeManager>().EnumeratePrototypes<GameMapPrototype>().ToList();
+            MapLoadBenchmark.MapsSource = gameMaps.Select(x => x.ID);
+            await pair.CleanReturnAsync();
+            PoolManager.Shutdown();
+
+#if DEBUG
+            Console.ForegroundColor = ConsoleColor.Red;
+            Console.WriteLine("\nWARNING: YOU ARE RUNNING A DEBUG BUILD, USE A RELEASE BUILD FOR AN ACCURATE BENCHMARK");
+            Console.WriteLine("THE DEBUG BUILD IS ONLY GOOD FOR FIXING A CRASHING BENCHMARK\n");
+            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args, new DebugInProcessConfig());
+#else
+            var config = Environment.GetEnvironmentVariable("ROBUST_BENCHMARKS_ENABLE_SQL") != null ? DefaultSQLConfig.Instance : null;
+            BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args, config);
+#endif
         }
     }
 }

Content.Benchmarks/SpawnEquipDeleteBenchmark.cs

@@ -0,0 +1,66 @@
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using Content.IntegrationTests;
+using Content.IntegrationTests.Pair;
+using Content.Server.Station.Systems;
+using Content.Shared.Roles;
+using Robust.Shared;
+using Robust.Shared.Analyzers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Map;
+
+namespace Content.Benchmarks;
+
+/// <summary>
+/// This benchmarks spawns several humans, gives them captain equipment and then deletes them.
+/// This measures performance for spawning, deletion, containers, and inventory code.
+/// </summary>
+[Virtual, MemoryDiagnoser]
+public class SpawnEquipDeleteBenchmark
+{
+    private TestPair _pair = default!;
+    private StationSpawningSystem _spawnSys = default!;
+    private const string Mob = "MobHuman";
+    private StartingGearPrototype _gear = default!;
+    private EntityUid _entity;
+    private EntityCoordinates _coords;
+
+    [Params(1, 4, 16, 64)]
+    public int N;
+
+    [GlobalSetup]
+    public async Task SetupAsync()
+    {
+        ProgramShared.PathOffset = "../../../../";
+        PoolManager.Startup(null);
+        _pair = await PoolManager.GetServerClient();
+        var server = _pair.Server;
+
+        var mapData = await _pair.CreateTestMap();
+        _coords = mapData.GridCoords;
+        _spawnSys = server.System<StationSpawningSystem>();
+        _gear = server.ProtoMan.Index<StartingGearPrototype>("CaptainGear");
+    }
+
+    [GlobalCleanup]
+    public async Task Cleanup()
+    {
+        await _pair.DisposeAsync();
+        PoolManager.Shutdown();
+    }
+
+    [Benchmark]
+    public async Task SpawnDeletePlayer()
+    {
+        await _pair.Server.WaitPost(() =>
+        {
+            var server = _pair.Server;
+            for (var i = 0; i < N; i++)
+            {
+                _entity = server.EntMan.SpawnAttachedTo(Mob, _coords);
+                _spawnSys.EquipStartingGear(_entity, _gear, null);
+                server.EntMan.DeleteEntity(_entity);
+            }
+        });
+    }
+}

Content.Benchmarks/StereoToMonoBenchmark.cs

@@ -1,9 +1,11 @@
 using System.Runtime.Intrinsics.X86;
 using BenchmarkDotNet.Attributes;
+using Robust.Shared.Analyzers;
 
 namespace Content.Benchmarks
 {
-    public sealed class StereoToMonoBenchmark
+    [Virtual]
+    public class StereoToMonoBenchmark
     {
         [Params(128, 256, 512)]
         public int N { get; set; }

Content.Client/AI/ClientAiDebugSystem.cs

@@ -1,204 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Content.Client.Stylesheets;
-using Content.Shared.AI;
-using Robust.Client.Graphics;
-using Robust.Client.UserInterface;
-using Robust.Client.UserInterface.Controls;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Maths;
-using static Robust.Client.UserInterface.Controls.BoxContainer;
-
-namespace Content.Client.AI
-{
-#if DEBUG
-    public sealed class ClientAiDebugSystem : EntitySystem
-    {
-        [Dependency] private readonly IEyeManager _eyeManager = default!;
-
-        private AiDebugMode _tooltips = AiDebugMode.None;
-        private readonly Dictionary<EntityUid, PanelContainer> _aiBoxes = new();
-
-        public override void Update(float frameTime)
-        {
-            base.Update(frameTime);
-            if (_tooltips == 0)
-            {
-                if (_aiBoxes.Count > 0)
-                {
-                    foreach (var (_, panel) in _aiBoxes)
-                    {
-                        panel.Dispose();
-                    }
-
-                    _aiBoxes.Clear();
-                }
-                return;
-            }
-
-            var deletedEntities = new List<EntityUid>(0);
-            foreach (var (entity, panel) in _aiBoxes)
-            {
-                if (Deleted(entity))
-                {
-                    deletedEntities.Add(entity);
-                    continue;
-                }
-
-                if (!_eyeManager.GetWorldViewport().Contains(EntityManager.GetComponent<TransformComponent>(entity).WorldPosition))
-                {
-                    panel.Visible = false;
-                    continue;
-                }
-
-                var (x, y) = _eyeManager.CoordinatesToScreen(EntityManager.GetComponent<TransformComponent>(entity).Coordinates).Position;
-                var offsetPosition = new Vector2(x - panel.Width / 2, y - panel.Height - 50f);
-                panel.Visible = true;
-
-                LayoutContainer.SetPosition(panel, offsetPosition);
-            }
-
-            foreach (var entity in deletedEntities)
-            {
-                _aiBoxes.Remove(entity);
-            }
-        }
-
-        public override void Initialize()
-        {
-            base.Initialize();
-            UpdatesOutsidePrediction = true;
-            SubscribeNetworkEvent<SharedAiDebug.UtilityAiDebugMessage>(HandleUtilityAiDebugMessage);
-            SubscribeNetworkEvent<SharedAiDebug.AStarRouteMessage>(HandleAStarRouteMessage);
-            SubscribeNetworkEvent<SharedAiDebug.JpsRouteMessage>(HandleJpsRouteMessage);
-        }
-
-        private void HandleUtilityAiDebugMessage(SharedAiDebug.UtilityAiDebugMessage message)
-        {
-            if ((_tooltips & AiDebugMode.Thonk) != 0)
-            {
-                // I guess if it's out of range we don't know about it?
-                var entity = message.EntityUid;
-                TryCreatePanel(entity);
-
-                // Probably shouldn't access by index but it's a debugging tool so eh
-                var label = (Label) _aiBoxes[entity].GetChild(0).GetChild(0);
-                label.Text = $"Current Task: {message.FoundTask}\n" +
-                             $"Task score: {message.ActionScore}\n" +
-                             $"Planning time (ms): {message.PlanningTime * 1000:0.0000}\n" +
-                             $"Considered {message.ConsideredTaskCount} tasks";
-            }
-        }
-
-        private void HandleAStarRouteMessage(SharedAiDebug.AStarRouteMessage message)
-        {
-            if ((_tooltips & AiDebugMode.Paths) != 0)
-            {
-                var entity = message.EntityUid;
-                TryCreatePanel(entity);
-
-                var label = (Label) _aiBoxes[entity].GetChild(0).GetChild(1);
-                label.Text = $"Pathfinding time (ms): {message.TimeTaken * 1000:0.0000}\n" +
-                             $"Nodes traversed: {message.CameFrom.Count}\n" +
-                             $"Nodes per ms: {message.CameFrom.Count / (message.TimeTaken * 1000)}";
-            }
-        }
-
-        private void HandleJpsRouteMessage(SharedAiDebug.JpsRouteMessage message)
-        {
-            if ((_tooltips & AiDebugMode.Paths) != 0)
-            {
-                var entity = message.EntityUid;
-                TryCreatePanel(entity);
-
-                var label = (Label) _aiBoxes[entity].GetChild(0).GetChild(1);
-                label.Text = $"Pathfinding time (ms): {message.TimeTaken * 1000:0.0000}\n" +
-                             $"Jump Nodes: {message.JumpNodes.Count}\n" +
-                             $"Jump Nodes per ms: {message.JumpNodes.Count / (message.TimeTaken * 1000)}";
-            }
-        }
-
-        public void Disable()
-        {
-            foreach (var tooltip in _aiBoxes.Values)
-            {
-                tooltip.Dispose();
-            }
-            _aiBoxes.Clear();
-            _tooltips = AiDebugMode.None;
-        }
-
-
-        private void EnableTooltip(AiDebugMode tooltip)
-        {
-            _tooltips |= tooltip;
-        }
-
-        private void DisableTooltip(AiDebugMode tooltip)
-        {
-            _tooltips &= ~tooltip;
-        }
-
-        public void ToggleTooltip(AiDebugMode tooltip)
-        {
-            if ((_tooltips & tooltip) != 0)
-            {
-                DisableTooltip(tooltip);
-            }
-            else
-            {
-                EnableTooltip(tooltip);
-            }
-        }
-
-        private bool TryCreatePanel(EntityUid entity)
-        {
-            if (!_aiBoxes.ContainsKey(entity))
-            {
-                var userInterfaceManager = IoCManager.Resolve<IUserInterfaceManager>();
-
-                var actionLabel = new Label
-                {
-                    MouseFilter = Control.MouseFilterMode.Ignore,
-                };
-
-                var pathfindingLabel = new Label
-                {
-                    MouseFilter = Control.MouseFilterMode.Ignore,
-                };
-
-                var vBox = new BoxContainer()
-                {
-                    Orientation = LayoutOrientation.Vertical,
-                    SeparationOverride = 15,
-                    Children = {actionLabel, pathfindingLabel},
-                };
-
-                var panel = new PanelContainer
-                {
-                    StyleClasses = { StyleNano.StyleClassTooltipPanel },
-                    Children = {vBox},
-                    MouseFilter = Control.MouseFilterMode.Ignore,
-                    ModulateSelfOverride = Color.White.WithAlpha(0.75f),
-                };
-
-                userInterfaceManager.StateRoot.AddChild(panel);
-
-                _aiBoxes[entity] = panel;
-                return true;
-            }
-
-            return false;
-        }
-    }
-
-    [Flags]
-    public enum AiDebugMode : byte
-    {
-        None = 0,
-        Paths = 1 << 1,
-        Thonk = 1 << 2,
-    }
-#endif
-}

Content.Client/AI/ClientPathfindingDebugSystem.cs

@@ -1,527 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Content.Shared.AI;
-using Robust.Client.Graphics;
-using Robust.Client.Player;
-using Robust.Shared.Enums;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Map;
-using Robust.Shared.Maths;
-using Robust.Shared.Prototypes;
-using Robust.Shared.Random;
-using Robust.Shared.Timing;
-
-namespace Content.Client.AI
-{
-#if DEBUG
-    public sealed class ClientPathfindingDebugSystem : EntitySystem
-    {
-        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
-        [Dependency] private readonly IEyeManager _eyeManager = default!;
-        [Dependency] private readonly IPlayerManager _playerManager = default!;
-
-
-        private PathfindingDebugMode _modes = PathfindingDebugMode.None;
-        private float _routeDuration = 4.0f; // How long before we remove a route from the overlay
-        private DebugPathfindingOverlay? _overlay;
-
-        public override void Initialize()
-        {
-            base.Initialize();
-            SubscribeNetworkEvent<SharedAiDebug.AStarRouteMessage>(HandleAStarRouteMessage);
-            SubscribeNetworkEvent<SharedAiDebug.JpsRouteMessage>(HandleJpsRouteMessage);
-            SubscribeNetworkEvent<SharedAiDebug.PathfindingGraphMessage>(HandleGraphMessage);
-            SubscribeNetworkEvent<SharedAiDebug.ReachableChunkRegionsDebugMessage>(HandleRegionsMessage);
-            SubscribeNetworkEvent<SharedAiDebug.ReachableCacheDebugMessage>(HandleCachedRegionsMessage);
-            // I'm lazy
-            EnableOverlay();
-        }
-
-        public override void Shutdown()
-        {
-            base.Shutdown();
-            DisableOverlay();
-        }
-
-        private void HandleAStarRouteMessage(SharedAiDebug.AStarRouteMessage message)
-        {
-            if ((_modes & PathfindingDebugMode.Nodes) != 0 ||
-                (_modes & PathfindingDebugMode.Route) != 0)
-            {
-                _overlay?.AStarRoutes.Add(message);
-                Timer.Spawn(TimeSpan.FromSeconds(_routeDuration), () =>
-                {
-                    if (_overlay == null) return;
-                    _overlay.AStarRoutes.Remove(message);
-                });
-            }
-        }
-
-        private void HandleJpsRouteMessage(SharedAiDebug.JpsRouteMessage message)
-        {
-            if ((_modes & PathfindingDebugMode.Nodes) != 0 ||
-                    (_modes & PathfindingDebugMode.Route) != 0)
-            {
-                _overlay?.JpsRoutes.Add(message);
-                Timer.Spawn(TimeSpan.FromSeconds(_routeDuration), () =>
-                {
-                    if (_overlay == null) return;
-                    _overlay.JpsRoutes.Remove(message);
-                });
-            }
-        }
-
-        private void HandleGraphMessage(SharedAiDebug.PathfindingGraphMessage message)
-        {
-            EnableOverlay().UpdateGraph(message.Graph);
-        }
-
-        private void HandleRegionsMessage(SharedAiDebug.ReachableChunkRegionsDebugMessage message)
-        {
-            EnableOverlay().UpdateRegions(message.GridId, message.Regions);
-        }
-
-        private void HandleCachedRegionsMessage(SharedAiDebug.ReachableCacheDebugMessage message)
-        {
-            EnableOverlay().UpdateCachedRegions(message.GridId, message.Regions, message.Cached);
-        }
-
-        private DebugPathfindingOverlay EnableOverlay()
-        {
-            if (_overlay != null)
-            {
-                return _overlay;
-            }
-
-            var overlayManager = IoCManager.Resolve<IOverlayManager>();
-            _overlay = new DebugPathfindingOverlay(EntityManager, _eyeManager, _playerManager, _prototypeManager) {Modes = _modes};
-            overlayManager.AddOverlay(_overlay);
-
-            return _overlay;
-        }
-
-        private void DisableOverlay()
-        {
-            if (_overlay == null)
-            {
-                return;
-            }
-
-            _overlay.Modes = 0;
-            var overlayManager = IoCManager.Resolve<IOverlayManager>();
-            overlayManager.RemoveOverlay(_overlay);
-            _overlay = null;
-        }
-
-        public void Disable()
-        {
-            _modes = PathfindingDebugMode.None;
-            DisableOverlay();
-        }
-
-
-        private void EnableMode(PathfindingDebugMode tooltip)
-        {
-            _modes |= tooltip;
-            if (_modes != 0)
-            {
-                EnableOverlay();
-            }
-
-            if (_overlay != null)
-            {
-                _overlay.Modes = _modes;
-            }
-
-            if (tooltip == PathfindingDebugMode.Graph)
-            {
-                RaiseNetworkEvent(new SharedAiDebug.RequestPathfindingGraphMessage());
-            }
-
-            if (tooltip == PathfindingDebugMode.Regions)
-            {
-                RaiseNetworkEvent(new SharedAiDebug.SubscribeReachableMessage());
-            }
-
-            // TODO: Request region graph, although the client system messages didn't seem to be going through anymore
-            // So need further investigation.
-        }
-
-        private void DisableMode(PathfindingDebugMode mode)
-        {
-            if (mode == PathfindingDebugMode.Regions && (_modes & PathfindingDebugMode.Regions) != 0)
-            {
-                RaiseNetworkEvent(new SharedAiDebug.UnsubscribeReachableMessage());
-            }
-
-            _modes &= ~mode;
-            if (_modes == 0)
-            {
-                DisableOverlay();
-            }
-            else if (_overlay != null)
-            {
-                _overlay.Modes = _modes;
-            }
-        }
-
-        public void ToggleTooltip(PathfindingDebugMode mode)
-        {
-            if ((_modes & mode) != 0)
-            {
-                DisableMode(mode);
-            }
-            else
-            {
-                EnableMode(mode);
-            }
-        }
-    }
-
-    internal sealed class DebugPathfindingOverlay : Overlay
-    {
-        private readonly IEyeManager _eyeManager;
-        private readonly IPlayerManager _playerManager;
-        private readonly IEntityManager _entities;
-
-        // TODO: Add a box like the debug one and show the most recent path stuff
-        public override OverlaySpace Space => OverlaySpace.ScreenSpace;
-        private readonly ShaderInstance _shader;
-
-        public PathfindingDebugMode Modes { get; set; } = PathfindingDebugMode.None;
-
-        // Graph debugging
-        public readonly Dictionary<int, List<Vector2>> Graph = new();
-        private readonly Dictionary<int, Color> _graphColors = new();
-
-        // Cached regions
-        public readonly Dictionary<EntityUid, Dictionary<int, List<Vector2>>> CachedRegions =
-                    new();
-
-        private readonly Dictionary<EntityUid, Dictionary<int, Color>> _cachedRegionColors =
-                     new();
-
-        // Regions
-        public readonly Dictionary<EntityUid, Dictionary<int, Dictionary<int, List<Vector2>>>> Regions =
-                    new();
-
-        private readonly Dictionary<EntityUid, Dictionary<int, Dictionary<int, Color>>> _regionColors =
-                     new();
-
-        // Route debugging
-        // As each pathfinder is very different you'll likely want to draw them completely different
-        public readonly List<SharedAiDebug.AStarRouteMessage> AStarRoutes = new();
-        public readonly List<SharedAiDebug.JpsRouteMessage> JpsRoutes = new();
-
-        public DebugPathfindingOverlay(IEntityManager entities, IEyeManager eyeManager, IPlayerManager playerManager, IPrototypeManager prototypeManager)
-        {
-            _entities = entities;
-            _eyeManager = eyeManager;
-            _playerManager = playerManager;
-            _shader = prototypeManager.Index<ShaderPrototype>("unshaded").Instance();
-        }
-
-        #region Graph
-        public void UpdateGraph(Dictionary<int, List<Vector2>> graph)
-        {
-            Graph.Clear();
-            _graphColors.Clear();
-            var robustRandom = IoCManager.Resolve<IRobustRandom>();
-            foreach (var (chunk, nodes) in graph)
-            {
-                Graph[chunk] = nodes;
-                _graphColors[chunk] = new Color(robustRandom.NextFloat(), robustRandom.NextFloat(),
-                    robustRandom.NextFloat(), 0.3f);
-            }
-        }
-
-        private void DrawGraph(DrawingHandleScreen screenHandle, Box2 viewport)
-        {
-            foreach (var (chunk, nodes) in Graph)
-            {
-                foreach (var tile in nodes)
-                {
-                    if (!viewport.Contains(tile)) continue;
-
-                    var screenTile = _eyeManager.WorldToScreen(tile);
-                    var box = new UIBox2(
-                        screenTile.X - 15.0f,
-                        screenTile.Y - 15.0f,
-                        screenTile.X + 15.0f,
-                        screenTile.Y + 15.0f);
-
-                    screenHandle.DrawRect(box, _graphColors[chunk]);
-                }
-            }
-        }
-        #endregion
-
-        #region Regions
-        //Server side debugger should increment every region
-        public void UpdateCachedRegions(EntityUid gridId, Dictionary<int, List<Vector2>> messageRegions, bool cached)
-        {
-            if (!CachedRegions.ContainsKey(gridId))
-            {
-                CachedRegions.Add(gridId, new Dictionary<int, List<Vector2>>());
-                _cachedRegionColors.Add(gridId, new Dictionary<int, Color>());
-            }
-
-            foreach (var (region, nodes) in messageRegions)
-            {
-                CachedRegions[gridId][region] = nodes;
-                if (cached)
-                {
-                    _cachedRegionColors[gridId][region] = Color.Blue.WithAlpha(0.3f);
-                }
-                else
-                {
-                    _cachedRegionColors[gridId][region] = Color.LimeGreen.WithAlpha(0.3f);
-                }
-
-                Timer.Spawn(3000, () =>
-                {
-                    if (CachedRegions[gridId].ContainsKey(region))
-                    {
-                        CachedRegions[gridId].Remove(region);
-                        _cachedRegionColors[gridId].Remove(region);
-                    }
-                });
-            }
-        }
-
-        private void DrawCachedRegions(DrawingHandleScreen screenHandle, Box2 viewport)
-        {
-            var transform = _entities.GetComponentOrNull<TransformComponent>(_playerManager.LocalPlayer?.ControlledEntity);
-            if (transform == null || transform.GridUid == null || !CachedRegions.TryGetValue(transform.GridUid.Value, out var entityRegions))
-            {
-                return;
-            }
-
-            foreach (var (region, nodes) in entityRegions)
-            {
-                foreach (var tile in nodes)
-                {
-                    if (!viewport.Contains(tile)) continue;
-
-                    var screenTile = _eyeManager.WorldToScreen(tile);
-                    var box = new UIBox2(
-                        screenTile.X - 15.0f,
-                        screenTile.Y - 15.0f,
-                        screenTile.X + 15.0f,
-                        screenTile.Y + 15.0f);
-
-                    screenHandle.DrawRect(box, _cachedRegionColors[transform.GridUid.Value][region]);
-                }
-            }
-        }
-
-        public void UpdateRegions(EntityUid gridId, Dictionary<int, Dictionary<int, List<Vector2>>> messageRegions)
-        {
-            if (!Regions.ContainsKey(gridId))
-            {
-                Regions.Add(gridId, new Dictionary<int, Dictionary<int, List<Vector2>>>());
-                _regionColors.Add(gridId, new Dictionary<int, Dictionary<int, Color>>());
-            }
-
-            var robustRandom = IoCManager.Resolve<IRobustRandom>();
-            foreach (var (chunk, regions) in messageRegions)
-            {
-                Regions[gridId][chunk] = new Dictionary<int, List<Vector2>>();
-                _regionColors[gridId][chunk] = new Dictionary<int, Color>();
-
-                foreach (var (region, nodes) in regions)
-                {
-                    Regions[gridId][chunk].Add(region, nodes);
-                    _regionColors[gridId][chunk][region] = new Color(robustRandom.NextFloat(), robustRandom.NextFloat(),
-                        robustRandom.NextFloat(), 0.5f);
-                }
-            }
-        }
-
-        private void DrawRegions(DrawingHandleScreen screenHandle, Box2 viewport)
-        {
-            var attachedEntity = _playerManager.LocalPlayer?.ControlledEntity;
-            if (!_entities.TryGetComponent(attachedEntity, out TransformComponent? transform) ||
-                transform.GridUid == null ||
-                !Regions.TryGetValue(transform.GridUid.Value, out var entityRegions))
-            {
-                return;
-            }
-
-            foreach (var (chunk, regions) in entityRegions)
-            {
-                foreach (var (region, nodes) in regions)
-                {
-                    foreach (var tile in nodes)
-                    {
-                        if (!viewport.Contains(tile)) continue;
-
-                        var screenTile = _eyeManager.WorldToScreen(tile);
-                        var box = new UIBox2(
-                            screenTile.X - 15.0f,
-                            screenTile.Y - 15.0f,
-                            screenTile.X + 15.0f,
-                            screenTile.Y + 15.0f);
-
-                        screenHandle.DrawRect(box, _regionColors[transform.GridUid.Value][chunk][region]);
-                    }
-                }
-            }
-        }
-        #endregion
-
-        #region Pathfinder
-        private void DrawAStarRoutes(DrawingHandleScreen screenHandle, Box2 viewport)
-        {
-            foreach (var route in AStarRoutes)
-            {
-                // Draw box on each tile of route
-                foreach (var position in route.Route)
-                {
-                    if (!viewport.Contains(position)) continue;
-                    var screenTile = _eyeManager.WorldToScreen(position);
-                    // worldHandle.DrawLine(position, nextWorld.Value, Color.Blue);
-                    var box = new UIBox2(
-                        screenTile.X - 15.0f,
-                        screenTile.Y - 15.0f,
-                        screenTile.X + 15.0f,
-                        screenTile.Y + 15.0f);
-                    screenHandle.DrawRect(box, Color.Orange.WithAlpha(0.25f));
-                }
-            }
-        }
-
-        private void DrawAStarNodes(DrawingHandleScreen screenHandle, Box2 viewport)
-        {
-            foreach (var route in AStarRoutes)
-            {
-                var highestGScore = route.GScores.Values.Max();
-
-                foreach (var (tile, score) in route.GScores)
-                {
-                    if ((route.Route.Contains(tile) && (Modes & PathfindingDebugMode.Route) != 0) ||
-                        !viewport.Contains(tile))
-                    {
-                        continue;
-                    }
-
-                    var screenTile = _eyeManager.WorldToScreen(tile);
-                    var box = new UIBox2(
-                        screenTile.X - 15.0f,
-                        screenTile.Y - 15.0f,
-                        screenTile.X + 15.0f,
-                        screenTile.Y + 15.0f);
-
-                    screenHandle.DrawRect(box, new Color(
-                        0.0f,
-                        score / highestGScore,
-                        1.0f - (score / highestGScore),
-                        0.1f));
-                }
-            }
-        }
-
-        private void DrawJpsRoutes(DrawingHandleScreen screenHandle, Box2 viewport)
-        {
-            foreach (var route in JpsRoutes)
-            {
-                // Draw box on each tile of route
-                foreach (var position in route.Route)
-                {
-                    if (!viewport.Contains(position)) continue;
-                    var screenTile = _eyeManager.WorldToScreen(position);
-                    // worldHandle.DrawLine(position, nextWorld.Value, Color.Blue);
-                    var box = new UIBox2(
-                        screenTile.X - 15.0f,
-                        screenTile.Y - 15.0f,
-                        screenTile.X + 15.0f,
-                        screenTile.Y + 15.0f);
-                    screenHandle.DrawRect(box, Color.Orange.WithAlpha(0.25f));
-                }
-            }
-        }
-
-        private void DrawJpsNodes(DrawingHandleScreen screenHandle, Box2 viewport)
-        {
-            foreach (var route in JpsRoutes)
-            {
-                foreach (var tile in route.JumpNodes)
-                {
-                    if ((route.Route.Contains(tile) && (Modes & PathfindingDebugMode.Route) != 0) ||
-                        !viewport.Contains(tile))
-                    {
-                        continue;
-                    }
-
-                    var screenTile = _eyeManager.WorldToScreen(tile);
-                    var box = new UIBox2(
-                        screenTile.X - 15.0f,
-                        screenTile.Y - 15.0f,
-                        screenTile.X + 15.0f,
-                        screenTile.Y + 15.0f);
-
-                    screenHandle.DrawRect(box, new Color(
-                        0.0f,
-                        1.0f,
-                        0.0f,
-                        0.2f));
-                }
-            }
-        }
-
-        #endregion
-
-        protected override void Draw(in OverlayDrawArgs args)
-        {
-            if (Modes == 0)
-            {
-                return;
-            }
-
-            var screenHandle = args.ScreenHandle;
-            screenHandle.UseShader(_shader);
-            var viewport = args.WorldAABB;
-
-            if ((Modes & PathfindingDebugMode.Route) != 0)
-            {
-                DrawAStarRoutes(screenHandle, viewport);
-                DrawJpsRoutes(screenHandle, viewport);
-            }
-
-            if ((Modes & PathfindingDebugMode.Nodes) != 0)
-            {
-                DrawAStarNodes(screenHandle, viewport);
-                DrawJpsNodes(screenHandle, viewport);
-            }
-
-            if ((Modes & PathfindingDebugMode.Graph) != 0)
-            {
-                DrawGraph(screenHandle, viewport);
-            }
-
-            if ((Modes & PathfindingDebugMode.CachedRegions) != 0)
-            {
-                DrawCachedRegions(screenHandle, viewport);
-            }
-
-            if ((Modes & PathfindingDebugMode.Regions) != 0)
-            {
-                DrawRegions(screenHandle, viewport);
-            }
-        }
-    }
-
-    [Flags]
-    public enum PathfindingDebugMode : byte
-    {
-        None = 0,
-        Route = 1 << 0,
-        Graph = 1 << 1,
-        Nodes = 1 << 2,
-        CachedRegions = 1 << 3,
-        Regions = 1 << 4,
-    }
-#endif
-}

Content.Client/AME/AMEControllerVisualizerSystem.cs

@@ -1,61 +0,0 @@
-using Content.Client.AME.Components;
-using Robust.Client.GameObjects;
-using static Content.Shared.AME.SharedAMEControllerComponent;
-
-namespace Content.Client.AME;
-
-public sealed class AMEControllerVisualizerSystem : VisualizerSystem<AMEControllerVisualsComponent>
-{
-    public override void Initialize()
-    {
-        base.Initialize();
-
-        SubscribeLocalEvent<AMEControllerVisualsComponent, ComponentInit>(OnComponentInit);
-    }
-
-    private void OnComponentInit(EntityUid uid, AMEControllerVisualsComponent component, ComponentInit args)
-    {
-        if(TryComp<SpriteComponent>(uid, out var sprite))
-        {
-            sprite.LayerMapSet(AMEControllerVisualLayers.Display, sprite.AddLayerState("control_on"));
-            sprite.LayerSetVisible(AMEControllerVisualLayers.Display, false);
-        }
-    }
-
-    protected override void OnAppearanceChange(EntityUid uid, AMEControllerVisualsComponent component, ref AppearanceChangeEvent args)
-    {
-        base.OnAppearanceChange(uid, component, ref args);
-
-        if(args.Sprite != null
-            && args.Component.TryGetData<string>(AMEControllerVisuals.DisplayState, out var state))
-        {
-            switch(state)
-            {
-                case "on":
-                    args.Sprite.LayerSetState(AMEControllerVisualLayers.Display, "control_on");
-                    args.Sprite.LayerSetVisible(AMEControllerVisualLayers.Display, true);
-                    break;
-                case "critical":
-                    args.Sprite.LayerSetState(AMEControllerVisualLayers.Display, "control_critical");
-                    args.Sprite.LayerSetVisible(AMEControllerVisualLayers.Display, true);
-                    break;
-                case "fuck":
-                    args.Sprite.LayerSetState(AMEControllerVisualLayers.Display, "control_fuck");
-                    args.Sprite.LayerSetVisible(AMEControllerVisualLayers.Display, true);
-                    break;
-                case "off":
-                    args.Sprite.LayerSetVisible(AMEControllerVisualLayers.Display, false);
-                    break;
-                default:
-                    args.Sprite.LayerSetVisible(AMEControllerVisualLayers.Display, false);
-                    break;
-            }
-        }
-    }
-}
-
-public enum AMEControllerVisualLayers : byte
-{
-    Display
-}
-

Content.Client/AME/AMEShieldingVisualizerSystem.cs

@@ -1,70 +0,0 @@
-using Content.Client.AME.Components;
-using Robust.Client.GameObjects;
-using static Content.Shared.AME.SharedAMEShieldComponent;
-
-namespace Content.Client.AME;
-
-public sealed class AMEShieldingVisualizerSystem : VisualizerSystem<AMEShieldingVisualsComponent>
-{
-    public override void Initialize()
-    {
-        base.Initialize();
-
-        SubscribeLocalEvent<AMEShieldingVisualsComponent, ComponentInit>(OnComponentInit);
-    }
-
-    private void OnComponentInit(EntityUid uid, AMEShieldingVisualsComponent component, ComponentInit args)
-    {
-        if(TryComp<SpriteComponent>(uid, out var sprite))
-        {
-            sprite.LayerMapSet(AMEShieldingVisualsLayer.Core, sprite.AddLayerState("core"));
-            sprite.LayerSetVisible(AMEShieldingVisualsLayer.Core, false);
-            sprite.LayerMapSet(AMEShieldingVisualsLayer.CoreState, sprite.AddLayerState("core_weak"));
-            sprite.LayerSetVisible(AMEShieldingVisualsLayer.CoreState, false);
-        }
-    }
-
-    protected override void OnAppearanceChange(EntityUid uid, AMEShieldingVisualsComponent component, ref AppearanceChangeEvent args)
-    {
-        if(args.Sprite == null)
-            return;
-
-        if(args.Component.TryGetData<string>(AMEShieldVisuals.Core, out var core))
-        {
-            if (core == "isCore")
-            {
-                args.Sprite.LayerSetState(AMEShieldingVisualsLayer.Core, "core");
-                args.Sprite.LayerSetVisible(AMEShieldingVisualsLayer.Core, true);
-
-            }
-            else
-            {
-                args.Sprite.LayerSetVisible(AMEShieldingVisualsLayer.Core, false);
-            }
-        }
-
-        if(args.Component.TryGetData<string>(AMEShieldVisuals.CoreState, out var coreState))
-        {
-            switch(coreState)
-            {
-                case "weak":
-                    args.Sprite.LayerSetState(AMEShieldingVisualsLayer.CoreState, "core_weak");
-                    args.Sprite.LayerSetVisible(AMEShieldingVisualsLayer.CoreState, true);
-                    break;
-                case "strong":
-                    args.Sprite.LayerSetState(AMEShieldingVisualsLayer.CoreState, "core_strong");
-                    args.Sprite.LayerSetVisible(AMEShieldingVisualsLayer.CoreState, true);
-                    break;
-                case "off":
-                    args.Sprite.LayerSetVisible(AMEShieldingVisualsLayer.CoreState, false);
-                    break;
-            }
-        }
-    }
-}
-
-public enum AMEShieldingVisualsLayer : byte
-{
-    Core,
-    CoreState,
-}

Content.Client/AME/Components/AMEControllerVisualsComponent.cs

@@ -1,9 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using Robust.Shared.GameObjects;
-
-namespace Content.Client.AME.Components;
-
-[RegisterComponent]
-public sealed class AMEControllerVisualsComponent : Component
-{
-}

Content.Client/AME/Components/AMEShieldingVisualsComponent.cs

@@ -1,9 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using Robust.Shared.GameObjects;
-
-namespace Content.Client.AME.Components;
-
-[RegisterComponent]
-public sealed class AMEShieldingVisualsComponent : Component
-{
-}

Content.Client/AME/UI/AMEControllerBoundUserInterface.cs

@@ -1,57 +0,0 @@
-using Content.Shared.Chemistry.Dispenser;
-using JetBrains.Annotations;
-using Robust.Client.GameObjects;
-using Robust.Shared.GameObjects;
-using static Content.Shared.AME.SharedAMEControllerComponent;
-
-namespace Content.Client.AME.UI
-{
-    [UsedImplicitly]
-    public sealed class AMEControllerBoundUserInterface : BoundUserInterface
-    {
-        private AMEWindow? _window;
-
-        public AMEControllerBoundUserInterface(ClientUserInterfaceComponent owner, object uiKey) : base(owner, uiKey)
-        {
-        }
-
-        protected override void Open()
-        {
-            base.Open();
-
-            _window = new AMEWindow(this);
-            _window.OnClose += Close;
-            _window.OpenCentered();
-        }
-
-        /// <summary>
-        /// Update the ui each time new state data is sent from the server.
-        /// </summary>
-        /// <param name="state">
-        /// Data of the <see cref="SharedReagentDispenserComponent"/> that this ui represents.
-        /// Sent from the server.
-        /// </param>
-        protected override void UpdateState(BoundUserInterfaceState state)
-        {
-            base.UpdateState(state);
-
-            var castState = (AMEControllerBoundUserInterfaceState) state;
-            _window?.UpdateState(castState); //Update window state
-        }
-
-        public void ButtonPressed(UiButton button, int dispenseIndex = -1)
-        {
-            SendMessage(new UiButtonPressedMessage(button));
-        }
-
-        protected override void Dispose(bool disposing)
-        {
-            base.Dispose(disposing);
-
-            if (disposing)
-            {
-                _window?.Dispose();
-            }
-        }
-    }
-}

Content.Client/AME/UI/AMEWindow.xaml.cs

@@ -1,74 +0,0 @@
-using Content.Client.UserInterface;
-using Robust.Client.AutoGenerated;
-using Robust.Client.UserInterface;
-using Robust.Client.UserInterface.Controls;
-using Robust.Client.UserInterface.CustomControls;
-using Robust.Client.UserInterface.XAML;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
-using Robust.Shared.Localization;
-using static Content.Shared.AME.SharedAMEControllerComponent;
-
-namespace Content.Client.AME.UI
-{
-    [GenerateTypedNameReferences]
-    public sealed partial class AMEWindow : DefaultWindow
-    {
-        public AMEWindow(AMEControllerBoundUserInterface ui)
-        {
-            RobustXamlLoader.Load(this);
-            IoCManager.InjectDependencies(this);
-
-            EjectButton.OnPressed += _ => ui.ButtonPressed(UiButton.Eject);
-            ToggleInjection.OnPressed += _ => ui.ButtonPressed(UiButton.ToggleInjection);
-            IncreaseFuelButton.OnPressed += _ => ui.ButtonPressed(UiButton.IncreaseFuel);
-            DecreaseFuelButton.OnPressed += _ => ui.ButtonPressed(UiButton.DecreaseFuel);
-        }
-
-        /// <summary>
-        /// Update the UI state when new state data is received from the server.
-        /// </summary>
-        /// <param name="state">State data sent by the server.</param>
-        public void UpdateState(BoundUserInterfaceState state)
-        {
-            var castState = (AMEControllerBoundUserInterfaceState) state;
-
-            // Disable all buttons if not powered
-            if (Contents.Children != null)
-            {
-                ButtonHelpers.SetButtonDisabledRecursive(Contents, !castState.HasPower);
-                EjectButton.Disabled = false;
-            }
-
-            if (!castState.HasFuelJar)
-            {
-                EjectButton.Disabled = true;
-                ToggleInjection.Disabled = true;
-                FuelAmount.Text = Loc.GetString("ame-window-fuel-not-inserted-text");
-            }
-            else
-            {
-                EjectButton.Disabled = false;
-                ToggleInjection.Disabled = false;
-                FuelAmount.Text = $"{castState.FuelAmount}";
-            }
-
-            if (!castState.IsMaster)
-            {
-                ToggleInjection.Disabled = true;
-            }
-
-            if (!castState.Injecting)
-            {
-                InjectionStatus.Text = Loc.GetString("ame-window-engine-injection-status-not-injecting-label") + " ";
-            }
-            else
-            {
-                InjectionStatus.Text = Loc.GetString("ame-window-engine-injection-status-injecting-label") + " ";
-            }
-
-            CoreCount.Text = $"{castState.CoreCount}";
-            InjectionAmount.Text = $"{castState.InjectionAmount}";
-        }
-    }
-}

Content.Client/Access/AccessOverlay.cs

@@ -0,0 +1,81 @@
+using System.Text;
+using Content.Client.Resources;
+using Content.Shared.Access.Components;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Enums;
+
+namespace Content.Client.Access;
+
+public sealed class AccessOverlay : Overlay
+{
+    private readonly IEntityManager _entityManager;
+    private readonly EntityLookupSystem _lookup;
+    private readonly SharedTransformSystem _xform;
+    private readonly Font _font;
+
+    public override OverlaySpace Space => OverlaySpace.ScreenSpace;
+
+    public AccessOverlay(IEntityManager entManager, IResourceCache cache, EntityLookupSystem lookup, SharedTransformSystem xform)
+    {
+        _entityManager = entManager;
+        _lookup = lookup;
+        _xform = xform;
+
+        _font = cache.GetFont("/Fonts/NotoSans/NotoSans-Regular.ttf", 12);
+    }
+
+    protected override void Draw(in OverlayDrawArgs args)
+    {
+        if (args.ViewportControl == null)
+            return;
+
+        var readerQuery = _entityManager.GetEntityQuery<AccessReaderComponent>();
+        var xformQuery = _entityManager.GetEntityQuery<TransformComponent>();
+
+        foreach (var ent in _lookup.GetEntitiesIntersecting(args.MapId, args.WorldAABB,
+                         LookupFlags.Static | LookupFlags.Approximate))
+        {
+            if (!readerQuery.TryGetComponent(ent, out var reader) ||
+                !xformQuery.TryGetComponent(ent, out var xform))
+            {
+                continue;
+            }
+
+            var text = new StringBuilder();
+            var index = 0;
+            var a = $"{_entityManager.ToPrettyString(ent)}";
+            text.Append(a);
+
+            foreach (var list in reader.AccessLists)
+            {
+                a = $"Tag {index}";
+                text.AppendLine(a);
+
+                foreach (var entry in list)
+                {
+                    a = $"- {entry}";
+                    text.AppendLine(a);
+                }
+
+                index++;
+            }
+
+            string textStr;
+
+            if (text.Length >= 2)
+            {
+                textStr = text.ToString();
+                textStr = textStr[..^2];
+            }
+            else
+            {
+                textStr = "";
+            }
+
+            var screenPos = args.ViewportControl.WorldToScreen(_xform.GetWorldPosition(xform));
+
+            args.ScreenHandle.DrawString(_font, screenPos, textStr, Color.Gold);
+        }
+    }
+}

Content.Client/Access/AccessOverriderSystem.cs

@@ -0,0 +1,11 @@
+using Content.Shared.Access.Systems;
+using JetBrains.Annotations;
+
+namespace Content.Client.Access
+{
+    [UsedImplicitly]
+    public sealed class AccessOverriderSystem : SharedAccessOverriderSystem
+    {
+
+    }
+}

Content.Client/Access/AccessSystem.cs

@@ -0,0 +1,7 @@
+using Content.Shared.Access.Systems;
+
+namespace Content.Client.Access;
+
+public sealed class AccessSystem : SharedAccessSystem
+{
+}

Content.Client/Access/Commands/ShowAccessReadersCommand.cs

@@ -0,0 +1,35 @@
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+using Robust.Shared.Console;
+
+namespace Content.Client.Access.Commands;
+
+public sealed class ShowAccessReadersCommand : IConsoleCommand
+{
+    public string Command => "showaccessreaders";
+    public string Description => "Shows all access readers in the viewport";
+    public string Help => $"{Command}";
+    public void Execute(IConsoleShell shell, string argStr, string[] args)
+    {
+        var collection = IoCManager.Instance;
+
+        if (collection == null)
+            return;
+
+        var overlay = collection.Resolve<IOverlayManager>();
+
+        if (overlay.RemoveOverlay<AccessOverlay>())
+        {
+            shell.WriteLine($"Set access reader debug overlay to false");
+            return;
+        }
+
+        var entManager = collection.Resolve<IEntityManager>();
+        var cache = collection.Resolve<IResourceCache>();
+        var lookup = entManager.System<EntityLookupSystem>();
+        var xform = entManager.System<SharedTransformSystem>();
+
+        overlay.AddOverlay(new AccessOverlay(entManager, cache, lookup, xform));
+        shell.WriteLine($"Set access reader debug overlay to true");
+    }
+}

Content.Client/Access/Components/IdCardConsoleComponent.cs

@@ -1,7 +0,0 @@
-using Content.Shared.Access.Components;
-
-namespace Content.Client.Access.Components;
-
-[RegisterComponent]
-[ComponentReference(typeof(SharedIdCardConsoleComponent))]
-public sealed class IdCardConsoleComponent : SharedIdCardConsoleComponent {}

Content.Client/Access/IdCardSystem.cs

@@ -0,0 +1,7 @@
+using Content.Shared.Access.Systems;
+
+namespace Content.Client.Access;
+
+public sealed class IdCardSystem : SharedIdCardSystem
+{
+}

Content.Client/Access/UI/AccessOverriderBoundUserInterface.cs

@@ -0,0 +1,72 @@
+using Content.Shared.Access.Components;
+using Content.Shared.Access.Systems;
+using Content.Shared.Containers.ItemSlots;
+using Robust.Client.GameObjects;
+using Robust.Shared.Prototypes;
+using static Content.Shared.Access.Components.AccessOverriderComponent;
+
+namespace Content.Client.Access.UI
+{
+    public sealed class AccessOverriderBoundUserInterface : BoundUserInterface
+    {
+        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+        private readonly SharedAccessOverriderSystem _accessOverriderSystem = default!;
+
+        private AccessOverriderWindow? _window;
+
+        public AccessOverriderBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+        {
+            _accessOverriderSystem = EntMan.System<SharedAccessOverriderSystem>();
+        }
+
+        protected override void Open()
+        {
+            base.Open();
+
+            List<string> accessLevels;
+
+            if (EntMan.TryGetComponent<AccessOverriderComponent>(Owner, out var accessOverrider))
+            {
+                accessLevels = accessOverrider.AccessLevels;
+                accessLevels.Sort();
+            }
+
+            else
+            {
+                accessLevels = new List<string>();
+                _accessOverriderSystem.Log.Error($"No AccessOverrider component found for {EntMan.ToPrettyString(Owner)}!");
+            }
+
+            _window = new AccessOverriderWindow(this, _prototypeManager, accessLevels)
+            {
+                Title = EntMan.GetComponent<MetaDataComponent>(Owner).EntityName
+            };
+
+            _window.PrivilegedIdButton.OnPressed += _ => SendMessage(new ItemSlotButtonPressedEvent(PrivilegedIdCardSlotId));
+
+            _window.OnClose += Close;
+            _window.OpenCentered();
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            base.Dispose(disposing);
+            if (!disposing)
+                return;
+
+            _window?.Dispose();
+        }
+
+        protected override void UpdateState(BoundUserInterfaceState state)
+        {
+            base.UpdateState(state);
+            var castState = (AccessOverriderBoundUserInterfaceState) state;
+            _window?.UpdateState(castState);
+        }
+
+        public void SubmitData(List<string> newAccessList)
+        {
+            SendMessage(new WriteToTargetAccessReaderIdMessage(newAccessList));
+        }
+    }
+}

Content.Client/Access/UI/AccessOverriderWindow.xaml

@@ -0,0 +1,23 @@
+<DefaultWindow xmlns="https://spacestation14.io"
+            MinSize="650 290">
+    <BoxContainer Orientation="Vertical">
+        <GridContainer Columns="2">
+            <GridContainer Columns="3" HorizontalExpand="True">
+                <Label Text="{Loc 'access-overrider-window-privileged-id'}" />
+                <Button Name="PrivilegedIdButton" Access="Public"/>
+                <Label Name="PrivilegedIdLabel" />
+            </GridContainer>
+        </GridContainer>
+        <Label Name="TargetNameLabel" />
+        <Control MinSize="0 8"/>
+        <GridContainer Name="AccessLevelGrid" Columns="5" HorizontalAlignment="Center">
+
+            <!-- Access level buttons are added here by the C# code -->
+
+        </GridContainer>
+        <Control MinSize="0 8"/>
+        <Label Name="MissingPrivilegesLabel" />
+        <Control MinSize="0 4"/>
+        <Label Name="MissingPrivilegesText" />
+    </BoxContainer>
+</DefaultWindow>

Content.Client/Access/UI/AccessOverriderWindow.xaml.cs

@@ -0,0 +1,111 @@
+using System.Linq;
+using Content.Shared.Access;
+using Content.Shared.Access.Systems;
+using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Prototypes;
+using static Content.Shared.Access.Components.AccessOverriderComponent;
+
+namespace Content.Client.Access.UI
+{
+    [GenerateTypedNameReferences]
+    public sealed partial class AccessOverriderWindow : DefaultWindow
+    {
+        [Dependency] private readonly ILogManager _logManager = default!;
+        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+
+        private readonly ISawmill _logMill = default!;
+        private readonly AccessOverriderBoundUserInterface _owner;
+        private readonly Dictionary<string, Button> _accessButtons = new();
+
+        public AccessOverriderWindow(AccessOverriderBoundUserInterface owner, IPrototypeManager prototypeManager,
+            List<string> accessLevels)
+        {
+            RobustXamlLoader.Load(this);
+            IoCManager.InjectDependencies(this);
+            _logMill = _logManager.GetSawmill(SharedAccessOverriderSystem.Sawmill);
+
+            _owner = owner;
+
+            foreach (var access in accessLevels)
+            {
+                if (!prototypeManager.TryIndex<AccessLevelPrototype>(access, out var accessLevel))
+                {
+                    _logMill.Error($"Unable to find accesslevel for {access}");
+                    continue;
+                }
+
+                var newButton = new Button
+                {
+                    Text = GetAccessLevelName(accessLevel),
+                    ToggleMode = true,
+                };
+
+                AccessLevelGrid.AddChild(newButton);
+                _accessButtons.Add(accessLevel.ID, newButton);
+                newButton.OnPressed += _ => SubmitData();
+            }
+        }
+
+        private static string GetAccessLevelName(AccessLevelPrototype prototype)
+        {
+            if (prototype.Name is { } name)
+                return Loc.GetString(name);
+
+            return prototype.ID;
+        }
+
+        public void UpdateState(AccessOverriderBoundUserInterfaceState state)
+        {
+            PrivilegedIdLabel.Text = state.PrivilegedIdName;
+            PrivilegedIdButton.Text = state.IsPrivilegedIdPresent
+                ? Loc.GetString("access-overrider-window-eject-button")
+                : Loc.GetString("access-overrider-window-insert-button");
+
+            TargetNameLabel.Text = state.TargetLabel;
+            TargetNameLabel.FontColorOverride = state.TargetLabelColor;
+
+            MissingPrivilegesLabel.Text = "";
+            MissingPrivilegesLabel.FontColorOverride = Color.Yellow;
+
+            MissingPrivilegesText.Text = "";
+            MissingPrivilegesText.FontColorOverride = Color.Yellow;
+
+            if (state.MissingPrivilegesList != null && state.MissingPrivilegesList.Any())
+            {
+                List<string> missingPrivileges = new List<string>();
+
+                foreach (string tag in state.MissingPrivilegesList)
+                {
+                    string privilege = Loc.GetString(_prototypeManager.Index<AccessLevelPrototype>(tag)?.Name ?? "generic-unknown");
+                    missingPrivileges.Add(privilege);
+                }
+
+                MissingPrivilegesLabel.Text = Loc.GetString("access-overrider-window-missing-privileges");
+                MissingPrivilegesText.Text = string.Join(", ", missingPrivileges);
+            }
+
+            var interfaceEnabled = state.IsPrivilegedIdPresent && state.IsPrivilegedIdAuthorized;
+
+            foreach (var (accessName, button) in _accessButtons)
+            {
+                button.Disabled = !interfaceEnabled;
+                if (interfaceEnabled)
+                {
+                    button.Pressed = state.TargetAccessReaderIdAccessList?.Contains(accessName) ?? false;
+                    button.Disabled = (!state.AllowedModifyAccessList?.Contains(accessName)) ?? true;
+                }
+            }
+        }
+
+        private void SubmitData()
+        {
+            _owner.SubmitData(
+
+                // Iterate over the buttons dictionary, filter by `Pressed`, only get key from the key/value pair
+                _accessButtons.Where(x => x.Value.Pressed).Select(x => x.Key).ToList());
+        }
+    }
+}

Content.Client/Access/UI/AgentIDCardBoundUserInterface.cs

@@ -10,7 +10,7 @@ namespace Content.Client.Access.UI
     {
         private AgentIDCardWindow? _window;
 
-        public AgentIDCardBoundUserInterface(ClientUserInterfaceComponent owner, object uiKey) : base(owner, uiKey)
+        public AgentIDCardBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
         {
         }
 
@@ -18,15 +18,16 @@ namespace Content.Client.Access.UI
         {
             base.Open();
 
-            _window = new AgentIDCardWindow();
+            _window?.Dispose();
+            _window = new AgentIDCardWindow(this);
             if (State != null)
                 UpdateState(State);
 
             _window.OpenCentered();
 
             _window.OnClose += Close;
-            _window.OnNameEntered += OnNameChanged;
-            _window.OnJobEntered += OnJobChanged;
+            _window.OnNameChanged += OnNameChanged;
+            _window.OnJobChanged += OnJobChanged;
         }
 
         private void OnNameChanged(string newName)
@@ -39,6 +40,11 @@ namespace Content.Client.Access.UI
             SendMessage(new AgentIDCardJobChangedMessage(newJob));
         }
 
+        public void OnJobIconChanged(string newJobIcon)
+        {
+            SendMessage(new AgentIDCardJobIconChangedMessage(newJobIcon));
+        }
+
         /// <summary>
         /// Update the UI state based on server-sent info
         /// </summary>
@@ -51,14 +57,16 @@ namespace Content.Client.Access.UI
 
             _window.SetCurrentName(cast.CurrentName);
             _window.SetCurrentJob(cast.CurrentJob);
+            _window.SetAllowedIcons(cast.Icons);
         }
 
         protected override void Dispose(bool disposing)
         {
             base.Dispose(disposing);
-            if (!disposing) return;
+            if (!disposing)
+                return;
+
             _window?.Dispose();
         }
     }
-
 }

Content.Client/Access/UI/AgentIDCardWindow.xaml

@@ -6,5 +6,12 @@
         <LineEdit Name="NameLineEdit" />
         <Label Name="CurrentJob" Text="{Loc 'agent-id-card-current-job'}" />
         <LineEdit Name="JobLineEdit" />
+        <BoxContainer Orientation="Horizontal">
+            <Label Text="{Loc 'agent-id-card-job-icon-label'}"/>
+            <Control HorizontalExpand="True" MinSize="50 0"/>
+            <GridContainer Name="IconGrid" Columns="10">
+                <!-- Job icon buttons are generated in the code -->
+            </GridContainer>
+        </BoxContainer>
     </BoxContainer>
 </DefaultWindow>

Content.Client/Access/UI/AgentIDCardWindow.xaml.cs

@@ -1,22 +1,86 @@
-using Robust.Client.UserInterface.CustomControls;
+using Content.Client.Stylesheets;
+using Content.Shared.StatusIcon;
 using Robust.Client.AutoGenerated;
+using Robust.Client.GameObjects;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.UserInterface.XAML;
+using Robust.Shared.Prototypes;
+using System.Numerics;
 
 namespace Content.Client.Access.UI
 {
     [GenerateTypedNameReferences]
     public sealed partial class AgentIDCardWindow : DefaultWindow
     {
-        public event Action<string>? OnNameEntered;
+        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+        [Dependency] private readonly IEntitySystemManager _entitySystem = default!;
+        private readonly SpriteSystem _spriteSystem;
+        private readonly AgentIDCardBoundUserInterface _bui;
 
-        public event Action<string>? OnJobEntered;
+        private const int JobIconColumnCount = 10;
 
-        public AgentIDCardWindow()
+        public event Action<string>? OnNameChanged;
+        public event Action<string>? OnJobChanged;
+
+        public AgentIDCardWindow(AgentIDCardBoundUserInterface bui)
         {
             RobustXamlLoader.Load(this);
+            IoCManager.InjectDependencies(this);
+            _spriteSystem = _entitySystem.GetEntitySystem<SpriteSystem>();
+            _bui = bui;
 
-            NameLineEdit.OnTextEntered += e => OnNameEntered?.Invoke(e.Text);
-            JobLineEdit.OnTextEntered += e => OnJobEntered?.Invoke(e.Text);
+            NameLineEdit.OnTextEntered += e => OnNameChanged?.Invoke(e.Text);
+            NameLineEdit.OnFocusExit += e => OnNameChanged?.Invoke(e.Text);
+
+            JobLineEdit.OnTextEntered += e => OnJobChanged?.Invoke(e.Text);
+            JobLineEdit.OnFocusExit += e => OnJobChanged?.Invoke(e.Text);
+        }
+
+        public void SetAllowedIcons(HashSet<string> icons)
+        {
+            IconGrid.DisposeAllChildren();
+
+            var jobIconGroup = new ButtonGroup();
+            var i = 0;
+            foreach (var jobIconId in icons)
+            {
+                if (!_prototypeManager.TryIndex<StatusIconPrototype>(jobIconId, out var jobIcon))
+                {
+                    continue;
+                }
+
+                String styleBase = StyleBase.ButtonOpenBoth;
+                var modulo = i % JobIconColumnCount;
+                if (modulo == 0)
+                    styleBase = StyleBase.ButtonOpenRight;
+                else if (modulo == JobIconColumnCount - 1)
+                    styleBase = StyleBase.ButtonOpenLeft;
+
+                // Generate buttons
+                var jobIconButton = new Button
+                {
+                    Access = AccessLevel.Public,
+                    StyleClasses = { styleBase },
+                    MaxSize = new Vector2(42, 28),
+                    Group = jobIconGroup,
+                    Pressed = i == 0,
+                };
+
+                // Generate buttons textures
+                TextureRect jobIconTexture = new TextureRect
+                {
+                    Texture = _spriteSystem.Frame0(jobIcon.Icon),
+                    TextureScale = new Vector2(2.5f, 2.5f),
+                    Stretch = TextureRect.StretchMode.KeepCentered,
+                };
+
+                jobIconButton.AddChild(jobIconTexture);
+                jobIconButton.OnPressed += _ => _bui.OnJobIconChanged(jobIcon.ID);
+                IconGrid.AddChild(jobIconButton);
+                i++;
+            }
         }
 
         public void SetCurrentName(string name)

Content.Client/Access/UI/IdCardConsoleBoundUserInterface.cs

@@ -1,29 +1,30 @@
-using Content.Client.Access.Components;
+using Content.Shared.Access.Components;
 using Content.Shared.Access.Systems;
 using Content.Shared.Containers.ItemSlots;
+using Content.Shared.CrewManifest;
 using Robust.Client.GameObjects;
 using Robust.Shared.Prototypes;
-using static Content.Shared.Access.Components.SharedIdCardConsoleComponent;
-
+using static Content.Shared.Access.Components.IdCardConsoleComponent;
 namespace Content.Client.Access.UI
 {
     public sealed class IdCardConsoleBoundUserInterface : BoundUserInterface
     {
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
-        [Dependency] private readonly IEntityManager _entityManager = default!;
-
-        public IdCardConsoleBoundUserInterface(ClientUserInterfaceComponent owner, object uiKey) : base(owner, uiKey)
-        {
-        }
+        private readonly SharedIdCardConsoleSystem _idCardConsoleSystem = default!;
 
         private IdCardConsoleWindow? _window;
 
+        public IdCardConsoleBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey)
+        {
+            _idCardConsoleSystem = EntMan.System<SharedIdCardConsoleSystem>();
+        }
+
         protected override void Open()
         {
             base.Open();
             List<string> accessLevels;
 
-            if (_entityManager.TryGetComponent<IdCardConsoleComponent>(Owner.Owner, out var idCard))
+            if (EntMan.TryGetComponent<IdCardConsoleComponent>(Owner, out var idCard))
             {
                 accessLevels = idCard.AccessLevels;
                 accessLevels.Sort();
@@ -31,11 +32,15 @@ namespace Content.Client.Access.UI
             else
             {
                 accessLevels = new List<string>();
-                Logger.ErrorS(SharedIdCardConsoleSystem.Sawmill, $"No IdCardConsole component found for {_entityManager.ToPrettyString(Owner.Owner)}!");
+                _idCardConsoleSystem.Log.Error($"No IdCardConsole component found for {EntMan.ToPrettyString(Owner)}!");
             }
 
-            _window = new IdCardConsoleWindow(this, _prototypeManager, accessLevels) {Title = _entityManager.GetComponent<MetaDataComponent>(Owner.Owner).EntityName};
+            _window = new IdCardConsoleWindow(this, _prototypeManager, accessLevels)
+            {
+                Title = EntMan.GetComponent<MetaDataComponent>(Owner).EntityName
+            };
 
+            _window.CrewManifestButton.OnPressed += _ => SendMessage(new CrewManifestOpenUiMessage());
             _window.PrivilegedIdButton.OnPressed += _ => SendMessage(new ItemSlotButtonPressedEvent(PrivilegedIdCardSlotId));
             _window.TargetIdButton.OnPressed += _ => SendMessage(new ItemSlotButtonPressedEvent(TargetIdCardSlotId));
 
@@ -46,7 +51,9 @@ namespace Content.Client.Access.UI
         protected override void Dispose(bool disposing)
         {
             base.Dispose(disposing);
-            if (!disposing) return;
+            if (!disposing)
+                return;
+
             _window?.Dispose();
         }
 
@@ -57,7 +64,7 @@ namespace Content.Client.Access.UI
             _window?.UpdateState(castState);
         }
 
-        public void SubmitData(string newFullName, string newJobTitle, List<string> newAccessList)
+        public void SubmitData(string newFullName, string newJobTitle, List<string> newAccessList, string newJobPrototype)
         {
             if (newFullName.Length > MaxFullNameLength)
                 newFullName = newFullName[..MaxFullNameLength];
@@ -68,7 +75,8 @@ namespace Content.Client.Access.UI
             SendMessage(new WriteToTargetIdMessage(
                 newFullName,
                 newJobTitle,
-                newAccessList));
+                newAccessList,
+                newJobPrototype));
         }
     }
 }

Content.Client/Access/UI/IdCardConsoleWindow.xaml

@@ -1,14 +1,19 @@
 <DefaultWindow xmlns="https://spacestation14.io"
             MinSize="650 290">
     <BoxContainer Orientation="Vertical">
-        <GridContainer Columns="3">
-            <Label Text="{Loc 'id-card-console-window-privileged-id'}" />
-            <Button Name="PrivilegedIdButton" Access="Public"/>
-            <Label Name="PrivilegedIdLabel" />
+        <GridContainer Columns="2">
+            <GridContainer Columns="3" HorizontalExpand="True">
+                <Label Text="{Loc 'id-card-console-window-privileged-id'}" />
+                <Button Name="PrivilegedIdButton" Access="Public"/>
+                <Label Name="PrivilegedIdLabel" />
 
-            <Label Text="{Loc 'id-card-console-window-target-id'}" />
-            <Button Name="TargetIdButton" Access="Public"/>
-            <Label Name="TargetIdLabel" />
+                <Label Text="{Loc 'id-card-console-window-target-id'}" />
+                <Button Name="TargetIdButton" Access="Public"/>
+                <Label Name="TargetIdLabel" />
+            </GridContainer>
+            <BoxContainer Orientation="Vertical">
+                <Button Name="CrewManifestButton" Access="Public" Text="{Loc 'crew-manifest-button-label'}" />
+            </BoxContainer>
         </GridContainer>
         <Control MinSize="0 8" />
         <GridContainer Columns="3" HSeparationOverride="4">
@@ -21,6 +26,10 @@
             <Button Name="JobTitleSaveButton" Text="{Loc 'id-card-console-window-save-button'}" Disabled="True" />
         </GridContainer>
         <Control MinSize="0 8" />
+        <GridContainer Columns="2">
+            <Label Text="{Loc 'id-card-console-window-job-selection-label'}" />
+            <OptionButton Name="JobPresetOptionButton" />
+        </GridContainer>
         <GridContainer Name="AccessLevelGrid" Columns="5" HorizontalAlignment="Center">
 
             <!-- Access level buttons are added here by the C# code -->

Content.Client/Access/UI/IdCardConsoleWindow.xaml.cs

@@ -1,31 +1,38 @@
-using System.Collections.Generic;
 using System.Linq;
 using Content.Shared.Access;
 using Content.Shared.Access.Systems;
+using Content.Shared.Roles;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.UserInterface.XAML;
-using Robust.Shared.Localization;
-using Robust.Shared.Maths;
 using Robust.Shared.Prototypes;
-using static Content.Shared.Access.Components.SharedIdCardConsoleComponent;
+using static Content.Shared.Access.Components.IdCardConsoleComponent;
 
 namespace Content.Client.Access.UI
 {
     [GenerateTypedNameReferences]
     public sealed partial class IdCardConsoleWindow : DefaultWindow
     {
+        [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+        [Dependency] private readonly ILogManager _logManager = default!;
+        private readonly ISawmill _logMill = default!;
+
         private readonly IdCardConsoleBoundUserInterface _owner;
 
         private readonly Dictionary<string, Button> _accessButtons = new();
+        private readonly List<string> _jobPrototypeIds = new();
 
         private string? _lastFullName;
         private string? _lastJobTitle;
+        private string? _lastJobProto;
 
-        public IdCardConsoleWindow(IdCardConsoleBoundUserInterface owner, IPrototypeManager prototypeManager, List<string> accessLevels)
+        public IdCardConsoleWindow(IdCardConsoleBoundUserInterface owner, IPrototypeManager prototypeManager,
+            List<string> accessLevels)
         {
             RobustXamlLoader.Load(this);
+            IoCManager.InjectDependencies(this);
+            _logMill = _logManager.GetSawmill(SharedIdCardConsoleSystem.Sawmill);
 
             _owner = owner;
 
@@ -43,17 +50,33 @@ namespace Content.Client.Access.UI
             };
             JobTitleSaveButton.OnPressed += _ => SubmitData();
 
+            var jobs = _prototypeManager.EnumeratePrototypes<JobPrototype>().ToList();
+            jobs.Sort((x, y) => string.Compare(x.LocalizedName, y.LocalizedName, StringComparison.CurrentCulture));
+
+            foreach (var job in jobs)
+            {
+                if (!job.SetPreference)
+                {
+                    continue;
+                }
+
+                _jobPrototypeIds.Add(job.ID);
+                JobPresetOptionButton.AddItem(Loc.GetString(job.Name), _jobPrototypeIds.Count - 1);
+            }
+
+            JobPresetOptionButton.OnItemSelected += SelectJobPreset;
+
             foreach (var access in accessLevels)
             {
                 if (!prototypeManager.TryIndex<AccessLevelPrototype>(access, out var accessLevel))
                 {
-                    Logger.ErrorS(SharedIdCardConsoleSystem.Sawmill, $"Unable to find accesslevel for {access}");
+                    _logMill.Error($"Unable to find accesslevel for {access}");
                     continue;
                 }
 
                 var newButton = new Button
                 {
-                    Text = accessLevel.Name,
+                    Text = GetAccessLevelName(accessLevel),
                     ToggleMode = true,
                 };
                 AccessLevelGrid.AddChild(newButton);
@@ -62,6 +85,65 @@ namespace Content.Client.Access.UI
             }
         }
 
+        private static string GetAccessLevelName(AccessLevelPrototype prototype)
+        {
+            if (prototype.Name is { } name)
+                return Loc.GetString(name);
+
+            return prototype.ID;
+        }
+
+        private void ClearAllAccess()
+        {
+            foreach (var button in _accessButtons.Values)
+            {
+                if (button.Pressed)
+                {
+                    button.Pressed = false;
+                }
+            }
+        }
+
+        private void SelectJobPreset(OptionButton.ItemSelectedEventArgs args)
+        {
+            if (!_prototypeManager.TryIndex(_jobPrototypeIds[args.Id], out JobPrototype? job))
+            {
+                return;
+            }
+
+            JobTitleLineEdit.Text = Loc.GetString(job.Name);
+            args.Button.SelectId(args.Id);
+
+            ClearAllAccess();
+
+            // this is a sussy way to do this
+            foreach (var access in job.Access)
+            {
+                if (_accessButtons.TryGetValue(access, out var button) && !button.Disabled)
+                {
+                    button.Pressed = true;
+                }
+            }
+
+            foreach (var group in job.AccessGroups)
+            {
+                if (!_prototypeManager.TryIndex(group, out AccessGroupPrototype? groupPrototype))
+                {
+                    continue;
+                }
+
+                foreach (var access in groupPrototype.Tags)
+                {
+                    if (_accessButtons.TryGetValue(access, out var button) && !button.Disabled)
+                    {
+                        button.Pressed = true;
+                    }
+                }
+            }
+
+            SubmitData();
+        }
+
         public void UpdateState(IdCardConsoleBoundUserInterfaceState state)
         {
             PrivilegedIdButton.Text = state.IsPrivilegedIdPresent
@@ -100,26 +182,41 @@ namespace Content.Client.Access.UI
 
             JobTitleSaveButton.Disabled = !interfaceEnabled || !jobTitleDirty;
 
+            JobPresetOptionButton.Disabled = !interfaceEnabled;
+
             foreach (var (accessName, button) in _accessButtons)
             {
                 button.Disabled = !interfaceEnabled;
                 if (interfaceEnabled)
                 {
                     button.Pressed = state.TargetIdAccessList?.Contains(accessName) ?? false;
+                    button.Disabled = (!state.AllowedModifyAccessList?.Contains(accessName)) ?? true;
                 }
             }
 
+            var jobIndex = _jobPrototypeIds.IndexOf(state.TargetIdJobPrototype);
+            if (jobIndex >= 0)
+            {
+                JobPresetOptionButton.SelectId(jobIndex);
+            }
+
             _lastFullName = state.TargetIdFullName;
             _lastJobTitle = state.TargetIdJobTitle;
+            _lastJobProto = state.TargetIdJobPrototype;
         }
 
         private void SubmitData()
         {
+            // Don't send this if it isn't dirty.
+            var jobProtoDirty = _lastJobProto != null &&
+                                _jobPrototypeIds[JobPresetOptionButton.SelectedId] != _lastJobProto;
+
             _owner.SubmitData(
                 FullNameLineEdit.Text,
                 JobTitleLineEdit.Text,
                 // Iterate over the buttons dictionary, filter by `Pressed`, only get key from the key/value pair
-                _accessButtons.Where(x => x.Value.Pressed).Select(x => x.Key).ToList());
+                _accessButtons.Where(x => x.Value.Pressed).Select(x => x.Key).ToList(),
+                jobProtoDirty ? _jobPrototypeIds[JobPresetOptionButton.SelectedId] : string.Empty);
         }
     }
 }

Content.Client/Actions/ActionsSystem.cs

@@ -1,33 +1,18 @@
-using Content.Client.Actions.Assignments;
-using Content.Client.Actions.UI;
-using Content.Client.Construction;
-using Content.Client.DragDrop;
-using Content.Client.Hands;
-using Content.Client.Items.Managers;
-using Content.Client.Outline;
-using Content.Client.Popups;
+using System.IO;
+using System.Linq;
 using Content.Shared.Actions;
 using Content.Shared.Actions.ActionTypes;
-using Content.Shared.Input;
 using JetBrains.Annotations;
 using Robust.Client.GameObjects;
-using Robust.Client.Graphics;
 using Robust.Client.Player;
-using Robust.Client.UserInterface;
-using Robust.Client.Utility;
-using Robust.Shared.Audio;
 using Robust.Shared.ContentPack;
 using Robust.Shared.GameStates;
-using Robust.Shared.Input;
 using Robust.Shared.Input.Binding;
-using Robust.Shared.Player;
 using Robust.Shared.Serialization.Manager;
 using Robust.Shared.Serialization.Markdown;
 using Robust.Shared.Serialization.Markdown.Mapping;
 using Robust.Shared.Serialization.Markdown.Sequence;
 using Robust.Shared.Utility;
-using System.IO;
-using System.Linq;
 using YamlDotNet.RepresentationModel;
 
 namespace Content.Client.Actions
@@ -35,110 +20,48 @@ namespace Content.Client.Actions
     [UsedImplicitly]
     public sealed class ActionsSystem : SharedActionsSystem
     {
+        public delegate void OnActionReplaced(ActionType existing, ActionType action);
 
         [Dependency] private readonly IPlayerManager _playerManager = default!;
-        [Dependency] private readonly IUserInterfaceManager _uiManager = default!;
-        [Dependency] private readonly IItemSlotManager _itemSlotManager = default!;
-        [Dependency] private readonly ISerializationManager _serializationManager = default!;
-        [Dependency] private readonly IResourceManager _resourceManager = default!;
-        [Dependency] private readonly IOverlayManager _overlayMan = default!;
-        [Dependency] private readonly PopupSystem _popupSystem = default!;
-        [Dependency] private readonly InteractionOutlineSystem _interactionOutline = default!;
-        [Dependency] private readonly TargetOutlineSystem _targetOutline = default!;
+        [Dependency] private readonly IResourceManager _resources = default!;
+        [Dependency] private readonly ISerializationManager _serialization = default!;
 
-        // TODO Redo assignments, including allowing permanent user configurable slot assignments.
-        /// <summary>
-        /// Current assignments for all hotbars / slots for this entity.
-        /// </summary>
-        public ActionAssignments Assignments = new(Hotbars, Slots);
+        public event Action<ActionType>? ActionAdded;
+        public event Action<ActionType>? ActionRemoved;
+        public event OnActionReplaced? ActionReplaced;
+        public event Action? ActionsUpdated;
+        public event Action<ActionsComponent>? LinkActions;
+        public event Action? UnlinkActions;
+        public event Action? ClearAssignments;
+        public event Action<List<SlotAssignment>>? AssignSlot;
 
-        public const byte Hotbars = 9;
-        public const byte Slots = 10;
-
-        public bool UIDirty;
-
-        public ActionsUI? Ui;
-        private EntityUid? _highlightedEntity;
+        public ActionsComponent? PlayerActions { get; private set; }
 
         public override void Initialize()
         {
             base.Initialize();
-
-            // set up hotkeys for hotbar
-            CommandBinds.Builder
-                .Bind(ContentKeyFunctions.OpenActionsMenu,
-                    InputCmdHandler.FromDelegate(_ => ToggleActionsMenu()))
-                .Bind(ContentKeyFunctions.Hotbar1,
-                    HandleHotbarKeybind(0))
-                .Bind(ContentKeyFunctions.Hotbar2,
-                    HandleHotbarKeybind(1))
-                .Bind(ContentKeyFunctions.Hotbar3,
-                    HandleHotbarKeybind(2))
-                .Bind(ContentKeyFunctions.Hotbar4,
-                    HandleHotbarKeybind(3))
-                .Bind(ContentKeyFunctions.Hotbar5,
-                    HandleHotbarKeybind(4))
-                .Bind(ContentKeyFunctions.Hotbar6,
-                    HandleHotbarKeybind(5))
-                .Bind(ContentKeyFunctions.Hotbar7,
-                    HandleHotbarKeybind(6))
-                .Bind(ContentKeyFunctions.Hotbar8,
-                    HandleHotbarKeybind(7))
-                .Bind(ContentKeyFunctions.Hotbar9,
-                    HandleHotbarKeybind(8))
-                .Bind(ContentKeyFunctions.Hotbar0,
-                    HandleHotbarKeybind(9))
-                .Bind(ContentKeyFunctions.Loadout1,
-                    HandleChangeHotbarKeybind(0))
-                .Bind(ContentKeyFunctions.Loadout2,
-                    HandleChangeHotbarKeybind(1))
-                .Bind(ContentKeyFunctions.Loadout3,
-                    HandleChangeHotbarKeybind(2))
-                .Bind(ContentKeyFunctions.Loadout4,
-                    HandleChangeHotbarKeybind(3))
-                .Bind(ContentKeyFunctions.Loadout5,
-                    HandleChangeHotbarKeybind(4))
-                .Bind(ContentKeyFunctions.Loadout6,
-                    HandleChangeHotbarKeybind(5))
-                .Bind(ContentKeyFunctions.Loadout7,
-                    HandleChangeHotbarKeybind(6))
-                .Bind(ContentKeyFunctions.Loadout8,
-                    HandleChangeHotbarKeybind(7))
-                .Bind(ContentKeyFunctions.Loadout9,
-                    HandleChangeHotbarKeybind(8))
-                // when selecting a target, we intercept clicks in the game world, treating them as our target selection. We want to
-                // take priority before any other systems handle the click.
-                .BindBefore(EngineKeyFunctions.Use, new PointerInputCmdHandler(TargetingOnUse, outsidePrediction: true),
-                    typeof(ConstructionSystem), typeof(DragDropSystem))
-                .BindBefore(EngineKeyFunctions.UIRightClick, new PointerInputCmdHandler(TargetingCancel, outsidePrediction: true))
-                .Register<ActionsSystem>();
-
             SubscribeLocalEvent<ActionsComponent, PlayerAttachedEvent>(OnPlayerAttached);
             SubscribeLocalEvent<ActionsComponent, PlayerDetachedEvent>(OnPlayerDetached);
-            SubscribeLocalEvent<ActionsComponent, ComponentHandleState>(HandleState);
+            SubscribeLocalEvent<ActionsComponent, ComponentHandleState>(HandleComponentState);
         }
 
         public override void Dirty(ActionType action)
         {
-            // Should only ever receive component states for attached player's component.
-            // --> lets not bother unnecessarily dirtying and prediction-resetting actions for other players.
-            if (action.AttachedEntity != _playerManager.LocalPlayer?.ControlledEntity)
+            if (_playerManager.LocalPlayer?.ControlledEntity != action.AttachedEntity)
                 return;
 
             base.Dirty(action);
-            UIDirty = true;
+            ActionsUpdated?.Invoke();
         }
 
-        private void HandleState(EntityUid uid, ActionsComponent component, ref ComponentHandleState args)
+        private void HandleComponentState(EntityUid uid, ActionsComponent component, ref ComponentHandleState args)
         {
-            // Client only needs to care about local player.
-            if (uid != _playerManager.LocalPlayer?.ControlledEntity)
-                return;
-
             if (args.Current is not ActionsComponentState state)
                 return;
 
-            var serverActions = new SortedSet<ActionType>(state.Actions);
+            state.SortedActions ??= new SortedSet<ActionType>(state.Actions);
+            var serverActions = state.SortedActions;
+            var removed = new List<ActionType>();
 
             foreach (var act in component.Actions.ToList())
             {
@@ -148,47 +71,43 @@ namespace Content.Client.Actions
                 if (!serverActions.TryGetValue(act, out var serverAct))
                 {
                     component.Actions.Remove(act);
-                    if (act.AutoRemove && !(Ui?.Locked ?? false))
-                        Assignments.Remove(act);
+                    if (act.AutoRemove)
+                        removed.Add(act);
+
                     continue;
                 }
 
                 act.CopyFrom(serverAct);
-                serverActions.Remove(serverAct);
             }
 
+            var added = new List<ActionType>();
+
             // Anything that remains is a new action
             foreach (var newAct in serverActions)
             {
+                if (component.Actions.Contains(newAct))
+                    continue;
+
                 // We create a new action, not just sorting a reference to the state's action.
-                component.Actions.Add((ActionType) newAct.Clone());
+                var action = (ActionType) newAct.Clone();
+                component.Actions.Add(action);
+                added.Add(action);
             }
 
-            UIDirty = true;
-        }
-
-        /// <summary>
-        /// Highlights the item slot (inventory or hand) that contains this item
-        /// </summary>
-        /// <param name="item"></param>
-        public void HighlightItemSlot(EntityUid item)
-        {
-            StopHighlightingItemSlot();
-
-            _highlightedEntity = item;
-            _itemSlotManager.HighlightEntity(item);
-        }
-
-        /// <summary>
-        /// Stops highlighting any item slots we are currently highlighting.
-        /// </summary>H
-        public void StopHighlightingItemSlot()
-        {
-            if (_highlightedEntity == null)
+            if (_playerManager.LocalPlayer?.ControlledEntity != uid)
                 return;
 
-            _itemSlotManager.UnHighlightEntity(_highlightedEntity.Value);
-            _highlightedEntity = null;
+            foreach (var action in removed)
+            {
+                ActionRemoved?.Invoke(action);
+            }
+
+            foreach (var action in added)
+            {
+                ActionAdded?.Invoke(action);
+            }
+
+            ActionsUpdated?.Invoke();
         }
 
         protected override void AddActionInternal(ActionsComponent comp, ActionType action)
@@ -199,7 +118,7 @@ namespace Content.Client.Actions
             if (comp.Actions.TryGetValue(action, out var existing))
             {
                 comp.Actions.Remove(existing);
-                Assignments.Replace(existing, action);
+                ActionReplaced?.Invoke(existing, action);
             }
 
             comp.Actions.Add(action);
@@ -207,100 +126,57 @@ namespace Content.Client.Actions
 
         public override void AddAction(EntityUid uid, ActionType action, EntityUid? provider, ActionsComponent? comp = null, bool dirty = true)
         {
-            if (uid != _playerManager.LocalPlayer?.ControlledEntity)
-                return;
-
             if (!Resolve(uid, ref comp, false))
                 return;
 
+            dirty &= !action.ClientExclusive;
             base.AddAction(uid, action, provider, comp, dirty);
-            UIDirty = true;
+
+            if (uid == _playerManager.LocalPlayer?.ControlledEntity)
+                ActionAdded?.Invoke(action);
         }
 
-        public override void RemoveActions(EntityUid uid, IEnumerable<ActionType> actions, ActionsComponent? comp = null, bool dirty = true)
+        public override void RemoveAction(EntityUid uid, ActionType action, ActionsComponent? comp = null, bool dirty = true)
         {
-            if (uid != _playerManager.LocalPlayer?.ControlledEntity)
+            if (GameTiming.ApplyingState && !action.ClientExclusive)
                 return;
 
             if (!Resolve(uid, ref comp, false))
                 return;
 
-            base.RemoveActions(uid, actions, comp, dirty);
+            dirty &= !action.ClientExclusive;
+            base.RemoveAction(uid, action, comp, dirty);
 
-            foreach (var act in actions)
-            {
-                if (act.AutoRemove && !(Ui?.Locked ?? false))
-                    Assignments.Remove(act);
-            }
-
-            UIDirty = true;
-        }
-
-        public override void FrameUpdate(float frameTime)
-        {
-            // avoid updating GUI when doing predictions & resetting state.
-            if (UIDirty)
-            {
-                UIDirty = false;
-                UpdateUI();
-            }
-        }
-
-        /// <summary>
-        /// Updates the displayed hotbar (and menu) based on current state of actions.
-        /// </summary>
-        public void UpdateUI()
-        {
-            if (Ui == null)
-                return;
-
-            foreach (var action in Ui.Component.Actions)
-            {
-                if (action.AutoPopulate && !Assignments.Assignments.ContainsKey(action))
-                    Assignments.AutoPopulate(action, Ui.SelectedHotbar, false);
-            }
-
-            // get rid of actions that are no longer available to the user
-            foreach (var (action, index) in Assignments.Assignments.ToList())
-            {
-                if (index.Count == 0)
-                {
-                    Assignments.Assignments.Remove(action);
-                    continue;
-                }
-
-                if (action.AutoRemove && !Ui.Locked && !Ui.Component.Actions.Contains(action))
-                    Assignments.ClearSlot(index[0].Hotbar, index[0].Slot, false);
-            }
-
-            Assignments.PreventAutoPopulate.RemoveWhere(action => !Ui.Component.Actions.Contains(action));
-
-            Ui.UpdateUI();
-        }
-
-        public void HandleHotbarKeybind(byte slot, in PointerInputCmdHandler.PointerInputCmdArgs args)
-        {
-            Ui?.HandleHotbarKeybind(slot, args);
-        }
-
-        public void HandleChangeHotbarKeybind(byte hotbar, in PointerInputCmdHandler.PointerInputCmdArgs args)
-        {
-            Ui?.HandleChangeHotbarKeybind(hotbar, args);
-        }
-
-        private void OnPlayerDetached(EntityUid uid, ActionsComponent component, PlayerDetachedEvent args)
-        {
-            if (Ui == null) return;
-            _uiManager.StateRoot.RemoveChild(Ui);
-            Ui = null;
+            if (action.AutoRemove && uid == _playerManager.LocalPlayer?.ControlledEntity)
+                ActionRemoved?.Invoke(action);
         }
 
         private void OnPlayerAttached(EntityUid uid, ActionsComponent component, PlayerAttachedEvent args)
         {
-            Assignments = new(Hotbars, Slots);
-            Ui = new ActionsUI(this, component);
-            _uiManager.StateRoot.AddChild(Ui);
-            UIDirty = true;
+            LinkAllActions(component);
+        }
+
+        private void OnPlayerDetached(EntityUid uid, ActionsComponent component, PlayerDetachedEvent? args = null)
+        {
+            UnlinkAllActions();
+        }
+
+        public void UnlinkAllActions()
+        {
+            PlayerActions = null;
+            UnlinkActions?.Invoke();
+        }
+
+        public void LinkAllActions(ActionsComponent? actions = null)
+        {
+             var player = _playerManager.LocalPlayer?.ControlledEntity;
+             if (player == null || !Resolve(player.Value, ref actions, false))
+             {
+                 return;
+             }
+
+             LinkActions?.Invoke(actions);
+             PlayerActions = actions;
         }
 
         public override void Shutdown()
@@ -309,70 +185,25 @@ namespace Content.Client.Actions
             CommandBinds.Unregister<ActionsSystem>();
         }
 
-        private PointerInputCmdHandler HandleHotbarKeybind(byte slot)
+        public void TriggerAction(ActionType? action)
         {
-            // delegate to the ActionsUI, simulating a click on it
-            return new((in PointerInputCmdHandler.PointerInputCmdArgs args) =>
-                {
-                    var playerEntity = _playerManager.LocalPlayer?.ControlledEntity;
-                    if (playerEntity == null ||
-                        !EntityManager.TryGetComponent<ActionsComponent?>(playerEntity.Value, out var actionsComponent)) return false;
-
-                    HandleHotbarKeybind(slot, args);
-                    return true;
-                }, false);
-        }
-
-        private PointerInputCmdHandler HandleChangeHotbarKeybind(byte hotbar)
-        {
-            // delegate to the ActionsUI, simulating a click on it
-            return new((in PointerInputCmdHandler.PointerInputCmdArgs args) =>
-                {
-                    var playerEntity = _playerManager.LocalPlayer?.ControlledEntity;
-                    if (!EntityManager.TryGetComponent<ActionsComponent?>(playerEntity, out var actionsComponent)) return false;
-
-                    HandleChangeHotbarKeybind(hotbar, args);
-                    return true;
-                },
-                false);
-        }
-
-        private void ToggleActionsMenu()
-        {
-            Ui?.ToggleActionsMenu();
-        }
-
-        /// <summary>
-        ///     A action slot was pressed. This either performs the action or toggles the targeting mode.
-        /// </summary>
-        internal void OnSlotPressed(ActionSlot slot)
-        {
-            if (Ui == null)
+            if (PlayerActions == null || action == null || _playerManager.LocalPlayer?.ControlledEntity is not { Valid: true } user)
                 return;
 
-            if (slot.Action == null || _playerManager.LocalPlayer?.ControlledEntity is not EntityUid user)
+            if (action.Provider != null && Deleted(action.Provider))
                 return;
 
-            if (slot.Action.Provider != null && Deleted(slot.Action.Provider))
-                return;
-
-            if (slot.Action is not InstantAction instantAction)
+            if (action is not InstantAction instantAction)
             {
-                // for target actions, we go into "select target" mode, we don't
-                // message the server until we actually pick our target.
-
-                // if we're clicking the same thing we're already targeting for, then we simply cancel
-                // targeting
-                Ui.ToggleTargeting(slot);
                 return;
             }
 
-            if (slot.Action.ClientExclusive)
+            if (action.ClientExclusive)
             {
                 if (instantAction.Event != null)
                     instantAction.Event.Performer = user;
 
-                PerformAction(Ui.Component, instantAction, instantAction.Event, GameTiming.CurTime);
+                PerformAction(user, PlayerActions, instantAction, instantAction.Event, GameTiming.CurTime);
             }
             else
             {
@@ -381,226 +212,6 @@ namespace Content.Client.Actions
             }
         }
 
-        private bool TargetingCancel(in PointerInputCmdHandler.PointerInputCmdArgs args)
-        {
-            if (!GameTiming.IsFirstTimePredicted)
-                return false;
-
-            // only do something for actual target-based actions
-            if (Ui?.SelectingTargetFor?.Action == null)
-                return false;
-
-            Ui.StopTargeting();
-            return true;
-        }
-
-        /// <summary>
-        ///     If the user clicked somewhere, and they are currently targeting an action, try and perform it.
-        /// </summary>
-        private bool TargetingOnUse(in PointerInputCmdHandler.PointerInputCmdArgs args)
-        {
-            if (!GameTiming.IsFirstTimePredicted)
-                return false;
-
-            // only do something for actual target-based actions
-            if (Ui?.SelectingTargetFor?.Action is not TargetedAction action)
-                return false;
-
-            if (_playerManager.LocalPlayer?.ControlledEntity is not EntityUid user)
-                return false;
-
-            if (!TryComp(user, out ActionsComponent? comp))
-                return false;
-
-            // Is the action currently valid?
-            if (!action.Enabled
-                || action.Charges != null && action.Charges == 0
-                || action.Cooldown.HasValue && action.Cooldown.Value.End > GameTiming.CurTime)
-            {
-                // The user is targeting with this action, but it is not valid. Maybe mark this click as
-                // handled and prevent further interactions.
-                return !action.InteractOnMiss;
-            }
-
-            switch (action)
-            {
-                case WorldTargetAction mapTarget:
-                    return TryTargetWorld(args, mapTarget, user, comp) || !action.InteractOnMiss;
-
-                case EntityTargetAction entTarget:
-                    return TargetEntity(args, entTarget, user, comp) || !action.InteractOnMiss;
-
-                default:
-                    Logger.Error($"Unknown targeting action: {action.GetType()}");
-                    return false;
-            }
-        }
-
-        private bool TryTargetWorld(in PointerInputCmdHandler.PointerInputCmdArgs args, WorldTargetAction action, EntityUid user, ActionsComponent actionComp)
-        {
-            var coords = args.Coordinates.ToMap(EntityManager);
-
-            if (!ValidateWorldTarget(user, coords, action))
-            {
-                // Invalid target.
-                if (action.DeselectOnMiss)
-                    Ui?.StopTargeting();
-
-                return false;
-            }
-
-            if (action.ClientExclusive)
-            {
-                if (action.Event != null)
-                {
-                    action.Event.Target = coords;
-                    action.Event.Performer = user;
-                }
-
-                PerformAction(actionComp, action, action.Event, GameTiming.CurTime);
-            }
-            else
-                EntityManager.RaisePredictiveEvent(new RequestPerformActionEvent(action, coords));
-
-            if (!action.Repeat)
-                Ui?.StopTargeting();
-
-            return true;
-        }
-
-        private bool TargetEntity(in PointerInputCmdHandler.PointerInputCmdArgs args, EntityTargetAction action, EntityUid user, ActionsComponent actionComp)
-        {
-            if (!ValidateEntityTarget(user, args.EntityUid, action))
-            {
-                if (action.DeselectOnMiss)
-                    Ui?.StopTargeting();
-
-                return false;
-            }
-
-            if (action.ClientExclusive)
-            {
-                if (action.Event != null)
-                {
-                    action.Event.Target = args.EntityUid;
-                    action.Event.Performer = user;
-                }
-
-                PerformAction(actionComp, action, action.Event, GameTiming.CurTime);
-            }
-            else
-                EntityManager.RaisePredictiveEvent(new RequestPerformActionEvent(action, args.EntityUid));
-
-            if (!action.Repeat)
-                Ui?.StopTargeting();
-
-            return true;
-        }
-
-        /// <summary>
-        ///     Execute convenience functionality for actions (pop-ups, sound, speech)
-        /// </summary>
-        protected override bool PerformBasicActions(EntityUid user, ActionType action)
-        {
-            var performedAction = action.Sound != null
-                || !string.IsNullOrWhiteSpace(action.UserPopup)
-                || !string.IsNullOrWhiteSpace(action.Popup);
-
-            if (!GameTiming.IsFirstTimePredicted)
-                return performedAction;
-
-            if (!string.IsNullOrWhiteSpace(action.UserPopup))
-            {
-                var msg = (!action.Toggled || string.IsNullOrWhiteSpace(action.PopupToggleSuffix))
-                    ? Loc.GetString(action.UserPopup)
-                    : Loc.GetString(action.UserPopup + action.PopupToggleSuffix);
-
-                _popupSystem.PopupEntity(msg, user);
-            }
-            else if (!string.IsNullOrWhiteSpace(action.Popup))
-            {
-                var msg = (!action.Toggled || string.IsNullOrWhiteSpace(action.PopupToggleSuffix))
-                    ? Loc.GetString(action.Popup)
-                    : Loc.GetString(action.Popup + action.PopupToggleSuffix);
-
-                _popupSystem.PopupEntity(msg, user);
-            }
-
-            if (action.Sound != null)
-                 SoundSystem.Play(action.Sound.GetSound(), Filter.Local(), user, action.AudioParams);
-
-            return performedAction;
-        }
-
-        internal void StopTargeting()
-        {
-            _targetOutline.Disable();
-            _interactionOutline.SetEnabled(true);
-
-            if (!_overlayMan.TryGetOverlay<ShowHandItemOverlay>(out var handOverlay) || handOverlay == null)
-                return;
-
-            handOverlay.IconOverride = null;
-            handOverlay.EntityOverride = null;
-        }
-
-        internal void StartTargeting(TargetedAction action)
-        {
-            // override "held-item" overlay
-            if (action.TargetingIndicator
-                && _overlayMan.TryGetOverlay<ShowHandItemOverlay>(out var handOverlay)
-                && handOverlay != null)
-            {
-                if (action.ItemIconStyle == ItemActionIconStyle.BigItem && action.Provider != null)
-                {
-                    handOverlay.EntityOverride = action.Provider;
-                }
-                else if (action.Toggled && action.IconOn != null)
-                    handOverlay.IconOverride = action.IconOn.Frame0();
-                else if (action.Icon != null)
-                    handOverlay.IconOverride = action.Icon.Frame0();
-            }
-
-            // TODO: allow world-targets to check valid positions. E.g., maybe:
-            // - Draw a red/green ghost entity
-            // - Add a yes/no checkmark where the HandItemOverlay usually is
-
-            // Highlight valid entity targets
-            if (action is not EntityTargetAction entityAction)
-                return;
-
-            Func<EntityUid, bool>? predicate = null;
-
-            if (!entityAction.CanTargetSelf)
-                predicate = e => e != entityAction.AttachedEntity;
-
-            var range = entityAction.CheckCanAccess ? action.Range : -1;
-
-            _interactionOutline.SetEnabled(false);
-            _targetOutline.Enable(range, entityAction.CheckCanAccess, predicate, entityAction.Whitelist, null);
-        }
-
-        internal void TryFillSlot(byte hotbar, byte index)
-        {
-            if (Ui == null)
-                return;
-
-            var fillEvent = new FillActionSlotEvent();
-            RaiseLocalEvent(Ui.Component.Owner, fillEvent, broadcast: true);
-
-            if (fillEvent.Action == null)
-                return;
-
-            fillEvent.Action.ClientExclusive = true;
-            fillEvent.Action.Temporary = true;
-            fillEvent.Action.AutoPopulate = false;
-
-            Ui.Component.Actions.Add(fillEvent.Action);
-            Assignments.AssignSlot(hotbar, index, fillEvent.Action);
-
-            Ui.UpdateUI();
-        }
-
         /*public void SaveActionAssignments(string path)
         {
 
@@ -628,13 +239,13 @@ namespace Content.Client.Actions
         /// </summary>
         public void LoadActionAssignments(string path, bool userData)
         {
-            if (Ui == null)
+            if (PlayerActions == null)
                 return;
 
-            var file = new ResourcePath(path).ToRootedPath();
+            var file = new ResPath(path).ToRootedPath();
             TextReader reader = userData
-                ? _resourceManager.UserData.OpenText(file)
-                : _resourceManager.ContentFileReadText(file);
+                ? _resources.UserData.OpenText(file)
+                : _resources.ContentFileReadText(file);
 
             var yamlStream = new YamlStream();
             yamlStream.Load(reader);
@@ -642,13 +253,9 @@ namespace Content.Client.Actions
             if (yamlStream.Documents[0].RootNode.ToDataNode() is not SequenceDataNode sequence)
                 return;
 
-            foreach (var (action, assigns) in Assignments.Assignments)
-            {
-                foreach (var index in assigns)
-                {
-                    Assignments.ClearSlot(index.Hotbar, index.Slot, true);
-                }
-            }
+            ClearAssignments?.Invoke();
+
+            var assignments = new List<SlotAssignment>();
 
             foreach (var entry in sequence.Sequence)
             {
@@ -658,28 +265,33 @@ namespace Content.Client.Actions
                 if (!map.TryGet("action", out var actionNode))
                     continue;
 
-                var action = _serializationManager.Read<ActionType>(actionNode);
+                var action = _serialization.Read<ActionType>(actionNode, notNullableOverride: true);
 
-                if (Ui.Component.Actions.TryGetValue(action, out var existingAction))
+                if (PlayerActions.Actions.TryGetValue(action, out var existingAction))
                 {
                     existingAction.CopyFrom(action);
                     action = existingAction;
                 }
                 else
-                    Ui.Component.Actions.Add(action);
+                {
+                    PlayerActions.Actions.Add(action);
+                }
 
                 if (!map.TryGet("assignments", out var assignmentNode))
                     continue;
 
-                var assignments = _serializationManager.Read<List<(byte Hotbar, byte Slot)>>(assignmentNode);
+                var nodeAssignments = _serialization.Read<List<(byte Hotbar, byte Slot)>>(assignmentNode, notNullableOverride: true);
 
-                foreach (var index in assignments)
+                foreach (var index in nodeAssignments)
                 {
-                    Assignments.AssignSlot(index.Hotbar, index.Slot, action);
+                    var assignment = new SlotAssignment(index.Hotbar, index.Slot, action);
+                    assignments.Add(assignment);
                 }
             }
 
-            UIDirty = true;
+            AssignSlot?.Invoke(assignments);
         }
+
+        public record struct SlotAssignment(byte Hotbar, byte Slot, ActionType Action);
     }
 }

Content.Client/Actions/Assignments/ActionAssignments.cs

@@ -1,167 +0,0 @@
-using Content.Shared.Actions;
-using Content.Shared.Actions.ActionTypes;
-using System.Linq;
-
-namespace Content.Client.Actions.Assignments
-{
-    /// <summary>
-    /// Tracks and manages the hotbar assignments for actions.
-    /// </summary>
-    [DataDefinition]
-    public sealed class ActionAssignments
-    {
-        // the slots and assignments fields hold client's assignments (what action goes in what slot),
-        // which are completely client side and independent of what actions they've actually been granted and
-        // what item the action is actually for.
-
-        /// <summary>
-        /// x = hotbar number, y = slot of that hotbar (index 0 corresponds to the one labeled "1",
-        /// index 9 corresponds to the one labeled "0"). Essentially the inverse of _assignments.
-        /// </summary>
-        private readonly ActionType?[,] _slots;
-
-        /// <summary>
-        /// Hotbar and slot assignment for each action type (slot index 0 corresponds to the one labeled "1",
-        /// slot index 9 corresponds to the one labeled "0"). The key corresponds to an index in the _slots array.
-        /// The value is a list because actions can be assigned to multiple slots. Even if an action type has not been granted,
-        /// it can still be assigned to a slot. Essentially the inverse of _slots.
-        /// There will be no entry if there is no assignment (no empty lists in this dict)
-        /// </summary>
-        [DataField("assignments")]
-        public readonly Dictionary<ActionType, List<(byte Hotbar, byte Slot)>> Assignments = new();
-
-        /// <summary>
-        /// Actions which have been manually cleared by the user, thus should not
-        /// auto-populate.
-        /// </summary>
-        public readonly SortedSet<ActionType> PreventAutoPopulate = new();
-
-        private readonly byte _numHotbars;
-        private readonly byte _numSlots;
-
-        public ActionAssignments(byte numHotbars, byte numSlots)
-        {
-            _numHotbars = numHotbars;
-            _numSlots = numSlots;
-            _slots = new ActionType?[numHotbars, numSlots];
-        }
-
-        public bool Remove(ActionType action) => Replace(action, null);
-
-        internal bool Replace(ActionType action, ActionType? newAction)
-        {
-            if (!Assignments.Remove(action, out var assigns))
-                return false;
-
-            if (newAction != null)
-                Assignments[newAction] = assigns;
-
-            foreach (var (bar, slot) in assigns)
-            {
-                _slots[bar, slot] = newAction;
-            }
-
-            return true;
-        }
-
-        /// <summary>
-        /// Assigns the indicated hotbar slot to the specified action type.
-        /// </summary>
-        /// <param name="hotbar">hotbar whose slot is being assigned</param>
-        /// <param name="slot">slot of the hotbar to assign to (0 = the slot labeled 1, 9 = the slot labeled 0)</param>
-        /// <param name="actionType">action to assign to the slot</param>
-        public void AssignSlot(byte hotbar, byte slot, ActionType actionType)
-        {
-            ClearSlot(hotbar, slot, false);
-            _slots[hotbar, slot] = actionType;
-            if (Assignments.TryGetValue(actionType, out var slotList))
-            {
-                slotList.Add((hotbar, slot));
-            }
-            else
-            {
-                var newList = new List<(byte Hotbar, byte Slot)> { (hotbar, slot) };
-                Assignments[actionType] = newList;
-            }
-        }
-
-        /// <summary>
-        /// Clear the assignment from the indicated slot.
-        /// </summary>
-        /// <param name="hotbar">hotbar whose slot is being cleared</param>
-        /// <param name="slot">slot of the hotbar to clear (0 = the slot labeled 1, 9 = the slot labeled 0)</param>
-        /// <param name="preventAutoPopulate">if true, the action assigned to this slot
-        /// will be prevented from being auto-populated in the future when it is newly granted.
-        /// Item actions will automatically be allowed to auto populate again
-        /// when their associated item are unequipped. This ensures that items that are newly
-        /// picked up will always present their actions to the user even if they had earlier been cleared.
-        /// </param>
-        public void ClearSlot(byte hotbar, byte slot, bool preventAutoPopulate)
-        {
-            // remove this particular assignment from our data structures
-            // (keeping in mind something can be assigned multiple slots)
-            var currentAction = _slots[hotbar, slot];
-
-            if (currentAction == null)
-                return;
-
-            if (preventAutoPopulate)
-                PreventAutoPopulate.Add(currentAction);
-
-            var assignmentList = Assignments[currentAction];
-            assignmentList = assignmentList.Where(a => a.Hotbar != hotbar || a.Slot != slot).ToList();
-            if (!assignmentList.Any())
-            {
-                Assignments.Remove(currentAction);
-            }
-            else
-            {
-                Assignments[currentAction] = assignmentList;
-            }
-
-            _slots[hotbar, slot] = null;
-        }
-
-        /// <summary>
-        /// Finds the next open slot the action can go in and assigns it there,
-        /// starting from the currently selected hotbar.
-        /// Does not update any UI elements, only updates the assignment data structures.
-        /// </summary>
-        /// <param name="force">if true, will force the assignment to occur
-        /// regardless of whether this assignment has been prevented from auto population
-        /// via ClearSlot's preventAutoPopulate parameter. If false, will have no effect
-        /// if this assignment has been prevented from auto population.</param>
-        public void AutoPopulate(ActionType toAssign, byte currentHotbar, bool force = true)
-        {
-            if (!force && PreventAutoPopulate.Contains(toAssign))
-                return;
-
-            for (byte hotbarOffset = 0; hotbarOffset < _numHotbars; hotbarOffset++)
-            {
-                for (byte slot = 0; slot < _numSlots; slot++)
-                {
-                    var hotbar = (byte) ((currentHotbar + hotbarOffset) % _numHotbars);
-                    var slotAssignment = _slots[hotbar, slot];
-
-                    if (slotAssignment != null)
-                        continue;
-
-                    AssignSlot(hotbar, slot, toAssign);
-                    return;
-                }
-            }
-            // there was no empty slot
-        }
-
-        /// <summary>
-        /// Gets the assignment to the indicated slot if there is one.
-        /// </summary>
-        public ActionType? this[in byte hotbar, in byte slot] => _slots[hotbar, slot];
-
-        /// <returns>true if we have the assignment assigned to some slot</returns>
-        public bool HasAssignment(ActionType assignment)
-        {
-            return Assignments.ContainsKey(assignment);
-        }
-    }
-}

Content.Client/Actions/UI/ActionMenu.cs

@@ -1,426 +0,0 @@
-using System.Globalization;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-using Content.Client.DragDrop;
-using Content.Client.HUD;
-using Content.Client.Stylesheets;
-using Content.Shared.Actions;
-using Content.Shared.Actions.ActionTypes;
-using Robust.Client.UserInterface.Controls;
-using Robust.Client.UserInterface.CustomControls;
-using Robust.Client.Utility;
-using Robust.Shared.Input;
-using Robust.Shared.Timing;
-using static Robust.Client.UserInterface.Controls.BaseButton;
-using static Robust.Client.UserInterface.Controls.BoxContainer;
-
-namespace Content.Client.Actions.UI
-{
-    /// <summary>
-    /// Action selection menu, allows filtering and searching over all possible
-    /// actions and populating those actions into the hotbar.
-    /// </summary>
-    public sealed class ActionMenu : DefaultWindow
-    {
-        // Pre-defined global filters that can be used to select actions based on their properties (as opposed to their
-        // own yaml-defined filters).
-        // TODO LOC STRINGs
-        private const string AllFilter = "all";
-        private const string ItemFilter = "item";
-        private const string InnateFilter = "innate";
-        private const string EnabledFilter = "enabled";
-        private const string InstantFilter = "instant";
-        private const string TargetedFilter = "targeted";
-
-        private readonly string[] _filters =
-        {
-            AllFilter,
-            ItemFilter,
-            InnateFilter,
-            EnabledFilter,
-            InstantFilter,
-            TargetedFilter
-        };
-
-        private const int MinSearchLength = 3;
-        private static readonly Regex NonAlphanumeric = new Regex(@"\W", RegexOptions.Compiled);
-        private static readonly Regex Whitespace = new Regex(@"\s+", RegexOptions.Compiled);
-
-        /// <summary>
-        /// Is an action currently being dragged from this window?
-        /// </summary>
-        public bool IsDragging => _dragDropHelper.IsDragging;
-
-        private readonly ActionsUI _actionsUI;
-        private readonly LineEdit _searchBar;
-        private readonly MultiselectOptionButton<string> _filterButton;
-        private readonly Label _filterLabel;
-        private readonly Button _clearButton;
-        private readonly GridContainer _resultsGrid;
-        private readonly TextureRect _dragShadow;
-        private readonly IGameHud _gameHud;
-        private readonly DragDropHelper<ActionMenuItem> _dragDropHelper;
-        private readonly IEntityManager _entMan;
-
-        public ActionMenu(ActionsUI actionsUI)
-        {
-            _actionsUI = actionsUI;
-            _gameHud = IoCManager.Resolve<IGameHud>();
-            _entMan = IoCManager.Resolve<IEntityManager>();
-
-            Title = Loc.GetString("ui-actionmenu-title");
-            MinSize = (320, 300);
-
-            Contents.AddChild(new BoxContainer
-            {
-	            Orientation = LayoutOrientation.Vertical,
-                Children =
-                {
-                    new BoxContainer
-                    {
-                        Orientation = LayoutOrientation.Horizontal,
-                        Children =
-                        {
-                            (_searchBar = new LineEdit
-                            {
-                                StyleClasses = { StyleNano.StyleClassActionSearchBox },
-                                HorizontalExpand = true,
-                                PlaceHolder = Loc.GetString("ui-actionmenu-search-bar-placeholder-text")
-                            }),
-                            (_filterButton = new MultiselectOptionButton<string>()
-                            {
-                                Label = Loc.GetString("ui-actionmenu-filter-button")
-                            })
-                        }
-                    },
-                    (_clearButton = new Button
-                    {
-                        Text = Loc.GetString("ui-actionmenu-clear-button"),
-                    }),
-                    (_filterLabel = new Label()),
-                    new ScrollContainer
-                    {
-                        //TODO: needed? MinSize = new Vector2(200.0f, 0.0f),
-                        VerticalExpand = true,
-                        HorizontalExpand = true,
-                        Children =
-                        {
-                            (_resultsGrid = new GridContainer
-                            {
-                                MaxGridWidth = 300
-                            })
-                        }
-                    }
-                }
-            });
-
-            foreach (var tag in _filters)
-            {
-                _filterButton.AddItem( CultureInfo.CurrentCulture.TextInfo.ToTitleCase(tag), tag);
-            }
-
-            // default to showing all actions.
-            _filterButton.SelectKey(AllFilter);
-
-            UpdateFilterLabel();
-
-            _dragShadow = new TextureRect
-            {
-                MinSize = (64, 64),
-                Stretch = TextureRect.StretchMode.Scale,
-                Visible = false,
-                SetSize = (64, 64)
-            };
-            UserInterfaceManager.PopupRoot.AddChild(_dragShadow);
-
-            _dragDropHelper = new DragDropHelper<ActionMenuItem>(OnBeginActionDrag, OnContinueActionDrag, OnEndActionDrag);
-        }
-
-        protected override void EnteredTree()
-        {
-            base.EnteredTree();
-            _clearButton.OnPressed += OnClearButtonPressed;
-            _searchBar.OnTextChanged += OnSearchTextChanged;
-            _filterButton.OnItemSelected += OnFilterItemSelected;
-            _gameHud.ActionsButtonDown = true;
-        }
-
-        protected override void ExitedTree()
-        {
-            base.ExitedTree();
-            _dragDropHelper.EndDrag();
-            _clearButton.OnPressed -= OnClearButtonPressed;
-            _searchBar.OnTextChanged -= OnSearchTextChanged;
-            _filterButton.OnItemSelected -= OnFilterItemSelected;
-            _gameHud.ActionsButtonDown = false;
-            foreach (var actionMenuControl in _resultsGrid.Children)
-            {
-                var actionMenuItem = (ActionMenuItem) actionMenuControl;
-                actionMenuItem.OnButtonDown -= OnItemButtonDown;
-                actionMenuItem.OnButtonUp -= OnItemButtonUp;
-                actionMenuItem.OnPressed -= OnItemPressed;
-            }
-        }
-
-        private void OnFilterItemSelected(MultiselectOptionButton<string>.ItemPressedEventArgs args)
-        {
-            UpdateFilterLabel();
-            SearchAndDisplay();
-        }
-
-        protected override void Resized()
-        {
-            base.Resized();
-            // TODO: Can rework this once https://github.com/space-wizards/RobustToolbox/issues/1392 is done,
-            // currently no good way to let the grid know what size it has to "work with", so must manually resize
-            _resultsGrid.MaxGridWidth = Width;
-        }
-
-        private bool OnBeginActionDrag()
-        {
-            _dragShadow.Texture = _dragDropHelper.Dragged?.Action?.Icon?.Frame0();
-            // don't make visible until frameupdate, otherwise it'll flicker
-            LayoutContainer.SetPosition(_dragShadow, UserInterfaceManager.MousePositionScaled.Position - (32, 32));
-            return true;
-        }
-
-        private bool OnContinueActionDrag(float frameTime)
-        {
-            // keep dragged entity centered under mouse
-            LayoutContainer.SetPosition(_dragShadow, UserInterfaceManager.MousePositionScaled.Position - (32, 32));
-            // we don't set this visible until frameupdate, otherwise it flickers
-            _dragShadow.Visible = true;
-            return true;
-        }
-
-        private void OnEndActionDrag()
-        {
-            _dragShadow.Visible = false;
-        }
-
-        private void OnItemButtonDown(ButtonEventArgs args)
-        {
-            if (args.Event.Function != EngineKeyFunctions.UIClick ||
-                args.Button is not ActionMenuItem action)
-            {
-                return;
-            }
-
-            _dragDropHelper.MouseDown(action);
-        }
-
-        private void OnItemButtonUp(ButtonEventArgs args)
-        {
-            // note the buttonup only fires on the control that was originally
-            // pressed to initiate the drag, NOT the one we are currently hovering
-            if (args.Event.Function != EngineKeyFunctions.UIClick) return;
-
-            if (UserInterfaceManager.CurrentlyHovered is ActionSlot targetSlot)
-            {
-                if (!_dragDropHelper.IsDragging || _dragDropHelper.Dragged?.Action == null)
-                {
-                    _dragDropHelper.EndDrag();
-                    return;
-                }
-
-                _actionsUI.System.Assignments.AssignSlot(_actionsUI.SelectedHotbar, targetSlot.SlotIndex, _dragDropHelper.Dragged.Action);
-                _actionsUI.UpdateUI();
-            }
-
-            _dragDropHelper.EndDrag();
-        }
-
-        private void OnItemFocusExited(ActionMenuItem item)
-        {
-            // lost focus, cancel the drag if one is in progress
-            _dragDropHelper.EndDrag();
-        }
-
-        private void OnItemPressed(ButtonEventArgs args)
-        {
-            if (args.Button is not ActionMenuItem actionMenuItem) return;
-
-            _actionsUI.System.Assignments.AutoPopulate(actionMenuItem.Action, _actionsUI.SelectedHotbar);
-            _actionsUI.UpdateUI();
-        }
-
-        private void OnClearButtonPressed(ButtonEventArgs args)
-        {
-            _searchBar.Clear();
-            _filterButton.DeselectAll();
-            UpdateFilterLabel();
-            SearchAndDisplay();
-        }
-
-        private void OnSearchTextChanged(LineEdit.LineEditEventArgs obj)
-        {
-            SearchAndDisplay();
-        }
-
-        private void SearchAndDisplay()
-        {
-            var search = Standardize(_searchBar.Text);
-            // only display nothing if there are no filters selected and text is not long enough.
-            // otherwise we will search if even one filter is applied, regardless of length of search string
-            if (_filterButton.SelectedKeys.Count == 0 &&
-                (string.IsNullOrWhiteSpace(search) || search.Length < MinSearchLength))
-            {
-                ClearList();
-                return;
-            }
-
-            var matchingActions = _actionsUI.Component.Actions
-                .Where(a => MatchesSearchCriteria(a, search, _filterButton.SelectedKeys));
-
-            PopulateActions(matchingActions);
-        }
-
-        private void UpdateFilterLabel()
-        {
-            if (_filterButton.SelectedKeys.Count == 0)
-            {
-                _filterLabel.Visible = false;
-            }
-            else
-            {
-                _filterLabel.Visible = true;
-                _filterLabel.Text = Loc.GetString("ui-actionmenu-filter-label",
-                                                  ("selectedLabels", string.Join(", ", _filterButton.SelectedLabels)));
-            }
-        }
-
-        private bool MatchesSearchCriteria(ActionType action, string standardizedSearch,
-            IReadOnlyList<string> selectedFilterTags)
-        {
-            // check filter tag match first - each action must contain all filter tags currently selected.
-            // if no tags selected, don't check tags
-            if (selectedFilterTags.Count > 0 && selectedFilterTags.Any(filterTag => !ActionMatchesFilterTag(action, filterTag)))
-            {
-                return false;
-            }
-
-            // check search tag match against the search query
-            if (action.Keywords.Any(standardizedSearch.Contains))
-            {
-                return true;
-            }
-
-            if (Standardize(action.Name.ToString()).Contains(standardizedSearch))
-            {
-                return true;
-            }
-
-            // search by provider name
-            if (action.Provider == null || action.Provider == _actionsUI.Component.Owner)
-                return false;
-
-            var name = _entMan.GetComponent<MetaDataComponent>(action.Provider.Value).EntityName;
-            return Standardize(name).Contains(standardizedSearch);
-        }
-
-        private bool ActionMatchesFilterTag(ActionType action, string tag)
-        {
-            return tag switch
-            {
-                EnabledFilter => action.Enabled,
-                ItemFilter => action.Provider != null && action.Provider != _actionsUI.Component.Owner,
-                InnateFilter => action.Provider == null || action.Provider == _actionsUI.Component.Owner,
-                InstantFilter => action is InstantAction,
-                TargetedFilter => action is TargetedAction,
-                _ => true
-            };
-        }
-
-        /// <summary>
-        /// Standardized form is all lowercase, no non-alphanumeric characters (converted to whitespace),
-        /// trimmed, 1 space max per whitespace gap,
-        /// and optional spaces between case change
-        /// </summary>
-        private static string Standardize(string rawText, bool splitOnCaseChange = false)
-        {
-            rawText ??= string.Empty;
-
-            // treat non-alphanumeric characters as whitespace
-            rawText = NonAlphanumeric.Replace(rawText, " ");
-
-            // trim spaces and reduce internal whitespaces to 1 max
-            rawText = Whitespace.Replace(rawText, " ").Trim();
-            if (splitOnCaseChange)
-            {
-                // insert a space when case switches from lower to upper
-                rawText = AddSpaces(rawText, true);
-            }
-
-            return rawText.ToLowerInvariant().Trim();
-        }
-
-        // taken from https://stackoverflow.com/a/272929 (CC BY-SA 3.0)
-        private static string AddSpaces(string text, bool preserveAcronyms)
-        {
-            if (string.IsNullOrWhiteSpace(text))
-                return string.Empty;
-            var newText = new StringBuilder(text.Length * 2);
-            newText.Append(text[0]);
-            for (var i = 1; i < text.Length; i++)
-            {
-                if (char.IsUpper(text[i]))
-                {
-                    if ((text[i - 1] != ' ' && !char.IsUpper(text[i - 1])) ||
-                        (preserveAcronyms && char.IsUpper(text[i - 1]) &&
-                         i < text.Length - 1 && !char.IsUpper(text[i + 1])))
-                        newText.Append(' ');
-                }
-
-                newText.Append(text[i]);
-            }
-            return newText.ToString();
-        }
-
-        private void PopulateActions(IEnumerable<ActionType> actions)
-        {
-            ClearList();
-
-            foreach (var action in actions)
-            {
-                var actionItem = new ActionMenuItem(_actionsUI, action, OnItemFocusExited);
-                _resultsGrid.Children.Add(actionItem);
-                actionItem.SetActionState(action.Enabled);
-                actionItem.OnButtonDown += OnItemButtonDown;
-                actionItem.OnButtonUp += OnItemButtonUp;
-                actionItem.OnPressed += OnItemPressed;
-            }
-        }
-
-        private void ClearList()
-        {
-            // TODO: Not sure if this unsub is needed if children are all being cleared
-            foreach (var actionItem in _resultsGrid.Children)
-            {
-                ((ActionMenuItem) actionItem).OnPressed -= OnItemPressed;
-            }
-            _resultsGrid.Children.Clear();
-        }
-
-        /// <summary>
-        /// Should be invoked when action states change, ensures
-        /// currently displayed actions are properly showing their revoked / granted status
-        /// </summary>
-        public void UpdateUI()
-        {
-            foreach (var actionItem in _resultsGrid.Children)
-            {
-                var actionMenuItem = ((ActionMenuItem) actionItem);
-                actionMenuItem.SetActionState(actionMenuItem.Action.Enabled);
-            }
-
-            SearchAndDisplay();
-        }
-
-        protected override void FrameUpdate(FrameEventArgs args)
-        {
-            base.FrameUpdate(args);
-            _dragDropHelper.Update(args.DeltaSeconds);
-        }
-    }
-}

Content.Client/Actions/UI/ActionMenuItem.cs

@@ -1,228 +0,0 @@
-using System;
-using Content.Client.Stylesheets;
-using Content.Shared.Actions;
-using Content.Shared.Actions.ActionTypes;
-using Robust.Client.GameObjects;
-using Robust.Client.Graphics;
-using Robust.Client.UserInterface;
-using Robust.Client.UserInterface.Controls;
-using Robust.Client.Utility;
-using Robust.Shared.Utility;
-using static Robust.Client.UserInterface.Controls.BoxContainer;
-
-namespace Content.Client.Actions.UI
-{
-    // TODO merge this with action-slot when it gets XAMLd
-    // this has way too much overlap, especially now that they both have the item-sprite icons.
-
-    /// <summary>
-    /// An individual action visible in the action menu.
-    /// </summary>
-    public sealed class ActionMenuItem : ContainerButton
-    {
-        // shorter than default tooltip delay so user can
-        // quickly explore what each action is
-        private const float CustomTooltipDelay = 0.2f;
-
-        private readonly TextureRect _bigActionIcon;
-        private readonly TextureRect _smallActionIcon;
-        private readonly SpriteView _smallItemSpriteView;
-        private readonly SpriteView _bigItemSpriteView;
-
-        public ActionType Action;
-
-        private Action<ActionMenuItem> _onControlFocusExited;
-
-        private readonly ActionsUI _actionsUI;
-
-        public ActionMenuItem(ActionsUI actionsUI, ActionType action, Action<ActionMenuItem> onControlFocusExited)
-        {
-            _actionsUI = actionsUI;
-            Action = action;
-            _onControlFocusExited = onControlFocusExited;
-
-            SetSize = (64, 64);
-            VerticalAlignment = VAlignment.Top;
-
-            _bigActionIcon = new TextureRect
-            {
-                HorizontalExpand = true,
-                VerticalExpand = true,
-                Stretch = TextureRect.StretchMode.Scale,
-                Visible = false
-            };
-            _bigItemSpriteView = new SpriteView
-            {
-                HorizontalExpand = true,
-                VerticalExpand = true,
-                Scale = (2, 2),
-                Visible = false,
-                OverrideDirection = Direction.South,
-            };
-            _smallActionIcon = new TextureRect
-            {
-                HorizontalAlignment = HAlignment.Right,
-                VerticalAlignment = VAlignment.Bottom,
-                Stretch = TextureRect.StretchMode.Scale,
-                Visible = false
-            };
-            _smallItemSpriteView = new SpriteView
-            {
-                HorizontalAlignment = HAlignment.Right,
-                VerticalAlignment = VAlignment.Bottom,
-                Visible = false,
-                OverrideDirection = Direction.South,
-            };
-
-            // padding to the left of the small icon
-            var paddingBoxItemIcon = new BoxContainer
-            {
-                Orientation = LayoutOrientation.Horizontal,
-                HorizontalExpand = true,
-                VerticalExpand = true,
-                MinSize = (64, 64)
-            };
-            paddingBoxItemIcon.AddChild(new Control()
-            {
-                MinSize = (32, 32),
-            });
-            paddingBoxItemIcon.AddChild(new Control
-            {
-                Children =
-                {
-                    _smallActionIcon,
-                    _smallItemSpriteView
-                }
-            });
-            AddChild(_bigActionIcon);
-            AddChild(_bigItemSpriteView);
-            AddChild(paddingBoxItemIcon);
-
-            TooltipDelay = CustomTooltipDelay;
-            TooltipSupplier = SupplyTooltip;
-            UpdateIcons();
-        }
-
-
-        public void UpdateIcons()
-        {
-            UpdateItemIcon();
-
-            if (Action == null)
-            {
-                SetActionIcon(null);
-                return;
-            }
-
-            if ((_actionsUI.SelectingTargetFor?.Action == Action || Action.Toggled) && Action.IconOn != null)
-                SetActionIcon(Action.IconOn.Frame0());
-            else
-                SetActionIcon(Action.Icon?.Frame0());
-        }
-
-        private void SetActionIcon(Texture? texture)
-        {
-            if (texture == null || Action == null)
-            {
-                _bigActionIcon.Texture = null;
-                _bigActionIcon.Visible = false;
-                _smallActionIcon.Texture = null;
-                _smallActionIcon.Visible = false;
-            }
-            else if (Action.EntityIcon != null && Action.ItemIconStyle == ItemActionIconStyle.BigItem)
-            {
-                _smallActionIcon.Texture = texture;
-                _smallActionIcon.Modulate = Action.IconColor;
-                _smallActionIcon.Visible = true;
-                _bigActionIcon.Texture = null;
-                _bigActionIcon.Visible = false;
-            }
-            else
-            {
-                _bigActionIcon.Texture = texture;
-                _bigActionIcon.Modulate = Action.IconColor;
-                _bigActionIcon.Visible = true;
-                _smallActionIcon.Texture = null;
-                _smallActionIcon.Visible = false;
-            }
-        }
-
-        private void UpdateItemIcon()
-        {
-            if (Action?.EntityIcon == null || !IoCManager.Resolve<IEntityManager>().TryGetComponent(Action.EntityIcon.Value, out SpriteComponent? sprite))
-            {
-                _bigItemSpriteView.Visible = false;
-                _bigItemSpriteView.Sprite = null;
-                _smallItemSpriteView.Visible = false;
-                _smallItemSpriteView.Sprite = null;
-            }
-            else
-            {
-                switch (Action.ItemIconStyle)
-                {
-                    case ItemActionIconStyle.BigItem:
-                        _bigItemSpriteView.Visible = true;
-                        _bigItemSpriteView.Sprite = sprite;
-                        _smallItemSpriteView.Visible = false;
-                        _smallItemSpriteView.Sprite = null;
-                        break;
-                    case ItemActionIconStyle.BigAction:
-
-                        _bigItemSpriteView.Visible = false;
-                        _bigItemSpriteView.Sprite = null;
-                        _smallItemSpriteView.Visible = true;
-                        _smallItemSpriteView.Sprite = sprite;
-                        break;
-
-                    case ItemActionIconStyle.NoItem:
-
-                        _bigItemSpriteView.Visible = false;
-                        _bigItemSpriteView.Sprite = null;
-                        _smallItemSpriteView.Visible = false;
-                        _smallItemSpriteView.Sprite = null;
-                        break;
-                }
-            }
-        }
-
-        protected override void ControlFocusExited()
-        {
-            base.ControlFocusExited();
-            _onControlFocusExited.Invoke(this);
-        }
-
-        private Control SupplyTooltip(Control? sender)
-        {
-            var name = FormattedMessage.FromMarkupPermissive(Loc.GetString(Action.Name));
-            var decr = FormattedMessage.FromMarkupPermissive(Loc.GetString(Action.Description));
-
-            var tooltip = new ActionAlertTooltip(name, decr);
-
-            if (Action.Enabled && (Action.Charges == null || Action.Charges != 0))
-                tooltip.Cooldown = Action.Cooldown;
-
-            return tooltip;
-        }
-
-        /// <summary>
-        /// Change how this is displayed depending on if it is granted or revoked
-        /// </summary>
-        public void SetActionState(bool granted)
-        {
-            if (granted)
-            {
-                if (HasStyleClass(StyleNano.StyleClassActionMenuItemRevoked))
-                {
-                    RemoveStyleClass(StyleNano.StyleClassActionMenuItemRevoked);
-                }
-            }
-            else
-            {
-                if (!HasStyleClass(StyleNano.StyleClassActionMenuItemRevoked))
-                {
-                    AddStyleClass(StyleNano.StyleClassActionMenuItemRevoked);
-                }
-            }
-        }
-    }
-}

Content.Client/Actions/UI/ActionSlot.cs

@@ -1,551 +0,0 @@
-using System;
-using Content.Client.Cooldown;
-using Content.Client.Stylesheets;
-using Content.Shared.Actions;
-using Content.Shared.Actions.ActionTypes;
-using Robust.Client.GameObjects;
-using Robust.Client.Graphics;
-using Robust.Client.UserInterface;
-using Robust.Client.UserInterface.Controls;
-using Robust.Client.Utility;
-using Robust.Shared.Input;
-using Robust.Shared.Timing;
-using Robust.Shared.Utility;
-using static Robust.Client.UserInterface.Controls.BoxContainer;
-
-namespace Content.Client.Actions.UI
-{
-    /// <summary>
-    /// A slot in the action hotbar. Not extending BaseButton because
-    /// its needs diverged too much.
-    /// </summary>
-    public sealed class ActionSlot : PanelContainer
-    {
-        // shorter than default tooltip delay so user can more easily
-        // see what actions they've been given
-        private const float CustomTooltipDelay = 0.5f;
-
-        private static readonly string EnabledColor = "#7b7e9e";
-        private static readonly string DisabledColor = "#950000";
-
-        private bool _spriteViewDirty = false;
-
-        /// <summary>
-        /// Current action in this slot.
-        /// </summary>
-        public ActionType? Action { get; private set; }
-
-        /// <summary>
-        /// 1-10 corresponding to the number label on the slot (10 is labeled as 0)
-        /// </summary>
-        private byte SlotNumber => (byte) (SlotIndex + 1);
-        public byte SlotIndex { get; }
-
-        private readonly IGameTiming _gameTiming;
-        private readonly IEntityManager _entMan;
-        private readonly RichTextLabel _number;
-        private readonly TextureRect _bigActionIcon;
-        private readonly TextureRect _smallActionIcon;
-        private readonly SpriteView _smallItemSpriteView;
-        private readonly SpriteView _bigItemSpriteView;
-        private readonly CooldownGraphic _cooldownGraphic;
-        private readonly ActionsUI _actionsUI;
-        private readonly ActionMenu _actionMenu;
-        // whether button is currently pressed down by mouse or keybind down.
-        private bool _depressed;
-        private bool _beingHovered;
-
-        /// <summary>
-        /// Creates an action slot for the specified number
-        /// </summary>
-        /// <param name="slotIndex">slot index this corresponds to, 0-9 (0 labeled as 1, 8, labeled "9", 9 labeled as "0".</param>
-        public ActionSlot(ActionsUI actionsUI, ActionMenu actionMenu, byte slotIndex, IGameTiming timing, IEntityManager entMan)
-        {
-            _actionsUI = actionsUI;
-            _actionMenu = actionMenu;
-            _gameTiming = timing;
-            _entMan = entMan;
-            SlotIndex = slotIndex;
-            MouseFilter = MouseFilterMode.Stop;
-
-            SetSize = (64, 64);
-            VerticalAlignment = VAlignment.Top;
-            TooltipDelay = CustomTooltipDelay;
-            TooltipSupplier = SupplyTooltip;
-
-            _number = new RichTextLabel
-            {
-                StyleClasses = {StyleNano.StyleClassHotbarSlotNumber}
-            };
-            _number.SetMessage(SlotNumberLabel());
-
-            _bigActionIcon = new TextureRect
-            {
-                HorizontalExpand = true,
-                VerticalExpand = true,
-                Stretch = TextureRect.StretchMode.Scale,
-                Visible = false
-            };
-            _bigItemSpriteView = new SpriteView
-            {
-                HorizontalExpand = true,
-                VerticalExpand = true,
-                Scale = (2,2),
-                Visible = false,
-                OverrideDirection = Direction.South,
-            };
-            _smallActionIcon = new TextureRect
-            {
-                HorizontalAlignment = HAlignment.Right,
-                VerticalAlignment = VAlignment.Bottom,
-                Stretch = TextureRect.StretchMode.Scale,
-                Visible = false
-            };
-            _smallItemSpriteView = new SpriteView
-            {
-                HorizontalAlignment = HAlignment.Right,
-                VerticalAlignment = VAlignment.Bottom,
-                Visible = false,
-                OverrideDirection = Direction.South,
-            };
-
-            _cooldownGraphic = new CooldownGraphic {Progress = 0, Visible = false};
-
-            // padding to the left of the number to shift it right
-            var paddingBox = new BoxContainer
-            {
-                Orientation = LayoutOrientation.Horizontal,
-                HorizontalExpand = true,
-                VerticalExpand = true,
-                MinSize = (64, 64)
-            };
-            paddingBox.AddChild(new Control()
-            {
-                MinSize = (4, 4),
-            });
-            paddingBox.AddChild(_number);
-
-            // padding to the left of the small icon
-            var paddingBoxItemIcon = new BoxContainer
-            {
-                Orientation = LayoutOrientation.Horizontal,
-                HorizontalExpand = true,
-                VerticalExpand = true,
-                MinSize = (64, 64)
-            };
-            paddingBoxItemIcon.AddChild(new Control()
-            {
-                MinSize = (32, 32),
-            });
-            paddingBoxItemIcon.AddChild(new Control
-            {
-                Children =
-                {
-                    _smallActionIcon,
-                    _smallItemSpriteView
-                }
-            });
-            AddChild(_bigActionIcon);
-            AddChild(_bigItemSpriteView);
-            AddChild(_cooldownGraphic);
-            AddChild(paddingBox);
-            AddChild(paddingBoxItemIcon);
-            DrawModeChanged();
-        }
-
-        private Control? SupplyTooltip(Control sender)
-        {
-            if (Action == null)
-                return null;
-
-            string? extra = null;
-            if (Action.Charges != null)
-            {
-                extra = Loc.GetString("ui-actionslot-charges", ("charges", Action.Charges));
-            }
-
-            var name = FormattedMessage.FromMarkupPermissive(Loc.GetString(Action.Name));
-            var decr = FormattedMessage.FromMarkupPermissive(Loc.GetString(Action.Description));
-
-            var tooltip = new ActionAlertTooltip(name, decr, extra);
-
-            if (Action.Enabled && (Action.Charges == null || Action.Charges != 0))
-                tooltip.Cooldown = Action.Cooldown;
-
-            return tooltip;
-        }
-
-        protected override void MouseEntered()
-        {
-            base.MouseEntered();
-
-            _beingHovered = true;
-            DrawModeChanged();
-
-            if (Action?.Provider != null)
-                _actionsUI.System.HighlightItemSlot(Action.Provider.Value);
-        }
-
-        protected override void MouseExited()
-        {
-            base.MouseExited();
-            _beingHovered = false;
-            CancelPress();
-            DrawModeChanged();
-            _actionsUI.System.StopHighlightingItemSlot();
-        }
-
-        protected override void KeyBindDown(GUIBoundKeyEventArgs args)
-        {
-            base.KeyBindDown(args);
-
-            if (Action == null)
-            {
-                // No action for this slot. Maybe the user is trying to add a mapping action?
-                _actionsUI.System.TryFillSlot(_actionsUI.SelectedHotbar, SlotIndex);
-                return;
-            }
-
-            // only handle clicks, and can't do anything to this if no assignment
-            if (args.Function == EngineKeyFunctions.UIClick)
-            {
-                // might turn into a drag or a full press if released
-                Depress(true);
-                _actionsUI.DragDropHelper.MouseDown(this);
-                DrawModeChanged();
-                return;
-            }
-
-            if (args.Function != EngineKeyFunctions.UIRightClick || _actionsUI.Locked)
-                return;
-
-            if (_actionsUI.DragDropHelper.IsDragging || _actionMenu.IsDragging)
-                return;
-
-            // user right clicked on an action slot, so we clear it.
-            _actionsUI.System.Assignments.ClearSlot(_actionsUI.SelectedHotbar, SlotIndex, true);
-
-            // If this was a temporary action, and it is no longer assigned to any slots, then we remove the action
-            // altogether.
-            if (Action.Temporary)
-            {
-                // Theres probably a better way to do this.....
-                DebugTools.Assert(Action.ClientExclusive, "Temporary-actions must be client exclusive");
-
-                if (!_actionsUI.System.Assignments.Assignments.TryGetValue(Action, out var index)
-                    || index.Count == 0)
-                {
-                    _actionsUI.Component.Actions.Remove(Action);
-                }
-            }
-
-            _actionsUI.StopTargeting();
-            _actionsUI.UpdateUI();
-        }
-
-        protected override void KeyBindUp(GUIBoundKeyEventArgs args)
-        {
-            base.KeyBindUp(args);
-
-            if (args.Function != EngineKeyFunctions.UIClick)
-                return;
-
-            // might be finishing a drag or using the action
-            if (_actionsUI.DragDropHelper.IsDragging &&
-                _actionsUI.DragDropHelper.Dragged == this &&
-                UserInterfaceManager.CurrentlyHovered is ActionSlot targetSlot &&
-                targetSlot != this)
-            {
-                // finish the drag, swap the 2 slots
-                var fromIdx = SlotIndex;
-                var fromAssignment = _actionsUI.System.Assignments[_actionsUI.SelectedHotbar, fromIdx];
-                var toIdx = targetSlot.SlotIndex;
-                var toAssignment = _actionsUI.System.Assignments[_actionsUI.SelectedHotbar, toIdx];
-
-                if (fromIdx == toIdx) return;
-                if (fromAssignment == null) return;
-
-                _actionsUI.System.Assignments.AssignSlot(_actionsUI.SelectedHotbar, toIdx, fromAssignment);
-                if (toAssignment != null)
-                {
-                    _actionsUI.System.Assignments.AssignSlot(_actionsUI.SelectedHotbar, fromIdx, toAssignment);
-                }
-                else
-                {
-                    _actionsUI.System.Assignments.ClearSlot(_actionsUI.SelectedHotbar, fromIdx, false);
-                }
-                _actionsUI.UpdateUI();
-            }
-            else
-            {
-                // perform the action
-                if (UserInterfaceManager.CurrentlyHovered == this)
-                {
-                    Depress(false);
-                }
-            }
-            _actionsUI.DragDropHelper.EndDrag();
-            DrawModeChanged();
-        }
-
-        protected override void ControlFocusExited()
-        {
-            // lost focus for some reason, cancel the drag if there is one.
-            base.ControlFocusExited();
-            _actionsUI.DragDropHelper.EndDrag();
-            DrawModeChanged();
-        }
-
-        /// <summary>
-        /// Cancel current press without triggering the action
-        /// </summary>
-        public void CancelPress()
-        {
-            _depressed = false;
-            DrawModeChanged();
-        }
-
-        /// <summary>
-        /// Press this button down. If it was depressed and now set to not depressed, will
-        /// trigger the action.
-        /// </summary>
-        public void Depress(bool depress)
-        {
-            // action can still be toggled if it's allowed to stay selected
-            if (Action == null || !Action.Enabled) return;
-
-            if (_depressed && !depress)
-            {
-                // fire the action
-                _actionsUI.System.OnSlotPressed(this);
-            }
-            _depressed = depress;
-        }
-
-        /// <summary>
-        /// Updates the item action assigned to this slot, tied to a specific item.
-        /// </summary>
-        /// <param name="action">action to assign</param>
-        /// <param name="item">item the action is provided by</param>
-        public void Assign(ActionType action)
-        {
-            // already assigned
-            if (Action != null && Action == action) return;
-
-            Action = action;
-            HideTooltip();
-            UpdateIcons();
-            DrawModeChanged();
-            _number.SetMessage(SlotNumberLabel());
-        }
-
-        /// <summary>
-        /// Clears the action assigned to this slot
-        /// </summary>
-        public void Clear()
-        {
-            if (Action == null) return;
-            Action = null;
-            _depressed = false;
-            HideTooltip();
-            UpdateIcons();
-            DrawModeChanged();
-            _number.SetMessage(SlotNumberLabel());
-        }
-
-        /// <summary>
-        /// Display the action in this slot (if there is one) as enabled
-        /// </summary>
-        public void Enable()
-        {
-            DrawModeChanged();
-            _number.SetMessage(SlotNumberLabel());
-        }
-
-        /// <summary>
-        /// Display the action in this slot (if there is one) as disabled.
-        /// The slot is still clickable.
-        /// </summary>
-        public void Disable()
-        {
-            _depressed = false;
-            DrawModeChanged();
-            _number.SetMessage(SlotNumberLabel());
-        }
-
-        private FormattedMessage SlotNumberLabel()
-        {
-            if (SlotNumber > 10) return FormattedMessage.FromMarkup("");
-            var number = Loc.GetString(SlotNumber == 10 ? "0" : SlotNumber.ToString());
-            var color = (Action == null || Action.Enabled) ? EnabledColor : DisabledColor;
-            return FormattedMessage.FromMarkup("[color=" + color + "]" + number + "[/color]");
-        }
-
-        public void UpdateIcons()
-        {
-            UpdateItemIcon();
-
-            if (Action == null)
-            {
-                SetActionIcon(null);
-                return;
-            }
-
-            if ((_actionsUI.SelectingTargetFor?.Action == Action || Action.Toggled) && Action.IconOn != null)
-                SetActionIcon(Action.IconOn.Frame0());
-            else
-                SetActionIcon(Action.Icon?.Frame0());
-        }
-
-        private void SetActionIcon(Texture? texture)
-        {
-            if (texture == null || Action == null)
-            {
-                _bigActionIcon.Texture = null;
-                _bigActionIcon.Visible = false;
-                _smallActionIcon.Texture = null;
-                _smallActionIcon.Visible = false;
-            }
-            else if (Action.EntityIcon != null && Action.ItemIconStyle == ItemActionIconStyle.BigItem)
-            {
-                _smallActionIcon.Texture = texture;
-                _smallActionIcon.Modulate = Action.IconColor;
-                _smallActionIcon.Visible = true;
-                _bigActionIcon.Texture = null;
-                _bigActionIcon.Visible = false;
-            }
-            else
-            {
-                _bigActionIcon.Texture = texture;
-                _bigActionIcon.Modulate = Action.IconColor;
-                _bigActionIcon.Visible = true;
-                _smallActionIcon.Texture = null;
-                _smallActionIcon.Visible = false;
-            }
-        }
-
-        private void UpdateItemIcon()
-        {
-            if (Action?.EntityIcon != null && !_entMan.EntityExists(Action.EntityIcon))
-            {
-                // This is almost certainly because a player received/processed their own actions component state before
-                // being send the entity in their inventory that enabled this action.
-
-                // Defer updating icons to the next FrameUpdate().
-                _spriteViewDirty = true;
-                return;
-            }
-
-            if (Action?.EntityIcon == null || !_entMan.TryGetComponent(Action.EntityIcon.Value, out SpriteComponent? sprite))
-            {
-                _bigItemSpriteView.Visible = false;
-                _bigItemSpriteView.Sprite = null;
-                _smallItemSpriteView.Visible = false;
-                _smallItemSpriteView.Sprite = null;
-            }
-            else
-            {
-                switch (Action.ItemIconStyle)
-                {
-                    case ItemActionIconStyle.BigItem:
-                        _bigItemSpriteView.Visible = true;
-                        _bigItemSpriteView.Sprite = sprite;
-                        _smallItemSpriteView.Visible = false;
-                        _smallItemSpriteView.Sprite = null;
-                        break;
-                    case ItemActionIconStyle.BigAction:
-
-                        _bigItemSpriteView.Visible = false;
-                        _bigItemSpriteView.Sprite = null;
-                        _smallItemSpriteView.Visible = true;
-                        _smallItemSpriteView.Sprite = sprite;
-                        break;
-
-                    case ItemActionIconStyle.NoItem:
-
-                        _bigItemSpriteView.Visible = false;
-                        _bigItemSpriteView.Sprite = null;
-                        _smallItemSpriteView.Visible = false;
-                        _smallItemSpriteView.Sprite = null;
-                        break;
-                }
-            }
-        }
-
-        public void DrawModeChanged()
-        {
-            // always show the normal empty button style if no action in this slot
-            if (Action == null)
-            {
-                SetOnlyStylePseudoClass(ContainerButton.StylePseudoClassNormal);
-                return;
-            }
-
-            // show a hover only if the action is usable or another action is being dragged on top of this
-            if (_beingHovered && (_actionsUI.DragDropHelper.IsDragging || _actionMenu.IsDragging || Action.Enabled))
-            {
-                SetOnlyStylePseudoClass(ContainerButton.StylePseudoClassHover);
-            }
-
-            // it's only depress-able if it's usable, so if we're depressed
-            // show the depressed style
-            if (_depressed)
-            {
-                SetOnlyStylePseudoClass(ContainerButton.StylePseudoClassPressed);
-                return;
-            }
-
-            // if it's toggled on, always show the toggled on style (currently same as depressed style)
-            if (Action.Toggled || _actionsUI.SelectingTargetFor == this)
-            {
-                // when there's a toggle sprite, we're showing that sprite instead of highlighting this slot
-                SetOnlyStylePseudoClass(Action.IconOn != null ? ContainerButton.StylePseudoClassNormal :
-                    ContainerButton.StylePseudoClassPressed);
-                return;
-            }
-
-            if (!Action.Enabled)
-            {
-                SetOnlyStylePseudoClass(ContainerButton.StylePseudoClassDisabled);
-                return;
-            }
-
-            SetOnlyStylePseudoClass(ContainerButton.StylePseudoClassNormal);
-        }
-
-        protected override void FrameUpdate(FrameEventArgs args)
-        {
-            base.FrameUpdate(args);
-
-            if (_spriteViewDirty)
-            {
-                _spriteViewDirty = false;
-                UpdateIcons();
-            }
-
-            if (Action == null || Action.Cooldown == null || !Action.Enabled)
-            {
-                _cooldownGraphic.Visible = false;
-                _cooldownGraphic.Progress = 0;
-                return;
-            }
-
-            var cooldown = Action.Cooldown.Value;
-            var duration = cooldown.End - cooldown.Start;
-            var curTime = _gameTiming.CurTime;
-            var length = duration.TotalSeconds;
-            var progress = (curTime - cooldown.Start).TotalSeconds / length;
-            var ratio = (progress <= 1 ? (1 - progress) : (curTime - cooldown.End).TotalSeconds * -5);
-
-            _cooldownGraphic.Progress = MathHelper.Clamp((float)ratio, -1, 1);
-            if (ratio > -1f)
-                _cooldownGraphic.Visible = true;
-            else
-            {
-                _cooldownGraphic.Visible = false;
-                Action.Cooldown = null;
-                DrawModeChanged();
-            }
-        }
-    }
-}

Content.Client/Actions/UI/ActionsUI.cs

@@ -1,505 +0,0 @@
-using Content.Client.DragDrop;
-using Content.Client.HUD;
-using Content.Client.Resources;
-using Content.Client.Stylesheets;
-using Content.Shared.Actions;
-using Content.Shared.Actions.ActionTypes;
-using Robust.Client.Graphics;
-using Robust.Client.ResourceManagement;
-using Robust.Client.UserInterface;
-using Robust.Client.UserInterface.Controls;
-using Robust.Client.Utility;
-using Robust.Shared.Input;
-using Robust.Shared.Input.Binding;
-using Robust.Shared.Timing;
-using Robust.Shared.Utility;
-using static Robust.Client.UserInterface.Controls.BoxContainer;
-
-namespace Content.Client.Actions.UI
-{
-    /// <summary>
-    ///     The action hotbar on the left side of the screen.
-    /// </summary>
-    public sealed class ActionsUI : Container
-    {
-        private const float DragDeadZone = 10f;
-        private const float CustomTooltipDelay = 0.4f;
-        internal readonly ActionsSystem System;
-        private readonly IGameHud _gameHud;
-        private readonly IEntityManager _entMan;
-        private readonly IGameTiming _timing;
-
-        /// <summary>
-        ///     The action component of the currently attached entity.
-        /// </summary>
-        public readonly ActionsComponent Component;
-
-        private readonly ActionSlot[] _slots;
-
-        private readonly GridContainer _slotContainer;
-
-        private readonly TextureButton _lockButton;
-        private readonly TextureButton _settingsButton;
-        private readonly Label _loadoutNumber;
-        private readonly Texture _lockTexture;
-        private readonly Texture _unlockTexture;
-        private readonly BoxContainer _loadoutContainer;
-
-        private readonly TextureRect _dragShadow;
-
-        private readonly ActionMenu _menu;
-
-        /// <summary>
-        /// Index of currently selected hotbar
-        /// </summary>
-        public byte SelectedHotbar { get; private set; }
-
-        /// <summary>
-        /// Action slot we are currently selecting a target for.
-        /// </summary>
-        public ActionSlot? SelectingTargetFor { get; private set; }
-
-        /// <summary>
-        /// Drag drop helper for coordinating drag drops between action slots
-        /// </summary>
-        public DragDropHelper<ActionSlot> DragDropHelper { get; }
-
-        /// <summary>
-        /// Whether the bar is currently locked by the user. This is intended to prevent drag / drop
-        /// and right click clearing slots. Anything else is still doable.
-        /// </summary>
-        public bool Locked { get; private set; }
-
-        /// <summary>
-        /// All the action slots in order.
-        /// </summary>
-        public IEnumerable<ActionSlot> Slots => _slots;
-
-        public ActionsUI(ActionsSystem system, ActionsComponent component)
-        {
-            SetValue(LayoutContainer.DebugProperty, true);
-            System = system;
-            Component = component;
-            _gameHud = IoCManager.Resolve<IGameHud>();
-            _timing = IoCManager.Resolve<IGameTiming>();
-            _entMan = IoCManager.Resolve<IEntityManager>();
-            _menu = new ActionMenu(this);
-
-            LayoutContainer.SetGrowHorizontal(this, LayoutContainer.GrowDirection.End);
-            LayoutContainer.SetGrowVertical(this, LayoutContainer.GrowDirection.Constrain);
-            LayoutContainer.SetAnchorTop(this, 0f);
-            LayoutContainer.SetAnchorBottom(this, 0.8f);
-            LayoutContainer.SetMarginLeft(this, 13);
-            LayoutContainer.SetMarginTop(this, 110);
-
-            HorizontalAlignment = HAlignment.Left;
-            VerticalExpand = true;
-
-            var resourceCache = IoCManager.Resolve<IResourceCache>();
-
-            // everything needs to go within an inner panel container so the panel resizes to fit the elements.
-            // Because ActionsUI is being anchored by layoutcontainer, the hotbar backing would appear too tall
-            // if ActionsUI was the panel container
-
-            var panelContainer = new PanelContainer()
-            {
-                StyleClasses = {StyleNano.StyleClassHotbarPanel},
-                HorizontalAlignment = HAlignment.Left,
-                VerticalAlignment = VAlignment.Top
-            };
-            AddChild(panelContainer);
-
-            var hotbarContainer = new BoxContainer
-            {
-	            Orientation = LayoutOrientation.Vertical,
-                SeparationOverride = 3,
-                HorizontalAlignment = HAlignment.Left
-            };
-            panelContainer.AddChild(hotbarContainer);
-
-            var settingsContainer = new BoxContainer
-            {
-                Orientation = LayoutOrientation.Horizontal,
-                HorizontalExpand = true
-            };
-            hotbarContainer.AddChild(settingsContainer);
-
-            settingsContainer.AddChild(new Control { HorizontalExpand = true, SizeFlagsStretchRatio = 1 });
-            _lockTexture = resourceCache.GetTexture("/Textures/Interface/Nano/lock.svg.192dpi.png");
-            _unlockTexture = resourceCache.GetTexture("/Textures/Interface/Nano/lock_open.svg.192dpi.png");
-            _lockButton = new TextureButton
-            {
-                TextureNormal = _unlockTexture,
-                HorizontalAlignment = HAlignment.Center,
-                VerticalAlignment = VAlignment.Center,
-                SizeFlagsStretchRatio = 1,
-                Scale = (0.5f, 0.5f),
-                ToolTip = Loc.GetString("ui-actionsui-function-lock-action-slots"),
-                TooltipDelay = CustomTooltipDelay
-            };
-            settingsContainer.AddChild(_lockButton);
-            settingsContainer.AddChild(new Control { HorizontalExpand = true, SizeFlagsStretchRatio = 2 });
-            _settingsButton = new TextureButton
-            {
-                TextureNormal = resourceCache.GetTexture("/Textures/Interface/Nano/gear.svg.192dpi.png"),
-                HorizontalAlignment = HAlignment.Center,
-                VerticalAlignment = VAlignment.Center,
-                SizeFlagsStretchRatio = 1,
-                Scale = (0.5f, 0.5f),
-                ToolTip = Loc.GetString("ui-actionsui-function-open-abilities-menu"),
-                TooltipDelay = CustomTooltipDelay
-            };
-            settingsContainer.AddChild(_settingsButton);
-            settingsContainer.AddChild(new Control { HorizontalExpand = true, SizeFlagsStretchRatio = 1 });
-
-            // this allows a 2 column layout if window gets too small
-            _slotContainer = new GridContainer
-            {
-                MaxGridHeight = CalcMaxHeight()
-            };
-            hotbarContainer.AddChild(_slotContainer);
-
-            _loadoutContainer = new BoxContainer
-            {
-                Orientation = LayoutOrientation.Horizontal,
-                HorizontalExpand = true,
-                MouseFilter = MouseFilterMode.Stop
-            };
-            hotbarContainer.AddChild(_loadoutContainer);
-
-            _loadoutContainer.AddChild(new Control { HorizontalExpand = true, SizeFlagsStretchRatio = 1 });
-            var previousHotbarIcon = new TextureRect()
-            {
-                Texture = resourceCache.GetTexture("/Textures/Interface/Nano/left_arrow.svg.192dpi.png"),
-                HorizontalAlignment = HAlignment.Center,
-                VerticalAlignment = VAlignment.Center,
-                SizeFlagsStretchRatio = 1,
-                TextureScale = (0.5f, 0.5f)
-            };
-            _loadoutContainer.AddChild(previousHotbarIcon);
-            _loadoutContainer.AddChild(new Control { HorizontalExpand = true, SizeFlagsStretchRatio = 2 });
-            _loadoutNumber = new Label
-            {
-                Text = "1",
-                SizeFlagsStretchRatio = 1
-            };
-            _loadoutContainer.AddChild(_loadoutNumber);
-            _loadoutContainer.AddChild(new Control { HorizontalExpand = true, SizeFlagsStretchRatio = 2 });
-            var nextHotbarIcon = new TextureRect
-            {
-                Texture = resourceCache.GetTexture("/Textures/Interface/Nano/right_arrow.svg.192dpi.png"),
-                HorizontalAlignment = HAlignment.Center,
-                VerticalAlignment = VAlignment.Center,
-                SizeFlagsStretchRatio = 1,
-                TextureScale = (0.5f, 0.5f)
-            };
-            _loadoutContainer.AddChild(nextHotbarIcon);
-            _loadoutContainer.AddChild(new Control { HorizontalExpand = true, SizeFlagsStretchRatio = 1 });
-
-            _slots = new ActionSlot[ActionsSystem.Slots];
-
-            _dragShadow = new TextureRect
-            {
-                MinSize = (64, 64),
-                Stretch = TextureRect.StretchMode.Scale,
-                Visible = false,
-                SetSize = (64, 64)
-            };
-            UserInterfaceManager.PopupRoot.AddChild(_dragShadow);
-
-            for (byte i = 0; i < ActionsSystem.Slots; i++)
-            {
-                var slot = new ActionSlot(this, _menu, i, _timing, _entMan);
-                _slotContainer.AddChild(slot);
-                _slots[i] = slot;
-            }
-
-            DragDropHelper = new DragDropHelper<ActionSlot>(OnBeginActionDrag, OnContinueActionDrag, OnEndActionDrag);
-            DragDropHelper.Deadzone = DragDeadZone;
-
-            MinSize = (10, 400);
-        }
-
-        protected override void EnteredTree()
-        {
-            base.EnteredTree();
-            _lockButton.OnPressed += OnLockPressed;
-            _settingsButton.OnPressed += OnToggleActionsMenu;
-            _loadoutContainer.OnKeyBindDown += OnHotbarPaginate;
-            _gameHud.ActionsButtonToggled += OnToggleActionsMenuTopButton;
-            _gameHud.ActionsButtonDown = false;
-            _gameHud.ActionsButtonVisible = true;
-        }
-
-        protected override void ExitedTree()
-        {
-            base.ExitedTree();
-            StopTargeting();
-            _menu.Close();
-            _lockButton.OnPressed -= OnLockPressed;
-            _settingsButton.OnPressed -= OnToggleActionsMenu;
-            _loadoutContainer.OnKeyBindDown -= OnHotbarPaginate;
-            _gameHud.ActionsButtonToggled -= OnToggleActionsMenuTopButton;
-            _gameHud.ActionsButtonDown = false;
-            _gameHud.ActionsButtonVisible = false;
-        }
-
-        protected override void Resized()
-        {
-            base.Resized();
-            _slotContainer.MaxGridHeight = CalcMaxHeight();
-        }
-
-        private float CalcMaxHeight()
-        {
-            // TODO: Can rework this once https://github.com/space-wizards/RobustToolbox/issues/1392 is done,
-            // this is here because there isn't currently a good way to allow the grid to adjust its height based
-            // on constraints, otherwise we would use anchors to lay it out
-
-            // it looks bad to have an uneven number of slots in the columns,
-            // so we either do a single column or 2 equal sized columns
-            if (Height < 650)
-            {
-                // 2 column
-                return 400;
-            }
-            else
-            {
-                // 1 column
-                return 900;
-            }
-        }
-
-        protected override void UIScaleChanged()
-        {
-            _slotContainer.MaxGridHeight = CalcMaxHeight();
-            base.UIScaleChanged();
-        }
-
-        /// <summary>
-        /// Refresh the display of all the slots in the currently displayed hotbar,
-        /// to reflect the current component state and assignments of actions component.
-        /// </summary>
-        public void UpdateUI()
-        {
-            _menu.UpdateUI();
-
-            foreach (var actionSlot in Slots)
-            {
-                var action = System.Assignments[SelectedHotbar, actionSlot.SlotIndex];
-
-                if (action == null)
-                {
-                    if (SelectingTargetFor == actionSlot)
-                        StopTargeting(true);
-                    actionSlot.Clear();
-                    continue;
-                }
-
-                if (Component.Actions.TryGetValue(action, out var actualAction))
-                {
-                    UpdateActionSlot(actualAction, actionSlot);
-                    continue;
-                }
-
-                // Action not in the actions component, but in the assignment list.
-                // This is either an action that doesn't auto-clear from the menu, or the action menu was locked.
-                // Show the old action, but make sure it is disabled;
-                action.Enabled = false;
-                action.Toggled = false;
-
-                // If we enable the item-sprite, and if the item-sprite has a visual toggle, then the player will be
-                // able to know whether the item is toggled, even if it is not in their LOS (but in PVS). And for things
-                // like PDA sprites, the player can even see whether the action's item is currently inside of their PVS.
-                // SO unless theres some way of "freezing" a sprite-view, we just have to disable it.
-                action.ItemIconStyle = ItemActionIconStyle.NoItem;
-
-                UpdateActionSlot(action, actionSlot);
-            }
-        }
-
-        private void UpdateActionSlot(ActionType action, ActionSlot actionSlot)
-        {
-            actionSlot.Assign(action);
-
-            if (!action.Enabled)
-            {
-                // just revoked an action we were trying to target with, stop targeting
-                if (SelectingTargetFor?.Action != null && SelectingTargetFor.Action == action)
-                {
-                    StopTargeting();
-                }
-
-                actionSlot.Disable();
-            }
-            else
-            {
-                actionSlot.Enable();
-            }
-
-            actionSlot.UpdateIcons();
-            actionSlot.DrawModeChanged();
-        }
-
-        private void OnHotbarPaginate(GUIBoundKeyEventArgs args)
-        {
-            // rather than clicking the arrows themselves, the user can click the hbox so it's more
-            // "forgiving" for misclicks, and we simply check which side they are closer to
-            if (args.Function != EngineKeyFunctions.UIClick) return;
-
-            var rightness = args.RelativePosition.X / _loadoutContainer.Width;
-            if (rightness > 0.5)
-            {
-                ChangeHotbar((byte) ((SelectedHotbar + 1) % ActionsSystem.Hotbars));
-            }
-            else
-            {
-                var newBar = SelectedHotbar == 0 ? ActionsSystem.Hotbars - 1 : SelectedHotbar - 1;
-                ChangeHotbar((byte) newBar);
-            }
-        }
-
-        private void ChangeHotbar(byte hotbar)
-        {
-            StopTargeting();
-            SelectedHotbar = hotbar;
-            _loadoutNumber.Text = (hotbar + 1).ToString();
-            UpdateUI();
-        }
-
-        /// <summary>
-        /// If currently targeting with this slot, stops targeting.
-        /// If currently targeting with no slot or a different slot, switches to
-        /// targeting with the specified slot.
-        /// </summary>
-        /// <param name="slot"></param>
-        public void ToggleTargeting(ActionSlot slot)
-        {
-            if (SelectingTargetFor == slot)
-            {
-                StopTargeting();
-                return;
-            }
-            StartTargeting(slot);
-        }
-
-        /// <summary>
-        /// Puts us in targeting mode, where we need to pick either a target point or entity
-        /// </summary>
-        private void StartTargeting(ActionSlot actionSlot)
-        {
-            if (actionSlot.Action == null)
-                return;
-
-            // If we were targeting something else we should stop
-            StopTargeting();
-
-            SelectingTargetFor = actionSlot;
-
-            if (actionSlot.Action is TargetedAction targetAction)
-                System.StartTargeting(targetAction);
-
-            UpdateUI();
-        }
-
-        /// <summary>
-        /// Switch out of targeting mode if currently selecting target for an action
-        /// </summary>
-        public void StopTargeting(bool updating = false)
-        {
-            if (SelectingTargetFor == null)
-                return;
-
-            SelectingTargetFor = null;
-            System.StopTargeting();
-
-            // Sometimes targeting gets stopped mid-UI update.
-            // in that case, don't need to do a nested UI refresh.
-            if (!updating)
-                UpdateUI();
-        }
-
-        private void OnToggleActionsMenu(BaseButton.ButtonEventArgs args)
-        {
-            ToggleActionsMenu();
-        }
-
-        private void OnToggleActionsMenuTopButton(bool open)
-        {
-            if (open == _menu.IsOpen) return;
-            ToggleActionsMenu();
-        }
-
-        public void ToggleActionsMenu()
-        {
-            if (_menu.IsOpen)
-            {
-                _menu.Close();
-            }
-            else
-            {
-                _menu.OpenCentered();
-            }
-        }
-
-        private void OnLockPressed(BaseButton.ButtonEventArgs obj)
-        {
-            Locked = !Locked;
-            _lockButton.TextureNormal = Locked ? _lockTexture : _unlockTexture;
-        }
-
-        private bool OnBeginActionDrag()
-        {
-            // only initiate the drag if the slot has an action in it
-            if (Locked || DragDropHelper.Dragged?.Action == null) return false;
-
-            _dragShadow.Texture = DragDropHelper.Dragged.Action.Icon?.Frame0();
-            LayoutContainer.SetPosition(_dragShadow, UserInterfaceManager.MousePositionScaled.Position - (32, 32));
-            DragDropHelper.Dragged.CancelPress();
-            return true;
-        }
-
-        private bool OnContinueActionDrag(float frameTime)
-        {
-            // stop if there's no action in the slot
-            if (Locked || DragDropHelper.Dragged?.Action == null) return false;
-
-            // keep dragged entity centered under mouse
-            LayoutContainer.SetPosition(_dragShadow, UserInterfaceManager.MousePositionScaled.Position - (32, 32));
-            // we don't set this visible until frameupdate, otherwise it flickers
-            _dragShadow.Visible = true;
-            return true;
-        }
-
-        private void OnEndActionDrag()
-        {
-            _dragShadow.Visible = false;
-        }
-
-        /// <summary>
-        /// Handle keydown / keyup for one of the slots via a keybinding, simulates mousedown/mouseup on it.
-        /// </summary>
-        /// <param name="slot">slot index to to receive the press (0 corresponds to the one labeled 1, 9 corresponds to the one labeled 0)</param>
-        public void HandleHotbarKeybind(byte slot, PointerInputCmdHandler.PointerInputCmdArgs args)
-        {
-            var actionSlot = _slots[slot];
-            actionSlot.Depress(args.State == BoundKeyState.Down);
-            actionSlot.DrawModeChanged();
-        }
-
-        /// <summary>
-        /// Handle hotbar change.
-        /// </summary>
-        /// <param name="hotbar">hotbar index to switch to</param>
-        public void HandleChangeHotbarKeybind(byte hotbar, PointerInputCmdHandler.PointerInputCmdArgs args)
-        {
-            ChangeHotbar(hotbar);
-        }
-
-        protected override void FrameUpdate(FrameEventArgs args)
-        {
-            base.FrameUpdate(args);
-            DragDropHelper.Update(args.DeltaSeconds);
-        }
-    }
-}

Content.Client/Administration/AdminNameOverlay.cs

@@ -1,3 +1,5 @@
+using System.Numerics;
+using Content.Client.Administration.Systems;
 using Robust.Client.Graphics;
 using Robust.Client.ResourceManagement;
 using Robust.Shared.Enums;
@@ -34,11 +36,11 @@ namespace Content.Client.Administration
             foreach (var playerInfo in _system.PlayerList)
             {
                 // Otherwise the entity can not exist yet
-                var entity = playerInfo.EntityUid;
-                if (!_entityManager.EntityExists(entity))
+                if (!_entityManager.EntityExists(playerInfo.EntityUid))
                 {
                     continue;
                 }
+                var entity = playerInfo.EntityUid.Value;
 
                 // if not on the same map, continue
                 if (_entityManager.GetComponent<TransformComponent>(entity).MapID != _eyeManager.CurrentMap)

Content.Client/Administration/AdminSystem.Menu.cs

@@ -1,167 +0,0 @@
-using System.Collections.Generic;
-using Content.Client.Administration.Managers;
-using Content.Client.Administration.UI;
-using Content.Client.Administration.UI.Tabs.PlayerTab;
-using Content.Client.HUD;
-using Content.Client.Verbs;
-using Content.Shared.Input;
-using Robust.Client.Console;
-using Robust.Client.Graphics;
-using Robust.Client.Input;
-using Robust.Client.ResourceManagement;
-using Robust.Client.UserInterface.Controls;
-using Robust.Client.UserInterface.CustomControls;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Input;
-using Robust.Shared.Input.Binding;
-using Robust.Shared.IoC;
-using Robust.Shared.Network;
-
-namespace Content.Client.Administration
-{
-    public sealed partial class AdminSystem
-    {
-        [Dependency] private readonly INetManager _netManager = default!;
-        [Dependency] private readonly IInputManager _inputManager = default!;
-        [Dependency] private readonly IGameHud _gameHud = default!;
-        [Dependency] private readonly IClientAdminManager _clientAdminManager = default!;
-        [Dependency] private readonly IClientConGroupController _clientConGroupController = default!;
-        [Dependency] private readonly IOverlayManager _overlayManager = default!;
-        [Dependency] private readonly IResourceCache _resourceCache = default!;
-        [Dependency] private readonly IEntityManager _entityManager = default!;
-        [Dependency] private readonly EntityLookupSystem _entityLookup = default!;
-        [Dependency] private readonly IClientConsoleHost _clientConsoleHost = default!;
-
-        [Dependency] private readonly VerbSystem _verbSystem = default!;
-
-        private AdminMenuWindow? _window;
-        private readonly List<BaseWindow> _commandWindows = new();
-
-        private void InitializeMenu()
-        {
-            // Reset the AdminMenu Window on disconnect
-            _netManager.Disconnect += (_, _) => ResetWindow();
-
-            _inputManager.SetInputCommand(ContentKeyFunctions.OpenAdminMenu,
-                InputCmdHandler.FromDelegate(_ => Toggle()));
-
-            _clientAdminManager.AdminStatusUpdated += () =>
-            {
-                // when status changes, show the top button if we can open admin menu.
-                // if we can't or we lost admin status, close it and hide the button.
-                _gameHud.AdminButtonVisible = CanOpen();
-                if (!_gameHud.AdminButtonVisible)
-                {
-                    Close();
-                }
-            };
-            _gameHud.AdminButtonToggled += (open) =>
-            {
-                if (open)
-                {
-                    TryOpen();
-                }
-                else
-                {
-                    Close();
-                }
-            };
-            _gameHud.AdminButtonVisible = CanOpen();
-            _gameHud.AdminButtonDown = false;
-        }
-
-
-        public void ResetWindow()
-        {
-            _window?.Close();
-            _window?.Dispose();
-            _window = null;
-
-            foreach (var window in _commandWindows)
-            {
-                window.Close();
-                window.Dispose();
-            }
-
-            _commandWindows.Clear();
-        }
-
-        public void OpenCommand(BaseWindow window)
-        {
-            _commandWindows.Add(window);
-            window.OpenCentered();
-        }
-
-        public void Open()
-        {
-            if (_window == null)
-            {
-                _window = new AdminMenuWindow();
-                _window.OnClose += Close;
-            }
-
-            _window.PlayerTabControl.OnEntryPressed += PlayerTabEntryPressed;
-            _window.OpenCentered();
-        }
-
-        public void Close()
-        {
-            if (_window != null)
-                _window.PlayerTabControl.OnEntryPressed -= PlayerTabEntryPressed;
-            _window?.Close();
-
-            foreach (var window in _commandWindows)
-                window?.Dispose();
-            _commandWindows.Clear();
-        }
-
-        /// <summary>
-        /// Checks if the player can open the window
-        /// </summary>
-        /// <returns>True if the player is allowed</returns>
-        public bool CanOpen()
-        {
-            return _clientConGroupController.CanAdminMenu();
-        }
-
-        /// <summary>
-        /// Checks if the player can open the window and tries to open it
-        /// </summary>
-        public void TryOpen()
-        {
-            if (CanOpen())
-                Open();
-        }
-
-        public void Toggle()
-        {
-            if (_window != null && _window.IsOpen)
-            {
-                Close();
-            }
-            else
-            {
-                TryOpen();
-            }
-        }
-
-        private void PlayerTabEntryPressed(BaseButton.ButtonEventArgs args)
-        {
-            if (args.Button is not PlayerTabEntry button
-                || button.PlayerUid == null)
-                return;
-
-            var uid = button.PlayerUid.Value;
-            var function = args.Event.Function;
-
-            if (function == EngineKeyFunctions.UIClick)
-                _clientConsoleHost.ExecuteCommand($"vv {uid}");
-            else if (function == ContentKeyFunctions.OpenContextMenu)
-                _verbSystem.VerbMenu.OpenVerbMenu(uid, true);
-            else
-                return;
-
-            args.Event.Handle();
-        }
-    }
-}

Content.Client/Administration/AdminSystem.Overlay.cs

@@ -1,45 +0,0 @@
-using Content.Client.Administration.Managers;
-using Robust.Client.Graphics;
-
-namespace Content.Client.Administration
-{
-    public sealed partial class AdminSystem
-    {
-        [Dependency] private readonly IClientAdminManager _adminManager = default!;
-        [Dependency] private readonly IEyeManager _eyeManager = default!;
-
-        private AdminNameOverlay _adminNameOverlay = default!;
-
-        public event Action? OverlayEnabled;
-        public event Action? OverlayDisabled;
-
-        private void InitializeOverlay()
-        {
-            _adminNameOverlay = new AdminNameOverlay(this, _entityManager, _eyeManager, _resourceCache, _entityLookup);
-            _adminManager.AdminStatusUpdated += OnAdminStatusUpdated;
-        }
-
-        private void ShutdownOverlay()
-        {
-            _adminManager.AdminStatusUpdated -= OnAdminStatusUpdated;
-        }
-
-        private void OnAdminStatusUpdated()
-        {
-            AdminOverlayOff();
-        }
-
-        public void AdminOverlayOn()
-        {
-            if (_overlayManager.HasOverlay<AdminNameOverlay>()) return;
-            _overlayManager.AddOverlay(_adminNameOverlay);
-            OverlayEnabled?.Invoke();
-        }
-
-        public void AdminOverlayOff()
-        {
-            _overlayManager.RemoveOverlay<AdminNameOverlay>();
-            OverlayDisabled?.Invoke();
-        }
-    }
-}

Content.Client/Administration/AdminSystem.cs

@@ -1,74 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Content.Shared.Administration;
-using Content.Shared.Administration.Events;
-using Content.Shared.GameTicking;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Network;
-
-namespace Content.Client.Administration
-{
-    public sealed partial class AdminSystem : EntitySystem
-    {
-        public event Action<List<PlayerInfo>>? PlayerListChanged;
-
-        private Dictionary<NetUserId, PlayerInfo>? _playerList;
-        public IReadOnlyList<PlayerInfo> PlayerList
-        {
-            get
-            {
-                if (_playerList != null) return _playerList.Values.ToList();
-
-                return new List<PlayerInfo>();
-            }
-        }
-
-        public override void Initialize()
-        {
-            base.Initialize();
-
-            InitializeOverlay();
-            InitializeMenu();
-            SubscribeNetworkEvent<FullPlayerListEvent>(OnPlayerListChanged);
-            SubscribeNetworkEvent<PlayerInfoChangedEvent>(OnPlayerInfoChanged);
-            SubscribeNetworkEvent<RoundRestartCleanupEvent>(OnRoundRestartCleanup);
-        }
-
-        public override void Shutdown()
-        {
-            base.Shutdown();
-            ShutdownOverlay();
-        }
-
-        private void OnRoundRestartCleanup(RoundRestartCleanupEvent msg, EntitySessionEventArgs args)
-        {
-            if (_playerList == null)
-                return;
-
-            foreach (var (id, playerInfo) in _playerList.ToArray())
-            {
-                if (playerInfo.Connected)
-                    continue;
-                _playerList.Remove(id);
-            }
-            PlayerListChanged?.Invoke(_playerList.Values.ToList());
-        }
-
-        private void OnPlayerInfoChanged(PlayerInfoChangedEvent ev)
-        {
-            if(ev.PlayerInfo == null) return;
-
-            if (_playerList == null) _playerList = new();
-
-            _playerList[ev.PlayerInfo.SessionId] = ev.PlayerInfo;
-            PlayerListChanged?.Invoke(_playerList.Values.ToList());
-        }
-
-        private void OnPlayerListChanged(FullPlayerListEvent msg)
-        {
-            _playerList = msg.PlayersInfo.ToDictionary(x => x.SessionId, x => x);
-            PlayerListChanged?.Invoke(msg.PlayersInfo);
-        }
-    }
-}

Content.Client/Administration/BwoinkSystem.cs

@@ -1,157 +0,0 @@
-#nullable enable
-using System.Collections.Generic;
-using System.Diagnostics.CodeAnalysis;
-using System.Linq;
-using Content.Client.Administration.Managers;
-using Content.Client.Administration.UI;
-using Content.Client.Administration.UI.CustomControls;
-using Content.Client.HUD;
-using Content.Shared.Administration;
-using JetBrains.Annotations;
-using Robust.Client.Graphics;
-using Robust.Client.UserInterface.CustomControls;
-using Robust.Client.Player;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Player;
-using Robust.Shared.Localization;
-using Robust.Shared.Audio;
-using Robust.Shared.IoC;
-using Robust.Shared.Network;
-
-namespace Content.Client.Administration
-{
-    [UsedImplicitly]
-    public sealed class BwoinkSystem : SharedBwoinkSystem
-    {
-        [Dependency] private readonly IClientAdminManager _adminManager = default!;
-        [Dependency] private readonly IPlayerManager _playerManager = default!;
-        [Dependency] private readonly IClyde _clyde = default!;
-        [Dependency] private readonly IGameHud _hud = default!;
-
-        private BwoinkWindow? _adminWindow;
-        private DefaultWindow? _plainWindow;
-        private readonly Dictionary<NetUserId, BwoinkPanel> _activePanelMap = new();
-
-        public bool IsOpen => (_adminWindow?.IsOpen ?? false) || (_plainWindow?.IsOpen ?? false);
-
-        protected override void OnBwoinkTextMessage(BwoinkTextMessage message, EntitySessionEventArgs eventArgs)
-        {
-            base.OnBwoinkTextMessage(message, eventArgs);
-            LogBwoink(message);
-            // Actual line
-            var window = EnsurePanel(message.ChannelId);
-            window.ReceiveLine(message);
-            // Play a sound if we didn't send it
-            var localPlayer = _playerManager.LocalPlayer;
-            if (localPlayer?.UserId != message.TrueSender)
-            {
-                SoundSystem.Play("/Audio/Effects/adminhelp.ogg", Filter.Local());
-                _clyde.RequestWindowAttention();
-            }
-
-            // If they're not an admin force it open so they read
-            // If it's admin-admin messaging then eh.
-            if (!_adminManager.HasFlag(AdminFlags.Adminhelp))
-                _plainWindow?.Open();
-            else
-            {
-                _adminWindow?.OnBwoink(message.ChannelId);
-
-                if (_adminWindow?.IsOpen != true)
-                    _hud.SetInfoRed(true);
-            }
-        }
-
-        public bool TryGetChannel(NetUserId ch, [NotNullWhen(true)] out BwoinkPanel? bp) => _activePanelMap.TryGetValue(ch, out bp);
-
-        private BwoinkPanel EnsureAdmin(NetUserId channelId)
-        {
-            _adminWindow ??= new BwoinkWindow(this);
-
-            if (!_activePanelMap.TryGetValue(channelId, out var existingPanel))
-            {
-                _activePanelMap[channelId] = existingPanel = new BwoinkPanel(this, channelId);
-                existingPanel.Visible = false;
-                if (!_adminWindow.BwoinkArea.Children.Contains(existingPanel))
-                    _adminWindow.BwoinkArea.AddChild(existingPanel);
-            }
-
-            return existingPanel;
-        }
-
-        private BwoinkPanel EnsurePlain(NetUserId channelId)
-        {
-            BwoinkPanel bp;
-            if (_plainWindow is null)
-            {
-                bp = new BwoinkPanel(this, channelId);
-                _plainWindow = new DefaultWindow()
-                {
-                    TitleClass="windowTitleAlert",
-                    HeaderClass="windowHeaderAlert",
-                    Title=Loc.GetString("bwoink-user-title"),
-                    SetSize=(400, 200),
-                };
-
-                _plainWindow.Contents.AddChild(bp);
-            }
-            else
-            {
-                bp = (BwoinkPanel) _plainWindow.Contents.GetChild(0);
-            }
-
-            return bp;
-        }
-
-        public BwoinkPanel EnsurePanel(NetUserId channelId)
-        {
-            if (_adminManager.HasFlag(AdminFlags.Adminhelp))
-                return EnsureAdmin(channelId);
-
-            return EnsurePlain(channelId);
-        }
-
-        public void Open(NetUserId? channelId = null)
-        {
-            if (channelId == null)
-            {
-                var localPlayer = _playerManager.LocalPlayer;
-                if (localPlayer != null)
-                    Open(localPlayer.UserId);
-                return;
-            }
-
-            _hud.SetInfoRed(false);
-
-            if (_adminManager.HasFlag(AdminFlags.Adminhelp))
-            {
-                SelectChannel(channelId.Value);
-                _adminWindow?.Open();
-                return;
-            }
-
-            EnsurePlain(channelId.Value);
-            _plainWindow?.Open();
-        }
-
-        public void Close()
-        {
-            _adminWindow?.Close();
-            _plainWindow?.Close();
-        }
-
-        private void SelectChannel(NetUserId uid)
-        {
-            _adminWindow ??= new BwoinkWindow(this);
-            _adminWindow.SelectChannel(uid);
-        }
-
-        public void Send(NetUserId channelId, string text)
-        {
-            // Reuse the channel ID as the 'true sender'.
-            // Server will ignore this and if someone makes it not ignore this (which is bad, allows impersonation!!!), that will help.
-            RaiseNetworkEvent(new BwoinkTextMessage(channelId, channelId, text));
-        }
-    }
-}
-

Content.Client/Administration/Commands/PlayGlobalSoundCommand.cs

@@ -1,48 +0,0 @@
-using System.Linq;
-using Robust.Client.Player;
-using Robust.Shared.Console;
-using Robust.Shared.ContentPack;
-
-namespace Content.Client.Administration.Commands;
-
-/// <summary>
-/// Proxy to server-side <c>playglobalsound</c> command. Implements completions.
-/// </summary>
-public sealed class PlayGlobalSoundCommand : IConsoleCommand
-{
-    public string Command => "playglobalsound";
-    public string Description => Loc.GetString("play-global-sound-command-description");
-    public string Help => Loc.GetString("play-global-sound-command-help");
-
-    public void Execute(IConsoleShell shell, string argStr, string[] args)
-    {
-        shell.RemoteExecuteCommand(argStr);
-    }
-
-    public CompletionResult GetCompletion(IConsoleShell shell, string[] args)
-    {
-        if (args.Length == 1)
-        {
-            var hint = Loc.GetString("play-global-sound-command-arg-path");
-            var res = IoCManager.Resolve<IResourceManager>();
-
-            var options = CompletionHelper.ContentFilePath(args[0], res);
-
-            return CompletionResult.FromHintOptions(options, hint);
-        }
-
-        if (args.Length == 2)
-            return CompletionResult.FromHint(Loc.GetString("play-global-sound-command-arg-volume"));
-
-        if (args.Length > 2)
-        {
-            var plyMgr = IoCManager.Resolve<IPlayerManager>();
-            var options = plyMgr.Sessions.Select(c => c.Name);
-            return CompletionResult.FromHintOptions(
-                options,
-                Loc.GetString("play-global-sound-command-arg-usern", ("user", args.Length - 2)));
-        }
-
-        return CompletionResult.Empty;
-    }
-}

Content.Client/Administration/Commands/UploadFile.cs

@@ -1,62 +0,0 @@
-using Content.Shared.Administration;
-using Content.Shared.CCVar;
-using Robust.Client.UserInterface;
-using Robust.Shared.Configuration;
-using Robust.Shared.Console;
-using Robust.Shared.Network;
-using Robust.Shared.Utility;
-
-namespace Content.Client.Administration.Commands;
-
-public sealed class UploadFile : IConsoleCommand
-{
-    public string Command => "uploadfile";
-    public string Description => "Uploads a resource to the server.";
-    public string Help => $"{Command} [relative path for the resource]";
-
-    public async void Execute(IConsoleShell shell, string argStr, string[] args)
-    {
-        var cfgMan = IoCManager.Resolve<IConfigurationManager>();
-
-        if (!cfgMan.GetCVar(CCVars.ResourceUploadingEnabled))
-        {
-            shell.WriteError("Network Resource Uploading is currently disabled by the server.");
-            return;
-        }
-
-        if (args.Length != 1)
-        {
-            shell.WriteError("Wrong number of arguments!");
-            return;
-        }
-
-        var dialog = IoCManager.Resolve<IFileDialogManager>();
-
-        var filters = new FileDialogFilters(new FileDialogFilters.Group("*"));
-        await using var file = await dialog.OpenFile(filters);
-
-        if (file == null)
-        {
-            shell.WriteError("Error picking file!");
-            return;
-        }
-
-        var sizeLimit = cfgMan.GetCVar(CCVars.ResourceUploadingLimitMb);
-
-        if (sizeLimit > 0f && file.Length * SharedNetworkResourceManager.BytesToMegabytes > sizeLimit)
-        {
-            shell.WriteError($"File above the current size limit! It must be smaller than {sizeLimit} MB.");
-            return;
-        }
-
-        var data = file.CopyToArray();
-
-        var netManager = IoCManager.Resolve<INetManager>();
-        var msg = netManager.CreateNetMessage<NetworkResourceUploadMessage>();
-
-        msg.RelativePath = new ResourcePath(args[0]).ToRelativePath();
-        msg.Data = data;
-
-        netManager.ClientSendMessage(msg);
-    }
-}

Content.Client/Administration/Components/HeadstandComponent.cs

@@ -0,0 +1,10 @@
+using Content.Shared.Administration.Components;
+using Robust.Shared.GameStates;
+
+namespace Content.Client.Administration.Components;
+
+[RegisterComponent, NetworkedComponent]
+public sealed partial class HeadstandComponent : SharedHeadstandComponent
+{
+
+}

Content.Client/Administration/Components/KillSignComponent.cs

@@ -4,5 +4,5 @@ using Robust.Shared.GameStates;
 namespace Content.Client.Administration.Components;
 
 [NetworkedComponent, RegisterComponent]
-public sealed class KillSignComponent : SharedKillSignComponent
+public sealed partial class KillSignComponent : SharedKillSignComponent
 { }

Content.Client/Administration/Managers/ClientAdminManager.cs

@@ -1,24 +1,26 @@
-using System;
-using System.Collections.Generic;
-using System.Reflection;
 using Content.Shared.Administration;
+using Content.Shared.Administration.Managers;
 using Robust.Client.Console;
-using Robust.Shared.Console;
-using Robust.Shared.IoC;
-using Robust.Shared.Log;
+using Robust.Client.Player;
+using Robust.Shared.ContentPack;
 using Robust.Shared.Network;
-using Robust.Shared.Reflection;
+using Robust.Shared.Players;
+using Robust.Shared.Utility;
 
 namespace Content.Client.Administration.Managers
 {
-    public sealed class ClientAdminManager : IClientAdminManager, IClientConGroupImplementation, IPostInjectInit
+    public sealed class ClientAdminManager : IClientAdminManager, IClientConGroupImplementation, IPostInjectInit, ISharedAdminManager
     {
+        [Dependency] private readonly IPlayerManager _player = default!;
         [Dependency] private readonly IClientNetManager _netMgr = default!;
         [Dependency] private readonly IClientConGroupController _conGroup = default!;
+        [Dependency] private readonly IResourceManager _res = default!;
 
         private AdminData? _adminData;
         private readonly HashSet<string> _availableCommands = new();
 
+        private readonly AdminCommandPermissions _localCommandPermissions = new();
+
         public event Action? AdminStatusUpdated;
 
         public bool IsActive()
@@ -33,6 +35,16 @@ namespace Content.Client.Administration.Managers
 
         public bool CanCommand(string cmdName)
         {
+            if (_adminData != null && _adminData.HasFlag(AdminFlags.Host))
+            {
+                // Host can execute all commands when connected.
+                // Kind of a shortcut to avoid pains during development.
+                return true;
+            }
+
+            if (_localCommandPermissions.CanCommand(cmdName, _adminData))
+                return true;
+
             return _availableCommands.Contains(cmdName);
         }
 
@@ -59,6 +71,12 @@ namespace Content.Client.Administration.Managers
         public void Initialize()
         {
             _netMgr.RegisterNetMessage<MsgUpdateAdminStatus>(UpdateMessageRx);
+
+            // Load flags for engine commands, since those don't have the attributes.
+            if (_res.TryContentFileRead(new ResPath("/clientCommandPerms.yml"), out var efs))
+            {
+                _localCommandPermissions.LoadPermissionsFromStream(efs);
+            }
         }
 
         private void UpdateMessageRx(MsgUpdateAdminStatus message)
@@ -67,7 +85,7 @@ namespace Content.Client.Administration.Managers
             var host = IoCManager.Resolve<IClientConsoleHost>();
 
             // Anything marked as Any we'll just add even if the server doesn't know about it.
-            foreach (var (command, instance) in host.RegisteredCommands)
+            foreach (var (command, instance) in host.AvailableCommands)
             {
                 if (Attribute.GetCustomAttribute(instance.GetType(), typeof(AnyCommandAttribute)) == null) continue;
                 _availableCommands.Add(command);
@@ -97,5 +115,20 @@ namespace Content.Client.Administration.Managers
         {
             _conGroup.Implementation = this;
         }
+
+        public AdminData? GetAdminData(EntityUid uid, bool includeDeAdmin = false)
+        {
+            return uid == _player.LocalPlayer?.ControlledEntity
+                ? _adminData
+                : null;
+        }
+
+        public AdminData? GetAdminData(ICommonSession session, bool includeDeAdmin = false)
+        {
+            if (_player.LocalPlayer?.UserId == session.UserId)
+                return _adminData;
+
+            return null;
+        }
     }
 }

Content.Client/Administration/Managers/GamePrototypeLoadManager.cs

@@ -1,39 +0,0 @@
-using System;
-using Content.Shared.Administration;
-using Robust.Shared.IoC;
-using Robust.Shared.Localization;
-using Robust.Shared.Log;
-using Robust.Shared.Network;
-using Robust.Shared.Prototypes;
-
-namespace Content.Client.Administration.Managers;
-
-public sealed class GamePrototypeLoadManager : IGamePrototypeLoadManager
-{
-    [Dependency] private readonly IClientNetManager _netManager = default!;
-    [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
-    [Dependency] private readonly ILocalizationManager _localizationManager = default!;
-
-    public void Initialize()
-    {
-        _netManager.RegisterNetMessage<GamePrototypeLoadMessage>(LoadGamePrototype);
-    }
-
-    private void LoadGamePrototype(GamePrototypeLoadMessage message)
-    {
-        _prototypeManager.LoadString(message.PrototypeData, true);
-        _prototypeManager.ResolveResults();
-        _localizationManager.ReloadLocalizations();
-        GamePrototypeLoaded?.Invoke();
-        Logger.InfoS("adminbus", "Loaded adminbus prototype data.");
-    }
-
-    public void SendGamePrototype(string prototype)
-    {
-        var msg = _netManager.CreateNetMessage<GamePrototypeLoadMessage>();
-        msg.PrototypeData = prototype;
-        _netManager.ClientSendMessage(msg);
-    }
-
-    public event Action? GamePrototypeLoaded;
-}

Content.Client/Administration/Managers/NetworkResourceManager.cs

@@ -1,15 +0,0 @@
-using Content.Shared.Administration;
-
-namespace Content.Client.Administration.Managers;
-
-public sealed class NetworkResourceManager : SharedNetworkResourceManager
-{
-    /// <summary>
-    ///     Callback for when the server sends a new resource.
-    /// </summary>
-    /// <param name="msg">The network message containing the data.</param>
-    protected override void ResourceUploadMsg(NetworkResourceUploadMessage msg)
-    {
-        ContentRoot.AddOrUpdateFile(msg.RelativePath, msg.Data);
-    }
-}

Content.Client/Administration/QuickDialogSystem.cs

@@ -0,0 +1,154 @@
+using System.Linq;
+using Content.Client.UserInterface.Controls;
+using Content.Shared.Administration;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+
+namespace Content.Client.Administration;
+
+/// <summary>
+/// This handles the client portion of quick dialogs.
+/// </summary>
+public sealed class QuickDialogSystem : EntitySystem
+{
+    /// <inheritdoc/>
+    public override void Initialize()
+    {
+        SubscribeNetworkEvent<QuickDialogOpenEvent>(OpenDialog);
+    }
+
+    private void OpenDialog(QuickDialogOpenEvent ev)
+    {
+        var window = new FancyWindow()
+        {
+            Title = ev.Title
+        };
+
+        var entryContainer = new BoxContainer()
+        {
+            Orientation = BoxContainer.LayoutOrientation.Vertical,
+            Margin = new Thickness(8),
+        };
+
+        var promptsDict = new Dictionary<string, LineEdit>();
+
+        foreach (var entry in ev.Prompts)
+        {
+            var entryBox = new BoxContainer()
+            {
+                Orientation = BoxContainer.LayoutOrientation.Horizontal
+            };
+
+            entryBox.AddChild(new Label { Text = entry.Prompt, HorizontalExpand = true, SizeFlagsStretchRatio = 0.5f });
+            var edit = new LineEdit() { HorizontalExpand = true};
+            entryBox.AddChild(edit);
+            switch (entry.Type)
+            {
+                case QuickDialogEntryType.Integer:
+                    edit.IsValid += VerifyInt;
+                    edit.PlaceHolder = "Integer..";
+                    break;
+                case QuickDialogEntryType.Float:
+                    edit.IsValid += VerifyFloat;
+                    edit.PlaceHolder = "Float..";
+                    break;
+                case QuickDialogEntryType.ShortText:
+                    edit.IsValid += VerifyShortText;
+                    edit.PlaceHolder = "Short text..";
+                    break;
+                case QuickDialogEntryType.LongText:
+                    edit.IsValid += VerifyLongText;
+                    edit.PlaceHolder = "Long text..";
+                    break;
+                default:
+                    throw new ArgumentOutOfRangeException();
+            }
+            promptsDict.Add(entry.FieldId, edit);
+            entryContainer.AddChild(entryBox);
+        }
+
+        var buttonsBox = new BoxContainer()
+        {
+            Orientation = BoxContainer.LayoutOrientation.Horizontal,
+            HorizontalAlignment = Control.HAlignment.Center,
+        };
+
+        var alreadyReplied = false;
+
+        if ((ev.Buttons & QuickDialogButtonFlag.OkButton) != 0)
+        {
+            var okButton = new Button()
+            {
+                Text = "Ok",
+            };
+
+            okButton.OnPressed += _ =>
+            {
+                RaiseNetworkEvent(new QuickDialogResponseEvent(ev.DialogId,
+                    promptsDict.Select(x => (x.Key, x.Value.Text)).ToDictionary(x => x.Key, x => x.Text),
+                    QuickDialogButtonFlag.OkButton));
+                alreadyReplied = true;
+                window.Close();
+            };
+
+            buttonsBox.AddChild(okButton);
+        }
+
+        if ((ev.Buttons & QuickDialogButtonFlag.OkButton) != 0)
+        {
+            var cancelButton = new Button()
+            {
+                Text = "Cancel",
+            };
+
+            cancelButton.OnPressed += _ =>
+            {
+                RaiseNetworkEvent(new QuickDialogResponseEvent(ev.DialogId,
+                    new(),
+                    QuickDialogButtonFlag.CancelButton));
+                alreadyReplied = true;
+                window.Close();
+            };
+
+            buttonsBox.AddChild(cancelButton);
+        }
+
+        window.OnClose += () =>
+        {
+            if (!alreadyReplied)
+            {
+                RaiseNetworkEvent(new QuickDialogResponseEvent(ev.DialogId,
+                    new(),
+                    QuickDialogButtonFlag.CancelButton));
+            }
+        };
+
+        entryContainer.AddChild(buttonsBox);
+
+        window.ContentsContainer.AddChild(entryContainer);
+
+        window.MinWidth *= 2; // Just double it.
+
+        window.OpenCentered();
+    }
+
+    private bool VerifyInt(string input)
+    {
+        return int.TryParse(input, out var _);
+    }
+
+    private bool VerifyFloat(string input)
+    {
+        return float.TryParse(input, out var _);
+    }
+
+    private bool VerifyShortText(string input)
+    {
+        return input.Length <= 100;
+    }
+
+    private bool VerifyLongText(string input)
+    {
+        return input.Length <= 2000;
+    }
+}

Content.Client/Administration/Systems/AdminSystem.Overlay.cs

@@ -0,0 +1,49 @@
+using Content.Client.Administration.Managers;
+using Robust.Client.Graphics;
+using Robust.Client.ResourceManagement;
+
+namespace Content.Client.Administration.Systems
+{
+    public sealed partial class AdminSystem
+    {
+        [Dependency] private readonly IOverlayManager _overlayManager = default!;
+        [Dependency] private readonly IResourceCache _resourceCache = default!;
+        [Dependency] private readonly IClientAdminManager _adminManager = default!;
+        [Dependency] private readonly IEyeManager _eyeManager = default!;
+        [Dependency] private readonly EntityLookupSystem _entityLookup = default!;
+
+        private AdminNameOverlay _adminNameOverlay = default!;
+
+        public event Action? OverlayEnabled;
+        public event Action? OverlayDisabled;
+
+        private void InitializeOverlay()
+        {
+            _adminNameOverlay = new AdminNameOverlay(this, EntityManager, _eyeManager, _resourceCache, _entityLookup);
+            _adminManager.AdminStatusUpdated += OnAdminStatusUpdated;
+        }
+
+        private void ShutdownOverlay()
+        {
+            _adminManager.AdminStatusUpdated -= OnAdminStatusUpdated;
+        }
+
+        private void OnAdminStatusUpdated()
+        {
+            AdminOverlayOff();
+        }
+
+        public void AdminOverlayOn()
+        {
+            if (_overlayManager.HasOverlay<AdminNameOverlay>()) return;
+            _overlayManager.AddOverlay(_adminNameOverlay);
+            OverlayEnabled?.Invoke();
+        }
+
+        public void AdminOverlayOff()
+        {
+            _overlayManager.RemoveOverlay<AdminNameOverlay>();
+            OverlayDisabled?.Invoke();
+        }
+    }
+}

Content.Client/Administration/Systems/AdminSystem.cs

@@ -0,0 +1,55 @@
+using System.Linq;
+using Content.Shared.Administration;
+using Content.Shared.Administration.Events;
+using Content.Shared.GameTicking;
+using Robust.Shared.Network;
+
+namespace Content.Client.Administration.Systems
+{
+    public sealed partial class AdminSystem : EntitySystem
+    {
+        public event Action<List<PlayerInfo>>? PlayerListChanged;
+
+        private Dictionary<NetUserId, PlayerInfo>? _playerList;
+        public IReadOnlyList<PlayerInfo> PlayerList
+        {
+            get
+            {
+                if (_playerList != null) return _playerList.Values.ToList();
+
+                return new List<PlayerInfo>();
+            }
+        }
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            InitializeOverlay();
+            SubscribeNetworkEvent<FullPlayerListEvent>(OnPlayerListChanged);
+            SubscribeNetworkEvent<PlayerInfoChangedEvent>(OnPlayerInfoChanged);
+        }
+
+        public override void Shutdown()
+        {
+            base.Shutdown();
+            ShutdownOverlay();
+        }
+
+        private void OnPlayerInfoChanged(PlayerInfoChangedEvent ev)
+        {
+            if(ev.PlayerInfo == null) return;
+
+            if (_playerList == null) _playerList = new();
+
+            _playerList[ev.PlayerInfo.SessionId] = ev.PlayerInfo;
+            PlayerListChanged?.Invoke(_playerList.Values.ToList());
+        }
+
+        private void OnPlayerListChanged(FullPlayerListEvent msg)
+        {
+            _playerList = msg.PlayersInfo.ToDictionary(x => x.SessionId, x => x);
+            PlayerListChanged?.Invoke(msg.PlayersInfo);
+        }
+    }
+}

Content.Client/Administration/Systems/AdminVerbSystem.cs

@@ -1,10 +1,8 @@
 using Content.Shared.Verbs;
 using Robust.Client.Console;
-using Robust.Client.ViewVariables;
-using Robust.Shared.GameObjects;
-using Robust.Shared.IoC;
+using Robust.Shared.Utility;
 
-namespace Content.Client.Verbs
+namespace Content.Client.Administration.Systems
 {
     /// <summary>
     ///     Client-side admin verb system. These usually open some sort of UIs.
@@ -29,7 +27,7 @@ namespace Content.Client.Verbs
                 Verb verb = new();
                 verb.Category = VerbCategory.Debug;
                 verb.Text = "View Variables";
-                verb.IconTexture = "/Textures/Interface/VerbIcons/vv.svg.192dpi.png";
+                verb.Icon = new SpriteSpecifier.Texture(new ("/Textures/Interface/VerbIcons/vv.svg.192dpi.png"));
                 verb.Act = () => _clientConsoleHost.ExecuteCommand($"vv {args.Target}");
                 verb.ClientExclusive = true; // opening VV window is client-side. Don't ask server to run this verb.
                 args.Verbs.Add(verb);

Content.Client/Administration/Systems/BwoinkSystem.cs

@@ -0,0 +1,42 @@
+#nullable enable
+using Content.Shared.Administration;
+using JetBrains.Annotations;
+using Robust.Shared.Network;
+using Robust.Shared.Timing;
+
+namespace Content.Client.Administration.Systems
+{
+    [UsedImplicitly]
+    public sealed class BwoinkSystem : SharedBwoinkSystem
+    {
+        [Dependency] private readonly IGameTiming _timing = default!;
+
+        public event EventHandler<BwoinkTextMessage>? OnBwoinkTextMessageRecieved;
+        private (TimeSpan Timestamp, bool Typing) _lastTypingUpdateSent;
+
+        protected override void OnBwoinkTextMessage(BwoinkTextMessage message, EntitySessionEventArgs eventArgs)
+        {
+            OnBwoinkTextMessageRecieved?.Invoke(this, message);
+        }
+
+        public void Send(NetUserId channelId, string text)
+        {
+            // Reuse the channel ID as the 'true sender'.
+            // Server will ignore this and if someone makes it not ignore this (which is bad, allows impersonation!!!), that will help.
+            RaiseNetworkEvent(new BwoinkTextMessage(channelId, channelId, text));
+            SendInputTextUpdated(channelId, false);
+        }
+
+        public void SendInputTextUpdated(NetUserId channel, bool typing)
+        {
+            if (_lastTypingUpdateSent.Typing == typing &&
+                _lastTypingUpdateSent.Timestamp + TimeSpan.FromSeconds(1) > _timing.RealTime)
+            {
+                return;
+            }
+
+            _lastTypingUpdateSent = (_timing.RealTime, typing);
+            RaiseNetworkEvent(new BwoinkClientTypingUpdated(channel, typing));
+        }
+    }
+}

Content.Client/Administration/Systems/HeadstandSystem.cs

@@ -0,0 +1,35 @@
+using Content.Client.Administration.Components;
+using Robust.Client.GameObjects;
+
+namespace Content.Client.Administration.Systems;
+
+public sealed class HeadstandSystem : EntitySystem
+{
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<HeadstandComponent, ComponentStartup>(OnHeadstandAdded);
+        SubscribeLocalEvent<HeadstandComponent, ComponentShutdown>(OnHeadstandRemoved);
+    }
+
+    private void OnHeadstandAdded(EntityUid uid, HeadstandComponent component, ComponentStartup args)
+    {
+        if (!TryComp<SpriteComponent>(uid, out var sprite))
+            return;
+
+        foreach (var layer in sprite.AllLayers)
+        {
+            layer.Rotation += Angle.FromDegrees(180.0f);
+        }
+    }
+
+    private void OnHeadstandRemoved(EntityUid uid, HeadstandComponent component, ComponentShutdown args)
+    {
+        if (!TryComp<SpriteComponent>(uid, out var sprite))
+            return;
+
+        foreach (var layer in sprite.AllLayers)
+        {
+            layer.Rotation -= Angle.FromDegrees(180.0f);
+        }
+    }
+}

Content.Client/Administration/Systems/KillSignSystem.cs

@@ -1,8 +1,9 @@
-using Content.Client.Administration.Components;
+using System.Numerics;
+using Content.Client.Administration.Components;
 using Robust.Client.GameObjects;
 using Robust.Shared.Utility;
 
-namespace Content.Client.Administration;
+namespace Content.Client.Administration.Systems;
 
 public sealed class KillSignSystem : EntitySystem
 {
@@ -33,7 +34,7 @@ public sealed class KillSignSystem : EntitySystem
 
         var adj = sprite.Bounds.Height / 2 + ((1.0f/32) * 6.0f);
 
-        var layer = sprite.AddLayer(new SpriteSpecifier.Rsi(new ResourcePath("Objects/Misc/killsign.rsi"), "sign"));
+        var layer = sprite.AddLayer(new SpriteSpecifier.Rsi(new ResPath("Objects/Misc/killsign.rsi"), "sign"));
         sprite.LayerMapSet(KillSignKey.Key, layer);
 
         sprite.LayerSetOffset(layer, new Vector2(0.0f, adj));

Content.Client/Administration/UI/AdminAnnounceWindow.xaml

@@ -1,15 +1,18 @@
 <DefaultWindow
     xmlns="https://spacestation14.io"
-    Title="{Loc 'admin-announce-title'}"
+    Title="{Loc admin-announce-title}"
     MinWidth="500">
     <GridContainer Columns="1">
         <BoxContainer Orientation="Horizontal" HorizontalExpand="True">
-            <LineEdit Name="Announcer" Access="Public" PlaceHolder="{Loc 'announcer-placeholder'}" Text="{Loc 'Central Command'}" HorizontalExpand="True" SizeFlagsStretchRatio="2"/>
+            <LineEdit Name="Announcer" Access="Public" PlaceHolder="{Loc admin-announce-announcer-placeholder}" Text="{Loc admin-announce-announcer-default}" HorizontalExpand="True" SizeFlagsStretchRatio="2"/>
             <Control HorizontalExpand="True" SizeFlagsStretchRatio="1" />
             <OptionButton Name="AnnounceMethod" Access="Public" HorizontalExpand="True" SizeFlagsStretchRatio="2"/>
         </BoxContainer>
-        <LineEdit Name="Announcement" Access="Public" PlaceHolder="{Loc 'announcement-placeholder'}"/>
+        <TextEdit Name="Announcement" Access="Public" VerticalExpand="True" MinHeight="100" />
 
-        <Button Name="AnnounceButton" Access="Public" Disabled="True" Text="{Loc 'Announce'}" HorizontalAlignment="Center"/>
+        <GridContainer Rows="1">
+            <CheckBox Name="KeepWindowOpen" Access="Public" Text="{Loc 'admin-announce-keep-open'}" />
+            <Button Name="AnnounceButton" Access="Public" Disabled="True" Text="{Loc admin-announce-button}" HorizontalAlignment="Center"/>
+        </GridContainer>
     </GridContainer>
 </DefaultWindow>

Content.Client/Administration/UI/AdminAnnounceWindow.xaml.cs

@@ -1,11 +1,10 @@
-using Content.Client.HUD;
 using Content.Shared.Administration;
 using Robust.Client.AutoGenerated;
+using Robust.Client.UserInterface;
 using Robust.Client.UserInterface.Controls;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.UserInterface.XAML;
-using Robust.Shared.IoC;
-using Robust.Shared.Localization;
+using Robust.Shared.Utility;
 
 namespace Content.Client.Administration.UI
 {
@@ -19,18 +18,18 @@ namespace Content.Client.Administration.UI
             RobustXamlLoader.Load(this);
             IoCManager.InjectDependencies(this);
 
-            AnnounceMethod.AddItem(_localization.GetString("announce-type-station"));
+            Announcement.Placeholder = new Rope.Leaf(_localization.GetString("admin-announce-announcement-placeholder"));
+            AnnounceMethod.AddItem(_localization.GetString("admin-announce-type-station"));
             AnnounceMethod.SetItemMetadata(0, AdminAnnounceType.Station);
-            AnnounceMethod.AddItem(_localization.GetString("announce-type-server"));
+            AnnounceMethod.AddItem(_localization.GetString("admin-announce-type-server"));
             AnnounceMethod.SetItemMetadata(1, AdminAnnounceType.Server);
             AnnounceMethod.OnItemSelected += AnnounceMethodOnOnItemSelected;
-            Announcement.OnTextChanged += AnnouncementOnOnTextChanged;
+            Announcement.OnKeyBindUp += AnnouncementOnOnTextChanged;
         }
 
-
-        private void AnnouncementOnOnTextChanged(LineEdit.LineEditEventArgs args)
+        private void AnnouncementOnOnTextChanged(GUIBoundKeyEventArgs args)
         {
-            AnnounceButton.Disabled = args.Text.TrimStart() == "";
+            AnnounceButton.Disabled = Rope.Collapse(Announcement.TextRope).TrimStart() == "";
         }
 
         private void AnnounceMethodOnOnItemSelected(OptionButton.ItemSelectedEventArgs args)

Content.Client/Administration/UI/AdminMenuWindow.xaml

@@ -1,10 +1,11 @@
-<DefaultWindow
+<DefaultWindow
     xmlns="https://spacestation14.io"
     xmlns:adminTab="clr-namespace:Content.Client.Administration.UI.Tabs.AdminTab"
     xmlns:adminbusTab="clr-namespace:Content.Client.Administration.UI.Tabs.AdminbusTab"
     xmlns:atmosTab="clr-namespace:Content.Client.Administration.UI.Tabs.AtmosTab"
     xmlns:tabs="clr-namespace:Content.Client.Administration.UI.Tabs"
-    xmlns:playerTab="clr-namespace:Content.Client.Administration.UI.Tabs.PlayerTab">
+    xmlns:playerTab="clr-namespace:Content.Client.Administration.UI.Tabs.PlayerTab"
+    xmlns:objectsTab="clr-namespace:Content.Client.Administration.UI.Tabs.ObjectsTab">
     <TabContainer Name="MasterTabContainer">
         <adminTab:AdminTab />
         <adminbusTab:AdminbusTab />
@@ -12,5 +13,6 @@
         <tabs:RoundTab />
         <tabs:ServerTab />
         <playerTab:PlayerTab Name="PlayerTabControl" Access="Public" />
+        <objectsTab:ObjectsTab Name="ObjectsTabControl" Access="Public" />
     </TabContainer>
 </DefaultWindow>

Content.Client/Administration/UI/AdminMenuWindow.xaml.cs

@@ -1,44 +1,35 @@
-using Content.Client.Administration.UI.Tabs;
-using Content.Client.HUD;
+using System.Numerics;
 using Robust.Client.AutoGenerated;
 using Robust.Client.UserInterface.CustomControls;
 using Robust.Client.UserInterface.XAML;
-using Robust.Shared.IoC;
-using Robust.Shared.Localization;
 
 namespace Content.Client.Administration.UI
 {
     [GenerateTypedNameReferences]
     public sealed partial class AdminMenuWindow : DefaultWindow
     {
-        [Dependency] private readonly IGameHud? _gameHud = default!;
+        public event Action? OnDisposed;
 
         public AdminMenuWindow()
         {
-            MinSize = SetSize = (500, 250);
+            MinSize = new Vector2(600, 250); // Corvax-Resize
             Title = Loc.GetString("admin-menu-title");
             RobustXamlLoader.Load(this);
-            IoCManager.InjectDependencies(this);
             MasterTabContainer.SetTabTitle(0, Loc.GetString("admin-menu-admin-tab"));
             MasterTabContainer.SetTabTitle(1, Loc.GetString("admin-menu-adminbus-tab"));
             MasterTabContainer.SetTabTitle(2, Loc.GetString("admin-menu-atmos-tab"));
             MasterTabContainer.SetTabTitle(3, Loc.GetString("admin-menu-round-tab"));
             MasterTabContainer.SetTabTitle(4, Loc.GetString("admin-menu-server-tab"));
             MasterTabContainer.SetTabTitle(5, Loc.GetString("admin-menu-players-tab"));
+            MasterTabContainer.SetTabTitle(6, Loc.GetString("admin-menu-objects-tab"));
         }
 
-        protected override void EnteredTree()
+        protected override void Dispose(bool disposing)
         {
-            base.EnteredTree();
-            if (_gameHud != null)
-                _gameHud.AdminButtonDown = true;
-        }
-
-        protected override void ExitedTree()
-        {
-            base.ExitedTree();
-            if (_gameHud != null)
-                _gameHud.AdminButtonDown = false;
+            OnDisposed?.Invoke();
+            base.Dispose(disposing);
+            OnDisposed = null;
         }
     }
 }
+

Content.Client/Administration/UI/AdminMenuWindowEui.cs

@@ -1,6 +1,8 @@
 using Content.Client.Eui;
 using Content.Shared.Administration;
+using Content.Shared.Eui;
 using Robust.Client.UserInterface.Controls;
+using Robust.Shared.Utility;
 
 namespace Content.Client.Administration.UI
 {
@@ -11,7 +13,7 @@ namespace Content.Client.Administration.UI
         public AdminAnnounceEui()
         {
             _window = new AdminAnnounceWindow();
-            _window.OnClose += () => SendMessage(new AdminAnnounceEuiMsg.Close());
+            _window.OnClose += () => SendMessage(new CloseEuiMessage());
             _window.AnnounceButton.OnPressed += AnnounceButtonOnOnPressed;
         }
 
@@ -19,10 +21,10 @@ namespace Content.Client.Administration.UI
         {
             SendMessage(new AdminAnnounceEuiMsg.DoAnnounce
             {
-                Announcement = _window.Announcement.Text,
+                Announcement = Rope.Collapse(_window.Announcement.TextRope),
                 Announcer =  _window.Announcer.Text,
                 AnnounceType =  (AdminAnnounceType) (_window.AnnounceMethod.SelectedMetadata ?? AdminAnnounceType.Station),
-                CloseAfter = true,
+                CloseAfter = !_window.KeepWindowOpen.Pressed,
             });
 
         }

Content.Client/Administration/UI/AdminRemarks/AdminMessageEui.cs

@@ -0,0 +1,38 @@
+using Content.Client.Eui;
+using Content.Shared.Administration.Notes;
+using Content.Shared.Eui;
+using JetBrains.Annotations;
+using static Content.Shared.Administration.Notes.AdminMessageEuiMsg;
+
+namespace Content.Client.Administration.UI.AdminRemarks;
+
+[UsedImplicitly]
+public sealed class AdminMessageEui : BaseEui
+{
+    private readonly AdminMessagePopupWindow _popup;
+
+    public AdminMessageEui()
+    {
+        _popup = new AdminMessagePopupWindow();
+        _popup.OnAcceptPressed += () => SendMessage(new Accept());
+        _popup.OnDismissPressed += () => SendMessage(new Dismiss());
+        _popup.OnClose += () => SendMessage(new CloseEuiMessage());
+    }
+
+    public override void HandleState(EuiStateBase state)
+    {
+        if (state is not AdminMessageEuiState s)
+        {
+            return;
+        }
+
+        _popup.SetMessage(s.Message);
+        _popup.SetDetails(s.AdminName, s.AddedOn);
+        _popup.Timer = s.Time;
+    }
+
+    public override void Opened()
+    {
+        _popup.OpenCentered();
+    }
+}

Content.Client/Administration/UI/AdminRemarks/AdminMessagePopupWindow.xaml

@@ -0,0 +1,26 @@
+<ui:FancyWindow xmlns="https://spacestation14.io"
+                xmlns:ui="clr-namespace:Content.Client.UserInterface.Controls"
+                xmlns:graphics="clr-namespace:Robust.Client.Graphics;assembly=Robust.Client"
+                VerticalExpand="True" HorizontalExpand="True"
+                Title="{Loc admin-notes-message-window-title}"
+                MinSize="600 170">
+    <PanelContainer VerticalExpand="True" HorizontalExpand="True">
+        <PanelContainer.PanelOverride>
+            <graphics:StyleBoxFlat BackgroundColor="#25252A" />
+        </PanelContainer.PanelOverride>
+        <ScrollContainer HScrollEnabled="False" VerticalExpand="True" HorizontalExpand="True" Margin="4">
+            <BoxContainer Orientation="Vertical" SeparationOverride="10" VerticalAlignment="Bottom">
+                <Label Name="AdminLabel" Text="Loading..." />
+                <RichTextLabel Name="MessageLabel" />
+                <Label Name="WaitLabel" />
+                <BoxContainer Orientation="Horizontal">
+                    <Button Name="DismissButton"
+                            Text="{Loc 'admin-notes-message-dismiss'}" />
+                    <Button Name="AcceptButton"
+                            Text="{Loc 'admin-notes-message-accept'}"
+                            Disabled="True" />
+                </BoxContainer>
+            </BoxContainer>
+        </ScrollContainer>
+    </PanelContainer>
+</ui:FancyWindow>