public void move(TGCVector3 movement)
{
// deshago el movimiento del manager
boundingSphere.moveCenter(-movement);
// limite de velocidad
if (movement.X > WALK_SPEED * MULT_CORRER)
{
movement.X = WALK_SPEED * 1.5f;
}
if (movement.Z > WALK_SPEED * MULT_CORRER)
{
movement.Z = WALK_SPEED * 1.5f;
}
if (movement.X < WALK_SPEED * MULT_CORRER * -1)
{
movement.X = WALK_SPEED * 1.5f * -1;
}
if (movement.Z < WALK_SPEED * MULT_CORRER * -1)
{
movement.Z = WALK_SPEED * 1.5f * -1;
}
mesh.Move(movement);
pies.moveCenter(movement);
boundingSphere.moveCenter(movement);
vel = movement;
}
/// <summary>
/// Se llama una sola vez, al principio cuando se ejecuta el ejemplo.
/// Escribir aquí todo el código de inicialización: cargar modelos, texturas, estructuras de optimización, todo
/// procesamiento que podemos pre calcular para nuestro juego.
/// Borrar el codigo ejemplo no utilizado.
/// </summary>
public override void Init()
{
anchoRuta = maximoXRuta - minimoXRuta;
var loader = new TgcSceneLoader();
var pathMesh = MediaDir + "Bloque1\\SkeletalAnimations\\Robot\\Robot-TgcSkeletalMesh.xml";
var mediaPath = MediaDir + "Bloque1\\SkeletalAnimations\\Robot\\";;
string[] animationsPath = { mediaPath + "Correr" + "-TgcSkeletalAnim.xml",
mediaPath + "Parado" + "-TgcSkeletalAnim.xml" };
//cargo y acomodo personaje
//personaje = loader.loadSceneFromFile(MediaDir + "Bloque1\\personaje-TgcScene.xml").Meshes[0];
//Cargar mesh y animaciones
var loaderSkeleton = new TgcSkeletalLoader();
personaje = loaderSkeleton.loadMeshAndAnimationsFromFile(pathMesh, mediaPath, animationsPath);
//Crear esqueleto a modo Debug
personaje.buildSkletonMesh();
//Elegir animacion Caminando
personaje.playAnimation("Parado", true);
personaje.AutoTransform = true;
personaje.Move(65f, 15f, -100f);
personaje.Scale = new TGCVector3(0.75f, 0.75f, 0.75f);
personaje.RotateY(FastMath.ToRad(179f));
//cargo las escenas
var escena1 = loader.loadSceneFromFile(MediaDir + "Bloque1\\escenario1-TgcScene.xml");
var escena2 = loader.loadSceneFromFile(MediaDir + "Bloque1\\escenario2-TgcScene.xml");
var escena3 = loader.loadSceneFromFile(MediaDir + "Bloque1\\escenario3-TgcScene.xml");
var escena4 = loader.loadSceneFromFile(MediaDir + "Bloque1\\escenario4-TgcScene.xml");
var escena5 = loader.loadSceneFromFile(MediaDir + "Bloque1\\escenario5-TgcScene.xml");
escenas.Add(escena1);
escenas.Add(escena2);
escenas.Add(escena3);
escenas.Add(escena4);
escenas.Add(escena5);
calcularPrimeraDisposicionAleatoriaDeEscenarios();
//cargo los obstaculos
var obstaculo1 = loader.loadSceneFromFile(MediaDir + "Bloque1\\obstaculos\\sarcofago-TgcScene.xml").Meshes[0];
var obstaculo2 = loader.loadSceneFromFile(MediaDir + "Bloque1\\obstaculos\\patrullero-TgcScene.xml").Meshes[0];
var obstaculo3 = loader.loadSceneFromFile(MediaDir + "Bloque1\\obstaculos\\estatua-TgcScene.xml").Meshes[0];
var obstaculo4 = loader.loadSceneFromFile(MediaDir + "Bloque1\\obstaculos\\autoDeslizador-TgcScene.xml").Meshes[0];
var obstaculo5 = loader.loadSceneFromFile(MediaDir + "Bloque1\\obstaculos\\pared-TgcScene.xml").Meshes[0];
obstaculos.Add(obstaculo1);
obstaculos.Add(obstaculo2);
obstaculos.Add(obstaculo3);
obstaculos.Add(obstaculo4);
obstaculos.Add(obstaculo5);
posiblesPosicionesObstaculosEnX.Add(anchoRuta / 3 + minimoXRuta); //bien
posiblesPosicionesObstaculosEnX.Add(anchoRuta / 3 + minimoXRuta + anchoRuta / 6 + anchoRuta / 5); //bien
posiblesPosicionesObstaculosEnX.Add(anchoRuta / 4 + maximoXRuta - anchoRuta / 6); //bien
calcularPosicionObstaculos();
camaraInterna = new camaraTerceraPersona(personaje.Position, 130, -500);
Camara = camaraInterna;
//Crear SkyBox
skyBox = new TgcSkyBox();
skyBox.Center = TGCVector3.Empty;
skyBox.Size = new TGCVector3(10000, 10000, 10000);
var texturesPath = MediaDir + "Bloque1\\SkyBox2\\";
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Up, texturesPath + "lun4_up.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Down, texturesPath + "lun4_dn.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Left, texturesPath + "lun4_lf.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Right, texturesPath + "lun4_rt.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Front, texturesPath + "lun4_bk.jpg");
skyBox.setFaceTexture(TgcSkyBox.SkyFaces.Back, texturesPath + "lun4_ft.jpg");
skyBox.Init();
}
public override void Update()
{
PreUpdate();
var movement = TGCVector3.Empty;
//Capturar Input teclado
if (Input.keyPressed(Key.F))
{
BoundingBox = !BoundingBox;
}
if (Input.keyDown(Key.D))
{
movement.X = 1;
}
else if (Input.keyDown(Key.A))
{
movement.X = -1;
}
if (Input.keyDown(Key.W))
{
movement.Z = 1;
personaje.playAnimation("Correr", true);
}
else if (Input.keyDown(Key.S))
{
movement.Z = -1;
personaje.playAnimation("Correr", true);
}
if (Input.keyUp(Key.W) || Input.keyUp(Key.S))
{
personaje.playAnimation("Parado", true);
}
//Guardar posicion original en X antes de cambiarla
var originalPosX = personaje.Position.X;
var originalPosZ = personaje.Position.Z;
movement *= velocidadDesplazamientoPersonaje * ElapsedTime;
personaje.Move(movement);
huboColision = false;
//chequeo si hay colision entre bounding boxes
for (int i = 0; i < obstaculos.Count(); i++)
{
var resultadoColision = TgcCollisionUtils.classifyBoxBox(personaje.BoundingBox, obstaculos[i].BoundingBox);
if (resultadoColision != TgcCollisionUtils.BoxBoxResult.Afuera)
{
huboColision = true;
break;
}
}
//chequeo si hubo colision y si supera el ancho de la ruta
if (huboColision)
{
personaje.Position = new TGCVector3(originalPosX, personaje.Position.Y, originalPosZ);
}
if ((personaje.Position.X < minimoXRutaPersonaje || personaje.Position.X > maximoXRutaPersonaje))
{
personaje.Position = new TGCVector3(originalPosX, personaje.Position.Y, personaje.Position.Z);
}
camaraInterna.Target = personaje.Position;
PostUpdate();
}
public override void Update()
{
PreUpdate();
//obtener velocidades de Modifiers
var velocidadCaminar = velocidadCaminarModifier.Value;
var velocidadRotacion = velocidadRotacionModifier.Value;
//Calcular proxima posicion de personaje segun Input
var moveForward = 0f;
float rotate = 0;
var moving = false;
var rotating = false;
float jump = 0;
//Adelante
if (Input.keyDown(Key.W))
{
moveForward = -velocidadCaminar;
moving = true;
}
//Atras
if (Input.keyDown(Key.S))
{
moveForward = velocidadCaminar;
moving = true;
}
//Derecha
if (Input.keyDown(Key.D))
{
rotate = velocidadRotacion;
rotating = true;
}
//Izquierda
if (Input.keyDown(Key.A))
{
rotate = -velocidadRotacion;
rotating = true;
}
//Jump
if (Input.keyUp(Key.Space) && jumping < 30)
{
jumping = 30;
}
if (Input.keyUp(Key.Space) || jumping > 0)
{
jumping -= 30 * ElapsedTime;
jump = jumping;
moving = 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);
}
//Si no se esta moviendo, activar animacion de Parado
else
{
personaje.playAnimation("Parado", true);
}
//Vector de movimiento
var movementVector = TGCVector3.Empty;
if (moving)
{
//Aplicar movimiento, desplazarse en base a la rotacion actual del personaje
movementVector = new TGCVector3(FastMath.Sin(personaje.Rotation.Y) * moveForward, jump,
FastMath.Cos(personaje.Rotation.Y) * moveForward);
}
//Actualizar valores de gravedad
collisionManager.GravityEnabled = habilitarGravedadModifier.Value;
collisionManager.GravityForce = gravedadModifier.Value;
collisionManager.SlideFactor = slideFactorModifier.Value;
//Mover personaje con detección de colisiones, sliding y gravedad
var realMovement = collisionManager.moveCharacter(characterSphere, movementVector, objetosColisionables);
personaje.Move(realMovement);
//Hacer que la camara siga al personaje en su nueva posicion
camaraInterna.Target = personaje.Position;
//Actualizar valores de la linea de movimiento
directionArrow.PStart = characterSphere.Center;
directionArrow.PEnd = characterSphere.Center + TGCVector3.Multiply(movementVector, 50);
directionArrow.updateValues();
//Cargar desplazamiento realizar en UserVar
UserVars.setValue("Movement", TGCVector3.PrintVector3(realMovement));
//Ver cual de las mallas se interponen en la visión de la cámara en 3ra persona.
objectsBehind.Clear();
objectsInFront.Clear();
foreach (var mesh in escenario.Meshes)
{
TGCVector3 q;
if (TgcCollisionUtils.intersectSegmentAABB(Camara.Position, camaraInterna.Target,
mesh.BoundingBox, out q))
{
objectsBehind.Add(mesh);
}
else
{
objectsInFront.Add(mesh);
}
}
PostUpdate();
}
public override void Update()
{
PreUpdate();
var velocidadCaminar = 25f * ElapsedTime;
//Calcular proxima posicion de personaje segun Input
var moving = false;
var movement = TGCVector3.Empty;
//Adelante
if (Input.keyDown(Key.W))
{
movement.Z = velocidadCaminar;
moving = true;
}
//Atras
if (Input.keyDown(Key.S))
{
movement.Z = -velocidadCaminar;
moving = true;
}
//Derecha
if (Input.keyDown(Key.D))
{
movement.X = velocidadCaminar;
moving = true;
}
//Izquierda
if (Input.keyDown(Key.A))
{
movement.X = -velocidadCaminar;
moving = true;
}
//Si hubo desplazamiento
if (moving)
{
//Aplicar movimiento
colliderCylinder.move(movement);
colliderCylinderFixedY.move(movement);
personaje.Move(movement);
//Activar animacion de caminando
personaje.playAnimation("Caminando", true);
}
else
{
//Si no se esta moviendo, activar animacion de Parado
personaje.playAnimation("Parado", true);
}
var size = sizeModifier.Value;
var rotation = rotationModifier.Value;
//Se tienen dos coliders, un cilindro con rotacion y otro orientado al eje Y.
colliderCylinder.Rotation = rotation;
colliderCylinder.Radius = size.X;
colliderCylinder.Length = size.Y;
//Actualizar este cilindro es mas costoso.
colliderCylinder.updateValues();
//Cilindro sin rotacion, para ser utilizado con personajes.
colliderCylinderFixedY.Radius = size.X;
colliderCylinderFixedY.Length = size.Y;
//Un cilindro orientado es facil de actualizar.
colliderCylinderFixedY.updateValues();
if (fixedYModifier.Value)
{
//Test de colisiones del cilindro orientado en Y, al ser mucho mas simple tiene mas test soportados por el framework.
if (TgcCollisionUtils.testSphereCylinder(collisionableSphere, colliderCylinderFixedY))
{
collisionableSphere.setRenderColor(collisionColor);
}
else
{
collisionableSphere.setRenderColor(noCollisionColor);
}
if (TgcCollisionUtils.testAABBCylinder(collisionableMeshAABB.BoundingBox, colliderCylinderFixedY))
{
collisionableMeshAABB.BoundingBox.setRenderColor(collisionColor);
}
else
{
collisionableMeshAABB.BoundingBox.setRenderColor(noCollisionColor);
}
if (TgcCollisionUtils.testCylinderCylinder(collisionableCylinder, colliderCylinderFixedY))
{
collisionableCylinder.setRenderColor(collisionColor);
}
else
{
collisionableCylinder.setRenderColor(noCollisionColor);
}
if (pickingTimeLeft > 0)
{
pickingTimeLeft -= ElapsedTime;
}
else
{
colliderCylinderFixedY.setRenderColor(noCollisionColor);
}
if (Input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
var pickingRay = new TgcPickingRay(Input);
pickingRay.updateRay();
if (TgcCollisionUtils.testRayCylinder(pickingRay.Ray, colliderCylinderFixedY))
{
pickingTimeLeft = PICKING_TIME;
colliderCylinderFixedY.setRenderColor(pickingColor);
}
}
}
else
{
//Test de colisiones del cilindro, la cantidad de test que tiene el framewor es acotada.
if (TgcCollisionUtils.testSphereCylinder(collisionableSphere, colliderCylinder))
{
collisionableSphere.setRenderColor(collisionColor);
}
else
{
collisionableSphere.setRenderColor(noCollisionColor);
}
if (pickingTimeLeft > 0)
{
pickingTimeLeft -= ElapsedTime;
}
else
{
colliderCylinder.setRenderColor(noCollisionColor);
}
if (Input.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
var pickingRay = new TgcPickingRay(Input);
pickingRay.updateRay();
if (TgcCollisionUtils.testRayCylinder(pickingRay.Ray, colliderCylinder))
{
pickingTimeLeft = PICKING_TIME;
colliderCylinder.setRenderColor(pickingColor);
}
}
}
//Hacer que la camara siga al personaje en su nueva posicion
camaraInterna.Target = personaje.Position;
PostUpdate();
}
public override void Update()
{
PreUpdate();
//obtener velocidades de Modifiers
var velocidadCaminar = velocidadCaminarModifier.Value;
var velocidadRotacion = velocidadRotacionModifier.Value;
var velocidadSalto = velocidadSaltoModifier.Value;
var tiempoSalto = tiempoSaltoModifier.Value;
//Calcular proxima posicion de personaje segun Input
var moveForward = 0f;
float rotate = 0;
var moving = false;
var rotating = false;
float jump = 0;
//Adelante
if (Input.keyDown(Key.W))
{
moveForward = -velocidadCaminar;
moving = true;
}
//Atras
if (Input.keyDown(Key.S))
{
moveForward = velocidadCaminar;
moving = true;
}
//Derecha
if (Input.keyDown(Key.D))
{
rotate = velocidadRotacion;
rotating = true;
}
//Izquierda
if (Input.keyDown(Key.A))
{
rotate = -velocidadRotacion;
rotating = true;
}
//Jump
if (!jumping && Input.keyPressed(Key.Space))
{
//Se puede saltar solo si hubo colision antes
if (collisionManager.Result.collisionFound)
{
jumping = true;
jumpingElapsedTime = 0f;
jump = 0;
}
}
//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);
}
//Saltando
if (jumping)
{
//Activar animacion de saltando
personaje.playAnimation("Jump", true);
}
//Si hubo desplazamiento
else if (moving)
{
//Activar animacion de caminando
personaje.playAnimation("Walk", true);
}
//Si no se esta moviendo ni saltando, activar animacion de Parado
else
{
personaje.playAnimation("StandBy", true);
}
//Actualizar salto
if (jumping)
{
//El salto dura un tiempo hasta llegar a su fin
jumpingElapsedTime += ElapsedTime;
if (jumpingElapsedTime > tiempoSalto)
{
jumping = false;
}
else
{
jump = velocidadSalto * (tiempoSalto - jumpingElapsedTime);
}
}
//Vector de movimiento
var movementVector = TGCVector3.Empty;
if (moving || jumping)
{
//Aplicar movimiento, desplazarse en base a la rotacion actual del personaje
movementVector = new TGCVector3(FastMath.Sin(personaje.Rotation.Y) * moveForward, jump, FastMath.Cos(personaje.Rotation.Y) * moveForward);
}
//Actualizar valores de gravedad
collisionManager.GravityEnabled = habilitarGravedadModifier.Value;
collisionManager.GravityForce = gravedadModifier.Value /** elapsedTime*/;
collisionManager.SlideFactor = slideFactorModifier.Value;
collisionManager.OnGroundMinDotValue = pendienteModifier.Value;
//Si esta saltando, desactivar gravedad
if (jumping)
{
collisionManager.GravityEnabled = false;
}
//Mover personaje con detección de colisiones, sliding y gravedad
if (collisionsModifier.Value)
{
//Aca se aplica toda la lógica de detección de colisiones del CollisionManager. Intenta mover el Elipsoide
//del personaje a la posición deseada. Retorna la verdadera posicion (realMovement) a la que se pudo mover
var realMovement = collisionManager.moveCharacter(characterElipsoid, movementVector, objetosColisionables);
personaje.Move(realMovement);
//Cargar desplazamiento realizar en UserVar
UserVars.setValue("Movement", TGCVector3.PrintVector3(realMovement));
}
else
{
personaje.Move(movementVector);
}
/*
* //Si estaba saltando y hubo colision de una superficie que mira hacia abajo, desactivar salto
* if (jumping && collisionManager.Result.collisionNormal.Y < 0)
* {
* jumping = false;
* }
*/
//Hacer que la camara siga al personaje en su nueva posicion
camaraInterna.Target = personaje.Position;
//Actualizar valores de la linea de movimiento
directionArrow.PStart = characterElipsoid.Center;
directionArrow.PEnd = characterElipsoid.Center + TGCVector3.Multiply(movementVector, 50);
directionArrow.updateValues();
//Actualizar valores de normal de colision
if (collisionManager.Result.collisionFound)
{
collisionNormalArrow.PStart = collisionManager.Result.collisionPoint;
collisionNormalArrow.PEnd = collisionManager.Result.collisionPoint + TGCVector3.Multiply(collisionManager.Result.collisionNormal, 80);
collisionNormalArrow.updateValues();
collisionPoint.Position = collisionManager.Result.collisionPoint;
collisionPoint.updateValues();
}
PostUpdate();
}
/////////////////////////////////////////////////////////////////////////
////////////////////////////////UPDATE///////////////////////////////////
/////////////////////////////////////////////////////////////////////////
public void update(float deltaTime, TgcD3dInput input, TgcCamera camara)
{
reproducirMusica(input);
velocidadCaminar = 350 * deltaTime;
if (floorCollider != null)
{
lastColliderPos = floorCollider.Position;
}
if (Math.Abs(tiempoOlas) > 5)
{
cambiarSigno();
}
if (signo < 0)
{
tiempoOlas -= deltaTime;
}
if (signo > 0)
{
tiempoOlas += deltaTime;
}
animarLibrosF1(deltaTime);
animarPlataformas(deltaTime);
animarBolasDeCanionYEmisoresDeParticulas(deltaTime);
ChocarConBolasDeCanion();
var moveForward = 0f;
float rotate = 0;
moving = false;
moveForward = MovimientoAbajo(input) - MovimientoArriba(input);
rotate = RotacionDerecha(input) - RotacionIzquierda(input);
if (floorCollider != null && plataformasMovibles.Contains(floorCollider) && floorCollider.BoundingBox.PMax.Y < personajePrincipal.BoundingBox.PMin.Y)
{
TGCVector3 res = floorCollider.Position;
res.Subtract(lastColliderPos);
personajePrincipal.Position = personajePrincipal.Position + res;
}
Salto(input);
AplicarGravedad(deltaTime);
if (rotating)
{
rotAngle = Geometry.DegreeToRadian(rotate * deltaTime);
personajePrincipal.RotateY(rotAngle);
camaraInterna.rotateY(rotAngle);
}
var Movimiento = TGCVector3.Empty;
//Si hubo desplazamiento
float scale = 1;
if (!enElPiso)
{
scale = 0.7f;
}
if (moving)
{
personajePrincipal.playAnimation("Caminando", true);
var lastPos = personajePrincipal.Position;
var pminPersonaje = personajePrincipal.BoundingBox.PMin.Y;
var pmaxPersonaje = personajePrincipal.BoundingBox.PMax.Y;
Movimiento = new TGCVector3(FastMath.Sin(personajePrincipal.Rotation.Y) * moveForward, 0, FastMath.Cos(personajePrincipal.Rotation.Y) * moveForward);
Movimiento.Scale(scale * sliderModifier);
Movimiento.Y = jump * deltaTime;
personajePrincipal.Move(Movimiento);
DetectarColisiones(lastPos, pminPersonaje, pmaxPersonaje, deltaTime);
}
else
{
personajePrincipal.playAnimation("Parado", true);
}
//Hacer que la camara siga al personaje en su nueva posicion
camaraInterna.Target = personajePrincipal.Position;
ajustarPosicionDeCamara();
var Rot = TGCMatrix.RotationY(personajePrincipal.Rotation.Y);
var T = TGCMatrix.Translation(personajePrincipal.Position);
escalaBase = Rot * T;
personajePrincipal.Transform = escalaBase;
}
public void MoveXZ(TGCVector3 movimiento, TgcBoundingAxisAlignBox lastCollider = null)
{
PosBeforeMovingInXZ = Mesh.Position;
Mesh.Position += movimiento;
var Collider = Env.Escenario.ColisionXZ(Mesh.BoundingBox);
if (movimiento == TGCVector3.Empty)
{
return;
}
if (Collider == null && TipoColisionActual == TiposColision.Pozo)
{
Pozo();
}
//El personaje se movera con la plataforma
else if (Collider == null && TipoColisionActual == TiposColision.Caja)
{
Mesh.Move(posicionPlataforma);
}
else if (Collider != null)
{
Collider = Collider.clone();
Collider.scaleTranslate(TGCVector3.Empty, new TGCVector3(1.05f, 1.05f, 1.05f));
var movementRay = PosBeforeMovingInXZ - Mesh.Position;
var rs = TGCVector3.Empty;
if (((Mesh.BoundingBox.PMax.X > Collider.PMax.X && movementRay.X > 0) ||
(Mesh.BoundingBox.PMin.X < Collider.PMin.X && movementRay.X < 0)) &&
((Mesh.BoundingBox.PMax.Z > Collider.PMax.Z && movementRay.Z > 0) ||
(Mesh.BoundingBox.PMin.Z < Collider.PMin.Z && movementRay.Z < 0)))
{
//Este primero es un caso particularse dan las dos condiciones simultaneamente entonces para saber de que lado moverse hay que hacer algunos calculos mas.
//por el momento solo se esta verificando que la posicion actual este dentro de un bounding para moverlo en ese plano.
if (Mesh.Position.X > Collider.PMin.X && Mesh.Position.X < Collider.PMax.X)
{
//El personaje esta contenido en el bounding X
//Sliding Z Dentro de X
rs = new TGCVector3(movementRay.X, movementRay.Y, 0);
}
if (Mesh.Position.Z > Collider.PMin.Z && Mesh.Position.Z < Collider.PMax.Z)
{
//El personaje esta contenido en el bounding Z
//Sliding X Dentro de Z
rs = new TGCVector3(0, movementRay.Y, movementRay.Z);
}
//Seria ideal sacar el punto mas proximo al bounding que colisiona y chequear con eso, en ves que con la posicion.
}
else
{
if ((Mesh.BoundingBox.PMax.X > Collider.PMax.X && movementRay.X > 0) ||
(Mesh.BoundingBox.PMin.X < Collider.PMin.X && movementRay.X < 0))
{
//Sliding X
rs = new TGCVector3(0, movementRay.Y, movementRay.Z);
}
if ((Mesh.BoundingBox.PMax.Z > Collider.PMax.Z && movementRay.Z > 0) ||
(Mesh.BoundingBox.PMin.Z < Collider.PMin.Z && movementRay.Z < 0))
{
//Sliding Z
rs = new TGCVector3(movementRay.X, movementRay.Y, 0);
}
}
Mesh.Position = PosBeforeMovingInXZ;
MoveXZ(rs * -0.9f, Collider);
}
}
/// /////////////////////////////////////////////////////////////////////
/// ////////////////////////////UPDATE///////////////////////////////////
/// /////////////////////////////////////////////////////////////////////
public void update(float deltaTime, TgcD3dInput input, TgcCamera camara)
{
//velocidadCaminar = 1000 * deltaTime;
velocidadCaminar = 5;
if (floorCollider != null)
{
lastColliderPos = floorCollider.Position;
}
var moveForward = 0f;
float rotate = 0;
moving = false;
if (activarTeleport)
{
velocidadCaminar = 0;
tiempoTeleport += deltaTime;
if (Math.Sin(tiempoTeleport) > 0.999)
{
if (puertaCruzada == 1)
{
personajePrincipal.Position = puerta1;
}
if (puertaCruzada == 2)
{
personajePrincipal.Position = puerta2;
}
if (puertaCruzada == 3)
{
personajePrincipal.Position = puerta3;
}
}
if (Math.Sin(tiempoTeleport) < 0)
{
tiempoTeleport = 0;
desactivarTeleport = true;
activarTeleport = false;
}
}
if (Math.Abs(tiempoOlas) > 5)
{
cambiarSigno();
}
if (signo < 0)
{
tiempoOlas -= deltaTime;
}
if (signo > 0)
{
tiempoOlas += deltaTime;
}
MoverColeccionables(deltaTime);
moveForward = MovimientoAbajo(input) - MovimientoArriba(input);
rotate = RotacionDerecha(input) - RotacionIzquierda(input);
Salto(input, deltaTime);
AplicarGravedad(deltaTime);
if (rotating)
{
rotAngle = Geometry.DegreeToRadian(rotate * deltaTime);
personajePrincipal.RotateY(rotAngle);
camaraInterna.rotateY(rotAngle);
}
var Movimiento = TGCVector3.Empty;
float scale = 1;
if (!enElPiso)
{
scale = 0.4f;
}
if (moving)
{
personajePrincipal.playAnimation("Caminando", true);
var lastPos = personajePrincipal.Position;
var pminPersonaje = personajePrincipal.BoundingBox.PMin.Y;
var pmaxPersonaje = personajePrincipal.BoundingBox.PMax.Y;
Movimiento = new TGCVector3(FastMath.Sin(personajePrincipal.Rotation.Y) * moveForward, 0, FastMath.Cos(personajePrincipal.Rotation.Y) * moveForward);
Movimiento.Scale(scale * sliderModifier);
Movimiento.Y = jump;
personajePrincipal.Move(Movimiento);
DetectarColisiones(lastPos, pminPersonaje, pmaxPersonaje);
}
else
{
personajePrincipal.playAnimation("Parado", true);
}
camaraInterna.Target = personajePrincipal.Position;
ajustarPosicionDeCamara();
var Rot = TGCMatrix.RotationY(personajePrincipal.Rotation.Y);
var T = TGCMatrix.Translation(personajePrincipal.Position);
escalaBase = Rot * T;
personajePrincipal.Transform = escalaBase;
}
