Example #1
0
        public void Initialize()
        {
            if (levelFile == null)
            {
                return;
            }
            MovableElements    = new List <IMoveable>();
            updateableElements = new List <IUpdateableObject>();
            drawableElements   = new List <IDrawableObject>();

            List <string> row    = new List <string>(levelFile[0].Split(','));
            int           width  = row.Count;
            int           height = levelFile.Count;

            Tiles = new ICollisionable[width, height];

            for (int j = 0; j < height; j++)
            {
                row = new List <string>(levelFile[j].Split(','));
                for (int i = 0; i < width; i++)
                {
                    Vector2    position = CalculatePositionWithCell(i, j);
                    Entity     entity;
                    EntityType entityType = EntityType.BlockCenter;
                    if (i != 0 && j != 0 && i != width - 1 && j != height - 1)
                    {
                        if (i < row.Count)
                        {
                            if (!resources.StringType.ContainsKey(row[i]))
                            {
                                continue;
                            }
                            entityType = resources.StringType[row[i]];
                        }
                    }

                    entity = resources.EntityTypeCreator[entityType].FactoryMethod(resources, position);
                    if (entity is IUpdateableObject)
                    {
                        updateableElements.Add((IUpdateableObject)entity);
                    }
                    if (entity is IDrawableObject)
                    {
                        drawableElements.Add((IDrawableObject)entity);
                    }
                    if (entity is IMoveable)
                    {
                        MovableElements.Add((IMoveable)entity);
                    }
                    if (!(entity is IMoveable) && entity is ICollisionable)
                    {
                        Tiles[i, j] = (ICollisionable)entity;
                    }
                    if (entity is Player)
                    {
                        Player = (Player)entity;
                    }
                }
            }
        }
Example #2
0
 public override void OnCollision(ICollisionable collisionableObject)
 {
     if (collisionableObject is IDamageable)
     {
         ((IDamageable)collisionableObject).LoseLife(Damage);
     }
 }
Example #3
0
 public override void OnCollision(ICollisionable collisionableObject)
 {
     if (collisionableObject is Player)
     {
         ((Player)collisionableObject).CurrentEntityStates.Add(EntityStates.Win);
     }
 }
Example #4
0
 public void OnCollision(ICollisionable source)
 {
     animationWatch = animationWatch ?? Stopwatch.StartNew();
     animationWatch.Reset();
     animationWatch.Start();
     _sprite = SpriteDuck;
     _size   = new Vector2(SpriteDuck.Width / 2f, SpriteDuck.Height / 2f);
 }
Example #5
0
 public bool Collide(ICollisionable other)
 {
     if (other is CollisionBox box)
     {
         if (Y > box.Y && Y < box.Bottom ||
             Bottom > box.Y && Bottom < box.Bottom)                     //Collision on the X-Axis
         {
             if (X == box.Right || Right == box.X)
             {
                 return(true);
             }
         }
         else if (X > box.X && X < box.Right ||
                  Right > box.X && Right < box.Right)                //Collision on the Y-Axis
         {
             if (Y == box.Bottom || Bottom == box.Y)
             {
                 return(true);
             }
         }
     }
     else if (other is CollisionCircle circle)
     {
         if (circle.Collide(LeftTop))
         {
             return(true);
         }
         if (circle.Collide(RightTop))
         {
             return(true);
         }
         if (circle.Collide(LeftBottom))
         {
             return(true);
         }
         if (circle.Collide(RightBottom))
         {
             return(true);
         }
         if (circle.Position.X > X && circle.Position.X < Right)
         {
             return(Collide(circle.Position + new Vector2(0, circle.Radius)) ||
                    Collide(circle.Position - new Vector2(0, circle.Radius)));
         }
         if (circle.Position.Y > Y && circle.Position.Y < Bottom)
         {
             return(Collide(circle.Position + new Vector2(circle.Radius, 0)) ||
                    Collide(circle.Position - new Vector2(circle.Radius, 0)));
         }
         return(false);
     }
     else
     {
         throw new NotSupportedException("Unknown Type " + other.GetType().Name);
     }
     return(false);
 }
Example #6
0
 protected GameObject(GameObject clone)
 {
     this.collision    = clone.collision;
     this.Position     = clone.Position;
     this.Size         = clone.Size;
     this.Velocity     = clone.Velocity;
     this.Acceleration = clone.Acceleration;
     this.friction     = clone.friction;
 }
Example #7
0
 public override void OnCollision(ICollisionable collisionableObject)
 {
     if (Position.Y == range.Max)
     {
         return;
     }
     if (collisionableObject is IDamageable)
     {
         ((IDamageable)collisionableObject).LoseLife(Damage);
     }
 }
Example #8
0
        public bool EstEnCollisionAvecUnObjet(ICollisionable objet)
        {
            bool valRetour = false;
            int  i         = 0;

            while (!valRetour && i < Components.Count)
            {
                valRetour = objet.EstEnCollision(Components[i]);
                ++i;
            }
            return(valRetour);
        }
Example #9
0
 public override void OnCollision(ICollisionable collisionableObject)
 {
     if (!Active)
     {
         return;
     }
     if (collisionableObject is IKeyOwner)
     {
         CollisionSound.Play();
         ((IKeyOwner)collisionableObject).Keys++;
     }
     Active = false;
 }
Example #10
0
 public override void OnCollision(ICollisionable collisionableObject)
 {
     if (!Active)
     {
         return;
     }
     if (collisionableObject is IScore)
     {
         CollisionSound.Play();
         ((IScore)collisionableObject).Score += Score;
         Active = false;
     }
 }
Example #11
0
        protected Dictionary <CollisionTypes, List <ICollisionable> > GetPlayerBorderCollisions(Player player, Rectangle playerBorderRectangle, Map map)
        {
            Dictionary <CollisionTypes, List <ICollisionable> > collisions = new Dictionary <CollisionTypes, List <ICollisionable> >();

            int firstXTileToCheck = playerBorderRectangle.X / map.TileSide;

            firstXTileToCheck = (int)MathHelper.Clamp(firstXTileToCheck, 0, map.Tiles.GetLength(0) - 1);
            int lastXTileToCheck = (playerBorderRectangle.X + playerBorderRectangle.Width - 1) / map.TileSide;

            lastXTileToCheck = (int)MathHelper.Clamp(lastXTileToCheck, 0, map.Tiles.GetLength(0) - 1);
            int firstYTileToCheck = playerBorderRectangle.Y / map.TileSide;

            firstYTileToCheck = (int)MathHelper.Clamp(firstYTileToCheck, 0, map.Tiles.GetLength(1) - 1);
            int lastYTileToCheck = (playerBorderRectangle.Y + playerBorderRectangle.Height - 1) / map.TileSide;

            lastYTileToCheck = (int)MathHelper.Clamp(lastYTileToCheck, 0, map.Tiles.GetLength(1) - 1);

            for (int i = firstXTileToCheck; i <= lastXTileToCheck; i++)
            {
                for (int j = firstYTileToCheck; j <= lastYTileToCheck; j++)
                {
                    ICollisionable tile = map.Tiles[i, j];
                    if (tile == null)
                    {
                        continue;
                    }
                    if (playerBorderRectangle.Intersects(tile.HitBox))
                    {
                        if (tile.CollisionType == CollisionTypes.Block)
                        {
                            if (!collisions.ContainsKey(CollisionTypes.Block))
                            {
                                collisions.Add(CollisionTypes.Block, new List <ICollisionable>());
                            }
                            collisions[CollisionTypes.Block].Add(tile);
                        }
                        if (tile.CollisionType == CollisionTypes.None)
                        {
                            if (!collisions.ContainsKey(CollisionTypes.None))
                            {
                                collisions.Add(CollisionTypes.None, new List <ICollisionable>());
                            }
                            collisions[CollisionTypes.None].Add(tile);
                        }
                    }
                }
            }
            return(collisions);
        }
Example #12
0
        public Projectile(Game game, ICollisionable source, ProjectileOptions options)
        {
            _game    = game;
            _source  = source;
            _options = options;
            Position = new Position {
                Current = options.StartPosition, Destination = options.StartPosition
            };
            _size          = new Vector2(options.Sprite.Width / 2f, options.Sprite.Height / 2f);
            _tweenMovement = new TweenMovement(this);

            if (options.Collision.Type == ProjectileCollisionType.SpecificTarget)
            {
                _tweenMovement.SetPosition(options.Collision.SpecificTarget, options.MovementSpeed);
            }
        }
Example #13
0
 public bool Intersects(ICollisionable other)
 {
     if (other is CollisionCircle circle)
     {
         Vector2 dif = circle.Position - Position;
         return(dif.LengthSquared() < Radius * Radius + circle.Radius * Radius);
     }
     else if (other is CollisionBox box)
     {
         if (box.Intersects(Position))
         {
             return(true);
         }
         if (Intersects(box.LeftTop))
         {
             return(true);
         }
         if (Intersects(box.RightTop))
         {
             return(true);
         }
         if (Intersects(box.LeftBottom))
         {
             return(true);
         }
         if (Intersects(box.RightBottom))
         {
             return(true);
         }
         if (Position.X > box.X && Position.X < box.Right)
         {
             return(box.Intersects(Position + new Vector2(0, Radius)) ||
                    box.Intersects(Position - new Vector2(0, Radius)));
         }
         if (Position.Y > box.Y && Position.Y < box.Bottom)
         {
             return(box.Intersects(Position + new Vector2(Radius, 0)) ||
                    box.Intersects(Position - new Vector2(Radius, 0)));
         }
         return(false);
     }
     else
     {
         throw new NotImplementedException("Unknown Type: " + other.GetType().Name);
     }
 }
Example #14
0
        public List <Point> GetEntityCoordinatesOnMap(ICollisionable entity)
        {
            int firstX = entity.HitBox.X / TileSide;
            int firstY = entity.HitBox.Y / TileSide;
            int lastX  = (entity.HitBox.X + entity.HitBox.Width - 1) / TileSide;
            int lastY  = (entity.HitBox.Y + entity.HitBox.Height - 1) / TileSide;

            List <Point> points = new List <Point>();

            for (int i = firstX; i <= lastX; i++)
            {
                for (int j = firstY; j <= lastY; j++)
                {
                    points.Add(new Point(i, j));
                }
            }
            return(points);
        }
Example #15
0
        public bool CheckCollision()
        {
            ICollisionable result = null;

            if (_options.Collision.Type == ProjectileCollisionType.SpecificTarget)
            {
                var target = _options.Collision.SpecificTarget;
                if (target == null)
                {
                    Remove();
                    return(false);
                }
                if (target.Position.Current != Position.Current)
                {
                    return(false);
                }

                result = target;
            }

            if (_options.Collision.Type == ProjectileCollisionType.FirstHit)
            {
                foreach (var entity in _game.Collisionables.Keys.Where(w => w != this && w != _source))
                {
                    var bounds = entity.GetBounds();
                    if (!Collisions.IsColliding(GetBounds(), bounds))
                    {
                        continue;
                    }
                    result = entity;
                }
            }

            if (result == null)
            {
                return(false);
            }

            CollidingWith = result;
            result.OnCollision(this);
            OnCollision(result);
            Remove();
            return(true);
        }
Example #16
0
        private bool CheckPlayerTilesCollisions(Rectangle playerRectangle)
        {
            int firstXTileToCheck = playerRectangle.X / TileSide;

            firstXTileToCheck = (int)MathHelper.Clamp(firstXTileToCheck, 0, Tiles.GetLength(0) - 1);
            int lastXTileToCheck = (playerRectangle.X + playerRectangle.Width) / TileSide;

            lastXTileToCheck = (int)MathHelper.Clamp(lastXTileToCheck, 0, Tiles.GetLength(0) - 1);
            int firstYTileToCheck = playerRectangle.Y / TileSide;

            firstYTileToCheck = (int)MathHelper.Clamp(firstYTileToCheck, 0, Tiles.GetLength(1) - 1);
            int lastYTileToCheck = (playerRectangle.Y + playerRectangle.Height) / TileSide;

            lastYTileToCheck = (int)MathHelper.Clamp(lastYTileToCheck, 0, Tiles.GetLength(1) - 1);

            for (int i = firstXTileToCheck; i <= lastXTileToCheck; i++)
            {
                for (int j = firstYTileToCheck; j <= lastYTileToCheck; j++)
                {
                    if (Tiles[i, j] == null)
                    {
                        continue;
                    }
                    ICollisionable tile = Tiles[i, j];
                    if (tile.CollisionType == CollisionTypes.Block)
                    {
                        if (playerRectangle.Intersects(tile.HitBox))
                        {
                            return(true);
                        }
                    }
                    if (tile.CollisionType == CollisionTypes.Top)
                    {
                        int playerBottomY = Player.HitBox.Y + Player.HitBox.Height - 1;
                        if ((playerBottomY < tile.HitBox.Y) &&
                            playerRectangle.Intersects(tile.HitBox))
                        {
                            return(true);
                        }
                    }
                }
            }
            return(false);
        }
Example #17
0
        protected void AddMovableElementsForCollision(Map map, Player player, Vector2 oldPosition, ref List <ICollisionable>[,] collisions)
        {
            Rectangle rectangle = Rectangle.Union(player.BoundingBox.BoxInPosition(oldPosition), player.BoundingBox.BoxInPosition(player.Position));

            for (int k = 0; k < map.MovableElements.Count; k++)
            {
                IMoveable movable = map.MovableElements[k];
                if (!(movable is ICollisionable))
                {
                    continue;
                }
                if (movable == player)
                {
                    continue;
                }
                ICollisionable collisionableObject = movable as ICollisionable;
                if (collisionableObject.HitBox.Intersects(rectangle))
                {
                    List <Point> coordinates = map.GetEntityCoordinatesOnMap(collisionableObject);
                    for (int l = 0; l < coordinates.Count; l++)
                    {
                        int i = coordinates[l].X;
                        int j = coordinates[l].Y;
                        if (i > collisions.GetLength(0) - 1 || j > collisions.GetLength(1) - 1)
                        {
                            continue;
                        }
                        if (collisions[i, j] == null)
                        {
                            collisions[i, j] = new List <ICollisionable>();
                        }
                        collisions[i, j].Add(collisionableObject);
                    }
                }
            }
        }
Example #18
0
        public override void Move(ICollisionable entity, Vector2 nextPosition, Map map)
        {
            Player player = entity as Player;

            bool      xBlocked = false;
            Rectangle playerHitBoxInNextPosition = player.BoundingBox.BoxInPosition(nextPosition);

            int firstXTileToCheck = player.HitBox.X / map.TileSide;

            firstXTileToCheck = (int)MathHelper.Clamp(firstXTileToCheck, 0, map.Tiles.GetLength(0) - 1);
            int lastXTileToCheck = (playerHitBoxInNextPosition.X + playerHitBoxInNextPosition.Width - 1) / map.TileSide;

            lastXTileToCheck = (int)MathHelper.Clamp(lastXTileToCheck, 0, map.Tiles.GetLength(0) - 1);
            int firstYTileToCheck = player.HitBox.Y / map.TileSide;

            firstYTileToCheck = (int)MathHelper.Clamp(firstYTileToCheck, 0, map.Tiles.GetLength(1) - 1);
            int lastYTileToCheck = (player.HitBox.Y + player.HitBox.Height - 1) / map.TileSide;

            lastYTileToCheck = (int)MathHelper.Clamp(lastYTileToCheck, 0, map.Tiles.GetLength(1) - 1);

            float nextPlayerPositionX = nextPosition.X;
            int   playerNextRightX    = playerHitBoxInNextPosition.X + playerHitBoxInNextPosition.Width;

            List <ICollisionable>[,] collisions = new List <ICollisionable> [lastXTileToCheck + 1, lastYTileToCheck + 1];

            for (int i = firstXTileToCheck; i <= lastXTileToCheck; i++)
            {
                for (int j = firstYTileToCheck; j <= lastYTileToCheck; j++)
                {
                    ICollisionable tile = map.Tiles[i, j];
                    if (tile == null)
                    {
                        continue;
                    }
                    if (playerNextRightX <= tile.HitBox.X)
                    {
                        continue;
                    }

                    if (tile.CollisionType != CollisionTypes.Top)
                    {
                        if (collisions[i, j] == null)
                        {
                            collisions[i, j] = new List <ICollisionable>();
                        }
                        collisions[i, j].Add(tile);
                    }

                    if (tile.CollisionType == CollisionTypes.Block)
                    {
                        nextPlayerPositionX = tile.HitBox.X - player.BoundingBox.OffSetRight;
                        lastXTileToCheck    = i;
                        xBlocked            = true;
                    }
                }
            }

            Vector2 oldPosition = player.Position;

            player.Position = Vector2.UnitX * nextPlayerPositionX + Vector2.UnitY * player.Position;

            AddMovableElementsForCollision(map, player, oldPosition, ref collisions);

            CheckCollisionsRight(firstXTileToCheck, firstYTileToCheck, lastXTileToCheck, lastYTileToCheck, xBlocked, map, collisions, player);
        }
Example #19
0
 public static bool Intersects(ICollisionable collisionAble1, ICollisionable collisionAble2, bool coll1flipped, bool coll2flipped, out int highY, out int lowY)
 {
     return(IntersectPixels(collisionAble1.CollisionArea, collisionAble1.Mask, collisionAble2.CollisionArea, collisionAble2.Mask, coll1flipped, coll2flipped, out highY, out lowY));
 }
Example #20
0
 public abstract void Move(ICollisionable player, Vector2 nextPosition, Map map);
Example #21
0
 private void CheckCollisions(ICollisionable proxyA, ICollisionable proxyB)
 {
     // ToDo
 }
Example #22
0
 public void OnCollision(ICollisionable source)
 {
     throw new NotImplementedException();
 }
Example #23
0
 public void OnCollision(ICollisionable collisionableObject)
 {
 }
Example #24
0
 public abstract void OnCollide(ICollisionable other);
Example #25
0
      public void EnCollisionAvec(ICollisionable i)
      {

      }
        public override void Move(ICollisionable entity, Vector2 nextPosition, Map map)
        {
            Player player = entity as Player;

            bool xBlocked = false;
            bool yBlocked = false;

            Rectangle playerHitBoxInNextPosition = player.BoundingBox.BoxInPosition(nextPosition);

            int firstXTileToCheck = player.HitBox.X / map.TileSide;

            firstXTileToCheck = (int)MathHelper.Clamp(firstXTileToCheck, 0, map.Tiles.GetLength(0) - 1);
            int lastXTileToCheck = (playerHitBoxInNextPosition.X + playerHitBoxInNextPosition.Width) / map.TileSide;

            lastXTileToCheck = (int)MathHelper.Clamp(lastXTileToCheck, 0, map.Tiles.GetLength(0) - 1);
            int firstYTileToCheck = player.HitBox.Y / map.TileSide;

            firstYTileToCheck = (int)MathHelper.Clamp(firstYTileToCheck, 0, map.Tiles.GetLength(1) - 1);
            int lastYTileToCheck = (playerHitBoxInNextPosition.Y + playerHitBoxInNextPosition.Height) / map.TileSide;

            lastYTileToCheck = (int)MathHelper.Clamp(lastYTileToCheck, 0, map.Tiles.GetLength(1) - 1);

            Vector2 nextPlayerPosition = player.Position;
            int     playerRightX       = player.HitBox.X + player.HitBox.Width;
            int     playerBottomY      = player.HitBox.Y + player.HitBox.Height;
            int     playerNextBottomY  = playerHitBoxInNextPosition.Y + playerHitBoxInNextPosition.Height;

            List <ICollisionable>[,] collisions = new List <ICollisionable> [lastXTileToCheck + 1, lastYTileToCheck + 1];

            for (int i = firstXTileToCheck; i <= lastXTileToCheck; i++)
            {
                for (int j = firstYTileToCheck; j <= lastYTileToCheck; j++)
                {
                    ICollisionable tile = map.Tiles[i, j];
                    if (tile == null)
                    {
                        continue;
                    }

                    Vector2   playerIntermediatePosition;
                    Rectangle hitBoxInNextPositionToCheck;
                    Rectangle borderHitBox;

                    if (playerNextBottomY >= tile.HitBox.Y && playerBottomY <= tile.HitBox.Y)
                    {
                        float intermediatePlayerPositionYToCheck = tile.HitBox.Y - player.BoundingBox.OffSetBottom;
                        playerIntermediatePosition = player.GetIntermediatePositionWithY(nextPosition, intermediatePlayerPositionYToCheck);

                        hitBoxInNextPositionToCheck = player.BoundingBox.BoxInPosition(playerIntermediatePosition);
                        borderHitBox = new Rectangle(hitBoxInNextPositionToCheck.X, hitBoxInNextPositionToCheck.Y + hitBoxInNextPositionToCheck.Height, hitBoxInNextPositionToCheck.Width, 1);
                        if (tile.HitBox.Intersects(borderHitBox))
                        {
                            if (tile.CollisionType == CollisionTypes.None)
                            {
                                if (collisions[i, j] == null)
                                {
                                    collisions[i, j] = new List <ICollisionable>();
                                }
                                collisions[i, j].Add(tile);
                            }
                            if (tile.CollisionType == CollisionTypes.Block || tile.CollisionType == CollisionTypes.Top)
                            {
                                nextPlayerPosition = playerIntermediatePosition;
                                lastXTileToCheck   = (hitBoxInNextPositionToCheck.X + hitBoxInNextPositionToCheck.Width - 1) / map.TileSide;
                                lastYTileToCheck   = (hitBoxInNextPositionToCheck.Y + hitBoxInNextPositionToCheck.Height - 1) / map.TileSide;
                                yBlocked           = true;
                            }
                        }
                    }
                    if (playerRightX <= tile.HitBox.X)
                    {
                        float intermediatePlayerPositionXToCheck = tile.HitBox.X - player.BoundingBox.OffSetRight;
                        playerIntermediatePosition = player.GetIntermediatePositionWithX(nextPosition, intermediatePlayerPositionXToCheck);

                        hitBoxInNextPositionToCheck = player.BoundingBox.BoxInPosition(playerIntermediatePosition);
                        borderHitBox = new Rectangle(hitBoxInNextPositionToCheck.X + hitBoxInNextPositionToCheck.Width, hitBoxInNextPositionToCheck.Y, 1, hitBoxInNextPositionToCheck.Height);
                        if (tile.HitBox.Intersects(borderHitBox))
                        {
                            if (tile.CollisionType == CollisionTypes.None)
                            {
                                if (collisions[i, j] == null)
                                {
                                    collisions[i, j] = new List <ICollisionable>();
                                }
                                collisions[i, j].Add(tile);
                            }
                            if (tile.CollisionType == CollisionTypes.Block)
                            {
                                nextPlayerPosition = playerIntermediatePosition;
                                lastXTileToCheck   = (hitBoxInNextPositionToCheck.X + hitBoxInNextPositionToCheck.Width - 1) / map.TileSide;
                                lastYTileToCheck   = (hitBoxInNextPositionToCheck.Y + hitBoxInNextPositionToCheck.Height - 1) / map.TileSide;
                                xBlocked           = true;
                            }
                        }
                    }
                    if (!xBlocked && !yBlocked)
                    {
                        float intermediatePlayerPositionXToCheck = tile.HitBox.X - player.BoundingBox.OffSetRight;
                        playerIntermediatePosition = player.GetIntermediatePositionWithX(nextPosition, intermediatePlayerPositionXToCheck);

                        hitBoxInNextPositionToCheck = player.BoundingBox.BoxInPosition(playerIntermediatePosition);
                        borderHitBox = new Rectangle(hitBoxInNextPositionToCheck.X + hitBoxInNextPositionToCheck.Width, hitBoxInNextPositionToCheck.Y + hitBoxInNextPositionToCheck.Height, 1, 1);
                        if (tile.HitBox.Intersects(borderHitBox))
                        {
                            if (tile.CollisionType == CollisionTypes.None)
                            {
                                if (collisions[i, j] == null)
                                {
                                    collisions[i, j] = new List <ICollisionable>();
                                }
                                collisions[i, j].Add(tile);
                            }
                            if (tile.CollisionType == CollisionTypes.Block)
                            {
                                nextPlayerPosition = playerIntermediatePosition;
                                lastXTileToCheck   = (hitBoxInNextPositionToCheck.X + hitBoxInNextPositionToCheck.Width - 1) / map.TileSide;
                                lastYTileToCheck   = (hitBoxInNextPositionToCheck.Y + hitBoxInNextPositionToCheck.Height - 1) / map.TileSide;

                                xBlocked = true;
                            }
                        }
                    }
                }
            }

            if (!xBlocked && !yBlocked)
            {
                Vector2 oldPosition = player.Position;
                player.Position = nextPosition;

                AddMovableElementsForCollision(map, player, oldPosition, ref collisions);

                CheckCollisions(firstXTileToCheck, firstYTileToCheck, map, collisions, player);
            }
            else
            {
                Vector2 oldPosition = player.Position;
                player.Position = Vector2.UnitX * nextPlayerPosition + Vector2.UnitY * nextPlayerPosition;

                AddMovableElementsForCollision(map, player, oldPosition, ref collisions);

                if (xBlocked)
                {
                    Rectangle playerRightSide = new Rectangle(player.HitBox.X + player.HitBox.Width, player.HitBox.Y, 1, player.HitBox.Height);
                    Dictionary <CollisionTypes, List <ICollisionable> > borderCollisions = GetPlayerBorderCollisions(player, playerRightSide, map);
                    CheckCollisions(firstXTileToCheck, firstYTileToCheck, map, collisions, player, borderCollisions);
                    player.Speed *= Vector2.UnitY;
                    MovePlayerDown(player, nextPosition, map);
                }
                else
                {
                    Rectangle playerBottomSide = new Rectangle(player.HitBox.X, player.HitBox.Y + player.HitBox.Height, player.HitBox.Width, 1);
                    Dictionary <CollisionTypes, List <ICollisionable> > borderCollisions = GetPlayerBorderCollisions(player, playerBottomSide, map);
                    CheckCollisions(firstXTileToCheck, firstYTileToCheck, map, collisions, player, borderCollisions);
                    MovePlayerRight(player, nextPosition, map);
                }
            }
        }
Example #27
0
 public override void OnCollide(ICollisionable other)
 {
     // do some damage and movement stuff now
 }
Example #28
0
 public static bool Intersects(ICollisionable collisionAble1, ICollisionable collisionAble2, bool coll1flipped = false, bool coll2flipped = false)
 {
     return(IntersectPixels(collisionAble1.CollisionArea, collisionAble1.Mask, collisionAble2.CollisionArea, collisionAble2.Mask, coll1flipped, coll2flipped));
 }
 public bool CollidedWith(ICollisionable component)
 {
     return BoundingBox.Intersects(component.BoundingBox);
 }
Example #30
0
 public void OnCollision(ICollisionable source)
 {
     _options.Collision.OnCollision?.Invoke(source);
     Remove();
 }
 public void EnCollisionAvec(ICollisionable i)
 {
    EntitésEnCollision.Add(i);
 }
 public bool CollidedWith(ICollisionable component)
 {
     return(BoundingBox.Intersects(component.BoundingBox));
 }