262 lines
40 KiB
JavaScript
262 lines
40 KiB
JavaScript
'use strict';
|
|
|
|
const http = require('http');
|
|
const fs = require('fs');
|
|
const fsp = fs.promises;
|
|
const path = require('path');
|
|
const crypto = require('crypto');
|
|
const { URL } = require('url');
|
|
const { createRealtimeHub } = require('./realtime-server');
|
|
const AppLogic = require('./app-logic');
|
|
const PuzzleCore = require('./puzzle-core');
|
|
const STORE_CATALOG = new Map(require('./store-catalog.json').map(item => [item.id, Object.freeze(item)]));
|
|
|
|
const ROOT = __dirname;
|
|
const DATA_DIR = path.resolve(process.env.BEND_FIELD_DATA_DIR || path.join(ROOT, 'cloud-data'));
|
|
const WORLD_FILE = path.join(DATA_DIR, 'shared-world.json');
|
|
const WORLD_BOARDS_DIR = path.join(DATA_DIR, 'shared-world.boards');
|
|
const HOST = process.env.HOST || '0.0.0.0';
|
|
const PORT = Number(process.env.PORT || 8080);
|
|
const MAX_BODY_BYTES = 64 * 1024 * 1024;
|
|
const MAX_BOARDS_PER_PUSH = 10000;
|
|
const MAX_PATHS_PER_BOARD = 512;
|
|
const MAX_CELLS_PER_PATH = 5000;
|
|
const CLOUD_PAGE_LIMIT = 512;
|
|
const CHANGE_HISTORY_LIMIT = 256;
|
|
const CLEAR_EVENT_LIMIT = 64;
|
|
const MAX_PLAYER_PURCHASES = 10000;
|
|
const GENERATION_FAILURE_BONUS = 2500;
|
|
const GENERATION_FAILURE_MIN_DELAY_MS = 8000;
|
|
const PLAYER_RE = /^[a-f0-9]{16,64}$/i;
|
|
const TOKEN_RE = /^[a-f0-9]{32,128}$/i;
|
|
const BOARD_RE = /^B(?:0|[1-9][0-9]*)$/;
|
|
const MIME = {
|
|
'.html': 'text/html; charset=utf-8', '.js': 'text/javascript; charset=utf-8', '.css': 'text/css; charset=utf-8',
|
|
'.svg': 'image/svg+xml', '.ico': 'image/x-icon', '.ttf': 'font/ttf', '.json': 'application/json; charset=utf-8',
|
|
'.txt': 'text/plain; charset=utf-8', '.md': 'text/markdown; charset=utf-8',
|
|
};
|
|
let worldQueue = Promise.resolve();
|
|
const playerQueues = new Map();
|
|
let realtimeHub = null;
|
|
|
|
function json(res, status, value) {
|
|
const body = JSON.stringify(value);
|
|
res.writeHead(status, {'content-type':'application/json; charset=utf-8','content-length':Buffer.byteLength(body),'cache-control':'no-store','x-content-type-options':'nosniff'});
|
|
res.end(body);
|
|
}
|
|
function serverTime(){return Date.now()}
|
|
function tokenHash(token){return crypto.createHash('sha256').update(token).digest('hex')}
|
|
function safeEqualHex(a,b){if(typeof a!=='string'||typeof b!=='string'||a.length!==b.length)return false;try{return crypto.timingSafeEqual(Buffer.from(a,'hex'),Buffer.from(b,'hex'))}catch{return false}}
|
|
function badRequest(message){throw Object.assign(new Error(message),{status:400})}
|
|
function finiteNumber(value,fallback=0){return Number.isFinite(Number(value))?Number(value):fallback}
|
|
function cleanPlayerName(value,fallback=''){
|
|
const name=String(value||'').replace(/[\u0000-\u001f\u007f]/g,'').replace(/\s+/g,' ').trim().slice(0,24);
|
|
return name||fallback;
|
|
}
|
|
function defaultPlayerName(playerId){return `旅人-${String(playerId).slice(0,4).toUpperCase()}`}
|
|
function cleanId(value,maxLength=64){const text=String(value||'').trim();if(!text||text.length>maxLength||!/^[A-Za-z0-9:_-]+$/.test(text))return'';return text}
|
|
function storeItem(itemId){return STORE_CATALOG.get(String(itemId||''))||null}
|
|
function normalizePlayerPurchases(raw){
|
|
const purchases=[],seenIds=new Set(),seenStoreItems=new Set();
|
|
for(const source of Array.isArray(raw)?raw:[]){const purchaseId=cleanId(source?.purchaseId,64),boardId=cleanId(source?.boardId,32),item=storeItem(source?.itemId),storeKey=`${boardId}:${item?.id||''}`;if(!purchaseId||!boardId||!item||seenIds.has(purchaseId)||seenStoreItems.has(storeKey))continue;const boughtAt=finiteNumber(source.boughtAt,0);seenIds.add(purchaseId);seenStoreItems.add(storeKey);purchases.push({purchaseId,boardId,itemId:item.id,buyer:cleanPlayerName(source.buyer),boughtAt:boughtAt>0?boughtAt:0,paidCost:Number.isSafeInteger(source.paidCost)&&source.paidCost>0?source.paidCost:item.cost})}
|
|
return purchases;
|
|
}
|
|
function normalizeGenerationBonuses(raw){return[...new Set((Array.isArray(raw)?raw:[]).map(value=>String(value||'')).filter(value=>BOARD_RE.test(value)))].slice(-10000)}
|
|
function playerSpentScore(record){return normalizePlayerPurchases(record?.purchases).reduce((sum,purchase)=>sum+Math.max(0,Number(purchase.paidCost)||0),0)}
|
|
function playerEarnedScore(record){return Number.isSafeInteger(record?.earnedScore)&&record.earnedScore>=0?record.earnedScore:0}
|
|
function publicPlayerState(record){const earnedScore=playerEarnedScore(record),spentScore=playerSpentScore(record);return{revision:Number.isSafeInteger(record?.economyRevision)?record.economyRevision:0,purchases:normalizePlayerPurchases(record?.purchases),earnedScore,spentScore,availableScore:Math.max(0,earnedScore-spentScore),updatedAt:finiteNumber(record?.updatedAt,0)}}
|
|
function withPlayerQueue(playerId,task){const previous=playerQueues.get(playerId)||Promise.resolve(),run=previous.then(task,task),tail=run.then(()=>undefined,()=>undefined);playerQueues.set(playerId,tail);return run.finally(()=>{if(playerQueues.get(playerId)===tail)playerQueues.delete(playerId)})}
|
|
function playerPath(playerId){if(!PLAYER_RE.test(playerId))badRequest('Invalid player id');return path.join(DATA_DIR,`${playerId.toLowerCase()}.json`)}
|
|
function worldBoardVersionPath(boardId,revision){if(!BOARD_RE.test(boardId)||!Number.isSafeInteger(revision)||revision<0)badRequest('Invalid board version');return path.join(WORLD_BOARDS_DIR,`${boardId}.${revision}.json`)}
|
|
async function atomicWriteJson(file,value){const tmp=`${file}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`;await fsp.writeFile(tmp,JSON.stringify(value),{encoding:'utf8',mode:0o600});await fsp.rename(tmp,file)}
|
|
async function readPlayer(playerId){
|
|
try{const value=JSON.parse(await fsp.readFile(playerPath(playerId),'utf8'));if(!value||typeof value!=='object')throw new Error('Invalid player record');value.name=cleanPlayerName(value.name,defaultPlayerName(playerId));value.purchases=normalizePlayerPurchases(value.purchases);value.generationBonuses=normalizeGenerationBonuses(value.generationBonuses);value.economyRevision=Number.isSafeInteger(value.economyRevision)?value.economyRevision:0;value.earnedScore=playerEarnedScore(value);return value}
|
|
catch(error){if(error.code==='ENOENT')throw Object.assign(new Error('Cloud profile not found'),{status:404});throw error}
|
|
}
|
|
function emptyWorld(){const now=serverTime();return{revision:0,rowRevision:now*1000,expansionGrants:{},global:{schema:31,appVersion:'47.77',generatorVersion:5,worldGeneration:'v47-field-reset-20260728-interaction-fix',nextId:1,solved:0,earnedScore:0,specialMechanicsSeen:[],updatedAt:now,cloudRevision:0},boardVersions:{},changes:[],clearEvents:[],createdAt:now,updatedAt:now}}
|
|
async function readWorld(){
|
|
try{const value=JSON.parse(await fsp.readFile(WORLD_FILE,'utf8'));if(!value||typeof value!=='object')throw new Error('Invalid shared world');value.revision=Number.isSafeInteger(value.revision)?value.revision:0;value.rowRevision=Number.isSafeInteger(value.rowRevision)?value.rowRevision:Math.max(0,serverTime()*1000);value.boardVersions=value.boardVersions&&typeof value.boardVersions==='object'?value.boardVersions:{};value.changes=Array.isArray(value.changes)?value.changes:[];value.clearEvents=Array.isArray(value.clearEvents)?value.clearEvents:[];value.expansionGrants=value.expansionGrants&&typeof value.expansionGrants==='object'?value.expansionGrants:{};value.global=value.global&&typeof value.global==='object'?value.global:{};return value}
|
|
catch(error){if(error.code==='ENOENT')return emptyWorld();throw error}
|
|
}
|
|
async function readWorldBoard(record,id){const revision=record.boardVersions[id];if(!Number.isSafeInteger(revision))return null;try{const value=JSON.parse(await fsp.readFile(worldBoardVersionPath(id,revision),'utf8'));return value&&typeof value==='object'?value:null}catch(error){if(error.code==='ENOENT')throw Object.assign(new Error(`Shared board is missing: ${id}`),{status:500});throw error}}
|
|
function authenticate(req){const raw=String(req.headers.authorization||''),match=/^Bearer\s+([^.]*)\.([^.]*)$/i.exec(raw);if(!match||!PLAYER_RE.test(match[1])||!TOKEN_RE.test(match[2]))throw Object.assign(new Error('Unauthorized'),{status:401});return{playerId:match[1].toLowerCase(),token:match[2].toLowerCase()}}
|
|
async function authenticatedPlayer(req){const auth=authenticate(req),record=await readPlayer(auth.playerId);if(!safeEqualHex(record.tokenHash,tokenHash(auth.token)))throw Object.assign(new Error('Invalid cloud sync code'),{status:403});return{...auth,record}}
|
|
async function readJsonBody(req){const chunks=[];let bytes=0;for await(const chunk of req){bytes+=chunk.length;if(bytes>MAX_BODY_BYTES)throw Object.assign(new Error('Request body is too large'),{status:413});chunks.push(chunk)}if(!chunks.length)return{};try{const parsed=JSON.parse(Buffer.concat(chunks).toString('utf8'));if(!parsed||typeof parsed!=='object'||Array.isArray(parsed))throw new Error();return parsed}catch{throw Object.assign(new Error('Invalid JSON body'),{status:400})}}
|
|
function cellKey(cell){return `${cell[0]},${cell[1]}`}
|
|
function normalizedRouteKey(cells){const forward=cells.map(cellKey).join('|'),reverse=[...cells].reverse().map(cellKey).join('|');return forward<reverse?forward:reverse}
|
|
function validatePuzzle(meta){
|
|
const puzzle=meta.puzzle;if(!puzzle||typeof puzzle!=='object'||!Array.isArray(puzzle.valid)||!Array.isArray(puzzle.g)||!Array.isArray(puzzle.n)||!Array.isArray(puzzle.solution))badRequest(`Missing puzzle for ${meta.id}`);
|
|
const valid=new Set();for(const cell of puzzle.valid){if(!Array.isArray(cell)||cell.length!==2||!Number.isSafeInteger(cell[0])||!Number.isSafeInteger(cell[1])||valid.has(cellKey(cell)))badRequest(`Invalid puzzle cell for ${meta.id}`);valid.add(cellKey(cell))}
|
|
if(!valid.size||valid.size>meta.chunks.length*25)badRequest(`Invalid puzzle area for ${meta.id}`);
|
|
const obstacles=new Set();for(const cell of Array.isArray(puzzle.obstacles)?puzzle.obstacles:[]){if(!Array.isArray(cell)||cell.length!==2||!Number.isSafeInteger(cell[0])||!Number.isSafeInteger(cell[1])||valid.has(cellKey(cell))||obstacles.has(cellKey(cell)))badRequest(`Invalid obstacle for ${meta.id}`);obstacles.add(cellKey(cell))}
|
|
if(valid.size+obstacles.size!==meta.chunks.length*25)badRequest(`Incomplete puzzle area for ${meta.id}`);
|
|
const gates=puzzle.g;if(!gates.length||gates.length%2!==0)badRequest(`Invalid gates for ${meta.id}`);
|
|
for(const gate of gates)if(!Array.isArray(gate)||gate.length!==3||!Number.isSafeInteger(gate[0])||!Number.isSafeInteger(gate[1])||!valid.has(`${gate[0]},${gate[1]}`)||!['N','S','W','E'].includes(gate[2]))badRequest(`Invalid gate for ${meta.id}`);
|
|
for(const clue of puzzle.n)if(!Array.isArray(clue)||clue.length!==3||!Number.isSafeInteger(clue[0])||!Number.isSafeInteger(clue[1])||!Number.isSafeInteger(clue[2])||clue[2]<0||clue[2]>512||!valid.has(`${clue[0]},${clue[1]}`))badRequest(`Invalid clue for ${meta.id}`);
|
|
const warpMap=new Map();for(const pair of puzzle.specialCells?.warps||[]){if(!Array.isArray(pair?.a)||!Array.isArray(pair?.b)||!valid.has(cellKey(pair.a))||!valid.has(cellKey(pair.b)))badRequest(`Invalid warp for ${meta.id}`);warpMap.set(cellKey(pair.a),cellKey(pair.b));warpMap.set(cellKey(pair.b),cellKey(pair.a))}
|
|
const crossingSet=new Set((puzzle.specialCells?.crossings||[]).map(cellKey)),coverage=new Map();
|
|
const validateRoute=(route,label)=>{if(!route||typeof route!=='object'||!Array.isArray(route.cells)||!route.cells.length||!Number.isInteger(route.startGate)||!Number.isInteger(route.endGate)||route.startGate<0||route.endGate<0||route.startGate>=gates.length||route.endGate>=gates.length)badRequest(`Invalid ${label} for ${meta.id}`);if(cellKey(route.cells[0])!==`${gates[route.startGate][0]},${gates[route.startGate][1]}`||cellKey(route.cells[route.cells.length-1])!==`${gates[route.endGate][0]},${gates[route.endGate][1]}`)badRequest(`Gate mismatch in ${label} for ${meta.id}`);const local=new Set();for(let index=0;index<route.cells.length;index++){const cell=route.cells[index],key=Array.isArray(cell)?cellKey(cell):'';if(!Array.isArray(cell)||cell.length!==2||!Number.isSafeInteger(cell[0])||!Number.isSafeInteger(cell[1])||!valid.has(key)||local.has(key))badRequest(`Invalid ${label} cell for ${meta.id}`);local.add(key);if(index){const previous=route.cells[index-1],distance=Math.abs(previous[0]-cell[0])+Math.abs(previous[1]-cell[1]);if(distance!==1&&warpMap.get(cellKey(previous))!==key)badRequest(`Disconnected ${label} for ${meta.id}`)}}return route.cells};
|
|
for(const route of puzzle.solution)for(const cell of validateRoute(route,'solution path')){const key=cellKey(cell),count=(coverage.get(key)||0)+1;if(count>(crossingSet.has(key)?2:1))badRequest(`Overlapping solution for ${meta.id}`);coverage.set(key,count)}
|
|
if(coverage.size!==valid.size)badRequest(`Incomplete solution for ${meta.id}`);
|
|
return{valid,gates,warpMap,crossingSet,solutionKeys:puzzle.solution.map(route=>normalizedRouteKey(route.cells)).sort()};
|
|
}
|
|
function validateMeta(meta){
|
|
if(!meta||typeof meta!=='object'||!BOARD_RE.test(meta.id))badRequest('Invalid board metadata');const chunks=Array.isArray(meta.chunks)?meta.chunks:[];
|
|
if(!chunks.length||chunks.length>50)badRequest(`Invalid chunks for ${meta.id}`);const seen=new Set();for(const cell of chunks){if(!Array.isArray(cell)||cell.length!==2||!Number.isSafeInteger(cell[0])||!Number.isSafeInteger(cell[1])||Math.abs(cell[0])>1000000||Math.abs(cell[1])>1000000||seen.has(cellKey(cell)))badRequest(`Invalid chunk coordinate for ${meta.id}`);seen.add(cellKey(cell))}
|
|
if(!Number.isSafeInteger(meta.x)||!Number.isSafeInteger(meta.y)||Math.abs(meta.x)>100000000||Math.abs(meta.y)>100000000)badRequest(`Invalid board coordinate for ${meta.id}`);
|
|
if(!Number.isSafeInteger(meta.seed)||meta.seed<0||meta.seed>0xffffffff)badRequest(`Invalid seed for ${meta.id}`);
|
|
if(!Number.isInteger(meta.level)||meta.level<1||meta.level>10||!Number.isInteger(meta.targetLevel)||meta.targetLevel<1||meta.targetLevel>10)badRequest(`Invalid level for ${meta.id}`);
|
|
if(meta.entrySide!=null&&!['N','S','W','E'].includes(meta.entrySide))badRequest(`Invalid entry side for ${meta.id}`);
|
|
if(meta.sealedSides!=null&&(!Array.isArray(meta.sealedSides)||meta.sealedSides.some(side=>!['N','S','W','E'].includes(side))))badRequest(`Invalid sealed sides for ${meta.id}`);
|
|
const clean=JSON.parse(JSON.stringify(meta));validatePuzzle(clean);return clean;
|
|
}
|
|
function validateStateRow(row,meta){
|
|
if(!row||typeof row!=='object'||!BOARD_RE.test(row.id)||!row.value||typeof row.value!=='object')badRequest('Invalid board state');if(!meta)badRequest(`State without metadata: ${row.id}`);
|
|
const state=JSON.parse(JSON.stringify(row.value)),puzzle=validatePuzzle(meta),paths=Array.isArray(state.paths)?state.paths:[];if(paths.length>MAX_PATHS_PER_BOARD)badRequest(`Too many paths for ${row.id}`);
|
|
for(const item of paths){if(!item||typeof item!=='object'||!Array.isArray(item.cells)||item.cells.length>MAX_CELLS_PER_PATH)badRequest(`Invalid path for ${row.id}`);if(!Number.isInteger(item.startGate)||item.startGate<0||item.startGate>=puzzle.gates.length||item.endGate!=null&&(!Number.isInteger(item.endGate)||item.endGate<0||item.endGate>=puzzle.gates.length))badRequest(`Invalid path gates for ${row.id}`);const seen=new Set();for(let index=0;index<item.cells.length;index++){const cell=item.cells[index];if(!Array.isArray(cell)||cell.length!==2||!Number.isSafeInteger(cell[0])||!Number.isSafeInteger(cell[1]))badRequest(`Invalid path cell for ${row.id}`);const key=cellKey(cell);if(!puzzle.valid.has(key)||seen.has(key))badRequest(`Invalid path cell for ${row.id}`);seen.add(key);if(index){const previous=item.cells[index-1],distance=Math.abs(previous[0]-cell[0])+Math.abs(previous[1]-cell[1]);if(distance!==1&&puzzle.warpMap.get(cellKey(previous))!==key)badRequest(`Disconnected path for ${row.id}`)}}}
|
|
if(state.solved===true){const solvedKeys=paths.map(route=>route.endGate==null?'':normalizedRouteKey(route.cells)).sort();if(solvedKeys.length!==puzzle.solutionKeys.length||solvedKeys.some((key,index)=>!key||key!==puzzle.solutionKeys[index]))badRequest(`Solved state does not match puzzle for ${row.id}`)}
|
|
return state;
|
|
}
|
|
function worldMetaFingerprint(meta){const clean=JSON.parse(JSON.stringify(meta));delete clean.rev;delete clean.revAuthor;delete clean.sealedSides;return JSON.stringify(clean)}
|
|
function sanitizeWorldGlobal(value,record){
|
|
const source=value&&typeof value==='object'&&!Array.isArray(value)?value:{},prior=record?.global||{},clean={};
|
|
for(const key of['schema','gameplayVersion','worldGeneration','worldEpoch','appVersion','generatorVersion','nextId','solved','lastSolveAt','specialMechanicsSeen','quarantine'])if(Object.prototype.hasOwnProperty.call(source,key))clean[key]=JSON.parse(JSON.stringify(source[key]));
|
|
clean.specialMechanicsSeen=Array.isArray(clean.specialMechanicsSeen)?[...new Set(clean.specialMechanicsSeen.filter(type=>['warp','lock','crossing'].includes(type)))]:Array.isArray(prior.specialMechanicsSeen)?prior.specialMechanicsSeen:[];
|
|
clean.updatedAt=serverTime();return clean;
|
|
}
|
|
|
|
const STORE_CHANCE=1/30,STORE_PRICE_VERSION=1,EXPANSION_GRANT_TTL_MS=10*60*1000,MAX_NEW_BOARDS_PER_GRANT=8;
|
|
function authoritativeStoreItemIds(seed){
|
|
const all=[...STORE_CATALOG.values()],cursor=all.filter(item=>item.cursorStyle),other=all.filter(item=>!item.cursorStyle),
|
|
cursorPool=PuzzleCore.shuffle([...cursor],PuzzleCore.rngFrom(PuzzleCore.hash32((seed>>>0)^0x5f356495))),
|
|
otherPool=PuzzleCore.shuffle([...other],PuzzleCore.rngFrom(PuzzleCore.hash32((seed>>>0)^0x2c9277b5))),
|
|
selected=[...cursorPool.slice(0,12),...otherPool.slice(0,1)];
|
|
return PuzzleCore.shuffle(selected,PuzzleCore.rngFrom(PuzzleCore.hash32((seed>>>0)^0x6d2b79f5))).map(item=>item.id);
|
|
}
|
|
function authoritativeReward(meta,state,worldSeed=0){
|
|
const level=Math.max(1,Math.min(10,Number(meta.level)||1)),sections=Math.max(1,meta.chunks?.length||1),
|
|
totalCells=(state.paths||[]).reduce((sum,path)=>sum+(path.cells?.length||0),0),
|
|
base=Math.max(100,Math.round((level*level*100+totalCells*level*20)/80)*10),
|
|
reward=AppLogic.deterministicBoardReward(base,{worldSeed,meta,state,timeAttackModifier:1,scoreLensCount:0});
|
|
return{award:Math.max(13,Math.min(Number.MAX_SAFE_INTEGER,reward.award)),identity:reward.identity,coefficient:reward.coefficient};
|
|
}
|
|
function authoritativeStore(meta,state,playerName,worldSeed=0){
|
|
const roll=(PuzzleCore.hash32((meta.seed>>>0)^0x7f4a7c15)>>>0)/4294967296;if(roll>=STORE_CHANCE||!state.paths?.length)return null;
|
|
const pathIndex=state.paths.reduce((best,path,index)=>(path.cells?.length||0)>(state.paths[best]?.cells?.length||0)?index:best,0),path=state.paths[pathIndex],cellIndex=Math.max(0,Math.min(path.cells.length-1,Math.floor(path.cells.length*.55))),
|
|
store={owner:playerName,pathIndex,cellIndex,openedAt:serverTime(),priceVersion:STORE_PRICE_VERSION,priceCoefficient:null,bonus:0,bonusVersion:6,itemIds:authoritativeStoreItemIds(meta.seed),purchases:[]},
|
|
[x,y]=storeItemPriceLocation(meta,state,store);store.priceCoefficient=AppLogic.deterministicStorePrice(1,worldSeed,x,y,STORE_PRICE_VERSION).coefficient;return store;
|
|
}
|
|
function boardTouchesWorld(meta,rows){const occupied=new Set();for(const row of rows)for(const[dx,dy]of row?.meta?.chunks||[])occupied.add(`${row.meta.x+dx},${row.meta.y+dy}`);for(const[dx,dy]of meta.chunks||[]){const x=meta.x+dx,y=meta.y+dy;for(const[ox,oy]of[[1,0],[-1,0],[0,1],[0,-1]])if(occupied.has(`${x+ox},${y+oy}`))return true}return false}
|
|
|
|
function publicStateForWorld(incoming,current,player,worldRevision,rowRevision,meta,worldSeed=0){
|
|
const now=serverTime(),wasSolved=current?.solved===true,wantsSolved=incoming.solved===true,base={paths:[],specialProgress:{crossings:[]},solved:false,expanded:false,expansionRetryRound:0,solvedBy:null,solvedById:null,solvedAt:null,scoreAwarded:0,scoreVersion:incoming.scoreVersion||0,rewardIdentity:null,rewardCoefficient:null,store:null,rev:rowRevision,revAuthor:'shared-world'};
|
|
if(wasSolved){
|
|
const stable=JSON.parse(JSON.stringify(current));stable.expanded=stable.expanded===true||incoming.expanded===true;stable.expansionRetryRound=stable.expanded?0:Math.max(stable.expansionRetryRound||0,incoming.expansionRetryRound||0);stable.rev=rowRevision;stable.revAuthor='shared-world';if(stable.store)stable.store.purchases=[];return{state:stable,clearEvent:null};
|
|
}
|
|
if(!wantsSolved)return{state:base,clearEvent:null};
|
|
const state=JSON.parse(JSON.stringify(incoming));state.solved=true;state.solvedBy=player.name;state.solvedById=player.playerId;state.solvedAt=now;state.rev=rowRevision;state.revAuthor='shared-world';state.expanded=false;state.expansionRetryRound=0;const reward=authoritativeReward(meta,state,worldSeed);state.scoreAwarded=reward.award;state.scoreVersion=6;state.rewardIdentity=reward.identity;state.rewardCoefficient=reward.coefficient;state.store=authoritativeStore(meta,state,player.name,worldSeed);
|
|
return{state,clearEvent:{id:meta.id,playerId:player.playerId,playerName:player.name,x:meta.x,y:meta.y,level:meta.level,scoreAwarded:state.scoreAwarded,solvedAt:now,revision:worldRevision}};
|
|
}
|
|
function cloudDeltaSince(record,since){if(!(since>0)||since>=record.revision)return null;const changes=record.changes.filter(change=>Number.isSafeInteger(change?.revision)&&change.revision>since).sort((a,b)=>a.revision-b.revision);if(!changes.length||changes[0].revision!==since+1||changes[changes.length-1].revision!==record.revision)return null;for(let index=1;index<changes.length;index++)if(changes[index].revision!==changes[index-1].revision+1)return null;const metaIds=new Set(),stateIds=new Set(),deleted=new Set();for(const change of changes){for(const id of change.deleted||[]){metaIds.delete(id);stateIds.delete(id);deleted.add(id)}for(const id of change.metaIds||[]){deleted.delete(id);metaIds.add(id)}for(const id of change.stateIds||[]){deleted.delete(id);stateIds.add(id)}}return{metaIds,stateIds,deleted}}
|
|
async function publicWorldPage(record,ids,metaIds=null,stateIds=null){const rows=await Promise.all(ids.map(id=>readWorldBoard(record,id))),metas={},states={};for(let index=0;index<ids.length;index++){const id=ids[index],row=rows[index];if(!row)continue;if((!metaIds||metaIds.has(id))&&row.meta)metas[id]=row.meta;if((!stateIds||stateIds.has(id))&&row.state)states[id]=row.state}return{global:{...(record.global||{}),cloudProfile:null,cloudRevision:record.revision},metas,states}}
|
|
function withWorldQueue(task){const run=worldQueue.then(task,task);worldQueue=run.then(()=>undefined,()=>undefined);return run}
|
|
async function authenticateRealtime({playerId,token}){
|
|
if(!PLAYER_RE.test(String(playerId||''))||!TOKEN_RE.test(String(token||'')))throw new Error('Unauthorized');
|
|
const normalizedId=String(playerId).toLowerCase(),record=await readPlayer(normalizedId);
|
|
if(!safeEqualHex(record.tokenHash,tokenHash(String(token).toLowerCase())))throw new Error('Unauthorized');
|
|
return{playerId:normalizedId,name:record.name};
|
|
}
|
|
async function realtimeBoardInfo(boardId){
|
|
if(!BOARD_RE.test(String(boardId||'')))return null;const record=await readWorld(),row=await readWorldBoard(record,boardId);if(!row?.meta)return null;
|
|
let minX=Infinity,minY=Infinity,maxX=-Infinity,maxY=-Infinity;for(const[dx,dy]of row.meta.chunks||[]){const x=row.meta.x+dx,y=row.meta.y+dy;minX=Math.min(minX,x);minY=Math.min(minY,y);maxX=Math.max(maxX,x+1);maxY=Math.max(maxY,y+1)}
|
|
if(!Number.isFinite(minX))return null;return{solved:row.state?.solved===true,bounds:{minX,minY,maxX,maxY,x:(minX+maxX)/2,y:(minY+maxY)/2}};
|
|
}
|
|
function assertNoOverlaps(rows){const occupied=new Map();for(const row of rows){const meta=row?.meta;if(!meta)continue;for(const[dx,dy]of meta.chunks){const key=`${meta.x+dx},${meta.y+dy}`,prior=occupied.get(key);if(prior&&prior!==meta.id)badRequest(`Board overlap: ${prior} / ${meta.id}`);occupied.set(key,meta.id)}}}
|
|
|
|
function storeItemPriceLocation(meta,state,store){
|
|
const path=store&&state?.paths?.[store.pathIndex],cell=path?.cells?.[store.cellIndex];
|
|
if(Array.isArray(cell))return[meta.x+(cell[1]+.5)/5,meta.y+(cell[0]+.5)/5];
|
|
const count=Math.max(1,meta.chunks?.length||1),x=meta.x+.5+(meta.chunks||[]).reduce((sum,chunk)=>sum+chunk[0],0)/count,y=meta.y+.5+(meta.chunks||[]).reduce((sum,chunk)=>sum+chunk[1],0)/count;return[x,y];
|
|
}
|
|
async function storePurchaseContext(world,boardId,itemId){
|
|
if(!BOARD_RE.test(String(boardId||'')))badRequest('Invalid store board');const item=STORE_CATALOG.get(itemId);if(!item)badRequest('Invalid store item');
|
|
const row=await readWorldBoard(world,boardId);if(!row?.meta||row.state?.solved!==true||!row.state?.store)badRequest('Store is not available');
|
|
const store=row.state.store,itemIds=Array.isArray(store.itemIds)?store.itemIds:[];if(!itemIds.includes(item.id))badRequest('Item is not sold by this store');
|
|
const starter=await readWorldBoard(world,'B0'),worldSeed=starter?.meta?.seed||0,[x,y]=storeItemPriceLocation(row.meta,row.state,store),computed=AppLogic.deterministicStorePrice(1,worldSeed,x,y,store.priceVersion||1),coefficient=computed.coefficient,adjusted=Math.round(Math.max(0,Number(item.cost)||0)*coefficient),price=item.id.startsWith('cursor-face-')?Math.max(500,Math.min(50000,adjusted)):Math.max(item.cursorStyle?500:3000,adjusted);
|
|
return{row,item,price};
|
|
}
|
|
async function sharedWorldEarnedScore(world){
|
|
const cached=Number(world?.global?.earnedScore);if(Number.isSafeInteger(cached)&&cached>=0)return cached;
|
|
let total=0;for(const id of Object.keys(world?.boardVersions||{})){const row=await readWorldBoard(world,id),award=Number(row?.state?.scoreAwarded)||0;if(row?.state?.solved===true&&Number.isSafeInteger(award)&&award>0)total+=award}
|
|
return Math.max(0,total);
|
|
}
|
|
async function assertPlayerCanAfford(world,record,price){
|
|
const earned=playerEarnedScore(record),spent=playerSpentScore(record),available=Math.max(0,earned-spent);if(available<price)throw Object.assign(new Error(`Insufficient score: ${available} / ${price}`),{status:402});return{earned,spent,available};
|
|
}
|
|
function purchaseForStoreItem(record,boardId,itemId){return normalizePlayerPurchases(record.purchases).find(purchase=>purchase.boardId===boardId&&purchase.itemId===itemId)||null}
|
|
function createPlayerPurchase(record,boardId,item,price,timestamp=serverTime()){
|
|
const purchase={purchaseId:crypto.randomBytes(16).toString('hex'),boardId,itemId:item.id,buyer:record.name,boughtAt:timestamp,paidCost:price};
|
|
record.purchases=normalizePlayerPurchases([...(record.purchases||[]),purchase]);
|
|
record.economyRevision=(record.economyRevision||0)+1;
|
|
record.updatedAt=timestamp;
|
|
return record.purchases.find(row=>row.purchaseId===purchase.purchaseId)||purchase;
|
|
}
|
|
async function writePlayerRecord(record){record.purchases=normalizePlayerPurchases(record.purchases);record.generationBonuses=normalizeGenerationBonuses(record.generationBonuses);await atomicWriteJson(playerPath(record.playerId),record)}
|
|
|
|
async function handleApi(req,res,url){
|
|
if(req.method==='GET'&&url.pathname==='/api/cloud/status')return json(res,200,{available:true,sharedWorld:true,realtime:true,reactions:true,playerEconomy:true,sharedItems:false,claimTtlMs:realtimeHub?.claimTtlMs||300000,serverTime:serverTime()});
|
|
if(req.method==='POST'&&url.pathname==='/api/cloud/session'){
|
|
const body=await readJsonBody(req),playerId=crypto.randomBytes(12).toString('hex'),token=crypto.randomBytes(32).toString('hex'),now=serverTime(),name=cleanPlayerName(body.name,defaultPlayerName(playerId));
|
|
const record={playerId,name,tokenHash:tokenHash(token),purchases:[],generationBonuses:[],earnedScore:0,economyRevision:0,createdAt:now,updatedAt:now};await atomicWriteJson(playerPath(playerId),record);return json(res,201,{playerId,token,name,revision:0,serverTime:now});
|
|
}
|
|
if(req.method==='POST'&&url.pathname==='/api/cloud/profile'){
|
|
const auth=await authenticatedPlayer(req),body=await readJsonBody(req),name=cleanPlayerName(body.name);if(!name)badRequest('Player name is required');auth.record.name=name;auth.record.updatedAt=serverTime();await atomicWriteJson(playerPath(auth.playerId),auth.record);realtimeHub?.notifyProfileChange(auth.playerId,name);return json(res,200,{playerId:auth.playerId,name,serverTime:auth.record.updatedAt});
|
|
}
|
|
if(req.method==='GET'&&url.pathname==='/api/player/state'){
|
|
const player=await authenticatedPlayer(req);return json(res,200,{player:publicPlayerState(player.record),serverTime:serverTime()});
|
|
}
|
|
if(req.method==='POST'&&url.pathname==='/api/player/generation-bonus'){
|
|
const auth=await authenticatedPlayer(req),body=await readJsonBody(req),boardId=String(body.boardId||'');if(!BOARD_RE.test(boardId))badRequest('Invalid board id');
|
|
return withPlayerQueue(auth.playerId,()=>withWorldQueue(async()=>{const record=await readPlayer(auth.playerId),world=await readWorld(),row=await readWorldBoard(world,boardId),now=serverTime();if(!row?.state?.solved||row.state.solvedById!==auth.playerId)throw Object.assign(new Error('Only the solver can receive this bonus'),{status:403});if(row.state.expanded===true)throw Object.assign(new Error('Expansion already succeeded'),{status:409});if(now-(Number(row.state.solvedAt)||0)<GENERATION_FAILURE_MIN_DELAY_MS)throw Object.assign(new Error('Generation attempt is still in progress'),{status:409});const grant=world.expansionGrants?.[auth.playerId];if(!grant||grant.boardId!==boardId||grant.expiresAt<now||!(grant.maxBoards>0))throw Object.assign(new Error('No failed expansion is eligible'),{status:409});record.generationBonuses=normalizeGenerationBonuses(record.generationBonuses);if(!record.generationBonuses.includes(boardId)){record.generationBonuses.push(boardId);record.earnedScore=Math.min(Number.MAX_SAFE_INTEGER,playerEarnedScore(record)+GENERATION_FAILURE_BONUS);record.economyRevision=(record.economyRevision||0)+1;record.updatedAt=now;await writePlayerRecord(record)}return json(res,200,{bonus:GENERATION_FAILURE_BONUS,player:publicPlayerState(record),serverTime:now})}));
|
|
}
|
|
if(req.method==='POST'&&url.pathname==='/api/player/purchase'){
|
|
const auth=await authenticatedPlayer(req),body=await readJsonBody(req),boardId=String(body.boardId||''),itemId=String(body.itemId||'');
|
|
return withPlayerQueue(auth.playerId,async()=>{const record=await readPlayer(auth.playerId),world=await readWorld(),context=await storePurchaseContext(world,boardId,itemId),existing=purchaseForStoreItem(record,boardId,itemId);if(existing)return json(res,200,{purchase:existing,player:publicPlayerState(record),serverTime:serverTime()});await assertPlayerCanAfford(world,record,context.price);const purchase=createPlayerPurchase(record,boardId,context.item,context.price);await writePlayerRecord(record);return json(res,201,{purchase,player:publicPlayerState(record),serverTime:record.updatedAt})});
|
|
}
|
|
if(req.method==='GET'&&url.pathname==='/api/cloud/pull'){
|
|
const player=await authenticatedPlayer(req),record=await readWorld(),since=Math.max(0,Math.floor(finiteNumber(url.searchParams.get('since'),0))),eventsSince=Math.max(0,Math.floor(finiteNumber(url.searchParams.get('eventsSince'),0))),changed=since!==record.revision,
|
|
clearEvents=record.clearEvents.filter(event=>(event.revision||0)>eventsSince);
|
|
if(!changed)return json(res,200,{changed:false,revision:record.revision,latestEventRevision:record.clearEvents.at(-1)?.revision||0,clearEvents,player:{id:player.playerId,name:player.record.name},serverTime:serverTime()});
|
|
const cursor=Math.max(0,Math.floor(finiteNumber(url.searchParams.get('cursor'),0))),at=Math.max(0,Math.floor(finiteNumber(url.searchParams.get('at'),record.revision)));if(cursor&&at!==record.revision)return json(res,409,{error:'World changed during paged pull',revision:record.revision,serverTime:serverTime()});
|
|
const delta=cloudDeltaSince(record,since),fullSnapshot=!delta,metaIds=delta?.metaIds||new Set(Object.keys(record.boardVersions)),stateIds=delta?.stateIds||new Set(Object.keys(record.boardVersions)),ids=[...new Set([...metaIds,...stateIds])].filter(id=>Number.isSafeInteger(record.boardVersions[id])).sort((a,b)=>Number(a.slice(1))-Number(b.slice(1))),pageIds=ids.slice(cursor,cursor+CLOUD_PAGE_LIMIT),nextCursor=cursor+pageIds.length<ids.length?cursor+pageIds.length:null,page=await publicWorldPage(record,pageIds,metaIds,stateIds);
|
|
return json(res,200,{changed:true,revision:record.revision,latestEventRevision:record.clearEvents.at(-1)?.revision||0,clearEvents:cursor?[]:clearEvents,player:{id:player.playerId,name:player.record.name},serverTime:serverTime(),fullSnapshot,page:{...page,deleted:delta?[...delta.deleted]:[]},nextCursor});
|
|
}
|
|
if(req.method==='POST'&&url.pathname==='/api/cloud/push'){
|
|
const player=await authenticatedPlayer(req),body=await readJsonBody(req);
|
|
return withPlayerQueue(player.playerId,()=>withWorldQueue(async()=>{
|
|
const playerRecord=await readPlayer(player.playerId),record=await readWorld(),baseRevision=Math.max(0,Math.floor(finiteNumber(body.baseRevision,0)));if(baseRevision!==record.revision)return json(res,409,{error:'Revision conflict',revision:record.revision,serverTime:serverTime()});
|
|
const metas=Array.isArray(body.metas)?body.metas:[],states=Array.isArray(body.states)?body.states:[],deleted=[];if(metas.length+states.length>MAX_BOARDS_PER_PUSH*2)throw Object.assign(new Error('Too many board changes'),{status:413});
|
|
const nextRevision=record.revision+1,rowRevision=Math.max((Number(record.rowRevision)||0)+1,serverTime()*1000),changedBoards=new Map(),previousVersions=new Map(),loadChangedBoard=async id=>{if(changedBoards.has(id))return changedBoards.get(id);const current=await readWorldBoard(record,id)||{meta:null,state:null};changedBoards.set(id,current);previousVersions.set(id,record.boardVersions[id]);return current};
|
|
for(const rawMeta of metas){const clean=validateMeta(rawMeta),row=await loadChangedBoard(clean.id);if(row.meta&&worldMetaFingerprint(row.meta)!==worldMetaFingerprint(clean))badRequest(`Existing board is immutable: ${clean.id}`);clean.rev=rowRevision;clean.revAuthor='shared-world';row.meta=clean}
|
|
const existingIds=new Set(Object.keys(record.boardVersions)),newMetaIds=[...changedBoards.keys()].filter(id=>!existingIds.has(id));
|
|
if(record.revision>0&&newMetaIds.length){const grant=record.expansionGrants?.[player.playerId];if(!grant||grant.expiresAt<serverTime())throw Object.assign(new Error('Expansion grant is required'),{status:403});if(newMetaIds.length>Math.min(MAX_NEW_BOARDS_PER_GRANT,grant.maxBoards||0))badRequest('Too many generated boards');const expectedStart=Math.max(1,Number(record.global?.nextId)||1),numbers=newMetaIds.map(id=>Number(id.slice(1))).sort((a,b)=>a-b);for(let i=0;i<numbers.length;i++)if(numbers[i]!==expectedStart+i)badRequest('Generated board ids are not contiguous');const existingRows=[];for(const id of existingIds){const row=await readWorldBoard(record,id);if(row)existingRows.push(row)}const accepted=[];for(const id of newMetaIds.sort((a,b)=>Number(a.slice(1))-Number(b.slice(1)))){const row=changedBoards.get(id);if(!boardTouchesWorld(row.meta,[...existingRows,...accepted]))badRequest(`Generated board is not adjacent: ${id}`);accepted.push(row)}grant.maxBoards-=newMetaIds.length;if(grant.maxBoards<=0)delete record.expansionGrants[player.playerId]}
|
|
const clearEvents=[];
|
|
for(const rawRow of states){if(!BOARD_RE.test(rawRow?.id))badRequest('Invalid board state');const row=await loadChangedBoard(rawRow.id);if(!row.meta)badRequest(`Board metadata is missing: ${rawRow.id}`);const incoming=validateStateRow(rawRow,row.meta),firstSolve=row.state?.solved!==true&&incoming.solved===true;if(firstSolve&&realtimeHub&&!realtimeHub.hasClaim(player.playerId,rawRow.id))throw Object.assign(new Error('Board claim is required'),{status:423});const starter=await readWorldBoard(record,'B0'),worldSeed=starter?.meta?.seed||0;const published=publicStateForWorld(incoming,row.state,playerRecord,nextRevision,rowRevision,row.meta,worldSeed);row.state=published.state;if(published.clearEvent){clearEvents.push(published.clearEvent);playerRecord.earnedScore=Math.min(Number.MAX_SAFE_INTEGER,playerEarnedScore(playerRecord)+published.clearEvent.scoreAwarded);playerRecord.economyRevision=(playerRecord.economyRevision||0)+1;playerRecord.updatedAt=published.clearEvent.solvedAt;record.expansionGrants[player.playerId]={boardId:rawRow.id,expiresAt:published.clearEvent.solvedAt+EXPANSION_GRANT_TTL_MS,maxBoards:MAX_NEW_BOARDS_PER_GRANT}}}
|
|
for(const [id,row] of changedBoards){if(!row.meta)badRequest(`Board metadata is missing: ${id}`);if(!row.state)row.state=publicStateForWorld({},null,playerRecord,nextRevision,rowRevision,row.meta).state}
|
|
const allIds=new Set([...Object.keys(record.boardVersions),...changedBoards.keys()]),allRows=[];for(const id of allIds){const row=changedBoards.get(id)||await readWorldBoard(record,id);if(row)allRows.push(row)}assertNoOverlaps(allRows);
|
|
await fsp.mkdir(WORLD_BOARDS_DIR,{recursive:true,mode:0o700});for(const[id,row]of changedBoards){await atomicWriteJson(worldBoardVersionPath(id,nextRevision),row);record.boardVersions[id]=nextRevision}
|
|
record.global={...(record.global||{}),...sanitizeWorldGlobal(body.global,record)};const boardNumbers=Object.keys(record.boardVersions).map(id=>Number(id.slice(1))).filter(Number.isSafeInteger);record.global.nextId=Math.max(Number(record.global.nextId)||1,(boardNumbers.length?Math.max(...boardNumbers)+1:1));let solved=0,earnedScore=0;for(const row of allRows)if(row.state?.solved){solved++;const award=Number(row.state.scoreAwarded)||0;if(Number.isSafeInteger(award)&&award>0)earnedScore+=award}record.global.solved=solved;record.global.earnedScore=Math.max(0,earnedScore);record.revision=nextRevision;record.rowRevision=rowRevision;record.global.cloudRevision=nextRevision;record.updatedAt=serverTime();record.global.updatedAt=record.updatedAt;
|
|
record.changes.push({revision:nextRevision,metaIds:metas.map(meta=>meta.id),stateIds:states.map(row=>row.id),deleted});if(record.changes.length>CHANGE_HISTORY_LIMIT)record.changes.splice(0,record.changes.length-CHANGE_HISTORY_LIMIT);
|
|
record.clearEvents.push(...clearEvents);if(record.clearEvents.length>CLEAR_EVENT_LIMIT)record.clearEvents.splice(0,record.clearEvents.length-CLEAR_EVENT_LIMIT);
|
|
if(clearEvents.length)await writePlayerRecord(playerRecord);await atomicWriteJson(WORLD_FILE,record);await Promise.all([...previousVersions].map(([id,revision])=>Number.isSafeInteger(revision)&&revision!==nextRevision?fsp.unlink(worldBoardVersionPath(id,revision)).catch(error=>{if(error.code!=='ENOENT')console.warn(error)}):null));
|
|
for(const event of clearEvents)realtimeHub?.releaseBoardClaim(event.id,'cleared');realtimeHub?.broadcastClearEvents(clearEvents);
|
|
return json(res,200,{revision:nextRevision,clearEvents,latestEventRevision:record.clearEvents.at(-1)?.revision||0,player:{id:player.playerId,name:player.record.name},serverTime:record.updatedAt});
|
|
}));
|
|
}
|
|
return json(res,404,{error:'API endpoint not found',serverTime:serverTime()});
|
|
}
|
|
async function serveStatic(req,res,url){
|
|
if(!['GET','HEAD'].includes(req.method))return json(res,405,{error:'Method not allowed'});let pathname;try{pathname=decodeURIComponent(url.pathname)}catch{return json(res,400,{error:'Invalid path'})}if(pathname==='/')pathname='/index.html';const file=path.resolve(ROOT,`.${pathname}`);if(!file.startsWith(`${ROOT}${path.sep}`)||file.startsWith(`${DATA_DIR}${path.sep}`)||path.basename(file).startsWith('.'))return json(res,403,{error:'Forbidden'});let stat;try{stat=await fsp.stat(file)}catch(error){if(error.code==='ENOENT')return json(res,404,{error:'Not found'});throw error}if(stat.isDirectory())return json(res,403,{error:'Directory listing is disabled'});const ext=path.extname(file).toLowerCase();let body=null;if(pathname==='/index.html')body=Buffer.from((await fsp.readFile(file,'utf8')).replace('name="bend-field-cloud-api" content="off"','name="bend-field-cloud-api" content="on"'));res.writeHead(200,{'content-type':MIME[ext]||'application/octet-stream','content-length':body?body.length:stat.size,'cache-control':ext==='.html'||ext==='.js'||ext==='.css'?'no-store':'public, max-age=86400','x-content-type-options':'nosniff','cross-origin-resource-policy':'same-origin','content-security-policy':"default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; worker-src 'self'; connect-src 'self'; object-src 'none'; base-uri 'none'; frame-ancestors 'self'"});if(req.method==='HEAD')return res.end();if(body)return res.end(body);const stream=fs.createReadStream(file);stream.on('error',error=>{console.error(error);if(!res.headersSent)json(res,error.code==='ENOENT'?404:500,{error:error.code==='ENOENT'?'Not found':'Internal server error'});else res.destroy(error)});stream.pipe(res);
|
|
}
|
|
async function main(){await fsp.mkdir(DATA_DIR,{recursive:true,mode:0o700});const server=http.createServer(async(req,res)=>{try{const url=new URL(req.url,`http://${req.headers.host||'localhost'}`);if(url.pathname.startsWith('/api/'))await handleApi(req,res,url);else await serveStatic(req,res,url)}catch(error){console.error(error);if(!res.headersSent)json(res,error.status||500,{error:error.status?error.message:'Internal server error',serverTime:serverTime()});else res.destroy()}});realtimeHub=createRealtimeHub({server,authenticate:authenticateRealtime,getBoardInfo:realtimeBoardInfo});server.listen(PORT,HOST,()=>{console.log(`BEND FIELD v47.77 shared world: http://${HOST}:${PORT}`);console.log(`Shared world data: ${DATA_DIR}`)})}
|
|
main().catch(error=>{console.error(error);process.exitCode=1});
|