@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,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
|
+
|