Merge branch 'master' into tooomm-ci_sign_mac

2026-06-14 10:04:46 -07:00 · 2026-06-13 22:15:52 +02:00 · 2026-06-13 22:15:52 +02:00 · 8c7b201022
commit 8c7b201022
parent 6f7c5d7788 f28ede7ae3
159 changed files with 2217 additions and 1365 deletions
--- a/.ci/lint_cpp.sh
+++ b/.ci/lint_cpp.sh
@ -13,17 +13,9 @@ fi
 # Check formatting using format.sh
 echo "Checking your code using format.sh..."

-diff="$(./format.sh --diff --cmake --shell --print-version --branch origin/master)"
+./format.sh --color-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
@ -36,19 +28,10 @@ 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
@ -65,9 +48,6 @@ EOM
 ***                                                     ***
 ***********************************************************

-Used version:
-$used_version
-
 Exiting...
 EOM
    exit 0
--- a/.github/workflows/desktop-build.yml
+++ b/.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
-  attestations: write
-  actions: write # needed for ccache action to be able to delete gha caches
+  id-token: write    # needed for signing certificate in attestation

 on:
  push:
@ -19,7 +19,7 @@ on:
      - '.github/workflows/desktop-build.yml'
      - 'CMakeLists.txt'
      - 'vcpkg.json'
-      - 'vcpkg'
+      - 'vcpkg'    # needed to match submodule bumps (gitlink)
    tags:
      - '*'
  pull_request:
@ -32,7 +32,7 @@ on:
      - '.github/workflows/desktop-build.yml'
      - 'CMakeLists.txt'
      - 'vcpkg.json'
-      - 'vcpkg'
+      - 'vcpkg'    # needed to match submodule bumps (gitlink)

 # 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,146 +64,150 @@ 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-depth: 0    # fetch all history for all branches and tags

-      - 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: |
-          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"
+          args=()
+          [[ $prerelease == yes ]] && args+=(--prerelease)
+          
+          gh release create "$tag_name" --verify-tag --draft "${args[@]}" \
+            --target "$target" \
+            --title "$release_name" \
+            --notes-file "$body_path"

  build-linux:
    strategy:
      fail-fast: false
      matrix:
-        # These names correspond to the files in ".ci/$distro$version"
+        # The files in ".ci/$distro$version" correspond to the values given here
        include:
          - distro: Arch
-            package: skip    # We are packaged in Arch already
+            
            allow-failure: yes
+            package: skip    # We are packaged in Arch already

          - distro: Servatrice_Debian
            version: 12
+            
            package: DEB
-            test: skip
            server_only: yes
+            test: skip

          - 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:
-      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
+      CACHE: ${{ github.workspace }}/.cache/${{ matrix.distro }}${{ matrix.version }}    # directory for caching docker image and ccache
      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:
-          path: ${{env.CACHE}}
-          key: ccache-${{matrix.distro}}${{matrix.version}}-${{env.BRANCH_NAME}}
-          restore-keys: ccache-${{matrix.distro}}${{matrix.version}}-
+          key: ccache-${{ matrix.distro }}${{ matrix.version }}-${{ env.BRANCH_NAME }}
+          path: ${{ env.CACHE }}
+          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=()
-          if [[ $server_only == yes ]]; then
-            args+=(--no-client)
-          fi
-          if [[ $GITHUB_REF == "refs/heads/master" ]]; then
-            args+=(--evict-ccache "$CCACHE_EVICTION_AGE")
-          fi
+          [[ $server_only == yes ]] && args+=(--no-client)
+          [[ $GITHUB_REF == "refs/heads/master" ]] && args+=(--evict-ccache "$CCACHE_EVICTION_AGE")
          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:
@ -213,47 +217,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:
-          GH_TOKEN: ${{github.token}}
-          tag_name: ${{needs.configure.outputs.tag}}
-          asset_name: ${{steps.build.outputs.fullname}}
-          asset_path: ${{steps.build.outputs.path}}
+          asset_name: ${{ steps.build.outputs.fullname }}
+          asset_path: ${{ steps.build.outputs.path }}
+          GH_TOKEN: ${{ github.token }}
+          tag_name: ${{ needs.configure.outputs.tag }}
        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:
@ -263,176 +267,179 @@ jobs:
          - os: macOS
            target: 13
            runner: macos-15-intel
-            soc: Intel
-            xcode: "16.4"
-            type: Release
-            override_target: 13
+            
+            ccache_eviction_age: 7d
+            cmake_generator: Ninja
            make_package: 1
+            override_target: 13
            package_suffix: "-macOS13_Intel"
            qt_version: 6.11.0
            qt_arch: clang_64
            qt_modules: qtimageformats qtmultimedia qtwebsockets
-            cmake_generator: Ninja
+            soc: Intel
+            type: Release
            use_ccache: 1
-            ccache_eviction_age: 7d
+            xcode: "16.4"

          - os: macOS
            target: 14
            runner: macos-14
-            soc: Apple
-            xcode: "15.4"
-            type: Release
+            
+            ccache_eviction_age: 7d
+            cmake_generator: Ninja
            make_package: 1
            package_suffix: "-macOS14"
            qt_version: 6.11.0
            qt_arch: clang_64
            qt_modules: qtimageformats qtmultimedia qtwebsockets
-            cmake_generator: Ninja
+            soc: Apple
+            type: Release
            use_ccache: 1
-            ccache_eviction_age: 7d
+            xcode: "15.4"

          - os: macOS
            target: 15
            runner: macos-15
-            soc: Apple
-            xcode: "16.4"
-            type: Release
+            
+            ccache_eviction_age: 7d
+            cmake_generator: Ninja
            make_package: 1
            package_suffix: "-macOS15"
            qt_version: 6.11.0
            qt_arch: clang_64
            qt_modules: qtimageformats qtmultimedia qtwebsockets
-            cmake_generator: Ninja
+            soc: Apple
+            type: Release
            use_ccache: 1
-            ccache_eviction_age: 7d
+            xcode: "16.4"

          - os: macOS
            target: 15
            runner: macos-15
-            soc: Apple
-            xcode: "16.4"
-            type: Debug
+            
+            ccache_eviction_age: 7d
+            cmake_generator: Ninja
            qt_version: 6.11.0
            qt_arch: clang_64
            qt_modules: qtimageformats qtmultimedia qtwebsockets
-            cmake_generator: Ninja
+            soc: Apple
+            type: Debug
            use_ccache: 1
-            ccache_eviction_age: 7d
+            xcode: "16.4"

          - os: Windows
            target: 10
            runner: windows-2025
-            type: Release
+            
+            cmake_generator: "Visual Studio 18 2026"
+            cmake_generator_platform: x64
            make_package: 1
            package_suffix: "-Win10"
            qt_version: 6.11.0
            qt_arch: win64_msvc2022_64
            qt_modules: qtimageformats qtmultimedia qtwebsockets
-            cmake_generator: "Visual Studio 17 2022"
-            cmake_generator_platform: x64
+            type: Release

-    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/
-      # 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_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

    steps:
-      - name: Checkout
+      - name: "Checkout"
        uses: actions/checkout@v6
        with:
          submodules: recursive

-      - name: Add msbuild to PATH
+      - name: "[Windows] Add msbuild to PATH"
        if: matrix.os == 'Windows'
        id: add-msbuild
        uses: microsoft/setup-msbuild@v3
        with:
          msbuild-architecture: x64

-      - name: Setup ccache
-        if: matrix.use_ccache == 1 && matrix.os == 'macOS'
+      - name: "[macOS] Setup ccache"
+        if: matrix.os == 'macOS' && matrix.use_ccache == 1
        run: brew install ccache

-      - name: Restore compiler cache (ccache)
-        if: matrix.use_ccache == 1
+      - name: "[macOS] Restore compiler cache (ccache)"
+        if: matrix.os == 'macOS' && matrix.use_ccache == 1
        id: ccache_restore
        uses: actions/cache/restore@v5
        env:
          BRANCH_NAME: ${{ github.head_ref || github.ref_name }}
        with:
-          path: ${{env.CCACHE_DIR}}
-          key: ccache-${{matrix.runner}}-${{matrix.soc}}-${{matrix.type}}-${{env.BRANCH_NAME}}
-          restore-keys: ccache-${{matrix.runner}}-${{matrix.soc}}-${{matrix.type}}-
+          key: ccache-${{ matrix.runner }}-${{ matrix.soc }}-${{ matrix.type }}-${{ env.BRANCH_NAME }}
+          path: ${{ env.CCACHE_DIR }}
+          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: Restore thin Qt ${{ steps.resolve_qt_version.outputs.version }} libraries (${{ matrix.soc }} macOS)
+      - name: "[macOS] Restore thin Qt ${{ steps.resolve_qt_version.outputs.version }} libraries"
        if: matrix.os == 'macOS'
        id: restore_qt
        uses: actions/cache/restore@v5
        with:
-          path: ${{ github.workspace }}/Qt
          key: thin-qt-macos-${{ matrix.soc }}-${{ steps.resolve_qt_version.outputs.version }}
+          path: ${{ github.workspace }}/Qt

      # 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: Install fat Qt ${{ steps.resolve_qt_version.outputs.version }} (${{ matrix.soc }} macOS)
+      # Qt build using vcpkg either just fails or takes too long to build
+      - name: "[macOS] Install fat Qt ${{ steps.resolve_qt_version.outputs.version }}"
        if: matrix.os == 'macOS' && steps.restore_qt.outputs.cache-hit != 'true'
        uses: jurplel/install-qt-action@v4
        with:
-          version: ${{ steps.resolve_qt_version.outputs.version }}
-          arch: ${{matrix.qt_arch}}
-          modules: ${{matrix.qt_modules}}
+          arch: ${{ matrix.qt_arch }}
          cache: false
-          dir: ${{github.workspace}}
+          dir: ${{ github.workspace }}
+          modules: ${{ matrix.qt_modules }}
+          version: ${{ steps.resolve_qt_version.outputs.version }}

-      - name: Thin Qt libraries (${{ matrix.soc }} macOS)
+      - name: "[macOS] Create thin Qt libraries"
        if: matrix.os == 'macOS' && steps.restore_qt.outputs.cache-hit != 'true'
        run: .ci/thin_macos_qtlib.sh

-      - name: Cache thin Qt libraries (${{ matrix.soc }} macOS)
+      - name: "[macOS] Cache thin Qt libraries"
        if: matrix.os == 'macOS' && steps.restore_qt.outputs.cache-hit != 'true'
        uses: actions/cache/save@v5
        with:
-          path: ${{ github.workspace }}/Qt
          key: thin-qt-macos-${{ matrix.soc }}-${{ steps.resolve_qt_version.outputs.version }}
+          path: ${{ github.workspace }}/Qt

-      - name: Install Qt ${{matrix.qt_version}} (Windows)
+      - name: "[Windows] Install Qt ${{ matrix.qt_version }}"
        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
-          version: ${{ steps.resolve_qt_version.outputs.version }}
-          arch: ${{matrix.qt_arch}}
-          modules: ${{matrix.qt_modules}}
+          arch: ${{ matrix.qt_arch }}
          cache: true
+          modules: ${{ matrix.qt_modules }}
+          version: ${{ steps.resolve_qt_version.outputs.version }}

-      - name: Install NSIS
+      - name: "[Windows] 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:
@ -447,12 +454,14 @@ jobs:
          # macOS-specific environment variables, will be ignored on Windows
          DEVELOPER_DIR: '/Applications/Xcode_${{matrix.xcode}}.app/Contents/Developer'
          TARGET_MACOS_VERSION: ${{ matrix.override_target }}
-          CCACHE_EVICTION_AGE: ${{ matrix.ccache_eviction_age }}
+          USE_CCACHE: ${{ matrix.use_ccache }}
+          VCPKG_BINARY_SOURCES: 'clear;files,${{ steps.vcpkg-cache.outputs.path }},readwrite'
+          VCPKG_DISABLE_METRICS: 1
        run: .ci/compile.sh --server --test --vcpkg

      # Delete used cache to emulate a ccache update. See https://github.com/actions/cache/issues/342
-      - name: Delete remote compiler cache (ccache)
-        if: github.ref == 'refs/heads/master' && matrix.use_ccache == 1 && steps.ccache_restore.outputs.cache-hit
+      - 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
        continue-on-error: true
        env:
          GH_TOKEN: ${{ github.token }}
@ -461,14 +470,14 @@ jobs:
            echo "Cache deleted successfully"
          fi

-      - name: Save updated compiler cache (ccache)
-        if: github.ref == 'refs/heads/master' && matrix.use_ccache == 1
+      - name: "[macOS] Save updated compiler cache (ccache)"
+        if: matrix.os == 'macOS' && matrix.use_ccache == 1 && github.ref == 'refs/heads/master'
        uses: actions/cache/save@v5
        with:
-          path: ${{env.CCACHE_DIR}}
          key: ${{ steps.ccache_restore.outputs.cache-primary-key }}
+          path: ${{ env.CCACHE_DIR }}

-      - name: Sign & notarize app bundle
+      - name: "[macOS] Sign & notarize app bundle"
        # if: matrix.os == 'macOS' && matrix.make_package && needs.configure.outputs.tag != null
        if: matrix.os == 'macOS'
        shell: bash
@ -482,48 +491,48 @@ jobs:
          MACOS_NOTARIZATION_TEAM_ID: ${{ secrets.PROD_MACOS_NOTARIZATION_TEAM_ID }}
        run: .ci/sign_macos_bundle.sh "${{ steps.build.outputs.path }}"

-      - 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: Upload PDBs (Program Databases)
+      - name: "[Windows] Upload PDBs (Program Databases)"
        if: matrix.os == 'Windows' && github.ref_type != 'tag'
        uses: actions/upload-artifact@v7
        with:
-          name: ${{steps.build.outputs.name}}-PDBs
+          if-no-files-found: error
+          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:
-          GH_TOKEN: ${{github.token}}
-          tag_name: ${{needs.configure.outputs.tag}}
-          asset_name: ${{steps.build.outputs.fullname}}
-          asset_path: ${{steps.build.outputs.path}}
+          asset_name: ${{ steps.build.outputs.fullname }}
+          asset_path: ${{ steps.build.outputs.path }}
+          GH_TOKEN: ${{ github.token }}
+          tag_name: ${{ needs.configure.outputs.tag }}
        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
--- a/.github/workflows/desktop-lint.yml
+++ b/.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,17 +21,20 @@ 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
--- a/.github/workflows/docker-release.yml
+++ b/.github/workflows/docker-release.yml
@ -1,9 +1,10 @@
 name: Build Docker Image

+permissions:
+  contents: read
+  packages: write
+
 on:
-  release:
-    types:
-      - released    # publishing of stable releases
  push:
    branches:
      - master
@ -13,6 +14,9 @@ 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:
@ -24,54 +28,50 @@ 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:
-          context: .
-          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
+          context: .
+          labels: ${{ steps.metadata.outputs.labels }}
+          platforms: linux/amd64,linux/arm64
+          push: ${{ github.ref_type == 'tag' }}
+          tags: ${{ steps.metadata.outputs.tags }}
--- a/.github/workflows/documentation-build.yml
+++ b/.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/
--- a/.github/workflows/translations-pull.yml
+++ b/.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
-          # https://github.com/transifex/cli#pulling-files-from-transifex
-          token: ${{ secrets.TX_TOKEN }}
+          # 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
+          token: ${{ secrets.TX_TOKEN }}

-      - 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,12 +38,7 @@ jobs:
          add-paths: |
            cockatrice/translations/*.ts
            oracle/translations/*.ts
-          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'
+          author: github-actions <github-actions@github.com>    # owner of the commit
          body: |
            Pulled all translated strings from [Transifex][1].
            
@ -53,12 +48,16 @@ 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
-          draft: false
+          title: 'Update translations'

-      - name: PR Status
+      - name: "PR Status"
        if: github.event_name != 'pull_request'
        shell: bash
        env:
--- a/.github/workflows/translations-push.yml
+++ b/.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:
-          FILE: 'oracle/oracle_en@source.ts'
          DIRS: 'oracle/src'
+          FILE: 'oracle/oracle_en@source.ts'
        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,19 +62,18 @@ jobs:
          add-paths: |
            cockatrice/cockatrice_en@source.ts
            oracle/oracle_en@source.ts
-          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
-          title: 'Update source strings'
+          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
+          delete-branch: true
+          draft: false
          labels: |
            CI
            Translation
-          draft: false
+          title: 'Update source strings'

-      - name: PR Status
+      - name: "PR Status"
        if: github.event_name != 'pull_request'
        shell: bash
        env:
--- a/cockatrice/CMakeLists.txt
+++ b/cockatrice/CMakeLists.txt
@ -56,56 +56,58 @@ set(cockatrice_SOURCES
    src/filters/filter_tree_model.cpp
    src/filters/syntax_help.cpp
    src/game/abstract_game.cpp
-    src/game/board/abstract_card_drag_item.cpp
-    src/game/board/abstract_card_item.cpp
-    src/game/board/abstract_counter.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/arrow_data.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_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/card_list.cpp
    src/game/board/card_state.cpp
-    src/game/board/counter_general.cpp
+    src/game_graphics/board/counter_general.cpp
    src/game/board/counter_state.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_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/game.cpp
    src/game/game_event_handler.cpp
    src/game/game_meta_info.cpp
-    src/game/game_scene.cpp
+    src/game_graphics/game_scene.cpp
    src/game/game_state.cpp
-    src/game/game_view.cpp
-    src/game/hand_counter.cpp
-    src/game/log/message_log_widget.cpp
+    src/game_graphics/game_view.cpp
+    src/game_graphics/hand_counter.cpp
+    src/game_graphics/log/message_log_widget.cpp
    src/game/phase.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_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/player/player_actions.cpp
-    src/game/player/player_area.cpp
+    src/game_graphics/player/player_area.cpp
+    src/game_graphics/player/player_dialogs.cpp
    src/game/player/player_event_handler.cpp
-    src/game/player/player_graphics_item.cpp
+    src/game_graphics/player/player_graphics_item.cpp
    src/game/player/player_info.cpp
-    src/game/player/player_list_widget.cpp
+    src/game_graphics/player/player_list_widget.cpp
    src/game/player/player_logic.cpp
    src/game/player/player_manager.cpp
-    src/game/player/player_target.cpp
+    src/game_graphics/player/player_target.cpp
    src/game/replay.cpp
    src/game/zones/card_zone_logic.cpp
    src/game/zones/hand_zone_logic.cpp
--- a/cockatrice/src/client/settings/cache_settings.cpp
+++ b/cockatrice/src/client/settings/cache_settings.cpp
@ -388,6 +388,7 @@ 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();
@ -1117,6 +1118,12 @@ 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;
--- a/cockatrice/src/client/settings/cache_settings.h
+++ b/cockatrice/src/client/settings/cache_settings.h
@ -183,6 +183,7 @@ signals:
    void soundThemeChanged();
    void ignoreUnregisteredUsersChanged();
    void ignoreUnregisteredUserMessagesChanged();
+    void ignoreNonBuddyUserMessagesChanged();
    void pixmapCacheSizeChanged(int newSizeInMBs);
    void networkCacheSizeChanged(int newSizeInMBs);
    void redirectCacheTtlChanged(int newTtl);
@ -294,6 +295,7 @@ private:
    QString soundThemeName;
    bool ignoreUnregisteredUsers;
    bool ignoreUnregisteredUserMessages;
+    bool ignoreNonBuddyUserMessages;
    QString picUrl;
    QString picUrlFallback;
    QString clientID;
@ -788,6 +790,10 @@ public:
    {
        return ignoreUnregisteredUserMessages;
    }
+    [[nodiscard]] bool getIgnoreNonBuddyUserMessages() const
+    {
+        return ignoreNonBuddyUserMessages;
+    }
    [[nodiscard]] int getPixmapCacheSize() const
    {
        return pixmapCacheSize;
@ -1111,6 +1117,7 @@ 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);
--- a/cockatrice/src/game/abstract_game.cpp
+++ b/cockatrice/src/game/abstract_game.cpp
@ -3,7 +3,7 @@
 #include "../interface/widgets/tabs/tab_game.h"
 #include "player/player_logic.h"

-AbstractGame::AbstractGame(TabGame *_tab) : QObject(_tab), tab(_tab)
+AbstractGame::AbstractGame(QObject *_parent) : QObject(_parent)
 {
    gameMetaInfo = new GameMetaInfo(this);
    gameEventHandler = new GameEventHandler(this);
--- a/cockatrice/src/game/abstract_game.h
+++ b/cockatrice/src/game/abstract_game.h
@ -16,26 +16,19 @@
 #include <libcockatrice/protocol/pb/game_replay.pb.h>

 class CardItem;
-class TabGame;
 class AbstractGame : public QObject
 {
    Q_OBJECT

 public:
-    explicit AbstractGame(TabGame *tab);
+    explicit AbstractGame(QObject *parent);

-    TabGame *tab;
    GameMetaInfo *gameMetaInfo;
    GameState *gameState;
    GameEventHandler *gameEventHandler;
    PlayerManager *playerManager;
    CardItem *activeCard;

-    TabGame *getTab() const
-    {
-        return tab;
-    }
-
    GameMetaInfo *getGameMetaInfo()
    {
        return gameMetaInfo;
--- a/cockatrice/src/game/arrow_registry.cpp
+++ b/cockatrice/src/game/arrow_registry.cpp
@ -0,0 +1,48 @@
+#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();
+}
--- a/cockatrice/src/game/arrow_registry.h
+++ b/cockatrice/src/game/arrow_registry.h
@ -0,0 +1,43 @@
+#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
--- a/cockatrice/src/game/board/arrow_data.cpp
+++ b/cockatrice/src/game/board/arrow_data.cpp
@ -1,8 +1,10 @@
 #include "arrow_data.h"

-ArrowData ArrowData::fromProto(const ServerInfo_Arrow &arrow)
+ArrowData ArrowData::fromProto(const ServerInfo_Arrow &arrow, int creatorId, bool isLocalCreator)
 {
    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());
--- a/cockatrice/src/game/board/arrow_data.h
+++ b/cockatrice/src/game/board/arrow_data.h
@ -8,16 +8,18 @@

 struct ArrowData
 {
-    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;
+    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 = "";

-    static ArrowData fromProto(const ServerInfo_Arrow &arrow);
+    static ArrowData fromProto(const ServerInfo_Arrow &arrow, int creatorId, bool isLocalCreator);

    bool isPlayerTargeted() const
    {
--- a/cockatrice/src/game/board/card_list.cpp
+++ b/cockatrice/src/game/board/card_list.cpp
@ -1,6 +1,6 @@
 #include "card_list.h"

-#include "card_item.h"
+#include "../../game_graphics/board/card_item.h"

 #include <QDebug>
 #include <algorithm>
--- a/cockatrice/src/game/game.cpp
+++ b/cockatrice/src/game/game.cpp
@ -4,16 +4,16 @@

 #include <libcockatrice/protocol/pb/event_game_joined.pb.h>

-Game::Game(TabGame *_tab,
+Game::Game(QObject *_parent,
+           bool isLocalGame,
           QList<AbstractClient *> &_clients,
           const Event_GameJoined &event,
           const QMap<int, QString> &_roomGameTypes)
-    : AbstractGame(_tab)
+    : AbstractGame(_parent)
 {
    gameMetaInfo->setFromProto(event.game_info());
    gameMetaInfo->setRoomGameTypes(_roomGameTypes);
-    gameState = new GameState(this, 0, event.host_id(), tab->getTabSupervisor()->getIsLocalGame(), _clients, false,
-                              event.resuming(), -1, false);
+    gameState = new GameState(this, 0, event.host_id(), isLocalGame, _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);
--- a/cockatrice/src/game/game.h
+++ b/cockatrice/src/game/game.h
@ -16,7 +16,8 @@ class Game : public AbstractGame
    Q_OBJECT

 public:
-    Game(TabGame *tab,
+    Game(QObject *parent,
+         bool isLocalGame,
         QList<AbstractClient *> &_clients,
         const Event_GameJoined &event,
         const QMap<int, QString> &_roomGameTypes);
--- a/cockatrice/src/game/game_event_handler.cpp
+++ b/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,23 +213,24 @@ void GameEventHandler::handleChatMessageSent(const QString &chatMessage)
    sendGameCommand(cmd);
 }

-void GameEventHandler::handleArrowDeletion(int arrowId)
+void GameEventHandler::handleArrowDeletion(int creatorId, int arrowId)
 {
    Command_DeleteArrow cmd;
    cmd.set_arrow_id(arrowId);

    auto preparedCommand = prepareGameCommand(cmd);

-    connect(preparedCommand, &PendingCommand::finished, this,
-            [arrowId, this](const Response &response) { handleArrowDeletionFinished(response, arrowId); });
+    connect(preparedCommand, &PendingCommand::finished, this, [creatorId, arrowId, this](const Response &response) {
+        handleArrowDeletionFinished(response, creatorId, arrowId);
+    });

    sendGameCommand(preparedCommand);
 }

-void GameEventHandler::handleArrowDeletionFinished(const Response &response, int arrowId)
+void GameEventHandler::handleArrowDeletionFinished(const Response &response, int creatorId, int arrowId)
 {
    if (response.response_code() == Response::RespNameNotFound) {
-        emit arrowDeleted(arrowId);
+        emit arrowDeleted(creatorId, arrowId);
    }
 }

--- a/cockatrice/src/game/game_event_handler.h
+++ b/cockatrice/src/game/game_event_handler.h
@ -60,8 +60,8 @@ public:
    void handleActivePhaseChanged(int phase);
    void handleGameLeft();
    void handleChatMessageSent(const QString &chatMessage);
-    void handleArrowDeletion(int arrowId);
-    void handleArrowDeletionFinished(const Response &response, int arrowId);
+    void handleArrowDeletion(int creatorId, int arrowId);
+    void handleArrowDeletionFinished(const Response &response, int creatorId, 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 +113,7 @@ signals:
    void containerProcessingStarted(GameEventContext context);
    void setContextJudgeName(QString judgeName);
    void containerProcessingDone();
-    void arrowDeleted(int arrowId);
+    void arrowDeleted(int creatorId, int arrowId);
    void logSpectatorSay(ServerInfo_User userInfo, QString message);
    void logSpectatorLeave(QString name, QString reason);
    void logGameStart();
--- a/cockatrice/src/game/player/player_actions.cpp
+++ b/cockatrice/src/game/player/player_actions.cpp
--- a/cockatrice/src/game/player/player_actions.h
+++ b/cockatrice/src/game/player/player_actions.h
@ -7,8 +7,11 @@

 #ifndef COCKATRICE_PLAYER_ACTIONS_H
 #define COCKATRICE_PLAYER_ACTIONS_H
-#include "../dialogs/dlg_create_token.h"
-#include "../dialogs/dlg_move_top_cards_until.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 "event_processing_options.h"
 #include "player_logic.h"

@ -25,7 +28,6 @@ class Message;
 }
 } // namespace google

-class CardItem;
 class Command_MoveCard;
 class GameEventContext;
 class PendingCommand;
@ -56,30 +58,75 @@ 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 actRollDie();
+    void actRequestRollDieDialog();
+    void actRollDie(int sides, int count);
    void actFlipCoin();
-    void actCreateToken();
+    void actRequestCreateTokenDialog(const QStringList &predefinedTokens);
+    void actCreateToken(TokenInfo tokenToCreate);
    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 actShuffleTop();
-    void actShuffleBottom();
+    void actRequestShuffleTopDialog();
+    void actShuffleTop(int number);
+    void actRequestShuffleBottomDialog();
+    void actShuffleBottom(int number);
    void actDrawCard();
-    void actDrawCards();
+    void actRequestDrawCardsDialog();
+    void actDrawCards(int number);
    void actUndoDraw();
-    void actMulligan();
+    void actRequestMulliganDialog();
+    void actMulligan(int number);
    void actMulliganSameSize();
    void actMulliganMinusOne();
    void doMulligan(int number);

-    void actPlay();
-    void actPlayFacedown();
-    void actHide();
+    void actPlay(QList<CardItem *> selectedCards);
+    void actPlayFacedown(QList<CardItem *> selectedCards);
+    void actHide(QList<CardItem *> selectedCards);

    void actMoveTopCardToPlay();
    void actMoveTopCardToPlayFaceDown();
@ -89,10 +136,14 @@ public slots:
    void actMoveTopCardsToGraveFaceDown();
    void actMoveTopCardsToExile();
    void actMoveTopCardsToExileFaceDown();
-    void actMoveTopCardsUntil();
+    void actRequestMoveTopCardsUntilDialog();
+    void moveTopCardsUntil(const QString &expr, MoveTopCardsUntilOptions options);
    void actMoveTopCardToBottom();
+    void actRequestMoveTopCardsToDialog(const QString &targetZone, const QString &zoneDisplayName, bool faceDown);
+    void moveTopCardsTo(int number, const QString &targetZone, bool faceDown);
    void actDrawBottomCard();
-    void actDrawBottomCards();
+    void actRequestDrawBottomCardsDialog();
+    void actDrawBottomCards(int number);
    void actMoveBottomCardToPlay();
    void actMoveBottomCardToPlayFaceDown();
    void actMoveBottomCardToGrave();
@ -102,6 +153,8 @@ 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();
@ -109,10 +162,12 @@ public slots:

    void actViewLibrary();
    void actViewHand();
-    void actViewTopCards();
-    void actViewBottomCards();
-    void actAlwaysRevealTopCard();
-    void actAlwaysLookAtTopCard();
+    void actRequestViewTopCardsDialog();
+    void actViewTopCards(int number);
+    void actRequestViewBottomCardsDialog();
+    void actViewBottomCards(int number);
+    void actAlwaysRevealTopCard(bool alwaysRevealTopCard);
+    void actAlwaysLookAtTopCard(bool alwaysRevealTopCard);
    void actViewGraveyard();
    void actLendLibrary(int lendToPlayerId);
    void actRevealTopCards(int revealToPlayerId, int amount);
@ -127,37 +182,41 @@ public slots:
    void actCreateRelatedCard();
    void actCreateAllRelatedCards();

-    void actMoveCardXCardsFromTop();
-    void actRemoveCardCounter(int counterId);
-    void actAddCardCounter(int counterId);
-    void actSetCardCounter(int counterId);
-    void actIncrementAllCardCounters();
+    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 actAttach();
-    void actUnattach();
+    void actUnattach(QList<CardItem *> selectedCards);
    void actDrawArrow();
-    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 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 actReduceLifeByPower();
+    void actReduceLifeByPower(QList<CardItem *> selectedCards);

-    void actSetAnnotation();
-    void actReveal(QAction *action);
+    void actRequestSetAnnotationDialog(QList<CardItem *> selectedCards);
+    void actSetAnnotation(QList<CardItem *> selectedCards, const QString &annotation);
+    void actReveal(QList<CardItem *> selectedCards, QAction *action);
    void actRevealHand(int revealToPlayerId);
    void actRevealRandomHandCard(int revealToPlayerId);
    void actRevealLibrary(int revealToPlayerId);

    void actSortHand();

-    void cardMenuAction();
+    void cardMenuAction(QList<CardItem *> selectedCards, CardMenuActionType type);

 private:
    PlayerLogic *player;
@ -176,21 +235,19 @@ private:
    int movingCardsUntilCounter = 0;
    MoveTopCardsUntilOptions movingCardsUntilOptions;

-    void moveTopCardsTo(const QString &targetZone, const QString &zoneDisplayName, bool faceDown);
-    void moveBottomCardsTo(const QString &targetZone, const QString &zoneDisplayName, bool faceDown);
+    bool lastRelatedCreationSucceeded = false;

    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(bool faceDown = false);
+    void playSelectedCards(QList<CardItem *> selectedCards, bool faceDown = false);

    void cmdSetTopCard(Command_MoveCard &cmd);
    void cmdSetBottomCard(Command_MoveCard &cmd);

-    void offsetCardCounter(int counterId, int offset);
+    void offsetCardCounter(QList<CardItem *> selectedCards, int counterId, int offset);
 };

 #endif // COCKATRICE_PLAYER_ACTIONS_H
--- a/cockatrice/src/game/player/player_event_handler.cpp
+++ b/cockatrice/src/game/player/player_event_handler.cpp
@ -1,12 +1,11 @@
 #include "player_event_handler.h"

+#include "../../game_graphics/board/arrow_item.h"
+#include "../../game_graphics/board/card_item.h"
 #include "../../game_graphics/zones/view_zone.h"
 #include "../../interface/widgets/tabs/tab_game.h"
 #include "../board/arrow_data.h"
-#include "../board/arrow_item.h"
-#include "../board/card_item.h"
 #include "../board/card_list.h"
-#include "libcockatrice/utility/color.h"
 #include "player_actions.h"
 #include "player_logic.h"

@ -33,10 +32,12 @@
 #include <libcockatrice/protocol/pb/event_set_card_counter.pb.h>
 #include <libcockatrice/protocol/pb/event_set_counter.pb.h>
 #include <libcockatrice/protocol/pb/event_shuffle.pb.h>
+#include <libcockatrice/utility/color.h>
 #include <libcockatrice/utility/zone_names.h>

 PlayerEventHandler::PlayerEventHandler(PlayerLogic *_player) : QObject(_player), player(_player)
 {
+    connect(this, &PlayerEventHandler::requestCardMenuUpdate, player, &PlayerLogic::requestCardMenuUpdate);
 }

 void PlayerEventHandler::eventGameSay(const Event_GameSay &event)
@ -92,26 +93,24 @@ void PlayerEventHandler::eventRollDie(const Event_RollDie &event)

 void PlayerEventHandler::eventCreateArrow(const Event_CreateArrow &event)
 {
-    const ArrowData data = ArrowData::fromProto(event.arrow_info());
+    auto data = QSharedPointer<ArrowData>::create(ArrowData::fromProto(
+        event.arrow_info(), player->getPlayerInfo()->getId(), player->getPlayerInfo()->getLocal()));

-    // Resolve names for logging
    const auto &playerList = player->getGame()->getPlayerManager()->getPlayers();
-    PlayerLogic *startPlayer = playerList.value(data.startPlayerId);
-    PlayerLogic *targetPlayer = playerList.value(data.targetPlayerId);
+    PlayerLogic *startPlayer = playerList.value(data->startPlayerId);
+    PlayerLogic *targetPlayer = playerList.value(data->targetPlayerId);

    QString startCardName, targetCardName;
    if (startPlayer) {
-        auto *zone = startPlayer->getZones().value(data.startZone);
-        if (zone) {
-            if (auto *card = zone->getCard(data.startCardId)) {
+        if (auto *zone = startPlayer->getZones().value(data->startZone)) {
+            if (auto *card = zone->getCard(data->startCardId)) {
                startCardName = card->getName();
            }
        }
    }
-    if (!data.isPlayerTargeted() && targetPlayer) {
-        auto *zone = targetPlayer->getZones().value(data.targetZone);
-        if (zone) {
-            if (auto *card = zone->getCard(data.targetCardId)) {
+    if (!data->isPlayerTargeted() && targetPlayer) {
+        if (auto *zone = targetPlayer->getZones().value(data->targetZone)) {
+            if (auto *card = zone->getCard(data->targetCardId)) {
                targetCardName = card->getName();
            }
        }
@ -119,16 +118,15 @@ void PlayerEventHandler::eventCreateArrow(const Event_CreateArrow &event)

    emit player->arrowCreateRequested(data);

-    const bool validForLogging = !startCardName.isEmpty() && (data.isPlayerTargeted() || !targetCardName.isEmpty());
-
-    if (startPlayer && targetPlayer && validForLogging) {
-        emit logCreateArrow(player, startPlayer, startCardName, targetPlayer, targetCardName, data.isPlayerTargeted());
+    if (startPlayer && targetPlayer && !startCardName.isEmpty() &&
+        (data->isPlayerTargeted() || !targetCardName.isEmpty())) {
+        emit logCreateArrow(player, startPlayer, startCardName, targetPlayer, targetCardName, data->isPlayerTargeted());
    }
 }

 void PlayerEventHandler::eventDeleteArrow(const Event_DeleteArrow &event)
 {
-    emit player->arrowDeleted(event.arrow_id());
+    emit player->arrowDeleted(player->getPlayerInfo()->getId(), event.arrow_id());
 }

 void PlayerEventHandler::eventCreateToken(const Event_CreateToken &event)
@ -255,7 +253,7 @@ void PlayerEventHandler::eventSetCardCounter(const Event_SetCardCounter &event)

    int oldValue = card->getCounters().value(event.counter_id(), 0);
    card->setCounter(event.counter_id(), event.counter_value());
-    player->getPlayerMenu()->updateCardMenu(card);
+    emit requestCardMenuUpdate(card);
    emit logSetCardCounter(player, card->getName(), event.counter_id(), event.counter_value(), oldValue);
 }

@ -373,7 +371,7 @@ void PlayerEventHandler::eventMoveCard(const Event_MoveCard &event, const GameEv
    targetZone->addCard(card, true, x, y);

    emit cardZoneChanged(card, startZone == targetZone);
-    player->getPlayerMenu()->updateCardMenu(card);
+    emit requestCardMenuUpdate(card);

    if (player->getPlayerActions()->isMovingCardsUntil() && startZoneString == ZoneNames::DECK &&
        targetZone->getName() == ZoneNames::STACK) {
@ -400,7 +398,7 @@ void PlayerEventHandler::eventFlipCard(const Event_FlipCard &event)

    emit logFlipCard(player, card->getName(), event.face_down());
    card->setFaceDown(event.face_down());
-    player->getPlayerMenu()->updateCardMenu(card);
+    emit requestCardMenuUpdate(card);
 }

 void PlayerEventHandler::eventDestroyCard(const Event_DestroyCard &event)
@ -469,7 +467,7 @@ void PlayerEventHandler::eventAttachCard(const Event_AttachCard &event)
    } else {
        emit logUnattachCard(player, startCard->getName());
    }
-    player->getPlayerMenu()->updateCardMenu(startCard);
+    emit requestCardMenuUpdate(startCard);
 }

 void PlayerEventHandler::eventDrawCards(const Event_DrawCards &event)
@ -555,7 +553,7 @@ void PlayerEventHandler::eventRevealCards(const Event_RevealCards &event, EventP
        }

        if (!options.testFlag(SKIP_REVEAL_WINDOW) && showZoneView && !cardList.isEmpty()) {
-            player->getGameScene()->addRevealedZoneView(player, zone, cardList, event.grant_write_access());
+            emit player->requestRevealedZoneView(player, zone, cardList, event.grant_write_access());
        }

        emit logRevealCards(player, zone, cardId, cardName, otherPlayer, false,
--- a/cockatrice/src/game/player/player_event_handler.h
+++ b/cockatrice/src/game/player/player_event_handler.h
@ -83,6 +83,7 @@ signals:
    void logAlwaysRevealTopCard(PlayerLogic *player, CardZoneLogic *zone, bool reveal);
    void logAlwaysLookAtTopCard(PlayerLogic *player, CardZoneLogic *zone, bool reveal);
    void cardZoneChanged(CardItem *card, bool sameZone);
+    void requestCardMenuUpdate(const CardItem *card);

 public:
    PlayerEventHandler(PlayerLogic *player);
--- a/cockatrice/src/game/player/player_info.h
+++ b/cockatrice/src/game/player/player_info.h
@ -7,7 +7,7 @@
 #ifndef COCKATRICE_PLAYER_INFO_H
 #define COCKATRICE_PLAYER_INFO_H

-#include "player_target.h"
+#include "../../game_graphics/player/player_target.h"

 #include <QObject>
 #include <libcockatrice/protocol/pb/serverinfo_user.pb.h>
--- a/cockatrice/src/game/player/player_logic.cpp
+++ b/cockatrice/src/game/player/player_logic.cpp
@ -1,18 +1,18 @@
 #include "player_logic.h"

+#include "../../game_graphics/board/arrow_item.h"
+#include "../../game_graphics/board/card_item.h"
+#include "../../game_graphics/board/counter_general.h"
+#include "../../game_graphics/game_scene.h"
+#include "../../game_graphics/player/player_target.h"
 #include "../../game_graphics/zones/hand_zone.h"
 #include "../../game_graphics/zones/pile_zone.h"
 #include "../../game_graphics/zones/stack_zone.h"
 #include "../../game_graphics/zones/table_zone.h"
 #include "../../interface/theme_manager.h"
 #include "../../interface/widgets/tabs/tab_game.h"
-#include "../board/arrow_item.h"
-#include "../board/card_item.h"
 #include "../board/card_list.h"
-#include "../board/counter_general.h"
-#include "../game_scene.h"
 #include "player_actions.h"
-#include "player_target.h"

 #include <QDebug>
 #include <QMenu>
@ -35,14 +35,6 @@ PlayerLogic::PlayerLogic(const ServerInfo_User &info, int _id, bool _local, bool
      conceded(false), zoneId(0), dialogSemaphore(false)
 {
    initializeZones();
-
-    playerMenu = new PlayerMenu(this);
-    graphicsItem = new PlayerGraphicsItem(this);
-    playerMenu->setMenusForGraphicItems();
-
-    connect(this, &PlayerLogic::activeChanged, graphicsItem, &PlayerGraphicsItem::onPlayerActiveChanged);
-
-    connect(this, &PlayerLogic::openDeckEditor, game->getTab(), &TabGame::openDeckEditor);
 }

 void PlayerLogic::initializeZones()
@ -68,13 +60,12 @@ PlayerLogic::~PlayerLogic()
    }
    zones.clear();

-    delete playerMenu;
    delete getPlayerInfo()->userInfo;
 }

 void PlayerLogic::clear()
 {
-    emit arrowsCleared();
+    emit arrowsClearedLocally();

    QMapIterator<QString, CardZoneLogic *> i(zones);
    while (i.hasNext()) {
@ -115,7 +106,7 @@ void PlayerLogic::processPlayerInfo(const ServerInfo_Player &info)
                                      /* HandZone */
                                      ZoneNames::HAND};
    clearCounters();
-    emit arrowsCleared();
+    emit arrowsClearedLocally();

    QMutableMapIterator<QString, CardZoneLogic *> zoneIt(zones);
    while (zoneIt.hasNext()) {
@ -231,7 +222,8 @@ void PlayerLogic::processCardAttachment(const ServerInfo_Player &info)

    const int arrowListSize = info.arrow_list_size();
    for (int i = 0; i < arrowListSize; ++i) {
-        emit arrowCreateRequested(ArrowData::fromProto(info.arrow_list(i)));
+        emit arrowCreateRequested(QSharedPointer<ArrowData>::create(
+            ArrowData::fromProto(info.arrow_list(i), getPlayerInfo()->getId(), getPlayerInfo()->getLocal())));
    }
 }

@ -325,22 +317,16 @@ void PlayerLogic::setActive(bool _active)
    active = _active;
    emit activeChanged(active);
 }
+void PlayerLogic::onRequestZoneViewToggle(const QString &zoneName, int numberCards, bool isReversed)
+{
+    emit requestZoneViewToggle(this, zoneName, numberCards, isReversed);
+}

 void PlayerLogic::updateZones()
 {
    getTableZone()->reorganizeCards();
 }

-PlayerGraphicsItem *PlayerLogic::getGraphicsItem()
-{
-    return graphicsItem;
-}
-
-GameScene *PlayerLogic::getGameScene()
-{
-    return getGraphicsItem()->getGameScene();
-}
-
 void PlayerLogic::setGameStarted()
 {
    if (playerInfo->local) {
--- a/cockatrice/src/game/player/player_logic.h
+++ b/cockatrice/src/game/player/player_logic.h
@ -7,6 +7,7 @@
 #ifndef PLAYER_H
 #define PLAYER_H

+#include "../../game_graphics/player/player_area.h"
 #include "../../interface/widgets/menus/tearoff_menu.h"
 #include "../board/arrow_data.h"
 #include "../interface/deck_loader/loaded_deck.h"
@ -14,10 +15,7 @@
 #include "../zones/pile_zone_logic.h"
 #include "../zones/stack_zone_logic.h"
 #include "../zones/table_zone_logic.h"
-#include "menu/player_menu.h"
-#include "player_area.h"
 #include "player_event_handler.h"
-#include "player_graphics_item.h"
 #include "player_info.h"

 #include <QInputDialog>
@ -54,6 +52,7 @@ class PlayerMenu;
 class QAction;
 class QMenu;
 class ServerInfo_Arrow;
+class ServerInfo_Card;
 class ServerInfo_Counter;
 class ServerInfo_Player;
 class ServerInfo_User;
@ -67,8 +66,14 @@ class PlayerLogic : public QObject

 signals:
    void openDeckEditor(const LoadedDeck &deck);
+    void requestZoneViewToggle(PlayerLogic *player, const QString &zoneName, int numberCards, bool isReversed);
+    void requestRevealedZoneView(PlayerLogic *player,
+                                 CardZoneLogic *zone,
+                                 const QList<const ServerInfo_Card *> &cardList,
+                                 bool withWritePermission);
    void deckChanged();
    void newCardAdded(AbstractCardItem *card);
+    void requestCardMenuUpdate(const CardItem *card);
    void counterAdded(CounterState *state);
    void counterRemoved(int counterId);
    void rearrangeCounters();
@ -78,13 +83,14 @@ signals:
    void clearCustomZonesMenu();
    void addViewCustomZoneActionToCustomZoneMenu(QString zoneName);
    void resetTopCardMenuActions();
-    void arrowCreateRequested(ArrowData data);
-    void arrowDeleteRequested(int arrowId);
-    void arrowDeleted(int arrowId);
-    void arrowsCleared(); // fires on clear() and processPlayerInfo
+    void arrowCreateRequested(QSharedPointer<ArrowData> data);
+    void arrowDeleteRequested(int creatorId, int arrowId);
+    void arrowDeleted(int creatorId, int arrowId);
+    void arrowsClearedLocally(); // fires on clear() and processPlayerInfo

 public slots:
    void setActive(bool _active);
+    void onRequestZoneViewToggle(const QString &zoneName, int numberCards, bool isReversed);

 public:
    PlayerLogic(const ServerInfo_User &info, int _id, bool _local, bool _judge, AbstractGame *_parent);
@ -112,10 +118,6 @@ public:
        return game;
    }

-    GameScene *getGameScene();
-
-    [[nodiscard]] PlayerGraphicsItem *getGraphicsItem();
-
    [[nodiscard]] PlayerActions *getPlayerActions() const
    {
        return playerActions;
@ -131,11 +133,6 @@ public:
        return playerInfo;
    }

-    [[nodiscard]] PlayerMenu *getPlayerMenu() const
-    {
-        return playerMenu;
-    }
-
    void setDeck(const DeckList &_deck);

    [[nodiscard]] const DeckList &getDeck() const
@ -234,8 +231,6 @@ private:
    PlayerInfo *playerInfo;
    PlayerEventHandler *playerEventHandler;
    PlayerActions *playerActions;
-    PlayerMenu *playerMenu;
-    PlayerGraphicsItem *graphicsItem;

    bool active;
    bool conceded;
--- a/cockatrice/src/game/replay.cpp
+++ b/cockatrice/src/game/replay.cpp
@ -2,9 +2,9 @@

 #include "../interface/widgets/tabs/tab_game.h"

-Replay::Replay(TabGame *_tab, GameReplay *_replay) : AbstractGame(_tab)
+Replay::Replay(QObject *_parent, GameReplay *_replay, bool isLocalGame) : AbstractGame(_parent)
 {
-    gameState = new GameState(this, 0, -1, tab->getTabSupervisor()->getIsLocalGame(), {}, false, false, -1, false);
+    gameState = new GameState(this, 0, -1, isLocalGame, {}, false, false, -1, false);
    connect(gameMetaInfo, &GameMetaInfo::startedChanged, gameState, &GameState::onStartedChanged);
    playerManager = new PlayerManager(this, -1, false, true);
    loadReplay(_replay);
--- a/cockatrice/src/game/replay.h
+++ b/cockatrice/src/game/replay.h
@ -15,7 +15,7 @@ class Replay : public AbstractGame
    Q_OBJECT

 public:
-    explicit Replay(TabGame *_tab, GameReplay *_replay);
+    explicit Replay(QObject *_parent, GameReplay *_replay, bool isLocalGame);
 };

 #endif // COCKATRICE_REPLAY_H
--- a/cockatrice/src/game/zones/card_zone_logic.cpp
+++ b/cockatrice/src/game/zones/card_zone_logic.cpp
@ -1,7 +1,7 @@
 #include "card_zone_logic.h"

+#include "../../game_graphics/board/card_item.h"
 #include "../../game_graphics/zones/view_zone.h"
-#include "../board/card_item.h"
 #include "../player/player_actions.h"
 #include "../player/player_logic.h"
 #include "view_zone_logic.h"
--- a/cockatrice/src/game/zones/hand_zone_logic.cpp
+++ b/cockatrice/src/game/zones/hand_zone_logic.cpp
@ -1,6 +1,6 @@
 #include "hand_zone_logic.h"

-#include "../board/card_item.h"
+#include "../../game_graphics/board/card_item.h"
 #include "card_zone_algorithms.h"

 HandZoneLogic::HandZoneLogic(PlayerLogic *_player,
--- a/cockatrice/src/game/zones/pile_zone_logic.cpp
+++ b/cockatrice/src/game/zones/pile_zone_logic.cpp
@ -1,6 +1,6 @@
 #include "pile_zone_logic.h"

-#include "../board/card_item.h"
+#include "../../game_graphics/board/card_item.h"

 PileZoneLogic::PileZoneLogic(PlayerLogic *_player,
                             const QString &_name,
--- a/cockatrice/src/game/zones/stack_zone_logic.cpp
+++ b/cockatrice/src/game/zones/stack_zone_logic.cpp
@ -1,6 +1,6 @@
 #include "stack_zone_logic.h"

-#include "../board/card_item.h"
+#include "../../game_graphics/board/card_item.h"
 #include "card_zone_algorithms.h"

 StackZoneLogic::StackZoneLogic(PlayerLogic *_player,
--- a/cockatrice/src/game/zones/table_zone_logic.cpp
+++ b/cockatrice/src/game/zones/table_zone_logic.cpp
@ -1,6 +1,6 @@
 #include "table_zone_logic.h"

-#include "../board/card_item.h"
+#include "../../game_graphics/board/card_item.h"

 TableZoneLogic::TableZoneLogic(PlayerLogic *_player,
                               const QString &_name,
--- a/cockatrice/src/game/zones/view_zone_logic.cpp
+++ b/cockatrice/src/game/zones/view_zone_logic.cpp
@ -1,7 +1,7 @@
 #include "view_zone_logic.h"

 #include "../../client/settings/cache_settings.h"
-#include "../board/card_item.h"
+#include "../../game_graphics/board/card_item.h"

 /**
 * @param _player the player that the cards are revealed to.
--- a/cockatrice/src/game_graphics/board/abstract_card_drag_item.cpp
+++ b/cockatrice/src/game_graphics/board/abstract_card_drag_item.cpp
--- a/cockatrice/src/game_graphics/board/abstract_card_drag_item.h
+++ b/cockatrice/src/game_graphics/board/abstract_card_drag_item.h
--- a/cockatrice/src/game_graphics/board/abstract_card_item.cpp
+++ b/cockatrice/src/game_graphics/board/abstract_card_item.cpp
--- a/cockatrice/src/game_graphics/board/abstract_card_item.h
+++ b/cockatrice/src/game_graphics/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,6 +44,11 @@ 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
--- a/cockatrice/src/game_graphics/board/abstract_counter.cpp
+++ b/cockatrice/src/game_graphics/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>
--- a/cockatrice/src/game_graphics/board/abstract_counter.h
+++ b/cockatrice/src/game_graphics/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>
--- a/cockatrice/src/game_graphics/board/arrow_item.cpp
+++ b/cockatrice/src/game_graphics/board/arrow_item.cpp
@ -2,11 +2,11 @@
 #include "arrow_item.h"

 #include "../../client/settings/cache_settings.h"
-#include "../../game_graphics/zones/card_zone.h"
-#include "../player/player_actions.h"
-#include "../player/player_logic.h"
+#include "../../game/player/player_actions.h"
+#include "../../game/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,12 +21,8 @@
 #include <libcockatrice/utility/color.h>
 #include <libcockatrice/utility/zone_names.h>

-ArrowItem::ArrowItem(PlayerLogic *_player,
-                     int _id,
-                     ArrowTarget *_startItem,
-                     ArrowTarget *_targetItem,
-                     const QColor &_color)
-    : player(_player), id(_id), startItem(_startItem), targetItem(_targetItem), color(_color)
+ArrowItem::ArrowItem(QSharedPointer<const ArrowData> _data, ArrowTarget *_startItem, ArrowTarget *_targetItem)
+    : data(std::move(_data)), startItem(_startItem), targetItem(_targetItem)
 {
    setZValue(ZValues::ARROWS);

@ -52,7 +48,7 @@ ArrowItem::ArrowItem(PlayerLogic *_player,

 void ArrowItem::onTargetDestroyed()
 {
-    emit requestDeletion(id);
+    emit requestDeletion(data->creatorId, data->id);
 }

 void ArrowItem::delArrow()
@ -130,7 +126,7 @@ void ArrowItem::updatePath(const QPointF &endPoint)

 void ArrowItem::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*option*/, QWidget * /*widget*/)
 {
-    QColor paintColor(color);
+    QColor paintColor(data->color);
    if (fullColor) {
        paintColor.setAlpha(200);
    } else {
@ -142,7 +138,7 @@ void ArrowItem::paint(QPainter *painter, const QStyleOptionGraphicsItem * /*opti

 void ArrowItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {
-    if (!player->getPlayerInfo()->getLocal()) {
+    if (!data->isLocalCreator) {
        event->ignore();
        return;
    }
@ -156,14 +152,20 @@ void ArrowItem::mousePressEvent(QGraphicsSceneMouseEvent *event)

    event->accept();
    if (event->button() == Qt::RightButton) {
-        emit requestDeletion(id);
+        emit requestDeletion(data->creatorId, data->id);
    }
 }

 // ArrowDragItem

 ArrowDragItem::ArrowDragItem(PlayerLogic *_owner, ArrowTarget *_startItem, const QColor &_color, int _deleteInPhase)
-    : ArrowItem(_owner, -1, _startItem, nullptr, _color), deleteInPhase(_deleteInPhase)
+    : ArrowItem(QSharedPointer<ArrowData>::create(ArrowData{.creatorId = _owner->getPlayerInfo()->getId(),
+                                                            .isLocalCreator = true,
+                                                            .id = -1,
+                                                            .color = _color}),
+                _startItem,
+                nullptr),
+      player(_owner), deleteInPhase(_deleteInPhase)
 {
 }

@ -238,7 +240,7 @@ void ArrowDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
        CardZoneLogic *startZone = startCard->getZone();

        Command_CreateArrow cmd;
-        cmd.mutable_arrow_color()->CopyFrom(convertQColorToColor(color));
+        cmd.mutable_arrow_color()->CopyFrom(convertQColorToColor(data->color));
        cmd.set_start_player_id(startZone->getPlayer()->getPlayerInfo()->getId());
        cmd.set_start_zone(startZone->getName().toStdString());
        cmd.set_start_card_id(startCard->getId());
@ -284,7 +286,14 @@ void ArrowDragItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)

 // ArrowAttachItem
 ArrowAttachItem::ArrowAttachItem(ArrowTarget *_startItem)
-    : ArrowItem(_startItem->getOwner(), -1, _startItem, nullptr, Qt::green)
+    : ArrowItem(
+          QSharedPointer<ArrowData>::create(ArrowData{.creatorId = _startItem->getOwner()->getPlayerInfo()->getId(),
+                                                      .isLocalCreator = true,
+                                                      .id = -1,
+                                                      .color = Qt::green}),
+          _startItem,
+          nullptr),
+      player(_startItem->getOwner())
 {
 }

--- a/cockatrice/src/game_graphics/board/arrow_item.h
+++ b/cockatrice/src/game_graphics/board/arrow_item.h
@ -1,20 +1,15 @@
-/**
- * @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
@ -22,25 +17,27 @@ class ArrowItem : public QObject, public QGraphicsItem
    Q_OBJECT
    Q_INTERFACES(QGraphicsItem)
 signals:
-    void requestDeletion(int id);
+    void requestDeletion(int creatorId, int id);

 private:
    QPainterPath path;

 protected:
-    PlayerLogic *player;
-    int id;
+    QSharedPointer<const ArrowData> data;
    QPointer<ArrowTarget> startItem;
    QPointer<ArrowTarget> targetItem;
    bool targetLocked = false;
-    QColor color;
    bool fullColor = true;

    void mousePressEvent(QGraphicsSceneMouseEvent *event) override;

 public:
-    ArrowItem(PlayerLogic *_player, int _id, ArrowTarget *_startItem, ArrowTarget *_targetItem, const QColor &_color);
+    ArrowItem(QSharedPointer<const ArrowData> _data, ArrowTarget *_startItem, ArrowTarget *_targetItem);
+
    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
@ -51,17 +48,13 @@ public:
    {
        return path;
    }
-
-    void updatePath();
-    void updatePath(const QPointF &endPoint);
-
    [[nodiscard]] int getId() const
    {
-        return id;
+        return data->id;
    }
-    [[nodiscard]] PlayerLogic *getPlayer() const
+    [[nodiscard]] int getCreatorId() const
    {
-        return player;
+        return data->creatorId;
    }
    [[nodiscard]] ArrowTarget *getStartItem() const
    {
@ -75,14 +68,13 @@ public:
    {
        targetLocked = _targetLocked;
    }
-
-    void delArrow();
 };

 class ArrowDragItem : public ArrowItem
 {
    Q_OBJECT
 private:
+    PlayerLogic *player;
    int deleteInPhase;
    QList<ArrowDragItem *> childArrows;
    QMetaObject::Connection positionConnection;
@ -100,6 +92,7 @@ class ArrowAttachItem : public ArrowItem
 {
    Q_OBJECT
 private:
+    PlayerLogic *player;
    QList<ArrowAttachItem *> childArrows;
    QMetaObject::Connection positionConnection;
    void attachCards(CardItem *startCard, const CardItem *targetCard);
@ -113,4 +106,4 @@ protected:
    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override;
 };

-#endif // ARROWITEM_H
+#endif
--- a/cockatrice/src/game_graphics/board/arrow_target.cpp
+++ b/cockatrice/src/game_graphics/board/arrow_target.cpp
@ -1,6 +1,6 @@
 #include "arrow_target.h"

-#include "../player/player_logic.h"
+#include "../../game/player/player_logic.h"
 #include "arrow_item.h"

 ArrowTarget::ArrowTarget(PlayerLogic *_owner, QGraphicsItem *parent) : AbstractGraphicsItem(parent), owner(_owner)
--- a/cockatrice/src/game_graphics/board/arrow_target.h
+++ b/cockatrice/src/game_graphics/board/arrow_target.h
@ -7,7 +7,7 @@
 #ifndef ARROWTARGET_H
 #define ARROWTARGET_H

-#include "../../game_graphics/board/abstract_graphics_item.h"
+#include "abstract_graphics_item.h"

 #include <QList>

--- a/cockatrice/src/game_graphics/board/card_drag_item.cpp
+++ b/cockatrice/src/game_graphics/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>
--- a/cockatrice/src/game_graphics/board/card_drag_item.h
+++ b/cockatrice/src/game_graphics/board/card_drag_item.h
--- a/cockatrice/src/game_graphics/board/card_item.cpp
+++ b/cockatrice/src/game_graphics/board/card_item.cpp
@ -1,14 +1,14 @@
 #include "card_item.h"

 #include "../../client/settings/cache_settings.h"
-#include "../../game_graphics/zones/table_zone.h"
-#include "../../game_graphics/zones/view_zone.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 "../../interface/widgets/tabs/tab_game.h"
 #include "../game_scene.h"
-#include "../phase.h"
-#include "../player/player_actions.h"
-#include "../player/player_logic.h"
-#include "../zones/view_zone_logic.h"
+#include "../zones/table_zone.h"
+#include "../zones/view_zone.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) {
-            owner->getPlayerMenu()->updateCardMenu(nullptr);
+            emit owner->requestCardMenuUpdate(nullptr);
            owner->getGame()->setActiveCard(nullptr);
        }
        owner = nullptr;
@ -399,8 +399,11 @@ void CardItem::playCard(bool faceDown)
        emit tz->toggleTapped();
    } else {
        if (SettingsCache::instance().getClickPlaysAllSelected()) {
-            faceDown ? state->getZone()->getPlayer()->getPlayerActions()->actPlayFacedown()
-                     : state->getZone()->getPlayer()->getPlayerActions()->actPlay();
+            if (faceDown) {
+                emit playSelectedFaceDown(this);
+            } else {
+                emit playSelected(this);
+            }
        } else {
            state->getZone()->getPlayer()->getPlayerActions()->playCard(this, faceDown);
        }
@ -460,7 +463,7 @@ void CardItem::handleClickedToPlay(bool shiftHeld)
 {
    if (isUnwritableRevealZone(state->getZone())) {
        if (SettingsCache::instance().getClickPlaysAllSelected()) {
-            state->getZone()->getPlayer()->getPlayerActions()->actHide();
+            emit hideSelected(this);
        } else {
            state->getZone()->removeCard(this);
        }
@ -471,21 +474,15 @@ void CardItem::handleClickedToPlay(bool shiftHeld)

 void CardItem::mouseReleaseEvent(QGraphicsSceneMouseEvent *event)
 {
-    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())) {
+    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())) {
        handleClickedToPlay(event->modifiers().testFlag(Qt::ShiftModifier));
    }
-
-    if (owner != nullptr) { // cards without owner will be deleted
+    if (owner != nullptr) {
        setCursor(Qt::OpenHandCursor);
    }
    AbstractCardItem::mouseReleaseEvent(event);
@ -531,14 +528,14 @@ bool CardItem::animationEvent()
 QVariant CardItem::itemChange(GraphicsItemChange change, const QVariant &value)
 {
    if ((change == ItemSelectedHasChanged) && owner != nullptr) {
-        if (value == true) {
-            owner->getGame()->setActiveCard(this);
-            owner->getPlayerMenu()->updateCardMenu(this);
-        } else if (owner->getGameScene()->selectedItems().isEmpty()) {
+        bool selected = value.toBool();

-            owner->getGame()->setActiveCard(nullptr);
-            owner->getPlayerMenu()->updateCardMenu(nullptr);
+        if (selected) {
+            owner->getGame()->setActiveCard(this);
        }
+
+        emit selectionChanged(this, selected);
    }
+
    return AbstractCardItem::itemChange(change, value);
-}
+}
--- a/cockatrice/src/game_graphics/board/card_item.h
+++ b/cockatrice/src/game_graphics/board/card_item.h
@ -7,9 +7,9 @@
 #ifndef CARDITEM_H
 #define CARDITEM_H

-#include "../zones/card_zone_logic.h"
+#include "../../game/board/card_state.h"
+#include "../../game/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>
--- a/cockatrice/src/game_graphics/board/counter_general.cpp
+++ b/cockatrice/src/game_graphics/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>

--- a/cockatrice/src/game_graphics/board/counter_general.h
+++ b/cockatrice/src/game_graphics/board/counter_general.h
--- a/cockatrice/src/game_graphics/board/translate_counter_name.cpp
+++ b/cockatrice/src/game_graphics/board/translate_counter_name.cpp
--- a/cockatrice/src/game_graphics/board/translate_counter_name.h
+++ b/cockatrice/src/game_graphics/board/translate_counter_name.h
--- a/cockatrice/src/game_graphics/card_dimensions.h
+++ b/cockatrice/src/game_graphics/card_dimensions.h
--- a/cockatrice/src/game_graphics/deckview/deck_view.cpp
+++ b/cockatrice/src/game_graphics/deckview/deck_view.cpp
--- a/cockatrice/src/game_graphics/deckview/deck_view.h
+++ b/cockatrice/src/game_graphics/deckview/deck_view.h
--- a/cockatrice/src/game_graphics/deckview/deck_view_container.cpp
+++ b/cockatrice/src/game_graphics/deckview/deck_view_container.cpp
--- a/cockatrice/src/game_graphics/deckview/deck_view_container.h
+++ b/cockatrice/src/game_graphics/deckview/deck_view_container.h
--- a/cockatrice/src/game_graphics/deckview/tabbed_deck_view_container.cpp
+++ b/cockatrice/src/game_graphics/deckview/tabbed_deck_view_container.cpp
--- a/cockatrice/src/game_graphics/deckview/tabbed_deck_view_container.h
+++ b/cockatrice/src/game_graphics/deckview/tabbed_deck_view_container.h
--- a/cockatrice/src/game_graphics/dialogs/dlg_create_token.cpp
+++ b/cockatrice/src/game_graphics/dialogs/dlg_create_token.cpp
--- a/cockatrice/src/game_graphics/dialogs/dlg_create_token.h
+++ b/cockatrice/src/game_graphics/dialogs/dlg_create_token.h
--- a/cockatrice/src/game_graphics/dialogs/dlg_move_top_cards_until.cpp
+++ b/cockatrice/src/game_graphics/dialogs/dlg_move_top_cards_until.cpp
--- a/cockatrice/src/game_graphics/dialogs/dlg_move_top_cards_until.h
+++ b/cockatrice/src/game_graphics/dialogs/dlg_move_top_cards_until.h
--- a/cockatrice/src/game_graphics/dialogs/dlg_roll_dice.cpp
+++ b/cockatrice/src/game_graphics/dialogs/dlg_roll_dice.cpp
--- a/cockatrice/src/game_graphics/dialogs/dlg_roll_dice.h
+++ b/cockatrice/src/game_graphics/dialogs/dlg_roll_dice.h
--- a/cockatrice/src/game_graphics/game_scene.cpp
+++ b/cockatrice/src/game_graphics/game_scene.cpp
@ -1,13 +1,17 @@
 #include "game_scene.h"

 #include "../client/settings/cache_settings.h"
-#include "../game_graphics/zones/select_zone.h"
-#include "../game_graphics/zones/view_zone.h"
-#include "../game_graphics/zones/view_zone_widget.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 "board/card_item.h"
 #include "phases_toolbar.h"
+#include "player/menu/player_menu.h"
 #include "player/player_graphics_item.h"
-#include "player/player_logic.h"
+#include "zones/select_zone.h"
+#include "zones/view_zone.h"
+#include "zones/view_zone_widget.h"

 #include <QBasicTimer>
 #include <QDebug>
@ -72,6 +76,80 @@ 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.
@ -82,9 +160,11 @@ void GameScene::addPlayer(PlayerLogic *player)
 {
    qCInfo(GameScenePlayerAdditionRemovalLog) << "GameScene::addPlayer name=" << player->getPlayerInfo()->getName();

-    playerViews.insert(player->getPlayerInfo()->getId(), player->getGraphicsItem());
-    addItem(player->getGraphicsItem());
-    connect(player->getGraphicsItem(), &PlayerGraphicsItem::sizeChanged, this, &GameScene::rearrange);
+    auto *view = new PlayerGraphicsItem(player);
+
+    playerViews.insert(player->getPlayerInfo()->getId(), view);
+    addItem(view);
+    connect(view, &PlayerGraphicsItem::sizeChanged, this, &GameScene::rearrange);

    connect(player, &PlayerLogic::concededChanged, this, [this](int id, bool conceded) {
        if (conceded) {
@ -93,11 +173,13 @@ 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::arrowsCleared, this,
-            [this, id = player->getPlayerInfo()->getId()]() { clearArrowsForPlayer(id); });
+    connect(player, &PlayerLogic::arrowsClearedLocally, this,
+            [this, id = player->getPlayerInfo()->getId()]() { clearArrowsForPlayerLocally(id); });

    connect(player->getPlayerEventHandler(), &PlayerEventHandler::cardZoneChanged, this, &GameScene::onCardZoneChanged);

@ -123,6 +205,7 @@ void GameScene::removePlayer(PlayerLogic *player)
    }
    auto *view = playerViews.take(player->getPlayerInfo()->getId());
    removeItem(view);
+    view->deleteLater();
    rearrange();
 }

@ -204,7 +287,7 @@ QList<PlayerLogic *> GameScene::collectActivePlayers(int &firstPlayerIndex) cons
    bool firstPlayerFound = false;

    for (auto *pgItem : playerViews.values()) {
-        PlayerLogic *p = pgItem->getPlayer();
+        PlayerLogic *p = pgItem->getLogic();
        if (p && !p->getConceded()) {
            activePlayers.append(p);
            if (!firstPlayerFound && p->getPlayerInfo()->getLocal()) {
@ -275,12 +358,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(player->getGraphicsItem());
+                playersByColumn[col].prepend(playerViews.value(player->getPlayerInfo()->getId()));
            } else {
-                playersByColumn[col].append(player->getGraphicsItem());
+                playersByColumn[col].append(playerViews.value(player->getPlayerInfo()->getId()));
            }

-            auto *pgItem = player->getGraphicsItem();
+            auto *pgItem = playerViews.value(player->getPlayerInfo()->getId());
            thisColumnHeight += pgItem->boundingRect().height() + playerAreaSpacing;
            columnWidth[col] = std::max(columnWidth[col], (int)pgItem->boundingRect().width());
        }
@ -367,86 +450,62 @@ void GameScene::resizeColumnsAndPlayers(const QList<qreal> &minWidthByColumn, qr
    }
 }

-void GameScene::addArrow(const ArrowData &data)
+void GameScene::addArrow(QSharedPointer<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->getPlayer();
-    auto *startZone = startLogic->getZones().value(data.startZone);
+    PlayerLogic *startLogic = startView->getLogic();
+    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->getPlayer()->getZones().value(data.targetZone);
+        auto *zone = targetView->getLogic()->getZones().value(data->targetZone);
        if (zone) {
-            targetItem = zone->getCard(data.targetCardId);
+            targetItem = zone->getCard(data->targetCardId);
        }
    }
    if (!targetItem) {
        return;
    }

-    auto *arrow = new ArrowItem(startView->getPlayer(), data.id, startCard, targetItem, data.color);
+    auto *arrow = new ArrowItem(data, startCard, targetItem);
    addItem(arrow);
-    arrowRegistry.insert(data.id, arrow);
+    arrowRegistry.insert(data, arrow);
    connect(arrow, &ArrowItem::requestDeletion, this, &GameScene::requestArrowDeletion);
 }

-void GameScene::deleteArrow(int arrowId)
+void GameScene::deleteArrow(int playerId, int arrowId)
 {
-    if (arrowRegistry.contains(arrowId)) {
-        arrowRegistry.take(arrowId)->delArrow();
+    if (auto *arrow = arrowRegistry.take(playerId, arrowId)) {
+        arrow->delArrow();
    }
 }

-void GameScene::clearArrowsForPlayer(int playerId)
+void GameScene::requestArrowDeletion(int playerId, int arrowId)
 {
-    QList<int> toDelete;
-    for (auto i = arrowRegistry.cbegin(); i != arrowRegistry.cend(); ++i) {
-        auto *arrow = i.value();
-        if (arrow->getPlayer()->getPlayerInfo()->getId() == playerId) {
-            toDelete.append(i.key());
-        }
-    }
-
-    for (int arrowId : toDelete) {
-        arrowRegistry.take(arrowId)->delArrow();
-    }
-}
-
-void GameScene::requestArrowDeletion(int arrowId)
-{
-    if (arrowRegistry.contains(arrowId)) {
-        emit arrowDeletionRequested(arrowId);
-    }
-}
-
-void GameScene::requestClearArrowsForPlayer(int playerId)
-{
-    for (auto *arrow : arrowRegistry.values()) {
-        if (arrow->getPlayer()->getPlayerInfo()->getId() == playerId) {
-            emit requestArrowDeletion(arrow->getId());
-        }
+    if (arrowRegistry.contains(playerId, arrowId)) {
+        emit arrowDeletionRequested(playerId, arrowId);
    }
 }

 void GameScene::onCardZoneChanged(CardItem *card, bool sameZone)
 {
    QList<ArrowItem *> toDelete;
-    for (auto *arrow : arrowRegistry.values()) {
+    for (auto *arrow : arrowRegistry.all()) {
        if (arrow->getStartItem() == card || arrow->getTargetItem() == card) {
            if (sameZone) {
                arrow->updatePath();
@ -456,7 +515,21 @@ void GameScene::onCardZoneChanged(CardItem *card, bool sameZone)
        }
    }
    for (auto *arrow : toDelete) {
-        deleteArrow(arrow->getId());
+        deleteArrow(arrow->getCreatorId(), 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();
    }
 }

--- a/cockatrice/src/game_graphics/game_scene.h
+++ b/cockatrice/src/game_graphics/game_scene.h
@ -1,9 +1,10 @@
 #ifndef GAMESCENE_H
 #define GAMESCENE_H

-#include "board/arrow_data.h"
+#include "../game/arrow_registry.h"
+#include "../game/board/arrow_data.h"
+#include "../game/zones/card_zone_logic.h"
 #include "board/arrow_item.h"
-#include "zones/card_zone_logic.h"

 #include <QGraphicsScene>
 #include <QList>
@ -45,7 +46,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
-    QMap<int, ArrowItem *> arrowRegistry;               ///< ID registry for arrow graphics items
+    ArrowRegistry 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
@ -96,6 +97,16 @@ 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.
@ -181,6 +192,11 @@ 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);

@ -202,13 +218,13 @@ public slots:
    QTransform getViewportTransform() const;

    /// Directly modifies the scene
-    void addArrow(const ArrowData &data);
-    void deleteArrow(int arrowId);
+    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 arrowId);
-    void requestClearArrowsForPlayer(int playerId);
+    void requestArrowDeletion(int playerId, int arrowId);

    void onCardZoneChanged(CardItem *card, bool sameZone);

@ -223,7 +239,7 @@ signals:
    void sigStartRubberBand(const QPointF &selectionOrigin);
    void sigResizeRubberBand(const QPointF &cursorPoint, int selectedCount);
    void sigStopRubberBand();
-    void arrowDeletionRequested(int arrowId);
+    void arrowDeletionRequested(int creatorId, int arrowId);
 };

 #endif
--- a/cockatrice/src/game_graphics/game_view.cpp
+++ b/cockatrice/src/game_graphics/game_view.cpp
--- a/cockatrice/src/game_graphics/game_view.h
+++ b/cockatrice/src/game_graphics/game_view.h
--- a/cockatrice/src/game_graphics/hand_counter.cpp
+++ b/cockatrice/src/game_graphics/hand_counter.cpp
@ -1,6 +1,6 @@
 #include "hand_counter.h"

-#include "../game_graphics/zones/card_zone.h"
+#include "zones/card_zone.h"

 #include <QGraphicsSceneMouseEvent>
 #include <QPainter>
--- a/cockatrice/src/game_graphics/hand_counter.h
+++ b/cockatrice/src/game_graphics/hand_counter.h
@ -7,8 +7,8 @@
 #ifndef HANDCOUNTER_H
 #define HANDCOUNTER_H

-#include "../game_graphics/board/abstract_graphics_item.h"
-#include "../game_graphics/board/graphics_item_type.h"
+#include "board/abstract_graphics_item.h"
+#include "board/graphics_item_type.h"

 #include <QString>

--- a/cockatrice/src/game_graphics/log/message_log_widget.cpp
+++ b/cockatrice/src/game_graphics/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>
--- a/cockatrice/src/game_graphics/log/message_log_widget.h
+++ b/cockatrice/src/game_graphics/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;
--- a/cockatrice/src/game_graphics/phases_toolbar.cpp
+++ b/cockatrice/src/game_graphics/phases_toolbar.cpp
--- a/cockatrice/src/game_graphics/phases_toolbar.h
+++ b/cockatrice/src/game_graphics/phases_toolbar.h
@ -8,7 +8,7 @@
 #ifndef PHASESTOOLBAR_H
 #define PHASESTOOLBAR_H

-#include "../game_graphics/board/abstract_graphics_item.h"
+#include "board/abstract_graphics_item.h"

 #include <QFrame>
 #include <QGraphicsObject>
--- a/cockatrice/src/game_graphics/player/card_menu_action_type.h
+++ b/cockatrice/src/game_graphics/player/card_menu_action_type.h
--- a/cockatrice/src/game_graphics/player/menu/abstract_player_component.h
+++ b/cockatrice/src/game_graphics/player/menu/abstract_player_component.h
--- a/cockatrice/src/game_graphics/player/menu/card_menu.cpp
+++ b/cockatrice/src/game_graphics/player/menu/card_menu.cpp
@ -3,10 +3,11 @@
 #include "../../../client/settings/card_counter_settings.h"
 #include "../../../interface/widgets/tabs/tab_game.h"
 #include "../../board/card_item.h"
-#include "../../zones/view_zone_logic.h"
+#include "../../game/player/player_actions.h"
+#include "../../game/player/player_logic.h"
+#include "../../game/zones/view_zone_logic.h"
 #include "../card_menu_action_type.h"
-#include "../player_actions.h"
-#include "../player_logic.h"
+#include "../player_graphics_item.h"
 #include "move_menu.h"
 #include "pt_menu.h"

@ -31,93 +32,92 @@ static QIcon createCircleIcon(const QColor &color)
    return QIcon(pixmap);
 }

-CardMenu::CardMenu(PlayerLogic *_player, const CardItem *_card, bool _shortcutsActive)
+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)
    : player(_player), card(_card), shortcutsActive(_shortcutsActive)
 {
-    auto playerActions = player->getPlayerActions();
-
-    const QList<PlayerLogic *> &players = player->getGame()->getPlayerManager()->getPlayers().values();
+    const QList<PlayerLogic *> &players = player->getLogic()->getGame()->getPlayerManager()->getPlayers().values();

    for (auto playerToAdd : players) {
-        if (playerToAdd == player) {
+        if (playerToAdd == player->getLogic()) {
            continue;
        }
        playersInfo.append(qMakePair(playerToAdd->getPlayerInfo()->getName(), playerToAdd->getPlayerInfo()->getId()));
    }

-    connect(player->getGame()->getPlayerManager(), &PlayerManager::playerRemoved, this, &CardMenu::removePlayer);
+    connect(player->getLogic()->getGame()->getPlayerManager(), &PlayerManager::playerRemoved, this,
+            &CardMenu::removePlayer);

-    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);
+    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
    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);

-    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);
+    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);

    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 *tempAddCounter = new QAction(this);
-        tempAddCounter->setIconVisibleInMenu(true);
-        tempAddCounter->setIcon(circleIcon);
+        auto *addAction = makeAction(this, [actions, sel, i]() { actions->actAddCardCounter(sel(), i); });
+        addAction->setIcon(circleIcon);
+        aAddCounter.append(addAction);

-        auto *tempRemoveCounter = new QAction(this);
-        tempRemoveCounter->setIconVisibleInMenu(true);
-        tempRemoveCounter->setIcon(circleIcon);
+        auto *removeAction = makeAction(this, [actions, sel, i]() { actions->actRemoveCardCounter(sel(), i); });
+        removeAction->setIcon(circleIcon);
+        aRemoveCounter.append(removeAction);

-        auto *tempSetCounter = new QAction(this);
-        tempSetCounter->setIconVisibleInMenu(true);
-        tempSetCounter->setIcon(circleIcon);
-
-        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); });
+        auto *setAction = makeAction(this, [actions, sel, i]() { actions->actRequestSetCardCounterDialog(sel(), i); });
+        setAction->setIcon(circleIcon);
+        aSetCounter.append(setAction);
    }

    setShortcutsActive();
@ -129,7 +129,7 @@ CardMenu::CardMenu(PlayerLogic *_player, const CardItem *_card, bool _shortcutsA
    }

    bool revealedCard = false;
-    bool writeableCard = player->getPlayerInfo()->getLocalOrJudge();
+    bool writeableCard = player->getLogic()->getPlayerInfo()->getLocalOrJudge();
    if (auto *view = qobject_cast<ZoneViewZoneLogic *>(card->getZone())) {
        if (view->getRevealZone()) {
            if (view->getWriteableRevealZone()) {
@ -313,7 +313,9 @@ void CardMenu::createHandOrCustomZoneMenu(bool canModifyCard)

    initContextualPlayersMenu(revealMenu, aRevealToAll);

-    connect(revealMenu, &QMenu::triggered, player->getPlayerActions(), &PlayerActions::actReveal);
+    connect(revealMenu, &QMenu::triggered, this, [this](QAction *action) {
+        player->getLogic()->getPlayerActions()->actReveal(player->getGameScene()->selectedCards(), action);
+    });

    addSeparator();
    addAction(aClone);
@ -398,8 +400,7 @@ void CardMenu::addRelatedCardView()
        QAction *viewCard = viewRelatedCards->addAction(relatedCardName);
        Q_UNUSED(viewCard);

-        connect(viewCard, &QAction::triggered, player->getGame(),
-                [this, cardRef] { player->getGame()->getTab()->viewCardInfo(cardRef); });
+        connect(viewCard, &QAction::triggered, this, [this, cardRef] { emit cardInfoRequested(cardRef); });
    }
 }

@ -461,7 +462,8 @@ void CardMenu::addRelatedCardActions()

        auto *createRelated = new QAction(text, this);
        createRelated->setData(QVariant(index++));
-        connect(createRelated, &QAction::triggered, player->getPlayerActions(), &PlayerActions::actCreateRelatedCard);
+        connect(createRelated, &QAction::triggered, player->getLogic()->getPlayerActions(),
+                &PlayerActions::actCreateRelatedCard);
        addAction(createRelated);
    }

@ -470,7 +472,7 @@ void CardMenu::addRelatedCardActions()
            createRelatedCards->setShortcuts(
                SettingsCache::instance().shortcuts().getShortcut("Player/aCreateRelatedTokens"));
        }
-        connect(createRelatedCards, &QAction::triggered, player->getPlayerActions(),
+        connect(createRelatedCards, &QAction::triggered, player->getLogic()->getPlayerActions(),
                &PlayerActions::actCreateAllRelatedCards);
        addAction(createRelatedCards);
    }
--- a/cockatrice/src/game_graphics/player/menu/card_menu.h
+++ b/cockatrice/src/game_graphics/player/menu/card_menu.h
@ -8,15 +8,20 @@
 #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(PlayerLogic *player, const CardItem *card, bool shortcutsActive);
+    explicit CardMenu(PlayerGraphicsItem *player, const CardItem *card, bool shortcutsActive);
    void removePlayer(PlayerLogic *playerToRemove);
    void createTableMenu(bool canModifyCard);
    void createStackMenu(bool canModifyCard);
@ -41,7 +46,7 @@ public:
    QList<QAction *> aAddCounter, aSetCounter, aRemoveCounter;

 private:
-    PlayerLogic *player;
+    PlayerGraphicsItem *player;
    const CardItem *card;
    QList<QPair<QString, int>> playersInfo;
    bool shortcutsActive;
--- a/cockatrice/src/game_graphics/player/menu/custom_zone_menu.cpp
+++ b/cockatrice/src/game_graphics/player/menu/custom_zone_menu.cpp
@ -1,13 +1,14 @@
 #include "custom_zone_menu.h"

-#include "../player_logic.h"
+#include "../../game/player/player_logic.h"
+#include "../player_graphics_item.h"

-CustomZoneMenu::CustomZoneMenu(PlayerLogic *_player) : player(_player)
+CustomZoneMenu::CustomZoneMenu(PlayerGraphicsItem *_player) : player(_player)
 {
    menuAction()->setVisible(false);

-    connect(player, &PlayerLogic::clearCustomZonesMenu, this, &CustomZoneMenu::clearCustomZonesMenu);
-    connect(player, &PlayerLogic::addViewCustomZoneActionToCustomZoneMenu, this,
+    connect(player->getLogic(), &PlayerLogic::clearCustomZonesMenu, this, &CustomZoneMenu::clearCustomZonesMenu);
+    connect(player->getLogic(), &PlayerLogic::addViewCustomZoneActionToCustomZoneMenu, this,
            &CustomZoneMenu::addViewCustomZoneActionToCustomZoneMenu);

    retranslateUi();
@ -17,7 +18,7 @@ void CustomZoneMenu::retranslateUi()
 {
    setTitle(tr("C&ustom Zones"));

-    if (player->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {

        for (auto aViewZone : actions()) {
            aViewZone->setText(tr("View custom zone '%1'").arg(aViewZone->data().toString()));
@ -37,5 +38,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, zoneName, -1); });
+            [zoneName, this]() { player->getGameScene()->toggleZoneView(player->getLogic(), zoneName, -1); });
 }
--- a/cockatrice/src/game_graphics/player/menu/custom_zone_menu.h
+++ b/cockatrice/src/game_graphics/player/menu/custom_zone_menu.h
@ -11,12 +11,12 @@

 #include <QMenu>

-class PlayerLogic;
+class PlayerGraphicsItem;
 class CustomZoneMenu : public QMenu, public AbstractPlayerComponent
 {
    Q_OBJECT
 public:
-    explicit CustomZoneMenu(PlayerLogic *player);
+    explicit CustomZoneMenu(PlayerGraphicsItem *player);
    void retranslateUi() override;
    void setShortcutsActive() override
    {
@ -26,7 +26,7 @@ public:
    }

 private:
-    PlayerLogic *player;
+    PlayerGraphicsItem *player;
 private slots:
    void clearCustomZonesMenu();
    void addViewCustomZoneActionToCustomZoneMenu(QString zoneName);
--- a/cockatrice/src/game_graphics/player/menu/grave_menu.cpp
+++ b/cockatrice/src/game_graphics/player/menu/grave_menu.cpp
@ -1,21 +1,22 @@
 #include "grave_menu.h"

-#include "../../abstract_game.h"
-#include "../player_actions.h"
-#include "../player_logic.h"
+#include "../../game/abstract_game.h"
+#include "../../game/player/player_actions.h"
+#include "../../game/player/player_logic.h"
+#include "../player_graphics_item.h"

 #include <QAction>
 #include <QMenu>
 #include <libcockatrice/utility/zone_names.h>

-GraveyardMenu::GraveyardMenu(PlayerLogic *_player, QWidget *parent) : TearOffMenu(parent), player(_player)
+GraveyardMenu::GraveyardMenu(PlayerGraphicsItem *_player, QWidget *parent) : TearOffMenu(parent), player(_player)
 {
    createMoveActions();
    createViewActions();

    addAction(aViewGraveyard);

-    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
+    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
        mRevealRandomGraveyardCard = addMenu(QString());
        connect(mRevealRandomGraveyardCard, &QMenu::aboutToShow, this,
                &GraveyardMenu::populateRevealRandomMenuWithActivePlayers);
@ -36,9 +37,9 @@ GraveyardMenu::GraveyardMenu(PlayerLogic *_player, QWidget *parent) : TearOffMen

 void GraveyardMenu::createMoveActions()
 {
-    auto grave = player->getGraveZone();
+    auto grave = player->getLogic()->getGraveZone();

-    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
+    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
        aMoveGraveToTopLibrary = new QAction(this);
        aMoveGraveToTopLibrary->setData(QList<QVariant>() << ZoneNames::DECK << 0);

@ -60,7 +61,7 @@ void GraveyardMenu::createMoveActions()

 void GraveyardMenu::createViewActions()
 {
-    PlayerActions *playerActions = player->getPlayerActions();
+    PlayerActions *playerActions = player->getLogic()->getPlayerActions();

    aViewGraveyard = new QAction(this);
    connect(aViewGraveyard, &QAction::triggered, playerActions, &PlayerActions::actViewGraveyard);
@ -76,9 +77,9 @@ void GraveyardMenu::populateRevealRandomMenuWithActivePlayers()

    mRevealRandomGraveyardCard->addSeparator();

-    const auto &players = player->getGame()->getPlayerManager()->getPlayers().values();
+    const auto &players = player->getLogic()->getGame()->getPlayerManager()->getPlayers().values();
    for (auto *other : players) {
-        if (other == player) {
+        if (other == player->getLogic()) {
            continue;
        }
        QAction *a = mRevealRandomGraveyardCard->addAction(other->getPlayerInfo()->getName());
@ -90,7 +91,7 @@ void GraveyardMenu::populateRevealRandomMenuWithActivePlayers()
 void GraveyardMenu::onRevealRandomTriggered()
 {
    if (auto *a = qobject_cast<QAction *>(sender())) {
-        player->getPlayerActions()->actRevealRandomGraveyardCard(a->data().toInt());
+        player->getLogic()->getPlayerActions()->actRevealRandomGraveyardCard(a->data().toInt());
    }
 }

@ -100,7 +101,7 @@ void GraveyardMenu::retranslateUi()

    aViewGraveyard->setText(tr("&View graveyard"));

-    if (player->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
        moveGraveMenu->setTitle(tr("&Move graveyard to..."));
        aMoveGraveToTopLibrary->setText(tr("&Top of library"));
        aMoveGraveToBottomLibrary->setText(tr("&Bottom of library"));
--- a/cockatrice/src/game_graphics/player/menu/grave_menu.h
+++ b/cockatrice/src/game_graphics/player/menu/grave_menu.h
@ -13,7 +13,7 @@
 #include <QAction>
 #include <QMenu>

-class PlayerLogic;
+class PlayerGraphicsItem;
 class GraveyardMenu : public TearOffMenu, public AbstractPlayerComponent
 {
    Q_OBJECT
@ -21,7 +21,7 @@ signals:
    void newPlayerActionCreated(QAction *action);

 public:
-    explicit GraveyardMenu(PlayerLogic *player, QWidget *parent = nullptr);
+    explicit GraveyardMenu(PlayerGraphicsItem *player, QWidget *parent = nullptr);
    void createMoveActions();
    void createViewActions();
    void populateRevealRandomMenuWithActivePlayers();
@ -40,7 +40,7 @@ public:
    QAction *aMoveGraveToRfg = nullptr;

 private:
-    PlayerLogic *player;
+    PlayerGraphicsItem *player;
 };

 #endif // COCKATRICE_GRAVE_MENU_H
--- a/cockatrice/src/game_graphics/player/menu/hand_menu.cpp
+++ b/cockatrice/src/game_graphics/player/menu/hand_menu.cpp
@ -3,18 +3,22 @@
 #include "../../../client/settings/cache_settings.h"
 #include "../../../client/settings/shortcuts_settings.h"
 #include "../../../game_graphics/zones/hand_zone.h"
-#include "../../abstract_game.h"
-#include "../player_actions.h"
-#include "../player_logic.h"
+#include "../../game/abstract_game.h"
+#include "../../game/player/player_actions.h"
+#include "../../game/player/player_logic.h"
+#include "../player_graphics_item.h"

 #include <QAction>
 #include <QMenu>
 #include <libcockatrice/utility/zone_names.h>

-HandMenu::HandMenu(PlayerLogic *_player, PlayerActions *actions, QWidget *parent) : TearOffMenu(parent), player(_player)
+HandMenu::HandMenu(PlayerGraphicsItem *_player, QWidget *parent) : TearOffMenu(parent), player(_player)
 {
-    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
+    auto *actions = player->getLogic()->getPlayerActions();
+
+    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
        aViewHand = new QAction(this);
+
        connect(aViewHand, &QAction::triggered, actions, &PlayerActions::actViewHand);
        addAction(aViewHand);

@ -58,7 +62,7 @@ HandMenu::HandMenu(PlayerLogic *_player, PlayerActions *actions, QWidget *parent
    addSeparator();

    aMulligan = new QAction(this);
-    connect(aMulligan, &QAction::triggered, actions, &PlayerActions::actMulligan);
+    connect(aMulligan, &QAction::triggered, actions, &PlayerActions::actRequestMulliganDialog);
    addAction(aMulligan);

    // Mulligan same size
@ -75,7 +79,7 @@ HandMenu::HandMenu(PlayerLogic *_player, PlayerActions *actions, QWidget *parent

    mMoveHandMenu = addTearOffMenu(QString());

-    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
+    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
        aMoveHandToTopLibrary = new QAction(this);
        aMoveHandToTopLibrary->setData(QList<QVariant>() << ZoneNames::DECK << 0);
        aMoveHandToBottomLibrary = new QAction(this);
@ -85,7 +89,7 @@ HandMenu::HandMenu(PlayerLogic *_player, PlayerActions *actions, QWidget *parent
        aMoveHandToRfg = new QAction(this);
        aMoveHandToRfg->setData(QList<QVariant>() << ZoneNames::EXILE << 0);

-        auto hand = player->getHandZone();
+        auto hand = player->getLogic()->getHandZone();

        connect(aMoveHandToTopLibrary, &QAction::triggered, hand, &HandZoneLogic::moveAllToZone);
        connect(aMoveHandToBottomLibrary, &QAction::triggered, hand, &HandZoneLogic::moveAllToZone);
@ -107,7 +111,7 @@ void HandMenu::retranslateUi()
 {
    setTitle(tr("&Hand"));

-    if (player->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
        aViewHand->setText(tr("&View hand"));

        mSortHand->setTitle(tr("Sort hand by..."));
@ -166,9 +170,9 @@ void HandMenu::populateRevealHandMenuWithActivePlayers()

    mRevealHand->addSeparator();

-    const auto &players = player->getGame()->getPlayerManager()->getPlayers().values();
+    const auto &players = player->getLogic()->getGame()->getPlayerManager()->getPlayers().values();
    for (auto *other : players) {
-        if (other == player) {
+        if (other == player->getLogic()) {
            continue;
        }
        QAction *a = mRevealHand->addAction(other->getPlayerInfo()->getName());
@ -185,9 +189,9 @@ void HandMenu::populateRevealRandomHandCardMenuWithActivePlayers()

    mRevealRandomHandCard->addSeparator();

-    const auto &players = player->getGame()->getPlayerManager()->getPlayers().values();
+    const auto &players = player->getLogic()->getGame()->getPlayerManager()->getPlayers().values();
    for (auto *other : players) {
-        if (other == player) {
+        if (other == player->getLogic()) {
            continue;
        }
        QAction *a = mRevealRandomHandCard->addAction(other->getPlayerInfo()->getName());
@ -204,7 +208,7 @@ void HandMenu::onRevealHandTriggered()
    }

    const int targetId = action->data().toInt();
-    player->getPlayerActions()->actRevealHand(targetId);
+    player->getLogic()->getPlayerActions()->actRevealHand(targetId);
 }

 void HandMenu::onRevealRandomHandCardTriggered()
@ -215,5 +219,5 @@ void HandMenu::onRevealRandomHandCardTriggered()
    }

    const int targetId = action->data().toInt();
-    player->getPlayerActions()->actRevealRandomHandCard(targetId);
+    player->getLogic()->getPlayerActions()->actRevealRandomHandCard(targetId);
 }
--- a/cockatrice/src/game_graphics/player/menu/hand_menu.h
+++ b/cockatrice/src/game_graphics/player/menu/hand_menu.h
@ -13,7 +13,7 @@
 #include <QAction>
 #include <QMenu>

-class PlayerLogic;
+class PlayerGraphicsItem;
 class PlayerActions;

 class HandMenu : public TearOffMenu, public AbstractPlayerComponent
@ -21,7 +21,7 @@ class HandMenu : public TearOffMenu, public AbstractPlayerComponent
    Q_OBJECT

 public:
-    HandMenu(PlayerLogic *player, PlayerActions *actions, QWidget *parent = nullptr);
+    HandMenu(PlayerGraphicsItem *player, QWidget *parent = nullptr);

    QMenu *revealHandMenu() const
    {
@ -43,7 +43,7 @@ private slots:
    void onRevealRandomHandCardTriggered();

 private:
-    PlayerLogic *player;
+    PlayerGraphicsItem *player;

    QAction *aViewHand = nullptr;
    QAction *aMulligan = nullptr;
--- a/cockatrice/src/game_graphics/player/menu/library_menu.cpp
+++ b/cockatrice/src/game_graphics/player/menu/library_menu.cpp
@ -3,14 +3,16 @@
 #include "../../../client/settings/cache_settings.h"
 #include "../../../client/settings/shortcuts_settings.h"
 #include "../../../interface/widgets/tabs/tab_game.h"
-#include "../../abstract_game.h"
-#include "../player_actions.h"
-#include "../player_logic.h"
+#include "../../game/abstract_game.h"
+#include "../../game/player/player_actions.h"
+#include "../../game/player/player_logic.h"
+#include "../player_graphics_item.h"

 #include <QAction>
+#include <QGraphicsView>
 #include <QMenu>

-LibraryMenu::LibraryMenu(PlayerLogic *_player, QWidget *parent) : TearOffMenu(parent), player(_player)
+LibraryMenu::LibraryMenu(PlayerGraphicsItem *_player, QWidget *parent) : TearOffMenu(parent), player(_player)
 {
    createDrawActions();
    createShuffleActions();
@ -75,8 +77,8 @@ LibraryMenu::LibraryMenu(PlayerLogic *_player, QWidget *parent) : TearOffMenu(pa
    bottomLibraryMenu->addSeparator();
    bottomLibraryMenu->addAction(aShuffleBottomCards);

-    connect(player, &PlayerLogic::resetTopCardMenuActions, this, &LibraryMenu::resetTopCardMenuActions);
-    connect(player, &PlayerLogic::deckChanged, this, &LibraryMenu::enableOpenInDeckEditorAction);
+    connect(player->getLogic(), &PlayerLogic::resetTopCardMenuActions, this, &LibraryMenu::resetTopCardMenuActions);
+    connect(player->getLogic(), &PlayerLogic::deckChanged, this, &LibraryMenu::enableOpenInDeckEditorAction);

    retranslateUi();
 }
@ -94,41 +96,41 @@ void LibraryMenu::resetTopCardMenuActions()

 void LibraryMenu::createDrawActions()
 {
-    PlayerActions *playerActions = player->getPlayerActions();
+    PlayerActions *playerActions = player->getLogic()->getPlayerActions();

-    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
+    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
        aDrawCard = new QAction(this);
        connect(aDrawCard, &QAction::triggered, playerActions, &PlayerActions::actDrawCard);
        aDrawCards = new QAction(this);
-        connect(aDrawCards, &QAction::triggered, playerActions, &PlayerActions::actDrawCards);
+        connect(aDrawCards, &QAction::triggered, playerActions, &PlayerActions::actRequestDrawCardsDialog);
        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::actDrawBottomCards);
+        connect(aDrawBottomCards, &QAction::triggered, playerActions, &PlayerActions::actRequestDrawBottomCardsDialog);
    }
 }

 void LibraryMenu::createShuffleActions()
 {
-    PlayerActions *playerActions = player->getPlayerActions();
+    PlayerActions *playerActions = player->getLogic()->getPlayerActions();

-    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
+    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
        aShuffle = new QAction(this);
        connect(aShuffle, &QAction::triggered, playerActions, &PlayerActions::actShuffle);
        aShuffleTopCards = new QAction(this);
-        connect(aShuffleTopCards, &QAction::triggered, playerActions, &PlayerActions::actShuffleTop);
+        connect(aShuffleTopCards, &QAction::triggered, playerActions, &PlayerActions::actRequestShuffleTopDialog);
        aShuffleBottomCards = new QAction(this);
-        connect(aShuffleBottomCards, &QAction::triggered, playerActions, &PlayerActions::actShuffleBottom);
+        connect(aShuffleBottomCards, &QAction::triggered, playerActions, &PlayerActions::actRequestShuffleBottomDialog);
    }
 }

 void LibraryMenu::createMoveActions()
 {
-    PlayerActions *playerActions = player->getPlayerActions();
+    PlayerActions *playerActions = player->getLogic()->getPlayerActions();

-    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
+    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
        aMoveTopToPlay = new QAction(this);
        connect(aMoveTopToPlay, &QAction::triggered, playerActions, &PlayerActions::actMoveTopCardToPlay);
        aMoveTopToPlayFaceDown = new QAction(this);
@ -149,7 +151,8 @@ void LibraryMenu::createMoveActions()
        connect(aMoveTopCardsToExileFaceDown, &QAction::triggered, playerActions,
                &PlayerActions::actMoveTopCardsToExileFaceDown);
        aMoveTopCardsUntil = new QAction(this);
-        connect(aMoveTopCardsUntil, &QAction::triggered, playerActions, &PlayerActions::actMoveTopCardsUntil);
+        connect(aMoveTopCardsUntil, &QAction::triggered, playerActions,
+                &PlayerActions::actRequestMoveTopCardsUntilDialog);
        aMoveTopCardToBottom = new QAction(this);
        connect(aMoveTopCardToBottom, &QAction::triggered, playerActions, &PlayerActions::actMoveTopCardToBottom);

@ -181,16 +184,16 @@ void LibraryMenu::createMoveActions()

 void LibraryMenu::createViewActions()
 {
-    PlayerActions *playerActions = player->getPlayerActions();
+    PlayerActions *playerActions = player->getLogic()->getPlayerActions();

-    if (player->getPlayerInfo()->local || player->getPlayerInfo()->judge) {
+    if (player->getLogic()->getPlayerInfo()->local || player->getLogic()->getPlayerInfo()->judge) {
        aViewLibrary = new QAction(this);
        connect(aViewLibrary, &QAction::triggered, playerActions, &PlayerActions::actViewLibrary);

        aViewTopCards = new QAction(this);
-        connect(aViewTopCards, &QAction::triggered, playerActions, &PlayerActions::actViewTopCards);
+        connect(aViewTopCards, &QAction::triggered, playerActions, &PlayerActions::actRequestViewTopCardsDialog);
        aViewBottomCards = new QAction(this);
-        connect(aViewBottomCards, &QAction::triggered, playerActions, &PlayerActions::actViewBottomCards);
+        connect(aViewBottomCards, &QAction::triggered, playerActions, &PlayerActions::actRequestViewBottomCardsDialog);
        aAlwaysRevealTopCard = new QAction(this);
        aAlwaysRevealTopCard->setCheckable(true);
        connect(aAlwaysRevealTopCard, &QAction::triggered, playerActions, &PlayerActions::actAlwaysRevealTopCard);
@ -207,7 +210,7 @@ void LibraryMenu::retranslateUi()
 {
    setTitle(tr("&Library"));

-    if (player->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
        aViewLibrary->setText(tr("&View library"));
        aViewTopCards->setText(tr("View &top cards of library..."));
        aViewBottomCards->setText(tr("View bottom cards of library..."));
@ -263,9 +266,9 @@ void LibraryMenu::populateRevealLibraryMenuWithActivePlayers()

    mRevealLibrary->addSeparator();

-    const auto &players = player->getGame()->getPlayerManager()->getPlayers().values();
+    const auto &players = player->getLogic()->getGame()->getPlayerManager()->getPlayers().values();
    for (auto *other : players) {
-        if (other == player) {
+        if (other == player->getLogic()) {
            continue;
        }
        QAction *a = mRevealLibrary->addAction(other->getPlayerInfo()->getName());
@ -278,9 +281,9 @@ void LibraryMenu::populateLendLibraryMenuWithActivePlayers()
 {
    mLendLibrary->clear();

-    const auto &players = player->getGame()->getPlayerManager()->getPlayers().values();
+    const auto &players = player->getLogic()->getGame()->getPlayerManager()->getPlayers().values();
    for (auto *other : players) {
-        if (other == player) {
+        if (other == player->getLogic()) {
            continue;
        }
        QAction *a = mLendLibrary->addAction(other->getPlayerInfo()->getName());
@ -299,9 +302,9 @@ void LibraryMenu::populateRevealTopCardMenuWithActivePlayers()

    mRevealTopCard->addSeparator();

-    const auto &players = player->getGame()->getPlayerManager()->getPlayers().values();
+    const auto &players = player->getLogic()->getGame()->getPlayerManager()->getPlayers().values();
    for (auto *other : players) {
-        if (other == player) {
+        if (other == player->getLogic()) {
            continue;
        }
        QAction *a = mRevealTopCard->addAction(other->getPlayerInfo()->getName());
@ -313,27 +316,33 @@ void LibraryMenu::populateRevealTopCardMenuWithActivePlayers()
 void LibraryMenu::onRevealLibraryTriggered()
 {
    if (auto *a = qobject_cast<QAction *>(sender())) {
-        player->getPlayerActions()->actRevealLibrary(a->data().toInt());
+        player->getLogic()->getPlayerActions()->actRevealLibrary(a->data().toInt());
    }
 }

 void LibraryMenu::onLendLibraryTriggered()
 {
    if (auto *a = qobject_cast<QAction *>(sender())) {
-        player->getPlayerActions()->actLendLibrary(a->data().toInt());
+        player->getLogic()->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->getDeckZone()->getCards().size();
-        bool ok;
-        int number = QInputDialog::getInt(player->getGame()->getTab(), tr("Reveal top cards of library"),
+
+        int deckSize = player->getLogic()->getDeckZone()->getCards().size();
+        bool ok = true;
+        int number = QInputDialog::getInt(parent, tr("Reveal top cards of library"),
                                          tr("Number of cards: (max. %1)").arg(deckSize), defaultNumberTopCards, 1,
                                          deckSize, 1, &ok);
+
        if (ok) {
-            player->getPlayerActions()->actRevealTopCards(a->data().toInt(), number);
+            player->getLogic()->getPlayerActions()->actRevealTopCards(a->data().toInt(), number);
            defaultNumberTopCards = number;
        }
    }
--- a/cockatrice/src/game_graphics/player/menu/library_menu.h
+++ b/cockatrice/src/game_graphics/player/menu/library_menu.h
@ -13,6 +13,7 @@
 #include <QAction>
 #include <QMenu>

+class PlayerGraphicsItem;
 class PlayerLogic;
 class PlayerActions;

@ -24,7 +25,7 @@ public slots:
    void resetTopCardMenuActions();

 public:
-    LibraryMenu(PlayerLogic *player, QWidget *parent = nullptr);
+    LibraryMenu(PlayerGraphicsItem *player, QWidget *parent = nullptr);
    void createDrawActions();
    void createShuffleActions();
    void createMoveActions();
@ -111,7 +112,7 @@ public:
    int defaultNumberTopCards = 1;

 private:
-    PlayerLogic *player;
+    PlayerGraphicsItem *player;
 };

 #endif // COCKATRICE_LIBRARY_MENU_H
--- a/cockatrice/src/game_graphics/player/menu/move_menu.cpp
+++ b/cockatrice/src/game_graphics/player/menu/move_menu.cpp
@ -1,10 +1,11 @@
 #include "move_menu.h"

+#include "../../game/player/player_actions.h"
+#include "../../game/player/player_logic.h"
 #include "../card_menu_action_type.h"
-#include "../player_actions.h"
-#include "../player_logic.h"
+#include "../player_graphics_item.h"

-MoveMenu::MoveMenu(PlayerLogic *player) : QMenu(tr("Move to"))
+MoveMenu::MoveMenu(PlayerGraphicsItem *player) : QMenu(tr("Move to"))
 {
    aMoveToTopLibrary = new QAction(this);
    aMoveToTopLibrary->setData(cmMoveToTopLibrary);
@ -20,14 +21,22 @@ MoveMenu::MoveMenu(PlayerLogic *player) : QMenu(tr("Move to"))
    aMoveToExile = new QAction(this);
    aMoveToExile->setData(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);
+    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));

    addAction(aMoveToTopLibrary);
    addAction(aMoveToXfromTopOfLibrary);
--- a/cockatrice/src/game_graphics/player/menu/move_menu.h
+++ b/cockatrice/src/game_graphics/player/menu/move_menu.h
@ -8,13 +8,13 @@
 #define COCKATRICE_MOVE_MENU_H
 #include <QMenu>

-class PlayerLogic;
+class PlayerGraphicsItem;
 class MoveMenu : public QMenu
 {
    Q_OBJECT

 public:
-    explicit MoveMenu(PlayerLogic *player);
+    explicit MoveMenu(PlayerGraphicsItem *player);
    void setShortcutsActive();
    void retranslateUi();

--- a/cockatrice/src/game_graphics/player/menu/player_menu.cpp
+++ b/cockatrice/src/game_graphics/player/menu/player_menu.cpp
@ -5,17 +5,21 @@
 #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(PlayerLogic *_player) : QObject(_player), player(_player)
+PlayerMenu::PlayerMenu(PlayerGraphicsItem *_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->getPlayerInfo()->getLocalOrJudge()) {
-        handMenu = addManagedMenu<HandMenu>(player, player->getPlayerActions(), playerMenu);
+    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
+        handMenu = addManagedMenu<HandMenu>(player, playerMenu);
        libraryMenu = addManagedMenu<LibraryMenu>(player, playerMenu);
    } else {
        handMenu = nullptr;
@ -25,7 +29,7 @@ PlayerMenu::PlayerMenu(PlayerLogic *_player) : QObject(_player), player(_player)
    graveMenu = addManagedMenu<GraveyardMenu>(player, playerMenu);
    rfgMenu = addManagedMenu<RfgMenu>(player, playerMenu);

-    if (player->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
        sideboardMenu = addManagedMenu<SideboardMenu>(player, playerMenu);
        customZonesMenu = addManagedMenu<CustomZoneMenu>(player);
        playerMenu->addSeparator();
@ -40,7 +44,7 @@ PlayerMenu::PlayerMenu(PlayerLogic *_player) : QObject(_player), player(_player)
        utilityMenu = nullptr;
    }

-    if (player->getPlayerInfo()->getLocal()) {
+    if (player->getLogic()->getPlayerInfo()->getLocal()) {
        sayMenu = addManagedMenu<SayMenu>(player);
    } else {
        sayMenu = nullptr;
@ -55,13 +59,13 @@ PlayerMenu::PlayerMenu(PlayerLogic *_player) : QObject(_player), player(_player)

 void PlayerMenu::setMenusForGraphicItems()
 {
-    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);
+    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);
    }
 }

@ -74,12 +78,14 @@ 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->getGame()->getPlayerManager()->isSpectator() && !player->getGame()->getPlayerManager()->isJudge()) ||
-        player->getGame()->getActiveCard() != card) {
+    if ((player->getLogic()->getGame()->getPlayerManager()->isSpectator() &&
+         !player->getLogic()->getGame()->getPlayerManager()->isJudge()) ||
+        player->getLogic()->getGame()->getActiveCard() != card) {
        return nullptr;
    }

-    QMenu *menu = new CardMenu(player, card, shortcutsActive);
+    CardMenu *menu = new CardMenu(player, card, shortcutsActive);
+    connect(menu, &CardMenu::cardInfoRequested, this, &PlayerMenu::cardInfoRequested);
    emit cardMenuUpdated(menu);

    return menu;
@ -87,7 +93,7 @@ QMenu *PlayerMenu::updateCardMenu(const CardItem *card)

 void PlayerMenu::retranslateUi()
 {
-    playerMenu->setTitle(tr("Player \"%1\"").arg(player->getPlayerInfo()->getName()));
+    playerMenu->setTitle(tr("Player \"%1\"").arg(player->getLogic()->getPlayerInfo()->getName()));

    for (auto *component : managedComponents) {
        component->retranslateUi();
@ -104,7 +110,8 @@ 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->getPlayerInfo()->getLocalOrJudge() && !player->getPlayerInfo()->getLocal()) {
+        if (player->getLogic()->getPlayerInfo()->getLocalOrJudge() &&
+            !player->getLogic()->getPlayerInfo()->getLocal()) {
            setShortcutsInactive();
        } else {
            setShortcutsActive();
--- a/cockatrice/src/game_graphics/player/menu/player_menu.h
+++ b/cockatrice/src/game_graphics/player/menu/player_menu.h
@ -8,7 +8,6 @@
 #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"
@ -23,29 +22,31 @@
 #include <QObject>

 class CardItem;
+class CardMenu;
+class PlayerGraphicsItem;
 class PlayerMenu : public QObject
 {
    Q_OBJECT

 signals:
-    void cardMenuUpdated(QMenu *cardMenu);
+    void cardMenuUpdated(CardMenu *cardMenu);
+    void cardInfoRequested(const CardRef &cardRef);
    void shortcutsActivated();
    void shortcutsDeactivated();
    void retranslateRequested();

 public slots:
    void setMenusForGraphicItems();
+    QMenu *updateCardMenu(const CardItem *card);

 private slots:
    void refreshShortcuts();

 public:
-    explicit PlayerMenu(PlayerLogic *player);
+    explicit PlayerMenu(PlayerGraphicsItem *player);
    /** @brief Retranslate all user-visible strings. Called on language change. */
    void retranslateUi();

-    QMenu *updateCardMenu(const CardItem *card);
-
    [[nodiscard]] QMenu *getPlayerMenu() const
    {
        return playerMenu;
@ -77,7 +78,7 @@ public:
    void setShortcutsInactive();

 private:
-    PlayerLogic *player;
+    PlayerGraphicsItem *player;
    TearOffMenu *playerMenu;
    QMenu *countersMenu;
    HandMenu *handMenu;
--- a/cockatrice/src/game_graphics/player/menu/pt_menu.cpp
+++ b/cockatrice/src/game_graphics/player/menu/pt_menu.cpp
@ -1,32 +1,43 @@
 #include "pt_menu.h"

-#include "../player_actions.h"
-#include "../player_logic.h"
+#include "../../game/player/player_actions.h"
+#include "../../game/player/player_logic.h"
+#include "../player_graphics_item.h"

-PtMenu::PtMenu(PlayerLogic *player) : QMenu(tr("Power / toughness"))
+PtMenu::PtMenu(PlayerGraphicsItem *player) : QMenu(tr("Power / toughness"))
 {
-    PlayerActions *playerActions = player->getPlayerActions();
+    PlayerActions *playerActions = player->getLogic()->getPlayerActions();

    aIncP = new QAction(this);
-    connect(aIncP, &QAction::triggered, playerActions, &PlayerActions::actIncP);
+    connect(aIncP, &QAction::triggered, playerActions,
+            [player, playerActions] { playerActions->actIncP(player->getGameScene()->selectedCards()); });
    aDecP = new QAction(this);
-    connect(aDecP, &QAction::triggered, playerActions, &PlayerActions::actDecP);
+    connect(aDecP, &QAction::triggered, playerActions,
+            [player, playerActions] { playerActions->actDecP(player->getGameScene()->selectedCards()); });
    aIncT = new QAction(this);
-    connect(aIncT, &QAction::triggered, playerActions, &PlayerActions::actIncT);
+    connect(aIncT, &QAction::triggered, playerActions,
+            [player, playerActions] { playerActions->actIncT(player->getGameScene()->selectedCards()); });
    aDecT = new QAction(this);
-    connect(aDecT, &QAction::triggered, playerActions, &PlayerActions::actDecT);
+    connect(aDecT, &QAction::triggered, playerActions,
+            [player, playerActions] { playerActions->actDecT(player->getGameScene()->selectedCards()); });
    aIncPT = new QAction(this);
-    connect(aIncPT, &QAction::triggered, playerActions, [playerActions] { playerActions->actIncPT(); });
+    connect(aIncPT, &QAction::triggered, playerActions,
+            [player, playerActions] { playerActions->actIncPT(player->getGameScene()->selectedCards()); });
    aDecPT = new QAction(this);
-    connect(aDecPT, &QAction::triggered, playerActions, &PlayerActions::actDecPT);
+    connect(aDecPT, &QAction::triggered, playerActions,
+            [player, playerActions] { playerActions->actDecPT(player->getGameScene()->selectedCards()); });
    aFlowP = new QAction(this);
-    connect(aFlowP, &QAction::triggered, playerActions, &PlayerActions::actFlowP);
+    connect(aFlowP, &QAction::triggered, playerActions,
+            [player, playerActions] { playerActions->actFlowP(player->getGameScene()->selectedCards()); });
    aFlowT = new QAction(this);
-    connect(aFlowT, &QAction::triggered, playerActions, &PlayerActions::actFlowT);
+    connect(aFlowT, &QAction::triggered, playerActions,
+            [player, playerActions] { playerActions->actFlowT(player->getGameScene()->selectedCards()); });
    aSetPT = new QAction(this);
-    connect(aSetPT, &QAction::triggered, playerActions, &PlayerActions::actSetPT);
+    connect(aSetPT, &QAction::triggered, playerActions,
+            [player, playerActions] { playerActions->actRequestSetPTDialog(player->getGameScene()->selectedCards()); });
    aResetPT = new QAction(this);
-    connect(aResetPT, &QAction::triggered, playerActions, &PlayerActions::actResetPT);
+    connect(aResetPT, &QAction::triggered, playerActions,
+            [player, playerActions] { playerActions->actResetPT(player->getGameScene()->selectedCards()); });

    addAction(aIncP);
    addAction(aDecP);
--- a/cockatrice/src/game_graphics/player/menu/pt_menu.h
+++ b/cockatrice/src/game_graphics/player/menu/pt_menu.h
@ -8,14 +8,14 @@
 #define COCKATRICE_PT_MENU_H
 #include <QMenu>

-class PlayerLogic;
+class PlayerGraphicsItem;
 class PtMenu : public QMenu
 {

    Q_OBJECT

 public:
-    explicit PtMenu(PlayerLogic *player);
+    explicit PtMenu(PlayerGraphicsItem *player);
    void retranslateUi();
    void setShortcutsActive();

--- a/cockatrice/src/game_graphics/player/menu/rfg_menu.cpp
+++ b/cockatrice/src/game_graphics/player/menu/rfg_menu.cpp
@ -1,18 +1,19 @@
 #include "rfg_menu.h"

-#include "../player_actions.h"
-#include "../player_logic.h"
+#include "../../game/player/player_actions.h"
+#include "../../game/player/player_logic.h"
+#include "../player_graphics_item.h"

 #include <libcockatrice/utility/zone_names.h>

-RfgMenu::RfgMenu(PlayerLogic *_player, QWidget *parent) : TearOffMenu(parent), player(_player)
+RfgMenu::RfgMenu(PlayerGraphicsItem *_player, QWidget *parent) : TearOffMenu(parent), player(_player)
 {
    createMoveActions();
    createViewActions();

    addAction(aViewRfg);

-    if (player->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
        addSeparator();
        moveRfgMenu = addTearOffMenu(QString());
        moveRfgMenu->addAction(aMoveRfgToTopLibrary);
@ -28,8 +29,8 @@ RfgMenu::RfgMenu(PlayerLogic *_player, QWidget *parent) : TearOffMenu(parent), p

 void RfgMenu::createMoveActions()
 {
-    if (player->getPlayerInfo()->getLocalOrJudge()) {
-        auto rfg = player->getRfgZone();
+    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
+        auto rfg = player->getLogic()->getRfgZone();

        aMoveRfgToTopLibrary = new QAction(this);
        aMoveRfgToTopLibrary->setData(QList<QVariant>() << ZoneNames::DECK << 0);
@ -49,7 +50,7 @@ void RfgMenu::createMoveActions()

 void RfgMenu::createViewActions()
 {
-    PlayerActions *playerActions = player->getPlayerActions();
+    PlayerActions *playerActions = player->getLogic()->getPlayerActions();

    aViewRfg = new QAction(this);
    connect(aViewRfg, &QAction::triggered, playerActions, &PlayerActions::actViewRfg);
@ -61,7 +62,7 @@ void RfgMenu::retranslateUi()

    aViewRfg->setText(tr("&View exile"));

-    if (player->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
        moveRfgMenu->setTitle(tr("&Move exile to..."));
        aMoveRfgToTopLibrary->setText(tr("&Top of library"));
        aMoveRfgToBottomLibrary->setText(tr("&Bottom of library"));
--- a/cockatrice/src/game_graphics/player/menu/rfg_menu.h
+++ b/cockatrice/src/game_graphics/player/menu/rfg_menu.h
@ -13,12 +13,12 @@
 #include <QAction>
 #include <QMenu>

-class PlayerLogic;
+class PlayerGraphicsItem;
 class RfgMenu : public TearOffMenu, public AbstractPlayerComponent
 {
    Q_OBJECT
 public:
-    explicit RfgMenu(PlayerLogic *player, QWidget *parent = nullptr);
+    explicit RfgMenu(PlayerGraphicsItem *player, QWidget *parent = nullptr);
    void createMoveActions();
    void createViewActions();
    void retranslateUi() override;
@ -38,7 +38,7 @@ public:
    QAction *aMoveRfgToGrave = nullptr;

 private:
-    PlayerLogic *player;
+    PlayerGraphicsItem *player;
 };

 #endif // COCKATRICE_RFG_MENU_H
--- a/cockatrice/src/game_graphics/player/menu/say_menu.cpp
+++ b/cockatrice/src/game_graphics/player/menu/say_menu.cpp
@ -1,10 +1,11 @@
 #include "say_menu.h"

 #include "../../../client/settings/cache_settings.h"
-#include "../player_actions.h"
-#include "../player_logic.h"
+#include "../../game/player/player_actions.h"
+#include "../../game/player/player_logic.h"
+#include "../player_graphics_item.h"

-SayMenu::SayMenu(PlayerLogic *_player) : player(_player)
+SayMenu::SayMenu(PlayerGraphicsItem *_player) : player(_player)
 {
    connect(&SettingsCache::instance().messages(), &MessageSettings::messageMacrosChanged, this, &SayMenu::initSayMenu);
    initSayMenu();
@ -44,7 +45,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->getPlayerActions(), &PlayerActions::actSayMessage);
+        connect(newAction, &QAction::triggered, player->getLogic()->getPlayerActions(), &PlayerActions::actSayMessage);
        addAction(newAction);
    }

--- a/cockatrice/src/game_graphics/player/menu/say_menu.h
+++ b/cockatrice/src/game_graphics/player/menu/say_menu.h
@ -11,12 +11,12 @@

 #include <QMenu>

-class PlayerLogic;
+class PlayerGraphicsItem;
 class SayMenu : public QMenu, public AbstractPlayerComponent
 {
    Q_OBJECT
 public:
-    explicit SayMenu(PlayerLogic *player);
+    explicit SayMenu(PlayerGraphicsItem *player);

    void retranslateUi() override;
    void setShortcutsActive() override;
@ -26,7 +26,7 @@ private slots:
    void initSayMenu();

 private:
-    PlayerLogic *player;
+    PlayerGraphicsItem *player;
    bool shortcutsActive = false;
 };

--- a/cockatrice/src/game_graphics/player/menu/sideboard_menu.cpp
+++ b/cockatrice/src/game_graphics/player/menu/sideboard_menu.cpp
@ -1,14 +1,16 @@
 #include "sideboard_menu.h"

-#include "../player_actions.h"
-#include "../player_logic.h"
+#include "../../game/player/player_actions.h"
+#include "../../game/player/player_logic.h"
+#include "../player_graphics_item.h"

-SideboardMenu::SideboardMenu(PlayerLogic *player, QMenu *playerMenu) : QMenu(playerMenu)
+SideboardMenu::SideboardMenu(PlayerGraphicsItem *player, QMenu *playerMenu) : QMenu(playerMenu)
 {
    aViewSideboard = new QAction(this);
-    connect(aViewSideboard, &QAction::triggered, player->getPlayerActions(), &PlayerActions::actViewSideboard);
+    connect(aViewSideboard, &QAction::triggered, player->getLogic()->getPlayerActions(),
+            &PlayerActions::actViewSideboard);

-    if (player->getPlayerInfo()->getLocalOrJudge()) {
+    if (player->getLogic()->getPlayerInfo()->getLocalOrJudge()) {
        addAction(aViewSideboard);
    }

--- a/Show more
+++ b/Show more