.ci/lint_cpp.sh

@@ -13,9 +13,17 @@ fi
 # Check formatting using format.sh
 echo "Checking your code using format.sh..."
 
-./format.sh --color-diff --cmake --shell --print-version --branch origin/master
+diff="$(./format.sh --diff --cmake --shell --print-version --branch origin/master)"
 err=$?
 
+sep="
+----------
+"
+used_version="${diff%%"$sep"*}"
+diff="${diff#*"$sep"}"
+changes_to_make="${diff%%"$sep"*}"
+files_to_edit="${diff#*"$sep"}"
+
 case $err in
   1)
     cat <<EOM
@@ -28,10 +36,19 @@ case $err in
 ***  Then commit and push those changes to this branch. ***
 ***   Check our CONTRIBUTING.md file for more details.  ***
 ***                                                     ***
-***                    Thank you ❤️                     ***
+***                    Thank you ❤️                      ***
 ***                                                     ***
 ***********************************************************
 
+Used version:
+$used_version
+
+Affected files:
+$files_to_edit
+
+The following changes should be made:
+$changes_to_make
+
 Exiting...
 EOM
     exit 2
@@ -48,6 +65,9 @@ EOM
 ***                                                     ***
 ***********************************************************
 
+Used version:
+$used_version
+
 Exiting...
 EOM
     exit 0

.github/workflows/desktop-build.yml

@@ -1,10 +1,10 @@
 name: Build Desktop
 
 permissions:
-  actions: write    # needed to delete entries in GHA cache (update ccache)
-  attestations: write    # needed to persist the attestation.
   contents: write
-  id-token: write    # needed for signing certificate in attestation
+  id-token: write
+  attestations: write
+  actions: write # needed for ccache action to be able to delete gha caches
 
 on:
   push:
@@ -19,7 +19,7 @@ on:
       - '.github/workflows/desktop-build.yml'
       - 'CMakeLists.txt'
       - 'vcpkg.json'
-      - 'vcpkg'    # needed to match submodule bumps (gitlink)
+      - 'vcpkg'
     tags:
       - '*'
   pull_request:
@@ -32,7 +32,7 @@ on:
       - '.github/workflows/desktop-build.yml'
       - 'CMakeLists.txt'
       - 'vcpkg.json'
-      - 'vcpkg'    # needed to match submodule bumps (gitlink)
+      - 'vcpkg'
 
 # Cancel earlier, unfinished runs of this workflow on the same branch (unless on release)
 concurrency:
@@ -44,11 +44,11 @@ jobs:
     name: Configure
     runs-on: ubuntu-slim
     outputs:
-      tag: ${{ steps.configure.outputs.tag }}
-      sha: ${{ steps.configure.outputs.sha }}
+      tag: ${{steps.configure.outputs.tag}}
+      sha: ${{steps.configure.outputs.sha}}
 
     steps:  
-      - name: "Configure"
+      - name: Configure
         id: configure
         shell: bash
         run: |
@@ -64,150 +64,146 @@ jobs:
           fi
           echo "sha=$sha" >>"$GITHUB_OUTPUT"
 
-      - name: "Checkout"
+      - name: Checkout
         if: steps.configure.outputs.tag != null
         uses: actions/checkout@v6
         with:
-          fetch-depth: 0    # fetch all history for all branches and tags
+          fetch-depth: 0
 
-      - name: "Prepare release parameters"
+      - name: Prepare release parameters
         id: prepare
         if: steps.configure.outputs.tag != null
         shell: bash
         env:
-          TAG: ${{ steps.configure.outputs.tag }}
+          TAG: ${{steps.configure.outputs.tag}}
         run: .ci/prep_release.sh
 
-      - name: "Create release"
+      - name: Create release
         if: steps.configure.outputs.tag != null
         id: create_release
         shell: bash
         env:
-          GH_TOKEN: ${{ github.token }}
-          tag_name: ${{ steps.configure.outputs.tag }}
-          target: ${{ steps.configure.outputs.sha }}
-          release_name: ${{ steps.prepare.outputs.title }}
-          body_path: ${{ steps.prepare.outputs.body_path }}
-          prerelease: ${{ steps.prepare.outputs.is_beta }}
+          GH_TOKEN: ${{github.token}}
+          tag_name: ${{steps.configure.outputs.tag}}
+          target: ${{steps.configure.outputs.sha}}
+          release_name: ${{steps.prepare.outputs.title}}
+          body_path: ${{steps.prepare.outputs.body_path}}
+          prerelease: ${{steps.prepare.outputs.is_beta}}
         run: |
-          args=()
-          [[ $prerelease == yes ]] && args+=(--prerelease)
-          
-          gh release create "$tag_name" --verify-tag --draft "${args[@]}" \
-            --target "$target" \
-            --title "$release_name" \
-            --notes-file "$body_path"
+          if [[ $prerelease == yes ]]; then
+            args="--prerelease"
+          fi
+          gh release create "$tag_name" --draft --verify-tag $args \
+              --target "$target" --title "$release_name" \
+              --notes-file "$body_path"
 
   build-linux:
     strategy:
       fail-fast: false
       matrix:
-        # The files in ".ci/$distro$version" correspond to the values given here
+        # These names correspond to the files in ".ci/$distro$version"
         include:
           - distro: Arch
-            
-            allow-failure: yes
             package: skip    # We are packaged in Arch already
+            allow-failure: yes
 
           - distro: Servatrice_Debian
             version: 12
-            
             package: DEB
-            server_only: yes
             test: skip
+            server_only: yes
 
           - distro: Debian
             version: 12
-            
             package: DEB
             test: skip    # Running tests on all distros is superfluous
 
           - distro: Debian
             version: 13
-            
             package: DEB
 
           - distro: Fedora
             version: 43
-            
             package: RPM
             test: skip    # Running tests on all distros is superfluous
 
           - distro: Fedora
             version: 44
-            
             package: RPM
 
           - distro: Ubuntu
             version: 24.04
-            
             package: DEB
             test: skip    # Running tests on all distros is superfluous
 
           - distro: Ubuntu
             version: 26.04
-            
             package: DEB
 
-    name: ${{ matrix.distro }} ${{ matrix.version }}
+    name: ${{matrix.distro}} ${{matrix.version}}
     needs: configure
     runs-on: ubuntu-latest
-    continue-on-error: ${{ matrix.allow-failure == 'yes' }}
+    continue-on-error: ${{matrix.allow-failure == 'yes'}}
     timeout-minutes: 70
     env:
-      CACHE: ${{ github.workspace }}/.cache/${{ matrix.distro }}${{ matrix.version }}    # directory for caching docker image and ccache
+      NAME: ${{matrix.distro}}${{matrix.version}}
+      CACHE: ${{github.workspace}}/.cache/${{matrix.distro}}${{matrix.version}}   # directory for caching docker image and ccache
+      # Cache size over the entire repo is 10Gi:
+      # https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#usage-limits-and-eviction-policy
+      CCACHE_SIZE: 550M
       CCACHE_EVICTION_AGE: 7d
-      CCACHE_SIZE: 550M    # space of all repo is 10Gi: https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#usage-limits-and-eviction-policy
       CMAKE_GENERATOR: 'Ninja'
-      NAME: ${{ matrix.distro }}${{ matrix.version }}
 
     steps:
-      - name: "Checkout"
+      - name: Checkout
         uses: actions/checkout@v6
 
-      - name: "Restore compiler cache (ccache)"
+      - name: Restore compiler cache (ccache)
         id: ccache_restore
         uses: actions/cache/restore@v5
         env:
           BRANCH_NAME: ${{ github.head_ref || github.ref_name }}
         with:
-          key: ccache-${{ matrix.distro }}${{ matrix.version }}-${{ env.BRANCH_NAME }}
-          path: ${{ env.CACHE }}
-          restore-keys: ccache-${{ matrix.distro }}${{ matrix.version }}-
+          path: ${{env.CACHE}}
+          key: ccache-${{matrix.distro}}${{matrix.version}}-${{env.BRANCH_NAME}}
+          restore-keys: ccache-${{matrix.distro}}${{matrix.version}}-
 
-      - name: "Build ${{ matrix.distro }} ${{ matrix.version }} Docker image"
+      - name: Build ${{matrix.distro}} ${{matrix.version}} Docker image
         shell: bash
         run: source .ci/docker.sh --build
 
-      - name: "Build debug and test"
+      - name: Build debug and test
         if: matrix.test != 'skip'
         shell: bash
         run: |
           source .ci/docker.sh
           RUN --server --debug --test --ccache "$CCACHE_SIZE" \
-            --cmake-generator "$CMAKE_GENERATOR"
+                  --cmake-generator "$CMAKE_GENERATOR"
 
-      - name: "Build release package"
+      - name: Build release package
         id: build
         if: matrix.package != 'skip'
         shell: bash
         env:
-          SUFFIX: '-${{ matrix.distro }}${{ matrix.version }}'
-          package: '${{ matrix.package }}'
-          server_only: '${{ matrix.server_only }}'
+          SUFFIX: '-${{matrix.distro}}${{matrix.version}}'
+          package: '${{matrix.package}}'
+          server_only: '${{matrix.server_only}}'
         run: |
           source .ci/docker.sh
           args=()
-          [[ $server_only == yes ]] && args+=(--no-client)
-          [[ $GITHUB_REF == "refs/heads/master" ]] && args+=(--evict-ccache "$CCACHE_EVICTION_AGE")
+          if [[ $server_only == yes ]]; then
+            args+=(--no-client)
+          fi
+          if [[ $GITHUB_REF == "refs/heads/master" ]]; then
+            args+=(--evict-ccache "$CCACHE_EVICTION_AGE")
+          fi
           args+=(--ccache "$CCACHE_SIZE")
           args+=(--cmake-generator "$CMAKE_GENERATOR")
           args+=(--suffix "$SUFFIX")
-          
           RUN --server --release --package "$package" "${args[@]}"
 
       # Delete used cache to emulate a ccache update. See https://github.com/actions/cache/issues/342
-      - name: "Delete remote compiler cache (ccache)"
+      - name: Delete remote compiler cache (ccache)
         if: github.ref == 'refs/heads/master' && steps.ccache_restore.outputs.cache-hit
         continue-on-error: true
         env:
@@ -217,47 +213,47 @@ jobs:
             echo "Cache deleted successfully"
           fi
 
-      - name: "Save updated compiler cache (ccache)"
+      - name: Save updated compiler cache (ccache)
         if: github.ref == 'refs/heads/master'
         uses: actions/cache/save@v5
         with:
+          path: ${{env.CACHE}}
           key: ${{ steps.ccache_restore.outputs.cache-primary-key }}
-          path: ${{ env.CACHE }}
 
-      - name: "Upload artifact"
+      - name: Upload artifact
         id: upload_artifact
         if: matrix.package != 'skip'
         uses: actions/upload-artifact@v7
         with:
+          path: ${{steps.build.outputs.path}}
           archive: false
           if-no-files-found: error
-          path: ${{ steps.build.outputs.path }}
 
-      - name: "Upload to release"
+      - name: Upload to release
         id: upload_release
         if: matrix.package != 'skip' && needs.configure.outputs.tag != null
         shell: bash
         env:
-          asset_name: ${{ steps.build.outputs.fullname }}
-          asset_path: ${{ steps.build.outputs.path }}
-          GH_TOKEN: ${{ github.token }}
-          tag_name: ${{ needs.configure.outputs.tag }}
+          GH_TOKEN: ${{github.token}}
+          tag_name: ${{needs.configure.outputs.tag}}
+          asset_name: ${{steps.build.outputs.fullname}}
+          asset_path: ${{steps.build.outputs.path}}
         run: gh release upload "$tag_name" "$asset_path#$asset_name"
 
-      - name: "Attest binary provenance"
+      - name: Attest binary provenance
         id: attestation
         if: steps.upload_release.outcome == 'success'
         uses: actions/attest@v4
         with:
+          subject-path: ${{steps.build.outputs.path}}
           show-summary: false
-          subject-path: ${{ steps.build.outputs.path }}
 
-      - name: "Verify binary attestation"
+      - name: Verify binary attestation
         if: steps.attestation.outcome == 'success'
         shell: bash
         env:
-          GH_TOKEN: ${{ github.token }}
-        run: gh attestation verify "${{ steps.build.outputs.path }}" --repo Cockatrice/Cockatrice
+          GH_TOKEN: ${{github.token}}
+        run: gh attestation verify "${{steps.build.outputs.path}}" --repo Cockatrice/Cockatrice
 
   build-vcpkg:
     strategy:
@@ -267,202 +263,200 @@ jobs:
           - os: macOS
             target: 13
             runner: macos-15-intel
-            
-            ccache_eviction_age: 7d
-            cmake_generator: Ninja
-            make_package: 1
+            soc: Intel
+            xcode: "16.4"
+            type: Release
             override_target: 13
+            make_package: 1
             package_suffix: "-macOS13_Intel"
             qt_version: 6.11.0
             qt_arch: clang_64
             qt_modules: qtimageformats qtmultimedia qtwebsockets
-            soc: Intel
-            type: Release
+            cmake_generator: Ninja
             use_ccache: 1
-            xcode: "16.4"
+            ccache_eviction_age: 7d
 
           - os: macOS
             target: 14
             runner: macos-14
-            
-            ccache_eviction_age: 7d
-            cmake_generator: Ninja
+            soc: Apple
+            xcode: "15.4"
+            type: Release
             make_package: 1
             package_suffix: "-macOS14"
             qt_version: 6.11.0
             qt_arch: clang_64
             qt_modules: qtimageformats qtmultimedia qtwebsockets
-            soc: Apple
-            type: Release
+            cmake_generator: Ninja
             use_ccache: 1
-            xcode: "15.4"
+            ccache_eviction_age: 7d
 
           - os: macOS
             target: 15
             runner: macos-15
-            
-            ccache_eviction_age: 7d
-            cmake_generator: Ninja
+            soc: Apple
+            xcode: "16.4"
+            type: Release
             make_package: 1
             package_suffix: "-macOS15"
             qt_version: 6.11.0
             qt_arch: clang_64
             qt_modules: qtimageformats qtmultimedia qtwebsockets
-            soc: Apple
-            type: Release
+            cmake_generator: Ninja
             use_ccache: 1
-            xcode: "16.4"
+            ccache_eviction_age: 7d
 
           - os: macOS
             target: 15
             runner: macos-15
-            
-            ccache_eviction_age: 7d
-            cmake_generator: Ninja
+            soc: Apple
+            xcode: "16.4"
+            type: Debug
             qt_version: 6.11.0
             qt_arch: clang_64
             qt_modules: qtimageformats qtmultimedia qtwebsockets
-            soc: Apple
-            type: Debug
+            cmake_generator: Ninja
             use_ccache: 1
-            xcode: "16.4"
+            ccache_eviction_age: 7d
 
           - os: Windows
             target: 10
             runner: windows-2025
-            
-            cmake_generator: "Visual Studio 18 2026"
-            cmake_generator_platform: x64
+            type: Release
             make_package: 1
             package_suffix: "-Win10"
             qt_version: 6.11.0
             qt_arch: win64_msvc2022_64
             qt_modules: qtimageformats qtmultimedia qtwebsockets
-            type: Release
+            cmake_generator: "Visual Studio 17 2022"
+            cmake_generator_platform: x64
 
-    name: ${{ matrix.os }} ${{ matrix.target }}${{ matrix.soc == 'Intel' && ' Intel' || '' }}${{ matrix.type == 'Debug' && ' Debug' || '' }}
+    name: ${{matrix.os}} ${{matrix.target}}${{ matrix.soc == 'Intel' && ' Intel' || '' }}${{ matrix.type == 'Debug' && ' Debug' || '' }}
     needs: configure
-    runs-on: ${{ matrix.runner }}
+    runs-on: ${{matrix.runner}}
     timeout-minutes: 100
     env:
-      CCACHE_DIR: ${{ github.workspace }}/.cache/
-      CCACHE_SIZE: 550M    # space of all repo is 10Gi: https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#usage-limits-and-eviction-policy
+      CCACHE_DIR: ${{github.workspace}}/.cache/
+      # Cache size over the entire repo is 10Gi:
+      # https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#usage-limits-and-eviction-policy
+      CCACHE_SIZE: 550M
 
     steps:
-      - name: "Checkout"
+      - name: Checkout
         uses: actions/checkout@v6
         with:
           submodules: recursive
 
-      - name: "[Windows] Add msbuild to PATH"
+      - name: Add msbuild to PATH
         if: matrix.os == 'Windows'
         id: add-msbuild
         uses: microsoft/setup-msbuild@v3
         with:
           msbuild-architecture: x64
 
-      - name: "[macOS] Setup ccache"
-        if: matrix.os == 'macOS' && matrix.use_ccache == 1
+      - name: Setup ccache
+        if: matrix.use_ccache == 1 && matrix.os == 'macOS'
         run: brew install ccache
 
-      - name: "[macOS] Restore compiler cache (ccache)"
-        if: matrix.os == 'macOS' && matrix.use_ccache == 1
+      - name: Restore compiler cache (ccache)
+        if: matrix.use_ccache == 1
         id: ccache_restore
         uses: actions/cache/restore@v5
         env:
           BRANCH_NAME: ${{ github.head_ref || github.ref_name }}
         with:
-          key: ccache-${{ matrix.runner }}-${{ matrix.soc }}-${{ matrix.type }}-${{ env.BRANCH_NAME }}
-          path: ${{ env.CCACHE_DIR }}
-          restore-keys: ccache-${{ matrix.runner }}-${{ matrix.soc }}-${{ matrix.type }}-
+          path: ${{env.CCACHE_DIR}}
+          key: ccache-${{matrix.runner}}-${{matrix.soc}}-${{matrix.type}}-${{env.BRANCH_NAME}}
+          restore-keys: ccache-${{matrix.runner}}-${{matrix.soc}}-${{matrix.type}}-
 
-      - name: "Install aqtinstall"
+      - name: Install aqtinstall
         run: pipx install aqtinstall
 
       # Resolve given wildcard versions (e.g. Qt 6.6.*) to latest version via aqtinstall to avoid stale caches on new releases
-      - name: "Resolve latest Qt patch version"
+      - name: Resolve latest Qt patch version
         id: resolve_qt_version
         shell: bash
-        run: .ci/resolve_latest_aqt_qt_version.sh "${{ matrix.qt_version }}"
+        run: .ci/resolve_latest_aqt_qt_version.sh "${{matrix.qt_version}}"
 
-      - name: "[macOS] Restore thin Qt ${{ steps.resolve_qt_version.outputs.version }} libraries"
+      - name: Restore thin Qt ${{ steps.resolve_qt_version.outputs.version }} libraries (${{ matrix.soc }} macOS)
         if: matrix.os == 'macOS'
         id: restore_qt
         uses: actions/cache/restore@v5
         with:
-          key: thin-qt-macos-${{ matrix.soc }}-${{ steps.resolve_qt_version.outputs.version }}
           path: ${{ github.workspace }}/Qt
+          key: thin-qt-macos-${{ matrix.soc }}-${{ steps.resolve_qt_version.outputs.version }}
 
       # Using jurplel/install-qt-action to install Qt without using brew
-      # Qt build using vcpkg either just fails or takes too long to build
-      - name: "[macOS] Install fat Qt ${{ steps.resolve_qt_version.outputs.version }}"
+      # qt build using vcpkg either just fails or takes too long to build
+      - name: Install fat Qt ${{ steps.resolve_qt_version.outputs.version }} (${{ matrix.soc }} macOS)
         if: matrix.os == 'macOS' && steps.restore_qt.outputs.cache-hit != 'true'
         uses: jurplel/install-qt-action@v4
         with:
-          arch: ${{ matrix.qt_arch }}
-          cache: false
-          dir: ${{ github.workspace }}
-          modules: ${{ matrix.qt_modules }}
           version: ${{ steps.resolve_qt_version.outputs.version }}
+          arch: ${{matrix.qt_arch}}
+          modules: ${{matrix.qt_modules}}
+          cache: false
+          dir: ${{github.workspace}}
 
-      - name: "[macOS] Create thin Qt libraries"
+      - name: Thin Qt libraries (${{ matrix.soc }} macOS)
         if: matrix.os == 'macOS' && steps.restore_qt.outputs.cache-hit != 'true'
         run: .ci/thin_macos_qtlib.sh
 
-      - name: "[macOS] Cache thin Qt libraries"
+      - name: Cache thin Qt libraries (${{ matrix.soc }} macOS)
         if: matrix.os == 'macOS' && steps.restore_qt.outputs.cache-hit != 'true'
         uses: actions/cache/save@v5
         with:
-          key: thin-qt-macos-${{ matrix.soc }}-${{ steps.resolve_qt_version.outputs.version }}
           path: ${{ github.workspace }}/Qt
+          key: thin-qt-macos-${{ matrix.soc }}-${{ steps.resolve_qt_version.outputs.version }}
 
-      - name: "[Windows] Install Qt ${{ matrix.qt_version }}"
+      - name: Install Qt ${{matrix.qt_version}} (Windows)
         if: matrix.os == 'Windows'
         uses: jurplel/install-qt-action@v4
         with:
-          # Qt 6.11.0 only works with aqtinstall directly from git until aqtinstall 3.4 is released
+          # qt 6.11.0 only works with aqtinstall directly from git until aqtinstall 3.4 is released
           aqtsource: git+https://github.com/miurahr/aqtinstall.git
-          arch: ${{ matrix.qt_arch }}
-          cache: true
-          modules: ${{ matrix.qt_modules }}
           version: ${{ steps.resolve_qt_version.outputs.version }}
+          arch: ${{matrix.qt_arch}}
+          modules: ${{matrix.qt_modules}}
+          cache: true
 
-      - name: "[Windows] Install NSIS"
+      - name: Install NSIS
         if: matrix.os == 'Windows'
         shell: bash
         run: choco install nsis
 
-      - name: "Setup vcpkg cache"
+      - name: Setup vcpkg cache
         id: vcpkg-cache
         uses: TAServers/vcpkg-cache@v3
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
 
-      # Uses environment variables, see compile.sh for more details
-      - name: "Build Cockatrice"
+      # uses environment variables, see compile.sh for more details
+      - name: Build Cockatrice
         id: build
         shell: bash
         env:
-          BUILDTYPE: '${{ matrix.type }}'
-          CCACHE_EVICTION_AGE: ${{ matrix.ccache_eviction_age }}
-          CMAKE_GENERATOR: ${{ matrix.cmake_generator }}
-          CMAKE_GENERATOR_PLATFORM: ${{ matrix.cmake_generator_platform }}
-          DEVELOPER_DIR: '/Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer'
-          MACOS_CERTIFICATE: ${{ secrets.PROD_MACOS_CERTIFICATE }}
-          MACOS_CERTIFICATE_NAME: ${{ secrets.PROD_MACOS_CERTIFICATE_NAME }}
-          MACOS_CERTIFICATE_PWD: ${{ secrets.PROD_MACOS_CERTIFICATE_PWD }}
-          MACOS_CI_KEYCHAIN_PWD: ${{ secrets.PROD_MACOS_CI_KEYCHAIN_PWD }}
-          MAKE_PACKAGE: '${{ matrix.make_package }}'
-          PACKAGE_SUFFIX: '${{ matrix.package_suffix }}'
-          TARGET_MACOS_VERSION: ${{ matrix.override_target }}
-          USE_CCACHE: ${{ matrix.use_ccache }}
-          VCPKG_BINARY_SOURCES: 'clear;files,${{ steps.vcpkg-cache.outputs.path }},readwrite'
+          BUILDTYPE: '${{matrix.type}}'
+          MAKE_PACKAGE: '${{matrix.make_package}}'
+          PACKAGE_SUFFIX: '${{matrix.package_suffix}}'
+          CMAKE_GENERATOR: ${{matrix.cmake_generator}}
+          CMAKE_GENERATOR_PLATFORM: ${{matrix.cmake_generator_platform}}
+          USE_CCACHE: ${{matrix.use_ccache}}
           VCPKG_DISABLE_METRICS: 1
+          VCPKG_BINARY_SOURCES: 'clear;files,${{ steps.vcpkg-cache.outputs.path }},readwrite'
+          # macOS-specific environment variables, will be ignored on Windows
+          MACOS_CERTIFICATE: ${{ secrets.PROD_MACOS_CERTIFICATE }}
+          MACOS_CERTIFICATE_PWD: ${{ secrets.PROD_MACOS_CERTIFICATE_PWD }}
+          MACOS_CERTIFICATE_NAME: ${{ secrets.PROD_MACOS_CERTIFICATE_NAME }}
+          MACOS_CI_KEYCHAIN_PWD: ${{ secrets.PROD_MACOS_CI_KEYCHAIN_PWD }}
+          DEVELOPER_DIR: '/Applications/Xcode_${{matrix.xcode}}.app/Contents/Developer'
+          TARGET_MACOS_VERSION: ${{ matrix.override_target }}
+          CCACHE_EVICTION_AGE: ${{ matrix.ccache_eviction_age }}
         run: .ci/compile.sh --server --test --vcpkg
 
       # Delete used cache to emulate a ccache update. See https://github.com/actions/cache/issues/342
-      - name: "[macOS] Delete remote compiler cache (ccache)"
-        if: matrix.os == 'macOS' && matrix.use_ccache == 1 && github.ref == 'refs/heads/master' && steps.ccache_restore.outputs.cache-hit
+      - name: Delete remote compiler cache (ccache)
+        if: github.ref == 'refs/heads/master' && matrix.use_ccache == 1 && steps.ccache_restore.outputs.cache-hit
         continue-on-error: true
         env:
           GH_TOKEN: ${{ github.token }}
@@ -471,14 +465,14 @@ jobs:
             echo "Cache deleted successfully"
           fi
 
-      - name: "[macOS] Save updated compiler cache (ccache)"
-        if: matrix.os == 'macOS' && matrix.use_ccache == 1 && github.ref == 'refs/heads/master'
+      - name: Save updated compiler cache (ccache)
+        if: github.ref == 'refs/heads/master' && matrix.use_ccache == 1
         uses: actions/cache/save@v5
         with:
+          path: ${{env.CCACHE_DIR}}
           key: ${{ steps.ccache_restore.outputs.cache-primary-key }}
-          path: ${{ env.CCACHE_DIR }}
 
-      - name: "[macOS] Sign app bundle"
+      - name: Sign app bundle
         if: matrix.os == 'macOS' && matrix.make_package && needs.configure.outputs.tag != null
         id: sign_macos
         env:
@@ -488,15 +482,15 @@ jobs:
           if [[ -n "$MACOS_CERTIFICATE_NAME" ]]
           then
             security unlock-keychain -p "$MACOS_CI_KEYCHAIN_PWD" build.keychain
-            /usr/bin/codesign --sign="$MACOS_CERTIFICATE_NAME" --entitlements=".ci/macos.entitlements" --options=runtime --force --deep --timestamp --verbose "${{ steps.build.outputs.path }}"
+            /usr/bin/codesign --sign="$MACOS_CERTIFICATE_NAME" --entitlements=".ci/macos.entitlements" --options=runtime --force --deep --timestamp --verbose "${{steps.build.outputs.path}}"
           fi
 
-      - name: "[macOS] Notarize app bundle"
-        if: matrix.os == 'macOS' && steps.sign_macos.outcome == 'success'
+      - name: Notarize app bundle
+        if: steps.sign_macos.outcome == 'success'
         env:
           MACOS_NOTARIZATION_APPLE_ID: ${{ secrets.PROD_MACOS_NOTARIZATION_APPLE_ID }}
-          MACOS_NOTARIZATION_PWD: ${{ secrets.PROD_MACOS_NOTARIZATION_PWD }}
           MACOS_NOTARIZATION_TEAM_ID: ${{ secrets.PROD_MACOS_NOTARIZATION_TEAM_ID }}
+          MACOS_NOTARIZATION_PWD: ${{ secrets.PROD_MACOS_NOTARIZATION_PWD }}
         run: |
           if [[ -n "$MACOS_NOTARIZATION_APPLE_ID" ]]
           then
@@ -508,7 +502,7 @@ jobs:
             # Therefore, we create a zip file containing our app bundle, so that we can send it to the
             # notarization service
             echo "Creating temp notarization archive"
-            ditto -c -k --keepParent "${{ steps.build.outputs.path }}" "notarization.zip"
+            ditto -c -k --keepParent "${{steps.build.outputs.path}}" "notarization.zip"
 
             # Here we send the notarization request to the Apple's Notarization service, waiting for the result.
             # This typically takes a few seconds inside a CI environment, but it might take more depending on the App
@@ -520,51 +514,51 @@ jobs:
             # Finally, we need to "attach the staple" to our executable, which will allow our app to be
             # validated by macOS even when an internet connection is not available.
             echo "Attach staple"
-            xcrun stapler staple "${{ steps.build.outputs.path }}"
+            xcrun stapler staple "${{steps.build.outputs.path}}"
           fi
 
-      - name: "Upload artifact"
+      - name: Upload artifact
         if: matrix.make_package
         id: upload_artifact
         uses: actions/upload-artifact@v7
         with:
+          path: ${{steps.build.outputs.path}}
           archive: false
           if-no-files-found: error
-          path: ${{ steps.build.outputs.path }}
 
-      - name: "[Windows] Upload PDBs (Program Databases)"
+      - name: Upload PDBs (Program Databases)
         if: matrix.os == 'Windows' && github.ref_type != 'tag'
         uses: actions/upload-artifact@v7
         with:
-          if-no-files-found: error
-          name: ${{ steps.build.outputs.name }}-PDBs
+          name: ${{steps.build.outputs.name}}-PDBs
           path: |
             build/cockatrice/Release/*.pdb
             build/oracle/Release/*.pdb
             build/servatrice/Release/*.pdb
+          if-no-files-found: error
 
-      - name: "Upload to release"
+      - name: Upload to release
         if: needs.configure.outputs.tag != null && matrix.make_package == '1'
         id: upload_release
         shell: bash
         env:
-          asset_name: ${{ steps.build.outputs.fullname }}
-          asset_path: ${{ steps.build.outputs.path }}
-          GH_TOKEN: ${{ github.token }}
-          tag_name: ${{ needs.configure.outputs.tag }}
+          GH_TOKEN: ${{github.token}}
+          tag_name: ${{needs.configure.outputs.tag}}
+          asset_name: ${{steps.build.outputs.fullname}}
+          asset_path: ${{steps.build.outputs.path}}
         run: gh release upload "$tag_name" "$asset_path#$asset_name"
 
-      - name: "Attest binary provenance"
+      - name: Attest binary provenance
         if: steps.upload_release.outcome == 'success'
         id: attestation
         uses: actions/attest@v4
         with:
+          subject-path: ${{steps.build.outputs.path}}
           show-summary: false
-          subject-path: ${{ steps.build.outputs.path }}
 
-      - name: "Verify binary attestation"
+      - name: Verify binary attestation
         if: steps.attestation.outcome == 'success'
         shell: bash
         env:
-          GH_TOKEN: ${{ github.token }}
-        run: gh attestation verify "${{ steps.build.outputs.path }}" --repo Cockatrice/Cockatrice
+          GH_TOKEN: ${{github.token}}
+        run: gh attestation verify "${{steps.build.outputs.path}}" --repo Cockatrice/Cockatrice

.github/workflows/desktop-lint.yml

@@ -1,7 +1,7 @@
 name: Code Style (C++) 
 
 on:
-  # Push trigger not needed for linting, we do not allow direct pushes to master
+  # push trigger not needed for linting, we do not allow direct pushes to master
   pull_request:
     paths:
       - '*/**'    # matches all files not in root
@@ -21,20 +21,17 @@ jobs:
     runs-on: ubuntu-slim
 
     steps:
-    - name: "Checkout"
+    - name: Checkout
       uses: actions/checkout@v6
       with:
         fetch-depth: 20    # should be enough to find merge base
 
-    - name: "Install dependencies"
+    - name: Install dependencies
       shell: bash
       run: |
         sudo apt-get update
-        sudo apt-get install -y --no-install-recommends \
-          clang-format \
-          cmake-format \
-          shellcheck
+        sudo apt-get install -y --no-install-recommends clang-format cmake-format shellcheck
 
-    - name: "Check code formatting"
+    - name: Check code formatting
       shell: bash
       run: ./.ci/lint_cpp.sh

.github/workflows/docker-release.yml

@@ -1,10 +1,9 @@
 name: Build Docker Image
 
-permissions:
-  contents: read
-  packages: write
-
 on:
+  release:
+    types:
+      - released    # publishing of stable releases
   push:
     branches:
       - master
@@ -14,9 +13,6 @@ on:
     paths:
       - '.github/workflows/docker-release.yml'
       - 'Dockerfile'
-  release:
-    types:
-      - released    # publishing of stable releases
 
 # Cancel earlier, unfinished runs of this workflow on the same branch (unless on release)
 concurrency:
@@ -28,50 +24,54 @@ jobs:
     name: amd64 & arm64
     if: ${{ github.repository_owner == 'Cockatrice' }}
     runs-on: ubuntu-latest
+
+    permissions:
+      contents: read
+      packages: write
   
     steps:
-      - name: "Checkout"
+      - name: Checkout
         uses: actions/checkout@v6
 
-      - name: "Docker metadata"
+      - name: Docker metadata
         id: metadata
         uses: docker/metadata-action@v6
         env:
           DOCKER_METADATA_ANNOTATIONS_LEVELS: index    # needed for GHCR
         with:
-          annotations: |
-            org.opencontainers.image.title=Servatrice
-            org.opencontainers.image.url=https://cockatrice.github.io/
-            org.opencontainers.image.description=Server for Cockatrice, a cross-platform virtual tabletop for multiplayer card games
           images: |
             ghcr.io/cockatrice/servatrice
           labels: |
             org.opencontainers.image.title=Servatrice
             org.opencontainers.image.url=https://cockatrice.github.io/
             org.opencontainers.image.description=Server for Cockatrice, a cross-platform virtual tabletop for multiplayer card games
+          annotations: |
+            org.opencontainers.image.title=Servatrice
+            org.opencontainers.image.url=https://cockatrice.github.io/
+            org.opencontainers.image.description=Server for Cockatrice, a cross-platform virtual tabletop for multiplayer card games  
 
-      - name: "Set up QEMU"
+      - name: Set up QEMU
         uses: docker/setup-qemu-action@v4
 
-      - name: "Set up Docker buildx"
+      - name: Set up Docker buildx
         uses: docker/setup-buildx-action@v4
 
-      - name: "Login to GitHub Container Registry"
+      - name: Login to GitHub Container Registry
         if: contains(github.event.release.tag_name, 'Release') && github.event.release.target_commitish == 'master'
         uses: docker/login-action@v4
         with:
-          password: ${{ github.token }}
           registry: ghcr.io
           username: ${{ github.actor }}
+          password: ${{ github.token }}
 
-      - name: "Build and push Docker image"
+      - name: Build and push Docker image
         uses: docker/build-push-action@v7
         with:
-          annotations: ${{ steps.metadata.outputs.annotations }}
-          cache-from: type=gha,scope=servatrice
-          cache-to: type=gha,mode=max,scope=servatrice
           context: .
-          labels: ${{ steps.metadata.outputs.labels }}
           platforms: linux/amd64,linux/arm64
           push: ${{ github.ref_type == 'tag' }}
           tags: ${{ steps.metadata.outputs.tags }}
+          labels: ${{ steps.metadata.outputs.labels }}
+          annotations: ${{ steps.metadata.outputs.annotations }}
+          cache-from: type=gha,scope=servatrice
+          cache-to: type=gha,mode=max,scope=servatrice

.github/workflows/documentation-build.yml

@@ -1,18 +1,18 @@
 name: Generate Docs
 
 on:
+  release:
+    types:
+      - published    # publishing of stable releases and pre-releases
   pull_request:
     paths:
       - 'doc/doxygen/**'
       - '.github/workflows/documentation-build.yml'
       - 'Doxyfile'
-  release:
-    types:
-      - published    # publishing of stable releases and pre-releases
   workflow_dispatch:
 
 env:
-  COCKATRICE_REF: ${{ github.ref_name }}    # tag name if the commit is tagged, otherwise branch name
+  COCKATRICE_REF: ${{ github.ref_name }}    # Tag name if the commit is tagged, otherwise branch name
 
 jobs:
   docs:
@@ -20,22 +20,22 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - name: "Checkout code"
+      - name: Checkout code
         uses: actions/checkout@v6
         with:
           submodules: recursive
 
-      - name: "Install Graphviz"
+      - name: Install Graphviz
         run: |
           sudo apt-get install -y graphviz
           dot -V
 
-      - name: "Install Doxygen"
+      - name: Install Doxygen
         uses: ssciwr/doxygen-install@v2
         with:
           version: "1.16.1"
 
-      - name: "Update Doxygen Configuration"
+      - name: Update Doxygen Configuration
         run: |
           git diff Doxyfile
           doxygen -u Doxyfile
@@ -48,16 +48,16 @@ jobs:
             exit 1
           fi
 
-      - name: "Generate Documentation"
+      - name: Generate Documentation
         if: always()
         run: doxygen Doxyfile
 
-      - name: "Deploy to cockatrice.github.io"
+      - name: Deploy to cockatrice.github.io
         if: github.event_name == 'release' || github.event_name == 'workflow_dispatch'
         uses: peaceiris/actions-gh-pages@v4
         with:
           deploy_key: ${{ secrets.DOCS_DEPLOY_KEY }}
-          destination_dir: docs    # docs will be available at https://cockatrice.github.io/docs/
           external_repository: Cockatrice/cockatrice.github.io
           publish_branch: master
           publish_dir: ./docs/html
+          destination_dir: docs    # Docs will live under https://cockatrice.github.io/docs/

.github/workflows/translations-pull.yml

@@ -1,14 +1,14 @@
 name: Update Translations
 
 on:
+  workflow_dispatch:
+  schedule:
+    # runs in the middle of each month starting a quarter (UTC) = two weeks after new strings are built
+    - cron: '0 0 15 1,4,7,10 *'
   pull_request:
     paths:
       - '.tx/**'
       - '.github/workflows/translations-pull.yml'
-  schedule:
-    # Runs in the middle of each month starting a quarter (UTC) = two weeks after new strings are built
-    - cron: '0 0 15 1,4,7,10 *'
-  workflow_dispatch:
 
 jobs:
   translations:
@@ -19,18 +19,18 @@ jobs:
     runs-on: ubuntu-slim
 
     steps:
-      - name: "Checkout repo"
+      - name: Checkout repo
         uses: actions/checkout@v6
 
-      - name: "Pull translated strings from Transifex"
+      - name: Pull translated strings from Transifex
         uses: transifex/cli-action@v2
         with:
-          # Used config file: https://github.com/Cockatrice/Cockatrice/blob/master/.tx/config
-          # Docs: https://github.com/transifex/cli#pulling-files-from-transifex
-          args: pull --force --all
+          # used config file: https://github.com/Cockatrice/Cockatrice/blob/master/.tx/config
+          # https://github.com/transifex/cli#pulling-files-from-transifex
           token: ${{ secrets.TX_TOKEN }}
+          args: pull --force --all
 
-      - name: "Create pull request"
+      - name: Create pull request
         if: github.event_name != 'pull_request'
         id: create_pr
         uses: peter-evans/create-pull-request@v8
@@ -38,7 +38,12 @@ jobs:
           add-paths: |
             cockatrice/translations/*.ts
             oracle/translations/*.ts
-          author: github-actions <github-actions@github.com>    # owner of the commit
+          commit-message: Update translation files
+          # author is the owner of the commit
+          author: github-actions <github-actions@github.com>
+          branch: ci-update_translations
+          delete-branch: true
+          title: 'Update translations'
           body: |
             Pulled all translated strings from [Transifex][1].
             
@@ -48,16 +53,12 @@ jobs:
             
             [1]: https://explore.transifex.com/cockatrice/cockatrice/
             [2]: https://github.com/Cockatrice/Cockatrice/actions/workflows/translations-pull.yml?query=branch%3Amaster
-          branch: ci-update_translations
-          commit-message: Update translation files
-          delete-branch: true
-          draft: false
           labels: |
             CI
             Translation
-          title: 'Update translations'
+          draft: false
 
-      - name: "PR Status"
+      - name: PR Status
         if: github.event_name != 'pull_request'
         shell: bash
         env:

.github/workflows/translations-push.yml

@@ -1,14 +1,14 @@
 name: Update Translation Source
 
 on:
+  workflow_dispatch:
+  schedule:
+    # runs at the start of each quarter (UTC)
+    - cron: '0 0 1 1,4,7,10 *'
   pull_request:
     paths:
       - '.ci/update_translation_source_strings.sh'
       - '.github/workflows/translations-push.yml'
-  schedule:
-    # Runs at the start of each quarter (UTC)
-    - cron: '0 0 1 1,4,7,10 *'
-  workflow_dispatch:
 
 jobs:
   translations:
@@ -19,16 +19,16 @@ jobs:
     runs-on: ubuntu-slim
 
     steps:
-      - name: "Checkout repo"
+      - name: Checkout repo
         uses: actions/checkout@v6
 
-      - name: "Install lupdate"
+      - name: Install lupdate
         shell: bash
         run: |
           sudo apt-get update
           sudo apt-get install -y --no-install-recommends qttools5-dev-tools
 
-      - name: "Update Cockatrice translation source"
+      - name: Update Cockatrice translation source
         id: cockatrice
         shell: bash
         run: |
@@ -36,15 +36,15 @@ jobs:
           export DIRS="cockatrice/src $(find . -maxdepth 1 -type d -name 'libcockatrice_*')"
           FILE="$FILE" DIRS="$DIRS" .ci/update_translation_source_strings.sh
 
-      - name: "Update Oracle translation source"
+      - name: Update Oracle translation source
         id: oracle
         shell: bash
         env:
-          DIRS: 'oracle/src'
           FILE: 'oracle/oracle_en@source.ts'
+          DIRS: 'oracle/src'
         run: .ci/update_translation_source_strings.sh
 
-      - name: "Render template"
+      - name: Render template
         id: template
         uses: chuhlomin/render-template/binary@v1
         with:
@@ -54,7 +54,7 @@ jobs:
             oracle_output: ${{ steps.oracle.outputs.output }}
             commit: ${{ github.sha }}
 
-      - name: "Create pull request"
+      - name: Create pull request
         if: github.event_name != 'pull_request'
         id: create_pr
         uses: peter-evans/create-pull-request@v8
@@ -62,18 +62,19 @@ jobs:
           add-paths: |
             cockatrice/cockatrice_en@source.ts
             oracle/oracle_en@source.ts
-          author: github-actions <github-actions@github.com>    # owner of the commit
-          body: ${{ steps.template.outputs.result }}
-          branch: ci-update_translation_source
           commit-message: Update translation source strings
+          # author is the owner of the commit
+          author: github-actions <github-actions@github.com>
+          branch: ci-update_translation_source
           delete-branch: true
-          draft: false
+          title: 'Update source strings'
+          body: ${{ steps.template.outputs.result }}
           labels: |
             CI
             Translation
-          title: 'Update source strings'
+          draft: false
 
-      - name: "PR Status"
+      - name: PR Status
         if: github.event_name != 'pull_request'
         shell: bash
         env:

cmake/NSIS.template.in

@@ -117,22 +117,21 @@ ${If} $InstDir == ""
     ; we need to set a default based on the install mode
     StrCpy $InstDir $0
 ${EndIf}
+Call SetModeDestinationFromInstdir
 
-; --- Detect portable install when using /R (must come BEFORE SetModeDestinationFromInstdir) ---
+; --- Detect portable install when using /R ---
 ${If} $ReinstallMode = 1
     IfFileExists "$InstDir\portable.dat" 0 not_portable
         StrCpy $PortableMode 1
         Goto portable_done
+
     not_portable:
         StrCpy $PortableMode 0
+
     portable_done:
 ${EndIf}
 
-; Now that $PortableMode reflects reality, commit InstDir into the correct slot
-Call SetModeDestinationFromInstdir
-
 ${If} $ReinstallMode = 1
-${AndIf} $PortableMode = 0
     Call AutoUninstallIfNeeded
 ${EndIf}
 

cockatrice/CMakeLists.txt

@@ -56,58 +56,56 @@ set(cockatrice_SOURCES
     src/filters/filter_tree_model.cpp
     src/filters/syntax_help.cpp
     src/game/abstract_game.cpp
-    src/game/arrow_registry.cpp
-    src/game_graphics/board/abstract_card_drag_item.cpp
-    src/game_graphics/board/abstract_card_item.cpp
-    src/game_graphics/board/abstract_counter.cpp
+    src/game/board/abstract_card_drag_item.cpp
+    src/game/board/abstract_card_item.cpp
+    src/game/board/abstract_counter.cpp
     src/game/board/arrow_data.cpp
-    src/game_graphics/board/arrow_item.cpp
-    src/game_graphics/board/arrow_target.cpp
-    src/game_graphics/board/card_drag_item.cpp
-    src/game_graphics/board/card_item.cpp
+    src/game/board/arrow_item.cpp
+    src/game/board/arrow_target.cpp
+    src/game/board/card_drag_item.cpp
+    src/game/board/card_item.cpp
     src/game/board/card_list.cpp
     src/game/board/card_state.cpp
-    src/game_graphics/board/counter_general.cpp
+    src/game/board/counter_general.cpp
     src/game/board/counter_state.cpp
-    src/game_graphics/board/translate_counter_name.cpp
-    src/game_graphics/deckview/deck_view.cpp
-    src/game_graphics/deckview/deck_view_container.cpp
-    src/game_graphics/deckview/tabbed_deck_view_container.cpp
-    src/game_graphics/dialogs/dlg_create_token.cpp
-    src/game_graphics/dialogs/dlg_move_top_cards_until.cpp
-    src/game_graphics/dialogs/dlg_roll_dice.cpp
+    src/game/board/translate_counter_name.cpp
+    src/game/deckview/deck_view.cpp
+    src/game/deckview/deck_view_container.cpp
+    src/game/deckview/tabbed_deck_view_container.cpp
+    src/game/dialogs/dlg_create_token.cpp
+    src/game/dialogs/dlg_move_top_cards_until.cpp
+    src/game/dialogs/dlg_roll_dice.cpp
     src/game/game.cpp
     src/game/game_event_handler.cpp
     src/game/game_meta_info.cpp
-    src/game_graphics/game_scene.cpp
+    src/game/game_scene.cpp
     src/game/game_state.cpp
-    src/game_graphics/game_view.cpp
-    src/game_graphics/hand_counter.cpp
-    src/game_graphics/log/message_log_widget.cpp
+    src/game/game_view.cpp
+    src/game/hand_counter.cpp
+    src/game/log/message_log_widget.cpp
     src/game/phase.cpp
-    src/game_graphics/phases_toolbar.cpp
-    src/game_graphics/player/menu/card_menu.cpp
-    src/game_graphics/player/menu/custom_zone_menu.cpp
-    src/game_graphics/player/menu/grave_menu.cpp
-    src/game_graphics/player/menu/hand_menu.cpp
-    src/game_graphics/player/menu/library_menu.cpp
-    src/game_graphics/player/menu/move_menu.cpp
-    src/game_graphics/player/menu/player_menu.cpp
-    src/game_graphics/player/menu/pt_menu.cpp
-    src/game_graphics/player/menu/rfg_menu.cpp
-    src/game_graphics/player/menu/say_menu.cpp
-    src/game_graphics/player/menu/sideboard_menu.cpp
-    src/game_graphics/player/menu/utility_menu.cpp
+    src/game/phases_toolbar.cpp
+    src/game/player/menu/card_menu.cpp
+    src/game/player/menu/custom_zone_menu.cpp
+    src/game/player/menu/grave_menu.cpp
+    src/game/player/menu/hand_menu.cpp
+    src/game/player/menu/library_menu.cpp
+    src/game/player/menu/move_menu.cpp
+    src/game/player/menu/player_menu.cpp
+    src/game/player/menu/pt_menu.cpp
+    src/game/player/menu/rfg_menu.cpp
+    src/game/player/menu/say_menu.cpp
+    src/game/player/menu/sideboard_menu.cpp
+    src/game/player/menu/utility_menu.cpp
     src/game/player/player_actions.cpp
-    src/game_graphics/player/player_area.cpp
-    src/game_graphics/player/player_dialogs.cpp
+    src/game/player/player_area.cpp
     src/game/player/player_event_handler.cpp
-    src/game_graphics/player/player_graphics_item.cpp
+    src/game/player/player_graphics_item.cpp
     src/game/player/player_info.cpp
-    src/game_graphics/player/player_list_widget.cpp
+    src/game/player/player_list_widget.cpp
     src/game/player/player_logic.cpp
     src/game/player/player_manager.cpp
-    src/game_graphics/player/player_target.cpp
+    src/game/player/player_target.cpp
     src/game/replay.cpp
     src/game/zones/card_zone_logic.cpp
     src/game/zones/hand_zone_logic.cpp
@@ -183,7 +181,6 @@ set(cockatrice_SOURCES
     src/interface/widgets/deck_analytics/analyzer_modules/mana_distribution/mana_distribution_single_display_widget.cpp
     src/interface/widgets/deck_analytics/analyzer_modules/mana_curve/mana_curve_total_widget.cpp
     src/interface/widgets/deck_analytics/analyzer_modules/mana_curve/mana_curve_category_widget.cpp
-    src/interface/widgets/deck_editor/card_database_view.cpp
     src/interface/widgets/deck_editor/deck_list_history_manager_widget.cpp
     src/interface/widgets/deck_editor/deck_editor_card_database_dock_widget.cpp
     src/interface/widgets/deck_editor/deck_editor_card_info_dock_widget.cpp

cockatrice/src/client/network/interfaces/deck_stats_interface.cpp

@@ -6,12 +6,12 @@
 #include <QNetworkRequest>
 #include <QRegularExpression>
 #include <QUrlQuery>
-#include <libcockatrice/card/database/card_database_manager.h>
 #include <libcockatrice/deck_list/deck_list.h>
 #include <libcockatrice/deck_list/tree/deck_list_card_node.h>
 #include <version_string.h>
 
-DeckStatsInterface::DeckStatsInterface(QObject *parent) : QObject(parent)
+DeckStatsInterface::DeckStatsInterface(CardDatabase &_cardDatabase, QObject *parent)
+    : QObject(parent), cardDatabase(_cardDatabase)
 {
     manager = new QNetworkAccessManager(this);
     connect(manager, &QNetworkAccessManager::finished, this, &DeckStatsInterface::queryFinished);
@@ -70,8 +70,8 @@ void DeckStatsInterface::analyzeDeck(const DeckList &deck)
 
 void DeckStatsInterface::copyDeckWithoutTokens(const DeckList &source, DeckList &destination)
 {
-    auto copyIfNotAToken = [&destination](const auto node, const auto card) {
-        CardInfoPtr dbCard = CardDatabaseManager::query()->getCardInfo(card->getName());
+    auto copyIfNotAToken = [this, &destination](const auto node, const auto card) {
+        CardInfoPtr dbCard = cardDatabase.query()->getCardInfo(card->getName());
         if (dbCard && !dbCard->getIsToken()) {
             DecklistCardNode *addedCard = destination.addCard(card->getName(), node->getName(), -1);
             addedCard->setNumber(card->getNumber());

cockatrice/src/client/network/interfaces/deck_stats_interface.h

@@ -7,6 +7,7 @@
 #ifndef DECKSTATS_INTERFACE_H
 #define DECKSTATS_INTERFACE_H
 
+#include <libcockatrice/card/database/card_database.h>
 #include <libcockatrice/deck_list/deck_list.h>
 
 class QByteArray;
@@ -20,6 +21,8 @@ class DeckStatsInterface : public QObject
 private:
     QNetworkAccessManager *manager;
 
+    CardDatabase &cardDatabase;
+
     /**
      * Deckstats doesn't recognize token cards, and instead tries to find the
      * closest non-token card instead. So we construct a new deck which has no
@@ -32,7 +35,7 @@ private slots:
     void getAnalyzeRequestData(const DeckList &deck, QByteArray &data);
 
 public:
-    explicit DeckStatsInterface(QObject *parent = nullptr);
+    explicit DeckStatsInterface(CardDatabase &_cardDatabase, QObject *parent = nullptr);
     void analyzeDeck(const DeckList &deck);
 };
 

cockatrice/src/client/network/interfaces/tapped_out_interface.cpp

@@ -6,12 +6,12 @@
 #include <QNetworkRequest>
 #include <QRegularExpression>
 #include <QUrlQuery>
-#include <libcockatrice/card/database/card_database_manager.h>
 #include <libcockatrice/deck_list/deck_list.h>
 #include <libcockatrice/deck_list/tree/deck_list_card_node.h>
 #include <version_string.h>
 
-TappedOutInterface::TappedOutInterface(QObject *parent) : QObject(parent)
+TappedOutInterface::TappedOutInterface(CardDatabase &_cardDatabase, QObject *parent)
+    : QObject(parent), cardDatabase(_cardDatabase)
 {
     manager = new QNetworkAccessManager(this);
     connect(manager, &QNetworkAccessManager::finished, this, &TappedOutInterface::queryFinished);
@@ -97,8 +97,8 @@ void TappedOutInterface::analyzeDeck(const DeckList &deck)
 
 void TappedOutInterface::copyDeckSplitMainAndSide(const DeckList &source, DeckList &mainboard, DeckList &sideboard)
 {
-    auto copyMainOrSide = [&mainboard, &sideboard](const auto node, const auto card) {
-        CardInfoPtr dbCard = CardDatabaseManager::query()->getCardInfo(card->getName());
+    auto copyMainOrSide = [this, &mainboard, &sideboard](const auto node, const auto card) {
+        CardInfoPtr dbCard = cardDatabase.query()->getCardInfo(card->getName());
         if (!dbCard || dbCard->getIsToken()) {
             return;
         }

cockatrice/src/client/network/interfaces/tapped_out_interface.h

@@ -7,8 +7,8 @@
 #ifndef TAPPEDOUT_INTERFACE_H
 #define TAPPEDOUT_INTERFACE_H
 
-#include <QLoggingCategory>
-#include <QObject>
+#include <libcockatrice/card/database/card_database.h>
+#include <libcockatrice/deck_list/deck_list.h>
 
 inline Q_LOGGING_CATEGORY(TappedOutInterfaceLog, "tapped_out_interface");
 
@@ -29,13 +29,14 @@ class TappedOutInterface : public QObject
 private:
     QNetworkAccessManager *manager;
 
+    CardDatabase &cardDatabase;
     void copyDeckSplitMainAndSide(const DeckList &source, DeckList &mainboard, DeckList &sideboard);
 private slots:
     void queryFinished(QNetworkReply *reply);
     void getAnalyzeRequestData(const DeckList &deck, QByteArray &data);
 
 public:
-    explicit TappedOutInterface(QObject *parent = nullptr);
+    explicit TappedOutInterface(CardDatabase &_cardDatabase, QObject *parent = nullptr);
     void analyzeDeck(const DeckList &deck);
 };
 

cockatrice/src/client/settings/cache_settings.cpp

@@ -309,7 +309,6 @@ SettingsCache::SettingsCache()
     cardViewExpandedRowsMax = settings->value("interface/cardViewExpandedRowsMax", 20).toInt();
     closeEmptyCardView = settings->value("interface/closeEmptyCardView", true).toBool();
     focusCardViewSearchBar = settings->value("interface/focusCardViewSearchBar", true).toBool();
-    keepGameChatFocus = settings->value("interface/keepGameChatFocus", false).toBool();
 
     showDragSelectionCount = settings->value("interface/showlassoselectioncount", true).toBool();
     showTotalSelectionCount = settings->value("interface/showpersistentselectioncount", true).toBool();
@@ -389,7 +388,6 @@ SettingsCache::SettingsCache()
 
     ignoreUnregisteredUsers = settings->value("chat/ignore_unregistered", false).toBool();
     ignoreUnregisteredUserMessages = settings->value("chat/ignore_unregistered_messages", false).toBool();
-    ignoreNonBuddyUserMessages = settings->value("chat/ignore_nonbuddy_messages", false).toBool();
 
     scaleCards = settings->value("cards/scaleCards", true).toBool();
     verticalCardOverlapPercent = settings->value("cards/verticalCardOverlapPercent", 33).toInt();
@@ -458,13 +456,6 @@ void SettingsCache::setFocusCardViewSearchBar(QT_STATE_CHANGED_T value)
     settings->setValue("interface/focusCardViewSearchBar", focusCardViewSearchBar);
 }
 
-void SettingsCache::setKeepGameChatFocus(QT_STATE_CHANGED_T value)
-{
-    keepGameChatFocus = value;
-    settings->setValue("interface/keepGameChatFocus", keepGameChatFocus);
-    emit keepGameChatFocusChanged(keepGameChatFocus);
-}
-
 void SettingsCache::setKnownMissingFeatures(const QString &_knownMissingFeatures)
 {
     knownMissingFeatures = _knownMissingFeatures;
@@ -1126,12 +1117,6 @@ void SettingsCache::setIgnoreUnregisteredUserMessages(QT_STATE_CHANGED_T _ignore
     settings->setValue("chat/ignore_unregistered_messages", ignoreUnregisteredUserMessages);
 }
 
-void SettingsCache::setIgnoreNonBuddyUserMessages(QT_STATE_CHANGED_T _ignoreNonBuddyUserMessages)
-{
-    ignoreNonBuddyUserMessages = static_cast<bool>(_ignoreNonBuddyUserMessages);
-    settings->setValue("chat/ignore_nonbuddy_messages", ignoreNonBuddyUserMessages);
-}
-
 void SettingsCache::setPixmapCacheSize(const int _pixmapCacheSize)
 {
     pixmapCacheSize = _pixmapCacheSize;

cockatrice/src/client/settings/cache_settings.h

@@ -183,7 +183,6 @@ signals:
     void soundThemeChanged();
     void ignoreUnregisteredUsersChanged();
     void ignoreUnregisteredUserMessagesChanged();
-    void ignoreNonBuddyUserMessagesChanged();
     void pixmapCacheSizeChanged(int newSizeInMBs);
     void networkCacheSizeChanged(int newSizeInMBs);
     void redirectCacheTtlChanged(int newTtl);
@@ -195,7 +194,6 @@ signals:
     void downloadSpoilerStatusChanged();
     void useTearOffMenusChanged(bool state);
     void roundCardCornersChanged(bool roundCardCorners);
-    void keepGameChatFocusChanged(bool value);
 
 private:
     QSettings *settings;
@@ -296,7 +294,6 @@ private:
     QString soundThemeName;
     bool ignoreUnregisteredUsers;
     bool ignoreUnregisteredUserMessages;
-    bool ignoreNonBuddyUserMessages;
     QString picUrl;
     QString picUrlFallback;
     QString clientID;
@@ -307,7 +304,6 @@ private:
     int cardViewExpandedRowsMax;
     bool closeEmptyCardView;
     bool focusCardViewSearchBar;
-    bool keepGameChatFocus;
     int pixmapCacheSize;
     int networkCacheSize;
     int redirectCacheTtl;
@@ -792,10 +788,6 @@ public:
     {
         return ignoreUnregisteredUserMessages;
     }
-    [[nodiscard]] bool getIgnoreNonBuddyUserMessages() const
-    {
-        return ignoreNonBuddyUserMessages;
-    }
     [[nodiscard]] int getPixmapCacheSize() const
     {
         return pixmapCacheSize;
@@ -937,7 +929,6 @@ public:
     void setCardViewExpandedRowsMax(int value);
     void setCloseEmptyCardView(QT_STATE_CHANGED_T value);
     void setFocusCardViewSearchBar(QT_STATE_CHANGED_T value);
-    void setKeepGameChatFocus(QT_STATE_CHANGED_T value);
     QString getClientID() override
     {
         return clientID;
@@ -970,10 +961,6 @@ public:
     {
         return focusCardViewSearchBar;
     }
-    [[nodiscard]] bool getKeepGameChatFocus() const
-    {
-        return keepGameChatFocus;
-    }
     [[nodiscard]] ShortcutsSettings &shortcuts() const
     {
         return *shortcutsSettings;
@@ -1124,7 +1111,6 @@ public slots:
     void setSoundThemeName(const QString &_soundThemeName);
     void setIgnoreUnregisteredUsers(QT_STATE_CHANGED_T _ignoreUnregisteredUsers);
     void setIgnoreUnregisteredUserMessages(QT_STATE_CHANGED_T _ignoreUnregisteredUserMessages);
-    void setIgnoreNonBuddyUserMessages(QT_STATE_CHANGED_T _ignoreNonBuddyUserMessages);
     void setPixmapCacheSize(const int _pixmapCacheSize);
     void setCardImageCacheMethod(CardPictureLoaderCacheMethod::CacheMethod _cardImageCachingMethod);
     void setNetworkCacheSizeInMB(const int _networkCacheSize);

cockatrice/src/client/settings/shortcuts_settings.h

@@ -223,10 +223,6 @@ private:
         {"TabDeckEditor/aLoadDeck", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Load Deck..."),
                                                 parseSequenceString("Ctrl+O"),
                                                 ShortcutGroup::Deck_Editor)},
-        {"TabDeckEditor/aLoadDeckFromWebsite",
-         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Load deck from online service..."),
-                     parseSequenceString("Ctrl+Shift+O"),
-                     ShortcutGroup::Deck_Editor)},
         {"TabDeckEditor/aLoadDeckFromClipboard",
          ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Load Deck from Clipboard..."),
                      parseSequenceString("Ctrl+Shift+V"),
@@ -287,10 +283,6 @@ private:
          ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Load Deck from Clipboard..."),
                      parseSequenceString("Ctrl+Shift+V"),
                      ShortcutGroup::Game_Lobby)},
-        {"DeckViewContainer/loadFromWebsiteButton",
-         ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Load from website..."),
-                     parseSequenceString("Ctrl+Shift+O"),
-                     ShortcutGroup::Game_Lobby)},
         {"DeckViewContainer/unloadDeckButton", ShortcutKey(QT_TRANSLATE_NOOP("shortcutsTab", "Unload Deck"),
                                                            parseSequenceString("Ctrl+Alt+U"),
                                                            ShortcutGroup::Game_Lobby)},

cockatrice/src/game/abstract_game.cpp

@@ -3,7 +3,7 @@
 #include "../interface/widgets/tabs/tab_game.h"
 #include "player/player_logic.h"
 
-AbstractGame::AbstractGame(QObject *_parent) : QObject(_parent)
+AbstractGame::AbstractGame(TabGame *_tab) : QObject(_tab), tab(_tab)
 {
     gameMetaInfo = new GameMetaInfo(this);
     gameEventHandler = new GameEventHandler(this);

cockatrice/src/game/abstract_game.h

@@ -16,19 +16,26 @@
 #include <libcockatrice/protocol/pb/game_replay.pb.h>
 
 class CardItem;
+class TabGame;
 class AbstractGame : public QObject
 {
     Q_OBJECT
 
 public:
-    explicit AbstractGame(QObject *parent);
+    explicit AbstractGame(TabGame *tab);
 
+    TabGame *tab;
     GameMetaInfo *gameMetaInfo;
     GameState *gameState;
     GameEventHandler *gameEventHandler;
     PlayerManager *playerManager;
     CardItem *activeCard;
 
+    TabGame *getTab() const
+    {
+        return tab;
+    }
+
     GameMetaInfo *getGameMetaInfo()
     {
         return gameMetaInfo;

cockatrice/src/game/arrow_registry.cpp

@@ -1,48 +0,0 @@
-#include "arrow_registry.h"
-
-#include "../game_graphics/board/arrow_item.h"
-
-void ArrowRegistry::insert(QSharedPointer<ArrowData> data, ArrowItem *arrow)
-{
-    const ArrowKey key{data->creatorId, data->id};
-
-    if (auto *existing = take(data->creatorId, data->id)) {
-        existing->delArrow();
-    }
-
-    dataStore.insert(key, data);
-    items.insert(key, arrow);
-    byPlayer[data->creatorId].insert(data->id);
-}
-
-ArrowItem *ArrowRegistry::take(int creatorId, int arrowId)
-{
-    const ArrowKey key{creatorId, arrowId};
-    dataStore.remove(key);
-    auto &playerSet = byPlayer[creatorId];
-    playerSet.remove(arrowId);
-    if (playerSet.isEmpty()) {
-        byPlayer.remove(creatorId);
-    }
-    return items.take(key);
-}
-
-ArrowItem *ArrowRegistry::get(int creatorId, int arrowId) const
-{
-    return items.value(ArrowKey{creatorId, arrowId}, nullptr);
-}
-
-bool ArrowRegistry::contains(int creatorId, int arrowId) const
-{
-    return items.contains(ArrowKey{creatorId, arrowId});
-}
-
-QSet<int> ArrowRegistry::idsForPlayer(int playerId) const
-{
-    return byPlayer.value(playerId);
-}
-
-QList<ArrowItem *> ArrowRegistry::all() const
-{
-    return items.values();
-}

cockatrice/src/game/arrow_registry.h

@@ -1,43 +0,0 @@
-#ifndef COCKATRICE_ARROW_REGISTRY_H
-#define COCKATRICE_ARROW_REGISTRY_H
-
-#include "board/arrow_data.h"
-
-#include <QMap>
-#include <QSet>
-#include <QSharedPointer>
-
-class ArrowItem;
-
-struct ArrowKey
-{
-    int creatorId;
-    int arrowId;
-
-    bool operator<(const ArrowKey &other) const
-    {
-        if (creatorId != other.creatorId) {
-            return creatorId < other.creatorId;
-        }
-        return arrowId < other.arrowId;
-    }
-};
-
-class ArrowRegistry
-{
-public:
-    void insert(QSharedPointer<ArrowData> data, ArrowItem *arrow);
-    ArrowItem *take(int creatorId, int arrowId);
-
-    [[nodiscard]] ArrowItem *get(int creatorId, int arrowId) const;
-    [[nodiscard]] bool contains(int creatorId, int arrowId) const;
-    [[nodiscard]] QSet<int> idsForPlayer(int playerId) const;
-    [[nodiscard]] QList<ArrowItem *> all() const;
-
-private:
-    QMap<ArrowKey, QSharedPointer<ArrowData>> dataStore;
-    QMap<ArrowKey, ArrowItem *> items;
-    QMap<int, QSet<int>> byPlayer;
-};
-
-#endif

cockatrice/src/game/board/abstract_card_item.h

@@ -7,9 +7,9 @@
 #ifndef ABSTRACTCARDITEM_H
 #define ABSTRACTCARDITEM_H
 
+#include "../../game_graphics/board/graphics_item_type.h"
 #include "../card_dimensions.h"
 #include "arrow_target.h"
-#include "graphics_item_type.h"
 
 #include <libcockatrice/card/printing/exact_card.h>
 #include <libcockatrice/utility/card_ref.h>
@@ -44,11 +44,6 @@ signals:
     void deleteCardInfoPopup(QString cardName);
     void sigPixmapUpdated();
     void cardShiftClicked(QString cardName);
-    void rightClicked(AbstractCardItem *card, QPoint screenPos);
-    void playSelected(AbstractCardItem *card);
-    void playSelectedFaceDown(AbstractCardItem *card);
-    void hideSelected(AbstractCardItem *card);
-    void selectionChanged(AbstractCardItem *card, bool selected);
 
 public:
     enum

cockatrice/src/game/board/abstract_counter.cpp

@@ -1,10 +1,10 @@
 #include "abstract_counter.h"
 
 #include "../../client/settings/cache_settings.h"
-#include "../../game/player/player_actions.h"
-#include "../../game/player/player_logic.h"
-#include "../../game_graphics/board/translate_counter_name.h"
 #include "../../interface/widgets/tabs/tab_game.h"
+#include "../player/player_actions.h"
+#include "../player/player_logic.h"
+#include "translate_counter_name.h"
 
 #include <QAction>
 #include <QApplication>

cockatrice/src/game/board/abstract_counter.h

@@ -7,9 +7,9 @@
 #ifndef COUNTER_H
 #define COUNTER_H
 
-#include "../../game/board/counter_state.h"
 #include "../../interface/widgets/menus/tearoff_menu.h"
 #include "../player/menu/abstract_player_component.h"
+#include "counter_state.h"
 
 #include <QGraphicsItem>
 #include <QInputDialog>

cockatrice/src/game/board/arrow_data.cpp

@@ -1,10 +1,8 @@
 #include "arrow_data.h"
 
-ArrowData ArrowData::fromProto(const ServerInfo_Arrow &arrow, int creatorId, bool isLocalCreator)
+ArrowData ArrowData::fromProto(const ServerInfo_Arrow &arrow)
 {
     ArrowData data;
-    data.creatorId = creatorId;
-    data.isLocalCreator = isLocalCreator;
     data.id = arrow.id();
     data.startPlayerId = arrow.start_player_id();
     data.startZone = QString::fromStdString(arrow.start_zone());

cockatrice/src/game/board/arrow_data.h

@@ -8,18 +8,16 @@
 
 struct ArrowData
 {
-    int creatorId = -1;
-    bool isLocalCreator = false;
-    int id = -1;
-    int startPlayerId = -1;
-    QString startZone = "";
-    int startCardId = -1;
-    int targetPlayerId = -1;
-    QString targetZone = "";
-    int targetCardId = -1;
-    QColor color = "";
+    int id;
+    int startPlayerId;
+    QString startZone;
+    int startCardId;
+    int targetPlayerId;
+    QString targetZone;    // empty = targeting a player
+    int targetCardId = -1; // -1 = targeting a player
+    QColor color;
 
-    static ArrowData fromProto(const ServerInfo_Arrow &arrow, int creatorId, bool isLocalCreator);
+    static ArrowData fromProto(const ServerInfo_Arrow &arrow);
 
     bool isPlayerTargeted() const
     {

cockatrice/src/game/board/arrow_item.cpp

@@ -2,11 +2,11 @@
 #include "arrow_item.h"
 
 #include "../../client/settings/cache_settings.h"
-#include "../../game/player/player_actions.h"
-#include "../../game/player/player_logic.h"
+#include "../../game_graphics/zones/card_zone.h"
+#include "../player/player_actions.h"
+#include "../player/player_logic.h"
 #include "../player/player_target.h"
 #include "../z_values.h"
-#include "../zones/card_zone.h"
 #include "card_item.h"
 
 #include <QDebug>
@@ -21,8 +21,12 @@
 #include <libcockatrice/utility/color.h>
 #include <libcockatrice/utility/zone_names.h>
 
-ArrowItem::ArrowItem(QSharedPointer<const ArrowData> _data, ArrowTarget *_startItem, ArrowTarget *_targetItem)
-    : data(std::move(_data)), startItem(_startItem), targetItem(_targetItem)
+ArrowItem::ArrowItem(PlayerLogic *_player,
+                     int _id,
+                     ArrowTarget *_startItem,
+                     ArrowTarget *_targetItem,
+                     const QColor &_color)
+    : player(_player), id(_id), startItem(_startItem), targetItem(_targetItem), color(_color)
 {
     setZValue(ZValues::ARROWS);
 
@@ -48,7 +52,7 @@ ArrowItem::ArrowItem(QSharedPointer<const ArrowData> _data, ArrowTarget *_startI
 
 void ArrowItem::onTargetDestroyed()
 {
-    emit requestDeletion(data->creatorId, data->id);
+    emit requestDeletion(id);
 }
 
 void ArrowItem::delArrow()
@@ -126,7 +130,7 @@ void ArrowItem::updatePath(const QPointF &endPoint)
 
 void ArrowItem::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
 {
-    QColor paintColor(data->color);
+    QColor paintColor(color);
     if (fullColor) {
         paintColor.setAlpha(200);
     } else {
@@ -138,7 +142,7 @@ void ArrowItem::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*opti
 
 void ArrowItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
-    if (!data->isLocalCreator) {
+    if (!player->getPlayerInfo()->getLocal()) {
         event->ignore();
         return;
     }
@@ -152,20 +156,14 @@ void ArrowItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
 
     event->accept();
     if (event->button() == Qt::RightButton) {
-        emit requestDeletion(data->creatorId, data->id);
+        emit requestDeletion(id);
     }
 }
 
 // ArrowDragItem
 
 ArrowDragItem::ArrowDragItem(PlayerLogic *_owner, ArrowTarget *_startItem, const QColor &_color, int _deleteInPhase)
-    : ArrowItem(QSharedPointer<ArrowData>::create(ArrowData{.creatorId = _owner->getPlayerInfo()->getId(),
-                                                            .isLocalCreator = true,
-                                                            .id = -1,
-                                                            .color = _color}),
-                _startItem,
-                nullptr),
-      player(_owner), deleteInPhase(_deleteInPhase)
+    : ArrowItem(_owner, -1, _startItem, nullptr, _color), deleteInPhase(_deleteInPhase)
 {
 }
 
@@ -240,7 +238,7 @@ void ArrowDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
         CardZoneLogic *startZone = startCard->getZone();
 
         Command_CreateArrow cmd;
-        cmd.mutable_arrow_color()->CopyFrom(convertQColorToColor(data->color));
+        cmd.mutable_arrow_color()->CopyFrom(convertQColorToColor(color));
         cmd.set_start_player_id(startZone->getPlayer()->getPlayerInfo()->getId());
         cmd.set_start_zone(startZone->getName().toStdString());
         cmd.set_start_card_id(startCard->getId());
@@ -286,14 +284,7 @@ void ArrowDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 
 // ArrowAttachItem
 ArrowAttachItem::ArrowAttachItem(ArrowTarget *_startItem)
-    : ArrowItem(
-          QSharedPointer<ArrowData>::create(ArrowData{.creatorId = _startItem->getOwner()->getPlayerInfo()->getId(),
-                                                      .isLocalCreator = true,
-                                                      .id = -1,
-                                                      .color = Qt::green}),
-          _startItem,
-          nullptr),
-      player(_startItem->getOwner())
+    : ArrowItem(_startItem->getOwner(), -1, _startItem, nullptr, Qt::green)
 {
 }
 

cockatrice/src/game/board/arrow_item.h

@@ -1,15 +1,20 @@
+/**
+ * @file arrow_item.h
+ * @ingroup GameGraphics
+ */
+//! \todo Document this file.
+
 #ifndef ARROWITEM_H
 #define ARROWITEM_H
 
-#include "../../game/board/arrow_data.h"
 #include "arrow_target.h"
 
 #include <QGraphicsItem>
 #include <QPointer>
-#include <QSharedPointer>
 
 class CardItem;
 class QGraphicsSceneMouseEvent;
+class QMenu;
 class PlayerLogic;
 
 class ArrowItem : public QObject, public QGraphicsItem
@@ -17,27 +22,25 @@ class ArrowItem : public QObject, public QGraphicsItem
     Q_OBJECT
     Q_INTERFACES(QGraphicsItem)
 signals:
-    void requestDeletion(int creatorId, int id);
+    void requestDeletion(int id);
 
 private:
     QPainterPath path;
 
 protected:
-    QSharedPointer<const ArrowData> data;
+    PlayerLogic *player;
+    int id;
     QPointer<ArrowTarget> startItem;
     QPointer<ArrowTarget> targetItem;
     bool targetLocked = false;
+    QColor color;
     bool fullColor = true;
 
     void mousePressEvent(QGraphicsSceneMouseEvent *event) override;
 
 public:
-    ArrowItem(QSharedPointer<const ArrowData> _data, ArrowTarget *_startItem, ArrowTarget *_targetItem);
-
+    ArrowItem(PlayerLogic *_player, int _id, ArrowTarget *_startItem, ArrowTarget *_targetItem, const QColor &_color);
     void onTargetDestroyed();
-    void delArrow();
-    void updatePath();
-    void updatePath(const QPointF &endPoint);
 
     void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override;
     [[nodiscard]] QRectF boundingRect() const override
@@ -48,13 +51,17 @@ public:
     {
         return path;
     }
+
+    void updatePath();
+    void updatePath(const QPointF &endPoint);
+
     [[nodiscard]] int getId() const
     {
-        return data->id;
+        return id;
     }
-    [[nodiscard]] int getCreatorId() const
+    [[nodiscard]] PlayerLogic *getPlayer() const
     {
-        return data->creatorId;
+        return player;
     }
     [[nodiscard]] ArrowTarget *getStartItem() const
     {
@@ -68,13 +75,14 @@ public:
     {
         targetLocked = _targetLocked;
     }
+
+    void delArrow();
 };
 
 class ArrowDragItem : public ArrowItem
 {
     Q_OBJECT
 private:
-    PlayerLogic *player;
     int deleteInPhase;
     QList<ArrowDragItem *> childArrows;
     QMetaObject::Connection positionConnection;
@@ -92,7 +100,6 @@ class ArrowAttachItem : public ArrowItem
 {
     Q_OBJECT
 private:
-    PlayerLogic *player;
     QList<ArrowAttachItem *> childArrows;
     QMetaObject::Connection positionConnection;
     void attachCards(CardItem *startCard, const CardItem *targetCard);
@@ -106,4 +113,4 @@ protected:
     void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override;
 };
 
-#endif
+#endif // ARROWITEM_H

cockatrice/src/game/board/arrow_target.cpp

@@ -1,6 +1,6 @@
 #include "arrow_target.h"
 
-#include "../../game/player/player_logic.h"
+#include "../player/player_logic.h"
 #include "arrow_item.h"
 
 ArrowTarget::ArrowTarget(PlayerLogic *_owner, QGraphicsItem *parent) : AbstractGraphicsItem(parent), owner(_owner)

cockatrice/src/game/board/arrow_target.h

@@ -7,7 +7,7 @@
 #ifndef ARROWTARGET_H
 #define ARROWTARGET_H
 
-#include "abstract_graphics_item.h"
+#include "../../game_graphics/board/abstract_graphics_item.h"
 
 #include <QList>
 

cockatrice/src/game/board/card_drag_item.cpp

@@ -1,9 +1,9 @@
 #include "card_drag_item.h"
 
+#include "../../game_graphics/zones/card_zone.h"
+#include "../../game_graphics/zones/table_zone.h"
+#include "../../game_graphics/zones/view_zone.h"
 #include "../game_scene.h"
-#include "../zones/card_zone.h"
-#include "../zones/table_zone.h"
-#include "../zones/view_zone.h"
 #include "card_item.h"
 
 #include <QCursor>

cockatrice/src/game/board/card_item.cpp

@@ -1,14 +1,14 @@
 #include "card_item.h"
 
 #include "../../client/settings/cache_settings.h"
-#include "../../game/phase.h"
-#include "../../game/player/player_actions.h"
-#include "../../game/player/player_logic.h"
-#include "../../game/zones/view_zone_logic.h"
+#include "../../game_graphics/zones/table_zone.h"
+#include "../../game_graphics/zones/view_zone.h"
 #include "../../interface/widgets/tabs/tab_game.h"
 #include "../game_scene.h"
-#include "../zones/table_zone.h"
-#include "../zones/view_zone.h"
+#include "../phase.h"
+#include "../player/player_actions.h"
+#include "../player/player_logic.h"
+#include "../zones/view_zone_logic.h"
 #include "arrow_item.h"
 #include "card_drag_item.h"
 
@@ -40,7 +40,7 @@ void CardItem::prepareDelete()
 {
     if (owner != nullptr) {
         if (owner->getGame()->getActiveCard() == this) {
-            emit owner->requestCardMenuUpdate(nullptr);
+            owner->getPlayerMenu()->updateCardMenu(nullptr);
             owner->getGame()->setActiveCard(nullptr);
         }
         owner = nullptr;
@@ -399,11 +399,8 @@ void CardItem::playCard(bool faceDown)
         emit tz->toggleTapped();
     } else {
         if (SettingsCache::instance().getClickPlaysAllSelected()) {
-            if (faceDown) {
-                emit playSelectedFaceDown(this);
-            } else {
-                emit playSelected(this);
-            }
+            faceDown ? state->getZone()->getPlayer()->getPlayerActions()->actPlayFacedown()
+                     : state->getZone()->getPlayer()->getPlayerActions()->actPlay();
         } else {
             state->getZone()->getPlayer()->getPlayerActions()->playCard(this, faceDown);
         }
@@ -463,7 +460,7 @@ void CardItem::handleClickedToPlay(bool shiftHeld)
 {
     if (isUnwritableRevealZone(state->getZone())) {
         if (SettingsCache::instance().getClickPlaysAllSelected()) {
-            emit hideSelected(this);
+            state->getZone()->getPlayer()->getPlayerActions()->actHide();
         } else {
             state->getZone()->removeCard(this);
         }
@@ -474,15 +471,21 @@ void CardItem::handleClickedToPlay(bool shiftHeld)
 
 void CardItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
-    if (event->button() == Qt::RightButton && owner != nullptr) {
-        emit rightClicked(this, event->screenPos());
-        return;
-    }
-    if ((event->modifiers() != Qt::AltModifier) && (event->button() == Qt::LeftButton) &&
-        (!SettingsCache::instance().getDoubleClickToPlay())) {
+    if (event->button() == Qt::RightButton) {
+
+        if (owner != nullptr) {
+            owner->getGame()->setActiveCard(this);
+            if (QMenu *cardMenu = owner->getPlayerMenu()->updateCardMenu(this)) {
+                cardMenu->popup(event->screenPos());
+                return;
+            }
+        }
+    } else if ((event->modifiers() != Qt::AltModifier) && (event->button() == Qt::LeftButton) &&
+               (!SettingsCache::instance().getDoubleClickToPlay())) {
         handleClickedToPlay(event->modifiers().testFlag(Qt::ShiftModifier));
     }
-    if (owner != nullptr) {
+
+    if (owner != nullptr) { // cards without owner will be deleted
         setCursor(Qt::OpenHandCursor);
     }
     AbstractCardItem::mouseReleaseEvent(event);
@@ -528,14 +531,14 @@ bool CardItem::animationEvent()
 QVariant CardItem::itemChange(GraphicsItemChange change, const QVariant &value)
 {
     if ((change == ItemSelectedHasChanged) && owner != nullptr) {
-        bool selected = value.toBool();
-
-        if (selected) {
+        if (value == true) {
             owner->getGame()->setActiveCard(this);
+            owner->getPlayerMenu()->updateCardMenu(this);
+        } else if (owner->getGameScene()->selectedItems().isEmpty()) {
+
+            owner->getGame()->setActiveCard(nullptr);
+            owner->getPlayerMenu()->updateCardMenu(nullptr);
         }
-
-        emit selectionChanged(this, selected);
     }
-
     return AbstractCardItem::itemChange(change, value);
-}
+}

cockatrice/src/game/board/card_item.h

@@ -7,9 +7,9 @@
 #ifndef CARDITEM_H
 #define CARDITEM_H
 
-#include "../../game/board/card_state.h"
-#include "../../game/zones/card_zone_logic.h"
+#include "../zones/card_zone_logic.h"
 #include "abstract_card_item.h"
+#include "card_state.h"
 
 #include <libcockatrice/network/server/remote/game/server_card.h>
 #include <libcockatrice/utility/trice_limits.h>
@@ -55,10 +55,6 @@ public:
                       CardZoneLogic *_zone = nullptr);
 
     void retranslateUi();
-    [[nodiscard]] CardState *getState() const
-    {
-        return state;
-    }
     [[nodiscard]] CardZoneLogic *getZone() const
     {
         return state->getZone();

cockatrice/src/game/board/card_list.cpp

@@ -1,6 +1,6 @@
 #include "card_list.h"
 
-#include "../../game_graphics/board/card_item.h"
+#include "card_item.h"
 
 #include <QDebug>
 #include <algorithm>

cockatrice/src/game/board/card_state.cpp

@@ -18,7 +18,7 @@ void CardState::setZone(CardZoneLogic *_zone)
     }
 
     zone = _zone;
-    emit zoneChanged(this, zone);
+    emit zoneChanged(zone);
     emit stateChanged();
 }
 

cockatrice/src/game/board/card_state.h

@@ -31,7 +31,7 @@ signals:
     void doesntUntapChanged(bool newValue);
     void destroyOnZoneChangeChanged(bool newValue);
     void attachedToChanged(CardItem *newAttachedTo);
-    void zoneChanged(CardState *changedCard, CardZoneLogic *newZone);
+    void zoneChanged(CardZoneLogic *newZone);
 
 public:
     explicit CardState(QObject *parent, CardZoneLogic *_zone) : QObject(parent), zone(_zone)

cockatrice/src/game/board/counter_general.cpp

@@ -1,7 +1,7 @@
 #include "counter_general.h"
 
+#include "../../game_graphics/board/abstract_graphics_item.h"
 #include "../../interface/pixel_map_generator.h"
-#include "abstract_graphics_item.h"
 
 #include <QPainter>
 

cockatrice/src/game/deckview/deck_view.cpp

@@ -360,16 +360,6 @@ void DeckViewScene::rebuildTree()
         return;
     }
 
-    QStringList requiredZones = {DECK_ZONE_MAIN, DECK_ZONE_SIDE};
-
-    for (const QString &zoneName : requiredZones) {
-        if (!cardContainers.contains(zoneName)) {
-            auto *container = new DeckViewCardContainer(zoneName);
-            cardContainers.insert(zoneName, container);
-            addItem(container);
-        }
-    }
-
     for (auto *currentZone : deck->getZoneNodes()) {
         DeckViewCardContainer *container = cardContainers.value(currentZone->getName(), 0);
         if (!container) {

cockatrice/src/game/deckview/deck_view_container.cpp

@@ -209,7 +209,6 @@ void DeckViewContainer::refreshShortcuts()
     loadLocalButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/loadLocalButton"));
     loadRemoteButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/loadRemoteButton"));
     loadFromClipboardButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/loadFromClipboardButton"));
-    loadFromWebsiteButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/loadFromWebsiteButton"));
     unloadDeckButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/unloadDeckButton"));
     readyStartButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/readyStartButton"));
     sideboardLockButton->setShortcut(shortcuts.getSingleShortcut("DeckViewContainer/sideboardLockButton"));

cockatrice/src/game/game.cpp

@@ -4,16 +4,16 @@
 
 #include <libcockatrice/protocol/pb/event_game_joined.pb.h>
 
-Game::Game(QObject *_parent,
-           bool isLocalGame,
+Game::Game(TabGame *_tab,
            QList<AbstractClient *> &_clients,
            const Event_GameJoined &event,
            const QMap<int, QString> &_roomGameTypes)
-    : AbstractGame(_parent)
+    : AbstractGame(_tab)
 {
     gameMetaInfo->setFromProto(event.game_info());
     gameMetaInfo->setRoomGameTypes(_roomGameTypes);
-    gameState = new GameState(this, 0, event.host_id(), isLocalGame, _clients, false, event.resuming(), -1, false);
+    gameState = new GameState(this, 0, event.host_id(), tab->getTabSupervisor()->getIsLocalGame(), _clients, false,
+                              event.resuming(), -1, false);
     connect(gameMetaInfo, &GameMetaInfo::startedChanged, gameState, &GameState::onStartedChanged);
     playerManager = new PlayerManager(this, event.player_id(), event.judge(), event.spectator());
     gameMetaInfo->setStarted(false);

cockatrice/src/game/game.h

@@ -16,8 +16,7 @@ class Game : public AbstractGame
     Q_OBJECT
 
 public:
-    Game(QObject *parent,
-         bool isLocalGame,
+    Game(TabGame *tab,
          QList<AbstractClient *> &_clients,
          const Event_GameJoined &event,
          const QMap<int, QString> &_roomGameTypes);

cockatrice/src/game/game_event_handler.cpp

@@ -1,8 +1,8 @@
 #include "game_event_handler.h"
 
-#include "../game_graphics/log/message_log_widget.h"
 #include "../interface/widgets/tabs/tab_game.h"
 #include "abstract_game.h"
+#include "log/message_log_widget.h"
 
 #include <libcockatrice/network/client/abstract/abstract_client.h>
 #include <libcockatrice/protocol/get_pb_extension.h>
@@ -213,25 +213,11 @@ void GameEventHandler::handleChatMessageSent(const QString &chatMessage)
     sendGameCommand(cmd);
 }
 
-void GameEventHandler::handleArrowDeletion(int creatorId, int arrowId)
+void GameEventHandler::handleArrowDeletion(int arrowId)
 {
     Command_DeleteArrow cmd;
     cmd.set_arrow_id(arrowId);
-
-    auto preparedCommand = prepareGameCommand(cmd);
-
-    connect(preparedCommand, &PendingCommand::finished, this, [creatorId, arrowId, this](const Response &response) {
-        handleArrowDeletionFinished(response, creatorId, arrowId);
-    });
-
-    sendGameCommand(preparedCommand);
-}
-
-void GameEventHandler::handleArrowDeletionFinished(const Response &response, int creatorId, int arrowId)
-{
-    if (response.response_code() == Response::RespNameNotFound) {
-        emit arrowDeleted(creatorId, arrowId);
-    }
+    sendGameCommand(cmd);
 }
 
 void GameEventHandler::eventSpectatorSay(const Event_GameSay &event,

cockatrice/src/game/game_event_handler.h

@@ -60,8 +60,7 @@ public:
     void handleActivePhaseChanged(int phase);
     void handleGameLeft();
     void handleChatMessageSent(const QString &chatMessage);
-    void handleArrowDeletion(int creatorId, int arrowId);
-    void handleArrowDeletionFinished(const Response &response, int creatorId, int arrowId);
+    void handleArrowDeletion(int arrowId);
 
     void eventSpectatorSay(const Event_GameSay &event, int eventPlayerId, const GameEventContext &context);
     void eventSpectatorLeave(const Event_Leave &event, int eventPlayerId, const GameEventContext &context);
@@ -113,7 +112,6 @@ signals:
     void containerProcessingStarted(GameEventContext context);
     void setContextJudgeName(QString judgeName);
     void containerProcessingDone();
-    void arrowDeleted(int creatorId, int arrowId);
     void logSpectatorSay(ServerInfo_User userInfo, QString message);
     void logSpectatorLeave(QString name, QString reason);
     void logGameStart();

cockatrice/src/game/game_scene.cpp

@@ -1,17 +1,13 @@
 #include "game_scene.h"
 
 #include "../client/settings/cache_settings.h"
-#include "../game/abstract_game.h"
-#include "../game/player/player_actions.h"
-#include "../game/player/player_logic.h"
-#include "../game_graphics/player/player_graphics_item.h"
+#include "../game_graphics/zones/select_zone.h"
+#include "../game_graphics/zones/view_zone.h"
+#include "../game_graphics/zones/view_zone_widget.h"
 #include "board/card_item.h"
 #include "phases_toolbar.h"
-#include "player/menu/player_menu.h"
 #include "player/player_graphics_item.h"
-#include "zones/select_zone.h"
-#include "zones/view_zone.h"
-#include "zones/view_zone_widget.h"
+#include "player/player_logic.h"
 
 #include <QBasicTimer>
 #include <QDebug>
@@ -76,80 +72,6 @@ QList<CardItem *> GameScene::selectedCards() const
     return selectedCards;
 }
 
-void GameScene::onCardSelectionChanged(AbstractCardItem *abstractCard, bool selected)
-{
-    CardItem *card = qobject_cast<CardItem *>(abstractCard);
-    if (!card || !card->getOwner()) {
-        return;
-    }
-
-    auto *owner = card->getOwner();
-
-    if (selected) {
-        owner->requestCardMenuUpdate(card);
-        return;
-    }
-
-    if (selectedItems().isEmpty()) {
-        owner->getGame()->setActiveCard(nullptr);
-        owner->requestCardMenuUpdate(nullptr);
-    }
-}
-
-void GameScene::onCardRightClicked(AbstractCardItem *abstractCard, QPoint screenPos)
-{
-    auto *card = qobject_cast<CardItem *>(abstractCard);
-    if (!card) {
-        return;
-    }
-    if (!card->getOwner()) {
-        return;
-    }
-    auto *view = playerViews.value(card->getOwner()->getPlayerInfo()->getId());
-    if (!view) {
-        return;
-    }
-
-    card->getOwner()->getGame()->setActiveCard(card);
-
-    if (auto *menu = view->getPlayerMenu()->updateCardMenu(card)) {
-        menu->popup(screenPos);
-    }
-}
-
-void GameScene::playSelected(AbstractCardItem *card)
-{
-    if (!card) {
-        return;
-    }
-    if (!card->getOwner()) {
-        return;
-    }
-    card->getOwner()->getPlayerActions()->actPlay(selectedCards());
-}
-
-void GameScene::playSelectedFaceDown(AbstractCardItem *card)
-{
-    if (!card) {
-        return;
-    }
-    if (!card->getOwner()) {
-        return;
-    }
-    card->getOwner()->getPlayerActions()->actPlayFacedown(selectedCards());
-}
-
-void GameScene::hideSelected(AbstractCardItem *card)
-{
-    if (!card) {
-        return;
-    }
-    if (!card->getOwner()) {
-        return;
-    }
-    card->getOwner()->getPlayerActions()->actHide(selectedCards());
-}
-
 /**
  * @brief Adds a player to the scene and stores their graphics item.
  * @param player Player to add.
@@ -160,11 +82,9 @@ void GameScene::addPlayer(PlayerLogic *player)
 {
     qCInfo(GameScenePlayerAdditionRemovalLog) << "GameScene::addPlayer name=" << player->getPlayerInfo()->getName();
 
-    auto *view = new PlayerGraphicsItem(player);
-
-    playerViews.insert(player->getPlayerInfo()->getId(), view);
-    addItem(view);
-    connect(view, &PlayerGraphicsItem::sizeChanged, this, &GameScene::rearrange);
+    playerViews.insert(player->getPlayerInfo()->getId(), player->getGraphicsItem());
+    addItem(player->getGraphicsItem());
+    connect(player->getGraphicsItem(), &PlayerGraphicsItem::sizeChanged, this, &GameScene::rearrange);
 
     connect(player, &PlayerLogic::concededChanged, this, [this](int id, bool conceded) {
         if (conceded) {
@@ -173,13 +93,11 @@ void GameScene::addPlayer(PlayerLogic *player)
         rearrange();
     });
 
-    connect(player, &PlayerLogic::requestZoneViewToggle, this, &GameScene::toggleZoneView);
-    connect(player, &PlayerLogic::requestRevealedZoneView, this, &GameScene::addRevealedZoneView);
-    connect(player, &PlayerLogic::arrowDeleted, this, &GameScene::deleteArrow);
-    connect(player, &PlayerLogic::arrowCreateRequested, this, &GameScene::addArrow);
-    connect(player, &PlayerLogic::arrowDeleteRequested, this, &GameScene::requestArrowDeletion);
-    connect(player, &PlayerLogic::arrowsClearedLocally, this,
-            [this, id = player->getPlayerInfo()->getId()]() { clearArrowsForPlayerLocally(id); });
+    connect(player, &PlayerLogic::arrowDeleted, this, &GameScene::onArrowDeleted);
+    connect(player, &PlayerLogic::arrowCreateRequested, this, &GameScene::onArrowCreateRequested);
+    connect(player, &PlayerLogic::arrowDeleteRequested, this, &GameScene::onArrowDeleteRequested);
+    connect(player, &PlayerLogic::arrowsCleared, this,
+            [this, id = player->getPlayerInfo()->getId()]() { clearArrowsForPlayer(id); });
 
     connect(player->getPlayerEventHandler(), &PlayerEventHandler::cardZoneChanged, this, &GameScene::onCardZoneChanged);
 
@@ -205,7 +123,6 @@ void GameScene::removePlayer(PlayerLogic *player)
     }
     auto *view = playerViews.take(player->getPlayerInfo()->getId());
     removeItem(view);
-    view->deleteLater();
     rearrange();
 }
 
@@ -287,7 +204,7 @@ QList<PlayerLogic *> GameScene::collectActivePlayers(int &firstPlayerIndex) cons
     bool firstPlayerFound = false;
 
     for (auto *pgItem : playerViews.values()) {
-        PlayerLogic *p = pgItem->getLogic();
+        PlayerLogic *p = pgItem->getPlayer();
         if (p && !p->getConceded()) {
             activePlayers.append(p);
             if (!firstPlayerFound && p->getPlayerInfo()->getLocal()) {
@@ -358,12 +275,12 @@ QSizeF GameScene::computeSceneSizeAndPlayerLayout(const QList<PlayerLogic *> &pl
         for (int j = 0; j < rowsInColumn; ++j) {
             PlayerLogic *player = playersIter.next();
             if (col == 0) {
-                playersByColumn[col].prepend(playerViews.value(player->getPlayerInfo()->getId()));
+                playersByColumn[col].prepend(player->getGraphicsItem());
             } else {
-                playersByColumn[col].append(playerViews.value(player->getPlayerInfo()->getId()));
+                playersByColumn[col].append(player->getGraphicsItem());
             }
 
-            auto *pgItem = playerViews.value(player->getPlayerInfo()->getId());
+            auto *pgItem = player->getGraphicsItem();
             thisColumnHeight += pgItem->boundingRect().height() + playerAreaSpacing;
             columnWidth[col] = std::max(columnWidth[col], (int)pgItem->boundingRect().width());
         }
@@ -450,62 +367,62 @@ void GameScene::resizeColumnsAndPlayers(const QList<qreal> &minWidthByColumn, qr
     }
 }
 
-void GameScene::addArrow(QSharedPointer<ArrowData> data)
+void GameScene::onArrowCreateRequested(const ArrowData &data)
 {
-    auto *startView = playerViews.value(data->startPlayerId);
-    auto *targetView = playerViews.value(data->targetPlayerId);
+    auto *startView = playerViews.value(data.startPlayerId);
+    auto *targetView = playerViews.value(data.targetPlayerId);
     if (!startView || !targetView) {
         return;
     }
 
-    PlayerLogic *startLogic = startView->getLogic();
-    auto *startZone = startLogic->getZones().value(data->startZone);
+    PlayerLogic *startLogic = startView->getPlayer();
+    auto *startZone = startLogic->getZones().value(data.startZone);
     if (!startZone) {
         return;
     }
 
-    CardItem *startCard = startZone->getCard(data->startCardId);
+    CardItem *startCard = startZone->getCard(data.startCardId);
     if (!startCard) {
         return;
     }
 
     ArrowTarget *targetItem = nullptr;
-    if (data->isPlayerTargeted()) {
+    if (data.isPlayerTargeted()) {
         targetItem = targetView->getPlayerTarget();
     } else {
-        auto *zone = targetView->getLogic()->getZones().value(data->targetZone);
+        auto *zone = targetView->getPlayer()->getZones().value(data.targetZone);
         if (zone) {
-            targetItem = zone->getCard(data->targetCardId);
+            targetItem = zone->getCard(data.targetCardId);
         }
     }
     if (!targetItem) {
         return;
     }
 
-    auto *arrow = new ArrowItem(data, startCard, targetItem);
+    auto *arrow = new ArrowItem(startView->getPlayer(), data.id, startCard, targetItem, data.color);
     addItem(arrow);
-    arrowRegistry.insert(data, arrow);
-    connect(arrow, &ArrowItem::requestDeletion, this, &GameScene::requestArrowDeletion);
+    arrowRegistry.insert(data.id, arrow);
+    connect(arrow, &ArrowItem::requestDeletion, this, &GameScene::onArrowDeleteRequested);
 }
 
-void GameScene::deleteArrow(int playerId, int arrowId)
+void GameScene::onArrowDeleted(int arrowId)
 {
-    if (auto *arrow = arrowRegistry.take(playerId, arrowId)) {
-        arrow->delArrow();
+    if (arrowRegistry.contains(arrowId)) {
+        arrowRegistry.take(arrowId)->delArrow();
     }
 }
 
-void GameScene::requestArrowDeletion(int playerId, int arrowId)
+void GameScene::onArrowDeleteRequested(int arrowId)
 {
-    if (arrowRegistry.contains(playerId, arrowId)) {
-        emit arrowDeletionRequested(playerId, arrowId);
+    if (arrowRegistry.contains(arrowId)) {
+        emit requestArrowDeletion(arrowId);
     }
 }
 
 void GameScene::onCardZoneChanged(CardItem *card, bool sameZone)
 {
     QList<ArrowItem *> toDelete;
-    for (auto *arrow : arrowRegistry.all()) {
+    for (auto *arrow : arrowRegistry.values()) {
         if (arrow->getStartItem() == card || arrow->getTargetItem() == card) {
             if (sameZone) {
                 arrow->updatePath();
@@ -515,21 +432,16 @@ void GameScene::onCardZoneChanged(CardItem *card, bool sameZone)
         }
     }
     for (auto *arrow : toDelete) {
-        deleteArrow(arrow->getCreatorId(), arrow->getId());
+        emit requestArrowDeletion(arrow->getId());
     }
 }
 
 void GameScene::clearArrowsForPlayer(int playerId)
 {
-    for (int arrowId : arrowRegistry.idsForPlayer(playerId)) {
-        emit requestArrowDeletion(playerId, arrowId);
-    }
-}
-
-void GameScene::clearArrowsForPlayerLocally(int playerId)
-{
-    for (int arrowId : arrowRegistry.idsForPlayer(playerId)) {
-        arrowRegistry.take(playerId, arrowId)->delArrow();
+    for (auto *arrow : arrowRegistry.values()) {
+        if (arrow->getPlayer()->getPlayerInfo()->getId() == playerId) {
+            emit requestArrowDeletion(arrow->getId());
+        }
     }
 }
 

cockatrice/src/game/game_scene.h

@@ -1,10 +1,9 @@
 #ifndef GAMESCENE_H
 #define GAMESCENE_H
 
-#include "../game/arrow_registry.h"
-#include "../game/board/arrow_data.h"
-#include "../game/zones/card_zone_logic.h"
+#include "board/arrow_data.h"
 #include "board/arrow_item.h"
+#include "zones/card_zone_logic.h"
 
 #include <QGraphicsScene>
 #include <QList>
@@ -46,7 +45,7 @@ private:
     PhasesToolbar *phasesToolbar;                       ///< Toolbar showing game phases
     QMap<int, PlayerGraphicsItem *> playerViews;        ///< ID lookup for player graphics items
     QList<QList<PlayerGraphicsItem *>> playersByColumn; ///< Players organized by column
-    ArrowRegistry arrowRegistry;                        ///< ID registry for arrow graphics items
+    QMap<int, ArrowItem *> arrowRegistry;               ///< ID registry for arrow graphics items
     QList<ZoneViewWidget *> zoneViews;                  ///< Active zone view widgets
     QSize viewSize;                                     ///< Current view size
     QPointer<CardItem> hoveredCard;                     ///< Currently hovered card
@@ -97,16 +96,6 @@ public:
      */
     void removePlayer(PlayerLogic *player);
 
-    QMap<int, PlayerGraphicsItem *> getPlayers() const
-    {
-        return playerViews;
-    }
-
-    PlayerGraphicsItem *viewForPlayer(int playerId)
-    {
-        return playerViews.value(playerId);
-    }
-
     /**
      * @brief Adjusts the global rotation offset for player layout.
      * @param rotationAdjustment Number of positions to rotate.
@@ -192,11 +181,6 @@ public:
     void stopRubberBand();
 
 public slots:
-    void onCardSelectionChanged(AbstractCardItem *card, bool selected);
-    void onCardRightClicked(AbstractCardItem *card, QPoint screenPos);
-    void playSelected(AbstractCardItem *card);
-    void playSelectedFaceDown(AbstractCardItem *card);
-    void hideSelected(AbstractCardItem *card);
     /** @brief Toggles a zone view for a player. */
     void toggleZoneView(PlayerLogic *player, const QString &zoneName, int numberCards, bool isReversed = false);
 
@@ -217,16 +201,11 @@ public slots:
     QTransform getViewTransform() const;
     QTransform getViewportTransform() const;
 
-    /// Directly modifies the scene
-    void addArrow(QSharedPointer<ArrowData> data);
-    void deleteArrow(int playerId, int arrowId);
-    void clearArrowsForPlayer(int playerId);
-    void clearArrowsForPlayerLocally(int playerId);
-
-    /// Queues up arrow deletion but doesn't directly modify the scene
-    void requestArrowDeletion(int playerId, int arrowId);
-
+    void onArrowCreateRequested(const ArrowData &data);
+    void onArrowDeleted(int arrowId);
+    void onArrowDeleteRequested(int arrowId);
     void onCardZoneChanged(CardItem *card, bool sameZone);
+    void clearArrowsForPlayer(int playerId);
 
 protected:
     /** @brief Handles hover updates. */
@@ -239,7 +218,7 @@ signals:
     void sigStartRubberBand(const QPointF &selectionOrigin);
     void sigResizeRubberBand(const QPointF &cursorPoint, int selectedCount);
     void sigStopRubberBand();
-    void arrowDeletionRequested(int creatorId, int arrowId);
+    void requestArrowDeletion(int arrowId);
 };
 
 #endif

cockatrice/src/game/game_view.cpp

@@ -34,6 +34,7 @@ GameView::GameView(GameScene *scene, QWidget *parent) : QGraphicsView(scene, par
 {
     setBackgroundBrush(QBrush(QColor(0, 0, 0)));
     setRenderHints(QPainter::TextAntialiasing | QPainter::Antialiasing);
+    setFocusPolicy(Qt::ClickFocus);
     setViewportUpdateMode(BoundingRectViewportUpdate);
 
     connect(scene, &GameScene::sceneRectChanged, this, &GameView::updateSceneRect);
@@ -43,9 +44,6 @@ GameView::GameView(GameScene *scene, QWidget *parent) : QGraphicsView(scene, par
     connect(scene, &GameScene::sigStopRubberBand, this, &GameView::stopRubberBand);
     connect(scene, &QGraphicsScene::selectionChanged, this, [this]() { updateTotalSelectionCount(); });
 
-    setFocusDisabled(SettingsCache::instance().getKeepGameChatFocus());
-    connect(&SettingsCache::instance(), &SettingsCache::keepGameChatFocusChanged, this, &GameView::setFocusDisabled);
-
     aCloseMostRecentZoneView = new QAction(this);
 
     connect(aCloseMostRecentZoneView, &QAction::triggered, scene, &GameScene::closeMostRecentZoneView);
@@ -188,12 +186,3 @@ void GameView::updateTotalSelectionCount(const QSize &viewSize)
         totalCountLabel->hide();
     }
 }
-
-/**
- * Disabling focus on the game view will allow chat to maintain the autofocusing behavior of pre 2.10.3,
- * at the cost of disabling the zone view search bar.
- */
-void GameView::setFocusDisabled(bool disabled)
-{
-    setFocusPolicy(disabled ? Qt::NoFocus : Qt::ClickFocus);
-}

cockatrice/src/game/game_view.h

@@ -31,7 +31,6 @@ private slots:
     void stopRubberBand();
     void refreshShortcuts();
     void updateTotalSelectionCount(const QSize &viewSize = QSize());
-    void setFocusDisabled(bool disabled);
 public slots:
     void updateSceneRect(const QRectF &rect);
 

cockatrice/src/game/hand_counter.cpp

@@ -1,6 +1,6 @@
 #include "hand_counter.h"
 
-#include "zones/card_zone.h"
+#include "../game_graphics/zones/card_zone.h"
 
 #include <QGraphicsSceneMouseEvent>
 #include <QPainter>

cockatrice/src/game/hand_counter.h

@@ -7,8 +7,8 @@
 #ifndef HANDCOUNTER_H
 #define HANDCOUNTER_H
 
-#include "board/abstract_graphics_item.h"
-#include "board/graphics_item_type.h"
+#include "../game_graphics/board/abstract_graphics_item.h"
+#include "../game_graphics/board/graphics_item_type.h"
 
 #include <QString>
 

cockatrice/src/game/log/message_log_widget.cpp

@@ -1,13 +1,13 @@
 #include "message_log_widget.h"
 
-#include "../../client/settings/card_counter_settings.h"
 #include "../../client/sound_engine.h"
-#include "../../game/phase.h"
-#include "../../game/player/player_logic.h"
 #include "../../interface/widgets/tabs/tab_game.h"
 #include "../board/card_item.h"
 #include "../board/translate_counter_name.h"
+#include "../phase.h"
+#include "../player/player_logic.h"
 
+#include <../../client/settings/card_counter_settings.h>
 #include <libcockatrice/protocol/pb/context_move_card.pb.h>
 #include <libcockatrice/protocol/pb/context_mulligan.pb.h>
 #include <libcockatrice/utility/zone_names.h>
@@ -650,16 +650,14 @@ void MessageLogWidget::logSetCardCounter(PlayerLogic *player, QString cardName,
     QString finalStr;
     int delta = abs(oldValue - value);
     if (value > oldValue) {
-        finalStr = tr("%1 places %2 %3%4 counter(s) on %5 (now %6).", "", delta);
+        finalStr = tr("%1 places %2 \"%3\" counter(s) on %4 (now %5).", "", delta);
     } else {
-        finalStr = tr("%1 removes %2 %3%4 counter(s) from %5 (now %6).", "", delta);
+        finalStr = tr("%1 removes %2 \"%3\" counter(s) from %4 (now %5).", "", delta);
     }
 
     auto &cardCounterSettings = SettingsCache::instance().cardCounters();
-    QString hex = cardCounterSettings.color(counterId).name();
     appendHtmlServerMessage(finalStr.arg(sanitizeHtml(player->getPlayerInfo()->getName()))
                                 .arg("<font class=\"blue\">" + QString::number(delta) + "</font>")
-                                .arg("<font color=\"" + hex + "\">●</font>")
                                 .arg(cardCounterSettings.displayName(counterId))
                                 .arg(cardLink(std::move(cardName)))
                                 .arg(value));

cockatrice/src/game/log/message_log_widget.h

@@ -7,8 +7,8 @@
 #ifndef MESSAGELOGWIDGET_H
 #define MESSAGELOGWIDGET_H
 
-#include "../../game/zones/card_zone_logic.h"
 #include "../../interface/widgets/server/chat_view/chat_view.h"
+#include "../zones/card_zone_logic.h"
 
 class AbstractGame;
 class CardItem;

cockatrice/src/game/phases_toolbar.h

@@ -8,7 +8,7 @@
 #ifndef PHASESTOOLBAR_H
 #define PHASESTOOLBAR_H
 
-#include "board/abstract_graphics_item.h"
+#include "../game_graphics/board/abstract_graphics_item.h"
 
 #include <QFrame>
 #include <QGraphicsObject>

cockatrice/src/game/player/menu/card_menu.cpp

@@ -3,121 +3,92 @@
 #include "../../../client/settings/card_counter_settings.h"
 #include "../../../interface/widgets/tabs/tab_game.h"
 #include "../../board/card_item.h"
-#include "../../game/player/player_actions.h"
-#include "../../game/player/player_logic.h"
-#include "../../game/zones/view_zone_logic.h"
+#include "../../zones/view_zone_logic.h"
 #include "../card_menu_action_type.h"
-#include "../player_graphics_item.h"
+#include "../player_actions.h"
+#include "../player_logic.h"
 #include "move_menu.h"
 #include "pt_menu.h"
 
-#include <QPainter>
 #include <libcockatrice/card/database/card_database_manager.h>
 #include <libcockatrice/card/relation/card_relation.h>
 #include <libcockatrice/utility/zone_names.h>
 
-/**
- * @brief Creates a circular icon filled with the specified color.
- */
-static QIcon createCircleIcon(const QColor &color)
-{
-    QPixmap pixmap(32, 32);
-    pixmap.fill(Qt::transparent);
-    QPainter painter(&pixmap);
-    painter.setRenderHint(QPainter::Antialiasing);
-    painter.setPen(Qt::NoPen);
-    painter.setBrush(color);
-    painter.drawEllipse(pixmap.rect());
-
-    return QIcon(pixmap);
-}
-
-template <typename Slot>
-static QAction *makeAction(QObject *parent, Slot &&slot, bool checkable = false, bool checked = false)
-{
-    auto *a = new QAction(parent);
-    a->setCheckable(checkable);
-    if (checkable) {
-        a->setChecked(checked);
-    }
-    QObject::connect(a, &QAction::triggered, parent, std::forward<Slot>(slot));
-    return a;
-}
-
-CardMenu::CardMenu(PlayerGraphicsItem *_player, const CardItem *_card, bool _shortcutsActive)
+CardMenu::CardMenu(PlayerLogic *_player, const CardItem *_card, bool _shortcutsActive)
     : player(_player), card(_card), shortcutsActive(_shortcutsActive)
 {
-    const QList<PlayerLogic *> &players = player->getLogic()->getGame()->getPlayerManager()->getPlayers().values();
+    auto playerActions = player->getPlayerActions();
+
+    const QList<PlayerLogic *> &players = player->getGame()->getPlayerManager()->getPlayers().values();
 
     for (auto playerToAdd : players) {
-        if (playerToAdd == player->getLogic()) {
+        if (playerToAdd == player) {
             continue;
         }
         playersInfo.append(qMakePair(playerToAdd->getPlayerInfo()->getName(), playerToAdd->getPlayerInfo()->getId()));
     }
 
-    connect(player->getLogic()->getGame()->getPlayerManager(), &PlayerManager::playerRemoved, this,
-            &CardMenu::removePlayer);
+    connect(player->getGame()->getPlayerManager(), &PlayerManager::playerRemoved, this, &CardMenu::removePlayer);
 
-    auto *actions = player->getLogic()->getPlayerActions();
-    auto *gameScene = player->getGameScene();
-
-    // Single selection resolver used by all lambdas — called at trigger time
-    auto sel = [gameScene]() { return gameScene->selectedCards(); };
-
-    // Unified dispatcher for card menu actions
-    auto invoke = [actions, sel](CardMenuActionType type) {
-        return [actions, sel, type]() { actions->cardMenuAction(sel(), type); };
-    };
-
-    // Actions using invoke (type dispatch, need selection)
-    aTap = makeAction(this, invoke(cmTap));
-    aDoesntUntap = makeAction(this, invoke(cmDoesntUntap), /*checkable=*/true, card && card->getDoesntUntap());
-    aFlip = makeAction(this, invoke(cmFlip));
-    aPeek = makeAction(this, invoke(cmPeek));
-    aClone = makeAction(this, invoke(cmClone));
-
-    // Actions using selection directly
-    aUnattach = makeAction(this, [actions, sel]() { actions->actUnattach(sel()); });
-    aSetAnnotation = makeAction(this, [actions, sel]() { actions->actRequestSetAnnotationDialog(sel()); });
-    aPlay = makeAction(this, [actions, sel]() { actions->actPlay(sel()); });
-    aPlayFacedown = makeAction(this, [actions, sel]() { actions->actPlayFacedown(sel()); });
-    aHide = makeAction(this, [actions, sel]() { actions->actHide(sel()); });
-    aReduceLifeByPower = makeAction(this, [actions, sel]() { actions->actReduceLifeByPower(sel()); });
-
-    // Actions that use activeCard, not selection — direct connection
+    aTap = new QAction(this);
+    aTap->setData(cmTap);
+    connect(aTap, &QAction::triggered, playerActions, &PlayerActions::cardMenuAction);
+    aDoesntUntap = new QAction(this);
+    aDoesntUntap->setData(cmDoesntUntap);
+    aDoesntUntap->setCheckable(true);
+    aDoesntUntap->setChecked(card != nullptr && card->getDoesntUntap());
+    connect(aDoesntUntap, &QAction::triggered, playerActions, &PlayerActions::cardMenuAction);
     aAttach = new QAction(this);
+    connect(aAttach, &QAction::triggered, playerActions, &PlayerActions::actAttach);
+    aUnattach = new QAction(this);
+    connect(aUnattach, &QAction::triggered, playerActions, &PlayerActions::actUnattach);
     aDrawArrow = new QAction(this);
+    connect(aDrawArrow, &QAction::triggered, playerActions, &PlayerActions::actDrawArrow);
+    aSetAnnotation = new QAction(this);
+    connect(aSetAnnotation, &QAction::triggered, playerActions, &PlayerActions::actSetAnnotation);
+    aFlip = new QAction(this);
+    aFlip->setData(cmFlip);
+    connect(aFlip, &QAction::triggered, player->getPlayerActions(), &PlayerActions::cardMenuAction);
+    aPeek = new QAction(this);
+    aPeek->setData(cmPeek);
+    connect(aPeek, &QAction::triggered, player->getPlayerActions(), &PlayerActions::cardMenuAction);
+    aClone = new QAction(this);
+    aClone->setData(cmClone);
+    connect(aClone, &QAction::triggered, player->getPlayerActions(), &PlayerActions::cardMenuAction);
     aSelectAll = new QAction(this);
+    connect(aSelectAll, &QAction::triggered, playerActions, &PlayerActions::actSelectAll);
     aSelectRow = new QAction(this);
+    connect(aSelectRow, &QAction::triggered, playerActions, &PlayerActions::actSelectRow);
     aSelectColumn = new QAction(this);
+    connect(aSelectColumn, &QAction::triggered, playerActions, &PlayerActions::actSelectColumn);
 
-    connect(aAttach, &QAction::triggered, actions, &PlayerActions::actAttach);
-    connect(aDrawArrow, &QAction::triggered, actions, &PlayerActions::actDrawArrow);
-    connect(aSelectAll, &QAction::triggered, actions, &PlayerActions::actSelectAll);
-    connect(aSelectRow, &QAction::triggered, actions, &PlayerActions::actSelectRow);
-    connect(aSelectColumn, &QAction::triggered, actions, &PlayerActions::actSelectColumn);
+    aReduceLifeByPower = new QAction(this);
+    connect(aReduceLifeByPower, &QAction::triggered, playerActions, &PlayerActions::actReduceLifeByPower);
+
+    aPlay = new QAction(this);
+    connect(aPlay, &QAction::triggered, playerActions, &PlayerActions::actPlay);
+    aHide = new QAction(this);
+    connect(aHide, &QAction::triggered, playerActions, &PlayerActions::actHide);
+    aPlayFacedown = new QAction(this);
+    connect(aPlayFacedown, &QAction::triggered, playerActions, &PlayerActions::actPlayFacedown);
 
     aRevealToAll = new QAction(this);
 
     mCardCounters = new QMenu;
 
-    // Card counters
     for (int i = 0; i < 6; ++i) {
-        QColor color = SettingsCache::instance().cardCounters().color(i);
-        QIcon circleIcon = createCircleIcon(color);
-
-        auto *addAction = makeAction(this, [actions, sel, i]() { actions->actAddCardCounter(sel(), i); });
-        addAction->setIcon(circleIcon);
-        aAddCounter.append(addAction);
-
-        auto *removeAction = makeAction(this, [actions, sel, i]() { actions->actRemoveCardCounter(sel(), i); });
-        removeAction->setIcon(circleIcon);
-        aRemoveCounter.append(removeAction);
-
-        auto *setAction = makeAction(this, [actions, sel, i]() { actions->actRequestSetCardCounterDialog(sel(), i); });
-        setAction->setIcon(circleIcon);
-        aSetCounter.append(setAction);
+        auto *tempAddCounter = new QAction(this);
+        auto *tempRemoveCounter = new QAction(this);
+        auto *tempSetCounter = new QAction(this);
+        aAddCounter.append(tempAddCounter);
+        aRemoveCounter.append(tempRemoveCounter);
+        aSetCounter.append(tempSetCounter);
+        connect(tempAddCounter, &QAction::triggered, playerActions,
+                [playerActions, i] { playerActions->actAddCardCounter(i); });
+        connect(tempRemoveCounter, &QAction::triggered, playerActions,
+                [playerActions, i] { playerActions->actRemoveCardCounter(i); });
+        connect(tempSetCounter, &QAction::triggered, playerActions,
+                [playerActions, i] { playerActions->actSetCardCounter(i); });
     }
 
     setShortcutsActive();
@@ -129,7 +100,7 @@ CardMenu::CardMenu(PlayerGraphicsItem *_player, const CardItem *_card, bool _sho
     }
 
     bool revealedCard = false;
-    bool writeableCard = player->getLogic()->getPlayerInfo()->getLocalOrJudge();
+    bool writeableCard = player->getPlayerInfo()->getLocalOrJudge();
     if (auto *view = qobject_cast<ZoneViewZoneLogic *>(card->getZone())) {
         if (view->getRevealZone()) {
             if (view->getWriteableRevealZone()) {
@@ -313,9 +284,7 @@ void CardMenu::createHandOrCustomZoneMenu(bool canModifyCard)
 
     initContextualPlayersMenu(revealMenu, aRevealToAll);
 
-    connect(revealMenu, &QMenu::triggered, this, [this](QAction *action) {
-        player->getLogic()->getPlayerActions()->actReveal(player->getGameScene()->selectedCards(), action);
-    });
+    connect(revealMenu, &QMenu::triggered, player->getPlayerActions(), &PlayerActions::actReveal);
 
     addSeparator();
     addAction(aClone);
@@ -400,7 +369,8 @@ void CardMenu::addRelatedCardView()
         QAction *viewCard = viewRelatedCards->addAction(relatedCardName);
         Q_UNUSED(viewCard);
 
-        connect(viewCard, &QAction::triggered, this, [this, cardRef] { emit cardInfoRequested(cardRef); });
+        connect(viewCard, &QAction::triggered, player->getGame(),
+                [this, cardRef] { player->getGame()->getTab()->viewCardInfo(cardRef); });
     }
 }
 
@@ -462,8 +432,7 @@ void CardMenu::addRelatedCardActions()
 
         auto *createRelated = new QAction(text, this);
         createRelated->setData(QVariant(index++));
-        connect(createRelated, &QAction::triggered, player->getLogic()->getPlayerActions(),
-                &PlayerActions::actCreateRelatedCard);
+        connect(createRelated, &QAction::triggered, player->getPlayerActions(), &PlayerActions::actCreateRelatedCard);
         addAction(createRelated);
     }
 
@@ -472,7 +441,7 @@ void CardMenu::addRelatedCardActions()
             createRelatedCards->setShortcuts(
                 SettingsCache::instance().shortcuts().getShortcut("Player/aCreateRelatedTokens"));
         }
-        connect(createRelatedCards, &QAction::triggered, player->getLogic()->getPlayerActions(),
+        connect(createRelatedCards, &QAction::triggered, player->getPlayerActions(),
                 &PlayerActions::actCreateAllRelatedCards);
         addAction(createRelatedCards);
     }

cockatrice/src/game/player/menu/card_menu.h

@@ -8,20 +8,15 @@
 #define COCKATRICE_CARD_MENU_H
 
 #include <QMenu>
-#include <libcockatrice/utility/card_ref.h>
 
 class CardItem;
-class PlayerGraphicsItem;
 class PlayerLogic;
 class CardMenu : public QMenu
 {
     Q_OBJECT
 
-signals:
-    void cardInfoRequested(const CardRef &cardRef);
-
 public:
-    explicit CardMenu(PlayerGraphicsItem *player, const CardItem *card, bool shortcutsActive);
+    explicit CardMenu(PlayerLogic *player, const CardItem *card, bool shortcutsActive);
     void removePlayer(PlayerLogic *playerToRemove);
     void createTableMenu(bool canModifyCard);
     void createStackMenu(bool canModifyCard);
@@ -46,7 +41,7 @@ public:
     QList<QAction *> aAddCounter, aSetCounter, aRemoveCounter;
 
 private:
-    PlayerGraphicsItem *player;
+    PlayerLogic *player;
     const CardItem *card;
     QList<QPair<QString, int>> playersInfo;
     bool shortcutsActive;

cockatrice/src/game/player/menu/custom_zone_menu.cpp

@@ -1,14 +1,13 @@
 #include "custom_zone_menu.h"
 
-#include "../../game/player/player_logic.h"
-#include "../player_graphics_item.h"
+#include "../player_logic.h"
 
-CustomZoneMenu::CustomZoneMenu(PlayerGraphicsItem *_player) : player(_player)
+CustomZoneMenu::CustomZoneMenu(PlayerLogic *_player) : player(_player)
 {
     menuAction()->setVisible(false);
 
-    connect(player->getLogic(), &PlayerLogic::clearCustomZonesMenu, this, &CustomZoneMenu::clearCustomZonesMenu);
-    connect(player->getLogic(), &PlayerLogic::addViewCustomZoneActionToCustomZoneMenu, this,
+    connect(player, &PlayerLogic::clearCustomZonesMenu, this, &CustomZoneMenu::clearCustomZonesMenu);
+    connect(player, &PlayerLogic::addViewCustomZoneActionToCustomZoneMenu, this,
             &CustomZoneMenu::addViewCustomZoneActionToCustomZoneMenu);
 
     retranslateUi();
@@ -18,7 +17,7 @@ void CustomZoneMenu::retranslateUi()
 {
     setTitle(tr("C&ustom Zones"));
 
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
 
         for (auto aViewZone : actions()) {
             aViewZone->setText(tr("View custom zone '%1'").arg(aViewZone->data().toString()));
@@ -38,5 +37,5 @@ void CustomZoneMenu::addViewCustomZoneActionToCustomZoneMenu(QString zoneName)
     QAction *aViewZone = addAction(tr("View custom zone '%1'").arg(zoneName));
     aViewZone->setData(zoneName);
     connect(aViewZone, &QAction::triggered, this,
-            [zoneName, this]() { player->getGameScene()->toggleZoneView(player->getLogic(), zoneName, -1); });
+            [zoneName, this]() { player->getGameScene()->toggleZoneView(player, zoneName, -1); });
 }

cockatrice/src/game/player/menu/custom_zone_menu.h

@@ -11,12 +11,12 @@
 
 #include <QMenu>
 
-class PlayerGraphicsItem;
+class PlayerLogic;
 class CustomZoneMenu : public QMenu, public AbstractPlayerComponent
 {
     Q_OBJECT
 public:
-    explicit CustomZoneMenu(PlayerGraphicsItem *player);
+    explicit CustomZoneMenu(PlayerLogic *player);
     void retranslateUi() override;
     void setShortcutsActive() override
     {
@@ -26,7 +26,7 @@ public:
     }
 
 private:
-    PlayerGraphicsItem *player;
+    PlayerLogic *player;
 private slots:
     void clearCustomZonesMenu();
     void addViewCustomZoneActionToCustomZoneMenu(QString zoneName);

cockatrice/src/game/player/menu/grave_menu.cpp

@@ -1,22 +1,21 @@
 #include "grave_menu.h"
 
-#include "../../game/abstract_game.h"
-#include "../../game/player/player_actions.h"
-#include "../../game/player/player_logic.h"
-#include "../player_graphics_item.h"
+#include "../../abstract_game.h"
+#include "../player_actions.h"
+#include "../player_logic.h"
 
 #include <QAction>
 #include <QMenu>
 #include <libcockatrice/utility/zone_names.h>
 
-GraveyardMenu::GraveyardMenu(PlayerGraphicsItem *_player, QWidget *parent) : TearOffMenu(parent), player(_player)
+GraveyardMenu::GraveyardMenu(PlayerLogic *_player, QWidget *parent) : TearOffMenu(parent), player(_player)
 {
     createMoveActions();
     createViewActions();
 
     addAction(aViewGraveyard);
 
-    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
+    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
         mRevealRandomGraveyardCard = addMenu(QString());
         connect(mRevealRandomGraveyardCard, &QMenu::aboutToShow, this,
                 &GraveyardMenu::populateRevealRandomMenuWithActivePlayers);
@@ -37,9 +36,9 @@ GraveyardMenu::GraveyardMenu(PlayerGraphicsItem *_player, QWidget *parent) : Tea
 
 void GraveyardMenu::createMoveActions()
 {
-    auto grave = player->getLogic()->getGraveZone();
+    auto grave = player->getGraveZone();
 
-    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
+    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
         aMoveGraveToTopLibrary = new QAction(this);
         aMoveGraveToTopLibrary->setData(QList<QVariant>() << ZoneNames::DECK << 0);
 
@@ -61,7 +60,7 @@ void GraveyardMenu::createMoveActions()
 
 void GraveyardMenu::createViewActions()
 {
-    PlayerActions *playerActions = player->getLogic()->getPlayerActions();
+    PlayerActions *playerActions = player->getPlayerActions();
 
     aViewGraveyard = new QAction(this);
     connect(aViewGraveyard, &QAction::triggered, playerActions, &PlayerActions::actViewGraveyard);
@@ -77,9 +76,9 @@ void GraveyardMenu::populateRevealRandomMenuWithActivePlayers()
 
     mRevealRandomGraveyardCard->addSeparator();
 
-    const auto &players = player->getLogic()->getGame()->getPlayerManager()->getPlayers().values();
+    const auto &players = player->getGame()->getPlayerManager()->getPlayers().values();
     for (auto *other : players) {
-        if (other == player->getLogic()) {
+        if (other == player) {
             continue;
         }
         QAction *a = mRevealRandomGraveyardCard->addAction(other->getPlayerInfo()->getName());
@@ -91,7 +90,7 @@ void GraveyardMenu::populateRevealRandomMenuWithActivePlayers()
 void GraveyardMenu::onRevealRandomTriggered()
 {
     if (auto *a = qobject_cast<QAction *>(sender())) {
-        player->getLogic()->getPlayerActions()->actRevealRandomGraveyardCard(a->data().toInt());
+        player->getPlayerActions()->actRevealRandomGraveyardCard(a->data().toInt());
     }
 }
 
@@ -101,7 +100,7 @@ void GraveyardMenu::retranslateUi()
 
     aViewGraveyard->setText(tr("&View graveyard"));
 
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
         moveGraveMenu->setTitle(tr("&Move graveyard to..."));
         aMoveGraveToTopLibrary->setText(tr("&Top of library"));
         aMoveGraveToBottomLibrary->setText(tr("&Bottom of library"));

cockatrice/src/game/player/menu/grave_menu.h

@@ -13,7 +13,7 @@
 #include <QAction>
 #include <QMenu>
 
-class PlayerGraphicsItem;
+class PlayerLogic;
 class GraveyardMenu : public TearOffMenu, public AbstractPlayerComponent
 {
     Q_OBJECT
@@ -21,7 +21,7 @@ signals:
     void newPlayerActionCreated(QAction *action);
 
 public:
-    explicit GraveyardMenu(PlayerGraphicsItem *player, QWidget *parent = nullptr);
+    explicit GraveyardMenu(PlayerLogic *player, QWidget *parent = nullptr);
     void createMoveActions();
     void createViewActions();
     void populateRevealRandomMenuWithActivePlayers();
@@ -40,7 +40,7 @@ public:
     QAction *aMoveGraveToRfg = nullptr;
 
 private:
-    PlayerGraphicsItem *player;
+    PlayerLogic *player;
 };
 
 #endif // COCKATRICE_GRAVE_MENU_H

cockatrice/src/game/player/menu/hand_menu.cpp

@@ -3,22 +3,18 @@
 #include "../../../client/settings/cache_settings.h"
 #include "../../../client/settings/shortcuts_settings.h"
 #include "../../../game_graphics/zones/hand_zone.h"
-#include "../../game/abstract_game.h"
-#include "../../game/player/player_actions.h"
-#include "../../game/player/player_logic.h"
-#include "../player_graphics_item.h"
+#include "../../abstract_game.h"
+#include "../player_actions.h"
+#include "../player_logic.h"
 
 #include <QAction>
 #include <QMenu>
 #include <libcockatrice/utility/zone_names.h>
 
-HandMenu::HandMenu(PlayerGraphicsItem *_player, QWidget *parent) : TearOffMenu(parent), player(_player)
+HandMenu::HandMenu(PlayerLogic *_player, PlayerActions *actions, QWidget *parent) : TearOffMenu(parent), player(_player)
 {
-    auto *actions = player->getLogic()->getPlayerActions();
-
-    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
+    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
         aViewHand = new QAction(this);
-
         connect(aViewHand, &QAction::triggered, actions, &PlayerActions::actViewHand);
         addAction(aViewHand);
 
@@ -62,7 +58,7 @@ HandMenu::HandMenu(PlayerGraphicsItem *_player, QWidget *parent) : TearOffMenu(p
     addSeparator();
 
     aMulligan = new QAction(this);
-    connect(aMulligan, &QAction::triggered, actions, &PlayerActions::actRequestMulliganDialog);
+    connect(aMulligan, &QAction::triggered, actions, &PlayerActions::actMulligan);
     addAction(aMulligan);
 
     // Mulligan same size
@@ -79,7 +75,7 @@ HandMenu::HandMenu(PlayerGraphicsItem *_player, QWidget *parent) : TearOffMenu(p
 
     mMoveHandMenu = addTearOffMenu(QString());
 
-    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
+    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
         aMoveHandToTopLibrary = new QAction(this);
         aMoveHandToTopLibrary->setData(QList<QVariant>() << ZoneNames::DECK << 0);
         aMoveHandToBottomLibrary = new QAction(this);
@@ -89,7 +85,7 @@ HandMenu::HandMenu(PlayerGraphicsItem *_player, QWidget *parent) : TearOffMenu(p
         aMoveHandToRfg = new QAction(this);
         aMoveHandToRfg->setData(QList<QVariant>() << ZoneNames::EXILE << 0);
 
-        auto hand = player->getLogic()->getHandZone();
+        auto hand = player->getHandZone();
 
         connect(aMoveHandToTopLibrary, &QAction::triggered, hand, &HandZoneLogic::moveAllToZone);
         connect(aMoveHandToBottomLibrary, &QAction::triggered, hand, &HandZoneLogic::moveAllToZone);
@@ -111,7 +107,7 @@ void HandMenu::retranslateUi()
 {
     setTitle(tr("&Hand"));
 
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
         aViewHand->setText(tr("&View hand"));
 
         mSortHand->setTitle(tr("Sort hand by..."));
@@ -170,9 +166,9 @@ void HandMenu::populateRevealHandMenuWithActivePlayers()
 
     mRevealHand->addSeparator();
 
-    const auto &players = player->getLogic()->getGame()->getPlayerManager()->getPlayers().values();
+    const auto &players = player->getGame()->getPlayerManager()->getPlayers().values();
     for (auto *other : players) {
-        if (other == player->getLogic()) {
+        if (other == player) {
             continue;
         }
         QAction *a = mRevealHand->addAction(other->getPlayerInfo()->getName());
@@ -189,9 +185,9 @@ void HandMenu::populateRevealRandomHandCardMenuWithActivePlayers()
 
     mRevealRandomHandCard->addSeparator();
 
-    const auto &players = player->getLogic()->getGame()->getPlayerManager()->getPlayers().values();
+    const auto &players = player->getGame()->getPlayerManager()->getPlayers().values();
     for (auto *other : players) {
-        if (other == player->getLogic()) {
+        if (other == player) {
             continue;
         }
         QAction *a = mRevealRandomHandCard->addAction(other->getPlayerInfo()->getName());
@@ -208,7 +204,7 @@ void HandMenu::onRevealHandTriggered()
     }
 
     const int targetId = action->data().toInt();
-    player->getLogic()->getPlayerActions()->actRevealHand(targetId);
+    player->getPlayerActions()->actRevealHand(targetId);
 }
 
 void HandMenu::onRevealRandomHandCardTriggered()
@@ -219,5 +215,5 @@ void HandMenu::onRevealRandomHandCardTriggered()
     }
 
     const int targetId = action->data().toInt();
-    player->getLogic()->getPlayerActions()->actRevealRandomHandCard(targetId);
+    player->getPlayerActions()->actRevealRandomHandCard(targetId);
 }

cockatrice/src/game/player/menu/hand_menu.h

@@ -13,7 +13,7 @@
 #include <QAction>
 #include <QMenu>
 
-class PlayerGraphicsItem;
+class PlayerLogic;
 class PlayerActions;
 
 class HandMenu : public TearOffMenu, public AbstractPlayerComponent
@@ -21,7 +21,7 @@ class HandMenu : public TearOffMenu, public AbstractPlayerComponent
     Q_OBJECT
 
 public:
-    HandMenu(PlayerGraphicsItem *player, QWidget *parent = nullptr);
+    HandMenu(PlayerLogic *player, PlayerActions *actions, QWidget *parent = nullptr);
 
     QMenu *revealHandMenu() const
     {
@@ -43,7 +43,7 @@ private slots:
     void onRevealRandomHandCardTriggered();
 
 private:
-    PlayerGraphicsItem *player;
+    PlayerLogic *player;
 
     QAction *aViewHand = nullptr;
     QAction *aMulligan = nullptr;

cockatrice/src/game/player/menu/library_menu.cpp

@@ -3,16 +3,14 @@
 #include "../../../client/settings/cache_settings.h"
 #include "../../../client/settings/shortcuts_settings.h"
 #include "../../../interface/widgets/tabs/tab_game.h"
-#include "../../game/abstract_game.h"
-#include "../../game/player/player_actions.h"
-#include "../../game/player/player_logic.h"
-#include "../player_graphics_item.h"
+#include "../../abstract_game.h"
+#include "../player_actions.h"
+#include "../player_logic.h"
 
 #include <QAction>
-#include <QGraphicsView>
 #include <QMenu>
 
-LibraryMenu::LibraryMenu(PlayerGraphicsItem *_player, QWidget *parent) : TearOffMenu(parent), player(_player)
+LibraryMenu::LibraryMenu(PlayerLogic *_player, QWidget *parent) : TearOffMenu(parent), player(_player)
 {
     createDrawActions();
     createShuffleActions();
@@ -77,8 +75,8 @@ LibraryMenu::LibraryMenu(PlayerGraphicsItem *_player, QWidget *parent) : TearOff
     bottomLibraryMenu->addSeparator();
     bottomLibraryMenu->addAction(aShuffleBottomCards);
 
-    connect(player->getLogic(), &PlayerLogic::resetTopCardMenuActions, this, &LibraryMenu::resetTopCardMenuActions);
-    connect(player->getLogic(), &PlayerLogic::deckChanged, this, &LibraryMenu::enableOpenInDeckEditorAction);
+    connect(player, &PlayerLogic::resetTopCardMenuActions, this, &LibraryMenu::resetTopCardMenuActions);
+    connect(player, &PlayerLogic::deckChanged, this, &LibraryMenu::enableOpenInDeckEditorAction);
 
     retranslateUi();
 }
@@ -96,41 +94,41 @@ void LibraryMenu::resetTopCardMenuActions()
 
 void LibraryMenu::createDrawActions()
 {
-    PlayerActions *playerActions = player->getLogic()->getPlayerActions();
+    PlayerActions *playerActions = player->getPlayerActions();
 
-    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
+    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
         aDrawCard = new QAction(this);
         connect(aDrawCard, &QAction::triggered, playerActions, &PlayerActions::actDrawCard);
         aDrawCards = new QAction(this);
-        connect(aDrawCards, &QAction::triggered, playerActions, &PlayerActions::actRequestDrawCardsDialog);
+        connect(aDrawCards, &QAction::triggered, playerActions, &PlayerActions::actDrawCards);
         aUndoDraw = new QAction(this);
         connect(aUndoDraw, &QAction::triggered, playerActions, &PlayerActions::actUndoDraw);
         aDrawBottomCard = new QAction(this);
         connect(aDrawBottomCard, &QAction::triggered, playerActions, &PlayerActions::actDrawBottomCard);
         aDrawBottomCards = new QAction(this);
-        connect(aDrawBottomCards, &QAction::triggered, playerActions, &PlayerActions::actRequestDrawBottomCardsDialog);
+        connect(aDrawBottomCards, &QAction::triggered, playerActions, &PlayerActions::actDrawBottomCards);
     }
 }
 
 void LibraryMenu::createShuffleActions()
 {
-    PlayerActions *playerActions = player->getLogic()->getPlayerActions();
+    PlayerActions *playerActions = player->getPlayerActions();
 
-    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
+    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
         aShuffle = new QAction(this);
         connect(aShuffle, &QAction::triggered, playerActions, &PlayerActions::actShuffle);
         aShuffleTopCards = new QAction(this);
-        connect(aShuffleTopCards, &QAction::triggered, playerActions, &PlayerActions::actRequestShuffleTopDialog);
+        connect(aShuffleTopCards, &QAction::triggered, playerActions, &PlayerActions::actShuffleTop);
         aShuffleBottomCards = new QAction(this);
-        connect(aShuffleBottomCards, &QAction::triggered, playerActions, &PlayerActions::actRequestShuffleBottomDialog);
+        connect(aShuffleBottomCards, &QAction::triggered, playerActions, &PlayerActions::actShuffleBottom);
     }
 }
 
 void LibraryMenu::createMoveActions()
 {
-    PlayerActions *playerActions = player->getLogic()->getPlayerActions();
+    PlayerActions *playerActions = player->getPlayerActions();
 
-    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
+    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
         aMoveTopToPlay = new QAction(this);
         connect(aMoveTopToPlay, &QAction::triggered, playerActions, &PlayerActions::actMoveTopCardToPlay);
         aMoveTopToPlayFaceDown = new QAction(this);
@@ -151,8 +149,7 @@ void LibraryMenu::createMoveActions()
         connect(aMoveTopCardsToExileFaceDown, &QAction::triggered, playerActions,
                 &PlayerActions::actMoveTopCardsToExileFaceDown);
         aMoveTopCardsUntil = new QAction(this);
-        connect(aMoveTopCardsUntil, &QAction::triggered, playerActions,
-                &PlayerActions::actRequestMoveTopCardsUntilDialog);
+        connect(aMoveTopCardsUntil, &QAction::triggered, playerActions, &PlayerActions::actMoveTopCardsUntil);
         aMoveTopCardToBottom = new QAction(this);
         connect(aMoveTopCardToBottom, &QAction::triggered, playerActions, &PlayerActions::actMoveTopCardToBottom);
 
@@ -184,16 +181,16 @@ void LibraryMenu::createMoveActions()
 
 void LibraryMenu::createViewActions()
 {
-    PlayerActions *playerActions = player->getLogic()->getPlayerActions();
+    PlayerActions *playerActions = player->getPlayerActions();
 
-    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
+    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
         aViewLibrary = new QAction(this);
         connect(aViewLibrary, &QAction::triggered, playerActions, &PlayerActions::actViewLibrary);
 
         aViewTopCards = new QAction(this);
-        connect(aViewTopCards, &QAction::triggered, playerActions, &PlayerActions::actRequestViewTopCardsDialog);
+        connect(aViewTopCards, &QAction::triggered, playerActions, &PlayerActions::actViewTopCards);
         aViewBottomCards = new QAction(this);
-        connect(aViewBottomCards, &QAction::triggered, playerActions, &PlayerActions::actRequestViewBottomCardsDialog);
+        connect(aViewBottomCards, &QAction::triggered, playerActions, &PlayerActions::actViewBottomCards);
         aAlwaysRevealTopCard = new QAction(this);
         aAlwaysRevealTopCard->setCheckable(true);
         connect(aAlwaysRevealTopCard, &QAction::triggered, playerActions, &PlayerActions::actAlwaysRevealTopCard);
@@ -210,7 +207,7 @@ void LibraryMenu::retranslateUi()
 {
     setTitle(tr("&Library"));
 
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
         aViewLibrary->setText(tr("&View library"));
         aViewTopCards->setText(tr("View &top cards of library..."));
         aViewBottomCards->setText(tr("View bottom cards of library..."));
@@ -266,9 +263,9 @@ void LibraryMenu::populateRevealLibraryMenuWithActivePlayers()
 
     mRevealLibrary->addSeparator();
 
-    const auto &players = player->getLogic()->getGame()->getPlayerManager()->getPlayers().values();
+    const auto &players = player->getGame()->getPlayerManager()->getPlayers().values();
     for (auto *other : players) {
-        if (other == player->getLogic()) {
+        if (other == player) {
             continue;
         }
         QAction *a = mRevealLibrary->addAction(other->getPlayerInfo()->getName());
@@ -281,9 +278,9 @@ void LibraryMenu::populateLendLibraryMenuWithActivePlayers()
 {
     mLendLibrary->clear();
 
-    const auto &players = player->getLogic()->getGame()->getPlayerManager()->getPlayers().values();
+    const auto &players = player->getGame()->getPlayerManager()->getPlayers().values();
     for (auto *other : players) {
-        if (other == player->getLogic()) {
+        if (other == player) {
             continue;
         }
         QAction *a = mLendLibrary->addAction(other->getPlayerInfo()->getName());
@@ -302,9 +299,9 @@ void LibraryMenu::populateRevealTopCardMenuWithActivePlayers()
 
     mRevealTopCard->addSeparator();
 
-    const auto &players = player->getLogic()->getGame()->getPlayerManager()->getPlayers().values();
+    const auto &players = player->getGame()->getPlayerManager()->getPlayers().values();
     for (auto *other : players) {
-        if (other == player->getLogic()) {
+        if (other == player) {
             continue;
         }
         QAction *a = mRevealTopCard->addAction(other->getPlayerInfo()->getName());
@@ -316,33 +313,27 @@ void LibraryMenu::populateRevealTopCardMenuWithActivePlayers()
 void LibraryMenu::onRevealLibraryTriggered()
 {
     if (auto *a = qobject_cast<QAction *>(sender())) {
-        player->getLogic()->getPlayerActions()->actRevealLibrary(a->data().toInt());
+        player->getPlayerActions()->actRevealLibrary(a->data().toInt());
     }
 }
 
 void LibraryMenu::onLendLibraryTriggered()
 {
     if (auto *a = qobject_cast<QAction *>(sender())) {
-        player->getLogic()->getPlayerActions()->actLendLibrary(a->data().toInt());
+        player->getPlayerActions()->actLendLibrary(a->data().toInt());
     }
 }
 
 void LibraryMenu::onRevealTopCardTriggered()
 {
-    QWidget *parent = nullptr;
-    if (auto *view = player->scene() ? player->scene()->views().value(0) : nullptr) {
-        parent = view->window();
-    }
     if (auto *a = qobject_cast<QAction *>(sender())) {
-
-        int deckSize = player->getLogic()->getDeckZone()->getCards().size();
-        bool ok = true;
-        int number = QInputDialog::getInt(parent, tr("Reveal top cards of library"),
+        int deckSize = player->getDeckZone()->getCards().size();
+        bool ok;
+        int number = QInputDialog::getInt(player->getGame()->getTab(), tr("Reveal top cards of library"),
                                           tr("Number of cards: (max. %1)").arg(deckSize), defaultNumberTopCards, 1,
                                           deckSize, 1, &ok);
-
         if (ok) {
-            player->getLogic()->getPlayerActions()->actRevealTopCards(a->data().toInt(), number);
+            player->getPlayerActions()->actRevealTopCards(a->data().toInt(), number);
             defaultNumberTopCards = number;
         }
     }

cockatrice/src/game/player/menu/library_menu.h

@@ -13,7 +13,6 @@
 #include <QAction>
 #include <QMenu>
 
-class PlayerGraphicsItem;
 class PlayerLogic;
 class PlayerActions;
 
@@ -25,7 +24,7 @@ public slots:
     void resetTopCardMenuActions();
 
 public:
-    LibraryMenu(PlayerGraphicsItem *player, QWidget *parent = nullptr);
+    LibraryMenu(PlayerLogic *player, QWidget *parent = nullptr);
     void createDrawActions();
     void createShuffleActions();
     void createMoveActions();
@@ -112,7 +111,7 @@ public:
     int defaultNumberTopCards = 1;
 
 private:
-    PlayerGraphicsItem *player;
+    PlayerLogic *player;
 };
 
 #endif // COCKATRICE_LIBRARY_MENU_H

cockatrice/src/game/player/menu/move_menu.cpp

@@ -1,11 +1,10 @@
 #include "move_menu.h"
 
-#include "../../game/player/player_actions.h"
-#include "../../game/player/player_logic.h"
 #include "../card_menu_action_type.h"
-#include "../player_graphics_item.h"
+#include "../player_actions.h"
+#include "../player_logic.h"
 
-MoveMenu::MoveMenu(PlayerGraphicsItem *player) : QMenu(tr("Move to"))
+MoveMenu::MoveMenu(PlayerLogic *player) : QMenu(tr("Move to"))
 {
     aMoveToTopLibrary = new QAction(this);
     aMoveToTopLibrary->setData(cmMoveToTopLibrary);
@@ -21,22 +20,14 @@ MoveMenu::MoveMenu(PlayerGraphicsItem *player) : QMenu(tr("Move to"))
     aMoveToExile = new QAction(this);
     aMoveToExile->setData(cmMoveToExile);
 
-    auto *actions = player->getLogic()->getPlayerActions();
-
-    auto invoke = [player](CardMenuActionType type) {
-        return [type, player]() {
-            player->getLogic()->getPlayerActions()->cardMenuAction(player->getGameScene()->selectedCards(), type);
-        };
-    };
-
-    connect(aMoveToTopLibrary, &QAction::triggered, actions, invoke(cmMoveToTopLibrary));
-    connect(aMoveToBottomLibrary, &QAction::triggered, actions, invoke(cmMoveToBottomLibrary));
-    connect(aMoveToXfromTopOfLibrary, &QAction::triggered, actions,
-            &PlayerActions::actRequestMoveCardXCardsFromTopDialog);
-    connect(aMoveToTable, &QAction::triggered, actions, invoke(cmMoveToTable));
-    connect(aMoveToHand, &QAction::triggered, actions, invoke(cmMoveToHand));
-    connect(aMoveToGraveyard, &QAction::triggered, actions, invoke(cmMoveToGraveyard));
-    connect(aMoveToExile, &QAction::triggered, actions, invoke(cmMoveToExile));
+    connect(aMoveToTopLibrary, &QAction::triggered, player->getPlayerActions(), &PlayerActions::cardMenuAction);
+    connect(aMoveToBottomLibrary, &QAction::triggered, player->getPlayerActions(), &PlayerActions::cardMenuAction);
+    connect(aMoveToXfromTopOfLibrary, &QAction::triggered, player->getPlayerActions(),
+            &PlayerActions::actMoveCardXCardsFromTop);
+    connect(aMoveToTable, &QAction::triggered, player->getPlayerActions(), &PlayerActions::cardMenuAction);
+    connect(aMoveToHand, &QAction::triggered, player->getPlayerActions(), &PlayerActions::cardMenuAction);
+    connect(aMoveToGraveyard, &QAction::triggered, player->getPlayerActions(), &PlayerActions::cardMenuAction);
+    connect(aMoveToExile, &QAction::triggered, player->getPlayerActions(), &PlayerActions::cardMenuAction);
 
     addAction(aMoveToTopLibrary);
     addAction(aMoveToXfromTopOfLibrary);

cockatrice/src/game/player/menu/move_menu.h

@@ -8,13 +8,13 @@
 #define COCKATRICE_MOVE_MENU_H
 #include <QMenu>
 
-class PlayerGraphicsItem;
+class PlayerLogic;
 class MoveMenu : public QMenu
 {
     Q_OBJECT
 
 public:
-    explicit MoveMenu(PlayerGraphicsItem *player);
+    explicit MoveMenu(PlayerLogic *player);
     void setShortcutsActive();
     void retranslateUi();
 

cockatrice/src/game/player/menu/player_menu.cpp

@@ -5,21 +5,17 @@
 #include "../../../game_graphics/zones/table_zone.h"
 #include "../../../interface/widgets/tabs/tab_game.h"
 #include "../../board/card_item.h"
-#include "../player_graphics_item.h"
 #include "card_menu.h"
 #include "hand_menu.h"
 
 #include <libcockatrice/protocol/pb/command_reveal_cards.pb.h>
 
-PlayerMenu::PlayerMenu(PlayerGraphicsItem *_player) : QObject(_player), player(_player)
+PlayerMenu::PlayerMenu(PlayerLogic *_player) : QObject(_player), player(_player)
 {
-    connect(player->getLogic(), &PlayerLogic::requestCardMenuUpdate, this, &PlayerMenu::updateCardMenu);
-    connect(this, &PlayerMenu::cardInfoRequested, player, &PlayerGraphicsItem::cardInfoRequested);
-
     playerMenu = new TearOffMenu();
 
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
-        handMenu = addManagedMenu<HandMenu>(player, playerMenu);
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
+        handMenu = addManagedMenu<HandMenu>(player, player->getPlayerActions(), playerMenu);
         libraryMenu = addManagedMenu<LibraryMenu>(player, playerMenu);
     } else {
         handMenu = nullptr;
@@ -29,7 +25,7 @@ PlayerMenu::PlayerMenu(PlayerGraphicsItem *_player) : QObject(_player), player(_
     graveMenu = addManagedMenu<GraveyardMenu>(player, playerMenu);
     rfgMenu = addManagedMenu<RfgMenu>(player, playerMenu);
 
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
         sideboardMenu = addManagedMenu<SideboardMenu>(player, playerMenu);
         customZonesMenu = addManagedMenu<CustomZoneMenu>(player);
         playerMenu->addSeparator();
@@ -44,7 +40,7 @@ PlayerMenu::PlayerMenu(PlayerGraphicsItem *_player) : QObject(_player), player(_
         utilityMenu = nullptr;
     }
 
-    if (player->getLogic()->getPlayerInfo()->getLocal()) {
+    if (player->getPlayerInfo()->getLocal()) {
         sayMenu = addManagedMenu<SayMenu>(player);
     } else {
         sayMenu = nullptr;
@@ -59,13 +55,13 @@ PlayerMenu::PlayerMenu(PlayerGraphicsItem *_player) : QObject(_player), player(_
 
 void PlayerMenu::setMenusForGraphicItems()
 {
-    player->getTableZoneGraphicsItem()->setMenu(playerMenu);
-    player->getGraveyardZoneGraphicsItem()->setMenu(graveMenu, graveMenu->aViewGraveyard);
-    player->getRfgZoneGraphicsItem()->setMenu(rfgMenu, rfgMenu->aViewRfg);
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
-        player->getHandZoneGraphicsItem()->setMenu(handMenu);
-        player->getDeckZoneGraphicsItem()->setMenu(libraryMenu, libraryMenu->aDrawCard);
-        player->getSideboardZoneGraphicsItem()->setMenu(sideboardMenu);
+    player->getGraphicsItem()->getTableZoneGraphicsItem()->setMenu(playerMenu);
+    player->getGraphicsItem()->getGraveyardZoneGraphicsItem()->setMenu(graveMenu, graveMenu->aViewGraveyard);
+    player->getGraphicsItem()->getRfgZoneGraphicsItem()->setMenu(rfgMenu, rfgMenu->aViewRfg);
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
+        player->getGraphicsItem()->getHandZoneGraphicsItem()->setMenu(handMenu);
+        player->getGraphicsItem()->getDeckZoneGraphicsItem()->setMenu(libraryMenu, libraryMenu->aDrawCard);
+        player->getGraphicsItem()->getSideboardZoneGraphicsItem()->setMenu(sideboardMenu);
     }
 }
 
@@ -78,14 +74,12 @@ QMenu *PlayerMenu::updateCardMenu(const CardItem *card)
 
     // If is spectator (as spectators don't need card menus), return
     // only update the menu if the card is actually selected
-    if ((player->getLogic()->getGame()->getPlayerManager()->isSpectator() &&
-         !player->getLogic()->getGame()->getPlayerManager()->isJudge()) ||
-        player->getLogic()->getGame()->getActiveCard() != card) {
+    if ((player->getGame()->getPlayerManager()->isSpectator() && !player->getGame()->getPlayerManager()->isJudge()) ||
+        player->getGame()->getActiveCard() != card) {
         return nullptr;
     }
 
-    CardMenu *menu = new CardMenu(player, card, shortcutsActive);
-    connect(menu, &CardMenu::cardInfoRequested, this, &PlayerMenu::cardInfoRequested);
+    QMenu *menu = new CardMenu(player, card, shortcutsActive);
     emit cardMenuUpdated(menu);
 
     return menu;
@@ -93,7 +87,7 @@ QMenu *PlayerMenu::updateCardMenu(const CardItem *card)
 
 void PlayerMenu::retranslateUi()
 {
-    playerMenu->setTitle(tr("Player \"%1\"").arg(player->getLogic()->getPlayerInfo()->getName()));
+    playerMenu->setTitle(tr("Player \"%1\"").arg(player->getPlayerInfo()->getName()));
 
     for (auto *component : managedComponents) {
         component->retranslateUi();
@@ -110,8 +104,7 @@ void PlayerMenu::refreshShortcuts()
 {
     if (shortcutsActive) {
         // Judges get access to every player's menus but only want shortcuts to be set for their own.
-        if (player->getLogic()->getPlayerInfo()->getLocalOrJudge() &&
-            !player->getLogic()->getPlayerInfo()->getLocal()) {
+        if (player->getPlayerInfo()->getLocalOrJudge() && !player->getPlayerInfo()->getLocal()) {
             setShortcutsInactive();
         } else {
             setShortcutsActive();

cockatrice/src/game/player/menu/player_menu.h

@@ -8,6 +8,7 @@
 #define COCKATRICE_PLAYER_MENU_H
 
 #include "../../../interface/widgets/menus/tearoff_menu.h"
+#include "../player_logic.h"
 #include "custom_zone_menu.h"
 #include "grave_menu.h"
 #include "hand_menu.h"
@@ -22,31 +23,29 @@
 #include <QObject>
 
 class CardItem;
-class CardMenu;
-class PlayerGraphicsItem;
 class PlayerMenu : public QObject
 {
     Q_OBJECT
 
 signals:
-    void cardMenuUpdated(CardMenu *cardMenu);
-    void cardInfoRequested(const CardRef &cardRef);
+    void cardMenuUpdated(QMenu *cardMenu);
     void shortcutsActivated();
     void shortcutsDeactivated();
     void retranslateRequested();
 
 public slots:
     void setMenusForGraphicItems();
-    QMenu *updateCardMenu(const CardItem *card);
 
 private slots:
     void refreshShortcuts();
 
 public:
-    explicit PlayerMenu(PlayerGraphicsItem *player);
+    explicit PlayerMenu(PlayerLogic *player);
     /** @brief Retranslate all user-visible strings. Called on language change. */
     void retranslateUi();
 
+    QMenu *updateCardMenu(const CardItem *card);
+
     [[nodiscard]] QMenu *getPlayerMenu() const
     {
         return playerMenu;
@@ -78,7 +77,7 @@ public:
     void setShortcutsInactive();
 
 private:
-    PlayerGraphicsItem *player;
+    PlayerLogic *player;
     TearOffMenu *playerMenu;
     QMenu *countersMenu;
     HandMenu *handMenu;

cockatrice/src/game/player/menu/pt_menu.cpp

@@ -1,43 +1,32 @@
 #include "pt_menu.h"
 
-#include "../../game/player/player_actions.h"
-#include "../../game/player/player_logic.h"
-#include "../player_graphics_item.h"
+#include "../player_actions.h"
+#include "../player_logic.h"
 
-PtMenu::PtMenu(PlayerGraphicsItem *player) : QMenu(tr("Power / toughness"))
+PtMenu::PtMenu(PlayerLogic *player) : QMenu(tr("Power / toughness"))
 {
-    PlayerActions *playerActions = player->getLogic()->getPlayerActions();
+    PlayerActions *playerActions = player->getPlayerActions();
 
     aIncP = new QAction(this);
-    connect(aIncP, &QAction::triggered, playerActions,
-            [player, playerActions] { playerActions->actIncP(player->getGameScene()->selectedCards()); });
+    connect(aIncP, &QAction::triggered, playerActions, &PlayerActions::actIncP);
     aDecP = new QAction(this);
-    connect(aDecP, &QAction::triggered, playerActions,
-            [player, playerActions] { playerActions->actDecP(player->getGameScene()->selectedCards()); });
+    connect(aDecP, &QAction::triggered, playerActions, &PlayerActions::actDecP);
     aIncT = new QAction(this);
-    connect(aIncT, &QAction::triggered, playerActions,
-            [player, playerActions] { playerActions->actIncT(player->getGameScene()->selectedCards()); });
+    connect(aIncT, &QAction::triggered, playerActions, &PlayerActions::actIncT);
     aDecT = new QAction(this);
-    connect(aDecT, &QAction::triggered, playerActions,
-            [player, playerActions] { playerActions->actDecT(player->getGameScene()->selectedCards()); });
+    connect(aDecT, &QAction::triggered, playerActions, &PlayerActions::actDecT);
     aIncPT = new QAction(this);
-    connect(aIncPT, &QAction::triggered, playerActions,
-            [player, playerActions] { playerActions->actIncPT(player->getGameScene()->selectedCards()); });
+    connect(aIncPT, &QAction::triggered, playerActions, [playerActions] { playerActions->actIncPT(); });
     aDecPT = new QAction(this);
-    connect(aDecPT, &QAction::triggered, playerActions,
-            [player, playerActions] { playerActions->actDecPT(player->getGameScene()->selectedCards()); });
+    connect(aDecPT, &QAction::triggered, playerActions, &PlayerActions::actDecPT);
     aFlowP = new QAction(this);
-    connect(aFlowP, &QAction::triggered, playerActions,
-            [player, playerActions] { playerActions->actFlowP(player->getGameScene()->selectedCards()); });
+    connect(aFlowP, &QAction::triggered, playerActions, &PlayerActions::actFlowP);
     aFlowT = new QAction(this);
-    connect(aFlowT, &QAction::triggered, playerActions,
-            [player, playerActions] { playerActions->actFlowT(player->getGameScene()->selectedCards()); });
+    connect(aFlowT, &QAction::triggered, playerActions, &PlayerActions::actFlowT);
     aSetPT = new QAction(this);
-    connect(aSetPT, &QAction::triggered, playerActions,
-            [player, playerActions] { playerActions->actRequestSetPTDialog(player->getGameScene()->selectedCards()); });
+    connect(aSetPT, &QAction::triggered, playerActions, &PlayerActions::actSetPT);
     aResetPT = new QAction(this);
-    connect(aResetPT, &QAction::triggered, playerActions,
-            [player, playerActions] { playerActions->actResetPT(player->getGameScene()->selectedCards()); });
+    connect(aResetPT, &QAction::triggered, playerActions, &PlayerActions::actResetPT);
 
     addAction(aIncP);
     addAction(aDecP);

cockatrice/src/game/player/menu/pt_menu.h

@@ -8,14 +8,14 @@
 #define COCKATRICE_PT_MENU_H
 #include <QMenu>
 
-class PlayerGraphicsItem;
+class PlayerLogic;
 class PtMenu : public QMenu
 {
 
     Q_OBJECT
 
 public:
-    explicit PtMenu(PlayerGraphicsItem *player);
+    explicit PtMenu(PlayerLogic *player);
     void retranslateUi();
     void setShortcutsActive();
 

cockatrice/src/game/player/menu/rfg_menu.cpp

@@ -1,19 +1,18 @@
 #include "rfg_menu.h"
 
-#include "../../game/player/player_actions.h"
-#include "../../game/player/player_logic.h"
-#include "../player_graphics_item.h"
+#include "../player_actions.h"
+#include "../player_logic.h"
 
 #include <libcockatrice/utility/zone_names.h>
 
-RfgMenu::RfgMenu(PlayerGraphicsItem *_player, QWidget *parent) : TearOffMenu(parent), player(_player)
+RfgMenu::RfgMenu(PlayerLogic *_player, QWidget *parent) : TearOffMenu(parent), player(_player)
 {
     createMoveActions();
     createViewActions();
 
     addAction(aViewRfg);
 
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
         addSeparator();
         moveRfgMenu = addTearOffMenu(QString());
         moveRfgMenu->addAction(aMoveRfgToTopLibrary);
@@ -29,8 +28,8 @@ RfgMenu::RfgMenu(PlayerGraphicsItem *_player, QWidget *parent) : TearOffMenu(par
 
 void RfgMenu::createMoveActions()
 {
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
-        auto rfg = player->getLogic()->getRfgZone();
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
+        auto rfg = player->getRfgZone();
 
         aMoveRfgToTopLibrary = new QAction(this);
         aMoveRfgToTopLibrary->setData(QList<QVariant>() << ZoneNames::DECK << 0);
@@ -50,7 +49,7 @@ void RfgMenu::createMoveActions()
 
 void RfgMenu::createViewActions()
 {
-    PlayerActions *playerActions = player->getLogic()->getPlayerActions();
+    PlayerActions *playerActions = player->getPlayerActions();
 
     aViewRfg = new QAction(this);
     connect(aViewRfg, &QAction::triggered, playerActions, &PlayerActions::actViewRfg);
@@ -62,7 +61,7 @@ void RfgMenu::retranslateUi()
 
     aViewRfg->setText(tr("&View exile"));
 
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
         moveRfgMenu->setTitle(tr("&Move exile to..."));
         aMoveRfgToTopLibrary->setText(tr("&Top of library"));
         aMoveRfgToBottomLibrary->setText(tr("&Bottom of library"));

cockatrice/src/game/player/menu/rfg_menu.h

@@ -13,12 +13,12 @@
 #include <QAction>
 #include <QMenu>
 
-class PlayerGraphicsItem;
+class PlayerLogic;
 class RfgMenu : public TearOffMenu, public AbstractPlayerComponent
 {
     Q_OBJECT
 public:
-    explicit RfgMenu(PlayerGraphicsItem *player, QWidget *parent = nullptr);
+    explicit RfgMenu(PlayerLogic *player, QWidget *parent = nullptr);
     void createMoveActions();
     void createViewActions();
     void retranslateUi() override;
@@ -38,7 +38,7 @@ public:
     QAction *aMoveRfgToGrave = nullptr;
 
 private:
-    PlayerGraphicsItem *player;
+    PlayerLogic *player;
 };
 
 #endif // COCKATRICE_RFG_MENU_H

cockatrice/src/game/player/menu/say_menu.cpp

@@ -1,11 +1,10 @@
 #include "say_menu.h"
 
 #include "../../../client/settings/cache_settings.h"
-#include "../../game/player/player_actions.h"
-#include "../../game/player/player_logic.h"
-#include "../player_graphics_item.h"
+#include "../player_actions.h"
+#include "../player_logic.h"
 
-SayMenu::SayMenu(PlayerGraphicsItem *_player) : player(_player)
+SayMenu::SayMenu(PlayerLogic *_player) : player(_player)
 {
     connect(&SettingsCache::instance().messages(), &MessageSettings::messageMacrosChanged, this, &SayMenu::initSayMenu);
     initSayMenu();
@@ -45,7 +44,7 @@ void SayMenu::initSayMenu()
 
     for (int i = 0; i < count; ++i) {
         auto *newAction = new QAction(SettingsCache::instance().messages().getMessageAt(i), this);
-        connect(newAction, &QAction::triggered, player->getLogic()->getPlayerActions(), &PlayerActions::actSayMessage);
+        connect(newAction, &QAction::triggered, player->getPlayerActions(), &PlayerActions::actSayMessage);
         addAction(newAction);
     }
 

cockatrice/src/game/player/menu/say_menu.h

@@ -11,12 +11,12 @@
 
 #include <QMenu>
 
-class PlayerGraphicsItem;
+class PlayerLogic;
 class SayMenu : public QMenu, public AbstractPlayerComponent
 {
     Q_OBJECT
 public:
-    explicit SayMenu(PlayerGraphicsItem *player);
+    explicit SayMenu(PlayerLogic *player);
 
     void retranslateUi() override;
     void setShortcutsActive() override;
@@ -26,7 +26,7 @@ private slots:
     void initSayMenu();
 
 private:
-    PlayerGraphicsItem *player;
+    PlayerLogic *player;
     bool shortcutsActive = false;
 };
 

cockatrice/src/game/player/menu/sideboard_menu.cpp

@@ -1,16 +1,14 @@
 #include "sideboard_menu.h"
 
-#include "../../game/player/player_actions.h"
-#include "../../game/player/player_logic.h"
-#include "../player_graphics_item.h"
+#include "../player_actions.h"
+#include "../player_logic.h"
 
-SideboardMenu::SideboardMenu(PlayerGraphicsItem *player, QMenu *playerMenu) : QMenu(playerMenu)
+SideboardMenu::SideboardMenu(PlayerLogic *player, QMenu *playerMenu) : QMenu(playerMenu)
 {
     aViewSideboard = new QAction(this);
-    connect(aViewSideboard, &QAction::triggered, player->getLogic()->getPlayerActions(),
-            &PlayerActions::actViewSideboard);
+    connect(aViewSideboard, &QAction::triggered, player->getPlayerActions(), &PlayerActions::actViewSideboard);
 
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
         addAction(aViewSideboard);
     }
 

cockatrice/src/game/player/menu/sideboard_menu.h

@@ -11,19 +11,19 @@
 
 #include <QMenu>
 
-class PlayerGraphicsItem;
+class PlayerLogic;
 class SideboardMenu : public QMenu, public AbstractPlayerComponent
 {
     Q_OBJECT
 
 public:
-    explicit SideboardMenu(PlayerGraphicsItem *player, QMenu *playerMenu);
+    explicit SideboardMenu(PlayerLogic *player, QMenu *playerMenu);
     void retranslateUi() override;
     void setShortcutsActive() override;
     void setShortcutsInactive() override;
 
 private:
-    PlayerGraphicsItem *player;
+    PlayerLogic *player;
 
     QAction *aViewSideboard;
 };

cockatrice/src/game/player/menu/utility_menu.cpp

@@ -1,49 +1,41 @@
 #include "utility_menu.h"
 
 #include "../../../interface/deck_loader/deck_loader.h"
-#include "../../game/player/player_actions.h"
-#include "../../game/player/player_logic.h"
-#include "../player_graphics_item.h"
+#include "../player_actions.h"
+#include "../player_logic.h"
 #include "player_menu.h"
 
 #include <libcockatrice/deck_list/tree/deck_list_card_node.h>
 #include <libcockatrice/deck_list/tree/inner_deck_list_node.h>
 
-UtilityMenu::UtilityMenu(PlayerGraphicsItem *_player, QMenu *playerMenu) : QMenu(playerMenu), player(_player)
+UtilityMenu::UtilityMenu(PlayerLogic *_player, QMenu *playerMenu) : QMenu(playerMenu), player(_player)
 {
-    PlayerActions *playerActions = player->getLogic()->getPlayerActions();
-    connect(playerActions, &PlayerActions::requestEnableAndSetCreateAnotherTokenAction, this,
-            &UtilityMenu::setAndEnableCreateAnotherTokenAction);
-    connect(playerActions, &PlayerActions::requestSetLastToken, this, &UtilityMenu::setLastToken);
+    PlayerActions *playerActions = player->getPlayerActions();
 
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
         aUntapAll = new QAction(this);
         connect(aUntapAll, &QAction::triggered, playerActions, &PlayerActions::actUntapAll);
 
         aRollDie = new QAction(this);
-        connect(aRollDie, &QAction::triggered, playerActions, &PlayerActions::actRequestRollDieDialog);
+        connect(aRollDie, &QAction::triggered, playerActions, &PlayerActions::actRollDie);
 
         aFlipCoin = new QAction(this);
         connect(aFlipCoin, &QAction::triggered, playerActions, &PlayerActions::actFlipCoin);
 
         aCreateToken = new QAction(this);
-        connect(aCreateToken, &QAction::triggered, playerActions, [this]() {
-            player->getLogic()->getPlayerActions()->actRequestCreateTokenDialog(getPredefinedTokens());
-        });
+        connect(aCreateToken, &QAction::triggered, playerActions, &PlayerActions::actCreateToken);
 
         aCreateAnotherToken = new QAction(this);
         connect(aCreateAnotherToken, &QAction::triggered, playerActions, &PlayerActions::actCreateAnotherToken);
         aCreateAnotherToken->setEnabled(false);
 
         aIncrementAllCardCounters = new QAction(this);
-        connect(aIncrementAllCardCounters, &QAction::triggered, playerActions, [this]() {
-            player->getLogic()->getPlayerActions()->actIncrementAllCardCounters(
-                player->getGameScene()->selectedCards());
-        });
+        connect(aIncrementAllCardCounters, &QAction::triggered, playerActions,
+                &PlayerActions::actIncrementAllCardCounters);
 
         createPredefinedTokenMenu = new QMenu(QString());
         createPredefinedTokenMenu->setEnabled(false);
-        connect(player->getLogic(), &PlayerLogic::deckChanged, this, &UtilityMenu::populatePredefinedTokensMenu);
+        connect(player, &PlayerLogic::deckChanged, this, &UtilityMenu::populatePredefinedTokensMenu);
 
         playerMenu->addAction(aIncrementAllCardCounters);
         playerMenu->addSeparator();
@@ -74,7 +66,7 @@ void UtilityMenu::populatePredefinedTokensMenu()
     clear();
     setEnabled(false);
     predefinedTokens.clear();
-    const DeckList &deckList = player->getLogic()->getDeck();
+    const DeckList &deckList = player->getDeck();
 
     if (deckList.isEmpty()) {
         return;
@@ -92,24 +84,14 @@ void UtilityMenu::populatePredefinedTokensMenu()
             if (i < 10) {
                 a->setShortcut(QKeySequence("Alt+" + QString::number((i + 1) % 10)));
             }
-            connect(a, &QAction::triggered, player->getLogic()->getPlayerActions(),
-                    &PlayerActions::actCreatePredefinedToken);
+            connect(a, &QAction::triggered, player->getPlayerActions(), &PlayerActions::actCreatePredefinedToken);
         }
     }
 }
 
-void UtilityMenu::setLastToken(CardInfoPtr lastToken)
-{
-    if (!createAnotherTokenActionExists()) {
-        return;
-    }
-
-    player->getLogic()->getPlayerActions()->setLastTokenInfo(lastToken);
-}
-
 void UtilityMenu::retranslateUi()
 {
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
         aIncrementAllCardCounters->setText(tr("Increment all card counters"));
         aUntapAll->setText(tr("&Untap all permanents"));
         aRollDie->setText(tr("R&oll die..."));
@@ -124,7 +106,7 @@ void UtilityMenu::setShortcutsActive()
 {
     ShortcutsSettings &shortcuts = SettingsCache::instance().shortcuts();
 
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
         aIncrementAllCardCounters->setShortcuts(shortcuts.getShortcut("Player/aIncrementAllCardCounters"));
         aUntapAll->setShortcuts(shortcuts.getShortcut("Player/aUntapAll"));
         aRollDie->setShortcuts(shortcuts.getShortcut("Player/aRollDie"));
@@ -136,7 +118,7 @@ void UtilityMenu::setShortcutsActive()
 
 void UtilityMenu::setShortcutsInactive()
 {
-    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getPlayerInfo()->getLocalOrJudge()) {
         aUntapAll->setShortcut(QKeySequence());
         aRollDie->setShortcut(QKeySequence());
         aFlipCoin->setShortcut(QKeySequence());

cockatrice/src/game/player/menu/utility_menu.h

@@ -10,21 +10,19 @@
 #include "abstract_player_component.h"
 
 #include <QMenu>
-#include <libcockatrice/card/card_info.h>
 
-class PlayerGraphicsItem;
+class PlayerLogic;
 class UtilityMenu : public QMenu, public AbstractPlayerComponent
 {
     Q_OBJECT
 public slots:
     void populatePredefinedTokensMenu();
-    void setLastToken(CardInfoPtr lastToken);
     void retranslateUi() override;
     void setShortcutsActive() override;
     void setShortcutsInactive() override;
 
 public:
-    explicit UtilityMenu(PlayerGraphicsItem *player, QMenu *playerMenu);
+    explicit UtilityMenu(PlayerLogic *player, QMenu *playerMenu);
 
     [[nodiscard]] bool createAnotherTokenActionExists() const
     {
@@ -33,7 +31,7 @@ public:
 
     void setAndEnableCreateAnotherTokenAction(QString text)
     {
-        aCreateAnotherToken->setText(tr("C&reate another %1 token").arg(text));
+        aCreateAnotherToken->setText(text);
         aCreateAnotherToken->setEnabled(true);
     }
 
@@ -43,7 +41,7 @@ public:
     }
 
 private:
-    PlayerGraphicsItem *player;
+    PlayerLogic *player;
     QStringList predefinedTokens;
 
     QMenu *createPredefinedTokenMenu;

cockatrice/src/game/player/player_actions.h

@@ -7,11 +7,8 @@
 
 #ifndef COCKATRICE_PLAYER_ACTIONS_H
 #define COCKATRICE_PLAYER_ACTIONS_H
-
-#include "../../game_graphics/board/card_item.h"
-#include "../../game_graphics/dialogs/dlg_create_token.h"
-#include "../../game_graphics/dialogs/dlg_move_top_cards_until.h"
-#include "../../game_graphics/player/card_menu_action_type.h"
+#include "../dialogs/dlg_create_token.h"
+#include "../dialogs/dlg_move_top_cards_until.h"
 #include "event_processing_options.h"
 #include "player_logic.h"
 
@@ -28,6 +25,7 @@ class Message;
 }
 } // namespace google
 
+class CardItem;
 class Command_MoveCard;
 class GameEventContext;
 class PendingCommand;
@@ -58,75 +56,30 @@ public:
         return movingCardsUntil;
     }
 
-signals:
-    void requestViewTopCardsDialog(int defaultNumberTopCards, int deckSize);
-    void requestViewBottomCardsDialog(int defaultNumberBottomCards, int deckSize);
-    void requestShuffleTopDialog(int defaultNumberTopCards, int maxCards);
-    void requestShuffleBottomDialog(int defaultNumberBottomCards, int maxCards);
-    void requestMulliganDialog(int startSize, int handSize, int deckSize);
-    void requestDrawCardsDialog(int defaultNumberTopCards, int deckSize);
-    void requestMoveTopCardsToDialog(int defaultNumberTopCards,
-                                     int maxCards,
-                                     const QString &targetZone,
-                                     const QString &zoneDisplayName,
-                                     bool faceDown);
-    void requestMoveTopCardsUntilDialog(MoveTopCardsUntilOptions options);
-    void requestMoveBottomCardsToDialog(int defaultNumberBottomCards,
-                                        int maxCards,
-                                        const QString &targetZone,
-                                        const QString &zoneDisplayName,
-                                        bool faceDown);
-    void requestDrawBottomCardsDialog(int defaultNumberBottomCards, int maxCards);
-    void requestRollDieDialog();
-    void requestCreateTokenDialog(const QStringList &predefinedTokens);
-    void requestCreateRelatedFromRelationDialog(const CardItem *sourceCard, const CardRelation *cardRelation);
-    void requestMoveCardXCardsFromTopDialog(int defaultNumberTopCardsToPlaceBelow, int deckSize);
-    void requestSetPTDialog(const QString &oldPT);
-    void requestSetAnnotationDialog(const QString &oldAnnotation);
-    void requestSetCardCounterDialog(int counterId, const QString &oldValueForDlg);
-    void requestZoneViewToggle(const QString &zoneName, int numberCards, bool isReversed = false);
-    void requestSortHand(const QList<CardList::SortOption> &options);
-    void requestEnableAndSetCreateAnotherTokenAction(const QString &lastTokenName);
-    void requestSetLastToken(CardInfoPtr lastToken);
-
 public slots:
     void setLastToken(CardInfoPtr cardInfo);
-    void setLastTokenInfo(CardInfoPtr cardInfo);
     void playCard(CardItem *c, bool faceDown);
     void playCardToTable(const CardItem *c, bool faceDown);
 
     void actUntapAll();
-    void actRequestRollDieDialog();
-    void actRollDie(int sides, int count);
+    void actRollDie();
     void actFlipCoin();
-    void actRequestCreateTokenDialog(const QStringList &predefinedTokens);
-    void actCreateToken(TokenInfo tokenToCreate);
+    void actCreateToken();
     void actCreateAnotherToken();
-    void actRequestCreateRelatedFromRelationDialog(const CardItem *sourceCard, const CardRelation *cardRelation);
-    bool createRelatedFromRelation(const CardItem *sourceCard, const CardRelation *cardRelation, int variableCount);
-    void onRelatedCardCreated(const CardItem *sourceCard, const CardRelation *cardRelation);
-    void setLastRelatedCreationSucceeded(bool succeeded)
-    {
-        lastRelatedCreationSucceeded = succeeded;
-    }
     void actShuffle();
-    void actRequestShuffleTopDialog();
-    void actShuffleTop(int number);
-    void actRequestShuffleBottomDialog();
-    void actShuffleBottom(int number);
+    void actShuffleTop();
+    void actShuffleBottom();
     void actDrawCard();
-    void actRequestDrawCardsDialog();
-    void actDrawCards(int number);
+    void actDrawCards();
     void actUndoDraw();
-    void actRequestMulliganDialog();
-    void actMulligan(int number);
+    void actMulligan();
     void actMulliganSameSize();
     void actMulliganMinusOne();
     void doMulligan(int number);
 
-    void actPlay(QList<CardItem *> selectedCards);
-    void actPlayFacedown(QList<CardItem *> selectedCards);
-    void actHide(QList<CardItem *> selectedCards);
+    void actPlay();
+    void actPlayFacedown();
+    void actHide();
 
     void actMoveTopCardToPlay();
     void actMoveTopCardToPlayFaceDown();
@@ -136,14 +89,10 @@ public slots:
     void actMoveTopCardsToGraveFaceDown();
     void actMoveTopCardsToExile();
     void actMoveTopCardsToExileFaceDown();
-    void actRequestMoveTopCardsUntilDialog();
-    void moveTopCardsUntil(const QString &expr, MoveTopCardsUntilOptions options);
+    void actMoveTopCardsUntil();
     void actMoveTopCardToBottom();
-    void actRequestMoveTopCardsToDialog(const QString &targetZone, const QString &zoneDisplayName, bool faceDown);
-    void moveTopCardsTo(int number, const QString &targetZone, bool faceDown);
     void actDrawBottomCard();
-    void actRequestDrawBottomCardsDialog();
-    void actDrawBottomCards(int number);
+    void actDrawBottomCards();
     void actMoveBottomCardToPlay();
     void actMoveBottomCardToPlayFaceDown();
     void actMoveBottomCardToGrave();
@@ -153,8 +102,6 @@ public slots:
     void actMoveBottomCardsToExile();
     void actMoveBottomCardsToExileFaceDown();
     void actMoveBottomCardToTop();
-    void actRequestMoveBottomCardsToDialog(const QString &targetZone, const QString &zoneDisplayName, bool faceDown);
-    void moveBottomCardsTo(int number, const QString &targetZone, bool faceDown);
 
     void actSelectAll();
     void actSelectRow();
@@ -162,12 +109,10 @@ public slots:
 
     void actViewLibrary();
     void actViewHand();
-    void actRequestViewTopCardsDialog();
-    void actViewTopCards(int number);
-    void actRequestViewBottomCardsDialog();
-    void actViewBottomCards(int number);
-    void actAlwaysRevealTopCard(bool alwaysRevealTopCard);
-    void actAlwaysLookAtTopCard(bool alwaysRevealTopCard);
+    void actViewTopCards();
+    void actViewBottomCards();
+    void actAlwaysRevealTopCard();
+    void actAlwaysLookAtTopCard();
     void actViewGraveyard();
     void actLendLibrary(int lendToPlayerId);
     void actRevealTopCards(int revealToPlayerId, int amount);
@@ -182,41 +127,37 @@ public slots:
     void actCreateRelatedCard();
     void actCreateAllRelatedCards();
 
-    void actRequestMoveCardXCardsFromTopDialog();
-    void actMoveCardXCardsFromTop(QList<CardItem *> selectedCards, int number);
-    void actRemoveCardCounter(QList<CardItem *> selectedCards, int counterId);
-    void actAddCardCounter(QList<CardItem *> selectedCards, int counterId);
-    void actRequestSetCardCounterDialog(QList<CardItem *> selectedCards, int counterId);
-    void actSetCardCounter(QList<CardItem *> selectedCards, int counterId, const QString &counterValue);
-    void actIncrementAllCardCounters(QList<CardItem *> cardsToUpdate);
+    void actMoveCardXCardsFromTop();
+    void actRemoveCardCounter(int counterId);
+    void actAddCardCounter(int counterId);
+    void actSetCardCounter(int counterId);
+    void actIncrementAllCardCounters();
     void actAttach();
-    void actUnattach(QList<CardItem *> selectedCards);
+    void actUnattach();
     void actDrawArrow();
-    void actIncPT(QList<CardItem *> selectedCards, int deltaP, int deltaT);
-    void actResetPT(QList<CardItem *> selectedCards);
-    void actRequestSetPTDialog(QList<CardItem *> selectedCards);
-    void actSetPT(QList<CardItem *> selectedCards, const QString &pt);
-    void actIncP(QList<CardItem *> selectedCards);
-    void actDecP(QList<CardItem *> selectedCards);
-    void actIncT(QList<CardItem *> selectedCards);
-    void actDecT(QList<CardItem *> selectedCards);
-    void actIncPT(QList<CardItem *> selectedCards);
-    void actDecPT(QList<CardItem *> selectedCards);
-    void actFlowP(QList<CardItem *> selectedCards);
-    void actFlowT(QList<CardItem *> selectedCards);
+    void actIncPT(int deltaP, int deltaT);
+    void actResetPT();
+    void actSetPT();
+    void actIncP();
+    void actDecP();
+    void actIncT();
+    void actDecT();
+    void actIncPT();
+    void actDecPT();
+    void actFlowP();
+    void actFlowT();
 
-    void actReduceLifeByPower(QList<CardItem *> selectedCards);
+    void actReduceLifeByPower();
 
-    void actRequestSetAnnotationDialog(QList<CardItem *> selectedCards);
-    void actSetAnnotation(QList<CardItem *> selectedCards, const QString &annotation);
-    void actReveal(QList<CardItem *> selectedCards, QAction *action);
+    void actSetAnnotation();
+    void actReveal(QAction *action);
     void actRevealHand(int revealToPlayerId);
     void actRevealRandomHandCard(int revealToPlayerId);
     void actRevealLibrary(int revealToPlayerId);
 
     void actSortHand();
 
-    void cardMenuAction(QList<CardItem *> selectedCards, CardMenuActionType type);
+    void cardMenuAction();
 
 private:
     PlayerLogic *player;
@@ -235,19 +176,21 @@ private:
     int movingCardsUntilCounter = 0;
     MoveTopCardsUntilOptions movingCardsUntilOptions;
 
-    bool lastRelatedCreationSucceeded = false;
+    void moveTopCardsTo(const QString &targetZone, const QString &zoneDisplayName, bool faceDown);
+    void moveBottomCardsTo(const QString &targetZone, const QString &zoneDisplayName, bool faceDown);
 
     void createCard(const CardItem *sourceCard,
                     const QString &dbCardName,
                     CardRelationType attach = CardRelationType::DoesNotAttach,
                     bool persistent = false);
+    bool createRelatedFromRelation(const CardItem *sourceCard, const CardRelation *cardRelation);
 
-    void playSelectedCards(QList<CardItem *> selectedCards, bool faceDown = false);
+    void playSelectedCards(bool faceDown = false);
 
     void cmdSetTopCard(Command_MoveCard &cmd);
     void cmdSetBottomCard(Command_MoveCard &cmd);
 
-    void offsetCardCounter(QList<CardItem *> selectedCards, int counterId, int offset);
+    void offsetCardCounter(int counterId, int offset);
 };
 
 #endif // COCKATRICE_PLAYER_ACTIONS_H

cockatrice/src/game/player/player_area.h

@@ -7,7 +7,7 @@
 #ifndef COCKATRICE_PLAYER_AREA_H
 #define COCKATRICE_PLAYER_AREA_H
 
-#include "../board/graphics_item_type.h"
+#include "../../game_graphics/board/graphics_item_type.h"
 #include "QGraphicsItem"
 
 /**