//-------------------------------------------------------------- /// <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 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); }