commit 8ce97729f49b61d91aaa67996889cf5ace758b12 Author: Nixiews Date: Fri Nov 20 19:59:44 2026 +0100 Initial commit diff --git a/assets/buildings/coal/building.json b/assets/buildings/coal/building.json new file mode 100644 index 0000000..d4a50ab --- /dev/null +++ b/assets/buildings/coal/building.json @@ -0,0 +1,11 @@ +{ + "name": "Centrale à charbon", + "sprite": "sprite.png", + "anim": { "type": "frames", "frames": 2, "fps": 2 }, + "cost": 800, + "requiresOffice": true, + "consumes": { "water": 4 }, + "produces": { "steam": 4 }, + "maintenance": { "every": 90, "duration": 12, "cost": 150 }, + "fallback": { "color": "#555555", "label": "C" } +} diff --git a/assets/buildings/coal/sprite.png b/assets/buildings/coal/sprite.png new file mode 100644 index 0000000..5d8e159 Binary files /dev/null and b/assets/buildings/coal/sprite.png differ diff --git a/assets/buildings/index.json b/assets/buildings/index.json new file mode 100644 index 0000000..3f5d389 --- /dev/null +++ b/assets/buildings/index.json @@ -0,0 +1 @@ +["office", "wind", "coal", "pump", "turbine"] diff --git a/assets/buildings/office/building.json b/assets/buildings/office/building.json new file mode 100644 index 0000000..ab42de2 --- /dev/null +++ b/assets/buildings/office/building.json @@ -0,0 +1,8 @@ +{ + "name": "Bureaux", + "sprite": "sprite.png", + "cost": 200, + "office": { "capacity": 5 }, + "maintenance": { "every": 60, "duration": 0, "cost": 20 }, + "fallback": { "color": "#4a6fa5", "label": "B" } +} diff --git a/assets/buildings/office/sprite.png b/assets/buildings/office/sprite.png new file mode 100644 index 0000000..8a29c74 Binary files /dev/null and b/assets/buildings/office/sprite.png differ diff --git a/assets/buildings/pump/building.json b/assets/buildings/pump/building.json new file mode 100644 index 0000000..3eebbc5 --- /dev/null +++ b/assets/buildings/pump/building.json @@ -0,0 +1,11 @@ +{ + "name": "Pompe", + "sprite": "sprite.png", + "cost": 150, + "anim": { "type": "frames", "frames": 6, "fps": 2 }, + "requiresOffice": true, + "placement": { "adjacentWater": true }, + "produces": { "water": 6 }, + "maintenance": { "every": 80, "duration": 0, "cost": 25 }, + "fallback": { "color": "#2f6fb3", "label": "P" } +} diff --git a/assets/buildings/pump/sprite.png b/assets/buildings/pump/sprite.png new file mode 100644 index 0000000..ed9ef00 Binary files /dev/null and b/assets/buildings/pump/sprite.png differ diff --git a/assets/buildings/turbine/building.json b/assets/buildings/turbine/building.json new file mode 100644 index 0000000..364d533 --- /dev/null +++ b/assets/buildings/turbine/building.json @@ -0,0 +1,11 @@ +{ + "name": "Turbine", + "sprite": "sprite.png", + "cost": 400, + "anim": { "type": "frames", "frames": 4, "fps": 2 }, + "requiresOffice": true, + "consumes": { "steam": 4 }, + "power": { "output": 12 }, + "maintenance": { "every": 100, "duration": 8, "cost": 60 }, + "fallback": { "color": "#9aa3ab", "label": "T" } +} diff --git a/assets/buildings/turbine/sprite.png b/assets/buildings/turbine/sprite.png new file mode 100644 index 0000000..8cf34f2 Binary files /dev/null and b/assets/buildings/turbine/sprite.png differ diff --git a/assets/buildings/wind/building.json b/assets/buildings/wind/building.json new file mode 100644 index 0000000..933d61d --- /dev/null +++ b/assets/buildings/wind/building.json @@ -0,0 +1,10 @@ +{ + "name": "Éolienne", + "sprite": "sprite.png", + "anim": { "type": "rotate", "speed": 1.5, "pivot": [16, 12] }, + "cost": 300, + "maintenance": { "every": 60, "duration": 0, "cost": 30 }, + "requiresOffice": true, + "power": { "output": 2, "scalesWithWind": true }, + "fallback": { "color": "#d8b020", "label": "W" } +} diff --git a/assets/buildings/wind/sprite.png b/assets/buildings/wind/sprite.png new file mode 100644 index 0000000..18692e4 Binary files /dev/null and b/assets/buildings/wind/sprite.png differ diff --git a/index.html b/index.html new file mode 100644 index 0000000..845c1d2 --- /dev/null +++ b/index.html @@ -0,0 +1,60 @@ + + + + + + Reactor + + + +
+

Reactor

+ + +
+ +
+
+ +
+ + + + +
+
+
+ +
+ +
+
+

+
+ + + + diff --git a/serve.py b/serve.py new file mode 100644 index 0000000..512e93b --- /dev/null +++ b/serve.py @@ -0,0 +1,18 @@ +#!/usr/bin/env python3 +"""Serveur de dev : comme `python3 -m http.server`, mais sans cache navigateur, +pour que les JSON, JS et PNG modifiés soient toujours rechargés. +Usage : python3 serve.py [port] (port 8000 par défaut)""" +import sys +from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer + + +class NoCache(SimpleHTTPRequestHandler): + def end_headers(self): + self.send_header('Cache-Control', 'no-store') + super().end_headers() + + +if __name__ == '__main__': + port = int(sys.argv[1]) if len(sys.argv) > 1 else 8000 + print(f'http://localhost:{port} (Ctrl+C pour arrêter)') + ThreadingHTTPServer(('', port), NoCache).serve_forever() diff --git a/src/camera.js b/src/camera.js new file mode 100644 index 0000000..50b3730 --- /dev/null +++ b/src/camera.js @@ -0,0 +1,83 @@ +// Caméra : position et zoom de la vue sur la grille. Aucun accès au DOM. +// écran = monde * zoom + (ox, oy), avec « monde » en pixels de sprite (une case = TILE). +// Les niveaux de zoom donnent une taille de case entière en pixels : pas de coutures entre les cases. +export const TILE = 32; +export const ZOOMS = [0.5, 0.75, 1, 1.5, 2, 3, 4]; +const START_ZOOM = 1.5; +const MARGIN = 64; // px de vide qu'on peut tirer au-delà des bords de la carte + +export const camera = { + ox: 0, oy: 0, // position à l'écran de l'angle haut-gauche de la carte (entiers) + zoom: START_ZOOM, + w: 0, h: 0, // taille de la vue (px) + cols: 1, rows: 1, // taille de la carte (cases) + dragging: false, // vue en cours de déplacement (curseur « main fermée ») +}; + +const tilePx = () => TILE * camera.zoom; + +// Carte plus petite que la vue : centrée. Sinon : on peut tirer de MARGIN px au-delà du bord. +function clampAxis(o, view, size) { + if (size + 2 * MARGIN <= view) return (view - size) / 2; + return Math.min(MARGIN, Math.max(view - size - MARGIN, o)); +} + +function clampCamera() { + camera.ox = Math.round(clampAxis(camera.ox, camera.w, camera.cols * tilePx())); + camera.oy = Math.round(clampAxis(camera.oy, camera.h, camera.rows * tilePx())); +} + +export function setMap(cols, rows) { + camera.cols = cols; + camera.rows = rows; +} + +export function resizeView(w, h) { + camera.w = w; + camera.h = h; + clampCamera(); +} + +// Carte centrée dans la vue, zoom de départ. +export function centerCamera() { + camera.zoom = START_ZOOM; + camera.ox = (camera.w - camera.cols * tilePx()) / 2; + camera.oy = (camera.h - camera.rows * tilePx()) / 2; + clampCamera(); +} + +export function panBy(dx, dy) { + camera.ox += dx; + camera.oy += dy; + clampCamera(); +} + +// Zoom d'un cran (dir = +1 / -1) en gardant fixe le point (sx, sy) de l'écran. +export function zoomStep(dir, sx = camera.w / 2, sy = camera.h / 2) { + const i = ZOOMS.indexOf(camera.zoom); + const next = ZOOMS[Math.min(ZOOMS.length - 1, Math.max(0, i + dir))]; + if (next === camera.zoom) return; + const wx = (sx - camera.ox) / camera.zoom, wy = (sy - camera.oy) / camera.zoom; // point du monde sous le curseur + camera.zoom = next; + camera.ox = sx - wx * next; + camera.oy = sy - wy * next; + clampCamera(); +} + +// Case sous un point de l'écran, ou null hors de la carte. +export function screenToCell(sx, sy) { + const x = Math.floor((sx - camera.ox) / tilePx()); + const y = Math.floor((sy - camera.oy) / tilePx()); + return x >= 0 && x < camera.cols && y >= 0 && y < camera.rows ? { x, y } : null; +} + +// Cases visibles (bornes incluses) : on ne dessine que celles-là. +export function visibleRange() { + const s = tilePx(); + return { + x0: Math.max(0, Math.floor(-camera.ox / s)), + x1: Math.min(camera.cols - 1, Math.floor((camera.w - camera.ox) / s)), + y0: Math.max(0, Math.floor(-camera.oy / s)), + y1: Math.min(camera.rows - 1, Math.floor((camera.h - camera.oy) / s)), + }; +} diff --git a/src/data/buildings.js b/src/data/buildings.js new file mode 100644 index 0000000..79be6ec --- /dev/null +++ b/src/data/buildings.js @@ -0,0 +1,92 @@ +// Registre des bâtiments, chargé depuis assets/buildings//building.json + sprite. +// Le nom du dossier est l'id du bâtiment (c'est lui qui est sauvegardé dans la grille). +// Les clés inconnues du JSON sont conservées telles quelles (électricité, coût…), +// donc de nouveaux champs n'exigent aucun changement ici. +// +// building.json : +// name : nom affiché dans la liste du marteau +// sprite : nom du PNG dans le dossier (défaut : sprite.png) +// anim : (optionnel) comment il s'anime +// rotate : PNG 32x64, rotor en haut (tourne autour de pivot), base + moyeu en bas +// { "type": "rotate", "speed": rad/s, "pivot": [x, y] } +// frames : PNG 32 x (32 * frames), images empilées, jouées en boucle +// { "type": "frames", "frames": N, "fps": images/s } +// (sans anim : PNG 32x32 statique) +// fallback : { "color", "label" } affichés si le PNG est introuvable +export const BUILDINGS = {}; + +const DIR = 'assets/buildings/'; +const TILE = 32; // doit rester égal à TILE de render.js + +// Dimensions attendues du PNG selon le type d'animation. +const SIZES = { + none: () => [TILE, TILE], + rotate: () => [TILE, TILE * 2], + frames: a => [TILE, TILE * a.frames], +}; + +function loadImage(url) { + return new Promise((resolve, reject) => { + const img = new Image(); + img.onload = () => resolve(img); + img.onerror = () => reject(new Error(`image introuvable : ${url}`)); + img.src = url; + }); +} + +// Valeurs par défaut + suppression des animations invalides (le bâtiment reste affichable). +function normalizeAnim(id, def) { + const a = def.anim; + if (!a) return; + if (a.type === 'rotate') { + a.speed ??= 1; + a.pivot ??= [16, 16]; + } else if (a.type === 'frames') { + a.fps ??= 4; + if (!Number.isInteger(a.frames) || a.frames < 1) { + console.warn(`[${id}] anim "frames" : "frames" doit être un entier >= 1, animation ignorée`); + delete def.anim; + } + } else { + console.warn(`[${id}] type d'animation inconnu « ${a.type} », animation ignorée`); + delete def.anim; + } +} + +function checkSize(id, def) { + if (!def.img) return; + const type = def.anim?.type ?? 'none'; + const [w, h] = SIZES[type](def.anim); + if (def.img.width !== w || def.img.height !== h) { + console.warn(`[${id}] sprite ${def.img.width}x${def.img.height}, attendu ${w}x${h} (${type})`); + } +} + +async function loadOne(id) { + try { + const res = await fetch(`${DIR}${id}/building.json`); + if (!res.ok) throw new Error(`building.json : HTTP ${res.status}`); + const def = await res.json(); + def.id = id; + def.name ??= id; + normalizeAnim(id, def); + def.img = await loadImage(`${DIR}${id}/${def.sprite ?? 'sprite.png'}`) + .catch(e => { console.warn(`[${id}] ${e.message}`); return null; }); + checkSize(id, def); + return def; + } catch (e) { + console.warn(`Bâtiment « ${id} » ignoré : ${e.message}`); + return null; + } +} + +export async function loadBuildings() { + let ids = []; + try { + ids = await (await fetch(`${DIR}index.json`)).json(); + } catch (e) { + console.error(`Impossible de lire ${DIR}index.json :`, e); + } + const defs = await Promise.all(ids.map(loadOne)); // l'ordre d'index.json est conservé + for (const def of defs) if (def) BUILDINGS[def.id] = def; +} diff --git a/src/data/locations.js b/src/data/locations.js new file mode 100644 index 0000000..63916ff --- /dev/null +++ b/src/data/locations.js @@ -0,0 +1 @@ +// Lieux et modificateurs (à venir) diff --git a/src/data/pipes.js b/src/data/pipes.js new file mode 100644 index 0000000..34d6d53 --- /dev/null +++ b/src/data/pipes.js @@ -0,0 +1,27 @@ +// Ressources transportées sous terre par des tuyaux. Tout se règle ici. +// L'ordre des clés est l'ordre de calcul : l'eau d'abord (elle devient de la vapeur), puis la vapeur. +// +// Dans building.json, un bâtiment les utilise ainsi (débits nominaux en unités/s) : +// "produces": { "water": 6 } ce qu'il envoie dans les tuyaux (pompe : eau, centrale : vapeur) +// "consumes": { "steam": 4 } ce qu'il puise dans les tuyaux (centrale : eau, turbine : vapeur) +// "placement": { "adjacentWater": true } à construire au bord de l'eau (pompe) +// Un bâtiment est relié aux tuyaux du bon type posés sur les cases voisines (haut, bas, gauche, droite). +// Un bâtiment qui manque de ressource tourne au prorata (rendement réduit) ; sans rien, il s'arrête. +export const RESOURCES = { + water: { + label: 'eau', + lack: "manque d'eau", + pipe: "Tuyau d'eau", + cost: 10, // € par case de tuyau + live: '#3d8bd9', dry: '#27496b', // couleur avec / sans débit + }, + steam: { + label: 'vapeur', + lack: 'manque de vapeur', + pipe: 'Conduite de vapeur', + cost: 15, + live: '#dfe4e8', dry: '#6a7075', + }, +}; + +export const RESOURCE_IDS = Object.keys(RESOURCES); diff --git a/src/data/plants.js b/src/data/plants.js new file mode 100644 index 0000000..3ac1268 --- /dev/null +++ b/src/data/plants.js @@ -0,0 +1 @@ +// Centrales : règles + forme de grille (à venir) diff --git a/src/data/world.js b/src/data/world.js new file mode 100644 index 0000000..7cf2e07 --- /dev/null +++ b/src/data/world.js @@ -0,0 +1,64 @@ +// Constantes du monde : relief et vent. Tout se règle ici. + +export const MAX_HEIGHT = 4; // altitudes 0 .. MAX_HEIGHT + +// Collines : une pour `cellsPerHill` cases (au moins `minHills`), de rayon (en cases) entre min et max. +// Plus la carte est grande, plus il y en a ; plus le rayon est grand, plus les reliefs sont larges. +export const TERRAIN = { + cellsPerHill: 90, + minHills: 3, + radius: { min: 1.3, max: 3.2 }, +}; + +// Direction de DÉPLACEMENT du vent (dx, dy) ; y augmente vers le bas. +// Un « vent d'ouest » vient de l'ouest et va vers l'est. +export const WIND_DIRS = [ + { id: 'N', label: 'du nord', arrow: '↓', dx: 0, dy: 1 }, +{ id: 'E', label: "d'est", arrow: '←', dx: -1, dy: 0 }, +{ id: 'S', label: 'du sud', arrow: '↑', dx: 0, dy: -1 }, +{ id: 'W', label: "d'ouest", arrow: '→', dx: 1, dy: 0 }, +]; + +// Rendement d'une éolienne selon le relief : +// pente face au vent (le vent monte vers elle) : bonus de perRise par niveau +// pente sous le vent (le vent descend vers elle) : malus de perRise par niveau +// sommet : le résultat est multiplié par summit +// (aucune case voisine plus haute, au moins une plus basse, altitude >= summitMinHeight) +export const WIND_RULES = { + perRise: 0.3, + summit: 0.5, + summitMinHeight: 3, + min: 0.2, + max: 2, +}; + +// Eau : lacs et mares, uniquement dans les basses terres (altitude 0), formes organiques (bruit lissé). +// coverage : part de la carte couverte, tirée au hasard entre min et max +// noiseScale : taille des taches (en cases) : petit = mares, grand = lacs +// maxShare : part maximale des cases d'altitude 0 qui peuvent devenir de l'eau +export const WATER = { + coverage: { min: 0.07, max: 0.13 }, + noiseScale: 6, + maxShare: 0.6, +}; + +// Le vent change de direction toutes les min..max secondes (max = 0 : jamais). +// Pour tester : { min: 8, max: 15 }. +export const WIND_CHANGE = { min: 90, max: 180 }; + +// Couleurs des cases selon l'altitude : fond et petits points. +export const TERRAIN_COLORS = [ + { bg: '#262829', dot: '#3a3d3f' }, +{ bg: '#2e3133', dot: '#444a4d' }, +{ bg: '#373b3e', dot: '#50565a' }, +{ bg: '#42474b', dot: '#5d646a' }, +{ bg: '#4e545a', dot: '#6a727a' }, +]; + +// Couleurs de l'eau : fond, berge (liseré côté terre) et reflets animés (r, g, b). +export const WATER_COLORS = { deep: '#1d3a55', shore: '#3a6a8c', ripple: '150, 200, 240' }; + +// Économie. +export const START_MONEY = 600; // argent au début d'une nouvelle partie (€) +export const ELECTRICITY_PRICE = 1; // € gagnés par MW produit et par seconde +export const REFUND = 0.5; // part du coût de construction rendue à la démolition diff --git a/src/designs.js b/src/designs.js new file mode 100644 index 0000000..de6e30e --- /dev/null +++ b/src/designs.js @@ -0,0 +1 @@ +// Export / import de designs (à venir) diff --git a/src/input.js b/src/input.js new file mode 100644 index 0000000..ef0fe73 --- /dev/null +++ b/src/input.js @@ -0,0 +1,126 @@ +import { state, applyTool, pipeOfTool } from './state.js'; +import { camera, screenToCell, panBy, zoomStep } from './camera.js'; + +// Cases d'une ligne entre deux cases (Bresenham) : un glissé rapide ne saute aucune case. +function* line(a, b) { + let { x, y } = a; + const dx = Math.abs(b.x - x), dy = -Math.abs(b.y - y); + const sx = x < b.x ? 1 : -1, sy = y < b.y ? 1 : -1; + let err = dx + dy; + for (;;) { + yield { x, y }; + if (x === b.x && y === b.y) return; + const e2 = 2 * err; + if (e2 >= dy) { err += dy; x += sx; } + if (e2 <= dx) { err += dx; y += sy; } + } +} + +// Seuls les tuyaux (et leur retrait sous terre) se posent en glissant : jamais les bâtiments, +// pour qu'un geste un peu large ne construise ou ne démolisse pas dix bâtiments d'un coup. +function draggable() { + return Boolean(pipeOfTool(state.tool)) || (state.tool === 'demolish' && state.mode === 'underground'); +} + +// Commandes : +// outil sélectionné : clic = construire / démolir (glisser = tuyaux) +// aucun outil : clic gauche maintenu = déplacer la vue +// clic milieu : déplace la vue même avec un outil +// molette : zoom (autour du curseur) clic droit : désélectionne l'outil +// tactile : un doigt comme la souris, deux doigts = déplacer + pincer pour zoomer +export function initInput(canvas, { onCancel } = {}) { + const pointers = new Map(); // pointerId -> position à l'écran, pour les pointeurs enfoncés + let mode = null; // null | 'pan' | 'build' + let last = null; // dernière case traitée pendant un glissé de pose + let pinch = null; // { mx, my, dist } : état du geste à deux doigts + let wheelAcc = 0; + + // Position du pointeur dans le canvas (en pixels du canvas). + function screen(e) { + const r = canvas.getBoundingClientRect(); + return { x: (e.clientX - r.left) * canvas.width / r.width, y: (e.clientY - r.top) * canvas.height / r.height }; + } + const cellAt = e => { const p = screen(e); return screenToCell(p.x, p.y); }; + + function begin(m) { + mode = m; + camera.dragging = m === 'pan'; + } + + function pinchState() { + const [a, b] = [...pointers.values()]; + return { mx: (a.x + b.x) / 2, my: (a.y + b.y) / 2, dist: Math.hypot(a.x - b.x, a.y - b.y) || 1 }; + } + + canvas.addEventListener('pointerdown', e => { + pointers.set(e.pointerId, screen(e)); + canvas.setPointerCapture?.(e.pointerId); + + if (pointers.size === 2) { begin(null); last = null; pinch = pinchState(); return; } + if (pointers.size > 2) return; + + if (e.button === 1) { begin('pan'); return; } + if (e.button !== 0) return; + if (!state.tool) { begin('pan'); return; } + + begin('build'); + state.hover = cellAt(e); + last = state.hover; + if (state.hover) applyTool(state.hover.x, state.hover.y); + }); + + canvas.addEventListener('pointermove', e => { + const prev = pointers.get(e.pointerId); + const p = screen(e); + if (prev) pointers.set(e.pointerId, p); + + if (pinch && pointers.size === 2) { + const now = pinchState(); + panBy(now.mx - pinch.mx, now.my - pinch.my); + const ratio = now.dist / pinch.dist; + if (ratio > 1.3 || ratio < 0.77) { zoomStep(ratio > 1 ? 1 : -1, now.mx, now.my); pinch.dist = now.dist; } + pinch.mx = now.mx; + pinch.my = now.my; + } else if (mode === 'pan' && prev) { + panBy(p.x - prev.x, p.y - prev.y); + } + + state.hover = screenToCell(p.x, p.y); + + if (mode === 'build' && state.hover && draggable()) { + const from = last ?? state.hover; + if (from.x === state.hover.x && from.y === state.hover.y) return; + for (const c of line(from, state.hover)) { + if (c.x === from.x && c.y === from.y) continue; // déjà traitée + applyTool(c.x, c.y); + } + last = state.hover; + } + }); + + function release(e) { + pointers.delete(e.pointerId); + if (pointers.size < 2) pinch = null; + if (pointers.size === 0) { begin(null); last = null; } + } + canvas.addEventListener('pointerup', release); + canvas.addEventListener('pointercancel', release); + canvas.addEventListener('pointerleave', () => { if (pointers.size === 0) state.hover = null; }); + + // Molette : un cran de zoom par « clic » de molette (cumul pour les pavés tactiles). + canvas.addEventListener('wheel', e => { + e.preventDefault(); + wheelAcc += e.deltaY * (e.deltaMode === 1 ? 16 : 1); + if (Math.abs(wheelAcc) < 40) return; + const p = screen(e); + zoomStep(wheelAcc < 0 ? 1 : -1, p.x, p.y); + wheelAcc = 0; + state.hover = screenToCell(p.x, p.y); + }, { passive: false }); + + canvas.addEventListener('mousedown', e => { if (e.button === 1) e.preventDefault(); }); // pas de défilement automatique + canvas.addEventListener('contextmenu', e => { + e.preventDefault(); + if (state.tool) onCancel?.(); + }); +} diff --git a/src/main.js b/src/main.js new file mode 100644 index 0000000..424e88c --- /dev/null +++ b/src/main.js @@ -0,0 +1,66 @@ +import { state, newGame, load, hasSave, save } from './state.js'; +import { update } from './sim.js'; +import { loadBuildings } from './data/buildings.js'; +import { render } from './render.js'; +import { camera, setMap, resizeView, centerCamera } from './camera.js'; +import { initUI, showGame, showMenu, updateHud, setTool } from './ui.js'; +import { initInput } from './input.js'; + +const canvas = document.getElementById('canvas'); +const ctx = canvas.getContext('2d'); + +const AUTOSAVE_EVERY = 5; // secondes + +// Le canvas remplit sa zone d'affichage : sa résolution suit sa taille à l'écran (1 pixel = 1 pixel CSS). +function fitCanvas() { + const w = Math.floor(canvas.clientWidth), h = Math.floor(canvas.clientHeight); + if (w < 1 || h < 1) return; + if (canvas.width !== w || canvas.height !== h) { canvas.width = w; canvas.height = h; } + resizeView(w, h); +} + +let running = false; +let last = 0; +let untilSave = AUTOSAVE_EVERY; + +function frame(now) { + if (!running) return; + const dt = Math.min((now - last) / 1000, 0.1); // plafonné si l'onglet était en pause + last = now; + update(state, dt); + render(ctx, state); + const cursor = state.tool ? 'crosshair' : (camera.dragging ? 'grabbing' : 'grab'); + if (canvas.style.cursor !== cursor) canvas.style.cursor = cursor; + updateHud(state); + if ((untilSave -= dt) <= 0) { save(); untilSave = AUTOSAVE_EVERY; } + requestAnimationFrame(frame); +} + +function start() { + showGame(); // la zone doit être visible avant de mesurer le canvas + setMap(state.grid[0].length, state.grid.length); + fitCanvas(); + centerCamera(); + running = true; + untilSave = AUTOSAVE_EVERY; + last = performance.now(); + requestAnimationFrame(frame); +} + +await loadBuildings(); + +initInput(canvas, { onCancel: () => setTool(null) }); +new ResizeObserver(() => { if (running) fitCanvas(); }).observe(canvas.parentElement); +initUI({ + onNew: () => { + if (hasSave() && !confirm('Une sauvegarde existe déjà. La remplacer ?')) return; + newGame(); + start(); + }, + onContinue: () => { if (load()) start(); }, + onMenu: () => { running = false; save(); showMenu(); }, +}); + +// L'argent évolue en continu : on sauvegarde aussi quand la page est cachée ou fermée. +window.addEventListener('pagehide', () => { if (running) save(); }); +document.addEventListener('visibilitychange', () => { if (document.hidden && running) save(); }); diff --git a/src/render.js b/src/render.js new file mode 100644 index 0000000..fc0e1f9 --- /dev/null +++ b/src/render.js @@ -0,0 +1,336 @@ +import { BUILDINGS } from './data/buildings.js'; +import { TERRAIN_COLORS, WATER_COLORS } from './data/world.js'; +import { RESOURCES } from './data/pipes.js'; +import { windAt } from './terrain.js'; +import { placeCheck, pipeOfTool, nearWater } from './state.js'; +import { TILE, camera, visibleRange } from './camera.js'; + +export { TILE }; + +// Le relief ne change pas pendant une partie : on le dessine une fois dans une image hors écran +// (recréée quand la carte change), puis chaque image n'en fait qu'un seul drawImage. +let terrainCache = null; // { terrain, water, canvas } + +function makeCanvas(w, h) { + if (typeof OffscreenCanvas !== 'undefined') return new OffscreenCanvas(w, h); + const c = document.createElement('canvas'); + c.width = w; + c.height = h; + return c; +} + +function terrainLayer(state) { + if (terrainCache?.terrain === state.terrain && terrainCache.water === state.water) return terrainCache.canvas; + const rows = state.terrain.length, cols = state.terrain[0].length; + const canvas = makeCanvas(cols * TILE, rows * TILE); + const c = canvas.getContext('2d'); + for (let y = 0; y < rows; y++) for (let x = 0; x < cols; x++) drawTerrain(c, state.terrain, x, y); + terrainCache = { terrain: state.terrain, water: state.water, canvas }; + return canvas; +} + +// Case de terrain : couleur selon l'altitude, points, liserés de relief. +function drawTerrain(ctx, terrain, x, y) { + const px = x * TILE, py = y * TILE; + const h = terrain[y][x]; + const { bg, dot } = TERRAIN_COLORS[Math.min(h, TERRAIN_COLORS.length - 1)]; + + ctx.fillStyle = bg; + ctx.fillRect(px, py, TILE, TILE); + + // quelques points, positions fixes dérivées des coordonnées (pas de scintillement) + const k = (Math.imul(x + 1, 73856093) ^ Math.imul(y + 1, 19349663)) >>> 0; + ctx.fillStyle = dot; + ctx.fillRect(px + 4 + (k % 24), py + 4 + ((k >>> 5) % 24), 2, 2); + ctx.fillRect(px + 4 + ((k >>> 10) % 24), py + 4 + ((k >>> 15) % 24), 2, 2); + + // relief : liseré clair au nord/ouest, sombre au sud/est, là où la case voisine est plus basse + const lower = (dx, dy) => (terrain[y + dy]?.[x + dx] ?? h) < h; + ctx.fillStyle = 'rgba(255, 255, 255, 0.12)'; + if (lower(0, -1)) ctx.fillRect(px, py, TILE, 2); + if (lower(-1, 0)) ctx.fillRect(px, py, 2, TILE); + ctx.fillStyle = 'rgba(0, 0, 0, 0.35)'; + if (lower(0, 1)) ctx.fillRect(px, py + TILE - 2, TILE, 2); + if (lower(1, 0)) ctx.fillRect(px + TILE - 2, py, 2, TILE); + + ctx.strokeStyle = '#1c1c1c'; + ctx.strokeRect(px + 0.5, py + 0.5, TILE - 1, TILE - 1); +} + +// Eau : forme arrondie aux angles « convexes » (là où deux côtés touchent la terre), berge claire côté terre, +// reflets qui scintillent doucement. Les bords de la carte comptent comme de l'eau (le lac continue au-delà). +const WATER_R = 10; // rayon des angles arrondis +const BANK = 2; // largeur de la berge (px) + +function drawWater(ctx, water, x, y, t) { + const isWater = (dx, dy) => water[y + dy]?.[x + dx] ?? true; + const l = !isWater(-1, 0), r = !isWater(1, 0), u = !isWater(0, -1), d = !isWater(0, 1); + const px = x * TILE, py = y * TILE; + + const shape = inset => { + const x0 = px + (l ? inset : 0), x1 = px + TILE - (r ? inset : 0); + const y0 = py + (u ? inset : 0), y1 = py + TILE - (d ? inset : 0); + const rad = Math.max(0, WATER_R - inset); + const tl = u && l ? rad : 0, tr = u && r ? rad : 0, br = d && r ? rad : 0, bl = d && l ? rad : 0; + ctx.beginPath(); + ctx.moveTo(x0 + tl, y0); + ctx.lineTo(x1 - tr, y0); if (tr) ctx.arcTo(x1, y0, x1, y0 + tr, tr); + ctx.lineTo(x1, y1 - br); if (br) ctx.arcTo(x1, y1, x1 - br, y1, br); + ctx.lineTo(x0 + bl, y1); if (bl) ctx.arcTo(x0, y1, x0, y1 - bl, bl); + ctx.lineTo(x0, y0 + tl); if (tl) ctx.arcTo(x0, y0, x0 + tl, y0, tl); + ctx.closePath(); + }; + + ctx.fillStyle = WATER_COLORS.shore; + shape(0); ctx.fill(); + ctx.fillStyle = WATER_COLORS.deep; + shape(BANK); ctx.fill(); + + // reflets : positions fixes par case, intensité qui pulse (légèrement déphasée d'une case à l'autre) + const k = (Math.imul(x + 7, 83492791) ^ Math.imul(y + 3, 2654435761)) >>> 0; + for (let i = 0; i < 2; i++) { + const a = 0.08 + 0.14 * (0.5 + 0.5 * Math.sin(t * 1.6 + (k >>> (i * 7)) % 628 / 100)); + ctx.fillStyle = `rgba(${WATER_COLORS.ripple}, ${a})`; + ctx.fillRect(px + 8 + ((k >>> (i * 9)) % 11), py + 8 + ((k >>> (i * 9 + 4)) % 15), 6, 1); + } +} + +// Affiché quand le PNG du bâtiment est introuvable. +function drawFallback(ctx, def, px, py) { + const { color = '#888888', label = def.name[0] } = def.fallback ?? {}; + ctx.fillStyle = color; + ctx.fillRect(px, py, TILE, TILE); + ctx.fillStyle = '#000'; + ctx.font = 'bold 16px monospace'; + ctx.textAlign = 'center'; + ctx.fillText(label, px + TILE / 2, py + TILE / 2 + 6); +} + +function drawStatic(ctx, img, px, py) { + ctx.drawImage(img, 0, 0, TILE, TILE, px, py, TILE, TILE); +} + +// rotate : PNG 32x64, rotor en haut (pivot au moyeu), base + moyeu en bas. +function drawRotor(ctx, img, px, py, cell, anim) { + const [cx, cy] = anim.pivot; + ctx.drawImage(img, 0, TILE, TILE, TILE, px, py, TILE, TILE); // base + ctx.save(); + ctx.translate(px + cx, py + cy); + ctx.rotate(cell.angle || 0); + ctx.drawImage(img, 0, 0, TILE, TILE, -cx, -cy, TILE, TILE); // rotor + ctx.restore(); + ctx.drawImage(img, cx - 1, TILE + cy - 1, 2, 2, px + cx - 1, py + cy - 1, 2, 2); // moyeu par-dessus +} + +// frames : images 32x32 empilées verticalement, une par valeur entière de cell.phase. +function drawFrames(ctx, img, px, py, cell, anim) { + const f = Math.floor(cell.phase || 0) % anim.frames; + ctx.drawImage(img, 0, f * TILE, TILE, TILE, px, py, TILE, TILE); +} + +const DRAWERS = { rotate: drawRotor, frames: drawFrames }; + +// cell = case de la grille ({ type, angle, phase }), ou {} pour un aperçu / une icône. +function drawBuilding(ctx, id, px, py, cell) { + const def = BUILDINGS[id]; + if (!def) return; // type inconnu (ancienne sauvegarde) + if (!def.img) return drawFallback(ctx, def, px, py); + const draw = DRAWERS[def.anim?.type] || drawStatic; + draw(ctx, def.img, px, py, cell, def.anim); +} + +// Icône 32x32 d'un bâtiment (pour la liste du marteau), sans transformation. +export function drawBuildingIcon(ctx, id) { + ctx.clearRect(0, 0, TILE, TILE); + ctx.imageSmoothingEnabled = false; + drawBuilding(ctx, id, 0, 0, {}); +} + +// Pastille d'état (en haut à droite) + barre de temps avant l'entretien (en bas). +function drawStatus(ctx, cell, def, px, py) { + const bx = px + TILE - 10, by = py + 2; + if (cell.status === 'unmanaged') { // « ! » rouge : pas assez de bureaux + ctx.fillStyle = '#c03030'; + ctx.fillRect(bx, by, 8, 8); + ctx.fillStyle = '#fff'; + ctx.fillRect(bx + 3, by + 1, 2, 4); + ctx.fillRect(bx + 3, by + 6, 2, 1); + } else if (cell.status === 'running' && cell.starved) { // « ! » à la couleur de la ressource qui manque + ctx.fillStyle = RESOURCES[cell.starved].live; + ctx.fillRect(bx, by, 8, 8); + ctx.fillStyle = '#10151a'; + ctx.fillRect(bx + 3, by + 1, 2, 4); + ctx.fillRect(bx + 3, by + 6, 2, 1); + } else if (cell.status === 'maintenance') { // clé orange : en entretien + ctx.fillStyle = '#d98a1f'; + ctx.fillRect(bx, by, 8, 8); + ctx.fillStyle = '#fff'; + for (let i = 0; i < 5; i++) ctx.fillRect(bx + 1 + i, by + 6 - i, 1, 1); + ctx.fillRect(bx + 5, by + 1, 2, 2); + } + + const m = def.maintenance; + if (!m?.every || cell.status === 'unmanaged') return; + const maint = cell.status === 'maintenance'; + const frac = Math.max(0, Math.min(1, maint ? cell.maint / m.duration : (cell.mt ?? m.every) / m.every)); + const w = TILE - 4; + ctx.fillStyle = 'rgba(0, 0, 0, 0.55)'; + ctx.fillRect(px + 2, py + TILE - 2, w, 2); + ctx.fillStyle = maint || frac < 0.25 ? '#d98a1f' : '#4caf50'; + ctx.fillRect(px + 2, py + TILE - 2, w * frac, 2); +} + +// Outil dépendant du vent : cases vertes = bon rendement, rouges = mauvais. +function drawWindOverlay(ctx, state) { + if (!BUILDINGS[state.tool]?.power?.scalesWithWind) return; + const { x0, x1, y0, y1 } = visibleRange(); + for (let y = y0; y <= y1; y++) for (let x = x0; x <= x1; x++) { + if (state.grid[y][x] || state.water[y][x]) continue; + const f = windAt(state.terrain, x, y, state.wind.dir).factor; + if (f >= 1.15) ctx.fillStyle = 'rgba(80, 200, 90, 0.30)'; + else if (f <= 0.85) ctx.fillStyle = 'rgba(220, 60, 50, 0.30)'; + else continue; + ctx.fillRect(x * TILE, y * TILE, TILE, TILE); + } +} + +// Outil à construire au bord de l'eau (pompe) : cases possibles en bleu. +function drawPlacementOverlay(ctx, state) { + if (!BUILDINGS[state.tool]?.placement?.adjacentWater) return; + const { x0, x1, y0, y1 } = visibleRange(); + ctx.fillStyle = 'rgba(61, 139, 217, 0.30)'; + for (let y = y0; y <= y1; y++) for (let x = x0; x <= x1; x++) { + if (!state.grid[y][x] && !state.water[y][x] && nearWater(x, y)) ctx.fillRect(x * TILE, y * TILE, TILE, TILE); + } +} + +// ---------- Tuyaux (vue sous-terre) ---------- + +const NEIGHBORS = [[0, -1], [0, 1], [-1, 0], [1, 0]]; // haut, bas, gauche, droite +const PW = 6; // épaisseur d'un tuyau (px) +const PO = (TILE - PW) / 2; + +// Rectangles d'un tuyau de type `res` en (x, y) : le centre + un bras vers chaque voisin relié +// (autre tuyau du même type, ou bâtiment qui produit / consomme cette ressource). +function pipeRects(state, x, y, res) { + const [u, d, l, r] = NEIGHBORS.map(([dx, dy]) => { + const nx = x + dx, ny = y + dy; + if (state.pipes[ny]?.[nx] === res) return true; + const def = BUILDINGS[state.grid[ny]?.[nx]?.type]; + return def?.produces?.[res] != null || def?.consumes?.[res] != null; + }); + const rects = [[PO, PO, PW, PW]]; + if (u) rects.push([PO, 0, PW, PO]); + if (d) rects.push([PO, PO + PW, PW, PO]); + if (l) rects.push([0, PO, PO, PW]); + if (r) rects.push([PO + PW, PO, PO, PW]); + return rects; +} + +function strokeRects(ctx, px, py, rects) { // contour sombre, sans déborder de la case + ctx.fillStyle = '#0b0f14'; + for (const [rx, ry, rw, rh] of rects) { + const x0 = Math.max(0, rx - 1), y0 = Math.max(0, ry - 1); + const x1 = Math.min(TILE, rx + rw + 1), y1 = Math.min(TILE, ry + rh + 1); + ctx.fillRect(px + x0, py + y0, x1 - x0, y1 - y0); + } +} + +function fillRects(ctx, px, py, rects, color) { + ctx.fillStyle = color; + for (const [rx, ry, rw, rh] of rects) ctx.fillRect(px + rx, py + ry, rw, rh); +} + +// Deux passes (contours puis remplissage) pour que les jonctions entre cases restent propres. +function drawPipes(ctx, state, t) { + const tiles = []; + const { x0, x1, y0, y1 } = visibleRange(); + for (let y = y0; y <= y1; y++) for (let x = x0; x <= x1; x++) { + const res = state.pipes[y][x]; + if (res) tiles.push({ x, y, res, rects: pipeRects(state, x, y, res) }); + } + for (const { x, y, rects } of tiles) strokeRects(ctx, x * TILE, y * TILE, rects); + for (const { x, y, res, rects } of tiles) { + const live = (state.pipeNet[y]?.[x]?.supply ?? 0) > 0; + fillRects(ctx, x * TILE, y * TILE, rects, live ? RESOURCES[res].live : RESOURCES[res].dry); + if (live && Math.floor(t * 4 + x + y) % 3 === 0) { // reflet qui court le long du réseau + ctx.fillStyle = 'rgba(255, 255, 255, 0.45)'; + ctx.fillRect(x * TILE + PO + 2, y * TILE + PO + 2, 2, 2); + } + } +} + +// Icône 32x32 d'un type de tuyau (liste des outils). +export function drawPipeIcon(ctx, res) { + ctx.clearRect(0, 0, TILE, TILE); + const rects = [[0, PO, TILE, PW], [PO, PO, PW, TILE - PO]]; // un « T » : horizontal + branche vers le bas + strokeRects(ctx, 0, 0, rects); + fillRects(ctx, 0, 0, rects, RESOURCES[res].live); +} + +// Case survolée : aperçu translucide + contour (orange = valide, rouge = impossible). +function drawHover(ctx, state) { + const { hover, tool } = state; + if (!hover || !tool) return; + const px = hover.x * TILE, py = hover.y * TILE; + const ok = !placeCheck(tool, hover.x, hover.y); + const demolish = tool === 'demolish'; + const res = pipeOfTool(tool); + + if (!demolish && ok) { + ctx.globalAlpha = 0.5; + if (res) { + const rects = pipeRects(state, hover.x, hover.y, res); + strokeRects(ctx, px, py, rects); + fillRects(ctx, px, py, rects, RESOURCES[res].live); + } else { + drawBuilding(ctx, tool, px, py, {}); + } + ctx.globalAlpha = 1; + } + ctx.strokeStyle = demolish ? (ok ? '#c03030' : '#555') : (ok ? '#e0603a' : '#c03030'); + ctx.lineWidth = 2; + ctx.strokeRect(px + 1, py + 1, TILE - 2, TILE - 2); +} + +export function render(ctx, state) { + const { zoom, ox, oy } = camera; + ctx.setTransform(1, 0, 0, 1, 0, 0); + ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height); + ctx.setTransform(zoom, 0, 0, zoom, ox, oy); + ctx.imageSmoothingEnabled = false; + + const t = performance.now() / 1000; + const under = state.mode === 'underground'; // vue sous-terre : sol assombri, bâtiments en filigrane, tuyaux visibles + const { x0, x1, y0, y1 } = visibleRange(); + + ctx.drawImage(terrainLayer(state), 0, 0); + if (under) { + ctx.fillStyle = 'rgba(52, 33, 18, 0.58)'; + ctx.fillRect(0, 0, state.grid[0].length * TILE, state.grid.length * TILE); + } + + for (let y = y0; y <= y1; y++) for (let x = x0; x <= x1; x++) { + if (state.water[y][x]) { // on ne construit pas sur l'eau + drawWater(ctx, state.water, x, y, t); + if (under) { ctx.fillStyle = 'rgba(0, 0, 0, 0.3)'; ctx.fillRect(x * TILE, y * TILE, TILE, TILE); } + continue; + } + const cell = state.grid[y][x]; + if (!cell) continue; + const idle = cell.status === 'unmanaged' || cell.status === 'maintenance'; + if (under) ctx.globalAlpha = 0.35; + else if (idle) ctx.globalAlpha = 0.45; + drawBuilding(ctx, cell.type, x * TILE, y * TILE, cell); + ctx.globalAlpha = 1; + const def = BUILDINGS[cell.type]; + if (def) drawStatus(ctx, cell, def, x * TILE, y * TILE); + } + + if (under) drawPipes(ctx, state, t); + else { + drawWindOverlay(ctx, state); + drawPlacementOverlay(ctx, state); + } + drawHover(ctx, state); +} diff --git a/src/sim.js b/src/sim.js new file mode 100644 index 0000000..d81d8c9 --- /dev/null +++ b/src/sim.js @@ -0,0 +1,155 @@ +// Simulation : aucun accès au DOM ni au canvas. +import { BUILDINGS } from './data/buildings.js'; +import { WIND_CHANGE, ELECTRICITY_PRICE } from './data/world.js'; +import { RESOURCE_IDS } from './data/pipes.js'; +import { windAt, pickWindDir, nextWindDelay } from './terrain.js'; + +const TAU = Math.PI * 2; +const NEIGHBORS = [[0, -1], [0, 1], [-1, 0], [1, 0]]; + +// Un animateur par type d'animation. cell.eff = rendement de la case, il module la vitesse. +// rotate → cell.angle (radians) frames → cell.phase (0 .. frames, partie entière = image) +const ANIMATORS = { + rotate: (cell, a, dt) => { cell.angle = ((cell.angle || 0) + a.speed * (cell.eff ?? 1) * dt) % TAU; }, + frames: (cell, a, dt) => { cell.phase = ((cell.phase || 0) + a.fps * (cell.eff ?? 1) * dt) % a.frames; }, +}; + +function updateWind(state, dt) { + if (!(WIND_CHANGE.max > 0)) return; + state.wind.timer -= dt; + if (state.wind.timer <= 0) { + state.wind.dir = pickWindDir(state.wind.dir); + state.wind.timer = nextWindDelay(); + } +} + +function tickNotice(state, dt) { + if (state.notice && (state.notice.ttl -= dt) <= 0) state.notice = null; +} + +// Tout bâtiment occupe un poste de bureau, sauf les bureaux eux-mêmes ou ceux qui déclarent +// "requiresOffice": false dans leur building.json. +function needsOffice(def) { + return def.requiresOffice ?? !def.office; +} + +// Entretien : le coût est payé tout de suite (l'argent peut passer sous zéro), +// puis le bâtiment s'arrête `duration` secondes. duration 0 : le coût seul (ex. salaires). +function startMaintenance(state, cell, m) { + state.money -= m.cost ?? 0; + cell.mt = m.every; + cell.maint = m.duration > 0 ? m.duration : null; + if (cell.maint != null) { cell.status = 'maintenance'; cell.eff = 0; } +} + +// Une ressource (eau, vapeur) : on regroupe les tuyaux de ce type en réseaux (cases voisines) ; +// un bâtiment qui produit ou consomme cette ressource se relie aux tuyaux posés sur ses cases voisines. +// Dans chaque réseau, l'offre (producteurs) est répartie entre les demandes (consommateurs) : +// satisfaction = min(1, offre / demande). Un consommateur voit son rendement multiplié par sa satisfaction. +// Les producteurs fournissent selon leur rendement actuel : une centrale privée d'eau ne fait pas de vapeur. +function flowStage(state, active, res) { + const rows = state.grid.length, cols = state.grid[0].length, N = rows * cols; + const pipeAt = (x, y) => state.pipes[y]?.[x] === res; + + // Union-find : nœuds 0..N-1 = tuyaux (par case), N..2N-1 = bâtiments (par case). + const parent = Int32Array.from({ length: 2 * N }, (_, i) => i); + const find = i => { while (parent[i] !== i) { parent[i] = parent[parent[i]]; i = parent[i]; } return i; }; + const union = (a, b) => { parent[find(a)] = find(b); }; + + for (let y = 0; y < rows; y++) for (let x = 0; x < cols; x++) { + if (!pipeAt(x, y)) continue; + const i = y * cols + x; + if (pipeAt(x + 1, y)) union(i, i + 1); + if (pipeAt(x, y + 1)) union(i, i + cols); + } + + const users = active.filter(({ def }) => def.produces?.[res] != null || def.consumes?.[res] != null); + for (const { x, y } of users) { + for (const [dx, dy] of NEIGHBORS) if (pipeAt(x + dx, y + dy)) union(N + y * cols + x, (y + dy) * cols + x + dx); + } + + const nets = new Map(); + const netOf = node => { + const root = find(node); + if (!nets.has(root)) nets.set(root, { supply: 0, demand: 0 }); + return nets.get(root); + }; + + for (const { cell, def, x, y } of users) { + const net = netOf(N + y * cols + x); + net.supply += (def.produces?.[res] ?? 0) * cell.eff; + net.demand += (def.consumes?.[res] ?? 0) * cell.eff; + } + + for (const { cell, def, x, y } of users) { + if (def.consumes?.[res] == null || !(cell.eff > 0)) continue; + const { supply, demand } = netOf(N + y * cols + x); + const sat = Math.min(1, supply / demand); + if (sat < 1) { cell.eff *= sat; cell.starved = res; } + } + + for (let y = 0; y < rows; y++) for (let x = 0; x < cols; x++) { + if (pipeAt(x, y)) state.pipeNet[y][x] = netOf(y * cols + x); + } +} + +// État d'une case (cell.status) : +// running : produit, s'anime, son compte à rebours d'entretien avance +// maintenance : à l'arrêt pendant l'entretien +// unmanaged : pas assez de bureaux, à l'arrêt, ses compteurs sont gelés +// cell.starved : ressource qui manque à une case « running » (ou null) ; cell.eff : rendement final. +export function update(state, dt) { + updateWind(state, dt); + tickNotice(state, dt); + + const items = []; + state.grid.forEach((row, y) => row.forEach((cell, x) => { + const def = cell && BUILDINGS[cell.type]; + if (def) items.push({ cell, def, x, y }); + })); + items.sort((a, b) => a.cell.order - b.cell.order); // les premiers construits sont gérés en premier + + const capacity = items.reduce((n, it) => n + (it.def.office?.capacity ?? 0), 0); + let need = 0; + let power = 0; + + // 1. Qui fonctionne ? (bureaux, entretien) et rendement de départ (vent). + const active = []; + for (const it of items) { + const { cell, def, x, y } = it; + cell.starved = null; + const managed = !needsOffice(def) || ++need <= capacity; + + if (!managed) { cell.status = 'unmanaged'; cell.eff = 0; continue; } + + if (cell.maint != null) { + cell.status = 'maintenance'; + cell.eff = 0; + cell.maint -= dt; + if (cell.maint <= 0) cell.maint = null; + continue; + } + + cell.status = 'running'; + cell.eff = def.power?.scalesWithWind ? windAt(state.terrain, x, y, state.wind.dir).factor : 1; + active.push(it); + } + + // 2. Eau, puis vapeur : le rendement des consommateurs baisse s'il manque de ressource. + state.pipeNet = state.grid.map(row => row.map(() => null)); + for (const res of RESOURCE_IDS) flowStage(state, active, res); + + // 3. Électricité, animations, compte à rebours d'entretien. + for (const { cell, def } of active) { + if (def.power) power += (def.power.output ?? 0) * cell.eff; + if (def.anim) ANIMATORS[def.anim.type]?.(cell, def.anim, dt); + + const m = def.maintenance; + if (m?.every && cell.mt != null && (cell.mt -= dt) <= 0) startMaintenance(state, cell, m); + } + + state.power = power; + state.income = power * ELECTRICITY_PRICE; + state.money += state.income * dt; + state.slots = { used: Math.min(need, capacity), capacity, need }; +} diff --git a/src/state.js b/src/state.js new file mode 100644 index 0000000..4abe076 --- /dev/null +++ b/src/state.js @@ -0,0 +1,199 @@ +import { genTerrain, genWater, pickWindDir, nextWindDelay } from './terrain.js'; +import { BUILDINGS } from './data/buildings.js'; +import { RESOURCES } from './data/pipes.js'; +import { START_MONEY, REFUND } from './data/world.js'; + +const KEY = 'reactor.save.v1'; +const COLS = 50; +const ROWS = 50; +const TAU = Math.PI * 2; + +// Sauvegardé : grid (type, order, mt, maint), terrain, water, pipes, wind.dir, money, counter. +// Non sauvegardé : le reste (calculé par la simulation ou lié à l'interface). +export const state = { + grid: [], + terrain: [], + water: [], // water[y][x] = true : case d'eau (non constructible) + pipes: [], // pipes[y][x] = null | 'water' | 'steam' : tuyau sous terre (un par case) + pipeNet: [], // calculé : { supply, demand } du réseau auquel appartient chaque tuyau + mode: 'surface', // 'surface' | 'underground' : vue affichée et outils proposés + wind: { dir: 0, timer: 0 }, // dir = index dans WIND_DIRS, timer = secondes avant changement + money: START_MONEY, // € (peut devenir négatif : entretien payé à crédit) + counter: 1, // prochain numéro d'ordre de construction + power: 0, // production totale (MW) + income: 0, // ventes d'électricité (€/s) + slots: { used: 0, capacity: 0, need: 0 }, // postes de gestion + notice: null, // message temporaire { text, ttl } + tool: null, // null | id d'un bâtiment | 'pipe:' | 'demolish' + hover: null, // case survolée { x, y } ou null +}; + +function emptyGrid() { + return Array.from({ length: ROWS }, () => Array(COLS).fill(null)); +} + +// Délai avant le premier entretien : l'intervalle + un peu de hasard, pour désynchroniser. +function firstMaintenance(type) { + const every = BUILDINGS[type]?.maintenance?.every; + return every ? every * (1 + Math.random() * 0.2) : null; +} + +// order = ordre de construction : les premiers construits sont les premiers gérés par les bureaux. +// mt = secondes avant le prochain entretien, maint = secondes d'entretien restantes (ou null). +function makeCell(type, order, mt, maint) { + return { + type, + order, + angle: Math.random() * TAU, // départ aléatoire : pas d'animations en phase + phase: Math.random() * 1000, + mt: mt ?? firstMaintenance(type), + maint: maint ?? null, + }; +} + +export function notify(text) { + state.notice = { text, ttl: 2.5 }; +} + +export function newGame() { + state.grid = emptyGrid(); + state.terrain = genTerrain(COLS, ROWS); + state.water = genWater(state.terrain, null, true); // true : peut creuser des vallées d'altitude 1 + state.pipes = emptyGrid(); + state.mode = 'surface'; + state.wind = { dir: pickWindDir(), timer: nextWindDelay() }; + state.money = START_MONEY; + state.counter = 1; + state.power = 0; + state.income = 0; + state.notice = null; + save(); +} + +const NEIGHBORS = [[0, -1], [0, 1], [-1, 0], [1, 0]]; + +export function nearWater(x, y) { + return NEIGHBORS.some(([dx, dy]) => state.water[y + dy]?.[x + dx]); +} + +// 'pipe:water' → 'water' ; autre outil → null +export function pipeOfTool(tool) { + return tool?.startsWith('pipe:') ? tool.slice(5) : null; +} + +// L'outil peut-il s'appliquer sur cette case ? null = oui. +// Sinon un objet : { msg } affiche un message, {} refuse sans rien dire (case déjà prise, rien à démolir). +export function placeCheck(tool, x, y) { + if (tool === 'demolish') { + const target = state.mode === 'underground' ? state.pipes[y][x] : state.grid[y][x]; + return target ? null : {}; + } + + const res = pipeOfTool(tool); + const def = res ? null : BUILDINGS[tool]; + if (!RESOURCES[res] && !def) return {}; + + if (res) { + if (state.water[y][x]) return { msg: "Pas de tuyau sous l'eau" }; + if (state.pipes[y][x]) return {}; + } else { + if (state.grid[y][x]) return {}; + if (state.water[y][x]) return { msg: "Impossible de construire sur l'eau" }; + if (def.placement?.adjacentWater && !nearWater(x, y)) return { msg: `${def.name} : à construire au bord de l'eau` }; + } + + const cost = res ? RESOURCES[res].cost : (def.cost ?? 0); + return state.money < cost ? { msg: `Fonds insuffisants : ${cost} € requis` } : null; +} + +// Applique l'outil actif sur une case : construit / pose un tuyau (si assez d'argent) ou démolit (remboursement partiel). +// En vue sous-terre, « démolir » retire les tuyaux ; en surface, les bâtiments. +export function applyTool(x, y) { + const tool = state.tool; + if (!tool) return; + + const refusal = placeCheck(tool, x, y); + if (refusal) { + if (refusal.msg) notify(refusal.msg); + return; + } + + const res = pipeOfTool(tool); + if (tool === 'demolish') { + if (state.mode === 'underground') { + state.money += Math.round(RESOURCES[state.pipes[y][x]].cost * REFUND); + state.pipes[y][x] = null; + } else { + const cell = state.grid[y][x]; + state.money += Math.round((BUILDINGS[cell.type]?.cost ?? 0) * REFUND); + state.grid[y][x] = null; + } + } else if (res) { + state.money -= RESOURCES[res].cost; + state.pipes[y][x] = res; + } else { + state.money -= BUILDINGS[tool].cost ?? 0; + state.grid[y][x] = makeCell(tool, state.counter++); + } + save(); +} + +export function hasSave() { + try { return localStorage.getItem(KEY) !== null; } catch { return false; } +} + +export function save() { + try { + const r1 = v => (v == null ? null : Math.round(v * 10) / 10); + const grid = state.grid.map(row => row.map(c => c && { + type: c.type, order: c.order, mt: r1(c.mt), maint: r1(c.maint), + })); + localStorage.setItem(KEY, JSON.stringify({ + v: 5, + grid, + terrain: state.terrain, + water: state.water.map(row => row.map(Number)), + pipes: state.pipes, + wind: { dir: state.wind.dir }, + money: Math.round(state.money * 100) / 100, + counter: state.counter, + })); + } catch (e) { + console.warn('Sauvegarde impossible :', e); + } +} + +export function load() { + try { + const data = JSON.parse(localStorage.getItem(KEY)); + // Anciennes sauvegardes : pas de numéro d'ordre → on en attribue dans l'ordre de la grille. + const maxOrder = Math.max(0, ...data.grid.flat().map(c => c?.order ?? 0)); + let counter = Math.max(data.counter ?? 1, maxOrder + 1); + + state.grid = data.grid.map(row => row.map(c => c && makeCell(c.type, c.order ?? counter++, c.mt, c.maint))); + state.counter = counter; + state.money = data.money ?? START_MONEY; + + const missingTerrain = !data.terrain; + state.terrain = data.terrain ?? genTerrain(state.grid[0].length, state.grid.length); + // Anciennes sauvegardes sans eau : on en génère, jamais sous un bâtiment existant. + const missingWater = !data.water; + state.water = data.water + ? data.water.map(row => row.map(Boolean)) + : genWater(state.terrain, state.grid.map(row => row.map(Boolean))); + // Tuyaux : on ne garde que les types connus, jamais sous l'eau (anciennes sauvegardes : aucun tuyau). + state.pipes = state.grid.map((row, y) => row.map((_, x) => { + const p = data.pipes?.[y]?.[x]; + return RESOURCES[p] && !state.water[y][x] ? p : null; + })); + state.mode = 'surface'; + state.wind = { dir: data.wind?.dir ?? pickWindDir(), timer: nextWindDelay() }; + state.power = 0; + state.income = 0; + state.notice = null; + if (missingTerrain || missingWater || data.v !== 5) save(); // fige le relief et l'eau générés / migre vers la v5 + return true; + } catch { + return false; + } +} diff --git a/src/terrain.js b/src/terrain.js new file mode 100644 index 0000000..56dcfe9 --- /dev/null +++ b/src/terrain.js @@ -0,0 +1,117 @@ +// Relief et vent : génération du terrain, rendement des éoliennes. Aucun accès DOM. +import { MAX_HEIGHT, WIND_DIRS, WIND_RULES, WIND_CHANGE, WATER, TERRAIN } from './data/world.js'; + +const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v)); + +// Collines gaussiennes (sommets à MAX_HEIGHT-1 .. MAX_HEIGHT), arrondies à des altitudes entières. Nombre et rayon : voir TERRAIN. +export function genTerrain(cols, rows) { + const count = Math.max(TERRAIN.minHills, Math.round(cols * rows / TERRAIN.cellsPerHill * (0.8 + Math.random() * 0.4))); + const { min, max } = TERRAIN.radius; + const hills = Array.from({ length: count }, () => ({ + x: Math.random() * cols, + y: Math.random() * rows, + r: min + Math.random() * (max - min), + h: MAX_HEIGHT - 1 + Math.random(), + })); + return Array.from({ length: rows }, (_, y) => Array.from({ length: cols }, (_, x) => { + let v = 0; + for (const hl of hills) { + const d2 = (x - hl.x) ** 2 + (y - hl.y) ** 2; + v = Math.max(v, hl.h * Math.exp(-d2 / (2 * hl.r ** 2))); + } + return clamp(Math.round(v), 0, MAX_HEIGHT); + })); +} + +// Bruit de valeurs lissé : treillis aléatoire interpolé (smoothstep), valeurs dans 0..1. +function makeNoise(scale) { + const n = 64; + const lattice = Array.from({ length: n * n }, () => Math.random()); + const at = (i, j) => lattice[((j % n) + n) % n * n + ((i % n) + n) % n]; + const smooth = t => t * t * (3 - 2 * t); + const ox = Math.random() * 20, oy = Math.random() * 20; // décalage : pas toujours le même coin + return (x, y) => { + const fx = x / scale + ox, fy = y / scale + oy; + const i = Math.floor(fx), j = Math.floor(fy); + const tx = smooth(fx - i), ty = smooth(fy - j); + const top = at(i, j) * (1 - tx) + at(i + 1, j) * tx; + const bot = at(i, j + 1) * (1 - tx) + at(i + 1, j + 1) * tx; + return top * (1 - ty) + bot * ty; + }; +} + +// Eau : taches organiques dans les basses terres, jamais sur une case `blocked` (déjà construite). +// On trie les cases candidates par bruit (légèrement pénalisé par l'altitude) et on prend les plus fortes : +// la quantité varie d'une partie à l'autre, la forme suit le bruit (lacs, mares, golfes), et les cases d'eau +// isolées sont retirées. +// carve = true (nouvelle partie) : l'eau peut aussi occuper des cases d'altitude 1, aplanies à 0 (vallée), +// ce qui garantit de l'eau même sur une carte très vallonnée. Sans carve (vieille sauvegarde), le relief +// n'est jamais modifié : seules les cases d'altitude 0 sont possibles. +export function genWater(terrain, blocked, carve = false) { + const rows = terrain.length, cols = terrain[0].length; + const coarse = makeNoise(WATER.noiseScale), fine = makeNoise(WATER.noiseScale / 2); + const water = Array.from({ length: rows }, () => Array(cols).fill(false)); + const maxH = carve ? 1 : 0; + + const candidates = []; + for (let y = 0; y < rows; y++) for (let x = 0; x < cols; x++) { + if (terrain[y][x] > maxH || blocked?.[y]?.[x]) continue; + candidates.push({ x, y, v: 0.7 * coarse(x, y) + 0.3 * fine(x, y) - 0.3 * terrain[y][x] }); + } + const { min, max } = WATER.coverage; + const target = Math.min( + Math.round(rows * cols * (min + Math.random() * (max - min))), + Math.floor(candidates.length * WATER.maxShare), + ); + candidates.sort((a, b) => b.v - a.v); + const picked = candidates.slice(0, target); + for (const c of picked) water[c.y][c.x] = true; + + // pas de case d'eau isolée (sauf s'il n'y en a qu'une) + if (picked.length > 1) { + for (const c of picked) { + const linked = [[0, -1], [0, 1], [-1, 0], [1, 0]].some(([dx, dy]) => water[c.y + dy]?.[c.x + dx]); + if (!linked) water[c.y][c.x] = false; + } + } + if (carve) { + for (let y = 0; y < rows; y++) for (let x = 0; x < cols; x++) if (water[y][x]) terrain[y][x] = 0; + } + return water; +} + +// Sommet : assez haut, aucune case voisine plus haute et au moins une plus basse. +function isSummit(terrain, x, y) { + const h = terrain[y][x]; + const around = [[0, -1], [0, 1], [-1, 0], [1, 0]] + .map(([dx, dy]) => terrain[y + dy]?.[x + dx]) + .filter(v => v !== undefined); + return h >= WIND_RULES.summitMinHeight && around.every(v => v <= h) && around.some(v => v < h); +} + +// Conditions de vent sur une case. dirIndex = index dans WIND_DIRS. +// rise > 0 : le vent arrive d'une case plus basse (pente face au vent). +export function windAt(terrain, x, y, dirIndex) { + const dir = WIND_DIRS[dirIndex]; + const height = terrain[y][x]; + const upwind = terrain[y - dir.dy]?.[x - dir.dx]; // case d'où vient le vent + const rise = upwind === undefined ? 0 : height - upwind; + const summit = isSummit(terrain, x, y); + + let factor = 1 + WIND_RULES.perRise * rise; + if (summit) factor *= WIND_RULES.summit; + factor = clamp(factor, WIND_RULES.min, WIND_RULES.max); + + const label = summit ? 'sommet' : rise > 0 ? 'pente face au vent' : rise < 0 ? 'pente sous le vent' : 'plat'; + return { height, rise, summit, factor, label }; +} + +export function pickWindDir(previous) { + let d; + do { d = Math.floor(Math.random() * WIND_DIRS.length); } while (d === previous); + return d; +} + +export function nextWindDelay() { + return WIND_CHANGE.min + Math.random() * (WIND_CHANGE.max - WIND_CHANGE.min); +} diff --git a/src/ui.js b/src/ui.js new file mode 100644 index 0000000..7fb6ec6 --- /dev/null +++ b/src/ui.js @@ -0,0 +1,211 @@ +import { state, hasSave, notify, save } from './state.js'; +import { BUILDINGS } from './data/buildings.js'; +import { drawBuildingIcon, drawPipeIcon } from './render.js'; +import { RESOURCES } from './data/pipes.js'; +import { WIND_DIRS, REFUND } from './data/world.js'; +import { windAt } from './terrain.js'; + +const $ = id => document.getElementById(id); + +export function initUI({ onNew, onContinue, onMenu }) { + $('btn-new').onclick = onNew; + $('btn-continue').onclick = onContinue; + $('btn-menu').onclick = onMenu; + for (const [name, m] of Object.entries(MENUS)) $(m.btn).onclick = () => toggleMenu(name); + document.addEventListener('keydown', e => { + const inGame = !$('game').classList.contains('hidden'); + if (inGame) watchDevCode(e); + if (e.key === 'Escape') setMenu(null); + else if ((e.key === 'u' || e.key === 'U') && inGame) toggleMenu('pipes'); + }); + buildLists(); + showMenu(); +} + +function drawDemolishIcon(ctx) { + ctx.fillStyle = '#c03030'; + for (let i = 0; i < 18; i++) { // croix en pixels + ctx.fillRect(7 + i, 7 + i, 3, 3); + ctx.fillRect(24 - i, 7 + i, 3, 3); + } +} + +function addTool(menu, id, name, drawIcon, sub, cost = 0) { + const icon = document.createElement('canvas'); + icon.width = icon.height = 32; + drawIcon(icon.getContext('2d')); + + const label = document.createElement('span'); + label.textContent = name; + + const btn = document.createElement('button'); + btn.type = 'button'; + btn.className = 'tool'; + btn.dataset.tool = id; + btn.dataset.menu = menu; // « Démolir » existe dans les deux menus : on ne surligne que celui qui est ouvert + btn.setAttribute('aria-pressed', 'false'); + btn.dataset.cost = cost; + const subLabel = document.createElement('span'); + subLabel.className = 'cost'; + subLabel.textContent = sub; + btn.append(icon, label, subLabel); + btn.onclick = () => setTool(state.tool === id ? null : id); + + const li = document.createElement('li'); + li.append(btn); + $(MENUS[menu].list).append(li); +} + +// Menus de construction : un bouton sur le côté qui ouvre un menu déroulant. Un seul menu ouvert à la fois. +// build : bâtiments (vue de surface) ; pipes : tuyaux (vue sous-terre, « Retirer » démolit un tuyau). +const MENUS = { + build: { btn: 'btn-build', list: 'build-list', mode: 'surface' }, + pipes: { btn: 'btn-layer', list: 'pipe-list', mode: 'underground' }, +}; +let openMenu = null; + +function buildLists() { + for (const [id, building] of Object.entries(BUILDINGS)) { + addTool('build', id, building.name, ctx => drawBuildingIcon(ctx, id), `${building.cost ?? 0} €`, building.cost ?? 0); + } + addTool('build', 'demolish', 'Démolir', drawDemolishIcon, `${Math.round(REFUND * 100)} % remboursé`); + + for (const [id, r] of Object.entries(RESOURCES)) { + addTool('pipes', `pipe:${id}`, r.pipe, ctx => drawPipeIcon(ctx, id), `${r.cost} € / case`, r.cost); + } + addTool('pipes', 'demolish', 'Retirer', drawDemolishIcon, `${Math.round(REFUND * 100)} % remboursé`); +} + +export function setTool(tool) { + state.tool = tool; + document.querySelectorAll('.dropdown .tool').forEach(btn => { + const on = btn.dataset.tool === tool && btn.dataset.menu === openMenu; + btn.classList.toggle('selected', on); + btn.setAttribute('aria-pressed', String(on)); + }); +} + +function closeMenu() { + const m = MENUS[openMenu]; + $(m.list).classList.add('hidden'); + $(m.btn).classList.remove('active'); + $(m.btn).setAttribute('aria-expanded', 'false'); + openMenu = null; +} + +// Ouvre un menu (ou ferme tout avec null). Le menu déjà ouvert est fermé d'abord ; la vue suit : +// sous-terre quand le menu des tuyaux est ouvert, surface sinon. Changer de menu désélectionne l'outil. +export function setMenu(name) { + if (name === openMenu) return; + if (openMenu) closeMenu(); + openMenu = name; + if (name) { + const m = MENUS[name]; + $(m.list).classList.remove('hidden'); + $(m.btn).classList.add('active'); + $(m.btn).setAttribute('aria-expanded', 'true'); + } + state.mode = name ? MENUS[name].mode : 'surface'; + state.hover = null; + setTool(null); +} + +function toggleMenu(name) { + setMenu(openMenu === name ? null : name); +} + +// Mode dev : taper « devmode » pendant une partie (sans rien sélectionner de particulier) ajoute de l'argent. +const DEV_CODE = 'devmode'; +const DEV_MONEY = 99999; +let devBuffer = ''; + +function watchDevCode(e) { + if (e.ctrlKey || e.metaKey || e.altKey || e.key.length !== 1) return; // lettres seules + devBuffer = (devBuffer + e.key.toLowerCase()).slice(-DEV_CODE.length); + if (devBuffer !== DEV_CODE) return; + devBuffer = ''; + state.money += DEV_MONEY; + notify(`Mode dev : +${DEV_MONEY.toLocaleString('fr-FR')} €`); + save(); +} + +export function showMenu() { + setMenu(null); + $('menu').classList.remove('hidden'); + $('game').classList.add('hidden'); + $('btn-continue').disabled = !hasSave(); +} + +export function showGame() { + setMenu(null); + state.mode = 'surface'; + $('menu').classList.add('hidden'); + $('game').classList.remove('hidden'); +} + +// ---------- HUD : production, vent, infos de la case survolée ---------- + +const fmt = n => n.toLocaleString('fr-FR', { minimumFractionDigits: 1, maximumFractionDigits: 1 }); + +function setText(id, text) { + const el = $(id); + if (el.textContent !== text) el.textContent = text; // évite de toucher au DOM sans raison +} + +function buildingInfo(cell, def) { + if (cell.status === 'unmanaged') return `${def.name} : non gérée (pas assez de bureaux)`; + if (cell.status === 'maintenance') return `${def.name} : en entretien (${Math.ceil(cell.maint)} s)`; + const eff = cell.eff ?? 1; + const bits = [def.name]; + if (def.power) bits.push(`${fmt(def.power.output * eff)} MW`); + for (const [res, rate] of Object.entries(def.produces ?? {})) bits.push(`${RESOURCES[res]?.label ?? res} ${fmt(rate * eff)}/s`); + if (cell.starved) bits.push(RESOURCES[cell.starved].lack); + if (def.office) bits.push(`${def.office.capacity} postes`); + if (def.maintenance?.every && cell.mt != null) bits.push(`entretien dans ${Math.ceil(cell.mt)} s`); + return bits.join(' · '); +} + +function cellInfo(state) { + if (state.notice) return state.notice.text; + const hv = state.hover; + if (!hv) return state.mode === 'underground' + ? "Vue sous-terre : relie la pompe, la centrale et la turbine avec des tuyaux (glisser pour en poser plusieurs)." + : "Molette : zoom · clic maintenu sans outil : déplacer la vue · clic droit : désélectionner l'outil"; + const cell = state.grid[hv.y][hv.x]; + const def = cell && BUILDINGS[cell.type]; + const w = windAt(state.terrain, hv.x, hv.y, state.wind.dir); + + if (state.water[hv.y][hv.x]) return "Eau · non constructible"; + + const under = state.mode === 'underground'; + const pipe = state.pipes[hv.y][hv.x]; + const net = state.pipeNet[hv.y]?.[hv.x]; + + const parts = []; + if (def) parts.push(buildingInfo(cell, def)); + if (under && pipe) parts.push(`${RESOURCES[pipe].pipe} · offre ${fmt(net?.supply ?? 0)}/s · demande ${fmt(net?.demand ?? 0)}/s`); + parts.push(`Altitude ${w.height}`); + if (!under && (!def || def.power?.scalesWithWind)) parts.push(`${w.label}, vent x${fmt(w.factor)}`); + return parts.join(' · '); +} + +function setNeg(id, neg) { + $(id).classList.toggle('neg', neg); +} + +export function updateHud(state) { + const dir = WIND_DIRS[state.wind.dir]; + const { capacity, need } = state.slots; + + setText('hud-money', `Argent : ${Math.trunc(state.money).toLocaleString('fr-FR')} €`); + setNeg('hud-money', state.money < 0); + setText('hud-power', `Production : ${fmt(state.power)} MW (+${fmt(state.income)} €/s)`); + setText('hud-slots', `Gestion : ${need}/${capacity}`); + setNeg('hud-slots', need > capacity); + setText('hud-wind', `Vent ${dir.label} ${dir.arrow}`); + setText('hud-cell', cellInfo(state)); + + document.querySelectorAll('.dropdown .tool').forEach(btn => { + btn.classList.toggle('poor', state.money < Number(btn.dataset.cost)); + }); +} diff --git a/style.css b/style.css new file mode 100644 index 0000000..fcab1f2 --- /dev/null +++ b/style.css @@ -0,0 +1,182 @@ +:root { + --bg: #161616; + --cell: #2a2a2a; + --line: #3a3a3a; + --text: #d8d8d8; + --muted: #8a8a8a; + --accent: #e0603a; + color-scheme: dark; +} + +* { box-sizing: border-box; } + +body { + margin: 0; + min-height: 100vh; + display: flex; + align-items: center; + justify-content: center; + background: var(--bg); + color: var(--text); + font-family: ui-monospace, "SF Mono", Menlo, Consolas, "DejaVu Sans Mono", monospace; +} + +.screen { + display: flex; + flex-direction: column; + align-items: center; + gap: 1rem; + padding: 1rem; +} + +.hidden { display: none !important; } + +h1 { + margin: 0 0 1.5rem; + font-size: 3rem; + font-weight: 700; +} + +button { + min-width: 12rem; + padding: 0.7rem 2rem; + font: inherit; + font-size: 1.1rem; + color: var(--text); + background: var(--cell); + border: 2px solid var(--muted); + box-shadow: 4px 4px 0 #000; + cursor: pointer; +} + +button:hover:not(:disabled) { border-color: var(--accent); } + +button:active:not(:disabled) { + transform: translate(2px, 2px); + box-shadow: 2px 2px 0 #000; +} + +button:disabled { + color: #555; + border-color: var(--line); + box-shadow: none; + cursor: not-allowed; +} + +button:focus-visible { + outline: 2px solid var(--accent); + outline-offset: 3px; +} + +#btn-menu { align-self: flex-start; min-width: 0; padding: 0.4rem 1.2rem; font-size: 1rem; } + +canvas { + display: block; + image-rendering: pixelated; +} + +/* Écran de jeu : plein écran, la zone de la carte prend tout l'espace restant. */ +#game { +width: 100%; +height: 100vh; +height: 100dvh; +align-items: stretch; +gap: 0.6rem; +padding: 0.75rem; +} + +.stage { + flex: 1; + min-height: 0; + display: flex; + gap: 0.75rem; +} + +.viewport { + position: relative; + flex: 1; + min-width: 0; + overflow: hidden; + background: #0e0e0e; + border: 2px solid var(--line); +} + +.viewport canvas { + position: absolute; + inset: 0; + width: 100%; + height: 100%; + touch-action: none; /* glisser = déplacer la vue ou poser des tuyaux, jamais faire défiler la page */ +} + +/* Boutons de menu sur le côté ; chacun ouvre un menu déroulant à sa droite, par-dessus la carte. */ +.sidebar { + display: flex; + flex-direction: column; + gap: 0.75rem; +} + +.side-item { position: relative; } + +.icon-btn { min-width: 0; padding: 0.6rem; line-height: 0; } +.icon-btn svg { width: 28px; height: 28px; fill: currentColor; } +.icon-btn.active { border-color: var(--accent); color: var(--accent); } + +.dropdown { + position: absolute; + top: 0; + left: calc(100% + 0.5rem); + z-index: 10; + display: flex; + flex-direction: column; + gap: 0.5rem; + min-width: 16rem; + max-height: calc(100dvh - 7rem); + margin: 0; + padding: 0.6rem; + overflow-y: auto; + list-style: none; + background: var(--bg); + border: 2px solid var(--muted); + box-shadow: 4px 4px 0 #000; +} + +.tool { + width: 100%; + min-width: 0; + display: flex; + align-items: center; + gap: 0.75rem; + padding: 0.35rem 0.7rem; + font-size: 0.9rem; + text-align: left; + box-shadow: 2px 2px 0 #000; +} + +.tool canvas { flex: none; width: 40px; height: 40px; } +.tool .cost { margin-left: auto; padding-left: 0.5rem; white-space: nowrap; } +.tool.selected { border-color: var(--accent); } + +.topbar { + align-self: stretch; + display: flex; + flex-wrap: wrap; + align-items: center; + justify-content: space-between; + gap: 1rem; +} + +.topbar #btn-menu { align-self: center; } + +.hud { display: flex; flex-wrap: wrap; gap: 0.25rem 1.5rem; } +#hud-power { color: var(--accent); font-weight: 700; } + +.info { margin: 0; min-height: 1.4em; color: var(--muted); font-size: 0.9rem; } + +#hud-money { font-weight: 700; } +.neg { color: #e05050; } + +.tool .cost { color: var(--muted); font-size: 0.75rem; } +.tool.poor .cost { color: #e05050; } + +.info { text-align: center; }