@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,301 @@
|
|
|
1
|
+
// genera_refugios.js - Decide los refugios subterráneos del mapa
|
|
2
|
+
// (plan_supervivencia.md §13). Corre una sola vez al construir el mapa, con la
|
|
3
|
+
// heightMap todavía como arrays y las zonas `parcela` a mano; es puro (sin
|
|
4
|
+
// sockets, sin volumen): lo prueba scripts/test_refugios.mjs. Sólo DECIDE y
|
|
5
|
+
// describe (qué cajas excavar, dónde van la puerta, la trampilla, la luz y el
|
|
6
|
+
// armario); excavar el volumen lo hace `excavarRefugios` (mapType3.js) y el
|
|
7
|
+
// estado de puertas y trampillas vive en server/refugios.js.
|
|
8
|
+
//
|
|
9
|
+
// Geometría y marco local (u, v): ver cliente/refugios_config.js.
|
|
10
|
+
|
|
11
|
+
import {
|
|
12
|
+
PROB_REFUGIO_PARCELA, MIN_REFUGIOS, INTENTOS_REFUGIO, REFUGIO, PROFUNDIDAD_REFUGIO,
|
|
13
|
+
ejesRefugio, rotYHacia
|
|
14
|
+
} from '../plugins/datos.js';
|
|
15
|
+
import { ARMARIO } from '../plugins/datos.js';
|
|
16
|
+
import { ID_LUZ_INTERIOR } from '../plugins/datos.js';
|
|
17
|
+
import { BLOCK_TYPES } from './mapConfig.js';
|
|
18
|
+
|
|
19
|
+
// Tipos de sala de casa donde se puede abrir la salida si la parcela no tiene patio.
|
|
20
|
+
const SALAS_VALIDAS = new Set(['living', 'dormitorio', 'comedor', 'cocina']);
|
|
21
|
+
|
|
22
|
+
// Ancho de la huella (lateral): paredes en v = -2 y v = 4; el interior de la sala va de -1 a 3.
|
|
23
|
+
const V_MIN = -2, V_MAX = 4;
|
|
24
|
+
const U_MIN = -6;
|
|
25
|
+
// Desvíos (celdas) probados alrededor del centro de la sala de casa, del más cercano al más lejano
|
|
26
|
+
// (el centro suele tener el punto de botín: se corre la tapa lo mínimo).
|
|
27
|
+
const DESVIOS_CASA = [];
|
|
28
|
+
for (let dx = -4; dx <= 4; dx++) for (let dz = -4; dz <= 4; dz++) DESVIOS_CASA.push([dx, dz]);
|
|
29
|
+
DESVIOS_CASA.sort((p, q) => Math.hypot(...p) - Math.hypot(...q));
|
|
30
|
+
|
|
31
|
+
/** Datos derivados de la salida: dE (0 patio / 1 casa) manda el largo del tramo en la escalera. */
|
|
32
|
+
function perfil(S, dE) {
|
|
33
|
+
const F = S - PROFUNDIDAD_REFUGIO;
|
|
34
|
+
const lidStart = 4 + dE;
|
|
35
|
+
const aUlt = lidStart + REFUGIO.trampillaLargo - 1;
|
|
36
|
+
return { F, lidStart, aUlt, lidLayer: S - 1 + dE };
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
/** Celda mundo (entera) de la celda local (a, b). */
|
|
40
|
+
function celda(ref, a, b) {
|
|
41
|
+
const e = ejesRefugio(ref.rot);
|
|
42
|
+
return { x: ref.ox + a * e.uX + b * e.vX, z: ref.oz + a * e.uZ + b * e.vZ };
|
|
43
|
+
}
|
|
44
|
+
|
|
45
|
+
/** Rectángulo mundo [x0,x1) x [z0,z1) que cubren las celdas locales a∈[a0,a1], b∈[b0,b1]. */
|
|
46
|
+
function rectLocal(ref, a0, a1, b0, b1) {
|
|
47
|
+
const p = celda(ref, a0, b0), q = celda(ref, a1, b1);
|
|
48
|
+
return { x0: Math.min(p.x, q.x), x1: Math.max(p.x, q.x) + 1, z0: Math.min(p.z, q.z), z1: Math.max(p.z, q.z) + 1 };
|
|
49
|
+
}
|
|
50
|
+
|
|
51
|
+
/** Caja de excavación mundo (min inclusive, max exclusive) de celdas locales + capas. */
|
|
52
|
+
function cajaExcavar(ref, a0, a1, b0, b1, y0, y1) {
|
|
53
|
+
const r = rectLocal(ref, a0, a1, b0, b1);
|
|
54
|
+
return { x0: r.x0, y0, z0: r.z0, x1: r.x1, y1: y1 + 1, z1: r.z1 };
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
const solapa = (r, s) => r.x0 < s.x1 && s.x0 < r.x1 && r.z0 < s.z1 && s.z0 < r.z1;
|
|
58
|
+
const expandir = (r, m) => ({ x0: r.x0 - m, z0: r.z0 - m, x1: r.x1 + m, z1: r.z1 + m });
|
|
59
|
+
const dentro = (r, p) => r.x0 <= p.x0 && r.z0 <= p.z0 && r.x1 >= p.x1 && r.z1 >= p.z1;
|
|
60
|
+
const rotDeFrente = (uX, uZ) => (uZ === 1 ? 0 : uX === 1 ? 1 : uZ === -1 ? 2 : 3);
|
|
61
|
+
|
|
62
|
+
/**
|
|
63
|
+
* Arma el refugio completo (sin validar contra el mapa).
|
|
64
|
+
* `ref` = { ox, oz, rot, S, dE }.
|
|
65
|
+
*/
|
|
66
|
+
export function disenarRefugio(ref) {
|
|
67
|
+
const e = ejesRefugio(ref.rot);
|
|
68
|
+
const { F, lidStart, aUlt, lidLayer } = perfil(ref.S, ref.dE);
|
|
69
|
+
const S = ref.S;
|
|
70
|
+
const R = REFUGIO;
|
|
71
|
+
const pt = (u, v) => ({ x: ref.ox + 0.5 + u * e.uX + v * e.vX, z: ref.oz + 0.5 + u * e.uZ + v * e.vZ });
|
|
72
|
+
|
|
73
|
+
// --- excavación -------------------------------------------------------
|
|
74
|
+
const excavar = [];
|
|
75
|
+
excavar.push(cajaExcavar(ref, -5, -1, -1, 3, F, F + R.altoSala - 1)); // sala
|
|
76
|
+
excavar.push(cajaExcavar(ref, 0, 0, 0, 1, F, F + R.puertaAlto - 1)); // hueco de la puerta (queda el dintel)
|
|
77
|
+
for (let a = 1; a <= aUlt; a++) { // descanso + escalera + hueco de la trampilla
|
|
78
|
+
const pies = a <= 2 ? F : F + (a - 2);
|
|
79
|
+
// cada celda deja 5 de aire sobre los pies (no 4): al subir un escalón el cuerpo
|
|
80
|
+
// (0.8 de ancho) queda a medias entre dos celdas y necesita la cabeza libre en la de atrás
|
|
81
|
+
const tope = a <= 2 ? F + R.altoSala - 1 : a < lidStart ? pies + R.altoSala - 1 : lidLayer;
|
|
82
|
+
excavar.push(cajaExcavar(ref, a, a, 0, 1, pies, tope));
|
|
83
|
+
}
|
|
84
|
+
|
|
85
|
+
// --- acabado: la sala se revoca (paredes de ladrillo, piso y techo) antes de excavar ---
|
|
86
|
+
const acabado = [
|
|
87
|
+
{ bloque: 'BRICK', ...cajaExcavar(ref, -6, 0, -2, 4, F, F + R.altoSala - 1) }, // macizo de paredes (se excava el interior)
|
|
88
|
+
{ bloque: 'GRAY', ...cajaExcavar(ref, -5, -1, -1, 3, F - 1, F - 1) }, // piso de la sala
|
|
89
|
+
{ bloque: 'GRAY', ...cajaExcavar(ref, 0, 2, 0, 1, F - 1, F - 1) }, // piso de la puerta y el descanso
|
|
90
|
+
{ bloque: 'WHITE', ...cajaExcavar(ref, -5, -1, -1, 3, F + R.altoSala, F + R.altoSala) } // techo
|
|
91
|
+
];
|
|
92
|
+
|
|
93
|
+
// --- puerta -----------------------------------------------------------
|
|
94
|
+
const bisagraP = pt(0, -0.5);
|
|
95
|
+
const centroP = pt(0, 0.5);
|
|
96
|
+
const puerta = {
|
|
97
|
+
tipo: 'puerta', y: F,
|
|
98
|
+
x: bisagraP.x, z: bisagraP.z, // bisagra
|
|
99
|
+
rotY: rotYHacia(e.vX, e.vZ), // cerrada: la hoja se extiende a lo largo de v
|
|
100
|
+
rotYAbierta: rotYHacia(-e.uX, -e.uZ), // abierta (hacia la sala): paralela a -u
|
|
101
|
+
abre: R.abre, largo: R.puertaAncho, alto: R.puertaAlto,
|
|
102
|
+
caja: { x: centroP.x, z: centroP.z, hl: R.puertaAncho / 2, hw: 0.5, rotY: rotYHacia(e.vX, e.vZ), y0: F, y1: F + R.puertaAlto }
|
|
103
|
+
};
|
|
104
|
+
|
|
105
|
+
// --- trampilla --------------------------------------------------------
|
|
106
|
+
const bisagraT = pt(lidStart - 0.5, 0.5);
|
|
107
|
+
const centroT = pt(lidStart - 0.5 + R.trampillaLargo / 2, 0.5);
|
|
108
|
+
const trampilla = {
|
|
109
|
+
tipo: 'trampilla', y: lidLayer + 1,
|
|
110
|
+
x: bisagraT.x, z: bisagraT.z, // bisagra: el extremo bajo del hueco
|
|
111
|
+
rotY: rotYHacia(e.uX, e.uZ), abre: 'arriba',
|
|
112
|
+
largo: R.trampillaLargo, ancho: R.trampillaAncho, alto: 1,
|
|
113
|
+
caja: { x: centroT.x, z: centroT.z, hl: R.trampillaLargo / 2, hw: R.trampillaAncho / 2, rotY: rotYHacia(e.uX, e.uZ), y0: lidLayer, y1: lidLayer + 1 }
|
|
114
|
+
};
|
|
115
|
+
|
|
116
|
+
// --- interior ---------------------------------------------------------
|
|
117
|
+
const centro = pt(-3, 1);
|
|
118
|
+
// armario contra la pared del fondo (a = -5), ocupando b = 1..2
|
|
119
|
+
const arm = pt(-5, 1.5);
|
|
120
|
+
const armario = {
|
|
121
|
+
x: arm.x, y: F, z: arm.z, rot: rotDeFrente(e.uX, e.uZ), ancho: ARMARIO.ancho, pared: true, contenido: 'vacio'
|
|
122
|
+
};
|
|
123
|
+
const luz = { x: centro.x, y: F + R.altoSala - 1.5, z: centro.z, model: ID_LUZ_INTERIOR };
|
|
124
|
+
|
|
125
|
+
// celdas donde se puede aparecer: interior de la sala, lejos del armario (a = -5, -4) y del barrido de la puerta (a = -2, -1)
|
|
126
|
+
const celdasSpawn = [];
|
|
127
|
+
for (let a = -5; a <= -1; a++) {
|
|
128
|
+
for (let b = -1; b <= 3; b++) {
|
|
129
|
+
if (a <= -4 && b >= 0 && b <= 3) continue; // armario y su frente
|
|
130
|
+
if (a >= -2 && b >= -1 && b <= 1) continue; // barrido de la hoja (cuarto de círculo de 2x2) y su borde
|
|
131
|
+
const c = pt(a, b);
|
|
132
|
+
celdasSpawn.push({ x: c.x, z: c.z });
|
|
133
|
+
}
|
|
134
|
+
}
|
|
135
|
+
const spawn = { x: centro.x, y: F, z: centro.z };
|
|
136
|
+
|
|
137
|
+
const s = rectLocal(ref, -5, -1, -1, 3);
|
|
138
|
+
return {
|
|
139
|
+
...ref, F, lidStart, aUlt, lidLayer,
|
|
140
|
+
salida: ref.salida || 'patio',
|
|
141
|
+
x: centro.x, y: F, z: centro.z,
|
|
142
|
+
sala: { x0: s.x0, y0: F, z0: s.z0, x1: s.x1, y1: F + R.altoSala, z1: s.z1 },
|
|
143
|
+
puerta, trampilla,
|
|
144
|
+
escalera: { desde: pt(1, 0.5), hasta: pt(aUlt, 0.5), pasos: aUlt - 2, ancho: R.puertaAncho, descanso: R.descanso },
|
|
145
|
+
spawn, celdasSpawn, armario, luz,
|
|
146
|
+
excavar, acabado,
|
|
147
|
+
huella: rectLocal(ref, U_MIN, aUlt, V_MIN, V_MAX),
|
|
148
|
+
zonaSalida: rectLocal(ref, lidStart, aUlt, 0, 1)
|
|
149
|
+
};
|
|
150
|
+
}
|
|
151
|
+
|
|
152
|
+
/**
|
|
153
|
+
* @param zonas lista de zonas del mapa (se usan las de tipo 'parcela')
|
|
154
|
+
* @param ctx { structures, entities, heightMap, surfaceTypeMap, width, depth, nidos, startPosition, rand, diag }
|
|
155
|
+
* @returns [{ id, parcela, ...refugio }]
|
|
156
|
+
*/
|
|
157
|
+
export function generarRefugios(zonas, ctx) {
|
|
158
|
+
const {
|
|
159
|
+
structures = [], entities = [], heightMap, surfaceTypeMap, width, depth, nidos = [],
|
|
160
|
+
startPosition = null, rand = Math.random, prob = PROB_REFUGIO_PARCELA
|
|
161
|
+
} = ctx;
|
|
162
|
+
const diag = ctx.diag || {};
|
|
163
|
+
const no = (m) => { diag[m] = (diag[m] || 0) + 1; return false; };
|
|
164
|
+
|
|
165
|
+
const edificios = structures.filter(s => s && s.width != null && s.depth != null && s.x >= 0 && s.z >= 0 && s.type !== 'spawn');
|
|
166
|
+
const objetos = entities.filter(e => e && (e.type === 'vehiculo' || (e.type === 'entidad_objeto' && e.model !== ID_LUZ_INTERIOR)));
|
|
167
|
+
const alt = (x, z) => { const c = heightMap[x]; const v = c && c[z]; return typeof v === 'number' ? v : null; };
|
|
168
|
+
const R = REFUGIO;
|
|
169
|
+
|
|
170
|
+
const parcelas = (zonas || []).filter(z => z.tipo === 'parcela' && z.x0 >= 0 && z.z0 >= 0 && z.x1 <= width && z.z1 <= depth);
|
|
171
|
+
|
|
172
|
+
/** ¿El suelo de todo el rectángulo está a la altura S y (opcional) sin calle/vereda/ladrillo? */
|
|
173
|
+
function sueloPlano(r, S, sinCalle) {
|
|
174
|
+
for (let x = r.x0; x < r.x1; x++) {
|
|
175
|
+
for (let z = r.z0; z < r.z1; z++) {
|
|
176
|
+
if (alt(x, z) !== S) return false;
|
|
177
|
+
if (sinCalle) {
|
|
178
|
+
const t = surfaceTypeMap[x] && surfaceTypeMap[x][z];
|
|
179
|
+
if (t === BLOCK_TYPES.ASPHALT || t === BLOCK_TYPES.VEREDA || t === BLOCK_TYPES.BRICK) return false;
|
|
180
|
+
}
|
|
181
|
+
}
|
|
182
|
+
}
|
|
183
|
+
return true;
|
|
184
|
+
}
|
|
185
|
+
|
|
186
|
+
/** Objetos (árboles, postes, autos) cuyo centro cae dentro de r. */
|
|
187
|
+
const hayObjeto = (r, objs) => objs.some(o => o.x >= r.x0 && o.x <= r.x1 && o.z >= r.z0 && o.z <= r.z1);
|
|
188
|
+
const hayNido = (r) => nidos.some(n => n.x >= r.x0 - n.radio - 1 && n.x <= r.x1 + n.radio + 1 && n.z >= r.z0 - n.radio - 1 && n.z <= r.z1 + n.radio + 1);
|
|
189
|
+
|
|
190
|
+
/** Validación común: huella dentro de la parcela, plana, sin nidos ni objetos; fuera del borde del mapa. */
|
|
191
|
+
function huellaValida(d, parcela, locales, S) {
|
|
192
|
+
const h = d.huella;
|
|
193
|
+
const p = { x0: parcela.x0 + R.margenParcela, z0: parcela.z0 + R.margenParcela, x1: parcela.x1 - R.margenParcela, z1: parcela.z1 - R.margenParcela };
|
|
194
|
+
if (!dentro(p, h)) return no('fuera_parcela');
|
|
195
|
+
if (h.x0 < R.margenMapa || h.z0 < R.margenMapa || h.x1 > width - R.margenMapa || h.z1 > depth - R.margenMapa) return no('borde');
|
|
196
|
+
if (!sueloPlano(h, S, false)) return no('desnivel');
|
|
197
|
+
if (hayNido(h)) return no('nido');
|
|
198
|
+
if (hayObjeto(expandir(h, 0.5), locales.objetos)) return no('objeto_huella');
|
|
199
|
+
return true;
|
|
200
|
+
}
|
|
201
|
+
|
|
202
|
+
/** Patio: la salida (trampilla + anillo) al aire libre y la huella lejos de cualquier casa. */
|
|
203
|
+
function patioValido(d, parcela, locales) {
|
|
204
|
+
if (!huellaValida(d, parcela, locales, d.S)) return false;
|
|
205
|
+
const hue = expandir(d.huella, 1);
|
|
206
|
+
for (const s of locales.edificios) if (solapa(hue, { x0: s.x, z0: s.z, x1: s.x + s.width, z1: s.z + s.depth })) return no('edificio_huella');
|
|
207
|
+
const anillo = expandir(d.zonaSalida, R.anilloPatio);
|
|
208
|
+
if (!sueloPlano(anillo, d.S, true)) return no('anillo_suelo');
|
|
209
|
+
for (const s of locales.edificios) {
|
|
210
|
+
if (solapa(anillo, expandir({ x0: s.x, z0: s.z, x1: s.x + s.width, z1: s.z + s.depth }, R.margenEdificio))) return no('anillo_edificio');
|
|
211
|
+
}
|
|
212
|
+
if (hayObjeto(expandir(anillo, R.margenObjeto), locales.objetos)) return no('anillo_objeto');
|
|
213
|
+
return true;
|
|
214
|
+
}
|
|
215
|
+
|
|
216
|
+
/** Sala de casa: la tapa en el centro libre de una sala de planta baja. */
|
|
217
|
+
function casaValida(d, parcela, locales, sala) {
|
|
218
|
+
if (!huellaValida(d, parcela, locales, d.S)) return false;
|
|
219
|
+
const interior = { x0: sala.x + 1, z0: sala.z + 1, x1: sala.x + sala.width - 1, z1: sala.z + sala.depth - 1 };
|
|
220
|
+
const anillo = expandir(d.zonaSalida, R.anilloCasa);
|
|
221
|
+
if (!dentro(interior, anillo)) return no('casa_anillo_fuera');
|
|
222
|
+
const libre = expandir(anillo, 1);
|
|
223
|
+
for (const a of sala.armarios || []) if (a.x >= libre.x0 - 1 && a.x <= libre.x1 + 1 && a.z >= libre.z0 - 1 && a.z <= libre.z1 + 1) return no('casa_armario');
|
|
224
|
+
const l = sala.lootSpot;
|
|
225
|
+
if (l && l.x >= libre.x0 - 1 && l.x <= libre.x1 + 1 && l.z >= libre.z0 - 1 && l.z <= libre.z1 + 1) return no('casa_botin');
|
|
226
|
+
const k = sala.stairKeepOut;
|
|
227
|
+
if (k && solapa(libre, { x0: k.x0, z0: k.z0, x1: k.x1, z1: k.z1 })) return no('casa_escalera');
|
|
228
|
+
// la huella subterránea no puede cruzar los cimientos de OTRA casa
|
|
229
|
+
const hue = expandir(d.huella, 0);
|
|
230
|
+
for (const s of locales.edificios) {
|
|
231
|
+
if (s === sala) continue;
|
|
232
|
+
if (solapa(hue, { x0: s.x, z0: s.z, x1: s.x + s.width, z1: s.z + s.depth }) && (s.floor || 0) === 0 && !(s.parcelId === sala.parcelId)) return no('casa_cimiento_ajeno');
|
|
233
|
+
}
|
|
234
|
+
return true;
|
|
235
|
+
}
|
|
236
|
+
|
|
237
|
+
/** Intenta ubicar un refugio en la parcela. Devuelve el diseño o null. */
|
|
238
|
+
function ubicar(parcela) {
|
|
239
|
+
const locales = {
|
|
240
|
+
edificios: edificios.filter(s => solapa(expandir(parcela, 6), { x0: s.x, z0: s.z, x1: s.x + s.width, z1: s.z + s.depth })),
|
|
241
|
+
objetos: objetos.filter(o => o.x >= parcela.x0 - 6 && o.x <= parcela.x1 + 6 && o.z >= parcela.z0 - 6 && o.z <= parcela.z1 + 6)
|
|
242
|
+
};
|
|
243
|
+
// 1º) patio: sorteo de la salida y del giro
|
|
244
|
+
for (let k = 0; k < (ctx.soloCasa ? 0 : INTENTOS_REFUGIO); k++) {
|
|
245
|
+
const ox = Math.floor(parcela.x0 + rand() * (parcela.x1 - parcela.x0));
|
|
246
|
+
const oz = Math.floor(parcela.z0 + rand() * (parcela.z1 - parcela.z0));
|
|
247
|
+
const S = alt(ox, oz);
|
|
248
|
+
if (S == null) continue;
|
|
249
|
+
const d = disenarRefugio({ ox, oz, rot: Math.floor(rand() * 4), S, dE: 0 });
|
|
250
|
+
if (patioValido(d, parcela, locales)) return d;
|
|
251
|
+
}
|
|
252
|
+
// 2º) sala de planta baja de la casa de la parcela
|
|
253
|
+
const salas = locales.edificios.filter(s => SALAS_VALIDAS.has(s.type) && (s.floor || 0) === 0 &&
|
|
254
|
+
s.x >= parcela.x0 && s.z >= parcela.z0 && s.x + s.width <= parcela.x1 && s.z + s.depth <= parcela.z1)
|
|
255
|
+
.sort((a, b) => b.width * b.depth - a.width * a.depth);
|
|
256
|
+
for (const sala of salas) {
|
|
257
|
+
const S = alt(sala.x + 1, sala.z + 1);
|
|
258
|
+
const dE = S == null ? -1 : sala.y + 1 - S; // el piso de la casa es la capa superficial (dE = 0) o un bloque más arriba
|
|
259
|
+
if (dE < 0 || dE > 1) continue;
|
|
260
|
+
// la tapa (4 de largo x 2 de ancho) centrada en la sala, con el largo sobre el eje más largo
|
|
261
|
+
const cx = sala.x + sala.width / 2, cz = sala.z + sala.depth / 2;
|
|
262
|
+
const rots = sala.width >= sala.depth ? [0, 2, 1, 3] : [1, 3, 0, 2];
|
|
263
|
+
for (const [dx, dz] of DESVIOS_CASA) {
|
|
264
|
+
for (const rot of rots) {
|
|
265
|
+
const e = ejesRefugio(rot);
|
|
266
|
+
// origen tal que el centro de la tapa caiga en el centro de la sala (más el desvío)
|
|
267
|
+
const { lidStart } = perfil(S, dE);
|
|
268
|
+
const uC = lidStart - 0.5 + REFUGIO.trampillaLargo / 2, vC = 0.5;
|
|
269
|
+
const ox = Math.round(cx - 0.5 - uC * e.uX - vC * e.vX) + dx;
|
|
270
|
+
const oz = Math.round(cz - 0.5 - uC * e.uZ - vC * e.vZ) + dz;
|
|
271
|
+
const d = disenarRefugio({ ox, oz, rot, S, dE, salida: 'casa' });
|
|
272
|
+
if (casaValida(d, parcela, locales, sala)) { d.sala_casa = sala.roomId != null ? sala.roomId : null; return d; }
|
|
273
|
+
}
|
|
274
|
+
}
|
|
275
|
+
}
|
|
276
|
+
return null;
|
|
277
|
+
}
|
|
278
|
+
|
|
279
|
+
const refugios = [];
|
|
280
|
+
const pendientes = [];
|
|
281
|
+
for (const parcela of parcelas) {
|
|
282
|
+
if (rand() >= prob) { pendientes.push(parcela); continue; }
|
|
283
|
+
const d = ubicar(parcela);
|
|
284
|
+
if (d) refugios.push({ ...d, parcela: parcela.id });
|
|
285
|
+
else no('parcela_descartada');
|
|
286
|
+
}
|
|
287
|
+
|
|
288
|
+
// mínimo garantizado: la parcela válida más cercana al inicio del mapa
|
|
289
|
+
if (refugios.length < MIN_REFUGIOS) {
|
|
290
|
+
const sp = startPosition || { x: width / 2, z: depth / 2 };
|
|
291
|
+
pendientes.sort((a, b) => Math.hypot((a.x0 + a.x1) / 2 - sp.x, (a.z0 + a.z1) / 2 - sp.z) - Math.hypot((b.x0 + b.x1) / 2 - sp.x, (b.z0 + b.z1) / 2 - sp.z));
|
|
292
|
+
for (const parcela of pendientes) {
|
|
293
|
+
const d = ubicar(parcela);
|
|
294
|
+
if (d) { refugios.push({ ...d, parcela: parcela.id, forzado: true }); break; }
|
|
295
|
+
no('parcela_descartada');
|
|
296
|
+
if (refugios.length >= MIN_REFUGIOS) break;
|
|
297
|
+
}
|
|
298
|
+
}
|
|
299
|
+
refugios.forEach((r, i) => { r.id = i; });
|
|
300
|
+
return refugios;
|
|
301
|
+
}
|
|
@@ -0,0 +1,200 @@
|
|
|
1
|
+
// genera_tiendas.js - Decide las tiendas del mapa (supervivencia, ver
|
|
2
|
+
// cliente/tiendas_config.js). Cada tienda es una sala de planta baja que da a la
|
|
3
|
+
// calle (tiene puerta de frente). El mostrador va a `DIST_MOSTRADOR` celdas del
|
|
4
|
+
// fondo de la sala, con el NPC detrás y la entrada libre delante.
|
|
5
|
+
//
|
|
6
|
+
// Reparto uniforme: el mapa se divide en COLUMNAS franjas (una por tienda) y se elige
|
|
7
|
+
// una sala candidata por franja. Así las tiendas quedan distribuidas por todo el
|
|
8
|
+
// mapa y no apiladas en un barrio. Si una celda no tiene candidatas se toma la
|
|
9
|
+
// más cercana al centro de la celda entre las que quedan.
|
|
10
|
+
//
|
|
11
|
+
// Sólo se elige entre salas sin botín fijo ni armario: no se quita nada a las
|
|
12
|
+
// otras modalidades. Las salas elegidas quedan marcadas con `sala.tienda = true`.
|
|
13
|
+
|
|
14
|
+
import { TIENDAS_POR_MAPA, ROT_PUERTA, ALTO_GONDOLA } from '../plugins/datos.js';
|
|
15
|
+
import { ESCALA_SUPERFICIE } from '../plugins/datos.js';
|
|
16
|
+
|
|
17
|
+
/**
|
|
18
|
+
* Tiendas de este mapa: la densidad de referencia por la superficie de la sala.
|
|
19
|
+
* Se calcula al usarla (los datos llegan por plugin, ver plugins/registro.js).
|
|
20
|
+
*/
|
|
21
|
+
function cantidadMapa() {
|
|
22
|
+
return Math.max(1, Math.round(TIENDAS_POR_MAPA * ESCALA_SUPERFICIE));
|
|
23
|
+
}
|
|
24
|
+
const FILAS = 1;
|
|
25
|
+
/** Celdas entre el mostrador y el fondo de la sala (el NPC queda en la celda de atrás). */
|
|
26
|
+
const DIST_MOSTRADOR = 4;
|
|
27
|
+
/** Largo del mostrador en celdas. */
|
|
28
|
+
const LARGO_MOSTRADOR = 4;
|
|
29
|
+
/** Tipos de sala que pueden ser tienda (no pasillo, escalera ni spawn). */
|
|
30
|
+
const TIPOS = new Set(['banio', 'cocina', 'comedor', 'dormitorio', 'living']);
|
|
31
|
+
|
|
32
|
+
/** Lado de la calle de la sala ('N','S','E','O') o null si no tiene puerta de frente en planta baja. */
|
|
33
|
+
function ladoCalle(s) {
|
|
34
|
+
if (!s.hasFrontDoor || (s.floor || 0) !== 0) return null;
|
|
35
|
+
if (s.frontNorth) return 'N';
|
|
36
|
+
if (s.frontSouth) return 'S';
|
|
37
|
+
if (s.frontEast) return 'E';
|
|
38
|
+
if (s.frontWest) return 'O';
|
|
39
|
+
return null;
|
|
40
|
+
}
|
|
41
|
+
|
|
42
|
+
/**
|
|
43
|
+
* Geometría de la tienda dentro de la sala `s` con la calle en `lado`.
|
|
44
|
+
* Devuelve los datos del mostrador y del NPC en coordenadas de mundo, o null
|
|
45
|
+
* si la sala es demasiado chica o el mostrador tapa el hueco de la escalera.
|
|
46
|
+
*/
|
|
47
|
+
export function geometriaTienda(s, lado) {
|
|
48
|
+
const alongZ = lado === 'N' || lado === 'S'; // la calle está en un lado de z
|
|
49
|
+
const L = alongZ ? s.depth : s.width; // largo hacia el fondo (desde la puerta)
|
|
50
|
+
const M = alongZ ? s.width : s.depth; // ancho de la sala (paralelo a la puerta)
|
|
51
|
+
if (L < DIST_MOSTRADOR + 3 || M < LARGO_MOSTRADOR + 2) return null;
|
|
52
|
+
|
|
53
|
+
// coordenada de mundo de la celda r (distancia desde la puerta) y de la celda m (lateral)
|
|
54
|
+
const celdaAxis = (r) => {
|
|
55
|
+
if (lado === 'N') return s.z + r; // puerta en z mínimo
|
|
56
|
+
if (lado === 'S') return s.z + s.depth - 1 - r; // puerta en z máximo
|
|
57
|
+
if (lado === 'O') return s.x + r; // puerta en x mínimo
|
|
58
|
+
return s.x + s.width - 1 - r; // E: puerta en x máximo
|
|
59
|
+
};
|
|
60
|
+
const celdaLat = (m) => (alongZ ? s.x + m : s.z + m);
|
|
61
|
+
|
|
62
|
+
const rMostrador = L - DIST_MOSTRADOR; // fila del mostrador
|
|
63
|
+
const rNpc = rMostrador + 1; // detrás, hacia el fondo
|
|
64
|
+
const rUso = rMostrador - 1; // delante, lado de la puerta
|
|
65
|
+
|
|
66
|
+
const mc = Math.floor(M / 2);
|
|
67
|
+
let m0 = Math.max(1, mc - Math.floor(LARGO_MOSTRADOR / 2));
|
|
68
|
+
let m1 = Math.min(M - 2, m0 + LARGO_MOSTRADOR - 1);
|
|
69
|
+
m0 = Math.max(1, m1 - LARGO_MOSTRADOR + 1);
|
|
70
|
+
const largo = m1 - m0 + 1;
|
|
71
|
+
|
|
72
|
+
// el hueco de la escalera (si lo hay) no puede quedar debajo del mostrador
|
|
73
|
+
const keep = s.stairKeepOut;
|
|
74
|
+
if (keep) {
|
|
75
|
+
for (let m = m0; m <= m1; m++) {
|
|
76
|
+
const x = alongZ ? celdaLat(m) : celdaAxis(rMostrador);
|
|
77
|
+
const z = alongZ ? celdaAxis(rMostrador) : celdaLat(m);
|
|
78
|
+
if (x >= keep.x0 && x < keep.x1 && z >= keep.z0 && z < keep.z1) return null;
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
// góndolas con exposición junto a las paredes laterales: la celda 0 y la M-1 son el muro,
|
|
83
|
+
// así que la góndola va en la celda 1 y en la M-2 (libres del mostrador).
|
|
84
|
+
// Van en las filas 2..4 (o hasta el mostrador), así la fila 0 queda libre para entrar.
|
|
85
|
+
// Son dos filas como mínimo; si no entran, la sala se queda sin góndolas.
|
|
86
|
+
const gondolas = [];
|
|
87
|
+
const r0 = 2, r1 = Math.min(4, rMostrador - 2);
|
|
88
|
+
if (r1 - r0 + 1 >= 2) {
|
|
89
|
+
for (const m of [1, M - 2]) {
|
|
90
|
+
let libre = true;
|
|
91
|
+
for (let r = r0; keep && r <= r1; r++) {
|
|
92
|
+
const x = alongZ ? celdaLat(m) : celdaAxis(r);
|
|
93
|
+
const z = alongZ ? celdaAxis(r) : celdaLat(m);
|
|
94
|
+
if (x >= keep.x0 && x < keep.x1 && z >= keep.z0 && z < keep.z1) libre = false;
|
|
95
|
+
}
|
|
96
|
+
if (!libre) continue;
|
|
97
|
+
const ra = celdaAxis(r0), rb = celdaAxis(r1);
|
|
98
|
+
const a0 = Math.min(ra, rb), a1 = Math.max(ra, rb) + 1; // borde a borde
|
|
99
|
+
const latC = celdaLat(m) + 0.5;
|
|
100
|
+
const c = alongZ ? { x: latC, z: (a0 + a1) / 2 } : { x: (a0 + a1) / 2, z: latC };
|
|
101
|
+
gondolas.push({ x: c.x, z: c.z, hl: (a1 - a0) / 2, hw: 0.4, rotY: alongZ ? Math.PI / 2 : 0 });
|
|
102
|
+
}
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
const lateralCentro = celdaLat(m0) + largo / 2; // borde a borde: m0 .. m1+1
|
|
106
|
+
const axisMostrador = celdaAxis(rMostrador) + 0.5;
|
|
107
|
+
const axisNpc = celdaAxis(rNpc) + 0.5;
|
|
108
|
+
const axisUso = celdaAxis(rUso) + 0.5;
|
|
109
|
+
|
|
110
|
+
// coordenadas de mundo (x, z) según el eje
|
|
111
|
+
const en = (axis, lat) => (alongZ ? { x: lat, z: axis } : { x: axis, z: lat });
|
|
112
|
+
const centro = en(axisMostrador, lateralCentro);
|
|
113
|
+
const npc = en(axisNpc, celdaLat(Math.floor((m0 + m1) / 2)) + 0.5);
|
|
114
|
+
const uso = en(axisUso, lateralCentro);
|
|
115
|
+
|
|
116
|
+
// caja de colisión del mostrador: hl a lo largo de la pared (x si rotY=0), hw hacia la calle
|
|
117
|
+
const rotY = alongZ ? 0 : Math.PI / 2;
|
|
118
|
+
return {
|
|
119
|
+
largo,
|
|
120
|
+
// rotY 0: el largo va en x; rotY π/2: el largo va en z (ver cajaDeMostrador)
|
|
121
|
+
mostrador: { x: centro.x, z: centro.z, hl: largo / 2, hw: 0.5, rotY },
|
|
122
|
+
gondolas,
|
|
123
|
+
npc: { x: npc.x, z: npc.z, rot: ROT_PUERTA[lado] },
|
|
124
|
+
uso: { x: uso.x, z: uso.z }
|
|
125
|
+
};
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
/**
|
|
129
|
+
* Elige hasta `cantidad` salas para tiendas y devuelve
|
|
130
|
+
* { tiendas, diag }. Cada tienda: { id, sala (tipo), x, y, z (centro del mostrador),
|
|
131
|
+
* npc:{x,y,z,rot}, uso:{x,z}, caja:{x,z,hl,hw,rotY,y0,y1}, lado }.
|
|
132
|
+
* `width`/`depth` son el tamaño del mapa (WORLD_CONFIG).
|
|
133
|
+
*/
|
|
134
|
+
export function elegirTiendas(structures, { width, depth, cantidad = cantidadMapa(), random = Math.random } = {}) {
|
|
135
|
+
const COLUMNAS = cantidad; // una franja por tienda: cubren el mapa de punta a punta
|
|
136
|
+
const diag = { candidatas: 0, sinGeometria: 0 };
|
|
137
|
+
const candidatas = [];
|
|
138
|
+
for (const s of structures || []) {
|
|
139
|
+
if (!s || s.type === undefined || !TIPOS.has(s.type)) continue;
|
|
140
|
+
if (s.width == null || s.depth == null || s.x == null || s.z == null) continue;
|
|
141
|
+
if (s.lootSpot || (s.armarios && s.armarios.length)) continue;
|
|
142
|
+
const lado = ladoCalle(s);
|
|
143
|
+
if (!lado) continue;
|
|
144
|
+
const geo = geometriaTienda(s, lado);
|
|
145
|
+
if (!geo) { diag.sinGeometria++; continue; }
|
|
146
|
+
candidatas.push({ sala: s, lado, geo, cx: s.x + s.width / 2, cz: s.z + s.depth / 2 });
|
|
147
|
+
}
|
|
148
|
+
diag.candidatas = candidatas.length;
|
|
149
|
+
|
|
150
|
+
const elegidas = [];
|
|
151
|
+
const usadas = new Set();
|
|
152
|
+
const cw = width / COLUMNAS, ch = depth / FILAS;
|
|
153
|
+
const celdas = [];
|
|
154
|
+
for (let f = 0; f < FILAS; f++) for (let c = 0; c < COLUMNAS; c++) celdas.push({ c, f });
|
|
155
|
+
// mezclar el orden de las celdas: si faltan candidatas, no siempre se quedan sin tienda las mismas
|
|
156
|
+
for (let i = celdas.length - 1; i > 0; i--) {
|
|
157
|
+
const j = Math.floor(random() * (i + 1));
|
|
158
|
+
[celdas[i], celdas[j]] = [celdas[j], celdas[i]];
|
|
159
|
+
}
|
|
160
|
+
for (const { c, f } of celdas) {
|
|
161
|
+
if (elegidas.length >= cantidad) break;
|
|
162
|
+
const x0 = c * cw, x1 = x0 + cw, z0 = f * ch, z1 = z0 + ch;
|
|
163
|
+
const enCelda = candidatas.filter(k => !usadas.has(k) && k.cx >= x0 && k.cx < x1 && k.cz >= z0 && k.cz < z1);
|
|
164
|
+
let elegida = enCelda.length ? enCelda[Math.floor(random() * enCelda.length)] : null;
|
|
165
|
+
if (!elegida) {
|
|
166
|
+
// celda vacía: la candidata libre más cercana al centro de la celda
|
|
167
|
+
const mx = (x0 + x1) / 2, mz = (z0 + z1) / 2;
|
|
168
|
+
let md = Infinity;
|
|
169
|
+
for (const k of candidatas) {
|
|
170
|
+
if (usadas.has(k)) continue;
|
|
171
|
+
const d = Math.hypot(k.cx - mx, k.cz - mz);
|
|
172
|
+
if (d < md) { md = d; elegida = k; }
|
|
173
|
+
}
|
|
174
|
+
}
|
|
175
|
+
if (!elegida) continue;
|
|
176
|
+
usadas.add(elegida);
|
|
177
|
+
elegidas.push(elegida);
|
|
178
|
+
}
|
|
179
|
+
|
|
180
|
+
const tiendas = elegidas.map((k, id) => {
|
|
181
|
+
const s = k.sala;
|
|
182
|
+
s.tienda = true;
|
|
183
|
+
s.tiendaLado = k.lado; // fachada de calle: ahí va el cartel (ver cartel_tienda.js)
|
|
184
|
+
const m = k.geo.mostrador;
|
|
185
|
+
return {
|
|
186
|
+
id, sala: s.type, lado: k.lado,
|
|
187
|
+
x: m.x, y: s.y + 1, z: m.z,
|
|
188
|
+
npc: { x: k.geo.npc.x, y: s.y + 1, z: k.geo.npc.z, rot: k.geo.npc.rot },
|
|
189
|
+
uso: k.geo.uso,
|
|
190
|
+
// huella de la sala (x0,z0,x1,z1): la bandera de la banda que la conquista va dentro de ella
|
|
191
|
+
sala_rect: { x0: s.x, z0: s.z, x1: s.x + s.width, z1: s.z + s.depth },
|
|
192
|
+
caja: { x: m.x, z: m.z, hl: m.hl, hw: m.hw, rotY: m.rotY, y0: s.y + 1, y1: s.y + 1 + 2, especie: 'mostrador' },
|
|
193
|
+
// góndolas con exposición: cajas de colisión propias (ver cliente/multijugador/tiendas.js)
|
|
194
|
+
gondolas: k.geo.gondolas.map(g => ({ ...g, y0: s.y + 1, y1: s.y + 1 + ALTO_GONDOLA, especie: 'gondola' }))
|
|
195
|
+
};
|
|
196
|
+
});
|
|
197
|
+
diag.elegidas = tiendas.length;
|
|
198
|
+
console.log(`[tiendas] ${tiendas.length} de ${cantidad} tiendas en el mapa (candidatas: ${diag.candidatas}, sin geometría: ${diag.sinGeometria})`);
|
|
199
|
+
return { tiendas, diag };
|
|
200
|
+
}
|