game.track — los circuitos: geometría, superficie y progreso.
Un circuito se define como una lista de puntos de control que se cierran
formando un bucle. De ahí salen tres cosas: la carretera (una fila de
losas), y las dos consultas que el kart necesita cada frame — ¿estoy sobre
el asfalto o fuera? y ¿por dónde voy de la vuelta?
Todo se construye en código en cada carga, así que recargar el mundo deja
exactamente el mismo circuito.
byIndex(i: ?) → void
El circuito que ocupa una posición del orden, o nil si aún no está
construido.
indexOf(id: ?) → void
En qué posición del orden está un circuito.
catmull(p0: ?, p1: ?, p2: ?, p3: ?, t: ?) → void
Curva
| arg | type | description |
|---|
| p0 | ? | |
| p1 | ? | |
| p2 | ? | |
| p3 | ? | |
| t | ? | |
c(a: ?, b: ?, cc: ?, d: ?) → void
| arg | type | description |
|---|
| a | ? | |
| b | ? | |
| cc | ? | |
| d | ? | |
sample(def: ?, spacing: ?) → void
Muestrea la curva cerrada cada `spacing` metros, por longitud de arco.
Devuelve una lista de puntos, cada uno con su tangente ya normalizada.
| arg | type | description |
|---|
| def | ? | |
| spacing | ? | |
spawnSlab(parent: ?, name: ?, sample: ?, width: ?, length: ?, thickness: ?, tint: ?, material: ?) → void
| arg | type | description |
|---|
| parent | ? | |
| name | ? | |
| sample | ? | |
| width | ? | |
| length | ? | |
| thickness | ? | |
| tint | ? | |
| material | ? | |
platformVisible(pl: ?, time: ?) → void
¿Está encendida una plataforma fantasmales ahora mismo? `blink` dice cuánto
dura cada fase: `on` encendida, `off` apagada, y `phase` el desfase, para que
dos plataformas de la misma sala no vayan a la vez.
| arg | type | description |
|---|
| pl | ? | |
| time | ? | |
chosenId( ) → void
Qué circuito se levanta, leído de `game/circuit.txt` — una línea, del estilo
`circuito = "playa"`. Es lo que hace que cambiar de circuito sea escribir el
archivo y reconstruir la escena: el circuito va HORNEADO en la escena, y lo
que se crea en tiempo de ejecución no se dibuja (ver PLAN, Trampas).
sampleIndex(fraction: ?, m: ?) → void
La muestra del circuito que cae en una fracción de vuelta.
| arg | type | description |
|---|
| fraction | ? | |
| m | ? | |
widthAt(def: ?, arc: ?, total: ?) → void
El ancho de la carretera en un punto de la vuelta. Casi todos los circuitos
tienen el mismo de punta a punta; uno con tramos estrechos (los pasillos de
una mansión, un puente de madera) declara `def.widthProfile` con los tramos
en fracciones de vuelta, y aquí se resuelve cuál toca.
| arg | type | description |
|---|
| def | ? | |
| arc | ? | |
| total | ? | |
build(id: ?, opts: ?) → void
Construye el circuito `id` y lo deja como el activo. Devuelve su instancia.
| arg | type | description |
|---|
| id | ? | |
| opts | ? | |
nearest(p: ?) → void
La muestra más cercana a un punto, con el lateral y el avance.
widthAt(arc: ?) → void
El ancho de la carretera en un punto de la vuelta, para saber si un kart
va sobre el asfalto o fuera.
surfaceAt(p: ?) → void
Qué superficie hay bajo un punto. De momento asfalto dentro del ancho
y la superficie del circuito fuera; los atajos y objetos añaden
excepciones más adelante.
centre( ) → void
Dónde cae el centro del circuito, para colocar el suelo y el mar.
gridPose(index: ?) → void
Dónde se coloca el kart número `index` en la parrilla de salida: dos
por fila, alternando lado, y cada fila una detrás de la anterior. Sale
de aquí, y no de cada sitio que coloca un kart, para que el jugador y
los rivales estén en la misma parrilla y no en dos inventadas.
heightAt(p: ?, y: ?) → void
Qué altura tiene el suelo en un punto. Los circuitos planos devuelven 0,
que es la mayoría; una playa con bajío devuelve la rampa que baja del
borde de la arena hasta el agua. El kart conduce a esta altura, así que
esto es lo que hace que se pueda bajar a la orilla en vez de flotar.
`y` es la altura a la que va el kart ahora mismo, y sirve para que las
plataformas de atajo sean de un solo sentido: se aterriza en ellas
bajando, y se pasa por debajo sin que te levanten.
platformPose(i: ?) → void
Dónde está cada plataforma de atajo, para que las monedas y los Dash
Panels se puedan colocar encima.
startPose(index: ?) → void
Dónde y mirando hacia dónde aparece un kart en la salida.
adopt(id: ?) → void
Aprende un circuito que YA está en la escena, sin construir nada. Es lo que
hace la escena al cargar: la geometría la puso `build.luau` al autorizar y
en play solo hace falta saber por dónde va la carretera.