fix: sync frontend & chain with new contract interface

- Add allHexKeys/hexExists to GameEngine for global hex enumeration
- Add getAllHexKeys ABI to mcp-server, update getWorld to return all hexes
- Fix frontend useGameEngine to match new getHex return signature
- Update Phaser scenes, CartoonTextures, LocationCluster for new hex data
- Update BuildingTags and WorldLayout for reduced slot count

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: keanji-x

contracts/src/GameEngine.sol

@@ -56,6 +56,8 @@ contract GameEngine is Initializable, OwnableUpgradeable, UUPSUpgradeable {
     mapping(bytes32 => Hex) public hexes;
     mapping(uint256 => bytes32[]) public agentHexKeys;   // agentId → owned hex keys
     mapping(uint256 => uint256) public hexCount;          // agentId → owned hex count
+    bytes32[] public allHexKeys;                          // global list of all ever-created hex keys
+    mapping(bytes32 => bool) public hexExists;            // dedup guard for allHexKeys
 
     /// @notice Agent-level ore pool. All hex production flows here.
     mapping(uint256 => uint256) public orePool;
@@ -185,6 +187,10 @@ contract GameEngine is Initializable, OwnableUpgradeable, UUPSUpgradeable {
         h.reserve = INITIAL_RESERVE;
         h.happiness = MAX_HAPPINESS;
         h.happinessUpdatedAt = block.timestamp;
+        if (!hexExists[key]) {
+            allHexKeys.push(key);
+            hexExists[key] = true;
+        }
     }
 
     // ══════════════════════════════════════════════════════════
@@ -402,6 +408,10 @@ contract GameEngine is Initializable, OwnableUpgradeable, UUPSUpgradeable {
         return agentHexKeys[agentId];
     }
 
+    function getAllHexKeys() external view returns (bytes32[] memory) {
+        return allHexKeys;
+    }
+
 
     // ══════════════════════════════════════════════════════════
     //                     RAID (composite attack)

frontend/src/game/BuildingTags.ts

@@ -29,11 +29,16 @@ export function allBuildingTextureKeys(): { key: string; file: string }[] {
   return result;
 }
 
-/** Resolve a location name to a building texture key. */
-export function buildingKeyForLocation(name: string): string {
+/** Resolve a location name to a building ID (e.g. 'medieval_mine'). */
+export function buildingIdForLocation(name: string): string {
   const lower = name.toLowerCase();
   for (const [keyword, tile] of Object.entries(TAG_MAP)) {
-    if (lower.includes(keyword)) return `building_${tile}`;
+    if (lower.includes(keyword)) return tile;
   }
-  return `building_${FALLBACK}`;
+  return FALLBACK;
+}
+
+/** Resolve a location name to a building texture key. */
+export function buildingKeyForLocation(name: string): string {
+  return `building_${buildingIdForLocation(name)}`;
 }

frontend/src/game/world/WorldLayout.ts

@@ -20,15 +20,18 @@ export function computeWorldLayout(
   }
 
   locArray.forEach((loc) => {
+    const hex = locToHex[loc.id];
+    // Only show locations that are tied to an agent's hex
+    if (!hex || hex.ownerId <= 0) return;
+
     const q = loc.q * LOCATION_SPREAD;
     const r = loc.r * LOCATION_SPREAD;
-    const hex = locToHex[loc.id];
 
     resolvedLocations.push({
       id: loc.id,
       name: loc.name,
-      ownerId: hex?.ownerId ?? 0,
-      ownerName: hex?.ownerId ? (agents[hex.ownerId]?.name ?? `#${hex.ownerId}`) : '',
+      ownerId: hex.ownerId,
+      ownerName: agents[hex.ownerId]?.name ?? `#${hex.ownerId}`,
       center: hexToPixel(q, r),
       centerHex: { q, r },
     });

frontend/src/hooks/useGameEngine.ts

@@ -35,6 +35,7 @@ const GAME_ENGINE_ABI = [
   'function getScore(uint256) view returns (uint256)',
   'function hexCount(uint256) view returns (uint256)',
   'function getAgentHexKeys(uint256) view returns (bytes32[])',
+  'function getAllHexKeys() view returns (bytes32[])',
   'function getHex(bytes32) view returns (uint256 ownerId, uint256 locationId, int32 q, int32 r, uint256 mineCount, uint256 arsenalCount, uint256 lastHarvest, uint256 reserve, uint256 happiness, uint256 happinessUpdatedAt)',
   'function orePool(uint256) view returns (uint256)',
 ];
@@ -56,9 +57,7 @@ function parseBoardResult(raw: any): BoardState {
 }
 
 export function useGameEngine() {
-  const setAgents = useGameStore((s) => s.setAgents);
-  const setLocations = useGameStore((s) => s.setLocations);
-  const setHexes = useGameStore((s) => s.setHexes);
+  const setWorldData = useGameStore((s) => s.setWorldData);
   const setAgentHexes = useGameStore((s) => s.setAgentHexes);
   const setMemories = useGameStore((s) => s.setMemories);
   const setLocationBoard = useGameStore((s) => s.setLocationBoard);
@@ -131,35 +130,37 @@ export function useGameEngine() {
         const newAgents: Record<number, Agent> = {};
         for (const agent of agentResults) newAgents[agent.id] = agent;
 
-        // Fetch hex data per agent + boards in parallel
+        // Fetch all hex data + boards in parallel
         const allHexes: Record<string, HexData> = {};
 
         await Promise.all([
-          // Agent hex territories
-          Promise.all(agentIds.map(async (aId: bigint) => {
-            const id = Number(aId);
-            try {
-              const keys: string[] = await gameEngine.getAgentHexKeys(id);
-              const hexList: HexData[] = [];
-              for (const k of keys) {
-                const [ownerId, locationId, q, r, mineCount, arsenalCount, lastHarvest, reserve, happiness, happinessUpdatedAt] =
-                  await gameEngine.getHex(k);
-                const hd: HexData = {
-                  hexKey: k, ownerId: Number(ownerId), locationId: Number(locationId),
-                  q: Number(q), r: Number(r),
-                  mineCount: Number(mineCount), arsenalCount: Number(arsenalCount),
-                  lastHarvest: Number(lastHarvest),
-                  reserve: Number(reserve),
-                  happiness: Number(happiness),
-                  usedSlots: Number(mineCount) + Number(arsenalCount), totalSlots: 6,
-                  defense: Number(arsenalCount) * 5,
-                };
-                hexList.push(hd);
-                allHexes[k] = hd;
+          // All hexes (global list — includes unowned/rebelled)
+          (async () => {
+            const keys: string[] = await gameEngine.getAllHexKeys();
+            const agentHexMap: Record<number, HexData[]> = {};
+            await Promise.all(keys.map(async (k: string) => {
+              const [ownerId, locationId, q, r, mineCount, arsenalCount, lastHarvest, reserve, happiness, happinessUpdatedAt] =
+                await gameEngine.getHex(k);
+              const hd: HexData = {
+                hexKey: k, ownerId: Number(ownerId), locationId: Number(locationId),
+                q: Number(q), r: Number(r),
+                mineCount: Number(mineCount), arsenalCount: Number(arsenalCount),
+                lastHarvest: Number(lastHarvest),
+                reserve: Number(reserve),
+                happiness: Number(happiness),
+                usedSlots: Number(mineCount) + Number(arsenalCount), totalSlots: 6,
+                defense: Number(arsenalCount) * 5,
+              };
+              allHexes[k] = hd;
+              if (hd.ownerId > 0) {
+                if (!agentHexMap[hd.ownerId]) agentHexMap[hd.ownerId] = [];
+                agentHexMap[hd.ownerId].push(hd);
               }
-              setAgentHexes(id, hexList);
-            } catch { /* agent may have 0 hexes */ }
-          })),
+            }));
+            for (const [id, hexList] of Object.entries(agentHexMap)) {
+              setAgentHexes(Number(id), hexList);
+            }
+          })(),
           // Memories
           Promise.all(agentIds.map(async (aId: bigint) => {
             const id = Number(aId);
@@ -180,9 +181,7 @@ export function useGameEngine() {
           })),
         ]);
 
-        setHexes(allHexes);
-        setLocations(newLocs);
-        setAgents(newAgents);
+        setWorldData(newAgents, newLocs, allHexes);
       } catch (err) {
         console.error("RPC Error:", err);
       } finally {
@@ -193,5 +192,5 @@ export function useGameEngine() {
     pullData();
     const interval = setInterval(pullData, 5000);
     return () => clearInterval(interval);
-  }, [setAgents, setLocations, setHexes, setAgentHexes, setMemories, setLocationBoard, setInbox]);
+  }, [setWorldData, setAgentHexes, setMemories, setLocationBoard, setInbox]);
 }

frontend/src/phaser/CartoonTextures.ts

@@ -23,7 +23,7 @@ const BUILDING_STYLES: Record<string, { wall: number; roof: number; accent: numb
   medieval_house:       { wall: 0xd4b896, roof: 0xc06090, accent: 0x7b5ea7 },
 };
 
-const AGENT_COLORS: { body: number; face: number }[] = [
+export const AGENT_COLORS: { body: number; face: number }[] = [
   { body: 0x4a7eb5, face: 0xfff0d8 },  // blue
   { body: 0x4a9e5c, face: 0xfff0d8 },  // green
   { body: 0x7b5ea7, face: 0xfff0d8 },  // purple
@@ -127,13 +127,14 @@ function generateTerrainTexture(scene: Phaser.Scene, key: string, biome: string,
   gfx.destroy();
 }
 
-function generateBuildingTexture(scene: Phaser.Scene, key: string, buildingId: string) {
+export function generateBuildingTexture(scene: Phaser.Scene, key: string, buildingId: string, roofColor?: number) {
   if (scene.textures.exists(key)) return;
 
   const gfx = scene.add.graphics();
   const cx = TILE_W / 2;
   const cy = TILE_H / 2;
   const style = BUILDING_STYLES[buildingId] || BUILDING_STYLES.medieval_house;
+  const roof = roofColor ?? style.roof;
 
   // Shadow under building
   gfx.fillStyle(0x000000, 0.15);
@@ -169,7 +170,7 @@ function generateBuildingTexture(scene: Phaser.Scene, key: string, buildingId: s
   gfx.lineBetween(cx + 8.5, by + 8, cx + 8.5, by + 15);
 
   // Roof
-  gfx.fillStyle(style.roof, 1);
+  gfx.fillStyle(roof, 1);
   gfx.fillTriangle(cx - bw / 2 - 6, by + 2, cx + bw / 2 + 6, by + 2, cx, by - 22);
 
   // Roof highlight

frontend/src/phaser/objects/LocationCluster.ts

@@ -1,8 +1,9 @@
 import * as Phaser from 'phaser';
 import type { ResolvedLocation } from '../../game/world/types';
-import { buildingKeyForLocation } from '../../game/BuildingTags';
+import { buildingKeyForLocation, buildingIdForLocation } from '../../game/BuildingTags';
 import { TILE_W, TILE_H } from '../../game/world/HexGrid';
 import { StoreBridge } from '../StoreBridge';
+import { generateBuildingTexture, AGENT_COLORS } from '../CartoonTextures';
 
 const CLICK_THRESHOLD = 8;
 const SELECT_COLOR = 0xd4a030; // warm gold
@@ -70,8 +71,18 @@ export class LocationCluster extends Phaser.GameObjects.Container {
     this.selectionRing.setVisible(false);
     this.add(this.selectionRing);
 
-    // Building tile
-    const texKey = buildingKeyForLocation(loc.name);
+    // Building tile — roof color matches owner's meeple color
+    let texKey: string;
+    if (loc.ownerId > 0) {
+      const buildingId = buildingIdForLocation(loc.name);
+      const roofColor = AGENT_COLORS[(loc.ownerId - 1) % AGENT_COLORS.length].body;
+      texKey = `building_${buildingId}_owner${loc.ownerId}`;
+      generateBuildingTexture(scene, texKey, buildingId, roofColor);
+    } else {
+      const buildingId = buildingIdForLocation(loc.name);
+      texKey = `building_${buildingId}_unowned`;
+      generateBuildingTexture(scene, texKey, buildingId, 0xe0d0c0);
+    }
     this.tile = scene.add.image(this.cx, this.cy, texKey);
     this.tile.setInteractive(
       new Phaser.Geom.Circle(60, 70, 50),