@greenborn/mapa-voxel-back 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,816 @@
1
+ // Segunda planta de las casas y escaleras que la comunican con la planta baja.
2
+ //
3
+ // Cómo está planteado
4
+ // -------------------
5
+ // Las salas de una casa son cajas (x,y,z,width,height,depth) apoyadas sobre el
6
+ // terreno: el piso es la capa `y` y el techo la capa `y + height - 1`. Para
7
+ // levantar un piso más alcanza con clonar las salas de la planta baja con
8
+ // `y` desplazado en `height - 1`, de modo que el piso de arriba *es* el techo
9
+ // de abajo y no queda ningún hueco ni voladizo: las paredes de las dos plantas
10
+ // caen sobre la misma huella y el generador de volumen no necesita saber nada
11
+ // nuevo para dibujarlas.
12
+ //
13
+ // La escalera es un tramo recto que sube un bloque por escalón, así que mide
14
+ // tantas celdas de largo como bloques hay que subir, y es tan ancha como los
15
+ // pasillos de la casa. Va *dentro de una sala*, separada de las cuatro paredes,
16
+ // y no en un pasillo: un tramo del ancho del pasillo lo taparía de pared a
17
+ // pared, y entonces o el pie o la cabeza de la escalera queda contra el fondo
18
+ // del pasillo —el pie se vuelve inalcanzable desde la planta baja, o el
19
+ // descanso de arriba queda aislado del resto de la planta alta—. Puesta en el
20
+ // medio de una sala queda piso libre alrededor en las dos plantas: se llega al
21
+ // primer escalón, se sale del último y ninguna puerta ni ventana se tapa.
22
+ //
23
+ // El hueco del entrepiso (la caja de escalera) sale de vaciar la columna de
24
+ // cada escalón hasta la altura del piso de arriba. El último escalón queda
25
+ // justo a esa altura, así que tapa su propio hueco y hace de umbral: desde él
26
+ // se sale caminando al descanso, que es piso de la planta alta.
27
+ //
28
+ // Por si alguna vez el tramo quedara pegado a una pared, la zona se anota en
29
+ // `stairKeepOut` y las funciones que abren puertas la esquivan (ver
30
+ // computeDoorSpan en mapType3Utils.js).
31
+
32
+ import { sortearArmario, sortearCantidades } from '../../plugins/datos.js';
33
+ import { BLOCK_TYPES, WORLD_CONFIG, isTintableRender, tintBlockRender } from '../mapConfig.js';
34
+ import { stairKeepOutRange } from '../mapType3Utils.js';
35
+
36
+ // proporción de casas según cantidad de plantas (suma 1)
37
+ export const FLOOR_COUNT_DISTRIBUTION = [
38
+ { floors: 1, probability: 0.3 },
39
+ { floors: 2, probability: 0.4 },
40
+ { floors: 3, probability: 0.2 },
41
+ { floors: 4, probability: 0.1 }
42
+ ];
43
+
44
+ // ancho de escalera por defecto, si la casa no tuviera ningún pasillo del que
45
+ // copiarlo (el generador los hace de 6 bloques).
46
+ const DEFAULT_STAIR_WIDTH = 6;
47
+
48
+ // celdas libres que se reservan a lo largo del tramo: una antes del primer
49
+ // escalón para poder encararlo y otra después del último, que es el descanso ya
50
+ // en la planta alta.
51
+ const STAIR_ACCESS = 1;
52
+ const STAIR_LANDING = 1;
53
+
54
+ // grosor de la losa de la escalera. Cada escalón apoya sobre esta cantidad de
55
+ // bloques y debajo del tramo queda aire, en lugar de un macizo desde el piso.
56
+ const GROSOR_ESCALERA = 2;
57
+
58
+ // ancho mínimo de cada uno de los dos tramos de la caja de escalera.
59
+ const STAIRWELL_MIN_BAND = 2;
60
+
61
+ // celdas de descanso que la caja deja en cada extremo, antes del primer escalón
62
+ // y después del último. Son dos (y no una como el tramo suelto de una sala)
63
+ // para que delante de la escalera quede sitio para moverse y para cruzar de un
64
+ // tramo al otro sin quedar encajonado.
65
+ const STAIRWELL_LANDING = 2;
66
+
67
+ // franja de paso que la caja deja a un costado, al lado de los dos tramos.
68
+ // Ningún tramo la vacía, así que es piso en todas las plantas: es por donde se
69
+ // entra desde la puerta y por donde se camina hasta el extremo que toca.
70
+ const STAIRWELL_WALKWAY = 2;
71
+
72
+ // tipos de sala donde no se pone la escalera: el baño porque no es lugar y el
73
+ // pasillo porque es demasiado angosto (ver la nota de arriba).
74
+ const SKIP_TYPES = new Set(['banio', 'hallway', 'spawn']);
75
+
76
+ // preferencia de sala para la escalera; las que no figuran van al final.
77
+ const TYPE_PREFERENCE = ['living', 'comedor', 'cocina', 'dormitorio'];
78
+
79
+ // para el botín de casa: el pasillo, el spawn y la caja de escalera no llevan
80
+ // punto fijo. El resto de las salas tira por separado (ver pickLootRooms).
81
+ const LOOT_SKIP_TYPES = new Set(['hallway', 'spawn', 'escalera']);
82
+
83
+ /**
84
+ * ¿Cuántas plantas tiene esta casa? Se expone el random como parámetro para
85
+ * poder forzar el resultado desde los tests.
86
+ */
87
+ export function pickFloorCount(random = Math.random) {
88
+ const r = random();
89
+ let acc = 0;
90
+ for (const { floors, probability } of FLOOR_COUNT_DISTRIBUTION) {
91
+ acc += probability;
92
+ if (r < acc) return floors;
93
+ }
94
+ return 1;
95
+ }
96
+
97
+ /**
98
+ * Altura de entrepiso: el piso de arriba se apoya sobre el techo de abajo, así
99
+ * que el desplazamiento es `height - 1` de las salas de la planta baja.
100
+ */
101
+ export function floorRise(rooms) {
102
+ let h = 0;
103
+ for (const r of rooms) {
104
+ if (typeof r.height === 'number') h = Math.max(h, r.height);
105
+ }
106
+ return Math.max(0, h - 1);
107
+ }
108
+
109
+ /**
110
+ * Ancho de escalera: el mismo que los pasillos de esta casa.
111
+ */
112
+ export function stairWidth(rooms) {
113
+ let w = Infinity;
114
+ for (const r of rooms) {
115
+ if (r.type !== 'hallway') continue;
116
+ w = Math.min(w, r.width, r.depth);
117
+ }
118
+ return Number.isFinite(w) ? w : DEFAULT_STAIR_WIDTH;
119
+ }
120
+
121
+ /**
122
+ * Plan del tramo que sube desde la planta `level` dentro del habitáculo de
123
+ * escalera (`escalera`). Toda la casa sube por la misma caja.
124
+ *
125
+ * Es una escalera de ida y vuelta, como la de un edificio: la caja se parte en
126
+ * dos tramos a lo largo, uno contra cada costado, y las plantas los van
127
+ * alternando. Las plantas pares suben por el tramo de un costado en un
128
+ * sentido y las impares por el del otro costado en el sentido contrario, así
129
+ * que el descanso de cada tramo cae justo al lado del pie del siguiente: se
130
+ * llega arriba, se da media vuelta y se sigue subiendo.
131
+ *
132
+ * Alternar los costados es lo que hace que la caja funcione. Si todas las
133
+ * plantas subieran por el mismo tramo, el de arriba quedaría justo sobre el de
134
+ * abajo —se rellenan macizos desde el piso— y le taparía la cabeza: los
135
+ * últimos escalones quedarían intransitables. Alternando, encima de un tramo
136
+ * sólo hay el hueco del entrepiso y el tramo de dos plantas más arriba, que
137
+ * está a dos entrepisos de distancia.
138
+ *
139
+ * Las filas de los dos extremos quedan siempre de piso (son los descansos, y
140
+ * ningún tramo las vacía), que es lo que pisa quien cambia de tramo. A un
141
+ * costado de los dos tramos queda además la franja de paso, que tampoco se
142
+ * vacía nunca: por ahí entra la puerta —`keepOut` reserva sólo los tramos, no
143
+ * la franja ni los descansos— y por ahí se camina hasta el extremo que toca
144
+ * subir en esta planta.
145
+ *
146
+ * Devuelve null si la caja no da para un tramo con sus dos descansos y la
147
+ * franja de paso.
148
+ */
149
+ export function planStairwell(room, rise, level = 0) {
150
+ if (rise <= 0) return null;
151
+ // interior de la caja: la capa exterior de cada lado es pared
152
+ const interior = {
153
+ x0: room.x + 1, x1: room.x + room.width - 2,
154
+ z0: room.z + 1, z1: room.z + room.depth - 2
155
+ };
156
+ const lenX = interior.x1 - interior.x0 + 1;
157
+ const lenZ = interior.z1 - interior.z0 + 1;
158
+ // los tramos suben a lo largo del lado más holgado, uno al lado del otro
159
+ const axis = (lenX >= lenZ) ? 'x' : 'z';
160
+ const long = (axis === 'x') ? lenX : lenZ;
161
+ const cross = (axis === 'x') ? lenZ : lenX;
162
+ const band = Math.floor((cross - STAIRWELL_WALKWAY) / 2);
163
+ if (long < rise + 2 * STAIRWELL_LANDING || band < STAIRWELL_MIN_BAND) {
164
+ return null;
165
+ }
166
+
167
+ const longLo = (axis === 'x') ? interior.x0 : interior.z0;
168
+ const longHi = longLo + long - 1;
169
+ const crossLo = (axis === 'x') ? interior.z0 : interior.x0;
170
+ const crossHi = crossLo + cross - 1;
171
+ // la franja de paso va contra un costado y los dos tramos a continuación
172
+ const bandLo = crossLo + (cross - 2 * band);
173
+
174
+ // plantas pares: tramo de adentro, subiendo hacia `longHi`.
175
+ // plantas impares: tramo del costado opuesto al paso, subiendo hacia `longLo`.
176
+ const par = (level % 2) === 0;
177
+ const dir = par ? 1 : -1;
178
+ const first = par ? longLo + STAIRWELL_LANDING : longHi - STAIRWELL_LANDING;
179
+ const cross0 = par ? bandLo : crossHi - band + 1;
180
+ const cross1 = cross0 + band - 1;
181
+
182
+ // se reservan los dos tramos (no la franja de paso ni los descansos): una
183
+ // puerta que diera a un tramo quedaría tapada por los escalones y, en las
184
+ // plantas en que ese tramo es el hueco del entrepiso, daría al vacío.
185
+ const koLongLo = longLo + STAIRWELL_LANDING;
186
+ const koLongHi = longHi - STAIRWELL_LANDING;
187
+
188
+ return {
189
+ room,
190
+ axis,
191
+ dir,
192
+ run: rise,
193
+ startX: (axis === 'x') ? first : cross0,
194
+ startZ: (axis === 'x') ? cross0 : first,
195
+ cross0,
196
+ cross1,
197
+ baseY: room.y,
198
+ keepOut: (axis === 'x')
199
+ ? { x0: koLongLo, x1: koLongHi + 1, z0: bandLo, z1: crossHi + 1 }
200
+ : { x0: bandLo, x1: crossHi + 1, z0: koLongLo, z1: koLongHi + 1 },
201
+ area: lenX * lenZ
202
+ };
203
+ }
204
+
205
+ // arma el tramo dentro de una sala. Busca la posición del tramo (eje, desplazamiento a lo largo y a lo
206
+ // ancho) que no pise `avoid` (huecos de escaleras anteriores) ni la puede
207
+ // `ok(keepOut)` rechace (por ejemplo, puertas). Prefiere el centro. Devuelve null si no hay ninguna.
208
+ function buildPlan(room, rise, width, ok = () => true) {
209
+ // interior de la sala: la capa exterior de cada lado es pared
210
+ const interior = {
211
+ x0: room.x + 1, x1: room.x + room.width - 2,
212
+ z0: room.z + 1, z1: room.z + room.depth - 2
213
+ };
214
+ const lenX = interior.x1 - interior.x0 + 1;
215
+ const lenZ = interior.z1 - interior.z0 + 1;
216
+ const needLong = rise + STAIR_ACCESS + STAIR_LANDING;
217
+ const needCross = width;
218
+
219
+ // el eje largo del tramo es el que deja más sitio; si no entra, se prueba el otro
220
+ const axes = (lenX >= lenZ) ? ['x', 'z'] : ['z', 'x'];
221
+ for (const axis of axes) {
222
+ const long = (axis === 'x') ? lenX : lenZ;
223
+ const cross = (axis === 'x') ? lenZ : lenX;
224
+ if (long < needLong || cross < needCross) continue;
225
+
226
+ const longLo = (axis === 'x') ? interior.x0 : interior.z0;
227
+ const crossLo = (axis === 'x') ? interior.z0 : interior.x0;
228
+ const centeredFirst = longLo + Math.floor((long - rise) / 2);
229
+ const centeredCross0 = crossLo + Math.floor((cross - width) / 2);
230
+ // primer escalón: entre el paso de acceso y el descanso
231
+ const firstMin = longLo + STAIR_ACCESS;
232
+ const firstMax = longLo + long - rise - STAIR_LANDING;
233
+ // franja transversal: cualquier posición dentro del interior
234
+ const cross0Max = crossLo + cross - width;
235
+
236
+ const firsts = orderByDistance(firstMin, firstMax, centeredFirst);
237
+ const cross0s = orderByDistance(crossLo, cross0Max, centeredCross0);
238
+ for (const first of firsts) {
239
+ for (const cross0 of cross0s) {
240
+ const cross1 = cross0 + width - 1;
241
+ const last = first + rise - 1;
242
+ const keepOut = (axis === 'x')
243
+ ? { x0: first, x1: last + 1, z0: cross0, z1: cross1 + 1 }
244
+ : { x0: cross0, x1: cross1 + 1, z0: first, z1: last + 1 };
245
+ if (!ok(keepOut)) continue;
246
+ return {
247
+ room,
248
+ axis,
249
+ dir: 1,
250
+ run: rise,
251
+ startX: (axis === 'x') ? first : cross0,
252
+ startZ: (axis === 'x') ? cross0 : first,
253
+ cross0,
254
+ cross1,
255
+ baseY: room.y,
256
+ keepOut,
257
+ area: lenX * lenZ
258
+ };
259
+ }
260
+ }
261
+ }
262
+ return null;
263
+ }
264
+
265
+ // valores de `min..max` ordenados por cercanía a `pref` (el centro primero)
266
+ function orderByDistance(min, max, pref) {
267
+ const out = [];
268
+ for (let v = min; v <= max; v++) out.push(v);
269
+ return out.sort((a, b) => Math.abs(a - pref) - Math.abs(b - pref) || a - b);
270
+ }
271
+
272
+ // cuánto se prefiere una sala para meter la escalera (menor es mejor)
273
+ function typeRank(room) {
274
+ const idx = TYPE_PREFERENCE.indexOf(room.type);
275
+ return (idx === -1) ? TYPE_PREFERENCE.length : idx;
276
+ }
277
+
278
+ // ¿se pisan dos huecos de escalera (con un bloque de margen)?
279
+ function keepOutsOverlap(a, b) {
280
+ return a.x0 < b.x1 + 1 && b.x0 < a.x1 + 1 && a.z0 < b.z1 + 1 && b.z0 < a.z1 + 1;
281
+ }
282
+
283
+ // ¿alguna abertura ya puesta en la sala (puerta) cae sobre el tramo? Las
284
+ // puertas de las plantas altas se copian de la planta baja, así que hay que
285
+ // mirarlas antes de elegir la sala para la escalera de la planta siguiente.
286
+ function openingHitsStairs(room, keepOut) {
287
+ const walls = [
288
+ { open: 'openNorth', axis: 'x', coord: room.z },
289
+ { open: 'openSouth', axis: 'x', coord: room.z + room.depth - 1 },
290
+ { open: 'openWest', axis: 'z', coord: room.x },
291
+ { open: 'openEast', axis: 'z', coord: room.x + room.width - 1 }
292
+ ];
293
+ for (const { open, axis, coord } of walls) {
294
+ const range = room[open + 'Range'];
295
+ const keep = stairKeepOutRange({ stairKeepOut: keepOut }, axis, coord);
296
+ if (!room[open] || !range || !keep) continue;
297
+ if (range.start < keep.end && keep.start < range.end) return true;
298
+ }
299
+ return false;
300
+ }
301
+
302
+ /**
303
+ * Elige dónde poner la escalera que sube desde la planta `level`: la sala más
304
+ * apropiada (living > comedor > cocina > dormitorio) y, a igualdad, la más
305
+ * grande, que es la que deja más piso libre alrededor del tramo. No se usan
306
+ * salas que ya tienen escalera (ni las que heredan su hueco de la planta de
307
+ * abajo) ni salas cuyas puertas caerían sobre el tramo. Devuelve el plan o
308
+ * null si no hay ninguna sala donde quepa.
309
+ */
310
+ export function planStairs(parcelRooms, rise, width = stairWidth(parcelRooms), level = 0) {
311
+ if (rise <= 0) return null;
312
+ let best = null;
313
+ let bestRank = Infinity;
314
+ for (const room of parcelRooms) {
315
+ if (SKIP_TYPES.has(room.type)) continue;
316
+ if ((room.floor || 0) !== level) continue;
317
+ // el hueco de una escalera de la planta de abajo (heredado) no puede
318
+ // pisarse; el resto de la sala sí sirve para otra escalera
319
+ const plan = buildPlan(room, rise, width, keepOut =>
320
+ !(room.stairKeepOut && keepOutsOverlap(room.stairKeepOut, keepOut)) &&
321
+ !openingHitsStairs(room, keepOut));
322
+ if (!plan) continue;
323
+ const rank = typeRank(room);
324
+ const better = !best || rank < bestRank ||
325
+ (rank === bestRank && plan.area > best.area);
326
+ if (better) {
327
+ best = plan;
328
+ bestRank = rank;
329
+ }
330
+ }
331
+ return best;
332
+ }
333
+
334
+ /**
335
+ * Deja el plan anotado en la sala que lleva la escalera: `stairs` para que el
336
+ * generador de volumen labre los escalones y `stairKeepOut` para que las
337
+ * puertas lo esquiven.
338
+ */
339
+ export function applyStairPlan(plan) {
340
+ if (!plan) return;
341
+ const room = plan.room;
342
+ room.stairKeepOut = plan.keepOut;
343
+ room.stairs = {
344
+ axis: plan.axis,
345
+ dir: plan.dir,
346
+ startX: plan.startX,
347
+ startZ: plan.startZ,
348
+ cross0: plan.cross0,
349
+ cross1: plan.cross1,
350
+ baseY: plan.baseY,
351
+ run: plan.run,
352
+ texture: room.floorTexture
353
+ };
354
+ }
355
+
356
+ // probabilidad de que una sala de la planta lleve botín fijo
357
+ export const LOOT_PROBABILITY_POR_SALA = 0.25;
358
+
359
+ /**
360
+ * Elige las salas que llevan botín fijo en la planta `level`: cada sala
361
+ * elegible (sin pasillo, spawn ni caja de escalera) tira por separado con
362
+ * probabilidad LOOT_PROBABILITY_POR_SALA. Devuelve la lista (puede ser vacía).
363
+ */
364
+ export function pickLootRooms(parcelRooms, level = 0, random = Math.random) {
365
+ const elegidas = [];
366
+ for (const room of parcelRooms) {
367
+ if (LOOT_SKIP_TYPES.has(room.type)) continue;
368
+ if ((room.floor || 0) !== level) continue;
369
+ if (random() < LOOT_PROBABILITY_POR_SALA) elegidas.push(room);
370
+ }
371
+ return elegidas;
372
+ }
373
+
374
+ /**
375
+ * Punto concreto donde apoya la caja dentro de `room`: una celda del interior,
376
+ * lo más cerca posible del centro, que no caiga en el hueco de la escalera.
377
+ * Devuelve coordenadas de mundo con la caja apoyada sobre la capa de piso.
378
+ */
379
+ export function pickLootSpot(room) {
380
+ if (!room) return null;
381
+ const x0 = room.x + 1;
382
+ const x1 = room.x + room.width - 2;
383
+ const z0 = room.z + 1;
384
+ const z1 = room.z + room.depth - 2;
385
+ const cx = Math.floor((x0 + x1) / 2);
386
+ const cz = Math.floor((z0 + z1) / 2);
387
+ const keep = room.stairKeepOut;
388
+ const enKeepOut = (x, z) => !!keep &&
389
+ x >= keep.x0 && x < keep.x1 && z >= keep.z0 && z < keep.z1;
390
+
391
+ let mejor = null;
392
+ let mejorDist = Infinity;
393
+ for (let x = x0; x <= x1; x++) {
394
+ for (let z = z0; z <= z1; z++) {
395
+ if (enKeepOut(x, z)) continue;
396
+ const d = (x - cx) * (x - cx) + (z - cz) * (z - cz);
397
+ if (d < mejorDist) {
398
+ mejor = { x, z };
399
+ mejorDist = d;
400
+ }
401
+ }
402
+ }
403
+ if (!mejor) return null;
404
+ return { x: mejor.x + 0.5, y: room.y + 1, z: mejor.z + 0.5 };
405
+ }
406
+
407
+ /**
408
+ * Armario de la sala (supervivencia, ver cliente/necesidades_config.js): según
409
+ * la probabilidad del tipo de sala se decide si lleva uno y qué trae (comida,
410
+ * agua, ambos o vacío) y CUÁNTO (`cantidad` {comida, agua}, ver
411
+ * CANTIDAD_ARMARIO); todo se sortea UNA vez, acá. Va en una esquina del
412
+ * interior, fuera del hueco de la escalera y de la celda de la caja de botín,
413
+ * con la espalda contra una de las dos paredes de la esquina.
414
+ *
415
+ * `rot` es hacia dónde mira el frente (0 = +z, 1 = +x, 2 = -z, 3 = -x) y
416
+ * `ext` hacia dónde se extiende a lo largo de la pared (alejándose del rincón,
417
+ * para ocupar la celda de al lado: ver cliente/armarios_config.js); `rot2` y
418
+ * `ext2` son lo mismo para la otra pared de la esquina. El servidor elige entre
419
+ * las dos según cuál tenga pared maciza detrás y lugar al lado (ver armarios.js).
420
+ * Devuelve `{x, y, z, contenido, cantidad, rot, ext, rot2, ext2}` o null.
421
+ */
422
+ export function pickArmario(room, random = Math.random) {
423
+ if (!room) return null;
424
+ const contenido = sortearArmario(room.type, random);
425
+ if (!contenido) return null;
426
+ const x0 = room.x + 1, x1 = room.x + room.width - 2;
427
+ const z0 = room.z + 1, z1 = room.z + room.depth - 2;
428
+ if (x1 < x0 || z1 < z0) return null;
429
+ const keep = room.stairKeepOut;
430
+ const loot = room.lootSpot;
431
+ // [x, z, rot si la pared es la de oeste/este, rot si es la de norte/sur]
432
+ const esquinas = [[x0, z0, 1, 0], [x1, z0, 3, 0], [x0, z1, 1, 2], [x1, z1, 3, 2]];
433
+ // orden al azar para no apilar siempre contra la misma pared
434
+ for (let i = esquinas.length - 1; i > 0; i--) {
435
+ const j = Math.floor(random() * (i + 1));
436
+ [esquinas[i], esquinas[j]] = [esquinas[j], esquinas[i]];
437
+ }
438
+ for (const [x, z, rotX, rotZ] of esquinas) {
439
+ if (keep && x >= keep.x0 && x < keep.x1 && z >= keep.z0 && z < keep.z1) continue;
440
+ if (loot && Math.floor(loot.x) === x && Math.floor(loot.z) === z) continue;
441
+ const cantidad = sortearCantidades(contenido, random);
442
+ // contra la pared oeste/este se extiende en z; contra la norte/sur, en x (siempre alejándose del rincón)
443
+ const extX = [x === x0 ? 1 : -1, 0], extZ = [0, z === z0 ? 1 : -1];
444
+ const primero = random() < 0.5;
445
+ return {
446
+ x: x + 0.5, y: room.y + 1, z: z + 0.5, contenido, cantidad,
447
+ rot: primero ? rotX : rotZ, ext: primero ? extZ : extX,
448
+ rot2: primero ? rotZ : rotX, ext2: primero ? extX : extZ
449
+ };
450
+ }
451
+ return null;
452
+ }
453
+
454
+ // alto del jugador (cliente/player.js): para pararse en el techo hacen falta
455
+ // este número de bloques libres encima de la cubierta.
456
+ const ALTO_JUGADOR = 4;
457
+
458
+ // --- Construcciones de azotea (ver planRoofExtras / buildRoofExtras) ---
459
+ // Casilla de la escalera: el cuartito con techo y puerta por el que se sale a
460
+ // la azotea. Alto libre por dentro, alto de la puerta y cuánto descanso
461
+ // techado se intenta dejar más allá del último escalón.
462
+ const CASILLA_ALTO = 6;
463
+ const CASILLA_ALTO_PUERTA = ALTO_JUGADOR + 1;
464
+ const CASILLA_ANCHO_PUERTA = 3;
465
+ const CASILLA_DESCANSO = 2;
466
+ // Tanque de agua: la mitad de las casas lleva uno, y de esos la mitad va
467
+ // sobre cuatro patas y la otra mitad apoyado directo en la cubierta.
468
+ const PROB_TANQUE = 0.5;
469
+ const PROB_TANQUE_CON_PATAS = 0.5;
470
+ const TANQUE_LARGO = 5, TANQUE_ANCHO = 4, TANQUE_ALTO = 3, TANQUE_PATAS = 3;
471
+ const TANQUE_TINTE = 0x39434f;
472
+ // Bloques que tiene que haber libres dentro del mundo por encima de la
473
+ // cubierta: lo más alto que se le construye encima (casilla con su losa, o
474
+ // tanque con patas) más uno de margen.
475
+ const ALTO_SOBRE_AZOTEA = Math.max(ALTO_JUGADOR, CASILLA_ALTO + 1, TANQUE_PATAS + TANQUE_ALTO) + 1;
476
+
477
+ /**
478
+ * Cuántas plantas caben en el volumen sin que el techo de la última quede
479
+ * pegado al borde del mundo: la cubierta está en `baseY + plantas * rise` y
480
+ * tiene que dejar ALTO_JUGADOR bloques libres encima.
481
+ */
482
+ export function maxFloorsFitting(baseY, rise, volumeHeight) {
483
+ if (rise <= 0) return 1;
484
+ return Math.max(1, Math.floor((volumeHeight - 1 - ALTO_SOBRE_AZOTEA - baseY) / rise));
485
+ }
486
+
487
+ /**
488
+ * Saca de `structures` las salas de la planta `floor` de la parcela.
489
+ */
490
+ export function removeFloor(structures, parcelId, floor) {
491
+ for (let i = structures.length - 1; i >= 0; i--) {
492
+ const s = structures[i];
493
+ if (s.parcelId === parcelId && (s.floor || 0) === floor) structures.splice(i, 1);
494
+ }
495
+ }
496
+
497
+ /**
498
+ * Quita la escalera anotada en la sala (la de `stairs` y su `stairKeepOut`).
499
+ * Acepta null para simplificar el llamado.
500
+ */
501
+ export function clearStairPlan(plan) {
502
+ if (!plan) return;
503
+ delete plan.room.stairs;
504
+ delete plan.room.stairKeepOut;
505
+ }
506
+
507
+ /** ¿La sala tiene alguna puerta? */
508
+ export function hasDoor(room) {
509
+ return !!(room.openNorth || room.openSouth || room.openEast || room.openWest);
510
+ }
511
+
512
+ // copia una sala a la planta de arriba (`stairKeepOut` se hereda: el hueco de
513
+ // la escalera de abajo también llega al descanso de la planta siguiente)
514
+ function cloneUp(room, rise) {
515
+ const c = Object.assign({}, room);
516
+ c.y = room.y + rise;
517
+ c.floor = (room.floor || 0) + 1;
518
+ delete c.roomId;
519
+ delete c.stairs; // la escalera se labra una sola vez, desde abajo
520
+ delete c.hasFrontDoor; // la puerta de calle existe sólo en la planta baja
521
+ // la puerta al patio daría al vacío si se repite arriba
522
+ if (room.rearDoorSide) {
523
+ delete c['open' + room.rearDoorSide];
524
+ delete c['open' + room.rearDoorSide + 'Range'];
525
+ delete c.rearDoorSide;
526
+ delete c.doorHeight;
527
+ }
528
+ ['North', 'South', 'West', 'East'].forEach(dir => {
529
+ const openKey = 'open' + dir + 'Range';
530
+ if (c[openKey]) c[openKey] = Object.assign({}, c[openKey]);
531
+ // las ventanas se recalculan por planta
532
+ delete c['window' + dir + 'Range'];
533
+ });
534
+ return c;
535
+ }
536
+
537
+ /**
538
+ * Clona las salas de la parcela una planta más arriba y las agrega a
539
+ * `structures`. Devuelve las salas nuevas.
540
+ */
541
+ export function buildUpperFloor(parcelRooms, structures, rise) {
542
+ const clones = [];
543
+ for (const room of parcelRooms) {
544
+ if (room.type === 'spawn') continue;
545
+ const clone = cloneUp(room, rise);
546
+ clones.push(clone);
547
+ structures.push(clone);
548
+ }
549
+ return clones;
550
+ }
551
+
552
+ /**
553
+ * Levanta el antepecho de los techos: un bloque por encima de la cubierta, a
554
+ * lo largo del perímetro de la casa. Ahora que por la caja de escalera se sale
555
+ * al techo, el pretil es lo que evita caerse por el borde de un tiro.
556
+ *
557
+ * Sólo va en el perímetro, no sobre las paredes de adentro: una celda de pared
558
+ * de la planta más alta lleva pretil cuando la celda vecina de ese lado no es
559
+ * parte de la misma casa. Así el techo queda despejado por dentro y amurallado
560
+ * por fuera.
561
+ */
562
+ export function buildRoofParapets(volume, structures, width, depth, volumeHeight) {
563
+ // salas de la planta más alta de cada casa, que son las que tienen cubierta
564
+ const topFloor = new Map();
565
+ for (const s of structures) {
566
+ if (!s.parcelId || s.type === 'spawn') continue;
567
+ const f = s.floor || 0;
568
+ if (!topFloor.has(s.parcelId) || f > topFloor.get(s.parcelId)) {
569
+ topFloor.set(s.parcelId, f);
570
+ }
571
+ }
572
+ const roof = structures.filter(s =>
573
+ s.parcelId && s.type !== 'spawn' && (s.floor || 0) === topFloor.get(s.parcelId)
574
+ );
575
+
576
+ // ¿(x,z) cae dentro de alguna sala con cubierta de esta misma casa?
577
+ const sameHouse = (parcelId, x, z) => roof.some(s =>
578
+ s.parcelId === parcelId &&
579
+ x >= s.x && x < s.x + s.width && z >= s.z && z < s.z + s.depth
580
+ );
581
+
582
+ for (const s of roof) {
583
+ const y = s.y + s.height; // un bloque sobre la cubierta
584
+ if (y < 0 || y >= volumeHeight) continue;
585
+ const texture = (s.wallTexture !== undefined) ? s.wallTexture : BLOCK_TYPES.BRICK;
586
+ const x1 = s.x + s.width - 1;
587
+ const z1 = s.z + s.depth - 1;
588
+ for (let x = s.x; x <= x1; x++) {
589
+ for (let z = s.z; z <= z1; z++) {
590
+ // sólo el anillo de pared de la sala
591
+ if (x !== s.x && x !== x1 && z !== s.z && z !== z1) continue;
592
+ if (x < 0 || x >= width || z < 0 || z >= depth) continue;
593
+ // ...y sólo donde dé al exterior de la casa
594
+ const exterior =
595
+ (x === s.x && !sameHouse(s.parcelId, x - 1, z)) ||
596
+ (x === x1 && !sameHouse(s.parcelId, x + 1, z)) ||
597
+ (z === s.z && !sameHouse(s.parcelId, x, z - 1)) ||
598
+ (z === z1 && !sameHouse(s.parcelId, x, z + 1));
599
+ if (!exterior) continue;
600
+ volume.set(x, y, z, texture);
601
+ }
602
+ }
603
+ }
604
+ }
605
+
606
+ /**
607
+ * Decide qué se construye sobre la azotea de una casa y lo deja anotado en
608
+ * sus salas (sólo datos; lo levanta `buildRoofExtras` y la luz la planta
609
+ * `agregarLucesInteriores` en mapType3Block.js):
610
+ *
611
+ * - `casillaAzotea`, en la sala del tramo que sale al techo: un cuartito
612
+ * con techo que cubre el hueco de la escalera, con una puerta hacia la
613
+ * azotea y una luz adentro que queda prendida de noche.
614
+ * - `tanqueAzotea`, en la mitad de las casas (tengan escalera o no): un
615
+ * tanque de agua rectangular, la mitad de las veces sobre cuatro patas.
616
+ *
617
+ * @param {object[]} topRooms salas de la planta más alta de la casa
618
+ * @param {object|null} stairPlan el tramo que sube a la azotea, si hay
619
+ */
620
+ export function planRoofExtras(topRooms, stairPlan) {
621
+ const rooms = topRooms.filter(s => s.type !== 'spawn');
622
+ if (rooms.length === 0) return;
623
+ // Cerca del borde del mundo el generador recorta las casas y otras
624
+ // construcciones pisan la parcela: ahí no se levanta nada.
625
+ const BORDE = 12;
626
+ const enAzotea = (x, z) =>
627
+ x >= BORDE && z >= BORDE && x < WORLD_CONFIG.width - BORDE && z < WORLD_CONFIG.height - BORDE &&
628
+ rooms.some(s => x >= s.x && x < s.x + s.width && z >= s.z && z < s.z + s.depth);
629
+ // el anillo exterior lleva el antepecho (ver buildRoofParapets)
630
+ const enBorde = (x, z) => !(enAzotea(x - 1, z) && enAzotea(x + 1, z) && enAzotea(x, z - 1) && enAzotea(x, z + 1));
631
+ const despejado = (x, z) => enAzotea(x, z) && !enBorde(x, z);
632
+
633
+ let ocupado = null; // caja (inclusive) que el tanque tiene que esquivar
634
+ if (stairPlan) {
635
+ const casilla = planCasilla(stairPlan, enAzotea, despejado);
636
+ const st = stairPlan;
637
+ const first = (st.axis === 'x') ? st.startX : st.startZ;
638
+ const last = first + st.dir * (st.run - 1);
639
+ // aunque no haya entrado la casilla, el hueco de la escalera se esquiva
640
+ ocupado = casilla || ((st.axis === 'x')
641
+ ? { x0: Math.min(first, last), x1: Math.max(first, last), z0: st.cross0, z1: st.cross1 }
642
+ : { x0: st.cross0, x1: st.cross1, z0: Math.min(first, last), z1: Math.max(first, last) });
643
+ if (casilla) stairPlan.room.casillaAzotea = casilla;
644
+ else console.log(' sin lugar para la casilla de la escalera en la azotea');
645
+ }
646
+
647
+ if (Math.random() >= PROB_TANQUE) return;
648
+ const conPatas = Math.random() < PROB_TANQUE_CON_PATAS;
649
+ const girado = Math.random() < 0.5;
650
+ const w = girado ? TANQUE_ANCHO : TANQUE_LARGO;
651
+ const d = girado ? TANQUE_LARGO : TANQUE_ANCHO;
652
+ const MARGEN = 2; // paso libre alrededor del tanque y hasta la casilla
653
+ const orden = rooms.slice().sort(() => Math.random() - 0.5);
654
+ for (const room of orden) {
655
+ for (let intento = 0; intento < 12; intento++) {
656
+ const x0 = room.x + Math.floor(Math.random() * Math.max(1, room.width - w + 1));
657
+ const z0 = room.z + Math.floor(Math.random() * Math.max(1, room.depth - d + 1));
658
+ let libre = true;
659
+ for (let x = x0 - 1; x <= x0 + w && libre; x++) {
660
+ for (let z = z0 - 1; z <= z0 + d && libre; z++) {
661
+ if (!despejado(x, z)) libre = false;
662
+ }
663
+ }
664
+ if (libre && ocupado &&
665
+ x0 - MARGEN <= ocupado.x1 && ocupado.x0 <= x0 + w - 1 + MARGEN &&
666
+ z0 - MARGEN <= ocupado.z1 && ocupado.z0 <= z0 + d - 1 + MARGEN) libre = false;
667
+ if (!libre) continue;
668
+ room.tanqueAzotea = { x0, z0, w, d, roofY: room.y + room.height - 1, conPatas };
669
+ return;
670
+ }
671
+ }
672
+ }
673
+
674
+ // La casilla: caja de paredes alrededor del hueco del tramo, alargada hacia
675
+ // la salida para dejar un descanso techado, con la puerta en la pared del
676
+ // fondo (de frente a quien sube) o, si esa da al vacío o al antepecho, en un
677
+ // costado del descanso. Devuelve null si no hay cómo ponerle una puerta que
678
+ // dé a la azotea.
679
+ function planCasilla(st, enAzotea, despejado) {
680
+ const first = (st.axis === 'x') ? st.startX : st.startZ;
681
+ // (i a lo largo del tramo, c a lo ancho) -> celda del mundo
682
+ const celda = (i, c) => (st.axis === 'x')
683
+ ? { x: first + st.dir * i, z: c }
684
+ : { x: c, z: first + st.dir * i };
685
+ const roofY = st.baseY + st.run; // la capa de la cubierta
686
+ const c0 = st.cross0 - 1, c1 = st.cross1 + 1;
687
+
688
+ for (let descanso = CASILLA_DESCANSO; descanso >= 0; descanso--) {
689
+ const iFondo = st.run + descanso; // pared del fondo
690
+ let entra = true;
691
+ for (let i = -1; i <= iFondo && entra; i++) {
692
+ for (let c = c0; c <= c1 && entra; c++) {
693
+ const p = celda(i, c);
694
+ if (!enAzotea(p.x, p.z)) entra = false;
695
+ }
696
+ }
697
+ if (!entra) continue;
698
+
699
+ // candidatas a puerta: [celdas de pared], cada una con su celda de afuera
700
+ const candidatas = [];
701
+ const ancho = Math.min(CASILLA_ANCHO_PUERTA, st.cross1 - st.cross0 + 1);
702
+ const cPuerta = st.cross0 + Math.floor((st.cross1 - st.cross0 + 1 - ancho) / 2);
703
+ const fondo = [];
704
+ for (let k = 0; k < ancho; k++) fondo.push({ pared: celda(iFondo, cPuerta + k), afuera: celda(iFondo + 1, cPuerta + k) });
705
+ candidatas.push(fondo);
706
+ // costados: sólo a la altura del piso techado (último escalón + descanso)
707
+ const iPiso0 = Math.max(st.run - 1, iFondo - CASILLA_ANCHO_PUERTA);
708
+ if (iFondo - iPiso0 >= 2) {
709
+ for (const [c, cAfuera] of [[c0, c0 - 1], [c1, c1 + 1]]) {
710
+ const lado = [];
711
+ for (let i = iPiso0; i < iFondo; i++) lado.push({ pared: celda(i, c), afuera: celda(i, cAfuera) });
712
+ candidatas.push(lado);
713
+ }
714
+ }
715
+ const puerta = candidatas.find(cs => cs.every(({ afuera }) => despejado(afuera.x, afuera.z)));
716
+ if (!puerta) continue;
717
+
718
+ const a = celda(-1, c0), b = celda(iFondo, c1);
719
+ const centro = celda((st.run - 1 + iFondo - 1) / 2, (st.cross0 + st.cross1) / 2);
720
+ return {
721
+ x0: Math.min(a.x, b.x), x1: Math.max(a.x, b.x),
722
+ z0: Math.min(a.z, b.z), z1: Math.max(a.z, b.z),
723
+ roofY,
724
+ puerta: puerta.map(({ pared }) => pared),
725
+ luz: { x: centro.x + 0.5, y: roofY + CASILLA_ALTO - 0.5, z: centro.z + 0.5 }
726
+ };
727
+ }
728
+ return null;
729
+ }
730
+
731
+ /**
732
+ * Levanta en el volumen lo que `planRoofExtras` dejó anotado: casillas de
733
+ * escalera y tanques de agua. Va después de las escaleras y los antepechos.
734
+ */
735
+ export function buildRoofExtras(volume, structures, width, depth, volumeHeight) {
736
+ const poner = (x, y, z, tipo, tinte, opacidad) => {
737
+ if (x < 0 || x >= width || z < 0 || z >= depth || y < 0 || y >= volumeHeight) return;
738
+ volume.set(x, y, z, tipo);
739
+ if (tipo !== BLOCK_TYPES.AIR && tinte != null && isTintableRender(tipo)) {
740
+ tintBlockRender(volume, x, y, z, tinte, opacidad);
741
+ }
742
+ };
743
+ for (const s of structures) {
744
+ const cas = s.casillaAzotea;
745
+ if (cas) {
746
+ const pared = (s.wallTexture !== undefined) ? s.wallTexture : BLOCK_TYPES.BRICK;
747
+ const tinte = (s.tintRender != null) ? s.tintRender : null;
748
+ const opacidad = (s.tintOpacity != null) ? s.tintOpacity : 0.5;
749
+ const esPuerta = (x, z) => cas.puerta.some(p => p.x === x && p.z === z);
750
+ for (let x = cas.x0; x <= cas.x1; x++) {
751
+ for (let z = cas.z0; z <= cas.z1; z++) {
752
+ const anillo = x === cas.x0 || x === cas.x1 || z === cas.z0 || z === cas.z1;
753
+ if (anillo) {
754
+ const puerta = esPuerta(x, z);
755
+ for (let h = 1; h <= CASILLA_ALTO; h++) {
756
+ if (puerta && h <= CASILLA_ALTO_PUERTA) poner(x, cas.roofY + h, z, BLOCK_TYPES.AIR);
757
+ else poner(x, cas.roofY + h, z, pared, tinte, opacidad);
758
+ }
759
+ }
760
+ // la losa que la techa
761
+ poner(x, cas.roofY + CASILLA_ALTO + 1, z, BLOCK_TYPES.GRAY);
762
+ }
763
+ }
764
+ }
765
+ const t = s.tanqueAzotea;
766
+ if (t) {
767
+ const base = t.roofY + 1 + (t.conPatas ? TANQUE_PATAS : 0);
768
+ if (t.conPatas) {
769
+ for (const [x, z] of [[t.x0, t.z0], [t.x0 + t.w - 1, t.z0], [t.x0, t.z0 + t.d - 1], [t.x0 + t.w - 1, t.z0 + t.d - 1]]) {
770
+ for (let y = t.roofY + 1; y < base; y++) poner(x, y, z, BLOCK_TYPES.GRAY);
771
+ }
772
+ }
773
+ for (let x = t.x0; x < t.x0 + t.w; x++) {
774
+ for (let z = t.z0; z < t.z0 + t.d; z++) {
775
+ for (let y = base; y < base + TANQUE_ALTO; y++) poner(x, y, z, BLOCK_TYPES.GRAY, TANQUE_TINTE, 0.75);
776
+ }
777
+ }
778
+ }
779
+ }
780
+ }
781
+
782
+ /**
783
+ * Labra las escaleras en el volumen. Por cada escalón se vacía la columna
784
+ * completa hasta el entrepiso —ese hueco es la caja de escalera, lo que permite
785
+ * asomar la cabeza a la planta alta— y después se rellena el escalón. El último
786
+ * escalón queda justo a la altura del piso de arriba, así que tapa su propio
787
+ * hueco y se puede caminar desde él hacia el descanso.
788
+ */
789
+ export function carveStairs(volume, structures, width, depth, volumeHeight) {
790
+ for (const s of structures) {
791
+ const st = s.stairs;
792
+ if (!st) continue;
793
+ const texture = (st.texture !== undefined) ? st.texture : BLOCK_TYPES.GRAY;
794
+ for (let i = 0; i < st.run; i++) {
795
+ const x = st.startX + (st.axis === 'x' ? i * st.dir : 0);
796
+ const z = st.startZ + (st.axis === 'z' ? i * st.dir : 0);
797
+ for (let c = st.cross0; c <= st.cross1; c++) {
798
+ const cx = (st.axis === 'x') ? x : c;
799
+ const cz = (st.axis === 'x') ? c : z;
800
+ if (cx < 0 || cx >= width || cz < 0 || cz >= depth) continue;
801
+ for (let y = st.baseY + 1; y <= st.baseY + st.run; y++) {
802
+ if (y < 0 || y >= volumeHeight) continue;
803
+ volume.set(cx, y, cz, BLOCK_TYPES.AIR);
804
+ }
805
+ // la escalera es una losa de GROSOR_ESCALERA bloques, no un
806
+ // macizo desde el piso: debajo del tramo queda aire.
807
+ const pisada = st.baseY + 1 + i;
808
+ const desde = Math.max(st.baseY + 1, pisada - GROSOR_ESCALERA + 1);
809
+ for (let y = desde; y <= pisada; y++) {
810
+ if (y < 0 || y >= volumeHeight) continue;
811
+ volume.set(cx, y, cz, texture);
812
+ }
813
+ }
814
+ }
815
+ }
816
+ }