@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,361 @@
1
+ // nuevo generador de ventanas: algoritmo modularizado según especificación del usuario
2
+ // Función diseñada para ejecutarse **una vez por parcela**, recibiendo la lista
3
+ // de salas que componen esa casa y el conjunto completo de estructuras para
4
+ // detectar adyacencias externas.
5
+
6
+ // (la versión anterior interpretaba el primer parámetro como el arreglo
7
+ // global de estructuras y filtraba internamente, lo cual llevó a la
8
+ // confusión mencionada por el usuario). Conservamos la compatibilidad
9
+ // mínima detectando el número de argumentos.
10
+
11
+ /**
12
+ * Comprueba si dos intervalos [a0,a1) y [b0,b1) se solapan (auxiliar).
13
+ */
14
+ function rangesOverlap(a0, a1, b0, b1) {
15
+ return a0 < b1 && b0 < a1;
16
+ }
17
+
18
+ import { BLOCK_TYPES } from '../mapConfig.js';
19
+
20
+ // parámetros por defecto de ventana (se podrían exponer si se desea)
21
+ // ahora la anchura base se ha doblado para cumplir la nueva especificación
22
+ // Nota: durante el cálculo de ventanas, si una pared no tiene espacio
23
+ // suficiente para el ancho estándar (`DEFAULT_WINDOW_LENGTH`), el algoritmo
24
+ // reduce la longitud efectiva a `pared.length - 2` (pero nunca menos de 1).
25
+ // Esto permite abrir una ventana incluso en paredes muy cortas; la lógica se
26
+ // encuentra en `assignWindows`.
27
+ const DEFAULT_WINDOW_LENGTH = 6;
28
+ // la altura se reduce en 1 para compensar el desplazamiento vertical
29
+ const DEFAULT_WINDOW_HEIGHT = 3;
30
+ // la elevación base se ajusta: ahora la ventana arranca dos bloques por
31
+ // encima del piso, como pide la última especificación. para compensar se
32
+ // reduce la altura efectiva en 1 (reflejado más abajo).
33
+ const DEFAULT_WINDOW_ELEVATION = 3; // bloques sobre el piso
34
+
35
+ // separación mínima entre ventanas adyacentes (por defecto igual al ancho de
36
+ // ventana, igual que antes en el código original donde cada pared sólo podía
37
+ // alojar una ventana única). se puede anular pasando
38
+ // `params.separation` a `assignWindows` o a `addWindows`.
39
+ const DEFAULT_WINDOW_SEPARATION = 2;
40
+
41
+ // constantes de cuadras/calles (duplicadas de mapType3Block.js para poder
42
+ // calcular si una coordenada está sobre una calle sin necesidad de importar
43
+ // el módulo entero).
44
+ const blockZoneSize = 176;
45
+ const streetWidth = 20;
46
+ const patternSize = blockZoneSize + streetWidth;
47
+
48
+ /**
49
+ * determina si una posición de minimapa corresponde a la calzada de una calle
50
+ * (se usa para permitir ventanas en el borde del solar si dan a la calle).
51
+ */
52
+ function isStreetCoord(x, z) {
53
+ const inStreetX = (x % patternSize) >= blockZoneSize;
54
+ const inStreetZ = (z % patternSize) >= blockZoneSize;
55
+ return inStreetX || inStreetZ;
56
+ }
57
+
58
+ /**
59
+ * Dados los límites del solar y una lista de estructuras, comprueba si la
60
+ * celda ((nx,nz) justo fuera de una pared) pertenece a otra habitación.
61
+ */
62
+ function structureAt(structures, nx, nz) {
63
+ return structures.some(t =>
64
+ nx >= t.x && nx < t.x + t.width &&
65
+ nz >= t.z && nz < t.z + t.depth
66
+ );
67
+ }
68
+
69
+ /**
70
+ * Las casas de dos plantas repiten la misma huella en altura, así que una sala
71
+ * sólo puede tapar la pared de otra si están en el mismo piso. Devuelve la
72
+ * sublista de `structures` que vive en la planta `floor` (memoizada por
73
+ * llamada a addWindows, que recorre muchas salas con la misma lista).
74
+ */
75
+ function structuresOnFloor(structures, floor, cache) {
76
+ const key = floor || 0;
77
+ let list = cache.get(key);
78
+ if (!list) {
79
+ list = structures.filter(t => (t.floor || 0) === key);
80
+ cache.set(key, list);
81
+ }
82
+ return list;
83
+ }
84
+
85
+ /**
86
+ * comprueba si un bloque de pared concreto ya forma parte de una abertura (puerta)
87
+ */
88
+ function isBlockedByOpening(room, x, z) {
89
+ // helper: bloquea un rango en una pared N/S (eje X) o E/O (eje Z).
90
+ // cuando hay Range se usa directamente; si falta (p.ej. puerta de patio
91
+ // que markRearDoor deja sin range) se calcula igual que mapType3.js:
92
+ // doorWidth = Math.min(4, lado - 2), centrado en la pared.
93
+ const blockedX = (range, wallZ) => {
94
+ if (z !== wallZ) return false;
95
+ if (range) return x >= range.start && x < range.end;
96
+ const dw = Math.min(4, room.width - 2);
97
+ const ds = room.x + Math.floor((room.width - dw) / 2);
98
+ return x >= ds && x < ds + dw;
99
+ };
100
+ const blockedZ = (range, wallX) => {
101
+ if (x !== wallX) return false;
102
+ if (range) return z >= range.start && z < range.end;
103
+ const dw = Math.min(4, room.depth - 2);
104
+ const ds = room.z + Math.floor((room.depth - dw) / 2);
105
+ return z >= ds && z < ds + dw;
106
+ };
107
+
108
+ // puertas interiores entre habitaciones y puerta del patio (open* sin Range)
109
+ if (room.openNorth && blockedX(room.openNorthRange, room.z)) return true;
110
+ if (room.openSouth && blockedX(room.openSouthRange, room.z + room.depth - 1)) return true;
111
+ if (room.openWest && blockedZ(room.openWestRange, room.x)) return true;
112
+ if (room.openEast && blockedZ(room.openEastRange, room.x + room.width - 1)) return true;
113
+
114
+ // puerta de entrada (hasFrontDoor) — igual fórmula que mapType3.js
115
+ if (room.hasFrontDoor) {
116
+ const doorWidthX = Math.min(4, room.width - 2);
117
+ const doorWidthZ = Math.min(4, room.depth - 2);
118
+ const doorXStart = room.x + Math.floor((room.width - doorWidthX) / 2);
119
+ const doorZStart = room.z + Math.floor((room.depth - doorWidthZ) / 2);
120
+ if (room.frontNorth && z === room.z &&
121
+ x >= doorXStart && x < doorXStart + doorWidthX) return true;
122
+ if (room.frontSouth && z === room.z + room.depth - 1 &&
123
+ x >= doorXStart && x < doorXStart + doorWidthX) return true;
124
+ if (room.frontWest && x === room.x &&
125
+ z >= doorZStart && z < doorZStart + doorWidthZ) return true;
126
+ if (room.frontEast && x === room.x + room.width - 1 &&
127
+ z >= doorZStart && z < doorZStart + doorWidthZ) return true;
128
+ }
129
+ return false;
130
+ }
131
+
132
+ /**
133
+ * paso 2: para una sala genera el listado de posiciones de pared válidas para
134
+ * ventanas. devuelve coordenadas globales junto a orientación.
135
+ */
136
+ // obtener rectángulos de parcela a partir de los identificadores
137
+ // conocidos; cada `parcelId` es la coordenada de la esquina superior
138
+ // izquierda del solar.
139
+ function computeParcelRects(structures) {
140
+ const rects = Object.create(null);
141
+ structures.forEach(s => {
142
+ if (s.parcelId == null) return;
143
+ if (!rects[s.parcelId]) {
144
+ const parts = s.parcelId.split('_').map(Number);
145
+ rects[s.parcelId] = { x: parts[0], z: parts[1] };
146
+ }
147
+ });
148
+ return Object.entries(rects).map(([id, { x, z }]) => ({ id, x, z }));
149
+ }
150
+
151
+ function computeAvailableWallPositions(room, structures, plotX0, plotZ0, plotWidth, plotDepth, sameFloor) {
152
+ const positions = [];
153
+ // los rectángulos de parcela se calculan con TODAS las estructuras: una
154
+ // parcela vecina delimita terreno ajeno aunque allí no haya planta alta.
155
+ const parcelRects = computeParcelRects(structures);
156
+ // las adyacencias que tapan una pared, en cambio, sólo cuentan dentro de
157
+ // la misma planta.
158
+ const neighbours = sameFloor || structures;
159
+ const roomParcel = room.parcelId;
160
+ const { x, z, width, depth } = room;
161
+ const check = (wx, wz, orientation) => {
162
+ // no considerar si ya hay apertura justo en este bloque
163
+ if (isBlockedByOpening(room, wx, wz)) return;
164
+ // no permitir ventanas si existe habitación adyacente en el lado exterior
165
+ let outsideX = wx;
166
+ let outsideZ = wz;
167
+ if (orientation === 'north') outsideZ = wz - 1;
168
+ if (orientation === 'south') outsideZ = wz + 1;
169
+ if (orientation === 'west') outsideX = wx - 1;
170
+ if (orientation === 'east') outsideX = wx + 1;
171
+ if (structureAt(neighbours, outsideX, outsideZ)) return;
172
+ // si el bloque exterior cae dentro de cualquier otra parcela,
173
+ // consideramos que la pared mira a terreno vecino y rechazamos la
174
+ // posición. no importa si la pared está en el límite; la ventana
175
+ // podría generarse en una habitación que se extiende sobre parcelas y
176
+ // en ese caso cada bloque debe comprobarse.
177
+ for (const { id: pid, x: px, z: pz } of parcelRects) {
178
+ if (pid === roomParcel) continue;
179
+ if (outsideX >= px && outsideX < px + plotWidth &&
180
+ outsideZ >= pz && outsideZ < pz + plotDepth) {
181
+ return; // vecino
182
+ }
183
+ }
184
+ positions.push({ x: wx, z: wz, orientation });
185
+ };
186
+
187
+ // helper que comprueba si una coordenada está dentro del solar
188
+ const inParcel = (px, pz) =>
189
+ px >= plotX0 && px < plotX0 + plotWidth &&
190
+ pz >= plotZ0 && pz < plotZ0 + plotDepth;
191
+
192
+ // norte (solo los segmentos de la pared que permanecen dentro del lote)
193
+ for (let sx = x; sx < x + width; sx++) {
194
+ if (inParcel(sx, z)) check(sx, z, 'north');
195
+ }
196
+ // sur
197
+ for (let sx = x; sx < x + width; sx++) {
198
+ const wz = z + depth - 1;
199
+ if (inParcel(sx, wz)) check(sx, wz, 'south');
200
+ }
201
+ // oeste
202
+ for (let sz = z; sz < z + depth; sz++) {
203
+ if (inParcel(x, sz)) check(x, sz, 'west');
204
+ }
205
+ // este
206
+ for (let sz = z; sz < z + depth; sz++) {
207
+ const wx = x + width - 1;
208
+ if (inParcel(wx, sz)) check(wx, sz, 'east');
209
+ }
210
+ return positions;
211
+ }
212
+
213
+ /**
214
+ * paso 3: agrupa posiciones contiguas en el mismo eje para formar paredes.
215
+ * Devuelve un arreglo de paredes; cada pared es un arreglo de posiciones
216
+ * ordenadas según la dirección principal (x o z).
217
+ */
218
+ function groupPositionsIntoWalls(positions) {
219
+ const walls = [];
220
+ // separar por orientación y eje de crecimiento
221
+ const buckets = {
222
+ north: [], south: [], west: [], east: []
223
+ };
224
+ positions.forEach(p => buckets[p.orientation].push(p));
225
+ Object.keys(buckets).forEach(dir => {
226
+ const list = buckets[dir];
227
+ if (list.length === 0) return;
228
+ // ordenar por el eje correcto
229
+ const key = (dir === 'north' || dir === 'south') ? 'x' : 'z';
230
+ list.sort((a, b) => a[key] - b[key]);
231
+ // agrupar contiguos
232
+ let current = [list[0]];
233
+ for (let i = 1; i < list.length; i++) {
234
+ const prev = list[i - 1];
235
+ const cur = list[i];
236
+ if (cur[key] === prev[key] + 1) {
237
+ current.push(cur);
238
+ } else {
239
+ walls.push(current);
240
+ current = [cur];
241
+ }
242
+ }
243
+ walls.push(current);
244
+ });
245
+ return walls;
246
+ }
247
+
248
+ /**
249
+ * paso 4: a partir del arreglo de paredes decide dónde colocar una ventana
250
+ * para cada sala; si la pared es suficientemente larga, se marca el rango en
251
+ * la estructura de la sala (window*Range) centrado en la pared.
252
+ */
253
+ function assignWindows(room, walls, params = {}) {
254
+ const winLen = params.length || DEFAULT_WINDOW_LENGTH;
255
+ const winSep = params.separation != null ? params.separation : DEFAULT_WINDOW_SEPARATION;
256
+
257
+ // helper para añadir rango a la estructura de la sala; si `append` es true
258
+ // se garantiza que el valor sea un arreglo y se apilan varios rangos. la
259
+ // orientación se calcula a partir de la primera y última posición.
260
+ const addRange = (orient, first, last, append) => {
261
+ const key = 'window' + orient[0].toUpperCase() + orient.slice(1) + 'Range';
262
+ const range = {
263
+ start: (orient === 'north' || orient === 'south') ? first.x : first.z,
264
+ end: (orient === 'north' || orient === 'south') ? last.x + 1 : last.z + 1
265
+ };
266
+ if (append) {
267
+ if (!room[key]) room[key] = [];
268
+ if (!Array.isArray(room[key])) room[key] = [room[key]];
269
+ room[key].push(range);
270
+ } else {
271
+ room[key] = range;
272
+ }
273
+ };
274
+
275
+ walls.forEach(wall => {
276
+ const L = wall.length;
277
+ // Reservar siempre 1 bloque de margen al inicio y al final de la pared.
278
+ // Esto garantiza que:
279
+ // a) nunca haya una ventana en el bloque más extremo de la pared, y
280
+ // b) siempre haya al menos 1 bloque sólido entre una ventana y el
281
+ // borde del segmento (que puede colindar con una puerta eliminada
282
+ // por isBlockedByOpening), por lo que las puertas tienen prioridad.
283
+ const inner = wall.slice(1, L - 1);
284
+ const M = inner.length; // = L - 2
285
+ if (M <= 0) return; // pared demasiado corta para dejar márgenes
286
+
287
+ // si winLen no cabe en la zona interna, usamos toda ella
288
+ const effectiveWinLen = Math.min(winLen, M);
289
+
290
+ // cuántas ventanas caben si dejamos `winSep` bloques entre ellas
291
+ const count = Math.floor(M / (effectiveWinLen + winSep));
292
+ if (count < 2) {
293
+ // una única ventana centrada en la zona interna
294
+ const half = Math.floor(effectiveWinLen / 2);
295
+ const startIndex = Math.max(0, Math.floor(M / 2) - half);
296
+ const windowSpan = inner.slice(startIndex, startIndex + effectiveWinLen);
297
+ if (windowSpan.length < effectiveWinLen) return;
298
+ addRange(windowSpan[0].orientation, windowSpan[0], windowSpan[windowSpan.length - 1], false);
299
+ return;
300
+ }
301
+
302
+ // múltiples ventanas centradas en la zona interna
303
+ const totalSpan = count * effectiveWinLen + (count - 1) * winSep;
304
+ const startWallIndex = Math.floor((M - totalSpan) / 2);
305
+
306
+ for (let i = 0; i < count; i++) {
307
+ const winStart = startWallIndex + i * (effectiveWinLen + winSep);
308
+ const windowSpan = inner.slice(winStart, winStart + effectiveWinLen);
309
+ if (windowSpan.length < effectiveWinLen) break;
310
+ // siempre apilamos porque aquí puede haber múltiples rangos
311
+ addRange(windowSpan[0].orientation, windowSpan[0], windowSpan[windowSpan.length - 1], true);
312
+ }
313
+ });
314
+ }
315
+
316
+ /**
317
+ * función principal exportada; llamada una vez se han establecido las
318
+ * interconexiones entre salas de una misma casa. Recibe la lista completa de
319
+ * estructuras de la parcela y los límites del solar (plotX0,etc.).
320
+ */
321
+ export function addWindows(rooms, structures, plotX0, plotZ0, plotWidth, plotDepth /* orientation ignored */) {
322
+ // compatibilidad con la firma antigua: si el segundo argumento no es un
323
+ // array asumimos que el primer parámetro era la lista global de
324
+ // `structures` y no se pasó `rooms` por separado.
325
+ if (!Array.isArray(structures)) {
326
+ // reordenar argumentos
327
+ plotDepth = plotWidth;
328
+ plotWidth = plotZ0;
329
+ plotZ0 = plotX0;
330
+ plotX0 = structures;
331
+ structures = rooms;
332
+ // filtre sólo baños y generadores de spawn; antiguamente los pasillos
333
+ // también se excluían porque no había soporte, pero ya no es el caso.
334
+ rooms = structures.filter(s => s.type !== 'spawn' && s.type !== 'banio');
335
+ }
336
+
337
+ // ahora `rooms` debe contener sólo las salas de la casa/parcelas; ignorar baños
338
+ const floorCache = new Map();
339
+ rooms.forEach(room => {
340
+ if (room.type === 'banio') return; // doble comprobación defensiva
341
+ const sameFloor = structuresOnFloor(structures, room.floor, floorCache);
342
+ const avail = computeAvailableWallPositions(room, structures, plotX0, plotZ0, plotWidth, plotDepth, sameFloor);
343
+ const walls = groupPositionsIntoWalls(avail);
344
+ assignWindows(room, walls);
345
+ // anotar el tipo de bloque que corresponderá a estas ventanas
346
+ room.windowBlockType = BLOCK_TYPES.WINDOW;
347
+ });
348
+ }
349
+
350
+ // exportamos el valor también por si otros módulos quieren consultarlo
351
+ // exportamos los valores por defecto para que otros módulos (por ejemplo
352
+ // mapType3.js) puedan basarse en la misma configuración y reflejar cambios
353
+ // de elevación/altura sin duplicar constantes.
354
+ export const WINDOW_BLOCK_TYPE = BLOCK_TYPES.WINDOW;
355
+ export const DEFAULT_WINDOW_LENGTH_VALUE = DEFAULT_WINDOW_LENGTH;
356
+ export const DEFAULT_WINDOW_HEIGHT_VALUE = DEFAULT_WINDOW_HEIGHT;
357
+ export const DEFAULT_WINDOW_ELEVATION_VALUE = DEFAULT_WINDOW_ELEVATION;
358
+
359
+ // helper exports for testing/debugging
360
+ export { assignWindows };
361
+