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);
}
}
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 Update()
{
//Obtenemos acceso al objeto que maneja input de mouse y teclado del framework
var input = Input;
//Declaramos un vector de movimiento inicializado en cero.
//El movimiento sobre el suelo es sobre el plano XZ.
//Sobre XZ nos movemos con las flechas del teclado o con las letas WASD.
var movement = TGCVector3.Empty;
//Movernos de izquierda a derecha, sobre el eje X.
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;
}
//Movernos adelante y atras, sobre el eje Z.
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
var originalPos = mainMesh.Position;
//Multiplicar movimiento por velocidad y elapsedTime
movement *= MOVEMENT_SPEED * ElapsedTime;
mainMesh.Position = mainMesh.Position + movement;
mainMesh.Transform = TGCMatrix.Translation(mainMesh.Position);
//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.
var collisionFound = false;
foreach (var mesh in scene.Meshes)
{
//Los dos BoundingBox que vamos a testear
var mainMeshBoundingBox = mainMesh.BoundingBox;
var sceneMeshBoundingBox = mesh.BoundingBox;
//Ejecutar algoritmo de detección de colisiones
var 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;
mainMesh.Transform = TGCMatrix.Translation(mainMesh.Position);
}
//Hacer que la camara en 3ra persona se ajuste a la nueva posicion del objeto
camaraInterna.Target = mainMesh.Position;
}
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 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 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 override void Render()
{
PreRender();
var velocidadCaminar = 400f;
var velocidadRotacion = 120f;
//Calcular proxima posicion de personaje segun Input
var moveForward = 0f;
float rotate = 0;
var d3dInput = TgcD3dInput.Instance;
var moving = false;
var 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
var rotAngle = Geometry.DegreeToRadian(rotate * ElapsedTime);
personaje.rotateY(rotAngle);
camaraInterna.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
var 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
var collide = false;
foreach (var obstaculo in obstaculos)
{
var 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
camaraInterna.Target = personaje.Position;
}
//Si no se esta moviendo, activar animacion de Parado
else
{
personaje.playAnimation("Parado", true);
}
//Ajustar la posicion de la camara segun la colision con los objetos del escenario
ajustarPosicionDeCamara(obstaculos);
//Render piso
piso.render();
//Render de obstaculos
foreach (var obstaculo in obstaculos)
{
obstaculo.render();
}
//Render personaje
personaje.animateAndRender(ElapsedTime);
PostRender();
}
public override void Update()
{
//Calcular proxima posicion de personaje segun Input
var moveForward = 0f;
float rotate = 0;
var moving = false;
var rotating = false;
//Adelante
if (Input.keyDown(Key.W))
{
moveForward = -VELODICAD_CAMINAR;
moving = true;
}
//Atras
if (Input.keyDown(Key.S))
{
moveForward = VELODICAD_CAMINAR;
moving = true;
}
//Derecha
if (Input.keyDown(Key.D))
{
rotate = VELOCIDAD_ROTACION;
rotating = true;
}
//Izquierda
if (Input.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
var rotAngle = Geometry.DegreeToRadian(rotate * ElapsedTime);
personaje.Rotation += new TGCVector3(0, rotAngle, 0);
camaraInterna.rotateY(rotAngle);
}
//Si hubo desplazamiento
if (moving)
{
//Aplicar movimiento hacia adelante o atras segun la orientacion actual del Mesh
var lastPos = personaje.Position;
var moveF = moveForward * ElapsedTime;
var z = (float)Math.Cos(personaje.Rotation.Y) * moveF;
var x = (float)Math.Sin(personaje.Rotation.Y) * moveF;
personaje.Position += new TGCVector3(x, 0, z);
//Detectar colisiones
var collide = false;
foreach (var obstaculo in obstaculos)
{
var 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;
}
}
personaje.Transform = TGCMatrix.Scaling(personaje.Scale)
* TGCMatrix.RotationYawPitchRoll(personaje.Rotation.Y, personaje.Rotation.X, personaje.Rotation.Z)
* TGCMatrix.Translation(personaje.Position);
//Hacer que la camara siga al personaje en su nueva posicion
camaraInterna.Target = personaje.Position;
}
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 bool CollidesWith(GameObject foreign)
{
return(Meshes.Any(mesh => foreign.Meshes.Any(foreignMesh => TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, foreignMesh.BoundingBox) != TgcCollisionUtils.BoxBoxResult.Afuera)));
}
private void DetectarColisiones(TGCVector3 lastPos, float pminYAnteriorPersonaje, float pmaxYAnteriorPersonaje)
{
var lastCollide = false;
foreach (var mesh in scene.Meshes)
{
//Los dos BoundingBox que vamos a testear
var mainMeshBoundingBox = personajePrincipal.BoundingBox;
var sceneMeshBoundingBox = mesh.BoundingBox;
if (mainMeshBoundingBox == sceneMeshBoundingBox)
{
continue;
}
//Ejecutar algoritmo de detección de colisiones
var collisionResult = TgcCollisionUtils.classifyBoxBox(mainMeshBoundingBox, sceneMeshBoundingBox);
//Hubo colisión con un objeto. Guardar resultado y abortar loop.
if (collisionResult != TgcCollisionUtils.BoxBoxResult.Afuera && !(fastSliders.Contains(mesh)))
{
if (sceneMeshBoundingBox.PMax.Y <= pminYAnteriorPersonaje + 10)
{
enElPiso = true;
lastPos.Y = sceneMeshBoundingBox.PMax.Y + 3;
floorCollider = mesh;
if (slowSliders.Contains(mesh))
{
sliderModifierType = "slow";
sliderFloorCollider = mesh;
sliderModifier = 1f;
}
}
else if (sceneMeshBoundingBox.PMin.Y > pmaxYAnteriorPersonaje && jump != 0)
{
ceilingCollider = mesh;
techo = true;
}
if (floorCollider != null && sceneMeshBoundingBox == floorCollider.BoundingBox)
{
lastCollide = true;
}
collider = mesh;
var movementRay = lastPos - personajePrincipal.Position;
Slider(lastPos, movementRay);
personajePrincipal.playAnimation("Caminando", true);
Coleccionar(mesh);
CruzarPuertas(mesh);
Caer(mesh);
}
else if (collisionResult != TgcCollisionUtils.BoxBoxResult.Afuera && fastSliders.Contains(mesh))
{
sliderModifierType = "fast";
sliderFloorCollider = mesh;
sliderModifier = 2f;
}
if (lastCollide == false)
{
enElPiso = false;
}
}
}
private void Move(TGCVector3 movement, float ElapsedTime)
{
TGCVector3 lastPos = mesh.Position;
mesh.Position += movement;
colision.stop();
if (estaEnNave)
{
// todo: chequear colisiones con la mesa y silla
//Check for collisions
bool collided = false;
List <TGCBox> meshes = InteriorNave.Instance().obtenerParedes();
foreach (var pared in meshes)
{
var result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, pared.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro ||
result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
collided = true;
break;
}
}
if (!collided)
{
List <TgcMesh> elementosMesa = MesaNave.Instance().meshes();
foreach (var elemento in elementosMesa)
{
//var result = TgcCollisionUtils.testAABBAABB(mesh.BoundingBox, elemento.BoundingBox);
var result = TgcCollisionUtils.testAABBAABB(new TgcBoundingAxisAlignBox(new TGCVector3(mesh.Position.X, elemento.Position.Y, mesh.Position.Z), mesh.Position), elemento.BoundingBox);
if (result)
{
collided = true;
break;
}
}
}
if (!collided)
{
List <TgcMesh> elementosSilla = SillaInterior.Instance().meshes();
foreach (var elemento in elementosSilla)
{
//var result = TgcCollisionUtils.testAABBAABB(mesh.BoundingBox, elemento.BoundingBox);
var result = TgcCollisionUtils.testAABBAABB(new TgcBoundingAxisAlignBox(new TGCVector3(mesh.Position.X, elemento.Position.Y, mesh.Position.Z), mesh.Position), elemento.BoundingBox);
if (result)
{
collided = true;
break;
}
}
}
if (!collided)
{
List <TgcMesh> elementosTimon = TimonInterior.Instance().meshes();
foreach (var elemento in elementosTimon)
{
var result = TgcCollisionUtils.testAABBAABB(mesh.BoundingBox, elemento.BoundingBox);
if (result)
{
collided = true;
break;
}
}
}
//If any collision then go to last position.
if (collided)
{
mesh.Position = lastPos;
colision.play(true);
}
if (mesh.Position != lastPos)
{
walking.play(true);
}
else
{
walking.stop();
}
}
else
{
// todo: manejamos que la colision de la nave haga que el player entre y sacamos lo del press en la "o"?
bool collided = false;
List <TgcMesh> meshes = Nave.Instance().obtenerMeshes();
foreach (var meshNave in meshes)
{
var result = TgcCollisionUtils.testAABBAABB(mesh.BoundingBox, meshNave.BoundingBox);
if (result)
{
collided = true;
break;
}
}
//If any collision then go to last position.
if (collided)
{
mesh.Position = lastPos;
colision.play(true);
return;
}
List <Entity> entities = Entities.GetEntities();
foreach (var entity in entities)
{
var result = TgcCollisionUtils.testAABBAABB(mesh.BoundingBox, entity.GetMesh().BoundingBox);
if (result)
{
collided = true;
break;
}
}
//If any collision then go to last position.
if (collided)
{
mesh.Position = lastPos;
colision.play(true);
return;
}
if (mesh.Position.X > 1000f || mesh.Position.X < -1000f || mesh.Position.Z > 1000f || mesh.Position.Z < -1000f)
{
// limitamos cuanto se puede mover el jugador
mesh.Position = lastPos;
colision.play(true);
}
// colisiones contra elementos del mar
}
}
public override void Render()
{
PreRender();
//Calcular proxima posicion de personaje segun Input
var moveForward = 0f;
float rotate = 0;
var d3dInput = TgcD3dInput.Instance;
var moving = false;
var 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
var rotAngle = Geometry.DegreeToRadian(rotate * ElapsedTime);
personaje.rotateY(rotAngle);
camaraInterna.rotateY(rotAngle);
}
//Si hubo desplazamiento
if (moving)
{
//Aplicar movimiento hacia adelante o atras segun la orientacion actual del Mesh
var lastPos = personaje.Position;
personaje.moveOrientedY(moveForward * ElapsedTime);
//Detectar colisiones
var collide = false;
foreach (var obstaculo in obstaculos)
{
var 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
Camara = new TgcThirdPersonCamera();
camaraInterna.Target = personaje.Position;
//Render piso
piso.render();
//Render obstaculos
foreach (var obstaculo in obstaculos)
{
obstaculo.render();
}
//Render personaje
personaje.render();
PostRender();
}
private void DetectarColisiones(TGCVector3 lastPos, float pminYAnteriorPersonaje, float pmaxYAnteriorPersonaje, float dtime)
{
var lastCollide = false;
detectarSiHayColisionDeCheckpoints(lastPos, pminYAnteriorPersonaje, pmaxYAnteriorPersonaje);
foreach (var mesh in scene.Meshes)
{
//Los dos BoundingBox que vamos a testear
var mainMeshBoundingBox = personajePrincipal.BoundingBox;
var sceneMeshBoundingBox = mesh.BoundingBox;
if (mainMeshBoundingBox == sceneMeshBoundingBox)
{
continue;
}
//Ejecutar algoritmo de detección de colisiones
var collisionResult = TgcCollisionUtils.classifyBoxBox(mainMeshBoundingBox, sceneMeshBoundingBox);
//Hubo colisión con un objeto. Guardar resultado y abortar loop.
if (collisionResult != TgcCollisionUtils.BoxBoxResult.Afuera)
{
if (sceneMeshBoundingBox.PMax.Y <= pminYAnteriorPersonaje + 10)
{
jump = 0;
jumping = 0;
enElPiso = true;
lastPos.Y = sceneMeshBoundingBox.PMax.Y + 3;
floorCollider = mesh;
if (slowSliders.Contains(mesh))
{
sliderFloorCollider = mesh;
sliderModifier = 0.2f;
}
else if (fastSliders.Contains(mesh))
{
sliderFloorCollider = mesh;
sliderModifier = 3;
}
}
else if (sceneMeshBoundingBox.PMin.Y > pmaxYAnteriorPersonaje && jump != 0)
{
ceilingCollider = mesh;
techo = true;
}
if (floorCollider != null && sceneMeshBoundingBox == floorCollider.BoundingBox)
{
lastCollide = true;
}
collider = mesh;
var movementRay = lastPos - personajePrincipal.Position;
Slider(lastPos, movementRay, dtime);
MoverObjetos(mesh, movementRay);
CaerseAlAgua(mesh, movementRay);
verSiSeCompletoNivel(mesh);
AgarrarLibros(mesh);
}
if (lastCollide == false && floorCollider != null)
{
personajePrincipal.Move(0, -3, 0);
if (TgcCollisionUtils.classifyBoxBox(personajePrincipal.BoundingBox, floorCollider.BoundingBox) == TgcCollisionUtils.BoxBoxResult.Afuera)
{
enElPiso = false;
}
personajePrincipal.Move(0, 3, 0);
}
else if (floorCollider == null)
{
enElPiso = false;
}
}
}
//**********************************************************************
// devuelve true: si se produce colision con escenario
// False: si no se produce colision
//**********************************************************************
public bool colisionaObstaculosMesh(TgcBoundingBox bound, TgcBoundingBox o)
{
return(TgcCollisionUtils.classifyBoxBox(o, bound) == TgcCollisionUtils.BoxBoxResult.Atravesando);
}
public void update(float dt, C_Hoja[] hojas, C_Earth the_earth, C_Earth the_earth2, C_Water water, TgcSkyBox skyBox)
{
time += dt;
TgcD3dInput d3dInput = GuiController.Instance.D3dInput;
//gravedad (si no estoy en contacto con algo, caer)
if (glued == null)
{
playMove.Y -= 30f * dt;
}
else
{
playMove.Y = 0;
}
//si estoy en el suelo y BARRA ESPACIADORA => Saltar
if (move_able & d3dInput.keyDown(Key.Space) && (glued != null))
{
playMove.Y = 30f;
sound_b.render();
}
//M => Bolquear movimiento
if (d3dInput.keyDown(Key.M))
{
move_able = !move_able;
}
//calcular movimiento hacia adelante y costado
float moveForward = 0f;
float moveLateral = 0f;
if (move_able & d3dInput.keyDown(Key.W))
{
moveForward = 1f;
}
if (move_able & d3dInput.keyDown(Key.S))
{
moveForward = -1f;
}
if (move_able & d3dInput.keyDown(Key.A))
{
moveLateral = 1f;
}
if (move_able & d3dInput.keyDown(Key.D))
{
moveLateral = -1f;
}
//rotar camara
rotation = 0;
if (d3dInput.keyDown(Key.Q))
{
rotation = 1;
}
if (d3dInput.keyDown(Key.E))
{
rotation = -1;
}
//calcular vectores de movimiento, basado en camara
playMove.X = playMove.Z = 0f;
if (moveLateral != 0 | moveForward != 0)
{
Vector3 camDir = GuiController.Instance.CurrentCamera.getLookAt() - GuiController.Instance.CurrentCamera.getPosition();
camDir.Y = 0;
Vector3 moveDir = Vector3.Normalize(camDir);
playMove.X = moveDir.X * moveForward - moveDir.Z * moveLateral;
playMove.Z = moveDir.Z * moveForward + moveDir.X * moveLateral;
//"normalizar" para tener velocidad maxima
float modXZ = (float)Math.Sqrt(playMove.X * playMove.X + playMove.Z * playMove.Z);
playMove.X = playMove.X * 75f / modXZ;
playMove.Z = playMove.Z * 75f / modXZ;
}
//si esta en contacto con una hoja, moverse con ella
if (glued != null)
{
if (glued.id == 'h')
{
C_Hoja h = (C_Hoja)glued;
playMove += h.vel;
}
}
Vector3 old_pos = pos;
pos += playMove * dt;
mesh.BoundingBox.move(playMove * dt);
bool collide = false;
TgcCollisionUtils.BoxBoxResult result;
//si choca contra una cara del skybox, frenarla
foreach (TgcMesh face in skyBox.Faces)
{
result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, face.BoundingBox);
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
collide = true;
break;
}
}
if (collide)
{
Vector3 dif = old_pos - pos;
dif.Y = 0f;
pos += dif;
mesh.BoundingBox.move(dif);
}
//cuando esta muriendo, si deja de estar en contacto con agua (la termino de atravesar) resetear
if (dieing)
{
result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, water.BoundingBox());
if (result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
sound_c.render();
}
if (result != TgcCollisionUtils.BoxBoxResult.Adentro && result != TgcCollisionUtils.BoxBoxResult.Atravesando)
{
reset(the_earth);
}
return;
}
//chequear si sihue en contacto con el objeto con el que estaba en contacto
if (glued != null)
{
result = TgcCollisionUtils.BoxBoxResult.Afuera;
if (glued.id == 'e')
{
C_Earth e = (C_Earth)glued;
result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, e.BoundingBox());
}
else if (glued.id == 'h')
{
C_Hoja h = (C_Hoja)glued;
result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, h.BoundingBox());
}
else if (glued.id == 'w')
{
C_Water w = (C_Water)glued;
result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, w.BoundingBox());
}
if (result == TgcCollisionUtils.BoxBoxResult.Encerrando || result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
return;
}
glued = null;
}
//colisionar con hojas
foreach (C_Hoja x in hojas)
{
result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, x.BoundingBox());
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
glued = x;
return;
}
}
//colisionar con la tierra
result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, the_earth.BoundingBox());
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
glued = the_earth;
return;
}
//colisionar con la otra tierra
result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, the_earth2.BoundingBox());
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
glued = the_earth2;
return;
}
//colisionar con agua
result = TgcCollisionUtils.classifyBoxBox(mesh.BoundingBox, water.BoundingBox());
if (result == TgcCollisionUtils.BoxBoxResult.Adentro || result == TgcCollisionUtils.BoxBoxResult.Atravesando)
{
dieing = true;
}
return;
}