private void ColisionNave(float elapsedTime)
{
TgcBoundingBox NaveBBox = nave.Modelo.BoundingBox;
TgcBoundingBox EnemigoBBox = NaveEnemiga1.Modelo.BoundingBox;
if (TgcCollisionUtils.classifyBoxBox(NaveBBox, EnemigoBBox) != TgcCollisionUtils.BoxBoxResult.Afuera) // CONVERTIR EN UN FOREACH CUANDO HAYA LISTA DE ENEMIGOS
{
NaveEnemiga1.Modelo.Position -= new Vector3(-50, 0, 0);
return;
}
foreach (TgcMesh mesh in Universo.Meshes)
{
if (mesh.Name == "Universo")
{
continue;
}
TgcBoundingBox SceneBBox = mesh.BoundingBox;
TgcCollisionUtils.BoxBoxResult collisionResult = TgcCollisionUtils.classifyBoxBox(NaveBBox, SceneBBox);
if (collisionResult != TgcCollisionUtils.BoxBoxResult.Afuera)
{
nave.Modelo.moveOrientedY(10000f * elapsedTime);
return;
}
}
}
public bool calcularColisionPersonaje(TgcMesh mesh, TgcSkeletalMesh Sold)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, Sold.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
return(true);
}
return(false);
}
private bool SigoColisionadoConPelota(Pelota pelota, Jugador jugador)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(pelota.BoundingBox, jugador.GetTgcBoundingBox());
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
return(true);
}
return(false);
}
/*calcula las colisiones para un mesh, una lista de boundingbox y el personaje*/
/*public bool calcularColisiones(TgcSkeletalMesh pMesh, Personaje persona, List<TgcBoundingBox> objetosColisionables)
* {
* foreach (TgcBoundingBox obstaculo in objetosColisionables)
* {
* TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(pMesh.BoundingBox, obstaculo);
* if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
* {
* return true;
* }
* }
* if (TgcCollisionUtils.testSphereAABB(persona.characterSphere, pMesh.BoundingBox))
* {
* return true;
* }
* return false;
* }*/
/*public bool calcularColisionPersonaje(TgcSkeletalMesh mesh, Personaje personaje)
* {
* if (TgcCollisionUtils.testSphereAABB(personaje.characterSphere, mesh.BoundingBox))
* {
* return true;
* }
* return false;
* }*/
/*public bool calcularColisionPersonaje(TgcMesh mesh, TgcSkeletalMesh Sold)
* {
* TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, Sold.BoundingBox);
* if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
* {
*
* return true;
* }
*
*
* return false;
*
* }*/
/*public bool calcularColisiones(TgcMesh pMesh, Personaje persona, List<TgcBoundingBox> objetosColisionables)
* {
* foreach (TgcBoundingBox obstaculo in objetosColisionables)
* {
* TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(pMesh.BoundingBox, obstaculo);
* if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
* {
* return true;
* }
* }
* if (TgcCollisionUtils.testSphereAABB(persona.characterSphere, pMesh.BoundingBox))
* {
* return true;
* }
* return false;
* }*/
public bool calcularColisionesBB(TgcMesh pMesh, List <TgcBoundingBox> objetosColisionables)
{
foreach (TgcBoundingBox obstaculo in objetosColisionables)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(pMesh.BoundingBox, obstaculo);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
return(true);
}
}
return(false);
}
//COLISION SKYBOX
public bool colisionSkyBox(bool collide)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, EjemploAlumno.Instance.skyBoundingBox.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Afuera || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
collide = true;
}
return(collide);
}
/// <summary>
/// Detecto si el jugador uno colisiona contra algo
/// </summary>
/// <param name="lastPos">Posicion anterior a moverse</param>
public bool DetectarColisiones(IColisionable colisionable, Vector3 lastPos)
{
foreach (IColisionable obstaculo in this.obstaculos)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(colisionable.GetTgcBoundingBox(), obstaculo.GetTgcBoundingBox());
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
return(true);
}
}
return(false);
}
public static List <BoundingBoxCollider> getColisions(BoundingBoxCollider boundingBox)
{
List <BoundingBoxCollider> boundingBoxes = new List <BoundingBoxCollider>();
foreach (BoundingBoxCollider obstaculo in CollisionManager.obstaculos)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(boundingBox.Aabb, obstaculo.Aabb);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
boundingBoxes.Add(obstaculo);
}
}
return(boundingBoxes);
}
//COLISION ENEMIGO
public bool colisionEnemigo(bool collide, Vector3 lastPositionEnemy)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, EjemploAlumno.Instance.shipContrincante.mesh.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Atravesando || result == TgcCollisionUtils.BoxBoxResult.Adentro)
{
collide = true;
EjemploAlumno.Instance.shipContrincante.traslacion = Matrix.Translation(lastPositionEnemy.X, lastPositionEnemy.Y, lastPositionEnemy.Z);
}
return(collide);
}
public static Boolean detectColision(BoundingBoxCollider boundingBox)
{
Boolean collide = false;
foreach (BoundingBoxCollider obstaculo in CollisionManager.obstaculos)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(boundingBox.Aabb, obstaculo.Aabb);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
collide = true;
break;
}
}
return(collide);
}
public bool calcularColisiones(TgcMesh pMesh, Personaje persona, List <TgcBoundingBox> objetosColisionables)
{
foreach (TgcBoundingBox obstaculo in objetosColisionables)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(pMesh.BoundingBox, obstaculo);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
return(true);
}
}
if (TgcCollisionUtils.testSphereAABB(persona.characterSphere, pMesh.BoundingBox))
{
return(true);
}
return(false);
}
private void testChildCollideability(TgcBoundingBox objeto, QuadtreeNode childNode,
float boxLowerX, float boxLowerY, float boxLowerZ, float boxUpperX, float boxUpperY, float boxUpperZ)
{
//test frustum-box intersection
TgcBoundingBox caja = new TgcBoundingBox(
new Vector3(boxLowerX, boxLowerY, boxLowerZ),
new Vector3(boxUpperX, boxUpperY, boxUpperZ));
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(objeto, caja);
//parte adentro: seguir haciendo testeos con hijos
if (result == TgcCollisionUtils.BoxBoxResult.Encerrando || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
findNodesToCollide(objeto, childNode, boxLowerX, boxLowerY, boxLowerZ, boxUpperX, boxUpperY, boxUpperZ);
}
}
public ColisionInfo GetColisiones(TgcBoundingAxisAlignBox colisionable)
{
ColisionInfo colisionInfo = new ColisionInfo();
foreach (IColisionablePelota obstaculo in this.obstaculos)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(colisionable, obstaculo.GetTgcBoundingBox());
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
colisionInfo.Add(obstaculo);
}
}
return(colisionInfo);
}
public override void Update(float elapsedTime)
{
Matrix translate = Matrix.Translation(-vectorDireccion * MOVEMENT_SPEED * elapsedTime);
//Matrix translate = Matrix.Translation(new Vector3(1,0,1) * MOVEMENT_SPEED * elapsedTime);
posActual = translate * posActual;
mesh.Transform = posActual;
mesh.BoundingBox.transform(mesh.Transform);
//Colision de enemigos con vegetacion, hecho para que no se queden trabados con o sin "ayuda" del player
List <TgcMesh> obstaculos = new List <TgcMesh>();
obstaculos = GameManager.Instance.quadTree.findMeshesToCollide(mesh.BoundingBox);
foreach (TgcMesh obstaculo in obstaculos)
{
if (!obstaculo.Name.StartsWith("ArbustoComplejo"))
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, obstaculo.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
GameManager.Instance.eliminarProyectil(this);
return;
}
}
}
effect.SetValue("time", time);
//Colision con Player1
TgcCollisionUtils.BoxBoxResult resultPlayer = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, CustomFpsCamera.Instance.boundingBox);
if (resultPlayer == TgcCollisionUtils.BoxBoxResult.Adentro || resultPlayer == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
GameManager.Instance.player1.recibirAtaque(damage);
GameManager.Instance.eliminarProyectil(this);
return;
}
if (time > MAX_TIME)
{
GameManager.Instance.eliminarProyectil(this);
return;
}
time += elapsedTime;
}
public override void Update()
{
PreUpdate();
Random rnd = new Random();
float speed = 20f * ElapsedTime;
for (int t = 0; t < cant_enemigos; ++t)
{
float an = enemigo_an[t];
TGCVector3 vel = new TGCVector3((float)Math.Sin(an), 0, (float)Math.Cos(an));
//Mover personaje
TGCVector3 lastPos = enemigos[t].Position;
enemigos[t].Move(vel * speed);
enemigos[t].Rotation = new TGCVector3(0, (float)Math.PI + an, 0); // +(float)Math.PI/2
//Detectar colisiones de BoundingBox utilizando herramienta TgcCollisionUtils
bool collide = false;
foreach (TgcMesh obstaculo in scene.Meshes)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(enemigos[t].BoundingBox, obstaculo.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
collide = true;
break;
}
}
//Si hubo colision, restaurar la posicion anterior
if (collide)
{
enemigos[t].Position = lastPos;
enemigo_an[t] += (float)rnd.Next(0, 100) / 100.0f;
}
enemigos[t].updateAnimation(ElapsedTime);
}
PostUpdate();
}
private void findNodesToCollide(TgcBoundingBox objeto, QuadtreeNode node,
float boxLowerX, float boxLowerY, float boxLowerZ,
float boxUpperX, float boxUpperY, float boxUpperZ)
{
TgcBoundingBox caja = new TgcBoundingBox(
new Vector3(boxLowerX, boxLowerY, boxLowerZ),
new Vector3(boxUpperX, boxUpperY, boxUpperZ));
QuadtreeNode[] children = node.children;
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(objeto, caja);
//es hoja, cargar todos los meshes
if (children == null)
{
collidedNodes.Add(node);
}
//recursividad sobre hijos
else
{
float midX = FastMath.Abs((boxUpperX - boxLowerX) / 2);
float midZ = FastMath.Abs((boxUpperZ - boxLowerZ) / 2);
//00
testChildCollideability(objeto, children[0], boxLowerX + midX, boxLowerY, boxLowerZ + midZ, boxUpperX, boxUpperY, boxUpperZ);
//01
testChildCollideability(objeto, children[1], boxLowerX + midX, boxLowerY, boxLowerZ, boxUpperX, boxUpperY, boxUpperZ - midZ);
//10
testChildCollideability(objeto, children[2], boxLowerX, boxLowerY, boxLowerZ + midZ, boxUpperX - midX, boxUpperY, boxUpperZ);
//11
testChildCollideability(objeto, children[3], boxLowerX, boxLowerY, boxLowerZ, boxUpperX - midX, boxUpperY, boxUpperZ - midZ);
}
}
public override void Update(float elapsedTime)
{
/* string weap = (string)GuiController.Instance.Modifiers.getValue("Arma");
* switch (weap)
* {
* case "Sniper":
* weapon = sniper;
* break;
*
* case "Rocket Launcher":
* weapon = launcher;
* break;
* }*/
//update de la pos del mesh auxiliar
meshAuxiliarParaSonido.Position = CustomFpsCamera.Instance.eye;
//Procesamos input de teclado
TgcD3dInput input = GuiController.Instance.D3dInput;
//Seteamos las teclas
if (GuiController.Instance.D3dInput.buttonDown(TgcD3dInput.MouseButtons.BUTTON_LEFT) && weapon.FIRE_DELAY <= 0)
{
weapon.FIRE_DELAY = weapon.MAX_DELAY;
weapon.muzzle.MUZZLE_DELAY = weapon.muzzle.MAX_DELAY;
weapon.muzzle.TIME_RENDER = weapon.muzzle.MAX_RENDER;
weapon.fireWeapon();
CustomFpsCamera.Instance.rotateSmoothly(-0.30f, -1.5f, 0);
}
if (weapon.FIRE_DELAY > 0)
{
weapon.FIRE_DELAY -= elapsedTime;
}
if (weapon.muzzle.MUZZLE_DELAY > 0)
{
weapon.muzzle.MUZZLE_DELAY -= elapsedTime;
}
if (weapon.muzzle.TIME_RENDER > 0)
{
weapon.muzzle.TIME_RENDER -= elapsedTime;
}
if (GuiController.Instance.D3dInput.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_RIGHT) && ZOOM_DELAY <= 0.5f)
{
ZOOM_DELAY = MAX_ZOOM_DELAY;
HUDManager.Instance.zoomCamera();
}
if (GuiController.Instance.D3dInput.keyDown(Key.LeftShift) && sprintTime < MAX_SPRINT_TIME)
{
CustomFpsCamera.Instance.MovementSpeed = 3 * CustomFpsCamera.DEFAULT_MOVEMENT_SPEED;
sprintTime += elapsedTime;
if (!running)
{
runSound.play(true);
walkSound.stop();
running = true;
}
if (sprintTime > MAX_SPRINT_TIME)
{
breathSound.play(true);
tiredTime = 0;
}
}
else
{
CustomFpsCamera.Instance.MovementSpeed = CustomFpsCamera.DEFAULT_MOVEMENT_SPEED;
tiredTime += elapsedTime;
if (running)
{
runSound.stop();
walkSound.play(true);
running = false;
}
if (tiredTime > TIRED_TIME && sprintTime != 0)
{
breathSound.stop();
sprintTime = 0;
}
}
if (ZOOM_DELAY > 0)
{
ZOOM_DELAY -= elapsedTime;
}
//muzzleFlash.Position = WEAPON_OFFSET;
weapon.Update(elapsedTime);
//Maxima inclinacion sobre terreno
float yActual;
float yAnterior;
float movspeed = CustomFpsCamera.Instance.MovementSpeed;
GameManager.Instance.interpoledHeight(CustomFpsCamera.Instance.eye.X, CustomFpsCamera.Instance.eye.Z, out yActual);
GameManager.Instance.interpoledHeight(prevEye.X, prevEye.Z, out yAnterior);
double diferenciaPotenciada = Math.Pow((yActual - yAnterior) / (movspeed * elapsedTime), 2);
if (diferenciaPotenciada >= intensidadMaximaEscalable)
{
CustomFpsCamera.Instance.eye = prevEye;
CustomFpsCamera.Instance.reconstructViewMatrix(false);
}
//Colision de la camara con sliding
List <TgcMesh> obstaculos = new List <TgcMesh>();
obstaculos = GameManager.Instance.quadTree.findMeshesToCollide(CustomFpsCamera.Instance.boundingBox);
foreach (TgcMesh obstaculo in obstaculos)
{
if (!obstaculo.Name.StartsWith("ArbustoComplejo"))
{
Vector3 dirMov = CustomFpsCamera.Instance.eye - prevEye;
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(CustomFpsCamera.Instance.boundingBox, obstaculo.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
CustomFpsCamera.Instance.eye = prevEye + new Vector3(dirMov.X, 0, 0);
CustomFpsCamera.Instance.reconstructViewMatrix(false);
TgcCollisionUtils.BoxBoxResult resultX = TgcCollisionUtils.classifyBoxBox(CustomFpsCamera.Instance.boundingBox, obstaculo.BoundingBox);
if (resultX == TgcCollisionUtils.BoxBoxResult.Adentro || resultX == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
CustomFpsCamera.Instance.eye = prevEye + new Vector3(0, 0, dirMov.Z);
CustomFpsCamera.Instance.reconstructViewMatrix(false);
TgcCollisionUtils.BoxBoxResult resultZ = TgcCollisionUtils.classifyBoxBox(CustomFpsCamera.Instance.boundingBox, obstaculo.BoundingBox);
if (resultZ == TgcCollisionUtils.BoxBoxResult.Adentro || resultZ == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
CustomFpsCamera.Instance.eye = prevEye;
}
}
break;
}
}
}
if (prevEye == CustomFpsCamera.Instance.eye)
{
walkSound.stop();
runSound.stop();
}
else if (!running)
{
walkSound.play(true);
}
prevEye = CustomFpsCamera.Instance.eye;
}
/// <summary>
/// Método muy básico para detectar la colisión de dos bounding box.
/// </summary>
/// <param name="box1">Bounding box del primer objeto.</param>
/// <param name="box2">Bounding box del segundo objeto.</param>
/// <returns>Valor indicando si hubo o no colisión entre las bounding box.</returns>
public static bool DetectarColision(TgcBoundingBox box1, TgcBoundingBox box2)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(box1, box2);
return(result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando || result == TgcCollisionUtils.BoxBoxResult.Encerrando);
}
public override void render(float elapsedTime)
{
#region Controller
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
#endregion
#region Transformaciones
//nave.Transform = Matrix.Scaling(NAVE_SCALE) * Matrix.Translation(0, 9000, 0);
//nave.Transform = Matrix.Translation(0, 500, 0);
//nave.Transform = Matrix.Scaling(NAVE_SCALE);
#endregion
#region Movimiento y Rotacion
bool moving = false;
bool rotating = false;
float moveForward = 0f;
float rotate = 0;
TgcD3dInput input = GuiController.Instance.D3dInput;
//Vector3 movement = new Vector3(0, 0, 0);
if (input.keyDown(Key.Left) || input.keyDown(Key.A))
{
rotate = -NAVE_ROTATION_SPEED;
rotating = true;
}
else if (input.keyDown(Key.Right) || input.keyDown(Key.D))
{
rotate = NAVE_ROTATION_SPEED;
rotating = true;
}
if (input.keyDown(Key.Up) || input.keyDown(Key.W))
{
moveForward = -NAVE_MOVEMENT_SPEED;
moving = true;
}
else if (input.keyDown(Key.Down) || input.keyDown(Key.S))
{
moveForward = NAVE_MOVEMENT_SPEED;
moving = true;
}
Vector3 Position_prev = nave.Position;
if (rotating)
{
nave.rotateY(Geometry.DegreeToRadian(rotate * elapsedTime));
GuiController.Instance.ThirdPersonCamera.rotateY(Geometry.DegreeToRadian(rotate * elapsedTime));
}
if (moving)
{
Vector3 lastPos = nave.Position;
nave.moveOrientedY(moveForward * elapsedTime);
}
//Aplicar movimiento (VIEJO)
//movement *= MOVEMENT_SPEED * elapsedTime;
//nave.move(movement);
bool Collision = false;
foreach (TgcMesh planeta in planetas)
{
TgcBoundingBox nave_BBox = nave.BoundingBox;
TgcBoundingBox planeta_BBox = planeta.BoundingBox;
TgcCollisionUtils.BoxBoxResult Collision_Type = TgcCollisionUtils.classifyBoxBox(nave_BBox, planeta_BBox);
if (Collision_Type != TgcCollisionUtils.BoxBoxResult.Afuera)
{
Collision = true;
break;
}
}
if (Collision)
{
;
}
#endregion
#region Camara
GuiController.Instance.ThirdPersonCamera.Target = nave.Position;
#endregion
#region Render
nave.render();
for (int i = 0; i < 10; i++)
{
planetas[i].render();
}
//universo.renderAll();
nave.BoundingBox.render();
foreach (TgcMesh planeta in planetas)
{
planeta.BoundingBox.render();
}
#endregion
}
public override void render(float elapsedTime)
{
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//Obtener boolean para saber si hay que mostrar Bounding Box
bool showBB = (bool)GuiController.Instance.Modifiers.getValue("showBoundingBox");
//obtener velocidades de Modifiers
float velocidadCaminar = (float)GuiController.Instance.Modifiers.getValue("VelocidadCaminar");
float velocidadRotacion = (float)GuiController.Instance.Modifiers.getValue("VelocidadRotacion");
//Calcular proxima posicion de personaje segun Input
float moveForward = 0f;
float rotate = 0;
TgcD3dInput d3dInput = GuiController.Instance.D3dInput;
bool moving = false;
bool rotating = false;
//Adelante
if (d3dInput.keyDown(Key.W))
{
moveForward = -velocidadCaminar;
moving = true;
}
//Atras
if (d3dInput.keyDown(Key.S))
{
moveForward = velocidadCaminar;
moving = true;
}
//Derecha
if (d3dInput.keyDown(Key.D))
{
rotate = velocidadRotacion;
rotating = true;
}
//Izquierda
if (d3dInput.keyDown(Key.A))
{
rotate = -velocidadRotacion;
rotating = true;
}
//Si hubo rotacion
if (rotating)
{
//Rotar personaje y la camara, hay que multiplicarlo por el tiempo transcurrido para no atarse a la velocidad el hardware
float rotAngle = Geometry.DegreeToRadian(rotate * elapsedTime);
personaje.rotateY(rotAngle);
GuiController.Instance.ThirdPersonCamera.rotateY(rotAngle);
}
//Si hubo desplazamiento
if (moving)
{
//Activar animacion de caminando
personaje.playAnimation("Caminando", true);
//Aplicar movimiento hacia adelante o atras segun la orientacion actual del Mesh
Vector3 lastPos = personaje.Position;
//La velocidad de movimiento tiene que multiplicarse por el elapsedTime para hacerse independiente de la velocida de CPU
//Ver Unidad 2: Ciclo acoplado vs ciclo desacoplado
personaje.moveOrientedY(moveForward * elapsedTime);
//Detectar colisiones
bool collide = false;
foreach (TgcBox obstaculo in obstaculos)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(personaje.BoundingBox, obstaculo.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
collide = true;
break;
}
}
//Si hubo colision, restaurar la posicion anterior
if (collide)
{
personaje.Position = lastPos;
}
else
{
}
}
//Si no se esta moviendo, activar animacion de Parado
else
{
personaje.playAnimation("Parado", true);
}
//Hacer que la camara siga al personaje en su nueva posicion
GuiController.Instance.ThirdPersonCamera.Target = personaje.Position;
//Render piso
piso.render();
//Render obstaculos
foreach (TgcBox obstaculo in obstaculos)
{
obstaculo.render();
if (showBB)
{
obstaculo.BoundingBox.render();
}
}
//Render personaje
personaje.animateAndRender();
if (showBB)
{
personaje.BoundingBox.render();
}
}
public void render(float elapsedTime)
{
//moverse y rotar son variables que me indican a qué velocidad se moverá o rotará el mesh respectivamente.
//Se inicializan en 0, porque por defecto está quieto.
float moverse = 0f;
float rotar = 0f;
habilitarDecremento = true;
GuiController.Instance.UserVars.setValue("Velocidad", Math.Abs(auto.velocidadActual));
GuiController.Instance.UserVars.setValue("Vida", escalaVida.X);
GuiController.Instance.UserVars.setValue("AngCol", Geometry.RadianToDegree(anguloColision));
GuiController.Instance.UserVars.setValue("AngRot", Geometry.RadianToDegree(anguloARotar));
//aumento de la velocidad de rotacion al derrapar
modificarVelocidadRotacion(auto);
//Procesa las entradas del teclado.
if (entrada.keyDown(Key.Q))
{
finDeJuego = true;
salirConQ = true;
}
if (entrada.keyDown(Key.S))
{
moverse = auto.irParaAtras(elapsedTime);
}
if (entrada.keyDown(Key.W))
{
moverse = auto.irParaAdelante(elapsedTime);
}
if (entrada.keyDown(Key.A) && (auto.velocidadActual > 0.5f || auto.velocidadActual < -0.5f)) //izquierda
{
rotar = -auto.velocidadRotacion;
}
if (entrada.keyDown(Key.D) && (auto.velocidadActual > 0.5f || auto.velocidadActual < -0.5f)) //derecha
{
rotar = auto.velocidadRotacion;
}
if (entrada.keyPressed(Key.M))
{
musica.muteUnmute();
auto.mutearSonido();
}
if (entrada.keyPressed(Key.R)) //boton de reset, el mesh vuelve a la posicion de inicio y restaura todos sus parametros
{
auto.reiniciar();
auto.mesh.move(new Vector3(0, 0, -3100));
auto.mesh.rotateY(-1.57f);
EjemploAlumno.instance.activar_efecto = false;
nivel.reiniciar();
this.reiniciar();
GuiController.Instance.ThirdPersonCamera.resetValues();
GuiController.Instance.ThirdPersonCamera.rotateY(-1.57f);
}
if (entrada.keyPressed(Key.B)) //Modo debug para visualizar BoundingBoxes entre otras cosas que nos sirvan a nosotros
{
Shared.debugMode = !Shared.debugMode;
}
if (entrada.keyPressed(Key.I))
{
modoDios = !modoDios;
}
//Frenado por inercia
if (!entrada.keyDown(Key.W) && !entrada.keyDown(Key.S) && auto.velocidadActual != 0)
{
moverse = auto.frenarPorInercia(elapsedTime);
}
if (moverse > auto.velocidadMaxima)
{
auto.velocidadActual = auto.velocidadMaxima;
}
if (moverse < (-auto.velocidadMaxima))
{
auto.velocidadActual = -auto.velocidadMaxima;
}
int sentidoRotacion = 0; //sentido de rotacion del reajuste de camara
float rotCamara = GuiController.Instance.ThirdPersonCamera.RotationY;
float rotAuto = auto.mesh.Rotation.Y;
float deltaRotacion = rotAuto - rotCamara;
float dif = FastMath.Abs(Geometry.RadianToDegree(deltaRotacion));
float rapidez = 5f; //aceleracion de reajuste de camara
if (rotar != 0)
{
habilitarDecremento = false;
habilitarContador = true;
}
if (dif < 40)
{
if (dif < 30)
{
if (dif < 20)
{
rapidez = 0.8f;
}
else
{
rapidez = 2f;
}
}
else
{
rapidez = 3f;
}
}
if (habilitarContador)
{
pasaronSegundos += elapsedTime;
}
if (deltaRotacion < 0)
{
sentidoRotacion = -1;
}
else
{
sentidoRotacion = 1;
}
if (deltaRotacion != 0 && pasaronSegundos > 0.5f)
{
ajustar = true;
pasaronSegundos = 0f;
habilitarContador = false;
}
float rotAngle = Geometry.DegreeToRadian(rotar * elapsedTime);
if (ajustar)
{
GuiController.Instance.ThirdPersonCamera.rotateY(sentidoRotacion * rapidez * elapsedTime);
}
if (deltaRotacion < 0)
{
sentidoRotacion = -1;
}
else
{
sentidoRotacion = 1;
}
incrementarTiempo(this, elapsedTime, habilitarDecremento);
auto.mesh.rotateY(rotAngle);
auto.obb.rotate(new Vector3(0, rotAngle, 0));
if (FastMath.Abs(Geometry.RadianToDegree(deltaRotacion)) % 360 < 3)
{
GuiController.Instance.ThirdPersonCamera.RotationY = rotAuto;
ajustar = false;
}
if (habilitarDecremento)
{
incrementarTiempo(this, elapsedTime, habilitarDecremento);
}
if (moverse != 0 || auto.velocidadActual != 0) //Si hubo movimiento
{
Vector3 lastPos = auto.mesh.Position;
auto.mesh.moveOrientedY(moverse * elapsedTime);
Vector3 position = auto.mesh.Position;
Vector3 posDiff = position - lastPos;
auto.obb.move(posDiff);
Vector3 direccion = new Vector3(FastMath.Sin(auto.mesh.Rotation.Y) * moverse, 0, FastMath.Cos(auto.mesh.Rotation.Y) * moverse);
auto.direccion.PEnd = auto.obb.Center + Vector3.Multiply(direccion, 50f);
//Detectar colisiones de BoundingBox utilizando herramienta TgcCollisionUtils
bool collide = false;
Vector3[] cornersAuto;
Vector3[] cornersObstaculo;
foreach (ObstaculoRigido obstaculo in nivel.obstaculos)
{
if (Colisiones.testObbObb2(auto.obb, obstaculo.obb)) //chequeo obstáculo por obstáculo si está chocando con auto
{
collide = true;
obstaculoChocado = obstaculo;
Shared.mostrarChispa = true;
if (FastMath.Abs(auto.velocidadActual) > 800)
{
auto.reproducirSonidoChoque(FastMath.Abs(auto.velocidadActual));
auto.deformarMesh(obstaculo.obb, FastMath.Abs(auto.velocidadActual));
}
if (FastMath.Abs(auto.velocidadActual) > 800 && !modoDios)
{
escalaVida.X -= 0.00003f * Math.Abs(auto.velocidadActual) * escalaInicial.X;
if (escalaVida.X > 0.03f)
{
vida.setEscala(new Vector2(escalaVida.X, escalaVida.Y));
}
else
{
finDeJuego = true;
muerte = true;
}
}
break;
}
}
//Si hubo colision, restaurar la posicion anterior (sino sigo de largo)
if (collide)
{
auto.mesh.Position = lastPos;
auto.obb.updateValues();
moverse = auto.chocar(elapsedTime);
if (FastMath.Abs(auto.velocidadActual) > 0)
{
cornersAuto = CalculosVectores.computeCorners(auto);
cornersObstaculo = CalculosVectores.computeCorners(obstaculoChocado);
List <Plane> carasDelObstaculo = CalculosVectores.generarCaras(cornersObstaculo);
Vector3 NormalAuto = direccion;
caraChocada = CalculosVectores.detectarCaraChocada(carasDelObstaculo, auto.puntoChoque);
Vector3 NormalObstaculo = new Vector3(caraChocada.A, caraChocada.B, caraChocada.C);
GuiController.Instance.UserVars.setValue("NormalObstaculoX", NormalObstaculo.X);
GuiController.Instance.UserVars.setValue("NormalObstaculoZ", NormalObstaculo.Z);
float desplazamientoInfinitesimal = 5f;
float constanteDesvio = 1.3f;
//Calculo el angulo entre ambos vectores
anguloColision = CalculosVectores.calcularAnguloEntreVectoresNormalizados(NormalAuto, NormalObstaculo);//Angulo entre ambos vectores
//rota mesh
if (FastMath.Abs(auto.velocidadActual) > 800)
{
if (Geometry.RadianToDegree(anguloColision) < 25) //dado un cierto umbral, el coche rebota sin cambiar su direccion
{
auto.velocidadActual = -auto.velocidadActual;
}
else //el coche choca y cambia su direccion
{
if (NormalObstaculo.Z > 0 && direccion.X > 0 && direccion.Z > 0)
{
anguloARotar = constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
auto.mesh.move(new Vector3(0, 0, -10));
colorDeColision = Color.Red;
}
if (NormalObstaculo.X > 0 && direccion.X > 0 && direccion.Z > 0)
{
anguloARotar = -constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
auto.mesh.move(new Vector3(-5, 0, 0));
colorDeColision = Color.Salmon;
}
if (NormalObstaculo.X > 0 && direccion.X > 0 && direccion.Z < 0)
{
anguloARotar = constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
colorDeColision = Color.Blue;
auto.mesh.move(new Vector3(-desplazamientoInfinitesimal, 0, 0));
}
if (NormalObstaculo.Z < 0 && direccion.X > 0 && direccion.Z < 0)
{
anguloARotar = -constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
auto.mesh.move(new Vector3(0, 0, desplazamientoInfinitesimal));
colorDeColision = Color.Green;
}
if (NormalObstaculo.Z < 0 && direccion.X < 0 && direccion.Z < 0)
{
anguloARotar = constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
auto.mesh.move(new Vector3(0, 0, desplazamientoInfinitesimal));
colorDeColision = Color.Pink;
}
if (NormalObstaculo.X < 0 && direccion.X < 0 && direccion.Z < 0)
{
anguloARotar = -constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
auto.mesh.move(new Vector3(desplazamientoInfinitesimal, 0, 0));
colorDeColision = Color.Silver;
}
if (NormalObstaculo.X < 0 && direccion.X < 0 && direccion.Z > 0)
{
anguloARotar = constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
auto.mesh.move(new Vector3(desplazamientoInfinitesimal, 0, 0));
colorDeColision = Color.Aquamarine;
}
if (NormalObstaculo.Z > 0 && direccion.X < 0 && direccion.Z > 0)
{
anguloARotar = -constanteDesvio * (Geometry.DegreeToRadian(90) - anguloColision);
auto.mesh.move(new Vector3(0, 0, -desplazamientoInfinitesimal));
colorDeColision = Color.Yellow;
}
auto.mesh.rotateY(anguloARotar);
}
}
}
}
foreach (Recursos recurso in nivel.recursos)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(auto.mesh.BoundingBox, recurso.modelo.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
nivel.recursos.Remove(recurso); //Saca el recurso de la lista para que no se renderice más
float puntos = Convert.ToSingle(this.puntos.Text) + 100f;
this.puntos.Text = Convert.ToString(puntos);
break;
}
}
//Chequeo si el auto agarro el checkpoint actual
if (Colisiones.testObbObb2(auto.obb, nivel.checkpointActual.obb))
{
if (nivel.checkpointsRestantes.Text != "1")
{
nivel.checkpoints.Remove(nivel.checkpointActual); //Saca el checkpoint de la lista para que no se renderice más
int restantes = (Convert.ToInt16(nivel.checkpointsRestantes.Text) - 1);
nivel.checkpointsRestantes.Text = restantes.ToString(); //Le resto uno a los restantes
this.tiempoRestante.Text = (Convert.ToSingle(this.tiempoRestante.Text) + 10f).ToString();
nivel.checkpointActual = nivel.checkpoints.ElementAt(0);
}
else
{
finDeJuego = true;
}
}
//Efecto blur
if (FastMath.Abs(auto.velocidadActual) > (auto.velocidadMaxima * 0.5555))
{
EjemploAlumno.instance.activar_efecto = true;
EjemploAlumno.instance.blur_intensity = 0.003f * (float)Math.Round(FastMath.Abs(auto.velocidadActual) / (auto.velocidadMaxima), 5);
}
else
{
EjemploAlumno.instance.activar_efecto = false;
}
}
GuiController.Instance.ThirdPersonCamera.Target = auto.mesh.Position;
//actualizo cam
Vector2 vectorCam = (Vector2)GuiController.Instance.Modifiers["AlturaCamara"];
GuiController.Instance.ThirdPersonCamera.setCamera(auto.mesh.Position, vectorCam.X, vectorCam.Y);
float tope = 1f;
float constanteDerrape = ((tiempoTrans / 2) < tope) ? (tiempoTrans / 2) : tope;
float proporcion = FastMath.Abs(auto.velocidadActual / auto.velocidadMaxima);
if (sentidoAnterior != sentidoRotacion && tiempoTrans != 0)
{
incrementarTiempo(this, elapsedTime * 5, true);
}
if (tiempoTrans == 0)
{
sentidoAnterior = sentidoRotacion;
}
auto.mesh.rotateY(constanteDerrape * sentidoAnterior * proporcion);
auto.render();
auto.obb = TgcObb.computeFromAABB(auto.mesh.BoundingBox);
auto.obb.setRotation(auto.mesh.Rotation);
auto.obb.setRenderColor(colorDeColision);
auto.mesh.rotateY(-constanteDerrape * sentidoAnterior * proporcion);
//dibuja el nivel
nivel.render(elapsedTime);
//AJUSTE DE CAMARA SEGUN COLISION
ajustarCamaraSegunColision(auto, nivel.obstaculos);
//Dibujo checkpoints restantes
nivel.checkpointsRestantes.render();
//Dibujo el puntaje del juego
this.puntos.render();
//CUENTA REGRESIVA
if (this.tiempoRestante.Text == "1")
{
uno.render();
}
if (this.tiempoRestante.Text == "2")
{
dos.render();
}
if (this.tiempoRestante.Text == "3")
{
tres.render();
}
//Actualizo y dibujo el relops
if ((DateTime.Now.Subtract(this.horaInicio).TotalSeconds) > segundosAuxiliares && !modoDios)
{
this.tiempoRestante.Text = (Convert.ToDouble(tiempoRestante.Text) - 1).ToString();
if (this.tiempoRestante.Text == "0") //Si se acaba el tiempo, me muestra el game over y reseetea todo
{
finDeJuego = true;
muerte = true;
}
segundosAuxiliares++;
}
this.tiempoRestante.render();
//Si se le acabo el tiempo o la vida, o apretó "Q"
if (finDeJuego)
{
//corta la música al salir
TgcMp3Player player = GuiController.Instance.Mp3Player;
player.closeFile();
GuiController.Instance.UserVars.clearVars();
//saca el blur
EjemploAlumno.instance.activar_efecto = false;
//reinicia los valores de las cosas del juego
auto.reiniciar();
nivel.reiniciar();
this.reiniciar();
//reinicia la camara
GuiController.Instance.ThirdPersonCamera.resetValues();
if (muerte)
{
EjemploAlu.setPantalla(EjemploAlu.getPantalla(1));
}
else if (salirConQ)
{
EjemploAlumno.getInstance().setPantalla(new PantallaInicio());
}
else
{
EjemploAlu.setPantalla(EjemploAlu.getPantalla(2));
}
}
if (comienzoNivel)
{
if (DateTime.Now.Subtract(this.horaInicio).TotalSeconds < 3)
{
if (auto.nombre == "Luigi")
{
misionLuigi.render();
}
else
{
misionMario.render();
}
}
else
{
comienzoNivel = false;
}
}
else
{
//Dibujo barrita
if (auto.nombre == "Luigi")
{
barra2.render();
}
else
{
barra.render();
}
vida.render();
}
//renderizo utilidades del debugMode
if (Shared.debugMode)
{
Vector2 vectorModifier = (Vector2)GuiController.Instance.Modifiers["PosicionFlechaDebug"];
Vector3 vectorPosicion = new Vector3(vectorModifier.X, 10, vectorModifier.Y);
debugArrow.PStart = vectorPosicion + new Vector3(0, 400f, 0);
debugArrow.PEnd = vectorPosicion;
debugArrow.updateValues();
debugArrow.render();
//renderizo normal al plano chocado
if (obstaculoChocado != null)
{
collisionNormalArrow.PStart = obstaculoChocado.obb.Center;
collisionNormalArrow.PEnd = obstaculoChocado.obb.Center + Vector3.Multiply(new Vector3(caraChocada.A, caraChocada.B, caraChocada.C), 500f);
collisionNormalArrow.updateValues();
collisionNormalArrow.render();
}
}
}
public override void render(float elapsedTime)
{
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//Procesamos input de teclado para mover el objeto principal en el plano XZ
TgcD3dInput input = GuiController.Instance.D3dInput;
Vector3 movement = new Vector3(0, 0, 0);
if (input.keyDown(Key.Left) || input.keyDown(Key.A))
{
movement.X = 1;
}
else if (input.keyDown(Key.Right) || input.keyDown(Key.D))
{
movement.X = -1;
}
if (input.keyDown(Key.Up) || input.keyDown(Key.W))
{
movement.Z = -1;
}
else if (input.keyDown(Key.Down) || input.keyDown(Key.S))
{
movement.Z = 1;
}
//Guardar posicion original antes de cambiarla
Vector3 originalPos = mainMesh.Position;
//Aplicar movimiento
movement *= MOVEMENT_SPEED * elapsedTime;
mainMesh.move(movement);
//Chequear si el objeto principal en su nueva posición choca con alguno de los objetos de la escena.
//Si es así, entonces volvemos a la posición original.
//Cada TgcMesh tiene un objeto llamado BoundingBox. El BoundingBox es una caja 3D que representa al objeto
//de forma simplificada (sin tener en cuenta toda la complejidad interna del modelo).
//Este BoundingBox se utiliza para chequear si dos objetos colisionan entre sí.
//El framework posee la clase TgcCollisionUtils con muchos algoritmos de colisión de distintos tipos de objetos.
//Por ejemplo chequear si dos cajas colisionan entre sí, o dos esferas, o esfera con caja, etc.
bool collisionFound = false;
foreach (TgcMesh mesh in scene.Meshes)
{
//Los dos BoundingBox que vamos a testear
TgcBoundingBox mainMeshBoundingBox = mainMesh.BoundingBox;
TgcBoundingBox sceneMeshBoundingBox = mesh.BoundingBox;
//Ejecutar algoritmo de detección de colisiones
TgcCollisionUtils.BoxBoxResult collisionResult = TgcCollisionUtils.classifyBoxBox(mainMeshBoundingBox, sceneMeshBoundingBox);
//Hubo colisión con un objeto. Guardar resultado y abortar loop.
if (collisionResult != TgcCollisionUtils.BoxBoxResult.Afuera)
{
collisionFound = true;
break;
}
}
//Si hubo alguna colisión, entonces restaurar la posición original del mesh
if (collisionFound)
{
mainMesh.Position = originalPos;
}
//Actualizar posicion de cámara
GuiController.Instance.ThirdPersonCamera.Target = mainMesh.Position;
//Dibujar
mainMesh.render();
scene.renderAll();
//En este ejemplo a modo de debug vamos a dibujar los BoundingBox de todos los objetos.
//Asi puede verse como se efectúa el testeo de colisiones.
mainMesh.BoundingBox.render();
foreach (TgcMesh mesh in scene.Meshes)
{
mesh.BoundingBox.render();
}
}
public override void render(float elapsedTime)
{
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//Ver si hay que mostrar el BoundingBox
bool showBB = (bool)GuiController.Instance.Modifiers.getValue("showBoundingBox");
//Calcular proxima posicion de personaje segun Input
Vector3 move = new Vector3(0, 0, 0);
//Multiplicar la velocidad por el tiempo transcurrido, para no acoplarse al CPU
float speed = VELOCIDAD_DESPLAZAMIENTO * elapsedTime;
TgcD3dInput d3dInput = GuiController.Instance.D3dInput;
bool moving = false;
//Adelante
if (d3dInput.keyDown(Key.W))
{
move.Z = -speed;
personaje.Rotation = new Vector3(0, 0, 0);
moving = true;
}
//Atras
else if (d3dInput.keyDown(Key.S))
{
move.Z = speed;
personaje.Rotation = new Vector3(0, (float)Math.PI, 0);
moving = true;
}
//Izquierda
else if (d3dInput.keyDown(Key.A))
{
move.X = +speed;
personaje.Rotation = new Vector3(0, -(float)Math.PI / 2, 0);
moving = true;
}
//Derecha
else if (d3dInput.keyDown(Key.D))
{
move.X = -speed;
personaje.Rotation = new Vector3(0, (float)Math.PI / 2, 0);
moving = true;
}
//Si hubo desplazamientos
if (moving)
{
//Mover personaje
Vector3 lastPos = personaje.Position;
personaje.move(move);
//Detectar colisiones de BoundingBox utilizando herramienta TgcCollisionUtils
bool collide = false;
foreach (TgcMesh obstaculo in obstaculos)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(personaje.BoundingBox, obstaculo.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
collide = true;
break;
}
}
//Si hubo colision, restaurar la posicion anterior
if (collide)
{
personaje.Position = lastPos;
}
}
//Renderizar piso
piso.render();
//Renderizar obstaculos
foreach (TgcMesh obstaculo in obstaculos)
{
obstaculo.render();
//Renderizar BoundingBox si asi lo pidieron
if (showBB)
{
obstaculo.BoundingBox.render();
}
}
//Render personaje
personaje.animateAndRender();
//Renderizar BoundingBox si asi lo pidieron
if (showBB)
{
personaje.BoundingBox.render();
}
}
public override void render(float elapsedTime)
{
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//Calcular proxima posicion de personaje segun Input
float moveForward = 0f;
float rotate = 0;
TgcD3dInput d3dInput = GuiController.Instance.D3dInput;
bool moving = false;
bool rotating = false;
//Adelante
if (d3dInput.keyDown(Key.W))
{
moveForward = -VELODICAD_CAMINAR;
moving = true;
}
//Atras
if (d3dInput.keyDown(Key.S))
{
moveForward = VELODICAD_CAMINAR;
moving = true;
}
//Derecha
if (d3dInput.keyDown(Key.D))
{
rotate = VELOCIDAD_ROTACION;
rotating = true;
}
//Izquierda
if (d3dInput.keyDown(Key.A))
{
rotate = -VELOCIDAD_ROTACION;
rotating = true;
}
//Si hubo rotacion
if (rotating)
{
//Rotar personaje y la camara, hay que multiplicarlo por el tiempo transcurrido para no atarse a la velocidad el hardware
float rotAngle = Geometry.DegreeToRadian(rotate * elapsedTime);
personaje.rotateY(rotAngle);
GuiController.Instance.ThirdPersonCamera.rotateY(rotAngle);
}
//Si hubo desplazamiento
if (moving)
{
//Aplicar movimiento hacia adelante o atras segun la orientacion actual del Mesh
Vector3 lastPos = personaje.Position;
personaje.moveOrientedY(moveForward * elapsedTime);
//Detectar colisiones
bool collide = false;
foreach (TgcBox obstaculo in obstaculos)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(personaje.BoundingBox, obstaculo.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
collide = true;
break;
}
}
//Si hubo colision, restaurar la posicion anterior
if (collide)
{
personaje.Position = lastPos;
}
}
//Hacer que la camara siga al personaje en su nueva posicion
GuiController.Instance.ThirdPersonCamera.Target = personaje.Position;
//Render piso
piso.render();
//Render obstaculos
foreach (TgcBox obstaculo in obstaculos)
{
obstaculo.render();
}
//Render personaje
personaje.render();
}
public static Boolean isColliding(BoundingBoxCollider boundingBox, BoundingBoxCollider obstaculo)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(boundingBox.Aabb, obstaculo.Aabb);
return(result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando);
}
public void Movimiento(float tiempoRenderizado, List <TgcMesh> obstaculos)
{
bool rotando = false;
bool seMovio = false;
float mover = 0f;
float rotar = 0f;
TgcD3dInput input = GuiController.Instance.D3dInput;
Vector3 movimiento = new Vector3(0, 0, 0);
//tiempos de renderizado para calcular aceleracion con limite
if (RendAcumuladoS < 10)
{
RendAcumuladoS += tiempoRenderizado; //tiempo que se estuvo yendo hacia atras
}
if (RendAcumuladoW < 10)
{
RendAcumuladoW += tiempoRenderizado; //tiempo que se estuvo yendo hacia adelante
}
if (input.keyDown(Key.Left) || input.keyDown(Key.A))
{
rotando = true;
rotar = -VelocidadRotacion;
}
else if (input.keyDown(Key.Right) || input.keyDown(Key.D))
{
rotando = true;
rotar = VelocidadRotacion;
}
if (input.keyDown(Key.Up) || input.keyDown(Key.W))
{
seMovio = true;
mover = -VelocidadMovimiento - 12 * (float)Math.Pow(RendAcumuladoW, 2);
Modelo.moveOrientedY(mover * tiempoRenderizado);
}
else
{
RendAcumuladoW = 0;
}
if (input.keyDown(Key.Down) || input.keyDown(Key.S))
{
seMovio = true;
mover = VelocidadMovimiento + 12 * (float)Math.Pow(RendAcumuladoS, 2);
Modelo.moveOrientedY(mover * tiempoRenderizado);
}
else
{
RendAcumuladoS = 0;
}
if (input.keyDown(Key.R))
{
seMovio = true;
mover = -VelocidadMovimiento;
Modelo.move(0, mover * tiempoRenderizado, 0);
}
else if (input.keyDown(Key.T))
{
seMovio = true;
mover = VelocidadMovimiento;
Modelo.move(0, mover * tiempoRenderizado, 0);
}
if (seMovio)
{
Vector3 ultimaPosicion = Modelo.Position;
bool colisiono = false;
foreach (TgcMesh obstaculo in obstaculos)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(Modelo.BoundingBox, obstaculo.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
colisiono = true;
break;
}
}
if (colisiono)
{
Modelo.Position = ultimaPosicion;
}
}
if (rotando)
{
Modelo.rotateY(Geometry.DegreeToRadian(rotar * tiempoRenderizado));
GuiController.Instance.ThirdPersonCamera.rotateY(Geometry.DegreeToRadian(rotar * tiempoRenderizado));
;
}
}
public override void Update(float elapsedTime)
{
if (muerto)
{
tiempoDesdeMuerto += elapsedTime;
}
Vector3 vectorPosActual = new Vector3(posicionActual.M41, posicionActual.M42, posicionActual.M43);
//Realizamos ataque de enemigos
if (!attacking && !muerto)
{
vectorDireccion = (CustomFpsCamera.Instance.Position - vectorPosActual);
if (vectorDireccion.Length() <= ATTACK_RANGE && attackDelay <= 0)
{
startAttack();
}
vectorDireccionRotacion = new Vector3(vectorDireccion.X, 0, vectorDireccion.Z);
vectorDireccionRotacion.Normalize();
vectorDireccion.Normalize();
attackDelay -= elapsedTime;
}
//realizamos el movimiento del enemigo
updateMovementMatrix(elapsedTime, vectorDireccion);
//Colision con otros enemigos
foreach (Enemy enemy in GameManager.Instance.enemies)
{
if (this != enemy && TgcCollisionUtils.testAABBAABB(this.mesh.BoundingBox, enemy.mesh.BoundingBox))
{
Vector3 eye = CustomFpsCamera.Instance.Position;
Vector3 vec1 = new Vector3();
vec1.X = this.posicionActual.M41;
vec1.Y = this.posicionActual.M42;
vec1.Z = this.posicionActual.M43;
Vector3 vec2 = new Vector3();
vec2.X = enemy.posicionActual.M41;
vec2.Y = enemy.posicionActual.M42;
vec2.Z = enemy.posicionActual.M43;
if (Vector3.Length(eye - vec1) <= Vector3.Length(eye - vec2))
{
enemy.posicionActual = enemy.posicionAnterior;
enemy.posicionActualHeadshot = enemy.posicionAnteriorHeadshot;
enemy.posicionActualChest = enemy.posicionAnteriorChest;
enemy.posicionActualLegs = enemy.posicionAnteriorLegs;
enemy.updateMovementMatrix(elapsedTime, new Vector3(0, 0, 0));
}
else
{
this.posicionActual = this.posicionAnterior;
this.posicionActualHeadshot = this.posicionAnteriorHeadshot;
this.posicionActualChest = this.posicionAnteriorChest;
this.posicionActualLegs = this.posicionAnteriorLegs;
this.updateMovementMatrix(elapsedTime, new Vector3(0, 0, 0));
}
}
}
//Colision de enemigos con vegetacion, hecho para que no se queden trabados con o sin "ayuda" del player
List <TgcMesh> obstaculos = new List <TgcMesh>();
obstaculos = GameManager.Instance.quadTree.findMeshesToCollide(mesh.BoundingBox);
foreach (TgcMesh obstaculo in obstaculos)
{
if (!obstaculo.Name.StartsWith("ArbustoComplejo"))
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, obstaculo.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
posicionActual = posicionAnterior;
posicionActualHeadshot = posicionAnteriorHeadshot;
posicionActualChest = posicionAnteriorChest;
posicionActualLegs = posicionAnteriorLegs;
vectorDireccionRotacion = vectorDireccionRotacionAnterior;
vectorDireccion = vectorDireccionAnterior;
Vector3 dirX = new Vector3(vectorDireccion.X, 0, 0);
dirX.Normalize();
updateMovementMatrix(elapsedTime, dirX);
TgcCollisionUtils.BoxBoxResult resultX = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, obstaculo.BoundingBox);
if (resultX == TgcCollisionUtils.BoxBoxResult.Adentro || resultX == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
posicionActual = posicionAnterior;
posicionActualHeadshot = posicionAnteriorHeadshot;
posicionActualChest = posicionAnteriorChest;
posicionActualLegs = posicionAnteriorLegs;
Vector3 dirZ = new Vector3(0, 0, vectorDireccion.Z);
dirZ.Normalize();
updateMovementMatrix(elapsedTime, dirZ);
TgcCollisionUtils.BoxBoxResult resultZ = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, obstaculo.BoundingBox);
if (resultZ == TgcCollisionUtils.BoxBoxResult.Adentro || resultZ == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
posicionActual = posicionAnterior;
posicionActualHeadshot = posicionAnteriorHeadshot;
posicionActualChest = posicionAnteriorChest;
posicionActualLegs = posicionAnteriorLegs;
}
}
break;
}
}
}
posicionAnterior = posicionActual;
posicionAnteriorHeadshot = posicionActualHeadshot;
posicionAnteriorChest = posicionActualChest;
posicionAnteriorLegs = posicionActualLegs;
vectorDireccionRotacionAnterior = vectorDireccionRotacion;
vectorDireccionAnterior = vectorDireccion;
this.SonidoMovimiento.Position = getPosicionActual();
//Colision con Player1
TgcCollisionUtils.BoxBoxResult resultPlayer = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, CustomFpsCamera.Instance.boundingBox);
if (resultPlayer == TgcCollisionUtils.BoxBoxResult.Adentro || resultPlayer == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
//si hay colision el enemigo ataca
attack(elapsedTime);
}
}
internal void Update(float elapsedTime)
{
time += elapsedTime;
windShader.SetValue("time", time);
SPAWN_TIME_COUNTER = SPAWN_TIME_COUNTER + elapsedTime;//contamos el tiempo que paso desde el ultimo spawn de enemigos
player1.Update(elapsedTime);
if (SPAWN_TIME_COUNTER > SPAWN_TIME && enemies.Count < MAX_ENEMIES)
{
//si paso un tiempo = SPAWN_TIME agregamos un nuevo enemigo seleccionado al azar
rand = random.Next(1, 4);
if (rand == 1)
{
Enemy enemigo = new Enemy_lvl_1();
enemies.Add(enemigo);
enemigo.Init();
}
if (rand == 2)
{
Enemy enemigo = new Enemy_lvl_2();
enemies.Add(enemigo);
enemigo.Init();
}
if (rand == 3)
{
Enemy enemigo = new Enemy_lvl_3();
enemies.Add(enemigo);
enemigo.Init();
}
SPAWN_TIME_COUNTER = 0;
}
//update de los enemigos
enemies.ForEach(enemy => updateYEliminarMuertos(elapsedTime, enemy));
proyectiles.ForEach(proyectil => proyectil.Update(elapsedTime));
if (KILL_DELAY > 0)
{
KILL_DELAY -= elapsedTime;
}
if (KILL_DELAY <= 0 && killMultiTracker >= 0)
{
if (killMultiTracker >= 2)
{
HUDManager.Instance.denied();
}
killMultiTracker = 0;
}
if (GuiController.Instance.D3dInput.keyPressed(Microsoft.DirectX.DirectInput.Key.N))
{
if (PostProcessManager.Instance.renderFlux == "RenderAll")
{
PostProcessManager.Instance.renderFlux = "NightVision";
}
else
{
PostProcessManager.Instance.renderFlux = "RenderAll";
}
}
if (GuiController.Instance.D3dInput.keyPressed(Microsoft.DirectX.DirectInput.Key.Q))
{
if (player1.weapon.Equals(player1.sniper))
{
player1.weapon = player1.launcher;
}
else
{
player1.weapon = player1.sniper;
}
player1.weapon.muzzle.scale = player1.weapon.scaleMuzzle;
}
if (GuiController.Instance.D3dInput.keyPressed(Microsoft.DirectX.DirectInput.Key.F6))
{
if (drawBoundingBoxes)
{
drawBoundingBoxes = false;
}
else
{
drawBoundingBoxes = true;
}
}
if (GuiController.Instance.D3dInput.keyPressed(Microsoft.DirectX.DirectInput.Key.F7))
{
if (invincibility)
{
invincibility = false;
}
else
{
invincibility = true;
}
}
if (GuiController.Instance.D3dInput.keyPressed(Microsoft.DirectX.DirectInput.Key.P))
{
CustomFpsCamera.Instance.JumpSpeed += 100;
}
if (GuiController.Instance.D3dInput.keyPressed(Microsoft.DirectX.DirectInput.Key.O))
{
CustomFpsCamera.Instance.JumpSpeed -= 100;
}
//hacemos que el skybox siga al player para no tener problemas con el farplane
Matrix translate = Matrix.Translation(CustomFpsCamera.Instance.Position);
skyBox.transform(translate);
foreach (Barril barril in barriles)
{
barril.Update(elapsedTime);
}
if (positiveMove0)
{
tLeftMoved0 += 0.02f;
tRightMoved0 += 0.02f;
if (tLeftMoved0 >= maxMoved)
{
positiveMove0 = false;
}
}
else
{
tLeftMoved0 -= 0.02f;
tRightMoved0 -= 0.02f;
if (tLeftMoved0 <= minMoved)
{
positiveMove0 = true;
}
}
if (positiveMove1)
{
tLeftMoved1 += 0.015f;
tRightMoved1 += 0.015f;
if (tLeftMoved1 >= maxMoved)
{
positiveMove1 = false;
}
}
else
{
tLeftMoved1 -= 0.015f;
tRightMoved1 -= 0.015f;
if (tLeftMoved1 <= minMoved)
{
positiveMove1 = true;
}
}
if (positiveMove2)
{
tLeftMoved2 += 0.01f;
tRightMoved2 += 0.01f;
if (tLeftMoved2 >= maxMoved)
{
positiveMove2 = false;
}
}
else
{
tLeftMoved2 -= 0.01f;
tRightMoved2 -= 0.01f;
if (tLeftMoved2 <= minMoved)
{
positiveMove2 = true;
}
}
bool capture = false;
int v, captured = 0;
for (v = 1; v < tesoros.Count; v++)
{
TgcCollisionUtils.BoxBoxResult result = TgcCollisionUtils.classifyBoxBox(CustomFpsCamera.Instance.boundingBox, tesoros[v].BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
capturas++;
captured = v;
capture = true;
HUDManager.Instance.refreshCapture();
}
}
if (capture)
{
tesoros[captured].dispose();
tesoros.RemoveAt(captured);
pointers[captured].dispose();
pointers.RemoveAt(captured);
}
if (capturas == 11)
{
WINNER = true;
}
if (WINNER)
{
gameWinner();
}
}
