@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.
- package/LICENSE +21 -0
- package/README.md +107 -2
- package/package.json +36 -4
- package/src/formato/chunk_compacto.js +263 -0
- package/src/generador/cartel_tienda.js +118 -0
- package/src/generador/construirMapa.js +447 -0
- package/src/generador/excavar_refugios.js +32 -0
- package/src/generador/genera_casa/bathroom_impl.js +87 -0
- package/src/generador/genera_casa/bathrooms_insert.js +104 -0
- package/src/generador/genera_casa/generadorCasa.js +470 -0
- package/src/generador/genera_casa/generadorCasaConexiones.js +299 -0
- package/src/generador/genera_casa/generadorCasaPisos.js +816 -0
- package/src/generador/genera_casa/generadorCasaVentanas.js +361 -0
- package/src/generador/genera_casa/ubicacionSalaCasa.js +486 -0
- package/src/generador/genera_nidos.js +74 -0
- package/src/generador/genera_refugios.js +301 -0
- package/src/generador/genera_tiendas.js +200 -0
- package/src/generador/mapConfig.js +549 -0
- package/src/generador/mapType3.js +635 -0
- package/src/generador/mapType3Block.js +476 -0
- package/src/generador/mapType3Center.js +137 -0
- package/src/generador/mapType3Parcel.js +63 -0
- package/src/generador/mapType3Utils.js +299 -0
- package/src/generador/volumeBuffer.js +210 -0
- package/src/index.js +23 -0
- package/src/plugins/datos.js +111 -0
- package/src/plugins/registro.js +48 -0
|
@@ -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
|
+
}
|