예제 #1
0
        public static void HandleMovement(IItem item)
        {
            item.Velocity = new Vector2(item.Velocity.X, item.Velocity.Y + Constants.G_CONST);
            Vector2 targetPosition = new Vector2(item.Position.X + item.Velocity.X, item.Position.Y + item.Velocity.Y);
            Vector2 finalPosition  = targetPosition;

            if (!CollisionDetector.IsPositionFree(item, targetPosition))
            {
                if (item.Velocity.Y >= Constants.CRUSHING_SPD_CONST)
                {
                    List <IEnemy> crushList = CollisionDetector.GetObjectsAtPosition <IEnemy>(item, targetPosition);
                    foreach (IEnemy enemy in crushList)
                    {
                        enemy.Kill();
                        ScoreManager.IncreaseScore(Constants.CRUSHING_PTS_CONST);
                    }
                }
                finalPosition = CollisionHelper.GetNewPosition(item, targetPosition);
                HandleCollisionDirections(item, finalPosition, targetPosition);
            }



            item.Position = finalPosition;
        }
예제 #2
0
        public override void DropItem()
        {
            float newItemX;

            if (StateManager.IsFacingRight)
            {
                newItemX = Position.X + Size.X + 1;
            }
            else
            {
                newItemX = Position.X - CurrentItem.Size.X - 1;
            }

            CurrentItem.CollisionType = CollisionType.Solid;
            if (!CollisionDetector.IsPositionFree(CurrentItem, new Vector2(newItemX, Position.Y + Size.Y - CurrentItem.Size.Y)))
            {
                CurrentItem.CollisionType = CollisionType.Liquid;
                return;
            }

            CurrentItem.Position          = new Vector2(newItemX, Position.Y);
            CurrentItem.Velocity          = new Vector2(0, Velocity.Y);
            StateManager.IsCarryingObject = false;
            CurrentItem = null;
        }
예제 #3
0
 private static bool GetPositionFree(ICollidable collidable, Vector2 newPosition, List <ICollidable> ignoreList)
 {
     if (ignoreList == null)
     {
         return(CollisionDetector.IsPositionFree(collidable, newPosition));
     }
     else
     {
         return(CollisionDetector.IsPositionFree(collidable, newPosition, ignoreList));
     }
 }
        public virtual void DropItem()
        {
            float newItemX = ItemXPosition();

            if (CollisionDetector.IsPositionFree(CurrentItem, new Vector2(newItemX, Position.Y + Size.Y - CurrentItem.Size.Y)))
            {
                CurrentItem.CollisionType     = CollisionType.Solid;
                CurrentItem.Position          = new Vector2(newItemX, Position.Y);
                CurrentItem.Velocity          = new Vector2(0, Velocity.Y);
                StateManager.IsCarryingObject = false;
                CurrentItem = null;
            }
        }
예제 #5
0
        public void Update()
        {
            ShouldNotifyReceivers = false;

            sprite.Update();
            if (!CollisionDetector.IsPositionFree(pressHitbox, Position))
            {
                Press();
            }
            else
            {
                Depress();
            }
        }
예제 #6
0
        public static void HandleMovement(IEnemy enemy)
        {
            Vector2 targetPosition = new Vector2(enemy.Position.X + enemy.Velocity.X, enemy.Position.Y + enemy.Velocity.Y);
            Vector2 finalPosition  = targetPosition;

            if (!CollisionDetector.IsPositionFree(enemy, targetPosition))
            {
                finalPosition = CollisionHelper.GetNewPosition(enemy, targetPosition);
                HandleCollisionDirections(enemy, finalPosition, targetPosition);
            }



            enemy.Position = finalPosition;
        }
        public static void HandleMovementAndCollisions(AbstractCharacter character)
        {
            character.Velocity = new Vector2(character.Velocity.X, character.Velocity.Y + Constants.G_CONST);
            Vector2 newPosition   = new Vector2(character.Position.X + character.Velocity.X, character.Position.Y + character.Velocity.Y);
            Vector2 finalPosition = newPosition;

            Vector2 itemNewPosition;
            Vector2 itemFinalPosition;

            List <ICollidable> ignoreList;

            ignoreList = new List <ICollidable>();
            if (character.CurrentItem != null)
            {
                ignoreList.Add(character);
                ignoreList.Add(character.CurrentItem);
            }

            if (CollisionDetector.IsPositionFree(character, new Vector2(character.Position.X, character.Position.Y + 1)))
            {
                character.GoToAir();
            }

            Vector2 testPosition = new Vector2(newPosition.X, character.Position.Y);

            HandleItemCollisions(character, testPosition);
            HandleCollectableCollisions(character, testPosition);
            HandleEnemyCollisions(character, testPosition);
            HandleTerrainCollisions(character, newPosition);

            if (!CollisionDetector.IsPositionFree(character, newPosition, ignoreList))
            {
                finalPosition = CollisionHelper.GetNewPosition(character, newPosition, ignoreList);

                if (finalPosition.Y < newPosition.Y)
                {
                    character.LandOnGround();
                }
                if (finalPosition.Y > newPosition.Y)
                {
                    character.HitBlockFromBelow();
                }
            }


            if (character.CurrentItem != null)
            {
                itemNewPosition   = Vector2.Add(character.CurrentItem.Position, Vector2.Subtract(finalPosition, character.Position));
                itemFinalPosition = itemNewPosition;
                if (!CollisionDetector.IsPositionFree(character.CurrentItem, itemNewPosition, ignoreList))
                {
                    itemFinalPosition = CollisionHelper.GetNewPosition(character.CurrentItem, itemNewPosition, ignoreList);

                    if (itemFinalPosition.Y < itemNewPosition.Y)
                    {
                        character.LandOnGround();
                    }
                    if (itemFinalPosition.Y > itemNewPosition.Y)
                    {
                        character.HitBlockFromBelow();
                    }
                }

                float itemDistance      = Vector2.Distance(itemFinalPosition, character.CurrentItem.Position);
                float characterDistance = Vector2.Distance(finalPosition, character.Position);
                if (characterDistance > itemDistance)
                {
                    finalPosition = Vector2.Add(character.Position, Vector2.Subtract(itemFinalPosition, character.CurrentItem.Position));
                }
            }

            character.Position = finalPosition;
            character.UpdateItemPosition();
        }