[Tachikomaia]

La imagen que ven muestra que:
En el piso 1 hay 1 hueco, son 2 plataformas.
En el piso 0 hay 0 huecos, es 1 plataforma.

La idea es que en el piso X haya X huecos. El piso 2 podría ser:
P H P H P
Pero para que el juego no sea tan fácil prefiero que sea
H P H
es decir, a partir del piso 2 quiero que haya huecos en los costados, así que la fórmula es
en pìso X hay X huecos y X-1 plataformas.

Pongo el código de lo que hice, quisiera saber cómo sería a partir del piso 2:

Código: [Seleccionar]

// Piso 0: 0 huecos, 1 plataforma:
// sDKPlataformas es un objeto vacío donde se insertan...
// pequeñas plataformas seguidas. Sirve para chequearlas más fácil,
// como si fueran 1 sola:
attachMovie("sDKPlataformas", "Plataformas0", 0);
setProperty ("Plataformas0", _x, 16);
setProperty ("Plataformas0", _y, 568);
PlataformasEnPiso = 0;
do {
NombreDePlataforma = "Plataforma"+PlataformasEnPiso;
Plataformas0.attachMovie("sDKPlataforma", NombreDePlataforma, PlataformasEnPiso);
setProperty ("Plataformas0."+NombreDePlataforma, _x, 32*PlataformasEnPiso);
PlataformasEnPiso++;
} while (PlataformasEnPiso <= 24);

// Piso 1: 1 hueco, 2 plataformas:
// Piso1 es un objeto vacío que facilitará...
// chequear plataformas a cierta altura:
attachMovie("sDKPlataformas", "Piso1", 1);
setProperty ("Piso1", _y, 568-18);
// A continuación se le insertarán objetos vacíos llamados...
// Plataformas, que facilitarán chequear las plataformas juntas,
// como si fuesen una:
PlataformasEnPiso = 0;
do {
NombreDePlataformas = "Plataformas"+PlataformasEnPiso;
Piso1.attachMovie("sDKPlataformas", NombreDePlataformas, PlataformasEnPiso);
RutaDePlataformas = "Piso1."+NombreDePlataformas;
setProperty (RutaDePlataformas, _x, 16+32*13*PlataformasEnPiso);
// Por último a los objetos llamados Plataformas se le...
// insertarán las plataformas, es decir los dibujos,
// que se llamarán Minis porque son pequeñas y...
// para intentar reducir la confusión:
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 < 12);
PlataformasEnPiso++;
} while (PlataformasEnPiso < 2);
Ah importante: El ancho de las plataformas (minis) no lo quiero reducir, quiero que se reduzca el ancho de los huecos.

[Luis Fuentes]

Hola

 Si:

 \( L \) es la longitud total del suelo
 \( p \) es el piso:
 \( a \) es el ancho del hueco.

 Entonces la posición inicial (entendiendo que \( 0 \) es el punto más a la izquierda del suelo) del hueco \( k \)-ésimo es:

\( (k-1)\cdot \dfrac{L-a}{p-1} \) con  \( k=1,2,\ldots,p \)

 En este gráfico ves como queda. Puedes modificar moviendo el punto \( C \) la longitud total; moviendo \( E \) el ancho del hueco.


Saludos.

[Tachikomaia]

Está muy bien intentaré usar la fórmula.

Por ahora lo hice a mi modo, claro que tiene errores, pero se ve bonito:


Probablemente describí mal el problema.

Tengo este objeto al que llamo Mini:


Mide 32 de ancho, la altura no es problema, su punto de referencia está en el medio (o sea si lo colocas en el punto 0 de la pantalla, 18 de su ancho va a queda en la izquierda fuera de la pantalla).
No le quiero cambiar el ancho porque en el juego original son así y quedaría raro cambiarlo, tiene unos agujeros, son como vigas de hierro.
Lo que se hace es insertar esos objetos uno al lado del otro cierta cantidad de veces, dependiendo de cuántos huecos debe haber en el piso.
Entonces debe calcularse cuánto ancho debe tener cada piso, y cuántos de esos objetos deben insertarse entre cada hueco.

Algo puse mal en el código, me gusta el efecto "circular" inesperado, pero bueno, tiene que mejorar, no debe haber plataformas en los extremos, etc. Fíjense a ver si lo pueden arreglar:

Código: [Seleccionar]

// 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);

[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: (actionscript) [Seleccionar]

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.