private void EnemyCollision(EntityContainer <Enemy> squadron)
{
squadron.Iterate(delegate(Enemy enemy) {
if (CollisionDetection.Aabb(player.Shape.AsDynamicShape(), enemy.Shape).Collision)
{
enemy.DeleteEntity();
GalagaBus.GetBus().RegisterEvent(
GameEventFactory <object> .CreateGameEventForAllProcessors(
GameEventType.PlayerEvent,
this,
"LOSE_LIFE",
"", ""));
}
if (enemy.Shape.Position.Y + enemy.Shape.Extent.Y <= 0.0f)
{
enemy.DeleteEntity();
GalagaBus.GetBus().RegisterEvent(
GameEventFactory <object> .CreateGameEventForAllProcessors(
GameEventType.PlayerEvent,
this,
"LOSE_LIFE",
"", ""));
}
});
}
public static void IterateShot(EntityContainer <Projectile> projectiles,
List <ISquadron> squads)
{
foreach (Projectile projectile in projectiles)
{
projectile.Shape.Move();
if (projectile.Shape.Position.Y > 1.0f)
{
projectile.DeleteEntity();
}
foreach (ISquadron squad in squads)
{
EntityContainer <Enemy> enemies = squad.Enemies;
foreach (Enemy enemy in enemies)
{
CollisionData collision =
CollisionDetection.Aabb(((DynamicShape)projectile.Shape),
enemy.Shape);
if (collision.Collision)
{
projectile.DealDamage(enemy);
}
projectiles.Iterate(Projectile.delete);
}
enemies.Iterate(Projectile.deleteE);
}
}
}
private void UpdateShots()
{
EntityContainer <PlayerShot> newPlayerShots = new EntityContainer <PlayerShot>();
playerShots.Iterate(delegate(PlayerShot shot) {
if (!shot.IsDeleted())
{
shot.Move();
newPlayerShots.AddDynamicEntity(shot);
}
foreach (ISquadron squadron in Enemies)
{
foreach (Enemy enemy in squadron.Enemies)
{
CollisionData collision =
CollisionDetection.Aabb(
shot.Shape.AsDynamicShape(),
enemy.Shape.AsDynamicShape());
if (collision.Collision && !shot.IsDeleted())
{
shot.DeleteEntity();
enemy.Hit();
AddExplosion(enemy.Shape.Position.X, enemy.Shape.Position.Y,
enemy.Shape.Extent.X, enemy.Shape.Extent.Y);
}
}
}
});
playerShots = newPlayerShots;
}
private void Collision()
{
foreach (Entity entity in paintBoard.Images)
{
switch (CollisionDetection.Aabb(
(DynamicShape)player.Entity.Shape, entity.Shape).Collision)
{
case true:
AddExplosion(player.Entity.Shape.Position,
player.Entity.Shape.Extent);
player.Entity.DeleteEntity();
break;
}
var newPlayerList = new List <Player>();
foreach (var player in playerList)
{
if (!player.Entity.IsDeleted())
{
newPlayerList.Add(player);
}
if (player.Entity.IsDeleted())
{
SpaceBus.GetBus().RegisterEvent(
GameEventFactory <object> .CreateGameEventForAllProcessors
(GameEventType.GameStateEvent, this,
"CHANGE_STATE", "GAME_OVER", ""));
}
}
playerList = newPlayerList;
}
}
public void IterateShots()
{
void IterateForShoots(PlayerShot shot)
{
shot.Shape.Move();
if (shot.Shape.Position.Y > 1.0f)
{
shot.DeleteEntity();
}
else
{
void Collision(Enemy enemy)
{
if (CollisionDetection.Aabb(shot.Shape.AsDynamicShape(), enemy.Shape).Collision)
{
shot.DeleteEntity();
enemy.DeleteEntity();
AddExplosion(enemy.Shape.Position.X, enemy.Shape.Position.Y,
enemy.Shape.Extent.X, enemy.Shape.Extent.Y);
score.AddPoint();
}
}
enemies.Iterate(Collision);
}
}
playerShots.Iterate(IterateForShoots);
}
public static void iterateShots()
{
foreach (var shot in Game.PlayerShots)
{
shot.Shape.Move();
if (shot.Shape.Position.Y > 1.0f)
{
shot.DeleteEntity();
}
else
{
foreach (var enemy in Game.enemies)
{
var col = CollisionDetection.Aabb(shot.Shape.AsDynamicShape(), enemy.Shape);
if (col.Collision)
{
shot.AddExplosion(enemy.Shape.Position.X, enemy.Shape.Position.Y,
enemy.Shape.Extent.X, enemy.Shape.Extent.Y);
explosions.RenderAnimations();
enemy.DeleteEntity();
shot.DeleteEntity();
}
}
}
}
}
/// <summary>
/// Move an actor in its predefined direction, checking for collisions
/// with a list of obstacles.
/// </summary>
/// <returns>If any collision occured</returns>
private bool CheckActorMove(DynamicShape actor, List <StationaryShape> obstacles, int iterations)
{
var collision = false;
for (int i = 0; i < iterations; i++)
{
actor.Move();
foreach (var obstacle in obstacles)
{
collision = CollisionDetection.Aabb(actor, obstacle).Collision;
if (collision)
{
Console.WriteLine($"Encountered collision:\n" +
$"actor lower left: {actor.Position}\n" +
$"actor upper left: {actor.Position + new Vec2F(0.0f, actor.Extent.Y)}\n" +
$"actor upper right: {actor.Position + actor.Extent}\n" +
$"actor upper left: {actor.Position + new Vec2F(actor.Extent.X, 0.0f)}\n" +
$"obstacle pos: {obstacle.Position}\n" +
$"obstacle extent: {obstacle.Extent}"
);
//actor.pos: {actor.Position}, obstacle.pos: {obstacle.Position}");
return(true);
}
}
}
return(collision);
}
public void IterateShots()
{
foreach (PlayerShot shot in playerShots)
{
shot.Shape.Move();
if (shot.Shape.Position.Y > 1.0f)
{
shot.DeleteEntity();
}
else
{
foreach (Enemy enemy in enemies)
{
if ((CollisionDetection.Aabb(shot.Shape.AsDynamicShape(), enemy.Shape)).Collision)
{
shot.DeleteEntity();
enemy.DeleteEntity();
AddExplosion(enemy.Shape.Position.X, enemy.Shape.Position.Y, enemy.Shape.Extent.X, enemy.Shape.Extent.Y);
score.AddPoint();
}
}
}
}
}
public void RenderState()
{
backGroundImage.RenderEntity();
player.entity.RenderEntity();
row.Enemies.Iterate(entity => entity.RenderEntity());
explosions.RenderAnimations();
foreach (var shot in player.PlayerShots)
{
shot.RenderEntity();
foreach (Enemy enemy in row.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);
}
}
}
score.RenderScore();
}
public void TestCollisionMultiplicationFactorCloseness()
{
var wall = new StationaryShape(new Vec2F(0.0f, 0.0f), new Vec2F(1.0f, 1.0f));
var move = new DynamicShape(new Vec2F(2.0f, 0.0f), new Vec2F(1.0f, 1.0f), new Vec2F(-1.0f, 0.0f));
var data = CollisionDetection.Aabb(move, wall);
Assert.IsFalse(data.Collision);
}
public void TestCollisionMultiplicationFactorExactness()
{
var wall = new StationaryShape(new Vec2F(0.0f, 0.0f), new Vec2F(1.0f, 1.0f));
var move = new DynamicShape(new Vec2F(2.0f, 0.0f), new Vec2F(1.0f, 1.0f), new Vec2F(-2.0f, 0.0f));
var data = CollisionDetection.Aabb(move, wall);
Assert.AreEqual(data.DirectionFactor.X, 0.5f);
}
public static bool CheckCollisionPassenger(List <Passenger> levelPassengers, Player player,
List <Dictionary <Char, List <Entity> > > diffrentPlatforms)
{
foreach (var passenger in levelPassengers)
{
//If Passenger player flies into passenger.
if (CollisionDetection.Aabb(passenger.GetShape(),
player.GetsShape().AsStationaryShape()).Collision&& !passenger.PickedUp &&
diffrentPlatforms[passenger.SetOffLevel]
.ContainsKey(passenger.GetReleasePlatformChar()) &&
player.GetsShape().Direction.Y == 0.0f &&
player.GetsShape().Direction.Y == 0.0f &&
passenger.SpawnTimer())
{
passenger.PickedUp = true;
passenger.GetShape().Direction.X = 0.0f;
PassengerCollision.passengerPickups.Add(passenger);
return(true);
//If Passenger walks into Player.
}
if (CollisionDetection.Aabb(player.GetsShape(),
passenger.GetShape().AsStationaryShape()).Collision&&
!passenger.PickedUp &&
diffrentPlatforms[passenger.SetOffLevel]
.ContainsKey(passenger.GetReleasePlatformChar()) &&
passenger.SpawnTimer())
{
passenger.PickedUp = true;
PassengerCollision.passengerPickups.Add(passenger);
return(true);
//If Passenger player flies into passenger.
}
if (CollisionDetection.Aabb(player.GetsShape(),
passenger.GetShape().AsStationaryShape()).Collision&&
!passenger.PickedUp &&
passenger.GetReleasePlatformChar() == '^' && passenger.SpawnTimer())
{
PassengerCollision.passengerPickups.Add(passenger);
passenger.PickedUp = true;
}
//If Passenger walks into Player.
if (CollisionDetection.Aabb(passenger.GetShape(),
player.GetsShape().AsStationaryShape()).Collision&& !passenger.PickedUp &&
passenger.GetReleasePlatformChar() == '^' && passenger.SpawnTimer())
{
PassengerCollision.passengerPickups.Add(passenger);
passenger.PickedUp = true;
}
}
return(false);
}
public void StudentCheck()
{
// Copied in the exact parameters from assignment 9 debug run where it first fails
StationaryShape s = new StationaryShape(new Vec2F(0.9f, 0.739130437f), new Vec2F(0.025f, 0.0434782617f));
DynamicShape a = new DynamicShape(new Vec2F(0.744843602f, 0.783036947f),
new Vec2F(0.065f, 0.05f), new Vec2F(-0.00157072174f, -0.00205000024f));
Assert.IsFalse(CollisionDetection.Aabb(a, s).Collision);
}
public static bool CustomerCollision(Player player, Customer customer)
{
var collisionData = CollisionDetection.Aabb(player.Shape, customer.Shape);
if (collisionData.Collision)
{
return(true);
}
return(false);
}
public bool Collision(Shape shape)
{
var collisionData = CollisionDetection.Aabb(Shape.AsDynamicShape(), shape);
if (!collisionData.Collision)
{
return(false);
}
DeleteEntity();
return(true);
}
/// <summary>
/// Checks collision between obstacle and player
/// </summary>
/// <param name="player">DynamicShape player</param>
/// <param name="obstacles">EntityContainer of obstacles</param>
/// <returns>bool if the collsion is true or false</returns>
public static bool CollisionObstacle(DynamicShape player, EntityContainer obstacles)
{
foreach (Entity obstacle in obstacles)
{
var check = CollisionDetection.Aabb(player, obstacle.Shape);
if (check.Collision)
{
return(true);
}
}
return(false);
}
public void TestNoCollisionDirectionDown()
{
actor.Direction.X = 0.0f;
actor.Direction.Y = -actorVelocity;
for (int i = 0; i < 20; i++)
{
var data = CollisionDetection.Aabb(actor, solidBlockUp);
actor.Position += actor.Direction;
Assert.IsFalse(data.Collision);
}
}
public void MovePlayer(Vec2F dir)
{
((DynamicShape)player.Shape).Direction = dir;
var collide = CollisionDetection.Aabb((DynamicShape)player.Shape, wall.Shape);
if (collide.Collision)
{
Console.WriteLine($"CollisionDetection occured in direction {collide.CollisionDir}");
dir *= collide.DirectionFactor;
}
player.Shape.Position += dir;
}
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);
}
/// <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;
}
}
}
/// <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", ""));
}
}
}
/// <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>
/// 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>
/// 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;
}
/// <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>
public static bool CollisionPlatform(DynamicShape player,
EntityContainer platforms)
{
foreach (Entity platform in platforms)
{
var check = CollisionDetection.Aabb(player,
platform.Shape); {
if (check.Collision)
{
return(true);
}
}
}
return(false);
}
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
}
/// <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);
}
