private void SpawnNeedle(SpriteOrientation orientation)
{
NeedleEnemy needle = null;
for (int i = needles.Count - 1; i >= 0; i--) //Grab a dead needle from the list or...
{
if (needles[i].IsAlive)
{
continue;
}
needle = needles[i];
break;
}
if (needle == null) //make a new one if there were no dead needles to grab
{
needle = new NeedleEnemy(needleRect, this.Power, needleSpeed, needleFrequency, orientation, CollisionType.Liquid, MessageToReceivers);
needles.Add(needle);
}
else
{
needle.Position = new Vector2(needleRect.X, needleRect.Y);
needle.SetOrientation(orientation);
needle.IsAlive = true;
}
CollisionDetector.AddCollidable(needle);
}
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;
}
private static Vector2 AbsoluteFixOffsetCollision(ICollidable collidable, Vector2 guessedPosition, Vector2 offset, List <ICollidable> ignoreList)
{
List <ICollidable> otherList;
if (ignoreList == null)
{
otherList = CollisionDetector.GetCollisionsAtPosition(collidable, Vector2.Add(guessedPosition, offset));
}
else
{
otherList = CollisionDetector.GetCollisionsAtPosition(collidable, Vector2.Add(guessedPosition, offset), ignoreList);
}
int xDirection = -Math.Sign(offset.X);
int yDirection = -Math.Sign(offset.Y);
foreach (ICollidable other in otherList)
{
Vector2 tempCollisionPosition;
Vector2 tempCollisionSize;
OutCollisionRectangle(collidable, Vector2.Add(guessedPosition, offset), other, out tempCollisionPosition, out tempCollisionSize);
if (tempCollisionSize != Vector2.Zero)
{
guessedPosition = MoveOutOfOtherInDirection(collidable, offset, other, tempCollisionSize);
}
}
return(guessedPosition);
}
public virtual void SetItemSetList(List <ItemSet> list)
{
itemSetList = list;
foreach (ItemSet set in list)
{
CollisionDetector.AddCollidableList(set.Collidables);
}
}
private void UpdateStateManager()
{
List <Actions> actions = new List <Actions>();
bool hasPressedLeft = false, hasPressedRight = false, hasDrank = false;
foreach (IController controller in controllers)
{
if (controller.IsActionActive(Actions.MoveLeft))
{
hasPressedLeft = true;
if (!hasPressedRight)
{
actions.Add(Actions.MoveLeft);
CollisionDetector.DoPositionsIntersect(Position, Position, Position, Position);
}
}
if (controller.IsActionActive(Actions.MoveRight))
{
hasPressedRight = true;
if (!hasPressedLeft)
{
actions.Add(Actions.MoveRight);
}
}
if (!hasPressedLeft && !hasPressedRight)
{
Velocity = new Vector2(0, Velocity.Y);
}
if (controller.IsActionActive(Actions.Jump))
{
actions.Add(Actions.Jump);
}
if (controller.IsActionActive(Actions.PickUp))
{
if (keyPickupHeld == false)
{
actions.Add(Actions.PickUp);
keyPickupHeld = true;
}
}
else
{
keyPickupHeld = false;
}
if (controller.IsActionActive(Actions.Drink) && !hasDrank)
{
hasDrank = true;
actions.Add(Actions.Drink);
}
}
ProcessActions(actions);
}
public virtual void SetCollectableList(List <ICollectable> list)
{
foreach (ICollectable c in list)
{
ICollidable collidable = (ICollidable)c;
collectableList.Add(collidable);
CollisionDetector.AddCollidable(collidable);
}
}
public virtual void SetEnemyList(List <IEnemy> list)
{
foreach (IEnemy c in list)
{
ICollidable collidable = (ICollidable)c;
enemyList.Add(collidable);
CollisionDetector.AddCollidable(collidable);
}
}
public virtual void SetTerrainList(List <AbstractTerrain> list)
{
foreach (AbstractTerrain c in list)
{
ICollidable collidable = (ICollidable)c;
terrainList.Add(collidable);
CollisionDetector.AddCollidable(collidable);
}
}
private static void HandleCollectableCollisions(AbstractCharacter character, Vector2 newPosition)
{
List <ICollectable> collectableList = CollisionDetector.GetObjectsAtPosition <ICollectable>(character, newPosition);
foreach (ICollectable collectable in collectableList)
{
RespondToICollectableCollision(collectable, character);
}
}
public virtual void SetItemList(List <IItem> list)
{
foreach (IItem c in list)
{
ICollidable collidable = (ICollidable)c;
itemList.Add(collidable);
CollisionDetector.AddCollidable(collidable);
}
}
public virtual void SetCharacterList(List <AbstractCharacter> list)
{
foreach (AbstractCharacter c in list)
{
ICollidable collidable = (ICollidable)c;
characterList.Add(collidable);
CollisionDetector.AddCollidable(collidable);
}
}
private static void HandleEnemyCollisions(AbstractCharacter character, Vector2 newPosition)
{
List <IEnemy> enemyList = CollisionDetector.GetObjectsAtPosition <IEnemy>(character, newPosition);
foreach (IEnemy enemy in enemyList)
{
RespondToIEnemyCollision(enemy, character);
}
}
public void Update()
{
List <ICollidable> collidableList;
sprite.Update();
collidableList = CollisionDetector.GetCollisionsAtPosition(hitboxTop, hitboxTop.Position);
MoveColliders(collidableList, TotalSpeed());
collidableList = CollisionDetector.GetCollisionsAtPosition(hitboxBot, hitboxBot.Position);
MoveColliders(collidableList, TotalSpeed());
}
private static void HandleItemCollisions(AbstractCharacter character, Vector2 newPosition)
{
List <IItem> itemList = CollisionDetector.GetObjectsAtPosition <IItem>(character, newPosition);
HandlePushing(character, newPosition, itemList);
foreach (IItem item in itemList)
{
RespondToIItemCollision(item, character);
}
}
public void Update()
{
if (!isWaitingForActivation)
{
List <AbstractCharacter> characters = CollisionDetector.GetObjectsAtPosition <AbstractCharacter>(hitbox, hitbox.Position);
foreach (AbstractCharacter character in characters)
{
character.Position = new Vector2(destination.X, destination.Y - character.Size.Y);
}
}
}
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;
}
}
public void Update()
{
ShouldNotifyReceivers = false;
sprite.Update();
if (!CollisionDetector.IsPositionFree(pressHitbox, Position))
{
Press();
}
else
{
Depress();
}
}
public virtual void PickupItem()
{
if (CurrentItem == null)
{
float newItemX = ItemXPosition();
List <PickupItem> items = CollisionDetector.GetObjectsAtPosition <PickupItem>(this, new Vector2(newItemX, Position.Y));
if (items.Count > 0)
{
CurrentItem = items[0];
items[0].CollisionType = CollisionType.Liquid;
StateManager.IsCarryingObject = true;
}
}
}
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;
}
private static void OutCollisionRectangle(ICollidable collidable1, Vector2 newPosition, ICollidable collidable2, out Vector2 position, out Vector2 size)
{
if (!CollisionDetector.DoPositionsIntersect(newPosition, collidable1.Size, collidable2.Position, collidable2.Size))
{
position = size = new Vector2();
return;
}
float x1 = Math.Max(newPosition.X, collidable2.Position.X);
float y1 = Math.Max(newPosition.Y, collidable2.Position.Y);
float x2 = Math.Min(newPosition.X + collidable1.Size.X, collidable2.Position.X + collidable2.Size.X);
float y2 = Math.Min(newPosition.Y + collidable1.Size.Y, collidable2.Position.Y + collidable2.Size.Y);
position = new Vector2(x1, y1);
size = new Vector2(Math.Abs(x2 - x1), Math.Abs(y2 - y1));
}
public Level()
{
this.IsCompleted = false;
this.TransitionType = Constants.NO_LEVEL_STRING;
this.IsFailed = false;
this.IsEventActivated = false;
this.camera = new Camera();
this.characterList = new List <ICollidable>();
this.enemyList = new List <ICollidable>();
this.collectableList = new List <ICollidable>();
this.itemList = new List <ICollidable>();
this.terrainList = new List <ICollidable>();
this.controllerList = new List <IController>();
CollisionDetector.ClearDetector();
}
public override void PickupItem()
{
if (CurrentItem == null)
{
float newItemX;
if (StateManager.IsFacingRight)
{
newItemX = Position.X + Size.X + 1;
}
else
{
newItemX = Position.X - 1;
}
List <PickupItem> items = CollisionDetector.GetObjectsAtPosition <PickupItem>(this, new Vector2(newItemX, Position.Y));
if (items.Count > 0)
{
CurrentItem = items[0];
items[0].CollisionType = CollisionType.Liquid;
StateManager.IsCarryingObject = true;
}
}
}
public void Kill()
{
CollisionDetector.RemoveCollidable(this);
IsAlive = false;
}
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();
}
