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> /// 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; }