private bool IsColliding(CollisionDirection direction)
{
Vector2 y = transform.up;
float yHeight = ballSprite.bounds.extents.y * transform.localScale.y;
Vector2 x = transform.right;
float xWidth = ballSprite.bounds.extents.x * transform.localScale.x;
switch (direction)
{
case CollisionDirection.Top:
return(_IsColliding(y, yHeight));
case CollisionDirection.Right:
return(_IsColliding(x, xWidth));
case CollisionDirection.Bottom:
return(_IsColliding(-y, yHeight));
case CollisionDirection.Left:
return(_IsColliding(-x, xWidth));
default:
throw new Exception("Invalid CollisionDirection passed to IsColliding");
}
}
public static void HandleCollision(Goomba goomba, IGameObject target)
{
Rectangle goombaRectangle = goomba.GetSizeRectangle();
if (goomba.state is FlipedGoombaState)
{
return;
}
if (target is IEnemy enemy)
{
Rectangle enemyRectangle = enemy.GetSizeRectangle();
CollisionDirection direction = CollisionDetection.DetectCollisionDirection(goombaRectangle, enemyRectangle);
if (!(direction is CollisionDirection.NoCollision))
{
if (direction is CollisionDirection.Left)
{
goomba.position = new Vector2(enemy.GetSizeRectangle().X - goomba.GetSizeRectangle().Width, goomba.position.Y);
goomba.moveLeft = true;
}
else if (direction is CollisionDirection.Right)
{
goomba.position = new Vector2(enemy.GetSizeRectangle().X + enemy.GetSizeRectangle().Width, goomba.position.Y);
goomba.moveLeft = false;
}
}
}
}
public Collision(Rectangle S, Rectangle D, CollisionType T, CollisionDirection Di)
{
Src = S;
Dest = D;
Type = T;
Dir = Di;
}
public override void HandleCollision(CollisionDirection collisionDirection, GameObject gameObject)
{
if (gameObject is FireBall || gameObject is Sword)
{
if ((this.bowserState is BowserChargeState || this.bowserState is BowserIdleState))
{
if ((collisionDirection == CollisionDirection.Left && this.IsFacingLeft) ||
(collisionDirection == CollisionDirection.Right && !this.IsFacingLeft))
{
this.health--;
if (this.health == 0)
{
this.bowserState.HandleDeadTransition();
}
}
}
}
else if (gameObject is Mario && ((Mario)gameObject).IsInvincible())
{
this.bowserState.HandleDeadTransition();
}
else if (gameObject is Block)
{
if (!(collisionDirection == CollisionDirection.Bottom))
{
this.YSpeed = 0.0f;
}
}
if (collisionDirection == CollisionDirection.Left || collisionDirection == CollisionDirection.Right)
{
this.XSpeed *= -1;
}
}
public void Execute()
{
if (!Game1.Instance.isPkMode)
{
warpRectangle = Game1.Instance.warpPipe.GetSizeRectangle();
}
Rectangle marioRectangle = mario.GetSizeRectangle();
marioRectangle.Height += 2;
CollisionDirection dir = CollisionDetection.DetectCollisionDirection(marioRectangle, warpRectangle);
if (dir == CollisionDirection.Top)
{
if (Game1.Instance.backgroundColor == Color.CornflowerBlue)
{
SoundFactory.Instance.playPipeSoundEffect();
Game1.Instance.LoadUndergroundLevel();
}
else if (Game1.Instance.backgroundColor == Color.Black)
{
SoundFactory.Instance.playPipeSoundEffect();
Game1.Instance.LoadOvergroundLevel();
}
return;
}
Game1.Instance.Mario.ToDown();
}
bool checkTopWindow(Rectangle collider, NativeMethods.RECT rctO, IntPtr currentWindowHandle)
{
NativeMethods.RECT rct;
IntPtr nextWindow = NativeMethods.GetTopWindow(IntPtr.Zero);
StringBuilder sb = new StringBuilder(128);
while (nextWindow != IntPtr.Zero)
{
if (NativeMethods.IsWindowVisible(nextWindow) && !NativeMethods.IsIconic(nextWindow) && nextWindow != Handle)
{
if (nextWindow == currentWindowHandle)
{
return(false);
}
NativeMethods.GetWindowText(nextWindow, sb, 128);
NativeMethods.GetWindowRect(new System.Runtime.InteropServices.HandleRef(this, nextWindow), out rct);
CollisionDirection windowCollision = Collisions.CheckCollision(Collisions.GetRectangleFromNative(rctO), Collisions.GetRectangleFromNative(rct), CollisionDirection.All);
CollisionDirection myCollision = Collisions.CheckCollision(collider, Collisions.GetRectangleFromNative(rct), CollisionDirection.All);
if (NativeMethods.IsZoomed(nextWindow) && windowCollision != CollisionDirection.None && myCollision != CollisionDirection.None && sb.Length != 0)
{
return(true);
}
if (myCollision != CollisionDirection.None && sb.Length != 0)
{
return(true);
}
}
nextWindow = NativeMethods.GetWindow(nextWindow, 2);
}
return(false);
}
public override void Collision(CollisionDirection direction)
{
if (direction == CollisionDirection.Down)
{
movement2D.JumpTo();
}
}
public override void HandleCollision(CollisionDirection collisionDirection, GameObject gameObject)
{
if (gameObject is FireBall || gameObject is Sword || (gameObject is Mario && ((Mario)gameObject).IsInvincible()))
{
this.piranhaState.HandlePiranhaDeathTransition();
}
}
public override void HandleCollision(CollisionDirection collisionDirection, GameObject gameObject)
{
if (gameObject is Mario)
{
Systems.Events.TheInstance.PowerUp();
Mario.GetInstance().RequestSuperMarioTransition();
this.IsCollidable = false;
this.IsVisible = false;
}
else if (gameObject is Block)
{
if (collisionDirection == CollisionDirection.Left || collisionDirection == CollisionDirection.Right)
{
this.XSpeed = -this.XSpeed;
}
else if (collisionDirection == CollisionDirection.Bottom)
{
if (((Block)gameObject).YSpeed < 0)
{
this.YSpeed = -2.0f;
this.XSpeed *= -1.0f;
}
else
{
this.YSpeed = 0.0f;
}
}
}
}
public static void HandleCollision(Game1 game, IGameObject collingfireball, IGameObject collidedEnemy)
{
if ((collidedEnemy is IEnemy enemy) && (collingfireball is Fireball fireball))
{
Rectangle fireballRectangle = fireball.GetSizeRectangle();
Rectangle enemyRectangle = enemy.GetSizeRectangle();
CollisionDirection direction = CollisionDetection.DetectCollisionDirection(fireballRectangle, enemyRectangle);
if (!(direction is CollisionDirection.NoCollision))
{
if (direction is CollisionDirection.Top)
{
fireball.position = new Vector2(fireball.position.X, enemy.GetSizeRectangle().Y - fireball.GetSizeRectangle().Height);
}
else if (direction is CollisionDirection.Left)
{
fireball.position = new Vector2(enemy.GetSizeRectangle().X - fireball.GetSizeRectangle().Width, fireball.position.Y);
}
else if (direction is CollisionDirection.Right)
{
fireball.position = new Vector2(enemy.GetSizeRectangle().X + enemy.GetSizeRectangle().Width, fireball.position.Y);
}
else if (direction is CollisionDirection.Bottom)
{
fireball.position = new Vector2(fireball.position.X, enemy.GetSizeRectangle().Y + enemy.GetSizeRectangle().Height);
}
game.HUD.GetScore(ConstantNumber.SCORE_100);
enemy.Flip();
fireball.Explode();
}
}
}
public static void HandleCollision(MushroomItem mushroom, IGameObject target)
{
Rectangle mushroomRectangle = mushroom.GetSizeRectangle();
mushroom.isOnGround = false;
if (target is Block block)
{
Rectangle blockRectangle = block.GetSizeRectangle();
CollisionDirection direction = CollisionDetection.DetectCollisionDirection(mushroomRectangle, blockRectangle);
if (!(direction is CollisionDirection.NoCollision))
{
if (mushroom.triggered)
{
if (direction is CollisionDirection.Left)
{
mushroom.position = new Vector2(block.GetSizeRectangle().X - mushroom.GetSizeRectangle().Width, mushroom.position.Y);
mushroom.moveLeft = true;
}
else if (direction is CollisionDirection.Right)
{
mushroom.position = new Vector2(block.GetSizeRectangle().X + block.GetSizeRectangle().Width, mushroom.position.Y);
mushroom.moveLeft = false;
}
else if (direction is CollisionDirection.Top)
{
mushroom.position = new Vector2(mushroom.position.X, block.GetSizeRectangle().Y - mushroom.GetSizeRectangle().Height);
mushroom.isOnGround = true;
}
}
}
}
}
public override void HandleCollision(CollisionDirection collisionDirection, GameObject gameObject)
{
if (gameObject is Block && !(gameObject is PyramidBlock))
{
DestroySelf();
Systems.Events.TheInstance.PortalOpened();
if (CollisionDirection.Top == collisionDirection)
{
Systems.Events.TheInstance.PortalProjCollision(left, gameObject, CollisionDirection.Bottom);
}
else if (CollisionDirection.Bottom == collisionDirection)
{
Systems.Events.TheInstance.PortalProjCollision(left, gameObject, CollisionDirection.Top);
}
else if (CollisionDirection.Left == collisionDirection)
{
Systems.Events.TheInstance.PortalProjCollision(left, gameObject, CollisionDirection.Right);
}
else if (CollisionDirection.Right == collisionDirection)
{
Systems.Events.TheInstance.PortalProjCollision(left, gameObject, CollisionDirection.Left);
}
}
else if (gameObject.IsSolid)
{
DestroySelf();
}
}
public static void HandleCollision(IGameObject collingfireball, IGameObject collidedPipe)
{
if ((collidedPipe is Pipe pipe) && (collingfireball is Fireball fireball))
{
Rectangle fireballRectangle = fireball.GetSizeRectangle();
Rectangle pipeRectangle = pipe.GetSizeRectangle();
CollisionDirection direction = DetectCollisionDirection(fireballRectangle, pipeRectangle);
if (!(direction is CollisionDirection.NoCollision))
{
if (direction is CollisionDirection.Left)
{
fireball.position = new Vector2(pipe.GetSizeRectangle().X - fireball.GetSizeRectangle().Width, fireball.position.Y);
fireball.Explode();
}
else if (direction is CollisionDirection.Right)
{
fireball.position = new Vector2(pipe.GetSizeRectangle().X + pipe.GetSizeRectangle().Width, fireball.position.Y);
fireball.Explode();
}
else if (direction is CollisionDirection.Top)
{
fireball.position = new Vector2(fireball.position.X, pipe.GetSizeRectangle().Y - fireball.GetSizeRectangle().Height);
}
else if (direction is CollisionDirection.Bottom)
{
fireball.position = new Vector2(fireball.position.X, pipe.GetSizeRectangle().Y + pipe.GetSizeRectangle().Height);
fireball.Explode();
}
}
}
}
public void Collide(Collider Source, CollisionDirection direction, Collider Target)
{
foreach (var item in collisions)
{
item.Collide(Source, direction, Target);
}
}
public override void HandleCollision(CollisionDirection collisionDirection, GameObject gameObject)
{
if (collisionDirection == CollisionDirection.Bottom && gameObject is Mario)
{
Bump();
}
}
public void Capture(int collisionMask, CollisionDirection collisionDirection, int outputId, Vector2 resolution)
{
if (TC_Area2D.current.currentTerrainArea == null)
{
return;
}
bool create = false;
if (rtCapture == null)
{
create = true;
}
else if (rtCapture.width != resolution.x || rtCapture.height != resolution.y)
{
TC_Compute.DisposeRenderTexture(ref rtCapture);
create = true;
}
if (create)
{
rtCapture = new RenderTexture((int)resolution.x, (int)resolution.y, 16, RenderTextureFormat.Depth, RenderTextureReadWrite.Linear);
cam.targetTexture = rtCapture;
}
// Debug.Log("Capture");
this.collisionMask = collisionMask;
terrain = TC_Area2D.current.currentTerrain;
// this.collisionDirection = collisionDirection;
cam.cullingMask = collisionMask;
SetCamera(collisionDirection, outputId);
cam.Render();
}
public void Collide(Collider Source, CollisionDirection direction, Collider Target)
{
if (direction == CollisionDirection.Bot && Target.Parent is Block)
{
Player.Grounded = true;
}
}
public static void HandleCollision(Koopa koopa, IGameObject target)
{
Rectangle koopaRectangle = koopa.GetSizeRectangle();
if (koopa.state is FlipedKoopaState)
{
return;
}
if (target is IPipe pipe)
{
Rectangle pipeRectangle = pipe.GetSizeRectangle();
CollisionDirection direction = CollisionDetection.DetectCollisionDirection(koopaRectangle, pipeRectangle);
if (!(direction is CollisionDirection.NoCollision))
{
if (direction is CollisionDirection.Left)
{
koopa.position = new Vector2(pipe.GetSizeRectangle().X - koopa.GetSizeRectangle().Width, koopa.position.Y);
koopa.TurnLeft();
koopa.moveLeft = true;
}
else if (direction is CollisionDirection.Right)
{
koopa.position = new Vector2(pipe.GetSizeRectangle().X + pipe.GetSizeRectangle().Width, koopa.position.Y);
koopa.TurnRight();
koopa.moveLeft = false;
}
}
}
}
public void PortalProjectileCollision(bool blue, GameObject obj, CollisionDirection collisionDirection)
{
if (PortalGun.GetInstance().TrackingMarioPosition)
{
PortalGun.GetInstance().GeneratePortal(blue, obj, collisionDirection);
}
}
private void CheckCollisions(CollisionDirection direction, Collider source, Collider target)
{
//var targets = quadtree.Get(source);
//for (int i = 0; i < targets.Length; i++)
{
#if DEBUG
if (source.Parent == null || target.Parent == null)
{
throw new Exception("Collider parent cannot be null!");
}
#endif
if (source.Parent == target.Parent)
{
return;
}
if (direction == CollisionDirection.Vertical)
{
source.IsCollidingV(target);
}
else
{
source.IsCollidingH(target);
}
}
}
/// <summary>
/// Handles collisions for a given block, don't call base.HandleCollision
/// </summary>
protected virtual bool HandleCollisions(GameTime gameTime, CollisionDirection direction, BlockCollision collision, Rectangle tileBounds, Vector2 depth, bool intersects, int x, int y)
{
if (collision != BlockCollision.Passable && intersects)
{
// If we crossed the top of a tile, we are on the ground.
if (previousBounds.Bottom <= tileBounds.Top)
{
if (collision == BlockCollision.Ladder || collision == BlockCollision.Platform || collision == BlockCollision.Falling)
{
isOnGround = true;
}
}
if (collision == BlockCollision.Impassable || isOnGround)
{
if (direction == CollisionDirection.Horizontal)
{
position.X += depth.X;
}
if (direction == CollisionDirection.Vertical)
{
isOnGround = true;
position.Y += depth.Y;
}
}
}
return(false);
}
CollisionDirection DetectCollisionSide(Collider2D bullet)
{
CollisionDirection direction = CollisionDirection.None;
if (bullet.transform.up == Vector3.right)
{
direction = CollisionDirection.FromLeft;
}
else if (bullet.transform.up == Vector3.left)
{
direction = CollisionDirection.FromRight;
}
else if (bullet.transform.up == Vector3.up)
{
direction = CollisionDirection.FromDown;
}
else if (bullet.transform.up == Vector3.down)
{
direction = CollisionDirection.FromUp;
}
else
{
direction = CollisionDirection.None;
}
return(direction);
}
public override void HandleCollision(CollisionDirection collisionDirection, GameObject gameObject)
{
if (gameObject is Block && !(gameObject is HiddenBlock))
{
this.SwordState.HandleReadyToSwingTransition();
}
}
public Collision(Rectangle S,Rectangle D,CollisionType T,CollisionDirection Di)
{
Src = S;
Dest = D;
Type = T;
Dir = Di;
}
public void SetCamera(CollisionDirection collisionDirection, int outputId)
{
if (t == null)
{
Start();
}
if (collisionDirection == CollisionDirection.Up)
{
t.position = new Vector3(TC_Area2D.current.bounds.center.x, -1 + TC_Settings.instance.generateOffset.y, TC_Area2D.current.bounds.center.z);
t.rotation = Quaternion.Euler(-90, 0, 0);
}
else
{
t.position = new Vector3(TC_Area2D.current.bounds.center.x, TC_Area2D.current.bounds.center.y + 1 + TC_Settings.instance.generateOffset.y, TC_Area2D.current.bounds.center.z);
t.rotation = Quaternion.Euler(90, 0, 0);
}
float orthographicSize = TC_Area2D.current.bounds.extents.x;
if (outputId == TC.heightOutput)
{
orthographicSize += TC_Area2D.current.resExpandBorderSize;
}
cam.orthographicSize = orthographicSize;
cam.nearClipPlane = 0;
cam.farClipPlane = TC_Area2D.current.currentTerrainArea.terrainSize.y + 1;
// Debug.Log(t.position);
// Vector3 size = area.currentTerrain.terrainData.size;
// t.position = new Vector3(area.area.center.x, -1, area.area.center.y);
}
public Point BoundingTest(BoundingBox boundry, BoundingBox boxB, Point scaler)
{
int xScale = (int)scaler.X;
int yScale = (int)scaler.Y;
Action <CollisionDirection> CollisionHandler = (collisionDir) =>
{
switch (collisionDir)
{
case CollisionDirection.Left:
xScale *= -1;
break;
case CollisionDirection.Top:
yScale *= -1;
break;
case CollisionDirection.Right:
xScale *= -1;
break;
case CollisionDirection.Bottom:
yScale *= -1;
break;
}
};
CollisionDirection collisionDirection = LateralCollision(boundry, boxB);
CollisionHandler(collisionDirection);
collisionDirection = VentralCollision(boundry, boxB);
CollisionHandler(collisionDirection);
return(new Point(xScale, yScale));
}
/// <summary>
/// Detects and resolves all collisions between the player and his neighboring
/// tiles. When a collision is detected, the player is pushed away along one
/// axis to prevent overlapping. There is some special logic for the Y axis to
/// handle platforms which behave differently depending on direction of movement.
/// </summary>
protected void HandleCollisions(CollisionDirection direction, GameTime gameTime)
{
// Get the player's bounding rectangle and find neighboring tiles.
Rectangle bounds = Bounds;
int leftTile = (int)Math.Floor((float)bounds.Left / Tile.Width);
int rightTile = (int)Math.Ceiling(((float)bounds.Right / Tile.Width)) - 1;
int topTile = (int)Math.Floor((float)bounds.Top / Tile.Height);
int bottomTile = (int)Math.Ceiling(((float)bounds.Bottom / Tile.Height)) - 1;
//Reset flag to search for ground collision.
IsOnGround = false;
for (int y = topTile; y <= bottomTile; ++y)
{
for (int x = leftTile; x <= rightTile; ++x)
{
Rectangle tileBounds = ((Map)Map).GetTileBounds(x, y);
BlockCollision collision = ((Map)Map).GetCollision(x, y);
Vector2 depth;
bool intersects = TileIntersectsPlayer(Bounds, tileBounds, direction, out depth);
HandleCollisions(gameTime, direction, collision, tileBounds, depth, intersects, x, y);
}
}
// Save the new bounds bottom.
PreviousState.Bounds = bounds;
}
void OnCollisionEnter2D(Collision2D collision)
{
if (collision.gameObject.CompareTag("StaticSurface") || collision.gameObject.CompareTag("Salvage"))
{
GetComponent<Rigidbody2D>().velocity = Vector2.zero;
isMoving = false;
// Store the collision direction as a set of booleans
// (ex. a collision on the west side of an object would
// have west=true and all else false)
collisionDirection = new CollisionDirection ();
Vector3 hit = collision.contacts[0].normal;
float angle = Vector3.Angle(hit,Vector3.up);
collisionDirection.north = Mathf.Approximately (angle, 0);
collisionDirection.south = Mathf.Approximately (angle, 180);
if(Mathf.Approximately(angle, 90)){
collisionDirection.east = Vector3.Cross(Vector3.forward,hit).y > 0;
collisionDirection.west = !collisionDirection.east;
}
}
if (collision.gameObject.CompareTag ("Salvage")) {
collision.gameObject.SetActive (false);
}
}
/// <summary>
/// Detects and resolves all collisions between the player and his neighboring
/// tiles. When a collision is detected, the player is pushed away along one
/// axis to prevent overlapping. There is some special logic for the Y axis to
/// handle platforms which behave differently depending on direction of movement.
/// </summary>
private void HandleCollisions(CollisionDirection direction)
{
// Get the player's bounding rectangle and find neighboring tiles.
Rectangle bounds = BoundingRectangle;
int leftTile = (int)Math.Floor((float)bounds.Left / Tile.Width);
int rightTile = (int)Math.Ceiling(((float)bounds.Right / Tile.Width)) - 1;
int topTile = (int)Math.Floor((float)bounds.Top / Tile.Height);
int bottomTile = (int)Math.Ceiling(((float)bounds.Bottom / Tile.Height)) - 1;
// Reset flag to search for ground collision.
isOnGround = false;
// For each potentially colliding tile,
for (int y = topTile; y <= bottomTile; ++y)
{
for (int x = leftTile; x <= rightTile; ++x)
{
Rectangle tileBounds = level.GetBounds(x, y);
// If this tile is collidable,
BlockCollision collision = level.GetCollision(x, y);
Vector2 depth;
if (collision != BlockCollision.Passable && PlayerCharacter.TileIntersectsPlayer(BoundingRectangle, tileBounds, direction, out depth))
{
if (collision == BlockCollision.Impassable || isOnGround || collision == BlockCollision.Platform || collision == BlockCollision.Falling)
{
if (direction == CollisionDirection.Horizontal)
{
position.X += depth.X;
}
else
{
if (Type == ParticleType.Rain)
{
level.DefaultParticleEngine.SpawnParticle(ParticleType.RainSplash, (int)Position.X, (int)Position.Y + bounds.Height - 3);
//Remove particle
TTL = 0;
//Make rain put out fire
if (level.InLevelBounds(Position) && (level.tiles[(int)(Position.X / Tile.Width), (int)(Position.Y / Tile.Width)].ForegroundFireMeta > 0 || level.tiles[(int)(Position.X / Tile.Width), (int)(Position.Y / Tile.Width)].BackgroundFireMeta > 0))
{
level.tiles[(int)(Position.X / Tile.Width), (int)(Position.Y / Tile.Width)].ForegroundFireMeta = level.tiles[(int)(Position.X / Tile.Width), (int)(Position.Y / Tile.Width)].BackgroundFireMeta = 0;
}
}
else if (Type == ParticleType.Snow)
{
if (!AlphaFade)
{
TTL = TTLoriginal = 20;
AlphaFade = true;
}
}
isOnGround = true;
position.Y += depth.Y;
}
}
}
}
}
// Save the new bounds bottom.
previousBounds = bounds;
}
public override void HandleCollision(CollisionDirection collisionDirection, GameObject gameObject)
{
if (gameObject is Mario && Mario.GetInstance().IsFinishedState() && !finished)
{
finished = true;
PlayerHUD.GetInstance().AddTimeToPoints();
}
}
public override void Collision(CollisionDirection direction)
{
// 플레이어의 위치는 현재 타일의 위치에서 이동 방향으로 1만큼 이동한 위치
Vector3 position = boxCollider2D.bounds.center + Vector3.right * (int)moveType;
// 플레이어가 왼쪽 or 오른쪽 이동하도록 메소드 호출
movement2D.SetupStraightMove(moveType, position);
}
private void StartPushing(CollisionDirection direction)
{
if (enabled)
{
isPushing = true;
pushingDirection = direction;
}
}
public override void HandleCollision(CollisionDirection cd, PhysicsAble entity)
{
if (entity is Level)
{
velocity = Vector2.Zero;
}
else
{
base.HandleCollision(cd, entity);
}
}
public override void HandleCollision(CollisionDirection cd, PhysicsAble entity)
{
// Die if you hit a wall
if (entity is DoctorWall) return;
if (entity is Level)
{
destroy();
}
else if (entity is Enemy)
{
if (lastHit != entity)
{
if (bounces == 3)
{
destroy();
return;
}
// Do damage
Enemy e = (Enemy)entity;
e.applyDamage(10);
// Bounce
lastHit = entity;
Entity closestEnemy = getClosestEnemy();
Vector2 newVelocity = Vector2.Zero;
if (closestEnemy == null)
{
Random r = new Random();
newVelocity = new Vector2(r.Next(0, 10) - 5, r.Next(0, 10) - 5);
}
else
{
newVelocity = getClosestEnemy().worldPosition - this.worldPosition;
}
newVelocity.Normalize();
velocity = newVelocity * 8;
bounces++;
}
}
else
{
base.HandleCollision(cd, entity);
}
}
public override void HandleCollision(CollisionDirection cd, PhysicsAble entity)
{
if (entity is Bullet)
{
bulletRef = (Bullet)entity;
bulletRef.attach(this);
}
else if (entity is Level)
{
velocity = Vector2.Zero;
}
else
{
base.HandleCollision(cd, entity);
}
}
public override void HandleCollision(CollisionDirection cd, PhysicsAble entity)
{
// Die if you hit a wall
if (entity is Level || entity is DoctorWall)
{
destroy();
}
else if (entity is PlayerCharacter) // Hurt players
{
// Do damage
PlayerCharacter e = (PlayerCharacter)entity;
e.applyDamage(1);
destroy();
}
else
{
base.HandleCollision(cd, entity);
}
}
public override void HandleCollision(CollisionDirection cd, PhysicsAble entity)
{
// Die if you hit a wall
if (entity is Level || entity is DoctorWall)
{
destroy();
context.bulletExists = false;
}
else if (entity is Enemy)
{
if (hits.Contains(entity)) return;
Enemy e = (Enemy)entity;
e.applyDamage(payload);
hits.Add(entity);
}
else
{
base.HandleCollision(cd, entity);
}
}
public override void HandleCollision(CollisionDirection cd, PhysicsAble entity)
{
if (entity is DoctorWall) return;
// Die if you hit a wall
if (entity is Level)
{
destroy();
}
else if (entity is Enemy)
{
// Do damage
Enemy e = (Enemy)entity;
e.applyDamage(1);
destroy();
}
else
{
base.HandleCollision(cd, entity);
}
}
public override void HandleCollision(CollisionDirection cd, PhysicsAble entity)
{
if (entity is PlayerCharacter)
{
PlayerCharacter pc = (PlayerCharacter)entity;
if (pc is Tank && pc.attacking)
{
return;
}
pc.applyDamage(1);
pc.velocity = velocity * 2;
velocity = Vector2.Zero;
}
else
{
base.HandleCollision(cd, entity);
}
}
public override void HandleCollision(CollisionDirection cd, PhysicsAble entity)
{
// Die if you hit a wall
if (entity is DoctorWall) return;
if (entity is Level)
{
destroy();
}
else if (entity is Enemy)
{
if (!hits.Contains(entity))
{
Enemy e = (Enemy)entity;
e.applyDamage(4);
hits.Add(e);
}
}
else
{
base.HandleCollision(cd, entity);
}
}
public void HandleCollision(CollisionDirection cd, PhysicsAble entity)
{
}
/// <summary>
/// Detects and resolves all collisions between the player and his neighboring
/// tiles. When a collision is detected, the player is pushed away along one
/// axis to prevent overlapping. There is some special logic for the Y axis to
/// handle platforms which behave differently depending on direction of movement.
/// </summary>
protected void HandleCollisions(CollisionDirection direction, GameTime gameTime)
{
// Get the player's bounding rectangle and find neighboring tiles.
Rectangle bounds = Bounds;
int leftTile = (int)Math.Floor((float)bounds.Left / Tile.Width);
int rightTile = (int)Math.Ceiling(((float)bounds.Right / Tile.Width)) - 1;
int topTile = (int)Math.Floor((float)bounds.Top / Tile.Height);
int bottomTile = (int)Math.Ceiling(((float)bounds.Bottom / Tile.Height)) - 1;
//Reset flag to search for ground collision.
IsOnGround = false;
for (int y = topTile; y <= bottomTile; ++y)
{
for (int x = leftTile; x <= rightTile; ++x)
{
Rectangle tileBounds = ((Map)Map).GetTileBounds(x, y);
BlockCollision collision = ((Map)Map).GetCollision(x, y);
Vector2 depth;
bool intersects = TileIntersectsPlayer(Bounds, tileBounds, direction, out depth);
HandleCollisions(gameTime, direction, collision, tileBounds, depth, intersects, x, y);
}
}
// Save the new bounds bottom.
PreviousState.Bounds = bounds;
}
/// <summary>
/// Handles collisions for a given block
/// </summary>
private bool HandleCollisions(GameTime gameTime, CollisionDirection direction, BlockCollision collision, Rectangle tileBounds, Vector2 depth, bool intersects, int x, int y)
{
if (collision != BlockCollision.Passable && intersects)
{
// If we crossed the top of a tile, we are on the ground.
if (PreviousState.Bounds.Bottom <= tileBounds.Top)
{
if (collision == BlockCollision.Platform)
{
IsOnGround = true;
}
}
if (collision == BlockCollision.Gravity)
{
Tile tile = Map.Tiles[x, y, 1];
if (tile.Block == BlockType.UpArrow)
GravityDirection = GravityDirection.Up;
else if (tile.Block == BlockType.DownArrow)
GravityDirection = GravityDirection.Down;
else if (tile.Block == BlockType.RightArrow)
GravityDirection = GravityDirection.Right;
else if (tile.Block == BlockType.LeftArrow)
GravityDirection = GravityDirection.Left;
return true;
}
if (collision == BlockCollision.Impassable || IsOnGround)
{
//Now that we know we hit something, resolve the collison
if (direction == CollisionDirection.Horizontal)
{
SimulationState.Position.X += depth.X;
IsOnGround = true;
}
if (direction == CollisionDirection.Vertical)
{
//Cancel jump if hit something (Ie, when you jump and hit the roof)
IsJumping = false;
JumpTime = 0;
//Obviously hit ground or roof
IsOnGround = true;
SimulationState.Position.Y += depth.Y;
}
}
}
return false;
}
public virtual void HandleCollision(CollisionDirection cd, PhysicsAble entity)
{
if (entity is Level || entity is DoctorWall)
{
velocity = Vector2.Zero;
}
}
/// <summary>
/// Checks for tile intersections/collision depth between a player and a tile
/// </summary>
/// <param name="player">A player's bounding rectangle</param>
/// <param name="block">A block's brounding rectangle</param>
/// <param name="direction">Collision direction</param>
/// <param name="depth">Returned depth of the collision</param>
/// <returns>If the tile intersects the player</returns>
public static bool TileIntersectsPlayer(Rectangle player, Rectangle block, CollisionDirection direction, out Vector2 depth)
{
depth = direction == CollisionDirection.Vertical ? new Vector2(0, player.GetVerticalIntersectionDepth(block)) : new Vector2(player.GetHorizontalIntersectionDepth(block), 0);
return depth.Y != 0 || depth.X != 0;
}
/// <summary>
/// A collision check with 2 level verification.
/// The First check uses rays from camera to player.
/// If first check returns false, use alternative rays from player.
/// This is to ensure the player still collides with objects when hidden from view.
/// </summary>
/// <param name="firstPoints">First set of points to send rays from. Usually at camera</param>
/// <param name="secondPoints">Second set. Usually at player</param>
/// <param name="secondaryDirection"> Direction to send secondary rays from. Usually left, right, up or down.</param>
/// <returns></returns>
public GameObject twoLevelCollisionCheck(Vector3[] firstPoints, Vector3[] secondPoints, Vector3 secondaryDirection, CollisionDirection orientation)
{
//The allowed distance of the ray for secondary collision check.
float distance;
//if it's not up or down it's left or right
if(secondaryDirection == transform.up || secondaryDirection == -1 * transform.up)
{
//vertical collision from center to bottom or top of sprite
distance = getVerticalCollisionDistance();
}
else
{
//horizontal collision is distance from center to left or right side.
distance = getHorizontalCollisionDistance();
}
//check intial point list for valid collsion
object[] o = checkCollisionList(firstPoints, Camera.main.transform.forward);
GameObject collide = null;
//
if (o != null)
{
//resolve if there was a valid collision with other sprite.
for(int i = 0; i < o.Length; i++)
{
GameObject ob = (GameObject)o[i];
SpriteCollider sc = ob.GetComponent<SpriteCollider>();
/*if (sc != null && sc.getVertCollision(gameObject, transform.position.y))
{
collide = ob;
break;
}*/
if(orientation == CollisionDirection.VERTICAL)
{
if (sc != null && sc.getVertCollision(gameObject, Bottom()))
{
collide = ob;
break;
}
}
else // then horizonal
{
if (sc != null && sc.getHorzCollision(gameObject))
{
collide = ob;
break;
}
}
}
}
//if there was no valid collision, check secondary
//this is to avoid player falling through platforms when behind non-colliding objects.
if (o == null || !collide)
{
o = checkCollisionList(secondPoints, secondaryDirection, distance);
if (o != null)
{
//resolve if there was a valid collision with other sprite.
for (int i = 0; i < o.Length; i++)
{
GameObject ob = (GameObject)o[i];
SpriteCollider sc = ob.GetComponent<SpriteCollider>();
if(orientation == CollisionDirection.VERTICAL)
{
if (sc != null && sc.getVertCollision(gameObject, Bottom()))
{
collide = ob;
break;
}
}
else
{
if (sc.getHorzCollision(gameObject))
{
collide = ob;
break;
}
}
}
}
if (o == null || !collide)
{
return null;
}
}
//shouldn't actually get to this point....
return collide;
}
