private static HashSet <TilePos> objectTiles(ICollisionObject obj)
{
switch (obj.Type)
{
case CollisionObjectType.Circle:
CollisionCircle circle = obj as CollisionCircle;
return(tilesByPosition(circle.Center.X - circle.Radius, circle.Center.Y - circle.Radius,
circle.Center.X + circle.Radius, circle.Center.Y + circle.Radius));
case CollisionObjectType.Rect:
CollisionRect rect = obj as CollisionRect;
Vector min = new Vector(double.MaxValue);
Vector max = new Vector(double.MinValue);
foreach (Vector point in rect.Points)
{
min.set(Math.Min(point.X, min.X), Math.Min(point.Y, min.Y));
max.set(Math.Max(point.X, max.X), Math.Max(point.Y, max.Y));
}
return(tilesByPosition(min.X, min.Y, max.X, max.Y));
}
;
return(new HashSet <TilePos>());
}
/// <summary>
/// A function used to indicate that a GameObject should check collisions with the BackgroundObjects and other GameObjects
/// </summary>
/// <param name="collisionObject"></param>
protected void AddCollisionObject(ICollisionObject collisionObject)
{
//Debug.Assert(collisionObject.UsesCollider);
//DebugUtils.AssertNotNull(collisionObject.PhysicsBody);
CollisionObjects.Add(collisionObject);
}
public void NotifyOfCollision(ICollisionObject otherObject)
{
if (otherObject is Cow)
{
remove();
}
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="collisionObject">The ParentObject this instance will be associated with</param>
/// <param name="vertices">The Model vertices used to compute the BEPUPgysics StaticMesh</param>
/// <param name="indices">The Model indices used to compute the BEPUPgysics StaticMesh</param>
public StaticMeshCollisionMove(ICollisionObject collisionObject, Vector3[] vertices, int[] indices)
: base(collisionObject)
{
ParentObject.World.Decompose(out _collisionObjectScale, out _collisionObjectRotation, out _collisionObjectTranslation);
SpaceObject = new StaticMesh(vertices, indices, new AffineTransform(_collisionObjectScale, _collisionObjectRotation, _collisionObjectTranslation));
}
/// <summary>
/// Executes collision between two bodies
/// </summary>
/// <param name="body1"></param>
/// <param name="body2"></param>
/// <param name="removePair"></param>
/// <returns></returns>
protected bool Test(ICollisionObject body1, ICollisionObject body2, bool removePair = true)
{
var result = new CollisionResult();
var paired = FindCollisionPair(body1, body2, removePair);
if (TestCollisionShapes(body1.CollisionShape, body2.CollisionShape, ref result))
{
result.Type = paired ? CollisionType.Stay : CollisionType.Enter;
CacheCollisionPair(body1, body2);
body2.OnCollision(result, body1);
result.Normal *= -1;
result.First = true;
body1.OnCollision(result, body2);
return(true);
}
else
{
if (paired)
{
result.Type = CollisionType.Exit;
body2.OnCollision(result, body1);
result.Normal *= -1;
result.First = true;
body1.OnCollision(result, body2);
return(true);
}
}
return(false);
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="collisionObject">The ParentObject this instance will be associated with</param>
/// <param name="vertices">The Model vertices used to compute the BEPUPgysics StaticMesh</param>
/// <param name="indices">The Model indices used to compute the BEPUPgysics StaticMesh</param>
public StaticMeshCollisionMove(ICollisionObject collisionObject, Vector3[] vertices, int[] indices)
: base(collisionObject)
{
ParentObject.World.Decompose(out _collisionObjectScale, out _collisionObjectRotation, out _collisionObjectTranslation);
SpaceObject = new StaticMesh(vertices, indices, new AffineTransform(_collisionObjectScale, _collisionObjectRotation, _collisionObjectTranslation));
}
///Other
private List <ICollisionObject> objectsByTilesAndEdgesInfo(Dictionary <TilePos, TileDir[]> tilesInfo)
{
CollisionRect carRect = new CollisionRect(car);
List <ICollisionObject> result = new List <ICollisionObject>();
if (null != tilesInfo)
{
foreach (TilePos pos in tilesInfo.Keys)
{
foreach (TileDir dir in tilesInfo[pos])
{
ICollisionObject obj = null;
if (dir.Correct())
{
obj = new CollisionSide(pos, dir);
}
else
{
obj = new CollisionCircle(pos, dir);
}
if (null == CollisionDetector.CheckCollision(carRect, obj))
{
result.Add(obj);
}
}
}
}
return(result);
}
public static CollisionInfo CheckCollision(ICollisionObject obj, ICollisionObject obj2)
{
CollisionInfo info = new CollisionInfo(obj, obj2);
if (CheckCollision(info))
{
return(info);
}
return(null);
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="collisionObject">The ParentObject this instance will be associated with</param>
/// <param name="model">The Model used to compute the BEPUPgysics StaticMesh</param>
public StaticMeshCollisionMove(ICollisionObject collisionObject, Model model) : base(collisionObject)
{
Vector3[] vertices;
int[] indices;
TriangleMesh.GetVerticesAndIndicesFromModel(model, out vertices, out indices);
ParentObject.World.Decompose(out _collisionObjectScale, out _collisionObjectRotation, out _collisionObjectTranslation);
SpaceObject = new StaticMesh(vertices, indices, new AffineTransform(_collisionObjectScale, _collisionObjectRotation, _collisionObjectTranslation));
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="collisionObject">The ParentObject this instance will be associated with</param>
/// <param name="model">The Model used to compute the BEPUPgysics StaticMesh</param>
public StaticMeshCollisionMove(ICollisionObject collisionObject, Model model) : base(collisionObject)
{
Vector3[] vertices;
int[] indices;
TriangleMesh.GetVerticesAndIndicesFromModel(model, out vertices, out indices);
ParentObject.World.Decompose(out _collisionObjectScale, out _collisionObjectRotation, out _collisionObjectTranslation);
SpaceObject = new StaticMesh(vertices, indices, new AffineTransform(_collisionObjectScale, _collisionObjectRotation, _collisionObjectTranslation));
}
/// <summary>
/// Adds a body to the CollisionSystem
/// </summary>
/// <param name="body"></param>
/// <returns></returns>
public virtual bool AddBody(ICollisionObject body)
{
if (!bodyList.Contains(body) && bodyList.Count < MaxCollisionBodies)
{
body.RefId = _uniqueIndex;
_uniqueIndex++;
bodyList.Add(body);
return(true);
}
return(false);
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="collisionObject">The ParentObject this instance will be associated with</param>
/// <param name="model">The Model used to compute the ConvexHull shape used for collision & physics</param>
/// <remarks>If a previously created instance uses the same Model as the one provided here, it will reuse the computed ConvexHull instance to save CPU</remarks>
public ConvexHullCollisionMove(ICollisionObject collisionObject, Model model) : base(collisionObject)
{
ModelReferencesToDelete.Clear();
foreach (var modelConvexHull in ModelConvexHulls)
{
if (!modelConvexHull.Key.IsAlive)
{
ModelReferencesToDelete.Add(modelConvexHull.Key);
}
else if (modelConvexHull.Key.Target == model)
{
ConvexHull convexHull = modelConvexHull.Value;
TransformableShape shape = new TransformableShape(convexHull.CollisionInformation.Shape, Matrix3X3.CreateFromMatrix(ParentObject.World));
SpaceObject = new Entity <ConvexCollidable <TransformableShape> >(
new ConvexCollidable <TransformableShape>(shape),
ParentObject.Mass,
convexHull.LocalInertiaTensor,
convexHull.Volume);
Entity.Position = ParentObject.World.Translation;
}
}
foreach (var modelReference in ModelReferencesToDelete)
{
ModelConvexHulls.Remove(modelReference);
}
if (SpaceObject == null)
{
Vector3[] vertices;
int[] indices;
TriangleMesh.GetVerticesAndIndicesFromModel(model, out vertices, out indices);
var modelReference = new WeakReference(model);
var convexHull = new ConvexHull(vertices, ParentObject.Mass);
ModelConvexHulls.Add(modelReference, convexHull);
TransformableShape shape = new TransformableShape(convexHull.CollisionInformation.Shape, Matrix3X3.CreateFromMatrix(ParentObject.World));
SpaceObject = new Entity <ConvexCollidable <TransformableShape> >(
new ConvexCollidable <TransformableShape>(shape),
ParentObject.Mass,
convexHull.LocalInertiaTensor,
convexHull.Volume);
Entity.Position = ParentObject.World.Translation;
}
ParentObject.World.GetScaleComponent(out CollisionObjectScale);
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="collisionObject">The ParentObject this instance will be associated with</param>
public BoxCollisionMove(ICollisionObject collisionObject)
: base(collisionObject)
{
ParentObject.World.GetScaleComponent(out CollisionObjectScale);
SpaceObject = new Box(
ParentObject.World.Translation,
(ParentObject.ObjectBoundingBox.Max.X - ParentObject.ObjectBoundingBox.Min.X) * CollisionObjectScale.X,
(ParentObject.ObjectBoundingBox.Max.Y - ParentObject.ObjectBoundingBox.Min.Y) * CollisionObjectScale.Y,
(ParentObject.ObjectBoundingBox.Max.Z - ParentObject.ObjectBoundingBox.Min.Z) * CollisionObjectScale.Z,
ParentObject.Mass);
}
public static bool isCollision(ICollisionObject rect1, ICollisionObject rect2)
{
if (rect1.position.X < rect2.position.X + rect2.size.X &&
rect1.position.X + rect1.size.X > rect2.position.X &&
rect1.position.Y < rect2.position.Y + rect2.size.Y &&
rect1.size.Y + rect1.position.Y > rect2.position.Y)
{
return(true);
}
return(false);
}
public static List <CollisionInfo> CollisionsWithMap(ICollisionObject obj)
{
HashSet <TilePos> tiles = objectTiles(obj);
List <ICollisionObject> checkObjects = new List <ICollisionObject>();
foreach (TilePos tile in tiles)
{
checkObjects.AddRange(MapObjects(tile));
}
return(CheckCollision(obj, checkObjects));
}
private bool FindCollisionPair(ICollisionObject a, ICollisionObject b, bool remove = true)
{
var idx = a.RefId * (MaxCollisionBodies + 1) + b.RefId;
if (remove)
{
return(_pairs.Remove(idx));
}
else
{
return(_pairs.Contains(idx));
}
}
public void OnCollision(CollisionResult result, ICollisionObject other)
{
_gizmoColor = result.Type == CollisionType.Exit ? Color.green : Color.red;
if (result.Type == CollisionType.Enter)
{
life--;
if (life == 0)
{
gameObject.SetActive(false);
numberofhide++;
}
}
}
private void Start()
{
m_clothParticleObjects = GetComponentsInChildren <ClothParticleObject>();
ClothParticleConstraints[] clothParticleConstraints = GetComponentsInChildren <ClothParticleConstraints>();
ParticleClothSettings particleSettings = new ParticleClothSettings();
ParticleData[] particleDatas = new ParticleData[m_clothParticleObjects.Length];
Stack <ConstraintData> constraintDatas = new Stack <ConstraintData>();
for (int i = 0; i < m_clothParticleObjects.Length; i++)
{
ClothParticleObject obj = m_clothParticleObjects[i];
obj.Index = i;
particleDatas[i] = obj.ToParticleData();
}
for (int i = 0; i < clothParticleConstraints.Length; i++)
{
ClothParticleConstraints obj = clothParticleConstraints[i];
int indexA = obj.GetComponent <ClothParticleObject>().Index;
for (int j = 0; j < obj.OtherClothParticles.Length; j++)
{
if (obj.ValidConnection(j))
{
ClothParticleObject other = obj.OtherClothParticles[j];
ConstraintData constraintData = new ConstraintData();
constraintData.ParticleAIndex = indexA;
constraintData.ParticleBIndex = other.Index;
constraintData.Length = Vector3.Distance(obj.transform.position, other.transform.position);
constraintDatas.Push(constraintData);
}
}
}
particleSettings.SetGravity(m_gravity.x, m_gravity.y, m_gravity.z);
particleSettings.SetParticles(particleDatas, constraintDatas.ToArray());
//gather collision Objects
ICollisionIntegrator[] collisions = GetComponentsInChildren <ICollisionIntegrator>();
ICollisionObject[] collisionObjects = new ICollisionObject[collisions.Length];
for (int i = 0; i < collisions.Length; i++)
{
collisionObjects[i] = collisions[i].CollisionObject();
}
particleSettings.SetCollisions(collisionObjects);
m_clothParticleSystem = new ClothParticleSystem(particleSettings);
}
public static List <CollisionInfo> CheckCollision(ICollisionObject obj, List <ICollisionObject> objects)
{
List <CollisionInfo> result = new List <CollisionInfo>();
foreach (ICollisionObject collisionObj in objects)
{
CollisionInfo info = new CollisionInfo(obj, collisionObj);
if (CheckCollision(info))
{
result.Add(info);
}
}
return(result);
}
public override bool CheckForCollision(ICollisionObject obj)
{
/* Get the circular collision */
Circle other = obj as Circle;
/* Check the collision */
if (other != null)
{
float radii = mRadius + other.mRadius;
return Vector2.DistanceSquared(other.Parent.GetActualPosition(), Parent.GetActualPosition()) - (radii * radii) < 0.0f;
}
else
{
return false;
}
}
public void NotifyOfCollision(ICollisionObject otherObject)
{
if (otherObject is Ammunition)
{
int d = ((Ammunition)otherObject).damage;
health -= d;
if (health <= 0)
{
isDead = true;
}
else
{
healthBar.takeDamage(d, gameTime);
}
}
}
public bool Remove(ICollisionObject collisionObject, Side side)
{
switch (side)
{
case Side.Bottom:
return(bottomCollided.Remove(collisionObject));
case Side.Right:
return(rightCollided.Remove(collisionObject));
case Side.Left:
return(leftCollided.Remove(collisionObject));
case Side.Top:
return(topCollided.Remove(collisionObject));
}
return(false);
}
private void CollidedByEnemyCallback(ObjectColliderBase collider, ICollisionObject enemy)
{
ClearCollider();
if (!_isFinish)
{
Explode();
ShakeEffect effect = EffectsManager.GetInstance().CreateEffectByType(EffectType.ShakeEffect) as ShakeEffect;
effect.DoShake(0, 5, 1, 5);
//ObjectColliderBase newCollider = ColliderManager.GetInstance().CreateColliderByType(eColliderType.Circle);
//newCollider.SetSize(_size, _size);
//newCollider.SetPosition(_curPos);
//newCollider.SetEliminateType(eEliminateDef.PlayerSpellCard);
//newCollider.SetColliderGroup(eColliderGroup.Enemy | eColliderGroup.EnemyBullet);
//newCollider.SetHitEnemyDamage(_dmg);
//newCollider.SetExistDuration(1);
_isFinish = true;
}
}
public bool Contains(ICollisionObject collisionObject)
{
if (bottomCollided.Contains(collisionObject))
{
return(true);
}
if (rightCollided.Contains(collisionObject))
{
return(true);
}
if (leftCollided.Contains(collisionObject))
{
return(true);
}
if (topCollided.Contains(collisionObject))
{
return(true);
}
return(false);
}
public bool RemoveAll(ICollisionObject collisionObject)
{
if (bottomCollided.Contains(collisionObject))
{
bottomCollided.Remove(collisionObject);
}
if (rightCollided.Contains(collisionObject))
{
rightCollided.Remove(collisionObject);
}
if (leftCollided.Contains(collisionObject))
{
leftCollided.Remove(collisionObject);
}
if (topCollided.Contains(collisionObject))
{
topCollided.Remove(collisionObject);
}
return(true);
}
public void Add(ICollisionObject objectToAdd, Side side)
{
switch (side)
{
case Side.Bottom:
bottomCollided.Add(objectToAdd);
break;
case Side.Right:
rightCollided.Add(objectToAdd);
break;
case Side.Left:
leftCollided.Add(objectToAdd);
break;
case Side.Top:
topCollided.Add(objectToAdd);
break;
}
}
public void Update(ICollisionObject CollisionObject)
{
if (repeat != 0)
{
if (collider.Intersects(CollisionObject.Collider))
{
try
{ function.Invoke(instance, new object[] { CollisionObject }); }
catch (Exception e)
{
Irbis.Irbis.WriteLine("Trigger Exception: " + e.Message);
Irbis.Irbis.WriteLine("Stacktrace:\n" + e.StackTrace + "\n");
Irbis.Irbis.DisplayInfoText("Trigger Exception: " + e.Message, Color.Red);
}
if (repeat > 0)
{
repeat--;
}
}
}
}
/// <summary>
/// Raises the appropriate ParentObject collision events depending on its CollisionType value
/// </summary>
/// <param name="sender">The current ISpaceObject instance</param>
/// <param name="other">The ISpaceObject instance which collided</param>
/// <param name="pair"/>
protected void OnCollisionDetected(Collidable sender, Collidable other, CollidablePairHandler pair)
{
if (sender.Tag == null || other.Tag == null)
{
return;
}
ICollisionObject senderCollisionObject = (ICollisionObject)sender.Tag;
ICollisionObject otherCollisionObject = (ICollisionObject)other.Tag;
switch (ParentObject.CollisionType)
{
case CollisionType.Trigger:
{
ParentObject.OnCollisionTrigger(senderCollisionObject, otherCollisionObject);
break;
}
case CollisionType.Collide:
{
var collisionPoint = new CollisionPoint
{
ContactObject = otherCollisionObject,
ContactPoint = pair.Contacts[0].Contact.Position,
ContactTime = pair.TimeOfImpact,
Material = null,
SurfaceNormal = pair.Contacts[0].Contact.Normal
};
ParentObject.OnCollisionReact(senderCollisionObject, otherCollisionObject, collisionPoint, ref _collisionHandled);
break;
}
default:
case CollisionType.None:
{
break;
}
}
}
public CollisionPoint(ICollisionObject collisionObject, PointD point)
{
CollisionObject = collisionObject;
Point = point;
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="collisionObject">The parent object this instance will be associataed with</param>
protected BEPUCollisionMove(ICollisionObject collisionObject)
{
ParentObject = collisionObject;
}
public CompoundBodyCollisionMove(ICollisionObject collisionObject, IList <CompoundShapeEntry> childrenShapes) : base(collisionObject)
{
SpaceObject = new CompoundBody(childrenShapes, collisionObject.Mass);
}
/* Events */
public void CheckCollision(ICollisionObject obj)
{
/* Check for collision */
bool this_collides = IsCollideableType(obj.Parent.Parent.GetType());
bool other_collideds = obj.IsCollideableType(Parent.Parent.GetType());
if ((this_collides || other_collideds) && CheckForCollision(obj))
{
/* Call this objects 'On Collision' event */
if (this_collides && mOnCollision != null)
{
mOnCollision(this, obj);
}
/* Call the other objects 'On Collision' event */
if (other_collideds && obj.OnCollision != null)
{
obj.OnCollision(obj, this);
}
}
}
public abstract bool CheckForCollision(ICollisionObject obj);
public ObjectCollided(ICollisionObject objectCollided, Side sideCollided)
{
collisionObject = objectCollided;
collisionSide = sideCollided;
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="collisionObject">The parent object this instance will be associataed with</param>
protected BEPUCollisionMove(ICollisionObject collisionObject)
{
ParentObject = collisionObject;
}
/// <summary>
/// Creates a new instance
/// </summary>
/// <param name="collisionObject">The ParentObject this instance will be associated with</param>
public SphereCollisionMove(ICollisionObject collisionObject) : base(collisionObject)
{
SpaceObject = new Sphere(ParentObject.World.Translation, ParentObject.WorldBoundingSphere.Radius);
CollisionObjectScale = ParentObject.WorldBoundingSphere.Radius;
}
public void addOther(ICollisionObject other)
{
otherObjects.Add(other);
}
/// <summary>
/// Creates new collision informations
/// </summary>
/// <param name="collider">The collisionobject we checked</param>
/// <param name="collidee">The collisionobject it collided with</param>
public CollisionInfo(ICollisionObject collider, ICollisionObject collidee)
{
this.left = collider;
this.right = collidee;
this.resolved = false;
}
/// <summary>
/// Removes a body from the CollisionSystem
/// </summary>
/// <param name="body"></param>
/// <returns></returns>
public virtual bool RemoveBody(ICollisionObject body)
{
return(bodyList.Remove(body));
}
public void NotifyOfCollision(ICollisionObject otherObject)
{
//Don't really care - the cow deletes it if necessary
}
public void removeOther(ICollisionObject other)
{
otherObjects.Remove(other);
}
public static CollisionObjectModel ToModel(this ICollisionObject obj) =>
new CollisionObjectModel
{
Frame = obj.Frame, Primitives = obj.Primitives.Select(x => x.ToModel()).ToList()
};
