// Player Sweeper — CLIENT-ONLY minesweeper behavior. // WALL PASS: realm guard at top. Server copy does NOTHING. // Owns: bomb detection, reveals, flag gamble, broken tiles, // selection highlight, tile painting (your view), all juice/feedback. // Emits to server: captureTile, markBroken, unlockTile, repairTile, // requestColor, spawnNumber. // NEVER reads tileState.capturedBy for game decisions. var C = require('lib/sweep-const.js'); // ========== REALM GUARD ========== // This script is attached to player, which runs on both client and server. // ALL gameplay logic is gated behind isClient. Server copy is inert. var isClient = false; var didInit = false; var needsRepaint = false; var selectionId = null; var facingTileKey = null; var seedCheckTimer = 0; function initClient(objectApi) { if (didInit) return; var s = objectApi.getState(); var mgr = objectApi.getObjectState('grid-manager'); var currentSeed = mgr ? (mgr.sessionSeed || 0) : 0; // If grid-manager hasn't spawned yet (seed = 0), defer init to next update tick if (currentSeed === 0) return; didInit = true; var storedSeed = (s && s.sessionSeed) || 0; var isNew = (storedSeed !== currentSeed); var existingColor = (!isNew && s && s.playerColor) ? s.playerColor : null; if (!existingColor) { var slot = C.hashCode(objectApi.id) % C.PLAYER_COLORS.length; existingColor = C.PLAYER_COLORS[slot]; } var colorSlot = C.hashCode(objectApi.id) % C.PLAYER_COLORS.length; var spawnPos = C.getSpawnWorldPos(colorSlot); objectApi.patchState({ sessionSeed: currentSeed, reveals: isNew ? {} : ((s && s.reveals) || {}), flags: isNew ? {} : ((s && s.flags) || {}), disturbed: isNew ? {} : ((s && s.disturbed) || {}), broken: isNew ? {} : ((s && s.broken) || {}), score: isNew ? 0 : ((s && s.score) || 0), captures: isNew ? 0 : (Object.keys((s && s.reveals) || {}).length + Object.keys((s && s.flags) || {}).length), bombsHit: isNew ? 0 : ((s && s.bombsHit) || 0), brokenRepairs: (s && s.brokenRepairs) || 0, lastTileKey: null, currentTile: null, facingTile: null, playerColor: existingColor, colorSlot: colorSlot, spawnPad: colorSlot, spawnPos: spawnPos, totalTiles: (function() { var n = 0; for (var r = 0; r < C.GRID_SIZE; r++) for (var c = 0; c < C.GRID_SIZE; c++) if (!C.isExcluded(r, c)) n++; return n; })(), totalCaptured: 0, spawnTimer: 2.0, }); // Teleport to spawn pad — client does this directly since color is deterministic objectApi.setProperty('feetPosition', { x: spawnPos.x, y: 0.2, z: spawnPos.z }); // Re-emit requestColor now that grid-manager should be ready objectApi.emit('requestColor', { playerId: objectApi.id }); // Defer repaint — tiles may not be synced to client yet on reconnect if (!isNew) { var repaintColor = existingColor; objectApi.runInSeconds(2.0, function() { repaintTiles(objectApi, repaintColor, false); }); } else { // Fresh session: force every tile back to its original sand color so // stale client-side trails from the previous session don't linger. objectApi.runInSeconds(1.0, function() { forceResetTileVisuals(objectApi); }); } } function forceResetTileVisuals(objectApi) { for (var r = 0; r < C.GRID_SIZE; r++) { for (var c = 0; c < C.GRID_SIZE; c++) { if (C.isExcluded(r, c)) continue; var tid = C.tileId(r, c); var tst = objectApi.getObjectState(tid); if (tst && tst.capturedBy) continue; // respect server-owned captures var origColor = (tst && tst.originalColor) || C.tileColor(r, c); objectApi.setObjectProperty(tid, 'material', { color: origColor, roughness: 0.95 }); } } } function repaintTiles(objectApi, playerColor, isNew) { if (isNew) return; var s = objectApi.getState(); var reveals = s.reveals || {}; var flags = s.flags || {}; var disturbed = s.disturbed || {}; var broken = s.broken || {}; var color = playerColor || s.playerColor || 'oklch(0.85 0.15 60)'; // Repaint revealed tiles + numbers (recompute counts fresh with generation awareness) var rk = Object.keys(reveals); var mgr2 = objectApi.getObjectState('grid-manager'); var repaintSeed = mgr2 ? (mgr2.sessionSeed || 0) : 0; var gl = genLookup(objectApi); var updatedReveals = null; var droppedKeys = null; var selfId = objectApi.id; for (var i = 0; i < rk.length; i++) { var parts = rk[i].split('-'); var row = parseInt(parts[0], 10); var col = parseInt(parts[1], 10); var tid = C.tileId(row, col); // SERVER TRUTH CHECK: if tile is no longer owned by self, drop stale reveal var tst = objectApi.getObjectState(tid); if (!tst || !tst.capturedBy || tst.capturedBy !== selfId) { if (!droppedKeys) droppedKeys = {}; droppedKeys[rk[i]] = true; // Restore tile to its original sand color so old colors don't bleed var origColor = (tst && tst.originalColor) || ((row + col) % 2 === 0 ? C.SAND_COLOR : C.SAND_DARK); objectApi.setObjectProperty(tid, 'material', { color: origColor, roughness: 0.85, metalness: 0.08 }); // Hide any stale number entity var staleNumId = 'num-' + selfId + '-' + row + '-' + col; try { objectApi.setObjectProperty(staleNumId, 'feetPosition', { x: 0, y: -10, z: 0 }); } catch(e) {} continue; } objectApi.setObjectProperty(tid, 'material', { color: color, roughness: 0.7, metalness: 0.15 }); // Recompute count with current tile generations var freshCount = C.countAdjacentGen(selfId, row, col, repaintSeed, gl); if (freshCount !== reveals[rk[i]]) { if (!updatedReveals) { updatedReveals = {}; for (var j = 0; j < rk.length; j++) updatedReveals[rk[j]] = reveals[rk[j]]; } updatedReveals[rk[i]] = freshCount; } if (freshCount > 0) spawnTileNumber(objectApi, row, col, freshCount); } if (droppedKeys) { if (!updatedReveals) { updatedReveals = {}; for (var k2 = 0; k2 < rk.length; k2++) updatedReveals[rk[k2]] = reveals[rk[k2]]; } var dkeys = Object.keys(droppedKeys); for (var dj = 0; dj < dkeys.length; dj++) delete updatedReveals[dkeys[dj]]; } if (updatedReveals) objectApi.patchState({ reveals: updatedReveals }); // Validate disturbed entries — purge any that aren't real bombs with current seed var cleanDisturbed = {}; var distDirty = false; var dk = Object.keys(disturbed); for (var di = 0; di < dk.length; di++) { var dp = dk[di].split('-'); var dr = parseInt(dp[0], 10); var dc = parseInt(dp[1], 10); var dgen = tileGen(objectApi, dr, dc); if (C.isBomb(objectApi.id, dr, dc, repaintSeed, dgen)) { cleanDisturbed[dk[di]] = true; } else { distDirty = true; } } if (distDirty) { disturbed = cleanDisturbed; objectApi.patchState({ disturbed: cleanDisturbed }); } // Validate broken entries — purge any that aren't real bombs var cleanBroken = {}; var brokDirty = false; var bk = Object.keys(broken); for (var bi = 0; bi < bk.length; bi++) { var bp = bk[bi].split('-'); var br = parseInt(bp[0], 10); var bc = parseInt(bp[1], 10); var bgen = tileGen(objectApi, br, bc); if (C.isBomb(objectApi.id, br, bc, repaintSeed, bgen)) { cleanBroken[bk[bi]] = true; } else { brokDirty = true; } } if (brokDirty) { broken = cleanBroken; objectApi.patchState({ broken: cleanBroken, bombsHit: Object.keys(cleanBroken).length }); } // Validate flags — purge any that aren't real bombs var cleanFlags = {}; var flagDirty = false; var fk = Object.keys(flags); for (var fi = 0; fi < fk.length; fi++) { var fp = fk[fi].split('-'); var fr = parseInt(fp[0], 10); var fc = parseInt(fp[1], 10); var fgen = tileGen(objectApi, fr, fc); if (C.isBomb(objectApi.id, fr, fc, repaintSeed, fgen)) { cleanFlags[fk[fi]] = true; } else { flagDirty = true; } } if (flagDirty) { flags = cleanFlags; objectApi.patchState({ flags: cleanFlags }); } // Repaint flagged tiles fk = Object.keys(flags); for (var fi2 = 0; fi2 < fk.length; fi2++) { var fp2 = fk[fi2].split('-'); var fr2 = parseInt(fp2[0], 10); var fc2 = parseInt(fp2[1], 10); var ftid = C.tileId(fr2, fc2); objectApi.setObjectProperty(ftid, 'material', { color: color, roughness: 0.7, metalness: 0.15 }); // Re-spawn flag marker var fpos = C.tileWorldPos(fr2, fc2); var flagOid = 'flag-' + objectApi.id + '-' + fr2 + '-' + fc2; try { objectApi.destroy(flagOid); } catch(e) {} objectApi.spawn(flagOid, { tags: ['flag-marker'], realm: 'client', properties: { model: 'cdn/model-lowpoly-flag-small-red.glb', feetPosition: { x: fpos.x, y: 0.3, z: fpos.z }, scale: 0.5, physics: 'none', }, }); } // Repaint bomb-disturbed tiles (private overlays) dk = Object.keys(disturbed); for (var di2 = 0; di2 < dk.length; di2++) { var dp2 = dk[di2].split('-'); var dr2 = parseInt(dp2[0], 10); var dc2 = parseInt(dp2[1], 10); spawnOverlay(objectApi, dr2, dc2, C.BOMB_COLOR, 'bomb'); } // Repaint broken tiles (private overlays) bk = Object.keys(broken); for (var bi2 = 0; bi2 < bk.length; bi2++) { var bp2 = bk[bi2].split('-'); var br2 = parseInt(bp2[0], 10); var bc2 = parseInt(bp2[1], 10); spawnOverlay(objectApi, br2, bc2, C.BROKEN_COLOR, 'broken'); } } export function onSpawn(objectApi) { // Always emit color request — safe from either side objectApi.emit('requestColor', { playerId: objectApi.id }); // getCamera() returns null on server, non-null on client (after first frame) isClient = (objectApi.getCamera() !== null); if (!isClient) return; initClient(objectApi); } export function update(dt, objectApi) { // Lazy client detection: getCamera() may be null on first onSpawn tick if (!isClient) { if (objectApi.getCamera() !== null) { isClient = true; initClient(objectApi); } else { return; } } // Wait until grid-manager seed is available before any sweep logic if (!didInit) { initClient(objectApi); if (!didInit) return; } // FORCE WIPE — server sets forceWipe:true to zero out displayed counts. // Player dicts can't truly be cleared (engine deep-merges), so we baseline them. // UI subtracts baselines so counts show as 0 until fresh captures happen. var fw = objectApi.getState(); if (fw && fw.forceWipe) { objectApi.patchState({ revealsBaseCount: Object.keys(fw.reveals || {}).length, flagsBaseCount: Object.keys(fw.flags || {}).length, disturbedBaseCount: Object.keys(fw.disturbed || {}).length, brokenBaseCount: Object.keys(fw.broken || {}).length, captures: 0, bombsHit: 0, totalCaptured: 0, forceWipe: false, }); return; } // Periodic seed check — catches grid-manager hot-reloads that change the seed seedCheckTimer -= dt; if (seedCheckTimer <= 0) { seedCheckTimer = 3.0; var mgrCheck = objectApi.getObjectState('grid-manager'); var liveSeed = mgrCheck ? (mgrCheck.sessionSeed || 0) : 0; var mySeed = (objectApi.getState() || {}).sessionSeed || 0; if (liveSeed !== 0 && liveSeed !== mySeed) { didInit = false; initClient(objectApi); if (!didInit) return; } } // Tab sleep detection — large dt means browser paused, client-realm entities may be gone if (dt > 2.0) { var rs = objectApi.getState(); repaintTiles(objectApi, rs.playerColor, false); } var pos = objectApi.getProperty('feetPosition'); var tile = C.worldToTile(pos.x, pos.z); var s = objectApi.getState(); // Block sweeping during bomb launch if (s.launched) return; // Spawn protection countdown var spawnTimer = s.spawnTimer || 0; if (spawnTimer > 0) { spawnTimer -= dt; if (spawnTimer < 0) spawnTimer = 0; objectApi.patchState({ spawnTimer: spawnTimer }); } var newKey = C.isValidTile(tile.row, tile.col) ? C.tileKey(tile.row, tile.col) : null; // Facing tile — one tile ahead based on camera yaw var cam = objectApi.getCamera(); var facingRow = null; var facingCol = null; if (cam && newKey !== null) { var yawRad = cam.yaw * Math.PI / 180; var aheadX = pos.x + (-Math.sin(yawRad)) * C.TILE_SPACING; var aheadZ = pos.z + (-Math.cos(yawRad)) * C.TILE_SPACING; var aheadTile = C.worldToTile(aheadX, aheadZ); if (C.isValidTile(aheadTile.row, aheadTile.col)) { facingRow = aheadTile.row; facingCol = aheadTile.col; } } // Selection highlight — only the one facing tile var newFacingKey = (facingRow !== null) ? C.tileKey(facingRow, facingCol) : null; if (newFacingKey !== facingTileKey) { clearSelection(objectApi); if (newFacingKey !== null) { var revs = s.reveals || {}; var dist = s.disturbed || {}; var brok = s.broken || {}; if (!revs[newFacingKey] && !dist[newFacingKey] && !brok[newFacingKey]) { showSelection(objectApi, facingRow, facingCol, s.playerColor); } } facingTileKey = newFacingKey; } var facingInfo = (facingRow !== null) ? { row: facingRow, col: facingCol } : null; // Same tile as last tick — just update facing if (newKey === s.lastTileKey) { objectApi.patchState({ facingTile: facingInfo }); return; } // Off-grid if (newKey === null) { clearSelection(objectApi); objectApi.patchState({ currentTile: null, lastTileKey: null, facingTile: null }); return; } // New tile — build info for HUD var reveals = s.reveals || {}; var disturbed = s.disturbed || {}; var flags = s.flags || {}; var broken = s.broken || {}; var tileInfo = buildTileInfo(objectApi, tile.row, tile.col, reveals, disturbed, flags, broken, newKey); var mgr = objectApi.getObjectState('grid-manager'); objectApi.patchState({ currentTile: tileInfo, lastTileKey: newKey, totalCaptured: mgr ? (mgr.totalCaptured || 0) : 0, facingTile: facingInfo, }); // Auto-reveal on step if ((s.spawnTimer || 0) <= 0 && reveals[newKey] === undefined && !disturbed[newKey] && !flags[newKey] && !broken[newKey]) { doReveal(objectApi, tile.row, tile.col); } // Refresh neighbor counts — catches stolen tiles that changed generation nearby rippleNeighborCounts(objectApi, tile.row, tile.col); } export function onInput(input, objectApi) { if (!isClient) return; var s = objectApi.getState(); if (s.launched) return; var facing = s.facingTile; if (!facing) return; var row = facing.row; var col = facing.col; if (input.actions.flag) { doFlag(objectApi, row, col); } if (input.actions.reveal) { var key = C.tileKey(row, col); var reveals = s.reveals || {}; var disturbed = s.disturbed || {}; var broken = s.broken || {}; var flagsInput = s.flags || {}; if (reveals[key] === undefined && !disturbed[key] && !broken[key] && !flagsInput[key]) doReveal(objectApi, row, col); } if (input.actions.repairBroken) { var rkey = C.tileKey(row, col); var rbroken = s.broken || {}; if (rbroken[rkey] && (s.brokenRepairs || 0) > 0) { objectApi.emit('repairTile', { playerId: objectApi.id, row: row, col: col }); } } } // ========== HELPERS ========== function tileGen(objectApi, r, c) { var ts = objectApi.getObjectState(C.tileId(r, c)); return (ts && ts.generation) || 0; } function genLookup(objectApi) { return function(r, c) { return tileGen(objectApi, r, c); }; } // After a reveal, recompute counts on neighboring revealed tiles (bomb layout may have shifted) function rippleNeighborCounts(objectApi, centerRow, centerCol) { var s = objectApi.getState(); var reveals = s.reveals || {}; var mgr = objectApi.getObjectState('grid-manager'); var seed = mgr ? (mgr.sessionSeed || 0) : 0; var pid = objectApi.id; var gl = genLookup(objectApi); var newReveals = null; for (var dr = -1; dr <= 1; dr++) { for (var dc = -1; dc <= 1; dc++) { if (dr === 0 && dc === 0) continue; var nr = centerRow + dr; var nc = centerCol + dc; var nkey = C.tileKey(nr, nc); if (reveals[nkey] === undefined) continue; var newCount = C.countAdjacentGen(pid, nr, nc, seed, gl); if (newCount !== reveals[nkey]) { if (!newReveals) { newReveals = {}; var rk = Object.keys(reveals); for (var i = 0; i < rk.length; i++) newReveals[rk[i]] = reveals[rk[i]]; } newReveals[nkey] = newCount; // Update existing number entity in place — don't spawn a duplicate updateNumber(objectApi, nr, nc, newCount); } } } if (newReveals) objectApi.patchState({ reveals: newReveals }); } // Update a number entity's text in place (no spawn, no duplicate) function updateNumber(objectApi, row, col, count) { var numId = 'num-' + objectApi.id + '-' + row + '-' + col; if (count > 0) { var numColor = C.NUMBER_COLORS[count] || 'oklch(0.3 0 0)'; objectApi.setObjectProperty(numId, 'text', { content: '' + count, size: 1.8, color: numColor, billboard: 'full', align: 'center', verticalAlign: 'middle', font: 'Geist Pixel Square' }); } else { // Hide: move underground and blank the text objectApi.setObjectProperty(numId, 'feetPosition', { x: 0, y: -10, z: 0 }); objectApi.setObjectProperty(numId, 'text', { content: '' }); } } // ========== REVEAL ========== function doReveal(objectApi, row, col) { var s = objectApi.getState(); var mgr = objectApi.getObjectState('grid-manager'); var sessionSeed = mgr ? (mgr.sessionSeed || 0) : 0; // Never reveal with seed 0 — seed not ready yet if (!sessionSeed) return; var key = C.tileKey(row, col); var tid = C.tileId(row, col); // Guard on YOUR dicts only — never check tileState.capturedBy var reveals = s.reveals || {}; var disturbed = s.disturbed || {}; var flags = s.flags || {}; var broken = s.broken || {}; // Flagged tiles are already claimed safely — never trigger bomb logic. if (flags[key]) return; if (broken[key]) return; var color = s.playerColor || 'oklch(0.85 0.15 60)'; var pos = C.tileWorldPos(row, col); var gen = tileGen(objectApi, row, col); var staleReveal = (reveals[key] !== undefined); var staleDisturbed = disturbed[key]; // If a prior-era entry exists but this tile isn't actually a bomb now, // treat it as stale and allow re-reveal (dict entry stays dormant). var actuallyBomb = C.isBomb(objectApi.id, row, col, sessionSeed, gen); if (staleReveal && !actuallyBomb) { // Re-paint stale revealed tile (tiles may have been wiped to sand). objectApi.setObjectProperty(tid, 'material', { color: color, roughness: 0.7, metalness: 0.15 }); var freshCount = C.countAdjacentGen(objectApi.id, row, col, sessionSeed, genLookup(objectApi)); if (freshCount > 0) spawnTileNumber(objectApi, row, col, freshCount); return; } if (staleDisturbed && !actuallyBomb) { // Old bomb entry but not a bomb now — clear overlay, paint as normal reveal. // Fall through to normal reveal path; don't early-return. } else if (staleReveal || staleDisturbed) { return; } if (C.isBomb(objectApi.id, row, col, sessionSeed, gen)) { // Bomb — claim tile for everyone, overlay is private var newDist = {}; var dk = Object.keys(disturbed); for (var di = 0; di < dk.length; di++) newDist[dk[di]] = true; newDist[key] = true; objectApi.patchState({ disturbed: newDist, bombsHit: (s.bombsHit || 0) + 1 }); objectApi.setObjectProperty(tid, 'material', { color: color, roughness: 0.7, metalness: 0.15 }); objectApi.emit('captureTile', { playerId: objectApi.id, row: row, col: col, type: 'bomb' }); spawnOverlay(objectApi, row, col, C.BOMB_COLOR, 'bomb'); objectApi.screenShake(0.3, 0.35); objectApi.screenFlash('oklch(0.25 0.15 30)', 0.25); objectApi.cameraPunch({ x: 0, y: -1, z: 0 }, 0.5); objectApi.particleBurst({ x: pos.x, y: 0.8, z: pos.z }, 'explosion', { scale: 1.5, color: 'oklch(0.7 0.2 50)' }); objectApi.particleBurst({ x: pos.x, y: 0.3, z: pos.z }, 'dust', { scale: 1.0, color: 'oklch(0.6 0.06 70)' }); objectApi.playSound('cdn/sfx-explosion-deep-rumble.mp3', { position: { x: pos.x, y: 0, z: pos.z }, volume: 0.7 }); objectApi.vignette(0.5, 'oklch(0.25 0.15 30)'); objectApi.damageNumber({ x: pos.x, y: 1.5, z: pos.z }, 0, { text: 'BOOM!', color: 'oklch(0.65 0.25 30)', crit: true }); objectApi.runInSeconds(2.0, function() { objectApi.vignette(0); }); // Launch player back to spawn pad var colorSlot = s.colorSlot; if (colorSlot === undefined || colorSlot === null) { colorSlot = C.hashCode(objectApi.id) % C.PLAYER_COLORS.length; } var spawnTarget = C.getSpawnWorldPos(colorSlot); var playerPos = objectApi.getProperty('feetPosition'); var dx = spawnTarget.x - playerPos.x; var dz = spawnTarget.z - playerPos.z; var dist = Math.sqrt(dx * dx + dz * dz); var arcHeight = Math.max(12, dist * 0.35); var flightTime = Math.max(1.0, Math.min(2.5, dist * 0.02)); objectApi.runInSeconds(0.4, function() { objectApi.patchState({ launched: true, launchOrigin: { x: playerPos.x, z: playerPos.z }, launchTarget: { x: spawnTarget.x, z: spawnTarget.z }, launchArc: arcHeight, launchDuration: flightTime, launchElapsed: 0, velocity: { x: 0, y: 0, z: 0 }, }); objectApi.announce('SENT HOME', { style: 'danger', color: 'oklch(0.65 0.25 30)', duration: 1.5 }); objectApi.playSound('cdn/sfx-whoosh-flying-fast.mp3', { volume: 0.6 }); }); return; } // Safe tile — use generation-aware count var gl = genLookup(objectApi); var count = C.countAdjacentGen(objectApi.id, row, col, sessionSeed, gl); var tileState = objectApi.getObjectState(tid); if (tileState && tileState.brokenBy && tileState.brokenBy !== objectApi.id) { objectApi.emit('unlockTile', { walkerId: objectApi.id, brokerId: tileState.brokenBy, row: row, col: col }); } var newReveals = {}; var rk = Object.keys(reveals); for (var ri = 0; ri < rk.length; ri++) newReveals[rk[ri]] = reveals[rk[ri]]; newReveals[key] = count; objectApi.patchState({ reveals: newReveals, captures: (s.captures || 0) + 1 }); objectApi.setObjectProperty(tid, 'material', { color: color, roughness: 0.7, metalness: 0.15 }); if (count > 0) spawnTileNumber(objectApi, row, col, count); objectApi.emit('captureTile', { playerId: objectApi.id, row: row, col: col, type: 'reveal' }); objectApi.playSound('cdn/sfx-click-soft-button.mp3', { position: { x: pos.x, y: 0, z: pos.z }, volume: 0.25, pitch: 0.85 + count * 0.1 }); // Ripple — neighboring revealed tiles may need count updates rippleNeighborCounts(objectApi, row, col); } // ========== FLAG GAMBLE ========== function doFlag(objectApi, row, col) { var s = objectApi.getState(); var mgr = objectApi.getObjectState('grid-manager'); var sessionSeed = mgr ? (mgr.sessionSeed || 0) : 0; if (!sessionSeed) return; var key = C.tileKey(row, col); // Guard on YOUR dicts only var reveals = s.reveals || {}; var disturbed = s.disturbed || {}; var broken = s.broken || {}; var flags = s.flags || {}; if (reveals[key] !== undefined || disturbed[key] || broken[key] || flags[key]) return; var tid = C.tileId(row, col); var pos = C.tileWorldPos(row, col); var color = s.playerColor || 'oklch(0.85 0.15 60)'; var gen = tileGen(objectApi, row, col); if (C.isBomb(objectApi.id, row, col, sessionSeed, gen)) { // Correct flag — capture! var newFlags = {}; var fk = Object.keys(flags); for (var i = 0; i < fk.length; i++) newFlags[fk[i]] = flags[fk[i]]; newFlags[key] = true; objectApi.patchState({ flags: newFlags, captures: (s.captures || 0) + 1 }); objectApi.emit('captureTile', { playerId: objectApi.id, row: row, col: col, type: 'flag' }); objectApi.setObjectProperty(tid, 'material', { color: color, roughness: 0.7, metalness: 0.15 }); // Flag marker — client realm, per-player ID so no collision var flagOid = 'flag-' + objectApi.id + '-' + row + '-' + col; objectApi.spawn(flagOid, { tags: ['flag-marker'], realm: 'client', properties: { feetPosition: { x: pos.x, y: C.TILE_HEIGHT, z: pos.z }, model: '/cdn/model-low-poly-flag-marker-triangular.glb', material: { color: color }, physics: 'none', scale: 0.6, }, }); objectApi.playSound('cdn/sfx-flag-plant-ground.mp3', { position: { x: pos.x, y: 0, z: pos.z }, volume: 0.4 }); objectApi.damageNumber({ x: pos.x, y: 1.5, z: pos.z }, 1, { text: 'FLAGGED!', color: color, crit: true }); objectApi.particleBurst({ x: pos.x, y: 0.5, z: pos.z }, 'magic', { scale: 0.6, color: color }); } else { // Wrong flag — broken, paint tile for everyone, overlay is private var newBroken = {}; var bk = Object.keys(broken); for (var bi = 0; bi < bk.length; bi++) newBroken[bk[bi]] = true; newBroken[key] = true; objectApi.patchState({ broken: newBroken }); objectApi.setObjectProperty(tid, 'material', { color: color, roughness: 0.7, metalness: 0.15 }); objectApi.emit('captureTile', { playerId: objectApi.id, row: row, col: col, type: 'bomb' }); spawnOverlay(objectApi, row, col, C.BROKEN_COLOR, 'broken'); objectApi.emit('markBroken', { playerId: objectApi.id, row: row, col: col }); objectApi.playSound('cdn/sfx-stone-crack-break.mp3', { position: { x: pos.x, y: 0, z: pos.z }, volume: 0.5 }); objectApi.damageNumber({ x: pos.x, y: 1.2, z: pos.z }, 0, { text: 'BROKEN', color: C.BROKEN_COLOR }); objectApi.particleBurst({ x: pos.x, y: 0.3, z: pos.z }, 'dust', { scale: 0.8, color: 'oklch(0.5 0 0)' }); objectApi.screenShake(0.1, 0.15); } } // ========== TILE NUMBERS (client-side, per-player) ========== function spawnTileNumber(objectApi, row, col, count) { var numId = 'num-' + objectApi.id + '-' + row + '-' + col; var pos = C.tileWorldPos(row, col); var numColor = C.NUMBER_COLORS[count] || 'oklch(0.3 0 0)'; // If entity already exists, just update it in place. Destroy+respawn can race: // the destroy queues and fires AFTER the spawn, wiping the brand-new entity. // Overlay slab is set to depthWrite:false so it won't occlude numbers sitting // just above the tile surface. var existing = objectApi.getObject(numId); if (existing) { objectApi.setObjectProperty(numId, 'feetPosition', { x: pos.x, y: 0.5, z: pos.z }); objectApi.setObjectProperty(numId, 'text', { content: '' + count, size: 1.8, color: numColor, billboard: 'full', align: 'center', verticalAlign: 'middle', font: 'Geist Pixel Square' }); return; } objectApi.spawn(numId, { tags: ['tile-number'], realm: 'client', properties: { feetPosition: { x: pos.x, y: 0.5, z: pos.z }, text: { content: '' + count, size: 1.8, color: numColor, billboard: 'full', align: 'center', verticalAlign: 'middle', font: 'Geist Pixel Square' }, physics: 'none', }, }); } // ========== PRIVATE OVERLAYS ========== // Spawn a client-realm overlay on a tile for bomb/broken/private states. // These are only visible to the local player. function overlayId(objectApi, row, col, kind) { return 'overlay-' + kind + '-' + objectApi.id + '-' + row + '-' + col; } function spawnOverlay(objectApi, row, col, color, kind) { var oid = overlayId(objectApi, row, col, kind); var pos = C.tileWorldPos(row, col); var mat = { color: color, roughness: 0.5, opacity: 0.85, transparent: true, depthWrite: false }; var existing = objectApi.getObject(oid); if (existing) { // Update in place — ensures material picks up depthWrite:false for pre-existing overlays. objectApi.setObjectProperty(oid, 'material', mat); objectApi.setObjectProperty(oid, 'feetPosition', { x: pos.x, y: C.TILE_HEIGHT + 0.01, z: pos.z }); return; } objectApi.spawn(oid, { tags: ['tile-overlay', kind + '-overlay'], realm: 'client', properties: { feetPosition: { x: pos.x, y: C.TILE_HEIGHT + 0.01, z: pos.z }, primitive: { kind: 'box', width: C.TILE_SIZE, height: 0.02, depth: C.TILE_SIZE }, material: mat, physics: 'none', }, }); } // ========== SELECTION HIGHLIGHT ========== function ensureRing(objectApi) { var ringId = 'sel-ring-' + objectApi.id; if (selectionId === ringId) return ringId; // Check if a stale ring already exists from a previous lifecycle var existing = objectApi.getObject(ringId); if (existing) { selectionId = ringId; return ringId; } // Clean up tracked ID if different if (selectionId && selectionId !== ringId) { try { objectApi.destroy(selectionId); } catch(e) {} } objectApi.spawn(ringId, { tags: ['selection-ring'], realm: 'client', properties: { feetPosition: { x: 0, y: -100, z: 0 }, primitive: { kind: 'torus', radius: 1.4, tube: 0.08, radialSegments: 24, tubularSegments: 48 }, material: { color: 'oklch(0.85 0.15 60)', emissive: 'oklch(0.85 0.15 60)', emissiveIntensity: 0.6, roughness: 0.3, metalness: 0.4, opacity: 0.85, transparent: true }, physics: 'none', }, }); selectionId = ringId; return ringId; } function showSelection(objectApi, row, col, playerColor) { var color = playerColor || 'oklch(0.85 0.15 60)'; var pos = C.tileWorldPos(row, col); var ringId = ensureRing(objectApi); objectApi.setObjectProperty(ringId, 'feetPosition', { x: pos.x, y: 0.18, z: pos.z }); objectApi.setObjectProperty(ringId, 'material', { color: color, emissive: color, emissiveIntensity: 0.6, roughness: 0.3, metalness: 0.4, opacity: 0.85, transparent: true }); } function hideSelection(objectApi) { if (selectionId) { objectApi.setObjectProperty(selectionId, 'feetPosition', { x: 0, y: -100, z: 0 }); } } function clearSelection(objectApi) { hideSelection(objectApi); facingTileKey = null; } // ========== TILE INFO BUILDER ========== function buildTileInfo(objectApi, row, col, reveals, disturbed, flags, broken, key) { var info = { row: row, col: col, status: 'uncaptured', number: null, capturerName: null }; if (disturbed[key]) { info.status = 'bomb'; return info; } if (broken[key]) { info.status = 'broken'; return info; } if (reveals[key] !== undefined) { info.status = 'own'; info.number = reveals[key]; return info; } if (flags[key]) { info.status = 'flagged'; return info; } // Check server tile state ONLY for display — never for game logic var tid = C.tileId(row, col); var ts = objectApi.getObjectState(tid); if (ts && ts.capturedBy) { info.status = 'captured'; var profile = objectApi.getProfile(ts.capturedBy); info.capturerName = profile ? profile.displayName : 'Unknown'; return info; } return info; }