void handleTopDownAdditionalPhysics(PhysicalProperties entityProps, IPhysicsObject entity, IPhysicsObject[] neighbours, GameTime gameTime)
{
// Gravity
if (entityProps.HasGravity)
{
if (entityProps.Velocity.X != 0)
{
var lerped = MathHelper.Lerp(entityProps.Velocity.X, 0, physSettings.Friction);
if (Math.Abs(lerped) < 2)
{
lerped = 0;
}
entityProps.Velocity.X = lerped;
}
if (entityProps.Velocity.Y != 0)
{
var lerped = MathHelper.Lerp(entityProps.Velocity.Y, 0, physSettings.Friction);
if (Math.Abs(lerped) < 2)
{
lerped = 0;
}
entityProps.Velocity.Y = lerped;
}
}
}
protected override IPhysicsObject CreatePhysicsObject(Scene s)
{
IPhysicsObject obj = s.Physics.CreateObjectBox(1, 200, 2, 200);
obj.Movable = false;
return(obj);
}
public IPhysicsBody CreateBody(IPhysicsObject owner, double width, double height, Shape shape)
{
return(new PhysicsBody(width, height, shape)
{
Owner = owner
});
}
public static int OverlapIgnoring(IPhysicsObject geom, ICollection <Collider> results, IEnumerable <Collider> ignoredColliders, int layerMask = Physics.AllLayers, QueryTriggerInteraction query = QueryTriggerInteraction.UseGlobal)
{
if (results == null)
{
throw new System.ArgumentNullException("results");
}
if (geom == null)
{
return(0);
}
int cnt = 0;
using (var set = TempCollection.GetSet <Collider>())
{
if (geom.Overlap(set, layerMask, query) > 0)
{
var e = set.GetEnumerator();
while (e.MoveNext())
{
if (!ignoredColliders.Contains(e.Current))
{
cnt++;
results.Add(e.Current);
}
}
}
}
return(cnt);
}
public void SimulatePhysics(GameTime gameTime, ref IPhysicsObject physicsObject)
{
//Declare flags for the movement algorightm
bool decelerating = false;
int decelerationSign = 0;
//Get the input vector from the object
Vector2 newInput = physicsObject.InputVector;
//If the input Vector has a zero, but the movement Vector is != 0, we need to decelerate
if(newInput.X == 0 && physicsObject.MovementVector.X != 0)
{
//We give the input the negative acceleration value of the movement vector
newInput.X = Math.Sign(physicsObject.MovementVector.X)*-1;
//We set the deceleration flag and save the sign of the current movement
decelerating = true;
decelerationSign = Math.Sign(physicsObject.MovementVector.X);
}
//If the input Vector has a zero, but the movement Vector is != 0, we need to decelerate
if (newInput.Y == 0 && physicsObject.MovementVector.Y != 0)
{
//We give the input the negative acceleration value of the movement vector
newInput.Y = Math.Sign(physicsObject.MovementVector.Y) * -1;
}
//Calculate the movement vector
Vector2 nextMovement = (newInput*physicsObject.Acceleration) + Gravity;
//We add the next movement to the movement vector
physicsObject.MovementVector += nextMovement;
//Check if the movement Vector is bigger then the max allowed speed
if(physicsObject.MovementVector.X > physicsObject.MaxSpeed || physicsObject.MovementVector.X < physicsObject.MaxSpeed*-1)
{
//If so, set the parameter to the max speed
physicsObject.MovementVector = new Vector2(physicsObject.MaxSpeed * Math.Sign(physicsObject.MovementVector.X), physicsObject.MovementVector.Y);
}
//Same as the previous statement
if (physicsObject.MovementVector.Y > physicsObject.MaxSpeed || physicsObject.MovementVector.Y < physicsObject.MaxSpeed*-1)
{
physicsObject.MovementVector = new Vector2(physicsObject.MovementVector.X, physicsObject.MaxSpeed * Math.Sign(physicsObject.MovementVector.Y));
}
//If we are decelerating, we need to make sure that we stop somewhere decelerating
if(decelerating)
{
//If the sign of the current movement vector has changed, we no longer need to decelerate, since we'd be going backwards then
if(Math.Sign(physicsObject.MovementVector.X) != decelerationSign)
{
//Set the movementvector to 0, in the x coordinate, so that we stop moving
physicsObject.MovementVector = new Vector2(0, physicsObject.MovementVector.Y);
decelerating = false;
}
}
//Add the movement vector to the position, so that we see a change onscreen
physicsObject.Position += physicsObject.MovementVector;
}
private static void TryToApplyForce(float force, Collider collider, ForceType type, float3 origin)
{
// if there is no physicsable interface - don't do anything else
IPhysicsObject pObject = collider.GetComponent <IPhysicsObject>();
if (pObject == null)
{
return;
}
switch (type)
{
case ForceType.Impulse:
pObject.AddImpulseForce(force, origin);
break;
case ForceType.Force:
pObject.AddForce(force);
break;
case ForceType.Freeze:
Debug.LogError("Force: Freeze type is not implemented.");
break;
}
}
/// <summary>
/// Pelaajablockin törmäys-event
/// </summary>
/// <param name="player">PlayerBlock joka törmäsi</param>
/// <param name="target">Block johon törmättiin</param>
public void PlayerBlockCollision(IPhysicsObject player, IPhysicsObject target)
{
Block block = target as Block;
PlayerBlock p = player as PlayerBlock;
// can we eat it
if (block != null && block.IsEdible)
{
if (block is NumberBlock)
{
NumberBlock numblock = block as NumberBlock;
// add to collected numbers
Peli.Instance.Collected.Add(numblock.Value);
Peli.Instance.CollectedUpdatedFlag = true;
}
else if (block is OrangeNumberBlock)
{
OrangeNumberBlock orangenumblock = block as OrangeNumberBlock;
// add to collected numbers
Peli.Instance.Collected.Add(orangenumblock.Value);
Peli.Instance.CollectedUpdatedFlag = true;
}
Peli.Instance.GridLogic.PlayerBlockEats(p, p.MovingTo);
block.Destroy();
}
}
/// <summary>
/// Modifies an existing height map field with short arrays.
/// </summary>
/// <param name="physObj"></param>
/// <param name="heightmap"></param>
/// <param name="width"></param>
/// <param name="height"></param>
public void ModifyHeightmapShort(IPhysicsObject physObj, short[] heightmap, int width, int height)
{
if (!objectIDs.ContainsKey(physObj))
{
return;
}
MataliPhysicsObject mataliPhysicsObj = objectIDs[physObj];
if (mataliPhysicsObj.InternalControllers.HeightmapController == null)
{
return;
}
int index = 0;
for (int i = 0; i < height; ++i)
{
for (int j = 0; j < width; ++j, index++)
{
mataliPhysicsObj.InternalControllers.HeightmapController.SetHeight(i, j, heightmap[index]);
}
}
mataliPhysicsObj.InternalControllers.HeightmapController.UpdateBounding();
}
public static bool DynamicRectVsRect(IPhysicsObject obj, float fElapsedTime, ICollision target, ref Vector2 contact_point, ref Vector2 contact_normal, ref float contact_time)
{
contact_point = Vector2.Zero;
contact_normal = Vector2.Zero;
contact_time = 0.0f;
// Check if dynamic rectangle is actually moving - we assume rectangles are NOT in collision to start
if (obj.Velocity.X == 0 && obj.Velocity.Y == 0)
{
return(false);
}
// Expand target rectangle by source dimensions
Vector2 objHalfSize = new Vector2(obj.CollisionBox.Size.X / 2, obj.CollisionBox.Size.Y / 2);
Rectangle expanded_target = new Rectangle();
expanded_target.Location = new Point(target.CollisionBox.Location.X - obj.CollisionBox.Size.X / 2, target.CollisionBox.Location.Y - obj.CollisionBox.Size.Y / 2);
expanded_target.Size = target.CollisionBox.Size + obj.CollisionBox.Size;
if (RayVsRect(obj.CollisionBox.Location.ToVector2() + objHalfSize, obj.Velocity * fElapsedTime, expanded_target, ref contact_point, ref contact_normal, ref contact_time))
{
return(contact_time >= 0.0f && contact_time < 1.0f);
}
else
{
return(false);
}
}
public static bool CheckAgainst(IPhysicsObject geom, IEnumerable <Collider> colliders, int layerMask = Physics.AllLayers, QueryTriggerInteraction query = QueryTriggerInteraction.UseGlobal)
{
if (geom == null)
{
return(false);
}
if (colliders == null)
{
return(false);
}
using (var set = TempCollection.GetSet <Collider>())
{
if (geom.Overlap(set, layerMask, query) > 0)
{
var e = LightEnumerator.Create <Collider>(colliders);
while (e.MoveNext())
{
if (set.Contains(e.Current))
{
return(true);
}
}
}
}
return(false);
}
/// <summary>
/// Performs raycast picking with the given near and far points.
/// </summary>
/// <param name="nearPoint">The near point of the pick ray</param>
/// <param name="farPoint">The far point of the pick ray</param>
/// <returns>A list of picked objects</returns>
public List <PickedObject> PickRayCast(Vector3 nearPoint, Vector3 farPoint)
{
pickedObjects.Clear();
Vector3 rayDirection = (farPoint - nearPoint);
rayDirection.Normalize();
scene.UpdatePhysicsObjectsIntersectedByRay(ref nearPoint, ref rayDirection, 0, false);
int objectsCollided = scene.IntersectedPhysicsObjectsCount;
Vector3 hitPosition = Vector3.Zero;
for (int i = 0; i < objectsCollided; i++)
{
MataliPhysicsObject obj = scene.GetIntersectedPhysicsObject(i, ref hitPosition);
IPhysicsObject physObj = GetIPhysicsObject(obj);
if (physObj != null && physObj.Pickable)
{
PickedObject pickedObject = new PickedObject(physObj, i);
pickedObjects.Add(pickedObject);
}
}
return(pickedObjects);
}
public void DestroyPhysicsObject(IPhysicsObject obj)
{
if (obj != null)
{
destroyedObjects.Enqueue(obj);
}
}
public IPhysicsObject[] GetNearbyCollidables(IPhysicsObject actor)
{
int chunkIndexX = (int)(actor.CollisionBox.X / ChunkWidth);
int chunkIndexY = (int)(actor.CollisionBox.Y / ChunkHeight);
var chunks = new Chunk[]
{
// Get own chunk
tryGetChunk(chunkIndexX, chunkIndexY),
// Get surrounding chunks
tryGetChunk(chunkIndexX - 1, chunkIndexY),
tryGetChunk(chunkIndexX - 1, chunkIndexY - 1),
tryGetChunk(chunkIndexX, chunkIndexY - 1),
tryGetChunk(chunkIndexX + 1, chunkIndexY - 1),
tryGetChunk(chunkIndexX + 1, chunkIndexY),
tryGetChunk(chunkIndexX + 1, chunkIndexY + 1),
tryGetChunk(chunkIndexX, chunkIndexY + 1),
tryGetChunk(chunkIndexX - 1, chunkIndexY + 1),
};
var collidables = chunks.Where(t => t != null) // Ensure chunk was found
.SelectMany(t => t.Entities) // Flatten
.Distinct() // Remove dupes
.Where(e => e != actor && (e.IsCollisionEnabled || e.IsOverlappingEnabled)) // Ignore self, and only look at enableds
.ToArray();
return(collidables);
}
public void AddBlock(int rand)
{
if (hasLost())
{
return;
}
TetrisSet.Type type;
if (rand == 0)
{
type = TetrisSet.Type.T1x5;
}
else if (rand == 1)
{
type = TetrisSet.Type.T2x2;
}
else
{
type = TetrisSet.Type.T2x3;
}
Vector2 position = new Vector2(random.Next(Convert.ToInt32(floor.getPosition().X - floor.getSize().X / 2), Convert.ToInt32(floor.getPosition().X + floor.getSize().X / 2)), 1);
int rotation = new Random((int)this.position.X).Next(0, 360);
IPhysicsObject block = new TetrisObject(world, type, position, rotation);
currentBlock = block;
blocks.Add(block);
}
public void ModifyPhysicsObject(IPhysicsObject physObj, Matrix newTransform)
{
if (!objectIDs.ContainsKey(physObj))
{
return;
}
}
private void OnShockwaveReachesObject(IPhysicsObject obj, Vector swForce)
{
if (ShockwaveReachesObject != null)
{
ShockwaveReachesObject(obj, swForce);
}
}
// TODO tämä saattaa olla turha jäänne, siivoa mikäli ongelmia ei ilmene (13.5.2018)
///// <summary>
///// Kutsutaan kun olio lisätään peliin.
///// </summary>
//public void OnAddedToGame()
//{
// if (AddedToGame != null)
// AddedToGame();
//}
/// <summary>
/// Kutsutaan kun törmätään.
/// </summary>
internal void OnCollided(IPhysicsObject part, IPhysicsObject target)
{
if (Collided != null)
{
Collided(this, target);
}
}
public CollisionRecord(IPhysicsObject obj, IPhysicsObject target, object targetTag, Delegate handler)
{
this.obj = obj;
this.target = target;
this.targetTag = targetTag;
this.handler = handler;
}
public void Update(GameTime gameTime, IPhysicsObject physicsObject)
{
float elapsed = gameTime.GetElapsedSeconds();
if (!physicsObject.PhysicsEnabled)
{
return;
}
Vector2 totalAcceleration;
if (physicsObject.GravityEnabled)
{
totalAcceleration = new Vector2(Gravity.X + physicsObject.Acceleration.X, Gravity.Y + physicsObject.Acceleration.Y);
}
else
{
totalAcceleration = physicsObject.Acceleration;
}
float newVelocityX = physicsObject.Velocity.X + totalAcceleration.X * elapsed;
float newVelocityY = physicsObject.Velocity.Y + totalAcceleration.Y * elapsed;
physicsObject.Velocity = new Vector2(newVelocityX, newVelocityY);
physicsObject.Position = new Vector2(physicsObject.Position.X + physicsObject.Velocity.X * elapsed,
physicsObject.Position.Y + physicsObject.Velocity.Y * elapsed);
}
/// <summary>
/// Aliohjelma joka käsittelee pelaajan törmäyksen oikeat kuvat sisältävän
/// fysiikkaolion kanssa: kasvattaa pelaajan pisteitä yhdellä
/// </summary>
/// <param name="pelaaja">pelaaja joka törmää</param>
/// <param name="kirjain">kirjain johon pelaaja törmää</param>
void KirjainPoimittu(IPhysicsObject pelaaja, IPhysicsObject kirjain)
{
pelaajanPisteet.Value++;
kirjain.Destroy();
if (pelaajanPisteet.Value == kenttienOikeatKerattavat[tasoMissaOllaan].Length)
{
MultiSelectWindow valintaIkkuna =
new MultiSelectWindow("Correct! The word was indeed "
+ kenttaSanat[tasoMissaOllaan] + ". Click OK to move forward", "OK");
valintaIkkuna.ItemSelected += new Action <int>(KenttaValiStop);
IsMouseVisible = true;
Add(valintaIkkuna);
foreach (PhysicsObject apuope in apuopeLista)
{
Explosion rajahdys = new Explosion(300);
rajahdys.Position = apuope.Position;
Add(rajahdys);
apuope.Destroy();
}
foreach (PhysicsObject kerattavaKama in kerattavaKamaLista)
{
Explosion rajahdys = new Explosion(50);
rajahdys.Position = kerattavaKama.Position;
Add(rajahdys);
kerattavaKama.Destroy();
}
tasoMissaOllaan++;
}
}
public void ClearParticle(IPhysicsObject p)
{
if (registry.ContainsKey(p))
{
registry.Remove(p);
}
}
public void updateForce(IPhysicsObject forceTarget, GameTime gameTime)
{
// Allow target to go to sleep
if (forceTarget.Awake)
{
Vector3 appliedForce = Force * forceTarget.Mass;
Forever.Interface.ICollideable bodyHaver = forceTarget as ICollideable;
Forever.Physics.Collide.Primitive prim = bodyHaver.GeometryData.Prim;
if (prim is Forever.Physics.Collide.Box)
{
Forever.Physics.Collide.Box box = prim as Forever.Physics.Collide.Box;
Vector3 totalForce = appliedForce;
float oldMag = totalForce.Length();
totalForce.Normalize();
float newMag = (oldMag/8f);
totalForce *= newMag;
foreach (Vector3 corner in box.WorldVerts())
{
forceTarget.addForce(totalForce, corner);
}
}
else
{
forceTarget.addForce(appliedForce);
}
}
}
public void prucall(IPhysicsObject physObj1, IPhysicsObject physObj2)
{
Vector3 vel = physObj1.InitialLinearVelocity;
Vector3 vel2 = physObj2.InitialLinearVelocity;
Notifier.AddMessage("Aquiiiiiii");
}
private static Vector GetNormal(IPhysicsObject physicsObject1, double X, double Y, double Vx, double Vy, double time)
{
var dx = physicsObject1.X + (time * physicsObject1.Vx) - (X + (time * Vx));
var dy = physicsObject1.Y + (time * physicsObject1.Vy) - (Y + (time * Vy));
var normal = new Vector(dx, dy).NewUnitized();
return(normal);
}
public static RaycastHit[] RadialCast(IPhysicsObject geom, float dist, int detail, int layerMask, Vector3 initialAxis, Vector3 rotationalAxis, QueryTriggerInteraction query = QueryTriggerInteraction.UseGlobal)
{
using (var lst = TempCollection.GetList <RaycastHit>())
{
RadialCast(geom, lst, dist, detail, layerMask, initialAxis, rotationalAxis, query);
return(lst.ToArray());
}
}
public static void Move(IPhysicsObject obj, GameTime gameTime)
{
Vector2 cp = Vector2.Zero;
Vector2 cn = Vector2.Zero;
float ct = 0, min_t = float.PositiveInfinity;
List <Tuple <int, float> > z = new List <Tuple <int, float> >();
for (int i = 0; i < LevelManager.CollisionBoxes.Count; i++)
{
if (CollsionDetector.DynamicRectVsRect(obj, (float)gameTime.ElapsedGameTime.TotalSeconds, LevelManager.CollisionBoxes[i], ref cp, ref cn, ref ct))
{
z.Add(new Tuple <int, float>(i, ct));
if (LevelManager.CollisionBoxes[i] is IDamageable && obj is IDamageable)
{
var damageAbleObj = obj as IDamageable;
var damageAbleBox = LevelManager.CollisionBoxes[i] as IDamageable;
damageAbleObj.Damage(damageAbleBox.DamageToDeal);
damageAbleBox.Damage(damageAbleObj.DamageToDeal);
}
}
}
z.Sort((x, y) => x.Item2.CompareTo(y.Item2));
foreach (Tuple <int, float> j in z)
{
if (LevelManager.CollisionBoxes[j.Item1] is Portal)
{
var portal = LevelManager.CollisionBoxes[j.Item1] as Portal;
switch (portal.GetToLevel())
{
case "Level1":
LevelManager.SetLevel(LevelName.Level1);
break;
case "Level2":
LevelManager.SetLevel(LevelName.Level2);
break;
case "Level3":
LevelManager.SetLevel(LevelName.Level3);
break;
}
if (obj is IDamageable)
{
var objAsDamageAble = obj as IDamageable;
objAsDamageAble.Health = 0;
}
break;
}
CollsionDetector.ResolveDynamicRectVsRect(obj, (float)gameTime.ElapsedGameTime.TotalSeconds, LevelManager.CollisionBoxes[j.Item1]);
}
obj.Position += obj.Velocity * new Vector2((float)gameTime.ElapsedGameTime.TotalSeconds, (float)gameTime.ElapsedGameTime.TotalSeconds);
}
protected virtual IPhysicsObject CreatePhysicsObject(Scene s)
{
IPhysicsObject obj = s.Physics.CreateObjectBox(1, 2, 2, 2);
obj.Position = base.Position;
obj.Speed = base.Speed;
obj.Orientation = base.Orientation;
return(obj);
}
public void SetTransform(IPhysicsObject physObj, Matrix transform)
{
if (objectIDs.ContainsKey(physObj))
{
MataliPhysicsObject mataliObj = objectIDs[physObj];
mataliObj.MainWorldTransform.SetTransformMatrix(transform);
mataliObj.RecalculateMainTransform();
}
}
/// <summary>
/// Apualiohjelma vihollisen räjäyttämiseksi ja poistamiseksi
/// </summary>
/// <param name="vihu"></param>
private void PossautaVihu(IPhysicsObject vihu)
{
Explosion rajahdys = new Explosion(vihu.Width * 10);
rajahdys.Position = vihu.Position;
rajahdys.UseShockWave = false;
Add(rajahdys);
Remove(vihu);
}
public void updateForce(IPhysicsObject forceTarget, GameTime gameTime)
{
Vector3 dir = BodyToFollow.Position - forceTarget.CenterOfMass;
dir.Normalize();
dir *= ForceMag;
forceTarget.addForce(dir);
}
public void SetPosition(IPhysicsObject physObj, Vector3 position)
{
if (objectIDs.ContainsKey(physObj))
{
MataliPhysicsObject mataliObj = objectIDs[physObj];
mataliObj.MainWorldTransform.SetPosition(position);
mataliObj.RecalculateMainTransform();
}
}
public void SetRotation(IPhysicsObject physObj, Quaternion rotation)
{
if (objectIDs.ContainsKey(physObj))
{
MataliPhysicsObject mataliObj = objectIDs[physObj];
mataliObj.MainWorldTransform.SetRotation(Matrix.CreateFromQuaternion(rotation));
mataliObj.RecalculateMainTransform();
}
}
/// <summary>
/// Remove all applied forces from an object
/// </summary>
/// <param name="component">Physics object on wich remove the forces</param>
public void RemoveAll(IPhysicsObject component)
{
List <ForceRegistration> registrationToDelete = registrations.Where(w => w.physicsComponent == component).ToList();
for (int i = 0; i < registrationToDelete.Count; i++)
{
registrations.Remove(registrationToDelete[i]);
}
}
public void SetAngularVelocity(IPhysicsObject physObj, Vector3 velocity)
{
if (!objectIDs.ContainsKey(physObj))
{
return;
}
HavokDllBridge.set_angular_velocity(objectIDs[physObj], Vector3Helper.ToFloats(velocity));
}
public void Remove(IPhysicsObject p, IForceGenerator forceGen)
{
List<IForceGenerator> list;
if (registry.ContainsKey(p))
{
list = registry[p];
list.Remove(forceGen);
}
}
public void AddTorque(IPhysicsObject physObj, float timeStep, Vector3 torque)
{
if (!objectIDs.ContainsKey(physObj))
{
return;
}
HavokDllBridge.add_torque(objectIDs[physObj], timeStep, Vector3Helper.ToFloats(torque));
}
public void Clear()
{
IPhysicsObject[] keys = new IPhysicsObject[registry.Keys.Count];
registry.Keys.CopyTo(keys, 0);
for (int i = 0; i < registry.Keys.Count; i++)
{
registry[keys[i]].Clear();
}
registry.Clear();
}
/// <summary>
/// Creates a pair of objects for detecting the collision event between these two objects
/// </summary>
/// <param name="colObj1"></param>
/// <param name="colObj2"></param>
public CollisionPair(IPhysicsObject colObj1, IPhysicsObject colObj2)
{
this.colObj1 = colObj1;
this.colObj2 = colObj2;
maxSize = 1;
normals = new List<Vector3>();
contacts = new List<Vector3>();
penetration = new List<float>();
contactPoints = 0;
}
public void Add(IPhysicsObject p, IForceGenerator forceGen)
{
List<IForceGenerator> list;
if (registry.ContainsKey(p))
{
list = registry[p];
}
else
{
registry[p] = list = new List<IForceGenerator>();
}
list.Add(forceGen);
}
public void UpdateForceGenerators(IPhysicsObject p, GameTime gameTime)
{
if (registry.ContainsKey(p))
{
int size = registry[p].Count;
IForceGenerator[] list = new IForceGenerator[size];
registry[p].CopyTo(list, 0);
for (int i = 0; i < size; i++)
{
list[i].updateForce(p, gameTime);
}
}
}
void AsetaNopeus(IPhysicsObject maila, Vector nopeus)
{
if ((nopeus.Y < 0) && (maila.Bottom < Level.Bottom))
{
maila.Velocity = Vector.Zero;
return;
}
if ((nopeus.Y > 0) && (maila.Top > Level.Top))
{
maila.Velocity = Vector.Zero;
return;
}
maila.Velocity = nopeus;
}
/// <summary>
/// Tippuvan blockin törmäys-event
/// </summary>
/// <param name="self">DroppingBlock joka törmäsi</param>
/// <param name="target">Block johon törmättiin</param>
public static void DroppingBlockCollided(IPhysicsObject self, IPhysicsObject target)
{
if ((self as DroppingBlock).IsMoving)
{
if (target is PlayerBlock)// || target is ExplodingBlock)
{
List<GameObject> list = GetImmediateSurroundings(self as Block, target as Block);
list.ForEach(x => { Block y = x as Block; y.TryExplode(); });
}
else if (target is ExplodingBlock)
{
(target as ExplodingBlock).ExplodingDroppingBlockCollided(target, self);
}
}
}
/// <summary>
/// Räjähtävän blockin törmäys-event
/// </summary>
/// <param name="self">ExplodingBlock joka törmäsi</param>
/// <param name="target">Block johon törmättiin</param>
public void ExplodingDroppingBlockCollided(IPhysicsObject self, IPhysicsObject target)
{
Debug.Print("ExplodingBlock at " + self.Position + " collided with obj at " + target.Position);
Explosion expl = new Explosion(80);
//rajahdys.Sound = LoadSoundEffect("implosionSound"); // todo: fix sounds
expl.Force = 0;
expl.ShockwaveColor = Color.LightBlue;
expl.Position = Vector.Average(new List<Vector> { self.Position, target.Position });
List<GameObject> list = new List<GameObject>();
if (target is PlayerBlock)
{
list = GetImmediateSurroundings(self as Block, target as Block);
}
else
{
list = GetImmediateSurroundings(self as Block);
}
list.ForEach(x => { Block y = x as Block; y.TryExplode(); });
Peli.Instance.Add(expl);
}
private IntPtr GetCollisionShape(IPhysicsObject physObj, Vector3 scale)
{
IntPtr collisionShape = IntPtr.Zero;
Vector3 boundingBox = Vector3Helper.GetDimensions(physObj.Model.MinimumBoundingBox);
float[] dim = new float[3];
float[] top = new float[3];
float[] bottom = new float[3];
float[] vertexCloud = null;
float radius = 0;
float height = 0;
float convexRadius = 0.05f;
if (physObj is HavokObject)
convexRadius = ((HavokObject)physObj).ConvexRadius;
switch (physObj.Shape)
{
case ShapeType.Box:
if (physObj.ShapeData.Count == 3)
{
dim[0] = physObj.ShapeData[0];
dim[1] = physObj.ShapeData[1];
dim[2] = physObj.ShapeData[2];
}
else
{
dim[0] = boundingBox.X * scale.X;
dim[1] = boundingBox.Y * scale.Y;
dim[2] = boundingBox.Z * scale.Z;
}
collisionShape = HavokDllBridge.create_box_shape(dim, convexRadius);
break;
case ShapeType.Sphere:
if (physObj.ShapeData.Count == 1)
radius = physObj.ShapeData[0];
else
radius = boundingBox.X * scale.X / 2;
collisionShape = HavokDllBridge.create_sphere_shape(radius);
break;
case ShapeType.Capsule:
case ShapeType.Cylinder:
if (physObj.ShapeData.Count == 2)
{
radius = physObj.ShapeData[0];
height = physObj.ShapeData[1];
}
else
{
radius = boundingBox.X * scale.X / 2;
height = boundingBox.Y * scale.Y;
}
if (physObj.Shape == ShapeType.Capsule)
{
top[1] = height / 2 - radius;
bottom[1] = -height / 2 + radius;
collisionShape = HavokDllBridge.create_capsule_shape(top, bottom, radius);
}
else
{
top[1] = height / 2;
bottom[1] = -height / 2;
collisionShape = HavokDllBridge.create_cylinder_shape(top, bottom, radius, convexRadius);
}
break;
case ShapeType.Cone:
throw new GoblinException("Cone shape is not supported by Havok physics");
case ShapeType.ChamferCylinder:
throw new GoblinException("ChamferCylinder is not supported by Havok physics");
case ShapeType.ConvexHull:
List<Vector3> vertices = physObj.MeshProvider.Vertices;
vertexCloud = new float[vertices.Count * 3];
for (int i = 0; i < vertices.Count; i++)
{
vertexCloud[i * 3] = vertices[i].X * scale.X;
vertexCloud[i * 3 + 1] = vertices[i].Y * scale.Y;
vertexCloud[i * 3 + 2] = vertices[i].Z * scale.Z;
}
collisionShape = HavokDllBridge.create_convex_shape(vertices.Count, vertexCloud,
sizeof(float) * 3, convexRadius);
break;
case ShapeType.TriangleMesh:
if(physObj.MeshProvider == null)
throw new GoblinException("MeshProvider cannot be null to construct TriangleMesh shape");
List<int> indices = physObj.MeshProvider.Indices;
vertices = physObj.MeshProvider.Vertices;
vertexCloud = new float[vertices.Count * 3];
for (int i = 0; i < vertices.Count; i++)
{
vertexCloud[i * 3] = vertices[i].X * scale.X;
vertexCloud[i * 3 + 1] = vertices[i].Y * scale.Y;
vertexCloud[i * 3 + 2] = vertices[i].Z * scale.Z;
}
collisionShape = HavokDllBridge.create_mesh_shape(vertices.Count, vertexCloud,
sizeof(float) * 3, indices.Count / 3, indices.ToArray(), convexRadius);
break;
case ShapeType.Compound:
break;
}
if (physObj is HavokObject)
{
if (((HavokObject)physObj).IsPhantom)
{
collisionShape = HavokDllBridge.create_phantom_shape(collisionShape,
((HavokObject)physObj).PhantomEnterCallback,
((HavokObject)physObj).PhantomLeaveCallback);
}
}
return collisionShape;
}
public Quaternion GetRotation(IPhysicsObject physObj)
{
if (!objectIDs.ContainsKey(physObj))
return Quaternion.Identity;
float[] rotation = new float[4];
HavokDllBridge.get_body_rotation(objectIDs[physObj], rotation);
return new Quaternion(rotation[0], rotation[1], rotation[2], rotation[3]);
}
public Vector3 GetPosition(IPhysicsObject physObj)
{
if (!objectIDs.ContainsKey(physObj))
return Vector3.Zero;
float[] position = new float[3];
HavokDllBridge.get_body_position(objectIDs[physObj], position);
return Vector3Helper.FromFloats(position);
}
public Matrix GetTransform(IPhysicsObject physObj)
{
if (!objectIDs.ContainsKey(physObj))
return Matrix.Identity;
float[] transform = new float[16];
HavokDllBridge.get_body_transform(objectIDs[physObj], transform);
return MatrixHelper.FloatsToMatrix(transform);
}
public Vector3 GetAngularVelocity(IPhysicsObject physObj)
{
if (!objectIDs.ContainsKey(physObj))
return Vector3.Zero;
float[] velocity = new float[3];
HavokDllBridge.get_angular_velocity(objectIDs[physObj], velocity);
return new Vector3(velocity[0], velocity[1], velocity[2]);
}
public void SetAngularVelocity(IPhysicsObject physObj, Vector3 velocity)
{
if (!objectIDs.ContainsKey(physObj))
return;
HavokDllBridge.set_angular_velocity(objectIDs[physObj], Vector3Helper.ToFloats(velocity));
}
public BoundingBox GetAxisAlignedBoundingBox(IPhysicsObject physObj)
{
if (!objectIDs.ContainsKey(physObj))
return new BoundingBox();
float[] min = new float[3];
float[] max = new float[3];
HavokDllBridge.get_AABB(objectIDs[physObj], min, max);
Vector3Helper.FromFloats(min, out tmpVec1);
Vector3Helper.FromFloats(max, out tmpVec2);
return new BoundingBox(tmpVec1, tmpVec2);
}
public void StopKeyframe(IPhysicsObject physObj)
{
if (!objectIDs.ContainsKey(physObj))
return;
Vector3 scale, trans;
Quaternion quat;
physObj.PhysicsWorldTransform.Decompose(out scale, out quat, out trans);
float[] pos = Vector3Helper.ToFloats(ref trans);
float[] rot = { quat.X, quat.Y, quat.Z, quat.W };
HavokDllBridge.apply_hard_keyframe(objectIDs[physObj], pos, rot, 0.016f);
}
public void ApplySoftKeyFrame(IPhysicsObject physObj, Vector3 newPos, Quaternion newRot,
Vector3 angularPositionFactor, Vector3 angularVelocityFactor, Vector3 linearPositionFactor,
Vector3 linearVelocityFactor, float maxAngularAcceleration, float maxLinearAcceleration,
float maxAllowedDistance, float timeStep)
{
if (!objectIDs.ContainsKey(physObj))
return;
float[] pos = Vector3Helper.ToFloats(ref newPos);
float[] rot = { newRot.X, newRot.Y, newRot.Z, newRot.W };
float[] angularPosFac = Vector3Helper.ToFloats(ref angularPositionFactor);
float[] angularVelFac = Vector3Helper.ToFloats(ref angularVelocityFactor);
float[] linearPosFac = Vector3Helper.ToFloats(ref linearPositionFactor);
float[] linearVelFac = Vector3Helper.ToFloats(ref linearVelocityFactor);
HavokDllBridge.apply_soft_keyframe(objectIDs[physObj], pos, rot, angularPosFac,
angularVelFac, linearPosFac, linearVelFac, maxAngularAcceleration,
maxLinearAcceleration, maxAllowedDistance, timeStep);
}
public void ApplyHardKeyFrame(IPhysicsObject physObj, Vector3 newPos, Quaternion newRot, float timeStep)
{
if (!objectIDs.ContainsKey(physObj))
return;
float[] pos = Vector3Helper.ToFloats(ref newPos);
float[] rot = { newRot.X, newRot.Y, newRot.Z, newRot.W };
HavokDllBridge.apply_hard_keyframe(objectIDs[physObj], pos, rot, timeStep);
}
public void ApplyKeyframe(IPhysicsObject physObj, Vector3 newPos, Quaternion newRot, float timeStep)
{
ApplyHardKeyFrame(physObj, newPos, newRot, timeStep);
}
/// <summary>
/// Not implemented yet.
/// </summary>
/// <param name="physObj"></param>
/// <param name="newTransform"></param>
public void ModifyPhysicsObject(IPhysicsObject physObj, Matrix newTransform)
{
}
public List<List<Vector3>> GetCollisionMesh(IPhysicsObject physObj)
{
throw new GoblinException("Havok physics does not return collision mesh information");
}
public void puercavida(IPhysicsObject physObj1, IPhysicsObject physObj2)
{
//Busco el Objeto Bala
Vector3 VelBullet;
Vector3 VelCar;
Vector3 Difvel;
if (physObj2.MaterialName == "Bullet")
{
VelBullet = ((NewtonPhysics)scene.PhysicsEngine).GetVelocity(physObj2);
VelCar = ((NewtonPhysics)scene.PhysicsEngine).GetVelocity(physObj1);
}
else
{
VelBullet = ((NewtonPhysics)scene.PhysicsEngine).GetVelocity(physObj1);
VelCar = ((NewtonPhysics)scene.PhysicsEngine).GetVelocity(physObj2);
}
Difvel = VelBullet - VelCar;
float Dilivel = Difvel.LengthSquared();
float Vel1 = VelBullet.LengthSquared();
float vel2 = VelCar.LengthSquared();
if (Dilivel > 50)
{
if(Vel1 > 90)
Notifier.AddMessage("Disparo");
else
Notifier.AddMessage("Choque");
}
//if (VelBullet.LengthSquared() > 3.0f)
//{
// Notifier.AddMessage("Disparo");
//}
//else
//{
// if(VelCar.LengthSquared() > 3.0f)
// Notifier.AddMessage("Choque");
//}
}
public void AddTorque(IPhysicsObject physObj, float timeStep, Vector3 torque)
{
if (!objectIDs.ContainsKey(physObj))
return;
HavokDllBridge.add_torque(objectIDs[physObj], timeStep, Vector3Helper.ToFloats(torque));
}
public void RemovePhysicsObject(IPhysicsObject physObj)
{
if (objectIDs.ContainsKey(physObj))
{
HavokDllBridge.remove_rigid_body(objectIDs[physObj]);
reverseIDs.Remove(objectIDs[physObj]);
scaleTable.Remove(objectIDs[physObj]);
objectIDs.Remove(physObj);
}
}
public void AddPhysicsObject(IPhysicsObject physObj)
{
if (objectIDs.ContainsKey(physObj))
return;
physObj.PhysicsWorldTransform = physObj.CompoundInitialWorldTransform;
HavokPhysics.MotionType motionType = MotionType.MOTION_INVALID;
HavokPhysics.CollidableQualityType qualityType =
CollidableQualityType.COLLIDABLE_QUALITY_INVALID;
float friction = -1;
float restitution = -1;
float maxLinearVelocity = -1;
float maxAngularVelocity = -1;
float allowedPenetrationDepth = -1;
float gravityFactor = 1;
if ((physObj is HavokObject))
{
HavokObject havokObj = (HavokObject)physObj;
motionType = havokObj.MotionType;
qualityType = havokObj.QualityType;
friction = havokObj.Friction;
restitution = havokObj.Restitution;
maxLinearVelocity = havokObj.MaxLinearVelocity;
maxAngularVelocity = havokObj.MaxAngularVelocity;
allowedPenetrationDepth = havokObj.AllowedPenetrationDepth;
gravityFactor = havokObj.GravityFactor;
}
else
{
bool isDynamic = (physObj.Mass != 0.0f && physObj.Interactable);
if (isDynamic)
motionType = MotionType.MOTION_DYNAMIC;
else
motionType = MotionType.MOTION_FIXED;
}
Quaternion rotation;
Vector3 trans;
Vector3 scale;
physObj.CompoundInitialWorldTransform.Decompose(out scale, out rotation, out trans);
IntPtr shape = GetCollisionShape(physObj, scale);
float[] pos = Vector3Helper.ToFloats(ref trans);
float[] rot = { rotation.X, rotation.Y, rotation.Z, rotation.W };
IntPtr body = HavokDllBridge.add_rigid_body(shape, physObj.Mass, motionType, qualityType,
pos, rot, Vector3Helper.ToFloats(physObj.InitialLinearVelocity), physObj.LinearDamping,
maxLinearVelocity, Vector3Helper.ToFloats(physObj.InitialAngularVelocity),
physObj.AngularDamping.X, maxAngularVelocity, friction, restitution,
allowedPenetrationDepth, physObj.NeverDeactivate, gravityFactor);
objectIDs.Add(physObj, body);
reverseIDs.Add(body, physObj);
scaleTable.Add(body, scale);
if ((physObj is HavokObject))
{
if (((HavokObject)physObj).ContactCallback != null ||
((HavokObject)physObj).CollisionStartCallback != null ||
((HavokObject)physObj).CollisionEndCallback != null)
HavokDllBridge.add_contact_listener(body, ((HavokObject)physObj).ContactCallback,
((HavokObject)physObj).CollisionStartCallback,
((HavokObject)physObj).CollisionEndCallback);
}
}
