public void render()
{
GuiController.Instance.Drawer2D.beginDrawSprite();
nombre.render();
sprite.render();
GuiController.Instance.Drawer2D.endDrawSprite();
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Actualizar valores cargados en modifiers
sprite.Position = (Vector2)GuiController.Instance.Modifiers["position"];
sprite.Scaling = (Vector2)GuiController.Instance.Modifiers["scaling"];
sprite.Rotation = FastMath.ToRad((float)GuiController.Instance.Modifiers["rotation"]);
//Dibujar box3D. Se deben dibujar primero todos los objetos 3D. Recien al final dibujar los Sprites
box.render();
//Iniciar dibujado de todos los Sprites de la escena (en este caso es solo uno)
GuiController.Instance.Drawer2D.beginDrawSprite();
//Dibujar sprite (si hubiese mas, deberian ir todos aquí)
sprite.render();
//Finalizar el dibujado de Sprites
GuiController.Instance.Drawer2D.endDrawSprite();
}
public void Render(float elapsedTime)
{
//Iniciar dibujado de todos los Sprites de la escena (en este caso es solo uno)
GuiController.Instance.Drawer2D.beginDrawSprite();
healthSprite.render();
HudFront.render();
scoreSprite.render();
hudWeapon.render();
if (reachedHighScore)
{
highScoreSprite.render();
}
cross.render();
//Finalizar el dibujado de Sprites
GuiController.Instance.Drawer2D.endDrawSprite();
// TODO, cuando el refresh funque
renderMinimap();
scoreText.render();
captureText.render();
if (TEXT_DELAY > 0)
{
int alphaLerp = (int)(TEXT_DELAY * 255 / TEXT_DELAY_MAX);
specialKillText.Color = Color.FromArgb(alphaLerp, specialKillText.Color);
specialKillText.render();
}
}
public void render()
{
GuiController.Instance.Drawer2D.beginDrawSprite();
sangre.render();
texto.render();
GuiController.Instance.Drawer2D.endDrawSprite();
}
public void render()
{
if (!enabled)
{
return;
}
//Dibujar sprite
sprite.render();
}
public void render(EjemploAlumno juego)
{
GuiController.Instance.Drawer2D.beginDrawSprite();
fondo.render();
GuiController.Instance.Drawer2D.endDrawSprite();
sombra.render();
titulo.render();
}
public void RenderUI(Snipers scene)
{
if (Playing)
{
sound.play();
}
GuiController.Instance.D3dDevice.Clear(ClearFlags.Target | ClearFlags.ZBuffer, Color.Black, 1.0f, 0);
GuiController.Instance.Drawer2D.beginDrawSprite();
sprite.render();
GuiController.Instance.Drawer2D.endDrawSprite();
}
public void renderizar()
{
#region RENDERIZAR ESCENARIO
skyBox.render();
lightMesh.render();
#endregion
#region RENDERIZAR PANTALLA
GuiController.Instance.Drawer2D.beginDrawSprite();
camara = (Boolean)GuiController.Instance.Modifiers["camaraEnBarco"];
if (camara)
{
animatedSprite2.Scaling = new Vector2(1.4f, 1.4f);
animatedSprite2.Position = new Vector2(traslacion, 0);
animatedSprite2.setFrameRate(3);
traslacion = traslacion + 12;
}
else
{
animatedSprite2.Scaling = new Vector2(0.4f, 0.4f);
animatedSprite2.Position = new Vector2(traslacion, screenSize.Height / 3);
animatedSprite2.setFrameRate(1);
traslacion = traslacion + 4;
}
if (traslacion > screenSize.Width)
{
animatedSprite2.dispose();
}
else
{
animatedSprite2.updateAndRender();
}
llueve = (Boolean)GuiController.Instance.Modifiers["lluvia"];
if (llueve)
{
animatedSprite.updateAndRender();
}
boton1.render();
boton2.render();
barra.render();
timon.render();
GuiController.Instance.Drawer2D.endDrawSprite();
#endregion
}
public void RenderUI(Snipers scene)
{
GuiController.Instance.Drawer2D.beginDrawSprite();
if (scope)
{
scope_stencil.render();
}
else
{
mira.render();
}
renderHUD();
GuiController.Instance.Drawer2D.endDrawSprite();
}
internal override void Render(float elapsedTime)
{
GuiController.Instance.Drawer2D.beginDrawSprite();
//Dibujar sprite (si hubiese mas, deberian ir todos aquí)
logo.render();
//Finalizar el dibujado de Sprites
GuiController.Instance.Drawer2D.endDrawSprite();
if (!select)
{
foreach (TgcText2d text in texts)
{
text.render();
}
}
}
public static void render(bool colision)
{
// animacion de la moneda que gira en el marcador
GuiController.Instance.Drawer2D.beginDrawSprite();
//AnimatedSprite.updateAndRender();
sprite.render();
GuiController.Instance.Drawer2D.endDrawSprite();
// texto que indica la cantidad de monedas juntadas
if (colision)
{
puntos += 1;
}
SpriteDrawer.BeginDrawSprite();
Puntos2d.Text = puntos.ToString();
Puntos2d.render();
SpriteDrawer.EndDrawSprite();
}
public void render(float cargaLinterna)
{
float elapsedTime = GuiController.Instance.ElapsedTime;
Device d3dDevice = GuiController.Instance.D3dDevice;
//Iniciar dibujado de todos los Sprites de la escena (en este caso es solo uno)
GuiController.Instance.Drawer2D.beginDrawSprite();
//Dibujar sprite (si hubiese mas, deberian ir todos aquí)
sprite.render();
if (cargaLinterna > 0.02)
{
spriteAmarillo.Scaling = new Vector2(0.1f * cargaLinterna, 0.05f);
spriteAmarillo.render();
}
//Finalizar el dibujado de Sprites
GuiController.Instance.Drawer2D.endDrawSprite();
}
public override void render(float elapsedTime)
{
Device d3dDevice = GuiController.Instance.D3dDevice;
//Velocidad de movimiento 2D
tgcKinect.Hands2dSpeed = new Vector2((float)GuiController.Instance.Modifiers["speedX"], (float)GuiController.Instance.Modifiers["speedY"]);
//Actualizar estado de kinect
TgcKinectSkeletonData data = tgcKinect.update();
if (data.Active)
{
//Render de esqueleto debug
tgcKinect.DebugSkeleton.render(data.Current.KinectSkeleton);
//Debug de pos de manos
bool showValues = (bool)GuiController.Instance.Modifiers["showValues"];
if (showValues)
{
BigLogger.log("RightHandPos", data.Current.RightHandPos);
BigLogger.log("LefttHandPos", data.Current.LefttHandPos);
BigLogger.renderLog();
}
//Dibujar cursores
rightHandPointer.Position = data.Current.RightHandPos;
leftHandPointer.Position = data.Current.LefttHandPos;
GuiController.Instance.Drawer2D.beginDrawSprite();
rightHandPointer.render();
leftHandPointer.render();
GuiController.Instance.Drawer2D.endDrawSprite();
}
//Dibujar limites de escena
center.render();
bounds.render();
}
public void renderMinimap()
{
updatePlayerPointer();
GuiController.Instance.Drawer2D.beginDrawSprite();
mapBaseSprite.render();
playerPointerSprite.render();
GuiController.Instance.Drawer2D.endDrawSprite();
foreach (Enemy enemigo in GameManager.Instance.enemies)
{
Vector3 distance = Vector3.Subtract(enemigo.getPosicionActual(), CustomFpsCamera.Instance.getPosition());// - enemigo.getPosicionActual();
Vector2 dist = new Vector2(distance.X, distance.Z);
if (Vector2.Length(dist) <= 2500 && !enemigo.muerto)
{
enemigo.updatePointer(mapCenter, dist);
GuiController.Instance.Drawer2D.beginDrawSprite();
enemigo.pointer.render();
GuiController.Instance.Drawer2D.endDrawSprite();
}
}
int t;
for (t = 1; t < GameManager.Instance.tesoros.Count; t++)
{
Vector3 distance = Vector3.Subtract(GameManager.Instance.tesoros[t].Position, CustomFpsCamera.Instance.getPosition());
Vector2 dist = new Vector2(distance.X, distance.Z);
if (Vector2.Length(dist) <= 2500)
{
GameManager.Instance.updatePointer(mapCenter, dist, t);
GuiController.Instance.Drawer2D.beginDrawSprite();
GameManager.Instance.pointers[t].render();
GuiController.Instance.Drawer2D.endDrawSprite();
}
}
}
public void render(float velocidad, float cantNitro)
{
agujaVelocimetro.Rotation = FastMath.Abs(velocidad) / 1000 * FastMath.PI / 2;
llenadoNitro.Scaling = new Vector2(0.73f * cantNitro / 100, 0.50f);
llenadoNitro.Color = Color.FromArgb(255, (int)((100 - cantNitro) * 2.55), 0, (int)(cantNitro * 2.55));
velocimetro.Color = Color.FromArgb(255, 215, 215, 235);
//Iniciar dibujado de todos los Sprites de la escena (en este caso es solo uno)
GuiController.Instance.Drawer2D.beginDrawSprite();
//Dibujar sprite (si hubiese mas, deberian ir todos aquí)
foreach (TgcSprite sprite in sprites)
{
sprite.render();
}
llenadoNitro.render();
//Finalizar el dibujado de Sprites
GuiController.Instance.Drawer2D.endDrawSprite();
}
public override void Render()
{
PreRender();
//Actualizar valores cargados en modifiers
sprite.Position = (Vector2)Modifiers["position"];
sprite.Scaling = (Vector2)Modifiers["scaling"];
sprite.Rotation = FastMath.ToRad((float)Modifiers["rotation"]);
//Dibujar box3D. Se deben dibujar primero todos los objetos 3D. Recien al final dibujar los Sprites
box.render();
//Iniciar dibujado de todos los Sprites de la escena (en este caso es solo uno)
TgcDrawer2D.Instance.beginDrawSprite();
//Dibujar sprite (si hubiese mas, deberian ir todos aquí)
sprite.render();
//Finalizar el dibujado de Sprites
TgcDrawer2D.Instance.endDrawSprite();
PostRender();
}
public override void render(float elapsedTime)
{
motionBlurFlag = (bool)GuiController.Instance.Modifiers["motionBlurFlag"];
TgcTexture texture = TgcTexture.createTexture(GuiController.Instance.AlumnoEjemplosMediaDir + "TheC#\\Pista\\pistaCarreras.png");
Microsoft.DirectX.Direct3D.Device d3dDevice = GuiController.Instance.D3dDevice;
//pantalla De Inicio
if (flagInicio == 0)
{
//Actualizar valores cargados en modifiers
/*sprite.Position = (Vector2)GuiController.Instance.Modifiers["position"];
* sprite.Scaling = (Vector2)GuiController.Instance.Modifiers["scaling"];
* sprite.Rotation = FastMath.ToRad((float)GuiController.Instance.Modifiers["rotation"]);
*/
//Iniciar dibujado de todos los Sprites de la escena (en este caso es solo uno)
GuiController.Instance.Drawer2D.beginDrawSprite();
sprite.render();
//Finalizar el dibujado de Sprites
GuiController.Instance.Drawer2D.endDrawSprite();
flagInicio = jugador.verSiAprietaSpace();
textIngreseTeclaSombra.render();
textIngreseTecla.render();
musica.verSiCambioMP3();
}
else
{
//Para contar el tiempo desde que preciona la barra espaciadora y comienza el juego
if (primerRenderDelJuegoAndando == true)
{
this.horaInicio = DateTime.Now;
primerRenderDelJuegoAndando = false;
}
//Todo lo referente a lo que debe hacer el IA
autoIA.elapsedTime = elapsedTime;
autoIA.establecerVelocidadMáximaEn((float)GuiController.Instance.Modifiers["velocidadMaxima"] * 1.02f);
if (colision.getTiempoQueChoco() == 0)
{
jugadorIA.jugar(trayectoDeIA[0].Center, meshAutoIA.Position);
}
meshAutoIA.Rotation = new Vector3(0f, autoIA.rotacion, 0f);
jugadorIA.setRotacion(meshAutoIA.Rotation);
meshAutoIA.moveOrientedY(-autoIA.velocidad * elapsedTime);
//Fin movimiento de auto IA
//Le paso el elapsed time al auto porque sus metodos no deben depender de los FPS
auto.elapsedTime = elapsedTime;
//Varío la velocidad Máxima del vehículo con el modifier "velocidadMáxima"
auto.establecerVelocidadMáximaEn((float)GuiController.Instance.Modifiers["velocidadMaxima"]);
//El jugador envia mensajes al auto dependiendo de que tecla presiono
//Se pone un tiempo para que luego de chocar 2 autos, estos no puedan ingresar movimiento (sólo se mueve por inercia)
if (colision.getTiempoQueChoco() == 0)
{
jugador.jugar(cantidadDeNitro);
}
else
{
colision.setTiempoQueChoco(colision.getTiempoQueChoco() - (8 * elapsedTime));
if (colision.getTiempoQueChoco() < 0)
{
colision.setTiempoQueChoco(0);
}
}
//Transfiero la rotacion del auto abstracto al mesh, y su obb
autoMesh.Rotation = new Vector3(0f, auto.rotacion, 0f);
oBBAuto.Center = autoMesh.Position;
oBBAuto.setRotation(autoMesh.Rotation);
meshAutoIA.Rotation = new Vector3(0f, autoIA.rotacion, 0f);
oBBAutoIa.Center = meshAutoIA.Position;
oBBAutoIa.setRotation(meshAutoIA.Rotation);
//Calculo de giro de la rueda
rotacionVertical -= auto.velocidad * elapsedTime / 60;
//Calculo el movimiento del mesh dependiendo de la velocidad del auto
autoMesh.moveOrientedY(-auto.velocidad * elapsedTime);
//Detección de colisiones
//Hubo colisión con un objeto. Guardar resultado y abortar loop.
//Si hubo alguna colisión, hacer esto:
if (huboColision(oBBAuto))
{
autoMesh.moveOrientedY(20 * auto.velocidad * elapsedTime); //Lo hago "como que rebote un poco" para no seguir colisionando
auto.velocidad = -(auto.velocidad * 0.3f); //Lo hago ir atrás un tercio de velocidad de choque
}
if (huboColision(oBBAutoIa))
{
meshAutoIA.moveOrientedY(20 * autoIA.velocidad * elapsedTime); //Lo hago "como que rebote un poco" para no seguir colisionando
autoIA.velocidad = -(autoIA.velocidad * 0.3f); //Lo hago ir atrás un tercio de velocidad de choque
}
//Colisión entre los autos
for (int i = 0; i < 4; i++)
{
float ro, alfa_rueda;
float posicion_xA1;
float posicion_yA1;
float posicion_xA2;
float posicion_yA2;
ro = FastMath.Sqrt(dx[i] * dxAColision[i] + dyAColision[i] * dyAColision[i]);
alfa_rueda = FastMath.Asin(dxAColision[i] / ro);
if (i == 0 || i == 2)
{
alfa_rueda += FastMath.PI;
}
posicion_xA1 = FastMath.Sin(alfa_rueda + auto.rotacion) * ro;
posicion_yA1 = FastMath.Cos(alfa_rueda + auto.rotacion) * ro;
posicion_xA2 = FastMath.Sin(alfa_rueda + autoIA.rotacion) * ro;
posicion_yA2 = FastMath.Cos(alfa_rueda + autoIA.rotacion) * ro;
obbsAuto[i].Position = (new Vector3(posicion_xA1, 15.5f, posicion_yA1) + autoMesh.Position);
obbsOtroAuto[i].Position = (new Vector3(posicion_xA2, 15.5f, posicion_yA2) + meshAutoIA.Position);
}
colision.colisionEntreAutos(obbsAuto, obbsOtroAuto, jugador, auto, autoIA, autoMesh, meshAutoIA, elapsedTime);
//Cosas sobre derrape
int direcGiroDerrape = 0;
if (auto.velocidad > 1500 && (jugador.estaGirandoDerecha() || jugador.estaGirandoIzquierda()))
{
if (jugador.estaGirandoIzquierda())
{
direcGiroDerrape = -1;
}
else if (jugador.estaGirandoDerecha())
{
direcGiroDerrape = 1;
}
autoMesh.Rotation = new Vector3(0f, auto.rotacion + (direcGiroDerrape * anguloDerrape), 0f);
oBBAuto.setRotation(new Vector3(autoMesh.Rotation.X, autoMesh.Rotation.Y + (direcGiroDerrape * anguloDerrape / 2), autoMesh.Rotation.Z));
if (anguloDerrape <= anguloMaximoDeDerrape)
{
anguloDerrape += velocidadDeDerrape * elapsedTime;
}
}
else
{
direcGiroDerrape = 0;
anguloDerrape = 0;
}
//Fin derrape
//Posiciono las ruedas
for (int i = 0; i < 4; i++)
{
float ro, alfa_rueda;
float posicion_x;
float posicion_y;
ro = FastMath.Sqrt(dx[i] * dx[i] + dy[i] * dy[i]);
alfa_rueda = FastMath.Asin(dx[i] / ro);
if (i == 0 || i == 2)
{
alfa_rueda += FastMath.PI;
}
posicion_x = FastMath.Sin(alfa_rueda + auto.rotacion + (anguloDerrape * direcGiroDerrape)) * ro;
posicion_y = FastMath.Cos(alfa_rueda + auto.rotacion + (anguloDerrape * direcGiroDerrape)) * ro;
ruedas[i].Position = (new Vector3(posicion_x, 15.5f, posicion_y) + autoMesh.Position);
//Si no aprieta para los costados, dejo la rueda derecha (por ahora, esto se puede modificar)
if (input.keyDown(Key.Left) || input.keyDown(Key.A) || input.keyDown(Key.Right) || input.keyDown(Key.D))
{
ruedas[i].Rotation = new Vector3(rotacionVertical, auto.rotacion + auto.rotarRueda(i) + (anguloDerrape * direcGiroDerrape), 0f);
}
else
{
ruedas[i].Rotation = new Vector3(rotacionVertical, auto.rotacion + (anguloDerrape * direcGiroDerrape), 0f);
}
}
//comienzo humo
float rohumo, alfa_humo;
float posicion_xhumo;
float posicion_yhumo;
rohumo = FastMath.Sqrt(-19f * -19f + 126f * 126f);
alfa_humo = FastMath.Asin(-19f / rohumo);
posicion_xhumo = FastMath.Sin(alfa_humo + auto.rotacion + (anguloDerrape * direcGiroDerrape)) * rohumo;
posicion_yhumo = FastMath.Cos(alfa_humo + auto.rotacion + (anguloDerrape * direcGiroDerrape)) * rohumo;
humo.Position = (new Vector3(posicion_xhumo, 15.5f, posicion_yhumo) + autoMesh.Position);
//Si no aprieta para los costados, dejo la rueda derecha (por ahora, esto se puede modificar)
if (input.keyDown(Key.Left) || input.keyDown(Key.A) || input.keyDown(Key.Right) || input.keyDown(Key.D))
{
humo.Rotation = new Vector3(0f, auto.rotacion + (anguloDerrape * direcGiroDerrape), 0f);
}
else
{
humo.Rotation = new Vector3(0f, auto.rotacion + (anguloDerrape * direcGiroDerrape), 0f);
}
//fin de humo
fuego.Position = humo.Position;
fuego.Rotation = humo.Rotation;
//fin fuego
cantidadDeNitro += 0.5f * elapsedTime;
cantidadDeNitro = FastMath.Min(cantidadDeNitro, 100f);
if (auto.nitro)
{
cantidadDeNitro -= 7 * elapsedTime;
cantidadDeNitro = FastMath.Max(cantidadDeNitro, 0f);
if (cantidadDeNitro > 1)
{
humo.Enabled = false;
fuego.Enabled = false;
}
}
else
{
humo.Enabled = false;
fuego.Enabled = false;
}
tiempoHumo += elapsedTime;
humo.UVOffset = new Vector2(0.9f, tiempoHumo);
humo.updateValues();
fuego.UVOffset = new Vector2(0.9f, tiempoHumo);
fuego.updateValues();
if (tiempoHumo > 50f)
{
tiempoHumo = 0f;
}
autoMeshPrevX = autoMesh.Position.X;
autoMeshPrevZ = autoMesh.Position.Z;
//Lineas de Frenado
if (jugador.estaFrenandoDeMano())
{
lineaDeFrenado[0].addTrack(new Vector3(ruedaDerechaDelanteraMesh.Position.X, 0, ruedaDerechaDelanteraMesh.Position.Z));
lineaDeFrenado[1].addTrack(new Vector3(ruedaDerechaTraseraMesh.Position.X, 0, ruedaDerechaTraseraMesh.Position.Z));
lineaDeFrenado[2].addTrack(new Vector3(ruedaIzquierdaDelanteraMesh.Position.X, 0, ruedaIzquierdaDelanteraMesh.Position.Z));
lineaDeFrenado[3].addTrack(new Vector3(ruedaIzquierdaTraseraMesh.Position.X, 0, ruedaIzquierdaTraseraMesh.Position.Z));
}
if (jugador.dejoDeFrenarDeMano())
{
for (int i = 0; i < lineaDeFrenado.Length; i++)
{
lineaDeFrenado[i].endTrack();
}
}
for (int i = 0; i < lineaDeFrenado.Length; i++)
{
lineaDeFrenado[i].render();
lineaDeFrenado[i].pasoDelTiempo(elapsedTime);
}
//Dibujo el reflejo de la luz en el auto
reflejo.Render();
//////Camara///////
if (jugador.estaMirandoHaciaAtras())
{
GuiController.Instance.ThirdPersonCamera.setCamera(autoMesh.Position, 200, -500);
GuiController.Instance.ThirdPersonCamera.Target = autoMesh.Position;
GuiController.Instance.ThirdPersonCamera.RotationY = auto.rotacion;
}
else
{
coheficienteCamara = jugador.verSiCambiaCamara();
GuiController.Instance.ThirdPersonCamera.setCamera(autoMesh.Position, 100 + (coheficienteCamara), 900 - (coheficienteCamara) * 4);
GuiController.Instance.ThirdPersonCamera.Target = autoMesh.Position;
GuiController.Instance.ThirdPersonCamera.RotationY = auto.rotacion;
}
//La camara no rota exactamente a la par del auto, hay un pequeño retraso
//GuiController.Instance.ThirdPersonCamera.RotationY += 5 * (auto.rotacion - prevCameraRotation) * elapsedTime;
//Ajusto la camara a menos de 360 porque voy a necesitar hacer calculos entre angulos
while (prevCameraRotation > 360)
{
prevCameraRotation -= 360;
}
prevCameraRotation = GuiController.Instance.ThirdPersonCamera.RotationY;
///////Musica/////////
jugador.verSiModificaMusica(musica);
//Dibujar objeto principal
//Siempre primero hacer todos los cálculos de lógica e input y luego al final dibujar todo (ciclo update-render)
foreach (TgcMesh mesh in scenePista.Meshes)
{
mesh.Enabled = (TgcCollisionUtils.classifyFrustumAABB(GuiController.Instance.Frustum, mesh.BoundingBox) != TgcCollisionUtils.FrustumResult.OUTSIDE);
}
if (motionBlurFlag)
{
motionBlur.update(elapsedTime);
motionBlur.motionBlurRender(elapsedTime, HighResolutionTimer.Instance.FramesPerSecond, auto.velocidad, 0);
}
else
{
foreach (TgcMesh mesh in scenePista.Meshes)
{
mesh.Technique = "DefaultTechnique";
mesh.render();
}
}
//Mostrar al auto IA
meshAutoIA.render();
//Muestro el punto siguiente
trayecto[0].render();
//mostrar el auto manejado por el humano
autoMesh.render();
for (int i = 0; i < 4; i++)
{
ruedas[i].render();
}
humo.render();
fuego.render();
//Colision con puntos de control, tanto de persona como IA
for (int i = 0; i < trayecto.Count; i++)
{
//Pregunto si colisiona con un punto de control activado. Lo sé, feo.
if ((i == 0) && TgcCollisionUtils.testPointCylinder(oBBAuto.Position, trayecto[i].BoundingCylinder))
{
TgcCylinder cilindroModificado = new TgcCylinder(trayecto[i].Center, 130, 30);
if (contadorDeActivacionesDePuntosDeControl != (posicionesPuntosDeControl.Count * 3))
{
trayecto.RemoveAt(i);
trayecto.Add(cilindroModificado);
contadorDeActivacionesDePuntosDeControl++;
textPuntosDeControlAlcanzados.Text = "Puntos De Control Alcanzados = " + contadorDeActivacionesDePuntosDeControl.ToString();
textTiempo.Text = (Convert.ToDouble(textTiempo.Text) + 3).ToString();
}
else
{
gano = true;
textGanaste.Text = "Ganaste y obtuviste un puntaje de " + textTiempo.Text + " puntos";
textGanaste.render();
auto.estatico();
//Para el IA
autoIA.estatico();
}
}
}
for (int i = 0; i < trayectoDeIA.Count; i++)
{
//Pregunto si colisiona con un punto de control activado
if ((i == 0) && TgcCollisionUtils.testPointCylinder(meshAutoIA.Position, trayectoDeIA[i].BoundingCylinder))
{
TgcCylinder cilindroModificado = new TgcCylinder(trayectoDeIA[i].Center, 130, 30);
if (contadorDeActivacionesDePuntosDeControlDeIA != (posicionesPuntosDeControlDeIA.Count * 3))
{
trayectoDeIA.RemoveAt(i);
trayectoDeIA.Add(cilindroModificado);
contadorDeActivacionesDePuntosDeControlDeIA++;
}
else
{
gano = true;
textGanaste.Text = "Ganó la máquina :P ";
textGanaste.render();
//Para el IA
autoIA.estatico();
auto.estatico();
}
}
}
textPosicionDelAutoActual.Text = autoMesh.Position.ToString();
//Renderizar los tres textos
textoVelocidad.mostrarVelocidad(auto.velocidad / 10).render(); //renderiza la velocidad
textPuntosDeControlAlcanzados.render();
textPosicionDelAutoActual.render();
//Cosas del tiempo
tiempo.incrementarTiempo(this, elapsedTime, (bool)GuiController.Instance.Modifiers["jugarConTiempo"]);
//Actualizo y dibujo el relops
if ((bool)GuiController.Instance.Modifiers["jugarConTiempo"])
{
if ((DateTime.Now.Subtract(this.horaInicio).TotalSeconds) > segundosAuxiliares)
{
if (Convert.ToDouble(textTiempo.Text) == 0)
{
textPerdiste.Text = "Perdiste y lograste " + contadorDeActivacionesDePuntosDeControl.ToString() + " puntos de control";
textPerdiste.render();
auto.estatico();
//Para el IA
autoIA.estatico();
}
else if (gano == true)
{
}
else
{
this.textTiempo.Text = (Convert.ToDouble(textTiempo.Text) - 1).ToString();
segundosAuxiliares++;
}
}
}
emisorHumo.update(elapsedTime, GuiController.Instance.CurrentCamera.getLookAt(), auto.rotacion, autoMesh.Position, anguloDerrape, direcGiroDerrape, auto.nitro && (cantidadDeNitro > 1), auto.velocidad);
emisorHumo.render(GuiController.Instance.CurrentCamera.getPosition());
textTiempo.render();
stringTiempo.render();
contadorDeFrames++;
hud.render(auto.velocidad, cantidadDeNitro);
}//cierra el if de que no esta en pantalla inicio
textFPS.Text = " FPS: " + HighResolutionTimer.Instance.FramesPerSecond.ToString();
textFPS.render();
}
public void render(float elapsedTime)
{
TgcD3dInput d3dInput = GuiController.Instance.D3dInput;
//Calcular proxima posicion de personaje segun Input
float moveForward = 0f;
float moveSide = 0f;
float rotateY = 0;
//float rotateX = 0;
float jump = 0;
bool moving = false;
bool rotating = false;
bool rotatingY = false;
// bool rotatingX = false;
bool running = false;
bool jumping = false;
string animationAction = "StandBy";
//Ubicarlo centrado en la pantalla
Size screenSize = GuiController.Instance.Panel3d.Size;
Size textureSize = mira.Texture.Size;
mira.Enabled = false;
TgcText2d hitCantTextY = new TgcText2d();
hitCantTextY.Position = new Point(0, 0);
hitCantTextY.Color = Color.White;
/* TgcText2d hitCantTextX = new TgcText2d();
* hitCantTextX.Position = new Point(0, 20);
* hitCantTextX.Color = Color.White;
*/
if (destroy)
{
goto Rendering;
}
//obtener velocidades de Modifiers
float velocidadCaminar = (float)GuiController.Instance.Modifiers["VelocidadCaminar"];
float velocidadRotacion = (float)GuiController.Instance.Modifiers.getValue("VelocidadRotacion");
//Detonar
if (this.canExplode && d3dInput.keyDown(Key.K))
{
animationAction = "Talk";
this.explosion.detonar();
destroy = true;
}
//Adelante
if (d3dInput.keyDown(Key.W))
{
if (!moving)
{
moveForward = -velocidadCaminar;
}
else
{
moveForward = -velocidadCaminar / 2;
}
moving = true;
}
//Atras
if (d3dInput.keyDown(Key.S))
{
if (!moving)
{
moveForward = velocidadCaminar;
}
else
{
moveForward = velocidadCaminar / 2;
}
moving = true;
}
//Derecha
if (d3dInput.XposRelative > 0 || d3dInput.keyDown(Key.RightArrow))
{
if (d3dInput.XposRelative > 0)
{
rotateY = (velocidadRotacion / 2);
}
else
{
rotateY = velocidadRotacion;
}
rotating = true;
rotatingY = true;
}
//Izquierda
if (d3dInput.XposRelative < 0 || d3dInput.keyDown(Key.LeftArrow))
{
if (d3dInput.XposRelative < 0)
{
rotateY = -(velocidadRotacion / 2);
}
else
{
rotateY = -velocidadRotacion;
}
rotating = true;
rotatingY = true;
}
//Mover Derecha
if (d3dInput.keyDown(Key.D))
{
if (!moving)
{
moveSide = -velocidadCaminar;
}
else
{
moveSide = -velocidadCaminar / 2;
}
moving = true;
}
//Mover Izquierda
if (d3dInput.keyDown(Key.A))
{
if (!moving)
{
moveSide = velocidadCaminar;
}
else
{
moveSide = velocidadCaminar / 2;
}
moving = true;
}
/* //Arriba
* if (d3dInput.YposRelative < 0)
* {
* //if (camara.RotationX > -(Math.PI / 3))
* //{
* rotateX = -velocidadRotacion;
* rotating = true;
* rotatingX = true;
* //}
* }
*
* //Abajo
* if (d3dInput.YposRelative > 0)
* {
* //if (camara.RotationX < (Math.PI / 3))
* //{
* rotateX = velocidadRotacion;
* rotating = true;
* rotatingX = true;
* //}
* }
*/
//Jump
/*if (d3dInput.keyDown(Key.Space))
* {
* jump = 30;
* moving = true;
* }*/
//Run
if (d3dInput.keyDown(Key.LeftShift))
{
running = true;
moveForward *= 1.5f;
}
if (d3dInput.keyDown(Key.E) || d3dInput.buttonDown(TgcD3dInput.MouseButtons.BUTTON_RIGHT))
{
mira.Enabled = true;
animationAction = "WeaponPos";
if (d3dInput.buttonPressed(TgcD3dInput.MouseButtons.BUTTON_LEFT))
{
this.fire();
}
}
//Si hubo rotacion
if (rotating)
{
if (rotatingY)
{
//Rotar personaje y la camara, hay que multiplicarlo por el tiempo transcurrido para no atarse a la velocidad el hardware
float rotAngleY = Geometry.DegreeToRadian(rotateY * elapsedTime);
this.personaje.rotateY(rotAngleY);
this.camara.rotateY(rotAngleY);
}
/* if (rotatingX)
* {
* //Rotar personaje y la camara, hay que multiplicarlo por el tiempo transcurrido para no atarse a la velocidad el hardware
* float rotAngleX = Geometry.DegreeToRadian(rotateX * elapsedTime);
* this.camara.rotateX(rotAngleX);
*
* }*/
}
//Si hubo desplazamiento
if (moving)
{
//Activar animacion de caminando
if (running)
{
this.personaje.playAnimation("Run", true);
}
else if (jumping)
{
this.personaje.playAnimation("Jump", true);
}
else
{
this.personaje.playAnimation("Walk", true);
}
}
//Si no se esta moviendo, activar animationAction
else
{
this.personaje.playAnimation(animationAction, true);
}
if (life <= 0)
{
this.personaje.playAnimation("Muerte", true);
}
//Vector de movimiento
Vector3 movementVector = Vector3.Empty;
if (moving)
{
//Aplicar movimiento, desplazarse en base a la rotacion actual del personaje
//Grupo Kamikaze3D :: Se agrega también al desplazamiento sobre el eje x y eje z, el valor de desplazamiento lateral
movementVector = new Vector3(
(FastMath.Sin(this.personaje.Rotation.Y) * moveForward) + (FastMath.Cos(this.personaje.Rotation.Y) * moveSide),
jump,
(FastMath.Cos(this.personaje.Rotation.Y) * moveForward) + (-FastMath.Sin(this.personaje.Rotation.Y) * moveSide)
);
}
//Mover personaje con detección de colisiones, sliding y gravedad
Vector3 realMovement;
if (collisionWithCharacters(movementVector))
{
realMovement = Vector3.Empty;
}
else
{
realMovement = collisionManager.moveCharacter(this.characterSphere, movementVector, this.objetosColisionables);
}
this.personaje.move(realMovement);
//Actualizar valores de la linea de movimiento
this.directionArrow.PStart = characterSphere.Center;
this.directionArrow.PEnd = characterSphere.Center + Vector3.Multiply(movementVector, 50);
this.directionArrow.updateValues();
//Caargar desplazamiento realizar en UserVar
GuiController.Instance.UserVars.setValue("Movement", TgcParserUtils.printVector3(realMovement));
Rendering:
//Render linea
if (renderDirectionArrow)
{
this.directionArrow.render();
}
this.renderBullets();
//Render personaje
this.personaje.animateAndRender();
//Iniciar dibujado de todos los Sprites de la escena (en este caso es solo uno)
GuiController.Instance.Drawer2D.beginDrawSprite();
//Dibujar sprite (si hubiese mas, deberian ir todos aquí)
mira.render();
//Finalizar el dibujado de Sprites
GuiController.Instance.Drawer2D.endDrawSprite();
//hitCantTextY.Text = "Y: " + camara.RotationY;
//hitCantTextX.Text = "X: " + camara.RotationX;
//hitCantTextY.render();
//hitCantTextX.render();
}