// Algo como esto if (MeteorYSpeed>0) { se está haciendo 2 veces,
// pero evitarlo implicaría unir cosas del jugador y la IA?
//
fscommand ("fullscreen", "true");
// Varía según diferencia de puntajes:
Dificultad = 0;
// Player:
attachMovie("sShip", "Player", 1);
setProperty ("Player", _x, 400);
setProperty ("Player", _y, 579.5);
// Velocidad conque se mueve:
PlayerSpeed = 3;
// Velocidad conque aumenta la puntería cuando...
// se prepara un rebote:
PlayerPunteria = 5;
// Siempre es PlayerPunteria^2:
PlayerMaxPunteria = 25;
PlayerScore = 0;
// Puntería alcanzada, en este momento el jugador saca...
// así que tiene la máxima. Entre más baja sea,
// peor puede que sea el rebote:
Punteria = PlayerMaxPunteria;
// ApuntandoX se define como si...
// el medio de la pantalla fuese 0:
ApuntandoX = 350*(2*random(2)-1);
ApuntandoY = 20.5+279.5*random(2);
// Hay una cantidad máxima que el meteoro puede rotar,
// hacia un lado u otro (valor negativo), depende de Dificultad.
// Rotando es un porcentaje, se rotará ese porcentaje del máximo:
Rotando = 100*(2*random(2)-1);
// IA:
attachMovie("sIA", "IA", 2);
setProperty ("IA", _x, 400);
setProperty ("IA", _y, 20.5);
IASpeed = 3;
IAPunteria = 3;
IAScore = 0;
// Meteor:
attachMovie("sMeteor", "Meteor", 3);
setProperty ("Meteor", _x, 400);
setProperty ("Meteor", _y, 544.5);
MeteorX = 400;
MeteorY = 544.5;
// Se define acá para que luego el programa considere que...
// hubo contacto entre la nave del jugador y el meteoro:
MeteorYSpeed = 1;
// Para que la curvatura dependa de...
// MeteorYSpeed (1 es hacia arriba, -1 hacia abajo):
MeteorYDirection = -1;
// Valores del color más brillante del meteoro (F0D9C8):
MaxRojo = 255;
MaxVerde = 217;
MaxAzul = 200;
// /////////////////////////////////////////////
// ////////////// Nave de Jugador //////////////
// /////////////////////////////////////////////
function ControlShip () {
if (Key.isDown(39)) {
// Derecha.
// Para evitar que se vaya demasiado al extremo derecho:
if (Player._x<722) {
Player._x = Player._x+PlayerSpeed;
} else {
Player._x = 725;
}
} else if (Key.isDown(37)) {
// Izquierda.
// Para evitar que se vaya demasiado al extremo izquierdo:
if (Player._x>78) {
Player._x = Player._x-PlayerSpeed;
} else {
Player._x = 75;
}
}
// Si el meteoro va hacia abajo:
if (MeteorYSpeed>0) {
// Si aún no se eligió hacia dónde rebotarlo:
if (ApuntandoX == 0) {
if (Key.isDown(65)) {
// Tecla A, a la izquierda:
ApuntandoX = -350;
ApuntandoY = 300;
attachMovie("sMira", "Mira", 4);
setProperty ("Mira", _x, 50);
setProperty ("Mira", _y, 300);
// Para luego saber que la tecla fue soltada:
TeclaPresionada = "A";
Punteria = 0;
Rotando = 0;
} else if (Key.isDown(83)) {
// S, a la derecha:
ApuntandoX = 350;
ApuntandoY = 300;
attachMovie("sMira", "Mira", 4);
setProperty ("Mira", _x, 750);
setProperty ("Mira", _y, 300);
TeclaPresionada = "S";
Punteria = 0;
Rotando = 0;
} else if (Key.isDown(81)) {
// Q, a la izquierda arriba:
ApuntandoX = -350;
ApuntandoY = 20.5;
attachMovie("sMira", "Mira", 4);
setProperty ("Mira", _x, 50);
setProperty ("Mira", _y, 20.5);
TeclaPresionada = "Q";
Punteria = 0;
Rotando = 0;
} else if (Key.isDown(87)) {
// W, a la derecha arriba:
ApuntandoX = 350;
ApuntandoY = 20.5;
attachMovie("sMira", "Mira", 4);
setProperty ("Mira", _x, 750);
setProperty ("Mira", _y, 20.5);
TeclaPresionada = "W";
Punteria = 0;
Rotando = 0;
}
// Si ya se eligió a donde apuntar pero aún no se soltó la tecla:
} else {
Punteria = Math.min(Punteria+PlayerPunteria, PlayerMaxPunteria, 100);
if (TeclaPresionada != "Ninguna") {
if (TeclaPresionada == "A" && !Key.isDown(65)) {
TeclaPresionada = "Ninguna";
} else if (TeclaPresionada == "S" && !Key.isDown(83)) {
TeclaPresionada = "Ninguna";
} else if (TeclaPresionada == "Q" && !Key.isDown(81)) {
TeclaPresionada = "Ninguna";
} else if (TeclaPresionada == "W" && !Key.isDown(87)) {
TeclaPresionada = "Ninguna";
}
// Si ya se eligió a dónde apuntar y se soltó la tecla pero no se eligió cómo rotarlo:
} else if (Rotando == 0) {
if (Key.isDown(65) or Key.isDown(81)) {
// Rotar a la izquierda. Representa un porcentaje,
// por ejemplo se aplicará el 1% de...
// la rotación que se elija al azar*-1.
Punteria = 0;
Rotando = -PlayerSpeed;
} else if (Key.isDown(83) or Key.isDown(87)) {
Punteria = 0;
Rotando = PlayerSpeed;
}
} else if (Rotando<0) {
Rotando = Math.max(Rotando-PlayerSpeed, -100);
} else if (Rotando>0) {
Rotando = Math.min(Rotando+PlayerSpeed, 100);
}
// setProperty ("Mira", _xscale, 200-Punteria);
// setProperty ("Mira", _yscale, 200-Punteria);
// setProperty ("Mira", _alpha, 50+Punteria/2);
}
}
}
// /////////////////////////////////////////////
// //////////////////// IA ///////////////////
// /////////////////////////////////////////////
function IATurn () {
IAReactionProgress++;
if (IAReactionProgress>500) {
// Si el meteoro va hacia arriba:
if (MeteorYSpeed<0) {
// La IA se moverá hacia él:
Distancia = IA._x-Meteor._x;
} else {
// La IA irá hacia el centro:
Distancia = IA._x-400;
}
if (Distancia<0) {
IA._x = IA._x+IASpeed;
// Para evitar que se vaya demasiado a la derecha:
if (IA._x>725) {
IA._x = 725;
}
} else if (Distancia>0) {
IA._x = IA._x-IASpeed;
if (IA._x<75) {
IA._x = 75;
}
}
}
}
// /////////////////////////////////////////////
// ///////////////// Meteor //////////////////
// /////////////////////////////////////////////
function VariarMeteoro () {
// esto no viene al caso
}
VariarMeteoro();
function MeteorMoves () {
MeteorXSpeed = MeteorXSpeed+MeteorRotation/1000*MeteorYDirection;
MeteorRotation = MeteorRotation/1.01;
MeteorX = MeteorX+MeteorXSpeed;
Meteor._x = MeteorX;
MeteorY = MeteorY+MeteorYSpeed;
Meteor._y = MeteorY;
Meteor._rotation = Meteor._rotation+MeteorRotation;
// Choque con nave derecha:
if (Meteor._x>752.5) {
MeteorXSpeed = -MeteorXSpeed;
if (MeteorYSpeed>0) {
// Si va hacia abajo:
MeteorYSpeed = Math.max(MeteorYSpeed, MeteorYSpeed-MeteorRotation/50);
} else if (MeteorYSpeed<0) {
MeteorYSpeed = Math.min(MeteorYSpeed, MeteorYSpeed+MeteorRotation/50);
}
MeteorRotation = Math.random()*10*(2*random(2)-1);
} else if (Meteor._x<47.5) {
// Choque con nave izquierda:
MeteorXSpeed = -MeteorXSpeed;
if (MeteorYSpeed>0) {
// Si va hacia abajo:
MeteorYSpeed = Math.max(MeteorYSpeed, MeteorYSpeed+MeteorRotation/50);
} else if (MeteorYSpeed<0) {
MeteorYSpeed = Math.min(MeteorYSpeed, MeteorYSpeed-MeteorRotation/50);
}
MeteorRotation = Math.random()*10*(2*random(2)-1);
}
if (Meteor.hitTest(Player) && MeteorYSpeed>0) {
// Estas 2 serán modificadas por baja Punteria luego:
MeteorYSpeed = Math.min(-Dificultad/10*Math.random()-1, -1);
MeteorRotation = (90*Math.random()+Dificultad*2)*Rotando/100;
// Distancia Y desde el meteoro hasta el punto hacia donde se lo apuntó:
DistanciaY = MeteorY-ApuntandoY;
// Cuánto tardará el meteoro en recorrerla:
TardanzaY = Math.ceil(DistanciaY/-MeteorYSpeed);
// Distancia X desde el meteoro hasta el punto hacia donde se lo apuntó:
DistanciaX = ApuntandoX+400-MeteorX;
// Determinar cuánto de moverá debido a la curva (falta considerar la reducción):
MovimientoPorCurva = MeteorRotation/1000*(101*TardanzaY-10100+10100*Math.pow(1.01, -TardanzaY));
// Determinar la velocidad X para que el meteoro llegue...
// al punto X apuntado justo cuando llega al punto Y apuntado,
// pero luego será modificada por baja Punteria:
MeteorXSpeed = (DistanciaX-MovimientoPorCurva)/TardanzaY;
// Modificaciones por baja Punteria:
InfluenciaDeError = Math.random()*(100-Punteria)/10;
MeteorYSpeed = Math.min(MeteorYSpeed+InfluenciaDeError, -1);
InfluenciaDeError = Math.random()*(100-Punteria)/10;
if (Rotando < 0) {
MeteorRotation = MeteorRotation+InfluenciaDeError;
} else if (Rotando > 0) {
MeteorRotation = MeteorRotation-InfluenciaDeError;
} else {
MeteorRotation = MeteorRotation+InfluenciaDeError*(2*random(2)-1);
}
InfluenciaDeError = Math.random()*(100-Punteria)/10*(2*random(2)-1);
MeteorXSpeed = MeteorXSpeed+InfluenciaDeError;
MeteorYDirection = 1;
// Probablemente innecesario:
TeclaPresionada = "Ninguna";
attachMovie("sMira", "Mira", 4);
setProperty ("Mira", _x, 400+ApuntandoX);
setProperty ("Mira", _y, ApuntandoY);
// removeMovieClip ("Mira");
IAReactionProgress = Dificultad/10;
IAPunteria = PlayerMaxPunteria;
IAApuntandoX = 350*(2*random(2)-1);
IAApuntandoY = 579.5-279.5*random(2);
IARotando = 100*(2*random(2)-1);
} else if (Meteor.hitTest(IA) && MeteorYSpeed<0) {
MeteorYSpeed = Math.max(Dificultad/10*Math.random()+1, 1);
MeteorRotation = (90*Math.random()+Dificultad*2)*IARotando/100;
DistanciaY = IAApuntandoY-MeteorY;
// Cuánto tardará el meteoro en recorrerla:
TardanzaY = Math.ceil(DistanciaY/MeteorYSpeed);
// Distancia X desde el meteoro hasta el punto hacia donde se lo apuntó:
DistanciaX = IAApuntandoX+400-MeteorX;
// Determinar cuánto de moverá debido a la curva (falta considerar la reducción):
MovimientoPorCurva = -MeteorRotation/1000*(101*TardanzaY-10100+10100*Math.pow(1.01, -TardanzaY));
// Determinar la velocidad X para que el meteoro llegue...
// al punto X apuntado justo cuando llega al punto Y apuntado:
MeteorXSpeed = (DistanciaX-MovimientoPorCurva)/TardanzaY;
InfluenciaDeError = Math.random()*(100-IAPunteria)/10;
MeteorYSpeed = Math.max(MeteorYSpeed-InfluenciaDeError, 1);
InfluenciaDeError = Math.random()*(100-IAPunteria)/10;
if (Rotando < 0) {
MeteorRotation = MeteorRotation+InfluenciaDeError;
} else if (Rotando > 0) {
MeteorRotation = MeteorRotation-InfluenciaDeError;
} else {
MeteorRotation = MeteorRotation+InfluenciaDeError*(2*random(2)-1);
}
InfluenciaDeError = Math.random()*(100-IAPunteria)/10*(2*random(2)-1);
MeteorXSpeed = MeteorXSpeed+InfluenciaDeError;
MeteorYDirection = -1;
attachMovie("sMira", "Mira", 4);
setProperty ("Mira", _x, 400+IAApuntandoX);
setProperty ("Mira", _y, IAApuntandoY);
Punteria = 0;
ApuntandoX = 0;
ApuntandoY = 20.5;
Rotando = 0;
// removeMovieClip ("Mira");
} else if (Meteor._y<0) {
// Punto de humano:
PlayerScore++;
Dificultad++;
PlayerSpeed = PlayerSpeed+0.1;
PlayerPunteria = PlayerPunteria+0.1;
PlayerMaxPunteria = Math.min(PlayerPunteria*PlayerPunteria, 100);
IASpeed = IASpeed+0.1;
setProperty ("Meteor", _x, 400);
setProperty ("Meteor", _y, 55.5);
MeteorX = 400;
MeteorY = 55.5;
// La IA va a sacar,
// ergo obtiene su máxima puntería:
IAPunteria = PlayerMaxPunteria;
IAApuntandoX = 350*(2*random(2)-1);
IAApuntandoY = 579.5-279.5*random(2);
IARotando = 100*(2*random(2)-1);
ShowScore();
} else if (Meteor._y>600) {
IAScore++;
Dificultad--;
PlayerSpeed = PlayerSpeed-0.1;
PlayerPunteria = PlayerPunteria-0.1;
PlayerMaxPunteria = Math.min(PlayerPunteria*PlayerPunteria, 100);
IASpeed = IASpeed-0.1;
setProperty ("Meteor", _x, 400);
setProperty ("Meteor", _y, 544.5);
MeteorX = 400;
MeteorY = 544.5;
Punteria = PlayerMaxPunteria;
ApuntandoX = 350*(2*random(2)-1);
ApuntandoY = 20.5+279.5*random(2);
Rotando = 100*(2*random(2)-1);
ShowScore();
}
}
//
function ShowScore () {
// esto no viene al caso
}
Mostrar Mensajes
