// 3 en línea muy simplificado:
// 2 jugadores rivales, A y B.
// No hay tablero, hay una cadena de texto.
// La acción es poner 0 o 1 en el 1er sitio disponible.
// Hay victoria de A cuando la cadena tiene 3 "0",
// victoria de B cuando la cadena tiene 3 "1",
// y empate cuando no hay victoria y...
// la cadena tiene 4 caracteres:
// 
// Situaciones a investigar:
S1 = "";
S2 = "0";
S3 = "1";
S4 = "00";
S5 = "01";
S6 = "10";
S7 = "11";
S8 = "001";
S9 = "010";
S10 = "011";
S11 = "100";
S12 = "101";
S13 = "110";
// 
// Indica de qué nro de situación se cargarán datos:
NDeSInvestigandose = 13;
do {
    SInvestigandose = eval("S"+NDeSInvestigandose);
    // Se ponen valores malos o peores que los posibles...
    // para que sean fáciles de superar por...
    // valores obtenidos y no se sustituyan por iguales:
    // Averiguar de quién es el turno:
    if (SInvestigandose.length%2 == 0) {
        Turno = "A";
        // Asumiendo que ambos juegan bien
        // (usan su BestAction),
        // indica el ganador (A o B) o empate (E);
        // el resultado no es necesariamente inmediato:
        EndEsperadoDeBest = "B";
        // Si A siempre usa su BestAction y B juega al azar
        // (esto se va sustituyendo por mejores resultados):
// PROBABLEMENTE EN VEZ DE ALOSE Y BLOSE SE PODRÍA USAR DRAW
// PORQUE EL LOSE DE UNO ES IGUAL AL WIN DEL OTRO.
        ALoseChanceDeBest = 101;
        AWinChanceDeBest = 0;
        // Si B siempre usa su BestAction y A juega al azar
        // (a esto se le va sumando para luego promediarlo):
        BLoseChanceDeBest = 0;
        BWinChanceDeBest = 0;
    } else {
        Turno = "B";
        // Básicamente todo es al revés:
        EndEsperadoDeBest = "A";
        ALoseChanceDeBest = 0;
        AWinChanceDeBest = 0;
        BLoseChanceDeBest = 101;
        BWinChanceDeBest = 0;
    }
    trace ("Investigando la situación "+SInvestigandose+", es el turno de "+Turno);
    // Acción a realizar 1ero:
    Action = 0;
    // PROBABLEMENTE AÚN INNEC
    // Mejor acción hallada hasta ahora en la NDeSInvestigandose:
    BestAction = 0;
    // PROBABLEMENTE AÚN INNEC
    // Usando siempre BestAction indica cuántas acciones...
    // faltan para llegar a un final, contando esta:
    DistanciaDeBest = 0;
    // Si ambos jugaran al azar
    // (a esto se le va sumando para luego promediarlo):
    ALoseChance = 0;
    AWinChance = 0;
    BLoseChance = 0;
    BWinChance = 0;
    do {
        // Nueva situación al aplicarle una acción...
        // a la investigada:
        NewS = SInvestigandose+Action;
        // Para evitar reconcatenar al cargar datos...
        // de la nueva situación:
        SNewS = "S"+NewS;
        trace ("Se realizó la acción "+Action+", el resultado es "+NewS);
        // Para evaluar el resultado:
        CantidadDe0s = 0;
        CantidadDe1s = 0;
        CaracterRevisandose = 0;
        do {
            if (NewS.charat(CaracterRevisandose) == "0") {
                CantidadDe0s++;
            } else {
                CantidadDe1s++;
            }
            CaracterRevisandose++;
        } while (CaracterRevisandose<NewS.length);
///////////////////////////////////////////////////////////
// Turno de A:
///////////////////////////////////////////////////////////
        if (Turno == "A") {
            if (CantidadDe0s == 3) {
                trace ("Victoria de A");
                BLoseChanceDeBest = BLoseChanceDeBest+100;
                AWinChance = AWinChance+100;
                BLoseChance = BLoseChance+100;
                if (EndEsperadoDeBest != "A") {
                    trace ("Se sustituyen datos sobre qué hacer en la investigada y por qué");
                    BestAction = Action;
                    EndEsperadoDeBest = "A";
                    DistanciaDeBest = 0;
                    ALoseChanceDeBest = 0;
                    AWinChanceDeBest = 100;
                }
            } else if (CantidadDe1s == 3) {
                trace ("Derrota de A");
                BWinChanceDeBest = BWinChanceDeBest+100;
                ALoseChance = ALoseChance+100;
                BWinChance = BWinChance+100;
                if (ALoseChanceDeBest == 101) {
                    trace ("Es el mejor resultado hallado, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                    BestAction = Action;
                    DistanciaDeBest = 0;
                    ALoseChanceDeBest = 100;
                    AWinChanceDeBest = 0;
                }
            } else if (NewS.length == 4) {
                trace ("Empate");
                if (EndEsperadoDeBest == "B") {
                    trace ("Es el mejor resultado hallado, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                    BestAction = Action;
                    EndEsperadoDeBest = "E";
                    DistanciaDeBest = 0;
                    ALoseChanceDeBest = 0;
                    AWinChanceDeBest = 0;
                }
            } else {
                trace ("No es un final, se vará qué tan conveniente es");
                NewEndEsperadoDeBest = eval(SNewS+"EndEsperadoDeBest");
                if (NewEndEsperadoDeBest == "A") {
                    trace ("Se espera victoria");
                    if (NewEndEsperadoDeBest != EndEsperadoDeBest) {
                        trace ("Es el mejor resultado hallado, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                        BestAction = Action;
                        EndEsperadoDeBest = "A";
                        DistanciaDeBest = eval(SNewS+"DistanciaDeBest");
                        ALoseChanceDeBest = eval(SNewS+"ALoseChanceDeBest");
                        BWinChanceDeBest = eval(SNewS+"BWinChanceDeBest");
                    } else if (NewEndEsperadoDeBest == EndEsperadoDeBest) {
                        // inútil aquí quizá
                        trace ("Es igual al mejor resultado hallado, se verá la distancia");
                        NewDistanciaDeBest = eval(SNewS+"DistanciaDeBest");
                        if (NewDistanciaDeBest<DistanciaDeBest) {
                            trace ("Es menor, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                            BestAction = Action;
                            DistanciaDeBest = NewDistanciaDeBest;
                            ALoseChanceDeBest = eval(SNewS+"ALoseChanceDeBest");
                            AWinChanceDeBest = eval(SNewS+"AWinChanceDeBest");
                        } else if (NewDistanciaDeBest == DistanciaDeBest) {
                            trace ("Es igual, se verá la chance de perder");
                            NewALoseChanceDeBest = eval(SNewS+"ALoseChanceDeBest");
                            if (NewALoseChanceDeBest<ALoseChanceDeBest) {
                                trace ("Es menor, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                                BestAction = Action;
                                ALoseChanceDeBest = NewALoseChanceDeBest;
                                AWinChanceDeBest = eval(SNewS+"AWinChanceDeBest");
                            } else if (NewALoseChanceDeBest == ALoseChanceDeBest) {
                                trace ("Es igual, se verá la chance de ganar");
                                NewAWinChanceDeBest = eval(SNewS+"AWinChanceDeBest");
                                if (NewAWinChanceDeBest>AWinChanceDeBest) {
                                    trace ("Es mayor, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                                    BestAction = Action;
                                    AWinChanceDeBest = NewAWinChanceDeBest;
                                } else if (NewAWinChanceDeBest == AWinChanceDeBest) {
                                    trace ("Es igual, se verán las chances por azar");
                                    // falta esto
                                }
                            }
                        }
                    }
                } else if (NewEndEsperadoDeBest == "E") {
                    trace ("Se espera empate");
                    if (EndEsperadoDeBest == "B") {
                        trace ("Es el mejor resultado hallado, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                        BestAction = Action;
                        EndEsperadoDeBest = "E";
                        DistanciaDeBest = eval(SNewS+"DistanciaDeBest");
                        ALoseChanceDeBest = eval(SNewS+"ALoseChanceDeBest");
                        BWinChanceDeBest = eval(SNewS+"BWinChanceDeBest");
                    } else if (EndEsperadoDeBest == "E") {
// ESTA PARTE ES CASI IGUAL A UNA ANTERIOR, AQUÍ SE DEFINE DISTANCIA
                        trace ("Es igual al mejor resultado hallado, se verá la chance de perder");
                        NewALoseChanceDeBest = eval(SNewS+"ALoseChanceDeBest");
                        if (NewALoseChanceDeBest<ALoseChanceDeBest) {
                            trace ("Es menor, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                            BestAction = Action;
                            DistanciaDeBest = eval(SNewS+"DistanciaDeBest");
                            ALoseChanceDeBest = NewALoseChanceDeBest;
                            AWinChanceDeBest = eval(SNewS+"AWinChanceDeBest");
                        } else if (NewALoseChanceDeBest == ALoseChanceDeBest) {
                            trace ("Es igual, se verá la chance de ganar");
                            NewAWinChanceDeBest = eval(SNewS+"AWinChanceDeBest");
                            if (NewAWinChanceDeBest>AWinChanceDeBest) {
                                trace ("Es mayor, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                                BestAction = Action;
                                DistanciaDeBest = eval(SNewS+"DistanciaDeBest");
                                AWinChanceDeBest = NewAWinChanceDeBest;
                            } else if (NewAWinChanceDeBest == AWinChanceDeBest) {
                                trace ("Es igual, se verán las chances por azar");
                                // falta esto
                            }
                        }
                    }
                } else {
                    trace ("Se espera derrota");
                    if (NewEndEsperadoDeBest == EndEsperadoDeBest) {
                        trace ("Es igual al mejor resultado hallado, se verá la chance de perder");
// ESTA PARTE ES IGUAL A UNA ANTERIOR (se define distancia)
                        NewALoseChanceDeBest = eval(SNewS+"ALoseChanceDeBest");
                        if (NewALoseChanceDeBest<ALoseChanceDeBest) {
                            trace ("Es menor, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                            BestAction = Action;
                            DistanciaDeBest = eval(SNewS+"DistanciaDeBest");
                            ALoseChanceDeBest = NewALoseChanceDeBest;
                            AWinChanceDeBest = eval(SNewS+"AWinChanceDeBest");
                        } else if (NewALoseChanceDeBest == ALoseChanceDeBest) {
                            trace ("Es igual, se verá la chance de ganar");
                            NewAWinChanceDeBest = eval(SNewS+"AWinChanceDeBest");
                            if (NewAWinChanceDeBest>AWinChanceDeBest) {
                                trace ("Es mayor, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                                BestAction = Action;
                                DistanciaDeBest = eval(SNewS+"DistanciaDeBest");
                                AWinChanceDeBest = NewAWinChanceDeBest;
                            } else if (NewAWinChanceDeBest == AWinChanceDeBest) {
                                trace ("Es igual, se verán las chances por azar");
                                // falta esto
                            }
                        }
                    }
                }
                // Se suman las chances de la situación obtenida:
                ALoseChance = ALoseChance+eval(SNewS+"ALoseChance");
                AWinChance = AWinChance+eval(SNewS+"AWinChance");
                BLoseChance = BLoseChance+eval(SNewS+"BLoseChance");
                BWinChance = BWinChance+eval(SNewS+"BWinChance");
                ALoseChanceDeBest = ALoseChanceDeBest+eval(SNewS+"ALoseChanceDeBest");
                AWinChanceDeBest = AWinChanceDeBest+eval(SNewS+"AWinChanceDeBest");
                BLoseChanceDeBest = BLoseChanceDeBest+eval(SNewS+"BLoseChanceDeBest");
                BWinChanceDeBest = BWinChanceDeBest+eval(SNewS+"BWinChanceDeBest");
            }
        } else {
///////////////////////////////////////////////////////////
// Turno de B:
///////////////////////////////////////////////////////////
            if (CantidadDe1s == 3) {
                trace ("Victoria de B");
                ALoseChanceDeBest = ALoseChanceDeBest+100;
                BWinChance = BWinChance+100;
                ALoseChance = ALoseChance+100;
                if (EndEsperadoDeBest != "B") {
                    trace ("Se sustituyen datos sobre qué hacer en la investigada y por qué");
                    BestAction = Action;
                    EndEsperadoDeBest = "B";
                    DistanciaDeBest = 0;
                    BLoseChanceDeBest = 0;
                    BWinChanceDeBest = 100;
                }
            } else if (CantidadDe0s == 3) {
                trace ("Derrota de B");
                AWinChanceDeBest = AWinChanceDeBest+100;
                BLoseChance = BLoseChance+100;
                AWinChance = AWinChance+100;
                if (BLoseChanceDeBest == 101) {
                    trace ("Es el mejor resultado hallado, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                    BestAction = Action;
                    DistanciaDeBest = 0;
                    BLoseChanceDeBest = 100;
                    BWinChanceDeBest = 0;
                }
            } else if (NewS.length == 4) {
                trace ("Empate");
                if (EndEsperadoDeBest == "A") {
                    trace ("Es el mejor resultado hallado, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                    BestAction = Action;
                    EndEsperadoDeBest = "E";
                    DistanciaDeBest = 0;
                    BLoseChanceDeBest = 0;
                    BWinChanceDeBest = 0;
                }
            } else {
                trace ("No es un final, se vará qué tan conveniente es");
                NewEndEsperadoDeBest = eval(SNewS+"EndEsperadoDeBest");
                if (NewEndEsperadoDeBest == "B") {
                    trace ("Se espera victoria");
                    if (NewEndEsperadoDeBest != EndEsperadoDeBest) {
                        trace ("Es el mejor resultado hallado, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                        BestAction = Action;
                        EndEsperadoDeBest = "B";
                        DistanciaDeBest = eval(SNewS+"DistanciaDeBest");
                        BLoseChanceDeBest = eval(SNewS+"BLoseChanceDeBest");
                        AWinChanceDeBest = eval(SNewS+"AWinChanceDeBest");
                    } else if (NewEndEsperadoDeBest == EndEsperadoDeBest) {
                        // inútil aquí quizá
                        trace ("Es igual al mejor resultado hallado, se verá la distancia");
                        NewDistanciaDeBest = eval(SNewS+"DistanciaDeBest");
                        if (NewDistanciaDeBest<DistanciaDeBest) {
                            trace ("Es menor, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                            BestAction = Action;
                            DistanciaDeBest = NewDistanciaDeBest;
                            BLoseChanceDeBest = eval(SNewS+"BLoseChanceDeBest");
                            BWinChanceDeBest = eval(SNewS+"BWinChanceDeBest");
                        } else if (NewDistanciaDeBest == DistanciaDeBest) {
                            trace ("Es igual, se verá la chance de perder");
                            NewBLoseChanceDeBest = eval(SNewS+"BLoseChanceDeBest");
                            if (NewBLoseChanceDeBest<BLoseChanceDeBest) {
                                trace ("Es menor, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                                BestAction = Action;
                                BLoseChanceDeBest = NewBLoseChanceDeBest;
                                BWinChanceDeBest = eval(SNewS+"BWinChanceDeBest");
                            } else if (NewBLoseChanceDeBest == BLoseChanceDeBest) {
                                trace ("Es igual, se verá la chance de ganar");
                                NewBWinChanceDeBest = eval(SNewS+"BWinChanceDeBest");
                                if (NewBWinChanceDeBest>BWinChanceDeBest) {
                                    trace ("Es mayor, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                                    BestAction = Action;
                                    BWinChanceDeBest = NewBWinChanceDeBest;
                                } else if (NewBWinChanceDeBest == BWinChanceDeBest) {
                                    trace ("Es igual, se verán las chances por azar");
                                    // falta esto
                                }
                            }
                        }
                    }
                } else if (NewEndEsperadoDeBest == "E") {
                    trace ("Se espera empate");
                    if (EndEsperadoDeBest == "A") {
                        trace ("Es el mejor resultado hallado, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                        BestAction = Action;
                        EndEsperadoDeBest = "E";
                        DistanciaDeBest = eval(SNewS+"DistanciaDeBest");
                        BLoseChanceDeBest = eval(SNewS+"BLoseChanceDeBest");
                        AWinChanceDeBest = eval(SNewS+"AWinChanceDeBest");
                    } else if (EndEsperadoDeBest == "E") {
// ESTA PARTE ES CASI IGUAL A UNA ANTERIOR, AQUÍ SE DEFINE DISTANCIA
                        trace ("Es igual al mejor resultado hallado, se verá la chance de perder");
                        NewBLoseChanceDeBest = eval(SNewS+"BLoseChanceDeBest");
                        if (NewBLoseChanceDeBest<BLoseChanceDeBest) {
                            trace ("Es menor, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                            BestAction = Action;
                            DistanciaDeBest = eval(SNewS+"DistanciaDeBest");
                            BLoseChanceDeBest = NewBLoseChanceDeBest;
                            BWinChanceDeBest = eval(SNewS+"BWinChanceDeBest");
                        } else if (NewBLoseChanceDeBest == BLoseChanceDeBest) {
                            trace ("Es igual, se verá la chance de ganar");
                            NewBWinChanceDeBest = eval(SNewS+"BWinChanceDeBest");
                            if (NewBWinChanceDeBest>BWinChanceDeBest) {
                                trace ("Es mayor, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                                BestAction = Action;
                                DistanciaDeBest = eval(SNewS+"DistanciaDeBest");
                                BWinChanceDeBest = NewBWinChanceDeBest;
                            } else if (NewBWinChanceDeBest == BWinChanceDeBest) {
                                trace ("Es igual, se verán las chances por azar");
                                // falta esto
                            }
                        }
                    }
                } else {
                    trace ("Se espera derrota");
                    if (NewEndEsperadoDeBest == EndEsperadoDeBest) {
                        trace ("Es igual al mejor resultado hallado, se verá la chance de perder");
// ESTA PARTE ES IGUAL A UNA ANTERIOR (se define distancia)
                        NewBLoseChanceDeBest = eval(SNewS+"BLoseChanceDeBest");
                        if (NewBLoseChanceDeBest<BLoseChanceDeBest) {
                            trace ("Es menor, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                            BestAction = Action;
                            DistanciaDeBest = eval(SNewS+"DistanciaDeBest");
                            BLoseChanceDeBest = NewBLoseChanceDeBest;
                            BWinChanceDeBest = eval(SNewS+"BWinChanceDeBest");
                        } else if (NewBLoseChanceDeBest == BLoseChanceDeBest) {
                            trace ("Es igual, se verá la chance de ganar");
                            NewBWinChanceDeBest = eval(SNewS+"BWinChanceDeBest");
                            if (NewBWinChanceDeBest>BWinChanceDeBest) {
                                trace ("Es mayor, se sustituyen datos sobre qué hacer en la S investigada y por qué");
                                BestAction = Action;
                                DistanciaDeBest = eval(SNewS+"DistanciaDeBest");
                                BWinChanceDeBest = NewBWinChanceDeBest;
                            } else if (NewBWinChanceDeBest == BWinChanceDeBest) {
                                trace ("Es igual, se verán las chances por azar");
                                // falta esto
                            }
                        }
                    }
                }
                // Se suman las chances de la situación obtenida:
                BLoseChance = BLoseChance+eval(SNewS+"BLoseChance");
                BWinChance = BWinChance+eval(SNewS+"BWinChance");
                ALoseChance = ALoseChance+eval(SNewS+"ALoseChance");
                AWinChance = AWinChance+eval(SNewS+"AWinChance");
                BLoseChanceDeBest = BLoseChanceDeBest+eval(SNewS+"BLoseChanceDeBest");
                BWinChanceDeBest = BWinChanceDeBest+eval(SNewS+"BWinChanceDeBest");
                ALoseChanceDeBest = ALoseChanceDeBest+eval(SNewS+"ALoseChanceDeBest");
                AWinChanceDeBest = AWinChanceDeBest+eval(SNewS+"AWinChanceDeBest");
            }
        }
        Action++;
    } while (Action<2);
    trace ("No hay más acciones posibles, anotando datos");
///////////////////////////////////////////////////////////
// Guardar datos descubiertos de las situaciones:
///////////////////////////////////////////////////////////
    set ("S"+SInvestigandose+"BestAction", BestAction);
    set ("S"+SInvestigandose+"EndEsperadoDeBest", EndEsperadoDeBest);
    set ("S"+SInvestigandose+"DistanciaDeBest", DistanciaDeBest+1);
    set ("S"+SInvestigandose+"AWinChance", AWinChance/2);
    set ("S"+SInvestigandose+"BWinChance", BWinChance/2);
    if (Turno == "A") {
        set ("S"+SInvestigandose+"ALoseChanceDeBest", ALoseChanceDeBest);
        set ("S"+SInvestigandose+"AWinChanceDeBest", AWinChanceDeBest);
        set ("S"+SInvestigandose+"BLoseChanceDeBest", BLoseChanceDeBest/2);
        set ("S"+SInvestigandose+"BWinChanceDeBest", BWinChanceDeBest/2);
    } else {
        set ("S"+SInvestigandose+"ALoseChanceDeBest", ALoseChanceDeBest/2);
        set ("S"+SInvestigandose+"AWinChanceDeBest", AWinChanceDeBest/2);
        set ("S"+SInvestigandose+"BLoseChanceDeBest", BLoseChanceDeBest);
        set ("S"+SInvestigandose+"BWinChanceDeBest", BWinChanceDeBest);
    }
    // Investigar la situación anterior de la lista:
    NDeSInvestigandose--;
} while (NDeSInvestigandose>0);

// En este momento Images es 30,
// Barriles es igual no porque hayan 30 sino para evitar que...
// tengan el mismo depth que las imágenes anteriores:
Barriles = 30;
// Para saber qué depth asignar cuando se debe insertar un barril:
LdeProfundidadesDisponibles = [];
do {
	Barriles++;
	LdeProfundidadesDisponibles.push(Barriles);
} while (LdeProfundidadesDisponibles.length < BarrilesRate);
Barriles = 30;

function AddBarriles () {
	BarrilesTurn = BarrilesTurn+BarrilesRate;
	while (LdeProfundidadesDisponibles.length > 0 && BarrilesTurn >= 100) {
		BarrilesTurn = BarrilesTurn-100;
		Barriles++;
		Name = "Barril"+LdeProfundidadesDisponibles[0];
		trace("LdeProfundidadesDisponibles[0]: "+LdeProfundidadesDisponibles[0]);
		trace("se agregó el barril "+Name);
		attachMovie("sDKBarril", Name, LdeProfundidadesDisponibles[0]);
		setProperty (Name, _x, Math.random()*800);
		setProperty (Name, _y, -50);
		set(Name+".SpeedX", Math.random()*MinBarrilSpeed*(random(2)*2-1));
		set(Name+".SpeedY", Math.random()*MinBarrilSpeed+MinBarrilSpeed);
		LdeProfundidadesDisponibles[0] = LdeProfundidadesDisponibles[LdeProfundidadesDisponibles.length-1];
		LdeProfundidadesDisponibles.pop();
		trace("LdeProfundidadesDisponibles[0]: "+LdeProfundidadesDisponibles[0]);
	}
}

function MoveBarriles () {
	BarrilaMover = Barriles;
	while (BarrilaMover > 30) {
		Name = "Barril"+BarrilaMover;
		setProperty (Name, _x, getProperty(Name, _x)+eval(Name+".SpeedX"));
		trace("se movió el barril "+Name);
		if (getProperty(Name, _x) < -50 or getProperty(Name, _x) > 850) {
			removeMovieClip ("Barril"+BarrilaMover);
			trace("se quitó el barril "+Name);
			LdeProfundidadesDisponibles.push(BarrilaMover);
			Barriles--;
		} else {
			setProperty (Name, _y, getProperty(Name, _y)+eval(Name+".SpeedY"));
			if (getProperty(Name, _y) > 650) {
				removeMovieClip ("Barril"+BarrilaMover);
				trace("se quitó el barril "+Name);
				LdeProfundidadesDisponibles.push(BarrilaMover);
				Barriles--;
			} else {
				// Esto no viene al caso.
			}
		}
		BarrilaMover--;
	}
}

// /////////////////////////////////////////////
// //////////////////  Pisos  //////////////////
// /////////////////////////////////////////////
Pisos = 0;
do {
	Piso = "Piso"+Pisos;
	attachMovie("sDKPiso", Piso, Pisos);
	setProperty (Piso, _x, Pisos*16+16);
	setProperty (Piso, _y, 568-Pisos*18);
	PartesDelPiso = 0;
	PartesRequeridas = 26-Pisos/2;
	do {
		Parte = "Parte"+PartesDelPiso;
		// trace("Insertando "+Parte+" en "+Piso+" con depth "+PartesDelPiso);
		eval(Piso).attachMovie("sDKPisoParte", Parte, PartesDelPiso);
		RutaDeParte = Piso+"."+Parte;
		setProperty (RutaDeParte, _x, 32*PartesDelPiso);
		setProperty (RutaDeParte, _y, 0);
		PartesDelPiso++;
	} while (PartesDelPiso <= PartesRequeridas);
	Pisos++;
} while (Pisos < 30);
Images = Pisos;
 
// /////////////////////////////////////////////
// //////////////////  Mario  //////////////////
// /////////////////////////////////////////////
attachMovie("sDKMario", "Player", Images);
 
// /////////////////////////////////////////////
// ////////////////  Barriles  /////////////////
// /////////////////////////////////////////////
// Cuando llega a 100 puede que se inserte un barril:
BarrilesTurn = 0;
// Determina qué tan rápido aumenta BarrilesTurn y...
// la máxima cantidad de bariiles:
BarrilesRate = 1;
MinBarrilSpeed = 0.1;
// Para saber qué depth asignar cuando se debe insertar un barril:
LdeProfundidadesDisponibles = [];
do {
	LdeProfundidadesDisponibles.push(LdeProfundidadesDisponibles.length+1);
} while (LdeProfundidadesDisponibles.length < BarrilesRate);
function AddBarriles () {
	BarrilesTurn = BarrilesTurn+BarrilesRate;
	while (LdeProfundidadesDisponibles.length > 0 && BarrilesTurn >= 100) {
		BarrilesTurn = BarrilesTurn-100;
		Name = "Barril"+LdeProfundidadesDisponibles[0];
		attachMovie("sDKBarril", Name, LdeProfundidadesDisponibles[0]+Images);
		setProperty (Name, _x, Math.random()*800);
		setProperty (Name, _y, -50);
		set(Name+".SpeedX", Math.random()*MinBarrilSpeed*(random(2)*2-1));
		set(Name+".SpeedY", Math.random()*MinBarrilSpeed+MinBarrilSpeed);
		// Borra el 1er elemento de la lista:
		LdeProfundidadesDisponibles.shift();
	}
}
function MoveBarriles () {
	BarrilaMover = 0;
	while (BarrilaMover < BarrilesRate) {
		BarrilaMover++;
		Name = "Barril"+BarrilaMover;
		setProperty (Name, _x, getProperty(Name, _x)+eval(Name+".SpeedX"));
		if (getProperty(Name, _x) < -50 or getProperty(Name, _x) > 850) {
			removeMovieClip ("Barril"+BarrilaMover);
			LdeProfundidadesDisponibles.push(BarrilaMover);
		} else {
			setProperty (Name, _y, getProperty(Name, _y)+eval(Name+".SpeedY"));
			if (getProperty(Name, _y) > 650) {
				removeMovieClip ("Barril"+BarrilaMover);
				LdeProfundidadesDisponibles.push(BarrilaMover);
			} else {
				// No viene al caso;
			}
		}
	}
}