haciendo una cuadrícula
Hasta hace poco para hacer una cuadrícula multiplicaba el las columnas deseadas por las filas, luego hacia un bucle ( loop ) hasta que llegara a ese total, dentro del bucle revisaba cuando llegara al total de filas, que me aumentara una unidad a las columnas para que asi se acodaran hacia abajo
algo como esto:
nota:
en la libreria hay un MovieClip con linkage id "clip" de 10x10
c = 20;//columnas
r = 20;//filas
total = c*r;
basey = 50;//basey
basex = 10;//basex
clipW = clipH = 10;//ancho y algo = 10
colscounter = 0; //contador para columnas
rowscounter = 0; //contador par filas
testA_iniTime = getTimer(); //tiempo inicial
trace("_________________\ntestA_iniTime: " add testA_iniTime);
for(var n = 0; n < total; n++){
var clip = this.attachMovie("clip","clip" add n, n+1);
clip._x = basex + (clipW * colscounter);
clip._y = basey + (clipH * rowscounter);
colscounter ++;
if(colscounter == c){
colscounter = 0;
rowscounter ++;
}
}
trace("testA_endTime: " add getTimer());
trace("totalTime: " add (getTimer() - testA_iniTime));
stop();
esto me tardó 84ms en una athlon 1.400
leyendo el libro de hall & wan vi una nueva forma mas optimizada, ésta es usar dos bucles anidados, más sencilla y más rápida =)
aquí el código.
nota :
Sigue habiendo un MovieClip en la librería con linkage id "clip" de 10x10
c = 20;//columnas
r = 20;//filas
basey = 50;//basey
basex = 10;//basex
clipW = clipH = 10;//ancho y algo = 10
testB_iniTime = getTimer(); //tiempo inicial
trace("_________________\ntestB_iniTime: " add testB_iniTime);
inilevel = 1;
for ( var n = 0 ; n < c; n++){
for( var i = 0 ; i < r; i++){
var clip = attachMovie("clip", "clipb" add i ,++inilevel);
clip._x = basex + (clipW * n);
clip._y = basey + (clipH * i);
}
}
trace("testB_endTime: " add getTimer());
trace("totalTime: " add (getTimer() - testB_iniTime));
stop();
con esta otra tardó 68 ms. en la misma máquina.
está bonito esto de leer libritos ^_^
Ta bonito Kada, por otro lado ¿cómo haría si quisiera dejar bloques vacíos en la cuadrícula?
Gracias
la vida era tan linda, sin complicaciones ni naa...
haciendolo bien tramposo puedes poner en un array o en una string, los campos que no quieres que se vean, de echo en string queda mas facil.
digamos
[code]
c = 20;//columnas
r = 20;//filas
basey = 50;//basey
basex = 10;//basex
clipW = clipH = 10;//ancho y algo = 10
inilevel = 1;
saltar = ",x5y6,x6y6,x13y6,x14y6,x5y7,x6y7,x13y7,x14y7,x4y10,x15y10,x5y11,x14y11,x6y12,x13y12,x7y13,x8y13,x9y13,x10y13,x11y13,x12y13,";
for ( var n = 0 ; n < c; n++){
for( var i = 0 ; i < r; i++){
if(saltar.indexOf(",x" add n add "y" add i add ",") == -1){
var clip = attachMovie("clip", "clipb" add i ,++inilevel);
clip._x = basex + (clipW * n);
clip._y = basey + (clipH * i);
}
}
}
stop();
[/code]
claro, es solo una posibilidad
nota:
el señor con el linkage id sigue en la librería.
Hola, justo el tema este de generar cuadriculas lo estuve explicando en el taller que imparti en el pasado Flashfestival, y efectivamente lo generabamos asi con un doble "for", para el tema de dejar unas en blanco y otras no yo personalmente prefiero tirar de arrays... seria algo asi:
dibujo= [[1,1,1,1,1,1,1,1,1,1],
[1,0,0,0,0,0,0,0,0,1],
[1,0,0,0,0,1,1,1,0,1],
[1,0,0,1,0,1,0,0,0,1],
[1,0,0,0,0,1,0,0,0,1],
[1,0,0,0,0,1,0,0,0,1],
[1,0,0,1,0,1,0,0,0,1],
[1,0,0,0,0,1,1,1,0,1],
[1,0,0,0,0,0,0,0,0,1],
[1,1,1,1,1,1,1,1,1,1]];
//generar dibujo
anchodelacasilla=64;
altodelacasilla=64;
for (x=0; x<10; x++) {
for (y=0; y<10; y++) {
this.attachMovie("casillaMC", "c"+x+"_"+y, p++);
this["c"+x+"_"+y]._x = x*anchodelacasilla;
this["c"+x+"_"+y]._y = y*altodelacasilla;
this["c"+x+"_"+y].gotoAndStop(dibujo[y][x]+1);
}
}
Nota: hay que crear un movieclip con dos frame, el primero en blanco y el segundo con un cuadrado negro (en este caso de 64x64, aunque cambiar las medidas es sencillo)
Un saludete,
Pedro Alpera | Una China en mi Zapato Studio
www.unachinaenmizapato.com
Pues... eso es teoria de mapbuilder que se utiliza para isometria. Es muy interesante todo eso.
Salu2 y Feliz Navidad! :)
Cuando hacemos attachmovie, si usamos un nivel de profundidad ya ocupado, el nuevo clip sustiye al otro. Si repetimos nombre de instancia no, aunque luego no podremos referirnos correctamente a las instancias.
Entonces, para el nombre de instancia, usamos attachMovie("linkage","instancia" add n++, n), o mejor aun, para referirnos mas tarde al clip por su posición en la cuadricula, this.attachMovie("casillaMC", "c"+x+"_"+y, p++) , tal como lo puso Pedro Alpera. Un carácter entre 'x' e 'y' es necesario para que no se evalue la suma de estos valores, con lo cual se repetirian nombres de instancia.
Se puede reducir el tiempo si usamos valores concretos para las variables ancho, alto... si en un juego usamos casillas siempre de 32*32 y el mismo tamaño visible del escenario, quizas en la construcción del escenario no, pero en otras partes críticas podemos ahorranos un tiempo importante. En ocasiones, para ganar velocidad va bien en tareas críticas usar expresiones más compactas, aunque menos legibles. Y también ahorrarse variables intermedias que consumen tiempo al evaluarlas. O sea, un punto de vista totalmente contrario a la reusabilidad.
Almacenando el valor de retorno de attachMovie() en una referencia es más rapido que evaluar en cada momento el nombre del clip con this["c"+x+"_"+y]. Sorprendentemente, usar with(attachMovie(...)){...} es más lento.
Algo que no se hasta que punto es necesario, es definir un valor inicial para el nivel, ya que al usar el incremento vale 1.