//--------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="CollisionAlgorithm"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="collisionDetection"/> is <see langword="null"/>.
/// </exception>
protected CollisionAlgorithm(CollisionDetection collisionDetection)
{
if (collisionDetection == null)
throw new ArgumentNullException("collisionDetection");
CollisionDetection = collisionDetection;
}
public void ComputeCollision()
{
CollisionDetection cd = new CollisionDetection();
CombinedCollisionAlgorithm cca = new CombinedCollisionAlgorithm(cd, new SphereSphereAlgorithm(cd), new SphereSphereAlgorithm(cd));
CollisionObject a = new CollisionObject(new GeometricObject
{
Shape = new SphereShape(1),
});
CollisionObject b = new CollisionObject(new GeometricObject
{
Shape = new SphereShape(1),
Pose = new Pose(new Vector3F(3, 0, 0)),
});
ContactSet set = cca.GetClosestPoints(a, b);
Assert.AreEqual(1, set.Count);
set = cca.GetContacts(a, b);
Assert.IsTrue(set == null || set.Count == 0);
((GeometricObject)b.GeometricObject).Pose = new Pose(new Vector3F(2, 0, 0));
set = cca.GetClosestPoints(a, b);
Assert.AreEqual(1, set.Count);
set = cca.GetContacts(a, b);
Assert.AreEqual(1, set.Count);
}
protected void InitAttackVariables()
{
attackManager = GetComponent<AttackManager> ();
flyingEnemyNavigation = GetComponent<FlyingEnemyNavigation> ();
groundEnemyNavigation = GetComponent<GroundEnemyNavigation> ();
navMeshAgent = GetComponent<NavMeshAgent> ();
collisionDetection = GetComponent<CollisionDetection> ();
target = Player.instance.positionController.transform;
}
public WarlordPhysics()
{
movingEntityMap = new Dictionary<uint, MovingEntity>();
globalForces = new List<ForceGenerator>();
collisionDetection = new CollisionDetection();
GlobalSystems.EventManager.Subscribe(AddEntity, "actor_created_event");
GlobalSystems.EventManager.Subscribe(RemoveEntity, "actor_removed_event");
}
void Start()
{
alreadyDestroyed = false;
enemyCol = gameObject.GetComponent<CollisionDetection> ();
enemyCol.OnDeath += startDetonation;
enemyCol.OnDeath += RemoveFromCount;
state = idle;
}
/// <summary>
/// Initializes a new instance of the <see cref="CombinedCollisionAlgorithm"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
/// <param name="closestPointsAlgorithm">The closest points algorithm.</param>
/// <param name="contactAlgorithm">The contact algorithm.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="closestPointsAlgorithm"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="contactAlgorithm"/> is <see langword="null"/>.
/// </exception>
public CombinedCollisionAlgorithm(CollisionDetection collisionDetection, CollisionAlgorithm closestPointsAlgorithm, CollisionAlgorithm contactAlgorithm)
: base(collisionDetection)
{
if (closestPointsAlgorithm == null)
throw new ArgumentNullException("closestPointsAlgorithm");
if (contactAlgorithm == null)
throw new ArgumentNullException("contactAlgorithm");
_closestPointsAlgorithm = closestPointsAlgorithm;
_contactAlgorithm = contactAlgorithm;
}
void Start()
{
collisionDetection = GetComponent<CollisionDetection> ();
collisionDetection.OnHit += show;
collisionDetection.OnDeath += RemoveSelf;
maxAmount = 4;
if (timedHiders == null) {
timedHiders = new List<TimedHider>();
}
show ();
}
// Use this for initialization
void Start()
{
//rb = (Rigidbody)GameObject.Find("ZombiePlayer_Spawn_Postion/Zombie_Player(Clone)/rig/hips/spine/chest").GetComponent<Rigidbody>();
SetText("START");
//InvokeRepeating("repeatCall", 0.1f, 0.1f);
PluginWrapper.GetInstance().CallJavaFunc("javaTestFunc", "UnityJavaJarTest");
PluginWrapper.GetInstance().CallJavaFunc("javaGetCoordFunc", "UnityJavaJarTest");
if (GameObject.Find("Wall_spawner").GetComponentInChildren <CollisionDetection>())
{
collisionDetection = (CollisionDetection)GameObject.Find("Wall_spawner").GetComponentInChildren <CollisionDetection>();
}
}
public override void Initialize()
{
Controller = new KeyboardController(myGame);
levelManager = new LevelManager("Levelmanager/Level2.xml");
levelManager.LoadLevel();
Level = levelManager.GetCurrentLevel();
ItemFactory.Instance.SetLevel(Level);
EnemyFactory.Instance.SetLevel(Level);
collisionHandler = new CollisionDetection(Level);
SoundFactory.Instance.Play(SoundFactory.ThemeSongs.MainTheme);
PlayerOneCamera.Instance.Reset();
}
public void TestClipLineToSegment2()
{
KVector2 start = new KVector2(-2, 3);
KVector2 end = new KVector2(1, 0);
KVector2 normal = new KVector2(-1, 0);
CollisionDetection.ClipPointsToLine(start, end, normal, 1, out KVector2[] output);
Assert.AreEqual(new KVector2(1, 0), output[0]);
Assert.AreEqual(new KVector2(-1, 2), output[1]);
}
public bool CollidWith()
{
var player = (DynamicShape)Player.GetInstance().Entity.Shape;
var data = CollisionDetection.Aabb(player, Shape);
if (data.Collision)
{
Player.GetInstance().Explode();
}
return(data.Collision);
}
public bool CollidWith()
{
var player = Player.GetInstance();
if (player.Destination.Length > 1)
{
// remove stamp for next level maker if it is for specific platform.
player.SetDestination(player.Destination[1].ToString());
}
return(CollisionDetection.Aabb(
(DynamicShape)Player.GetInstance().Entity.Shape, Shape).Collision);
}
public static bool ExitCollision(Player player, EntityContainer entityContainer)
{
foreach (Entity element in entityContainer)
{
var collisionData = CollisionDetection.Aabb(player.Shape, element.Shape);
if (collisionData.Collision)
{
return(true);
}
}
return(false);
}
public bool CollidWith()
{
var player = (DynamicShape)Player.GetInstance().Entity.Shape;
var pl = Player.GetInstance();
// drop of customer if the ID match
/*if (Customers.GetInstance().CustomerCount > 0 && pl.Destination == "^" ||
* pl.Destination == ID.ToString() &&
* player.Position.Y <= Shape.Position.Y + Shape.Extent.Y) {
*
* Player.GetInstance().DropOfCustomer();
*
* }*/
// Player collision
var data = CollisionDetection.Aabb(player, Shape);
if (data.Collision && data.CollisionDir != CollisionDirection.CollisionDirDown ||
(player.Position.X >= Shape.Position.X && player.Position.X <= Shape.Position.X + Shape.Extent.X &&
player.Position.Y >= Shape.Position.Y && player.Position.Y <= Shape.Position.Y + Shape.Extent.Y))
{
var p = Player.GetInstance();
// calculation speed
var speed = Math.Sqrt(
player.Direction.X * player.Direction.X +
player.Direction.Y * player.Direction.Y) /
Game.ScreenTimer.CapturedUpdates;
if (speed > 0.00004f)
{
p.Explode();
player.Position.Y = Shape.Position.Y + Shape.Extent.Y;
}
else
{
p.Landed = true;
if (p.Movement is TrivialMovement)
{
p.Movement = new OnPlatform(Shape);
((DynamicShape)p.Entity.Shape).Direction.X = 0.0f;
}
p.Location = ID.ToString();
}
}
return(data.Collision && data.CollisionDir != CollisionDirection.CollisionDirDown);
}
// Start is called before the first frame update
private void OnCollisionEnter(Collision collision)
{
if (ignoreCollision)
{
return;
}
ignoreCollision = true;
CollisionDetection cd = collision.contacts[0].otherCollider.gameObject.GetComponent <CollisionDetection>();
pongIq.CollisionDetected(cd.index, cd.value);
GetComponent <Rigidbody>().velocity = Vector3.zero;
cannon.ResetBall();
}
public override void DetectCollision()
{
Rectangle rect = new Rectangle(
new Point(
SpriteRectangle.X + (int)(velocity.X * Game.GameTimeSeconds),
SpriteRectangle.Y + (int)(velocity.Y * Game.GameTimeSeconds)),
new Point(SpriteRectangle.Width, SpriteRectangle.Height)); // Creates the projected rectangle
bool[] array = CollisionDetection.DetectCollisionArrayMap(rect);
North = array[0];
South = array[1];
East = array[2];
West = array[3];
}
void IDemoRPCService.Set(IAvatar avatar, DemoID demoID)
{
if (!_database.ContainsKey(demoID))
{
return;
}
CollisionDetection detection = _database[demoID];
IAvatarWearable wearable = detection.GetComponent <IAvatarWearable>();
avatar.SetWearable(wearable);
detection.GetComponent <Collider>().enabled = false;
}
public void ComputeCollision2()
{
// Use TestAlgo to test if GetClosestPoint returns only 1 contact.
CollisionDetection cd = new CollisionDetection();
CombinedCollisionAlgorithm cca = new CombinedCollisionAlgorithm(cd, new TestAlgo(cd), new TestAlgo(cd));
CollisionObject a = new CollisionObject();
CollisionObject b = new CollisionObject();
ContactSet set = cca.GetClosestPoints(a, b);
// Test algo returns 2 contacts. One is filtered out because a closest-point query should return only 1 contact.
Assert.AreEqual(1, set.Count);
Assert.AreEqual(1.2f, set[0].PenetrationDepth);
}
public static bool checkCollision(Map map, RobotState state, RobotState dest)
{
float radius = ((R2D2State)state).ScreenRadius;
foreach (Obstacle obs in map)
{
Obstacle ob = obs.createExpandedObstacle(Constants.BING_BANG_OBSTACLE_PROXIMITY_MULT * radius);
if (CollisionDetection.lineSegmentPolyIntersect(state.X, state.Y, dest.X, dest.Y, (BShape_Poly)ob))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Collision check for colliding with a portal
/// </summary>
private void PortalCollision()
{
var playerShape = player.Shape.AsDynamicShape();
foreach (Entity portal in portals)
{
var collisionData = CollisionDetection.Aabb(playerShape, portal.Shape);
if (collisionData.Collision)
{
levelManager.NextLevel();
break;
}
}
}
public void UpAction()
{
int heightChange = SourceRectangle.Height;
ActionState.ActionUp();
heightChange = SourceRectangle.Height - heightChange;
CollisionDetection.FixCollisionFromStateChange(this, heightChange);
/*This is sound effect for jumping*/
if (OnGround)
{
SoundItems.SoundFactory.Instance.JumpN();
}
}
/// <summary>
/// All methods in this class checks for collisions between entities using the
/// CollisionDetetion from DIKUArcade Platform
/// when there is a "proper" platform collision, ends game otherwise
/// </summary>
public static void ObstacleCollision(Player player, EntityContainer entityContainer)
{
foreach (Entity element in entityContainer)
{
var collisionData = CollisionDetection.Aabb(player.Shape, element.Shape);
if (collisionData.Collision)
{
EventBus.GetBus().RegisterEvent(
GameEventFactory <object> .CreateGameEventForAllProcessors(
GameEventType.GameStateEvent, "", "CHANGE_STATE",
"MAIN_MENU", ""));
}
}
}
public static void CheckIfShipShot(double gameTimeSeconds, ShipModel ship, AlienListModel aliensList, AlienBulletListModel alienBulletList, ExplosionListModel explosions, GameSounds gameSounds)
{
if (!ship.IsDestroyed)
{
bool shipDestroyed =
alienBulletList.AlienBullets.Exists(b => CollisionDetection.Hits(b.CentrePoint, ship.CentrePoint, CollisionDetectRange)) ||
aliensList.Aliens.Exists(a => CollisionDetection.Hits(a.CentrePoint, ship.CentrePoint, CollisionDetectRange));
if (shipDestroyed)
{
DestroyShip(gameTimeSeconds, ship, explosions, gameSounds);
}
}
}
/// <summary>
/// Method for determining collision with platform
/// </summary>
/// <param name="player">
/// player
/// </param>
/// <returns>
/// true if there is a collision with a platform else false
/// </returns>
/// <remarks>
/// Supporting method that will be used in collisiondetect method
/// for landing of taxi
/// </remarks>
private bool collisionPlatform(Player player)
{
foreach (Entity elm in Activeplatforms.textureList)
{
CollisionData col =
CollisionDetection.Aabb(player.Entity.Shape.AsDynamicShape(),
elm.Shape.AsDynamicShape());
if (col.Collision)
{
return(col.Collision);
}
}
return(false);
}
/// <summary>
/// Collision check for Obstacle objects
/// </summary>
private void ObstacleCollision()
{
var playerShape = player.Shape.AsDynamicShape();
foreach (Obstacle obstacle in obstacles)
{
var collisionData = CollisionDetection.Aabb(playerShape, obstacle.Shape);
if (collisionData.Collision)
{
spaceTaxibus.RegisterEvent(
GameEventFactory <object> .CreateGameEventForAllProcessors(
GameEventType.GameStateEvent, this, "CHANGE_STATE", "GAME_OVER", ""));
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CombinedCollisionAlgorithm"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
/// <param name="closestPointsAlgorithm">The closest points algorithm.</param>
/// <param name="contactAlgorithm">The contact algorithm.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="closestPointsAlgorithm"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="contactAlgorithm"/> is <see langword="null"/>.
/// </exception>
public CombinedCollisionAlgorithm(CollisionDetection collisionDetection, CollisionAlgorithm closestPointsAlgorithm, CollisionAlgorithm contactAlgorithm)
: base(collisionDetection)
{
if (closestPointsAlgorithm == null)
{
throw new ArgumentNullException("closestPointsAlgorithm");
}
if (contactAlgorithm == null)
{
throw new ArgumentNullException("contactAlgorithm");
}
_closestPointsAlgorithm = closestPointsAlgorithm;
_contactAlgorithm = contactAlgorithm;
}
/// <summary>
/// Remove bullets that collide with walls
/// </summary>
void CollisionDetect()
{
for (int w = 0; w < gameManager.levelManager.WallTileCount; w++)
{
if (CollisionDetection.PointRectCollision(
transform.position,
gameManager.levelManager.GetWallInfo(w)))
{
gameManager.Bullets.Remove(gameObject);
Destroy(gameObject);
break;
}
}
}
public void ComputeCollision2()
{
// Use TestAlgo to test if GetClosestPoint returns only 1 contact.
CollisionDetection cd = new CollisionDetection();
CombinedCollisionAlgorithm cca = new CombinedCollisionAlgorithm(cd, new TestAlgo(cd), new TestAlgo(cd));
CollisionObject a = new CollisionObject();
CollisionObject b = new CollisionObject();
ContactSet set = cca.GetClosestPoints(a, b);
// Test algo returns 2 contacts. One is filtered out because a closest-point query should return only 1 contact.
Assert.AreEqual(1, set.Count);
Assert.AreEqual(1.2f, set[0].PenetrationDepth);
}
public override void update(GameObject gameObject, QuadTree quadTree, SceneManager sceneManager)
{
quadTree.getObjects(gameObject).ForEach((returnObject) => {
Rectangle rect1 = new Rectangle((int)gameObject.position.X, (int)gameObject.position.Y, 128, 128);
Rectangle rect2 = new Rectangle((int)returnObject.position.X, (int)returnObject.position.Y, 128, 128);
if (CollisionDetection.AreRectanglesColliding(rect1, rect2))
{
if (null != gameObject.ComponentContainer.GetScriptComponent() && returnObject is MoronGameObject)
{
gameObject.ComponentContainer.GetScriptComponent().update(gameObject, quadTree, sceneManager);
}
}
});
}
public virtual void DetectCollision()
{
bool[] array = CollisionDetection.DetectCollisionArrayMap(SpriteRectangle);
North = array[0];
South = array[1];
East = array[2];
West = array[3];
AnimatedSprite[] temp;
CollisionDetection.DetectCollisionSprites(this, SpriteRectangle, out temp);
if (temp.Contains(Game.PlayerCharacter))
{
Game.PlayerCharacter.AddHealth(-Manager.Damage);
}
}
/// <summary>
/// IterateShots handles the logic of the playerShots. It checks for collision with enemies and
/// deletes both enemies and shots if needed.
/// </summary>
public void IterateShots()
{
foreach (var shot in playerShots)
{
shot.Shape.Move();
if (shot.Shape.Position.Y > 1.0f)
{
shot.DeleteEntity();
}
foreach (var enemy in enemies)
{
var shotHit = CollisionDetection.Aabb(shot.Shape.AsDynamicShape(), enemy.Shape);
if (shotHit.Collision)
{
AddExplosion(enemy.Shape.Position.X, enemy.Shape.Position.Y,
enemy.Shape.Extent.X, enemy.Shape.Extent.Y);
shot.DeleteEntity();
enemy.DeleteEntity();
score.AddPoint(100);
}
}
}
var newShot = new List <PlayerShot>();
foreach (var shot in playerShots)
{
if (!shot.IsDeleted())
{
newShot.Add(shot);
}
}
playerShots = newShot;
var newEnemies = new List <Enemy>();
foreach (var enemy in enemies)
{
if (!enemy.IsDeleted())
{
newEnemies.Add(enemy);
}
}
enemies = newEnemies;
}
public GameState(Game1 game, GraphicsDevice graphicsDevice, ContentManager content, int levelnumber) : base(game, graphicsDevice, content)
{
MediaPlayer.Stop();
collisiondetect = new CollisionDetection();
LoadSprites();
InitializeGameObject();
Levels = new LevelPicker(loadmapcontent(), hero, collisiondetect);
collisiondetect.walls = Levels.GetActiveWereld().ActiveRoom.GetCollisions();
hitdetection = new HitDetections(hero, Levels.GetActiveWereld().ActiveRoom.enemies);
SetStartingLevel(levelnumber);
MakeDeathScreen();
MediaPlayer.Play(gameBack);
}
public void CheckCollisionWithBall(Ball ball)
{
foreach (var item in items)
{
if (!item.Visible)
{
continue;
}
if (CollisionDetection.ShapesIntersect(item.BouncingBox, new Circle(ball.Radius, ball.GlobalCenter)))
{
item.Visible = false;
item.PlayEffect();
GameSettingHelper.AddOneCoin();
}
}
}
public void SetUp()
{
var mockBoard = new Mock <IBoard>();
mockBoard.Setup(m => m.Width).Returns(10);
mockBoard.Setup(m => m.Height).Returns(20);
mockBoard.Setup(m => m.ExistPosition(8, 0)).Returns(true);
mockBoard.Setup(m => m.ExistPosition(2, 0)).Returns(true);
CollisionDetection = new CollisionDetection(mockBoard.Object);
IBlocks = new IShapedBlocks();
LBlocks = new LShapedBlocks();
}
public void TestCollisionDirectionDown()
{
actor.Direction.X = 0.0f;
actor.Direction.Y = -actorVelocity;
for (int i = 0; i < 20; i++)
{
var data = CollisionDetection.Aabb(actor, solidBlockDown);
if (data.Collision)
{
Assert.That(data.CollisionDir, Is.EqualTo(CollisionDirection.CollisionDirDown));
return;
}
actor.Position += actor.Direction;
}
Assert.IsTrue(false); // collision was supposed to happen
}
public void CollisionDetected(CollisionDetection[] colliders, CollisionDetection collider, int index)
{
if (index == -1)
{
return;
}
foreach (CollisionDetection col in colliders)
{
if (col.index != -1)
{
col.gameObject.GetComponent <Renderer>().material = miss;
}
}
collider.gameObject.GetComponent <Renderer>().material = hit;
}
/// <summary>
/// Checks the collision between the player and the platform.
/// </summary>
/// <param name="Player"> Dynamic shape player</param>
/// <param name="platforms">Entity container with all the platforms</param>
/// <returns></returns>
private static bool CollisionPlatform(DynamicShape Player,
List <Entity> platforms)
{
foreach (var platform in platforms)
{
var check = CollisionDetection.Aabb(Player,
platform.Shape); {
if (check.Collision)
{
return(true);
}
}
}
return(false);
}
public void CheckCollisionWithBall(Ball ball)
{
foreach (var item in items)
{
if (!item.Visible)
{
continue;
}
if (CollisionDetection.ShapesIntersect(item.BouncingBox, new Circle(ball.Radius, ball.GlobalCenter)))
{
item.Visible = false;
item.PlayEffect();
ListBall.Instance.Increase(1);
}
}
}
public void TouchingButNotTouching()
{
// Special case: GJK reports contact, MPR cannot find the contact.
// This happens for perfectly touching quadrics.
CollisionDetection cd = new CollisionDetection();
CombinedCollisionAlgorithm cca = new CombinedCollisionAlgorithm(cd, new Gjk(cd), new MinkowskiPortalRefinement(cd));
CollisionObject a = new CollisionObject();
((GeometricObject)a.GeometricObject).Shape = new ConeShape(2, 2);
CollisionObject b = new CollisionObject();
((GeometricObject)b.GeometricObject).Shape = new CircleShape(2);
((GeometricObject)b.GeometricObject).Pose = new Pose(new Vector3F(4, 0, 0));
Assert.AreEqual(false, cca.HaveContact(a, b));
Assert.AreEqual(0, cca.GetContacts(a, b).Count);
Assert.IsTrue(cca.GetClosestPoints(a, b)[0].PenetrationDepth < 0);
}
/// <summary>
/// Initializes a new instance of the <see cref="TransformedShapeAlgorithm"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
public TransformedShapeAlgorithm(CollisionDetection collisionDetection)
: base(collisionDetection)
{
}
public TestAlgo(CollisionDetection cd)
: base(cd)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="CompositeShapeAlgorithm"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
public CompositeShapeAlgorithm(CollisionDetection collisionDetection)
: base(collisionDetection)
{
}
//--------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="MinkowskiPortalRefinement"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
public MinkowskiPortalRefinement(CollisionDetection collisionDetection)
: base(collisionDetection)
{
// Store DoMpr method in delegate to avoid garbage when using TestWithPerturbations.
_doMprMethod = DoMpr;
}
// Required for collision algorithm matrix.
// See FAST paper: "Interactive Continuous Collision Detection for Non-Convex Polyhedra", Kim Young et al.
/// <summary>
/// Gets the time of impact using Conservative Advancement (ignoring rotational movement).
/// </summary>
/// <param name="objectA">The object A.</param>
/// <param name="targetPoseA">The target pose of A.</param>
/// <param name="objectB">The object B.</param>
/// <param name="targetPoseB">The target pose of B.</param>
/// <param name="allowedPenetration">The allowed penetration depth.</param>
/// <param name="collisionDetection">The collision detection.</param>
/// <returns>
/// The time of impact in the range [0, 1].
/// </returns>
/// <remarks>
/// This algorithm does not work for concave objects.
/// </remarks>
/// <exception cref="ArgumentNullException">
/// <paramref name="objectA"/>, <paramref name="objectB"/> or
/// <paramref name="collisionDetection"/> is <see langword="null"/>.
/// </exception>
internal static float GetTimeOfImpactLinearCA(CollisionObject objectA, Pose targetPoseA,
CollisionObject objectB, Pose targetPoseB, float allowedPenetration,
CollisionDetection collisionDetection)
{
if (objectA == null)
throw new ArgumentNullException("objectA");
if (objectB == null)
throw new ArgumentNullException("objectB");
if (collisionDetection == null)
throw new ArgumentNullException("collisionDetection");
IGeometricObject geometricObjectA = objectA.GeometricObject;
IGeometricObject geometricObjectB = objectB.GeometricObject;
Pose startPoseA = geometricObjectA.Pose;
Pose startPoseB = geometricObjectB.Pose;
// Compute relative linear velocity.
// (linearRelVel ∙ normal > 0 if objects are getting closer.)
Vector3F linearVelocityA = targetPoseA.Position - startPoseA.Position;
Vector3F linearVelocityB = targetPoseB.Position - startPoseB.Position;
Vector3F linearVelocityRelative = linearVelocityA - linearVelocityB;
// Abort if relative movement is zero.
if (Numeric.IsZero(linearVelocityRelative.Length))
return 1;
var distanceAlgorithm = collisionDetection.AlgorithmMatrix[objectA, objectB];
// Use temporary test objects.
var testGeometricObjectA = TestGeometricObject.Create();
testGeometricObjectA.Shape = geometricObjectA.Shape;
testGeometricObjectA.Scale = geometricObjectA.Scale;
testGeometricObjectA.Pose = startPoseA;
var testGeometricObjectB = TestGeometricObject.Create();
testGeometricObjectB.Shape = geometricObjectB.Shape;
testGeometricObjectB.Scale = geometricObjectB.Scale;
testGeometricObjectB.Pose = startPoseB;
var testCollisionObjectA = ResourcePools.TestCollisionObjects.Obtain();
testCollisionObjectA.SetInternal(objectA, testGeometricObjectA);
var testCollisionObjectB = ResourcePools.TestCollisionObjects.Obtain();
testCollisionObjectB.SetInternal(objectB, testGeometricObjectB);
var testContactSet = ContactSet.Create(testCollisionObjectA, testCollisionObjectB);
try
{
distanceAlgorithm.UpdateClosestPoints(testContactSet, 0);
if (testContactSet.Count < 0)
{
// No closest-distance result. --> Abort.
return 1;
}
Vector3F normal = testContactSet[0].Normal;
float distance = -testContactSet[0].PenetrationDepth;
float λ = 0;
float λPrevious = 0;
for (int i = 0; i < MaxNumberOfIterations && distance > 0; i++)
{
// |v∙n|
float velocityProjected = Vector3F.Dot(linearVelocityRelative, normal);
// Abort for separating objects.
if (Numeric.IsLess(velocityProjected, 0))
break;
// Increase TOI.
float μ = (distance + allowedPenetration) / velocityProjected;
λ = λ + μ;
if (λ < 0 || λ > 1)
break;
Debug.Assert(λPrevious < λ);
if (λ <= λPrevious)
break;
// Get new interpolated poses - only positions are changed.
Vector3F positionA = startPoseA.Position + λ * (targetPoseA.Position - startPoseA.Position);
testGeometricObjectA.Pose = new Pose(positionA, startPoseA.Orientation);
Vector3F positionB = startPoseB.Position + λ * (targetPoseB.Position - startPoseB.Position);
testGeometricObjectB.Pose = new Pose(positionB, startPoseB.Orientation);
// Get new closest point distance.
distanceAlgorithm.UpdateClosestPoints(testContactSet, 0);
if (testContactSet.Count == 0)
break;
normal = testContactSet[0].Normal;
distance = -testContactSet[0].PenetrationDepth;
λPrevious = λ;
}
if (testContactSet.HaveContact && λ > 0 && λ < 1 && testContactSet.Count > 0)
{
return λ;
// We already have a contact that we could use.
// result.Contact = testContactSet[0];
}
}
finally
{
// Recycle temporary objects.
testContactSet.Recycle(true);
ResourcePools.TestCollisionObjects.Recycle(testCollisionObjectA);
ResourcePools.TestCollisionObjects.Recycle(testCollisionObjectB);
testGeometricObjectA.Recycle();
testGeometricObjectB.Recycle();
}
return 1;
}
public void ContactPositionTolerance()
{
CollisionDetection cd = new CollisionDetection();
cd.ContactPositionTolerance = 1f;
Assert.AreEqual(1f, cd.ContactPositionTolerance);
}
public void Epsilon()
{
CollisionDetection cd = new CollisionDetection();
cd.Epsilon = 1f;
Assert.AreEqual(1f, cd.Epsilon);
}
/// <summary>
/// Initializes a new instance of the <see cref="BoxBoxAlgorithm"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
public BoxBoxAlgorithm(CollisionDetection collisionDetection)
: base(collisionDetection)
{
}
private void ShadowMountains_KeyDown(object sender, KeyEventArgs e)
{
if (!inCombat)
{
Point p = new Point(0, 0);
if (e.KeyCode == Keys.Left)
{
p = new Point(-40, 0);
}
if (e.KeyCode == Keys.Right)
{
p = new Point(40, 0);
}
if (e.KeyCode == Keys.Up)
{
p = new Point(0, -40);
}
if (e.KeyCode == Keys.Down)
{
p = new Point(0, 40);
}
//
Point potentialMove = new Point(p.X + this.Player.SpritePictureBox.Location.X,
p.Y + this.Player.SpritePictureBox.Location.Y);
if (this.GetWalkableAt(potentialMove))
{
this.Player.Move(p.X, p.Y);
}
else
{
//Load new map if possible
if (potentialMove.X > this.Width - 80)
{
LoadNewMap(1, 0);
this.Player.Move((this.Width * (-1)), 0);
}
if (potentialMove.X < 0)
{
this.Player.Move(0, 0);
}
if (potentialMove.Y < 0)
{
this.Player.Move(0, 0);
}
if (potentialMove.Y > this.Height)
{
this.Player.Move(0, this.Height);
}
}
foreach (var enemy in this.enemyList)
{
if ((this.Player.Position.X == enemy.Position.X) && (this.Player.Position.Y == enemy.Position.Y) && enemy.IsAlive)
{
var collisionDetection = new CollisionDetection(this);
collisionDetection.DetectCollision(this.Player, enemy);
}
}
//foreach (var enemy in collisionDetection.UnitsInMap)
//{
// if (!(enemy is Player))
// {
// collisionDetection(this.player, enemy);
// }
//}
}
else
{
// //Use monsterInCombat variable to remove correct sprite
// //If the combat GUI has exited combat, remove our enemy sprite
// if (!combatGUI.inCombat)
// {
// monsterInCombat.alive = false;
// KillMonsterInList(monsterInCombat);
// inCombat = false;
// }
//}
//DetectCollision();
}
Draw();
}
public void ConstructorException2()
{
CollisionDetection cd = new CollisionDetection();
new CombinedCollisionAlgorithm(cd, new BoxBoxAlgorithm(cd), null);
}
public void SetUp()
{
_collisionDetection = new CollisionDetection();
// Create objects. Object A and B touch.
_objectA = new CollisionObject(new GeometricObject
{
Shape = new SphereShape(1),
Pose = Pose.Identity,
});
_objectB = new CollisionObject(new GeometricObject
{
Shape = new SphereShape(1),
Pose = new Pose(new Vector3F(2, 0, 0), QuaternionF.Identity),
});
_objectC = new CollisionObject(new GeometricObject
{
Shape = new SphereShape(1),
Pose = new Pose(new Vector3F(10, 0, 0), QuaternionF.Identity),
});
}
/// <summary>
/// Initializes a new instance of the <see cref="RayHeightFieldAlgorithm"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
public RayHeightFieldAlgorithm(CollisionDetection collisionDetection)
: base(collisionDetection)
{
_heightFieldAlgorithm = new HeightFieldAlgorithm(collisionDetection);
}
/// <summary>
/// Initializes a new instance of the <see cref="BoxSphereAlgorithm"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
public BoxSphereAlgorithm(CollisionDetection collisionDetection)
: base(collisionDetection)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="Gjk"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
public Gjk(CollisionDetection collisionDetection)
: base(collisionDetection)
{
}
// Required for collision algorithm matrix.
// See FAST paper: "Interactive Continuous Collision Detection for Non-Convex Polyhedra", Kim Young et al.
/// <summary>
/// Gets the time of impact using Conservative Advancement.
/// </summary>
/// <param name="objectA">The object A.</param>
/// <param name="targetPoseA">The target pose of A.</param>
/// <param name="objectB">The object B.</param>
/// <param name="targetPoseB">The target pose of B.</param>
/// <param name="allowedPenetrationDepth">The allowed penetration depth.</param>
/// <param name="collisionDetection">The collision detection.</param>
/// <returns>
/// The time of impact in the range [0, 1].
/// </returns>
/// <remarks>
/// This algorithm does not work for concave objects.
/// </remarks>
/// <exception cref="ArgumentNullException">
/// <paramref name="objectA"/>, <paramref name="objectB"/> or
/// <paramref name="collisionDetection"/> is <see langword="null"/>.
/// </exception>
internal static float GetTimeOfImpactCA(CollisionObject objectA, Pose targetPoseA,
CollisionObject objectB, Pose targetPoseB, float allowedPenetrationDepth,
CollisionDetection collisionDetection)
{
if (objectA == null)
throw new ArgumentNullException("objectA");
if (objectB == null)
throw new ArgumentNullException("objectB");
if (collisionDetection == null)
throw new ArgumentNullException("collisionDetection");
IGeometricObject geometricObjectA = objectA.GeometricObject;
IGeometricObject geometricObjectB = objectB.GeometricObject;
Pose startPoseA = geometricObjectA.Pose;
Pose startPoseB = geometricObjectB.Pose;
// Get angular velocity ω of object A (as magnitude + rotation axis).
// qEnd = ∆q * qStart
// => ∆q = qEnd * qStart.Inverse
QuaternionF qA = QuaternionF.CreateRotation(targetPoseA.Orientation * startPoseA.Orientation.Transposed);
// ω = ∆α / ∆t, ∆t = 1
// => ω = ∆α
float ωA = qA.Angle; // Magnitude |ω|
Vector3F ωAxisA = (!Numeric.AreEqual(qA.W, 1)) ? qA.Axis : Vector3F.UnitX; // Rotation axis of ω
// Get angular velocity ω of object B (as magnitude + rotation axis).
// (Same as above.)
QuaternionF qB = QuaternionF.CreateRotation(targetPoseB.Orientation * startPoseB.Orientation.Transposed);
float ωB = qB.Angle; // Magnitude |ω|
Vector3F ωAxisB = (!Numeric.AreEqual(qB.W, 1)) ? qB.Axis : Vector3F.UnitX; // Rotation axis of ω
// Bounding sphere radii.
float rMaxA = GetBoundingRadius(geometricObjectA);
float rMaxB = GetBoundingRadius(geometricObjectB);
// |ω| * rMax is the angular part of the projected velocity bound.
float angularVelocityProjected = ωA * rMaxA + ωB * rMaxB;
// Compute relative linear velocity.
// (linearRelVel ∙ normal > 0 if objects are getting closer.)
Vector3F linearVelocityA = targetPoseA.Position - startPoseA.Position;
Vector3F linearVelocityB = targetPoseB.Position - startPoseB.Position;
Vector3F linearVelocityRelative = linearVelocityA - linearVelocityB;
// Abort if relative movement is zero.
if (Numeric.IsZero(linearVelocityRelative.Length + angularVelocityProjected))
return 1;
var distanceAlgorithm = collisionDetection.AlgorithmMatrix[objectA, objectB];
// Use temporary test objects.
var testGeometricObjectA = TestGeometricObject.Create();
testGeometricObjectA.Shape = geometricObjectA.Shape;
testGeometricObjectA.Scale = geometricObjectA.Scale;
testGeometricObjectA.Pose = startPoseA;
var testGeometricObjectB = TestGeometricObject.Create();
testGeometricObjectB.Shape = geometricObjectB.Shape;
testGeometricObjectB.Scale = geometricObjectB.Scale;
testGeometricObjectB.Pose = startPoseB;
var testCollisionObjectA = ResourcePools.TestCollisionObjects.Obtain();
testCollisionObjectA.SetInternal(objectA, testGeometricObjectA);
var testCollisionObjectB = ResourcePools.TestCollisionObjects.Obtain();
testCollisionObjectB.SetInternal(objectB, testGeometricObjectB);
var testContactSet = ContactSet.Create(testCollisionObjectA, testCollisionObjectB);
try
{
distanceAlgorithm.UpdateClosestPoints(testContactSet, 0);
if (testContactSet.Count < 0)
{
// No distance result --> Abort.
return 1;
}
Vector3F normal = testContactSet[0].Normal;
float distance = -testContactSet[0].PenetrationDepth;
float λ = 0;
float λPrevious = 0;
for (int i = 0; i < MaxNumberOfIterations && distance > 0; i++)
{
// |v∙n|
float linearVelocityProject = Vector3F.Dot(linearVelocityRelative, normal);
// |n x ω| * rMax
angularVelocityProjected = Vector3F.Cross(normal, ωAxisA).Length * ωA * rMaxA
+ Vector3F.Cross(normal, ωAxisB).Length * ωB * rMaxB;
// Total projected velocity.
float velocityProjected = linearVelocityProject + angularVelocityProjected;
// Abort for separating objects.
if (Numeric.IsLess(velocityProjected, 0))
break;
// Increase TOI.
float μ = (distance + allowedPenetrationDepth) / velocityProjected;
λ = λ + μ;
if (λ < 0 || λ > 1)
break;
Debug.Assert(λPrevious < λ);
if (λ <= λPrevious)
break;
// Get new interpolated poses.
Vector3F positionA = startPoseA.Position + λ * (targetPoseA.Position - startPoseA.Position);
Matrix33F rotationA = Matrix33F.CreateRotation(ωAxisA, λ * ωA);
testGeometricObjectA.Pose = new Pose(positionA, rotationA * startPoseA.Orientation);
Vector3F positionB = startPoseB.Position + λ * (targetPoseB.Position - startPoseB.Position);
Matrix33F rotationB = Matrix33F.CreateRotation(ωAxisB, λ * ωB);
testGeometricObjectB.Pose = new Pose(positionB, rotationB * startPoseB.Orientation);
// Get new closest point distance.
distanceAlgorithm.UpdateClosestPoints(testContactSet, 0);
if (testContactSet.Count == 0)
break;
normal = testContactSet[0].Normal;
distance = -testContactSet[0].PenetrationDepth;
λPrevious = λ;
}
if (testContactSet.HaveContact && λ > 0 && λ < 1 && testContactSet.Count > 0)
{
return λ;
// We already have a contact that we could use.
// result.Contact = testContactSet[0];
}
}
finally
{
// Recycle temporary objects.
testContactSet.Recycle(true);
ResourcePools.TestCollisionObjects.Recycle(testCollisionObjectA);
ResourcePools.TestCollisionObjects.Recycle(testCollisionObjectB);
testGeometricObjectA.Recycle();
testGeometricObjectB.Recycle();
}
return 1;
}
/// <summary>
/// Initializes a new instance of the <see cref="InfiniteShapeAlgorithm"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
public InfiniteShapeAlgorithm(CollisionDetection collisionDetection)
: base(collisionDetection)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="PlaneConvexAlgorithm"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
public PlaneConvexAlgorithm(CollisionDetection collisionDetection)
: base(collisionDetection)
{
// Store test method to avoid garbage when using TestWithPerturbations.
_computeContactsMethod = contactSet => ComputeCollision(contactSet, CollisionQueryType.Contacts);
}
/// <summary>
/// Initializes a new instance of the <see cref="RayTriangleMeshAlgorithm"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
public RayTriangleMeshAlgorithm(CollisionDetection collisionDetection)
: base(collisionDetection)
{
_triangleMeshAlgorithm = new TriangleMeshAlgorithm(collisionDetection);
}
/// <summary>
/// Initializes a new instance of the <see cref="PlaneRayAlgorithm"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
public PlaneRayAlgorithm(CollisionDetection collisionDetection)
: base(collisionDetection)
{
}
//--------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="TriangleTriangleAlgorithm"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
public TriangleTriangleAlgorithm(CollisionDetection collisionDetection)
: base(collisionDetection)
{
}
private readonly Gjk _gjk; // A cached GJK instance.
#endregion Fields
#region Constructors
/// <summary>
/// Initializes a new instance of the <see cref="RayBoxAlgorithm"/> class.
/// </summary>
/// <param name="collisionDetection">The collision detection service.</param>
public RayBoxAlgorithm(CollisionDetection collisionDetection)
: base(collisionDetection)
{
_gjk = new Gjk(collisionDetection);
}
