Construir pirámide inversa, o parecido.

(1/1)

Tachikomaia:
Insertando este objeto

al que llamo Mini (luego le pondré Vigas o algo mejor)
construí 2 pisos así

Vean que el piso 1 tiene 1 hueco y son 2 plataformas,
mientras que el piso 0 tiene 0 huecos y es 1 plataforma.

Pero a partir del piso 2 quiero que la fórmula sea P huecos y P-1 plataformas, entendiendo que P es el nro de piso.
El piso 2 sería H P H
O sea, a partir de eso, siempre debe haber huecos en los costados.
El piso 3 tendrá 1 hueco más y 1 plataforma más, y así sucesivamente.

Con el código que puse para el piso 2 y siguientes, me quedó así:

Quiero que me ayuden a mejorarlo, como dije es a partir del piso 2, los anteriores ya están bien, creados de una forma más simple.
Código
// Pisos siguientes: P huecos, P-1 plataformas:
Piso = 1;
// Agregar piso:
do {
Piso++;
NombreDePiso = "Piso"+Piso;
attachMovie("sDKPlataformas", NombreDePiso, Piso);
setProperty (NombreDePiso, _x, 16);
setProperty (NombreDePiso, _y, 568-18*Piso);
MinisNecesariosEnPlataforma = (23-Piso)/(Piso-1);
// Agregar Plataformas:
PlataformasEnPiso = 0;
do {
NombreDePlataformas = "Plataformas"+PlataformasEnPiso;
eval(NombreDePiso).attachMovie("sDKPlataformas", NombreDePlataformas, PlataformasEnPiso);
RutaDePlataformas = NombreDePiso+"."+NombreDePlataformas;
setProperty (RutaDePlataformas, _x, 32*MinisNecesariosEnPlataforma*PlataformasEnPiso+(PlataformasEnPiso)*32);
// Agregar Minis:
MinisEnPlataformas = 0;
// Para evitar reconcatenar; p se entiende como punto:
RutaDePlataformasp = RutaDePlataformas+".";
do {
NombreDeMini = "Mini"+MinisEnPlataformas;
eval(RutaDePlataformas).attachMovie("sDKPlataforma", NombreDeMini, MinisEnPlataformas);
setProperty (RutaDePlataformasp+NombreDeMini, _x, 32*MinisEnPlataformas);
MinisEnPlataformas++;
} while (MinisEnPlataformas <= MinisNecesariosEnPlataforma);
PlataformasEnPiso++;
} while (PlataformasEnPiso <= Piso);
} while (Piso < 29);

En cuanto a por qué hacerlo de este modo, es que intento que cuando Mario salte se pueda chequear cada plataforma del piso que corresponda, otro modo sería crear los pisos enteros así nomás y taparlos con objetos del mismo color de fondo, quedaría como si fuesen agujeros, sería más fácil, pero el tema de chequear colisiones no sé si se facilita, además es como mal eso, los minis están ahí tapados, mejor que no estén.

Tachikomaia:
Para empezar por algo más simple ya que esto me supera, intento construir una pirámide común y corriente. Los minis o trocitos de vigas serían los ladrillos. El problema es que estoy colocando grupos de ladrillos, no coloco sueltos. Entonces:
En el piso 0 (el más de abajo) coloco 25 ladrillos, divididos en 1 grupo.
En el piso 1 coloco 24 divididos en 2 grupos.
En el piso 2, 23 dividos e 3. Y acá es donde me falla, porque si pongo 7 por grupo, van a ser 21, me faltan 2 ladrillos, y si pongo 8 por grupo me va a sobrar 1.

Que sean grupos me pareció mejor para chequear cuando Mario toca un piso, o sea, grupo1, o grupo2, etc, en vez de chequear trocito1, trocito2, etc. Pero bueno, serán grupos con agujeros que habrá que chequear distinto, no sé.

Logré esto:


Así:
Código
Pisos = 0;
do {
Piso = "mPiso"+Pisos;
// sDKPlataformas es un objeto vacío donde se insertan...
// pequeñas plataformas seguidas. Sirve para chequear...
// las colisiones más fácil:
attachMovie("sDKPlataformas", Piso, Pisos);
setProperty (Piso, _x, Pisos*16+16);
setProperty (Piso, _y, 584-Pisos*18);
PartesDelPiso = 0;
AgujeroCada = 25/(Pisos+1);
NextParteaSaltear = AgujeroCada;
// Ignoro cómo llamarle, está relacionado con lo que dice:
PartesRequeridas = 25-Pisos/2;
do {
if (PartesDelPiso >= NextParteaSaltear) {
NextParteaSaltear = NextParteaSaltear+AgujeroCada;
} else {
Parte = "Parte"+PartesDelPiso;
eval(Piso).attachMovie("sDKPlataforma", Parte, PartesDelPiso);
RutaDeParte = Piso+"."+Parte;
setProperty (RutaDeParte, _x, 32*PartesDelPiso);
setProperty (RutaDeParte, _y, 0);
}
PartesDelPiso++;
} while (PartesDelPiso <= PartesRequeridas);
Pisos++;
} while (Pisos < 30);
 

Claro que así no se puede llegar al martillo, además parece demasiado obvio que conviene subir por la izquierda.
Me interesa cómo lo arreglarían pero también cómo los niveles podrían variar sin variar mucho el código, o sea cambiando algunos números o fórmulas nada más, básicamente entre mayor sea el nivel más agujeros debe haber, pero siempre debe ser posible llegar al martillo.

Navegación

[0] Índice de Mensajes