private void ApuntarAlTarget()
{
//Se fija que el target haya cambiado de posicion
if (targetPos == this.autoP.getMesh().Position)
{
return;
}
targetPos = this.autoP.getMesh().Position;
float X1 = this.getMesh().Position.X;
float Z1 = this.getMesh().Position.Z;
float X2 = targetPos.X;
float Z2 = targetPos.Z;
float ang = FastMath.Atan2((Z2 - Z1), (X2 - X1));
float ang2 = (FastMath.PI * 3 / 2) - ang;
if (base.anguloFinal != ang2)
{
setAnguloFinal(ang2);
//float f = this.autoP.orientacion;
if (ang >= 0 && ang <= 3)
{
doblaD = true;
}
if (ang < 0 && ang >= -3)
{
doblaI = true;
}
}
}
private float AngleDistance(float a, float b)
{
//float c = b - a + FastMath.PI;
//float mod = c - FastMath.Floor(c / FastMath.PI_HALF) * FastMath.PI - FastMath.PI_HALF;
//return mod;
return(FastMath.Atan2(FastMath.Sin(b - a), FastMath.Cos(b - a)));
}
private TGCVector3 CalculateRotation(TGCVector3 normalObjeto)
{
var objectInclinationX = FastMath.Atan2(normalObjeto.X, normalObjeto.Y);
var objectInclinationZ = FastMath.Atan2(normalObjeto.X, normalObjeto.Y);
var rotation = new TGCVector3(-objectInclinationX, 0, -objectInclinationZ);
return(rotation);
}
public bool MoveTowards(Vector3 targetPos, List <Core.BoundingVolumes.TgcBoundingAxisAlignBox> obstaculos, float ElapsedTime)
{
var targetDistance = targetPos - Position;
bool ret = false;
//El monstruo solo se mueve en el plano XZ
targetDistance.Y = 0f;
//Normalizar distancia para obtener versor direccion
var targetDirection = Vector3.Normalize(targetDistance);
//Obtener movimiento
var movement = targetDirection * velocidad * ElapsedTime;
//Si el movimiento es mayor que la distancia al objetivo lo reemplazamos por la misma para no pasarnos
if (movement.LengthSq() >= targetDistance.LengthSq())
{
movement = targetDistance;
ret = true;
}
//Se obtiene el angulo de rotacion horizontal
var targetAngleH = FastMath.Atan2(targetDirection.X, targetDirection.Z);
//Se obtiene el angulo de rotacion vertical a partir de la altura del versor director(ya no es relevante)
//var targetAngleV = FastMath.Asin(targetDirection.Y);
var originalRot = mesh.Rotation;
var originalPos = Position;
if (chasingPlayer)
{
//Rotamos el mesh, se suma PI para que de la cara y no la espalda
mesh.Rotation = new Vector3(0, targetAngleH + FastMath.PI, 0);
move(movement, obstaculos);
}
else
{
//si tamos tranca rotamos lentamente a la dirección a la que queremos ir
//sacamos la distancia entre angulos
float distancia = AngleDistance(mesh.Rotation.Y, targetAngleH + FastMath.PI);
mesh.Rotation = new Vector3(0f, Approach(mesh.Rotation.Y, mesh.Rotation.Y + distancia, rotation_speed), 0f);
//si ya estamos como queremos nos movemos
if (FastMath.EpsilonEquals(AngleDistance(mesh.Rotation.Y, targetAngleH + FastMath.PI), 0f))
{
move(movement, obstaculos);
}
}
return(ret);
}
public static TGCVector3 QuaternionToEuler(Quaternion q)
{
float q0 = q.W;
float q1 = q.Y;
float q2 = q.X;
float q3 = q.Z;
TGCVector3 radAngles = new TGCVector3();
radAngles.Y = FastMath.Atan2(2f * (q0 * q1 + q2 * q3), 1f - 2f * (FastMath.Pow2(q1) + FastMath.Pow2(q2)));
radAngles.X = FastMath.Asin(2f * (q0 * q2 - q3 * q1));
radAngles.Z = FastMath.Atan2(2f * (q0 * q3 + q1 * q2), 1f - 2f * (FastMath.Pow2(q2) + FastMath.Pow2(q3)));
return(radAngles);
}
//mueve el barco y su boundingspehere en Y; hay que refactorearlo...
//mueve el barco y su boundingspehere en Y; hay que refactorearlo...
virtual public void flotar()
{
//normal del mar en el punto donde se encuentra el barco
normal = Oceano.normalEnPuntoXZ(this.Position.X, this.Position.Z);
//altura del mar en el punto de se encuentra el barco
float Y = Oceano.alturaEnPunto(this.Position.X, this.Position.Z);
//ponemos el bounding sphere a la altura donde esta el barco
this.boundingSphere.moveCenter(new Vector3(0, Y - boundingSphere.Position.Y + 40, 0));
//ubicamos al barco...
this.Position = new Vector3(this.Position.X, Y - 15, this.Position.Z); // ...en alto...
this.rotation.Z = FastMath.Atan2(-normal.X * FastMath.Cos(this.rotation.Y), normal.Y) + FastMath.Atan2(normal.Z * FastMath.Sin(this.rotation.Y), normal.Y); // ...con rotacion en Z...
this.rotation.X = FastMath.Atan2(normal.Z * FastMath.Cos(this.rotation.Y), normal.Y) + FastMath.Atan2(normal.X * FastMath.Sin(this.rotation.Y), normal.Y); // ...con rotacion en Y...
}
private void ApuntarAlTarget(Vector3 PosicionTarget)
{
//1- bajo el contador que se fija cuando fue la ultima vez que apunte.
// 2 - si todavia no puedo doblar, return!
if (tiempoEspera > 0f)
{
return;
}
tiempoEspera = FixedWaitingTime; //3- Vuelvo la constante a valor inicial para que
//espere para volver a apuntar la proxima vez.
//4 checkeo la cantidad de grados a girar y quedar apuntando hacia el target
var posicionMesh = Mesh.Position;
//float ab = Vector3.Dot(posicionMesh, PosicionTarget);
//float a = posicionMesh.Length();
//float b = PosicionTarget.Length();
//double anguloDouble = Math.Acos(Convert.ToDouble(a));
//anguloFinal = Convert.ToSingle(anguloDouble);
//ahora pongo al mesh mirando hacia el target.
//matrixRotacion = Matrix.RotationY(anguloFinal);
//obb.rotate(new Vector3(0, anguloFinal, 0));
// float ang = FastMath.Acos((a * b) / ab);
float X1 = Mesh.Position.X;
float Z1 = Mesh.Position.Z;
float X2 = meshTarget.Position.X;
float Z2 = meshTarget.Position.Z;
float ang = FastMath.Atan2((Z2 - Z1), (X2 - X1));
matrixRotacion = Matrix.RotationY((FastMath.PI * 3 / 2) - ang);
obb.setRotation(new Vector3(0, (FastMath.PI * 3 / 2) - ang, 0));
anguloFinal = ang;
angOrientacionMesh = ang;
//Doblar(ang);
}
public static Vector3 ToEulerAngles(this Quaternion q)
{
// Store the Euler angles in radians
Vector3 pitchYawRoll = new Vector3();
float PI = FastMath.PI;
float sqw = q.W * q.W;
float sqx = q.X * q.X;
float sqy = q.Y * q.Y;
float sqz = q.Z * q.Z;
// If quaternion is normalised the unit is one, otherwise it is the correction factor
float unit = sqx + sqy + sqz + sqw;
float test = q.X * q.Y + q.Z * q.W;
if (test > 0.499f * unit)
{
// Singularity at north pole
pitchYawRoll.Y = 2f * FastMath.Atan2(q.X, q.W); // Yaw
pitchYawRoll.X = PI * 0.5f; // Pitch
pitchYawRoll.Z = 0f; // Roll
return(pitchYawRoll);
}
else if (test < -0.499f * unit)
{
// Singularity at south pole
pitchYawRoll.Y = -2f * FastMath.Atan2(q.X, q.W); // Yaw
pitchYawRoll.X = -PI * 0.5f; // Pitch
pitchYawRoll.Z = 0f; // Roll
return(pitchYawRoll);
}
pitchYawRoll.Y = FastMath.Atan2(2 * q.Y * q.W - 2 * q.X * q.Z, sqx - sqy - sqz + sqw); // Yaw
pitchYawRoll.X = FastMath.Asin(2 * test / unit); // Pitch
pitchYawRoll.Z = FastMath.Atan2(2 * q.X * q.W - 2 * q.Y * q.Z, -sqx + sqy - sqz + sqw); // Roll
return(pitchYawRoll);
}
public void Update(float elapsedTime)
{
int velocidadEnemigo = randomEnemigo.Next(10, 15);
float angulo;
Enemigo otroEnemigo;
Vector3 posicionPlayer = GuiController.Instance.CurrentCamera.getPosition();
// vector con direccion al jugador
Vector3 direccionPlayer = posicionPlayer - enemigo.Position;
direccionPlayer.Y = 0;
Vector3 direccionMovimiento = direccionPlayer;
if (ColisionesAdmin.Instance.ColisionEnemigoConObjetos(this))
{
if (direccionColisionObjeto == vectorNulo)
{
angulo = (180 * (float)Math.Atan2(direccionMovimiento.Z, direccionMovimiento.X)) / (float)Math.PI;// +45;
angulo += 90;
direccionColisionObjeto = Rotar(angulo);
}
}
else
{
direccionColisionObjeto = vectorNulo;
if (this.colisionado == true)
{
if (!ColisionesAdmin.Instance.ColisionEnemigoConEnemigos(this, out otroEnemigo))
{
this.colisionado = false;
direccionColisionEnemigo = vectorNulo;
}
else if (direccionColisionEnemigo == vectorNulo)
{
angulo = (180 * (float)Math.Atan2(direccionMovimiento.Z, direccionMovimiento.X)) / (float)Math.PI;// +45;
int anguloGiro = randomEnemigo.Next(45, 90);
if (randomEnemigo.Next(0, 2) == 1)
{
anguloGiro *= -1;
}
angulo += anguloGiro;
direccionColisionEnemigo = Rotar(angulo);
}
}
else
{
if (ColisionesAdmin.Instance.ColisionEnemigoConEnemigos(this, out otroEnemigo))
{
otroEnemigo.colisionado = true;
}
if (direccionRandom == vectorNulo && randomEnemigo.Next(0, 500) == 1)
{
angulo = (180 * (float)FastMath.Atan2(direccionMovimiento.Z, direccionMovimiento.X)) / (float)Math.PI;// +45;
int anguloGiro = 30;
if (randomEnemigo.Next(0, 2) == 1)
{
anguloGiro = 90;
}
angulo += anguloGiro;
direccionRandom = Rotar(angulo);
}
else if (direccionRandom != vectorNulo && randomEnemigo.Next(0, 50) == 1)
{
direccionRandom = vectorNulo;
}
}
}
if (direccionRandom != vectorNulo)
{
direccionMovimiento = direccionRandom;
}
if (direccionColisionEnemigo != vectorNulo)
{
direccionMovimiento = direccionColisionEnemigo;
}
if (direccionColisionObjeto != vectorNulo)
{
direccionMovimiento = direccionColisionObjeto;
}
direccionMovimiento.Normalize();
// rotar al enemigo para que mire al jugador
enemigo.rotateY((float)Math.Atan2(direccionMovimiento.X, direccionMovimiento.Z) - enemigo.Rotation.Y + FastMath.PI);
enemigo.updateAnimation();
enemigo.move(direccionMovimiento * velocidadEnemigo * elapsedTime);
cabeza.moveCenter(direccionMovimiento * velocidadEnemigo * elapsedTime);
enemigo.BoundingBox.move(direccionMovimiento * velocidadEnemigo * elapsedTime);
emisorDeParticulas.Position = new Vector3(enemigo.Position.X, emisorDeParticulas.Position.Y, enemigo.Position.Z);
}
/// <summary>
/// Vuelve a crear la esfera si hubo cambio en el nivel de detalle, color o coordenadas de textura o si ForceUpdate
/// esta en true.
/// </summary>
public virtual void updateValues()
{
if (!mustUpdate && !ForceUpdate)
{
return;
}
if (indexBuffer != null && !indexBuffer.Disposed)
{
indexBuffer.Dispose();
}
if (vertexBuffer != null && !vertexBuffer.Disposed)
{
vertexBuffer.Dispose();
}
//Obtengo las posiciones de los vertices e indices de la esfera
List <Vector3> positions;
createSphereSubdividingAPolyhedron(out positions, out indices);
///////
vertices = new List <Vertex.PositionColoredTexturedNormal>();
var iverticesU1 = new List <int>();
var polos = new int[2];
var p = 0;
var c = color.ToArgb();
var twoPi = FastMath.TWO_PI;
//Creo la lista de vertices
for (var i = 0; i < positions.Count; i++)
{
var pos = positions[i];
var u = 0.5f + FastMath.Atan2(pos.Z, pos.X) / twoPi;
var v = 0.5f - 2 * FastMath.Asin(pos.Y) / twoPi;
vertices.Add(new Vertex.PositionColoredTexturedNormal(pos, c, UVTiling.X * u + UVOffset.X,
UVTiling.Y * v + UVOffset.Y, pos));
if (u == 1 || esPolo(vertices[i]))
{
iverticesU1.Add(i);
if (u != 1)
{
polos[p++] = i;
}
}
}
//Corrijo los triangulos que tienen mal las coordenadas debido a vertices compartidos
fixTexcoords(vertices, indices, iverticesU1, polos);
verticesCount = vertices.Count;
triangleCount = indices.Count / 3;
vertexBuffer = new VertexBuffer(typeof(Vertex.PositionColoredTexturedNormal), verticesCount,
D3DDevice.Instance.Device,
Usage.Dynamic | Usage.WriteOnly, Vertex.PositionColoredTexturedNormal.Format, Pool.Default);
vertexBuffer.SetData(vertices.ToArray(), 0, LockFlags.None);
indexBuffer = new IndexBuffer(typeof(int), indices.Count, D3DDevice.Instance.Device,
Usage.Dynamic | Usage.WriteOnly,
Pool.Default);
indexBuffer.SetData(indices.ToArray(), 0, LockFlags.None);
mustUpdate = false;
}
