public static bool beginCollisionWithPlayer(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
arbiter.GetShapes(out shape1, out shape2);
Goomba goomba = shape1.GetComponent <Goomba>();
Player player = shape2.GetComponent <Player>();
if (goomba.dieAnim.isDying() || player.isDying())
{
arbiter.Ignore(); // avoid the collision to continue since this frame
return(false); // avoid the collision to continue since this frame
}
goomba.idle.setIdle(true);
// if collides from top then kill the goomba
if (GameObjectTools.isHitFromAbove(goomba.transform.position.y, shape2.body, arbiter))
{
goomba.die();
// makes the player jumps a little upwards
player.forceJump();
}
// kills Player
else
{
arbiter.Ignore(); // avoid the collision to continue since this frame
LevelManager.Instance.loseGame(true); // force die animation
}
// Returning false from a begin callback means to ignore the collision response for these two colliding shapes
// until they separate. Also for current frame. Ignore() does the same but next frame.
return(true);
}
public static bool presolveCollisionWithOneway(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
// The order of the arguments matches the order in the function name.
arbiter.GetShapes(out shape1, out shape2);
// if collision was from below then continue with oneway platform logic
if (GameObjectTools.isHitFromBelow(arbiter))
{
arbiter.Ignore();
return(false);
}
Player player = shape1.getOwnComponent <Player>();
// if player wants to climb down (once it is over the platform) then disable the collision to start free fall
if (player.GetComponent <ClimbDownFromPlatform>().isClimbingDown())
{
player.jump.reset(); // set state as if were jumping
arbiter.Ignore();
return(false);
}
// let the collision happens
return(true);
}
public static bool beginCollisionWithAny(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
// The order of the arguments matches the order in the function name.
arbiter.GetShapes(out shape1, out shape2);
// change direction of movement whenever hit something like a wall
if (GameObjectTools.isWallHit(arbiter))
{
Patrol p1 = shape1.GetComponent <Patrol>();
if (p1 != null && p1.enabled)
{
p1.toogleDir();
}
Patrol p2 = shape2.GetComponent <Patrol>();
if (p2 != null && p2.enabled)
{
p2.toogleDir();
}
}
// Returning false from a begin callback means to ignore the collision response for these two colliding shapes
// until they separate. Also for current frame. Ignore() does the same but next fixed step.
return(true);
}
public static bool beginCollisionWithScenery(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
// The order of the arguments matches the order in the function name.
arbiter.GetShapes(out shape1, out shape2);
Jump jump = shape1.GetComponent <Jump>();
// if is jumping and hits a wall then continue the collision
/*if (jump != null && jump.isJumping && GameObjectTools.isWallHit(arbiter))
* return true;*/
if (jump != null && GameObjectTools.isGrounded(arbiter))
{
if (jump.foreverJump)
{
jump.forceJump(jump.foreverJumpVel);
}
// if it was jumping then reset jump behavior
else if (jump.isJumping)
{
jump.stop();
}
}
// Returning false from a begin callback means to ignore the collision response for these two colliding shapes
// until they separate. Also for current frame. Ignore() does the same but next frame.
return(true);
}
public static bool beginCollisionWithScenery(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
// The order of the arguments matches the order in the function name.
arbiter.GetShapes(out shape1, out shape2);
Player player = shape1.getOwnComponent <Player>();
if (player.isDying())
{
return(false); // stop collision with scenery since this frame
}
player.exitedFromScenery = false;
// Avoid ground penetration (Y axis). Another way: see collisionBias and/or minPenetrationForPenalty config in CollisionManagerCP.
// Currently is being addressed by AirGroundControlUpdater and in WalkAbs
/*if (GameObjectTools.isGrounded(arbiter)) {
* Vector2 thePos = player.body.position;
* float depth = arbiter.GetDepth(0);
* thePos.y -= depth;
* player.body.position = thePos;
* }*/
// Returning false from a begin callback means to ignore the collision response for these two colliding shapes
// until they separate. Also for current frame. Ignore() does the same but next fixed step.
return(true);
}
public static bool beginCollisionWithKoopaTroopa(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
arbiter.GetShapes(out shape1, out shape2);
KoopaTroopa koopa1 = shape1.GetComponent <KoopaTroopa>();
KoopaTroopa koopa2 = shape2.GetComponent <KoopaTroopa>();
bool hidden1 = koopa1._hide.isHidden();
bool hidden2 = koopa2._hide.isHidden();
bool bouncing1 = koopa1.bounce.isBouncing();
bool bouncing2 = koopa2.bounce.isBouncing();
// avoid koopa1 pushes hidden koopa2
Chase chase = shape1.GetComponent <Chase>();
if (chase != null && chase.isChasing())
{
chase.stopChasing();
chase.enableOperateWhenOutOfSensor();
}
// avoid koopa2 pushes hidden koopa1
chase = shape2.GetComponent <Chase>();
if (chase != null && chase.isChasing())
{
chase.stopChasing();
chase.enableOperateWhenOutOfSensor();
}
// is koopa above the other koopa?
if (GameObjectTools.isGrounded(arbiter))
{
if (!hidden1)
{
koopa1.jump.forceJump(koopa1.jumpSpeed);
}
else
{
koopa2.jump.forceJump(koopa1.jumpSpeed);
}
// NOTE: I assume here the isGrounded() works as expected
return(false); // avoid the collision to continue since this frame
}
// kills koopa 2
else if (bouncing1 && !hidden2 && !bouncing2)
{
//koopa2.die();
koopa2.hide();
}
// kills koopa 1
else if (bouncing2 && !hidden1 && !bouncing1)
{
//koopa1.die();
koopa1.hide();
}
// Returning false from a begin callback means to ignore the collision response for these two colliding shapes
// until they separate. Also for current frame. Ignore() does the same but next frame.
return(true);
}
public static bool beginCollisionWithPowerUp(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
arbiter.GetShapes(out shape1, out shape2);
KoopaTroopa koopa = shape1.getOwnComponent <KoopaTroopa>();
PowerUp powerUp = shape2.getOwnComponent <PowerUp>();
powerUp.Invoke("destroy", 0f); // a replacement for Destroy
koopa.stop();
// hide or kill the koopa
if (koopa._hide.isHidden())
{
koopa.die();
}
else
{
koopa.hide();
}
// Returning false from a begin callback means to ignore the collision response for these two colliding shapes
// until they separate. Also for current frame. Ignore() does the same but next fixed step.
return(false);
}
public static bool beginCollisionWithKoopaTroopa(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
arbiter.GetShapes(out shape1, out shape2);
KoopaTroopa koopa1 = shape1.getOwnComponent <KoopaTroopa>();
KoopaTroopa koopa2 = shape2.getOwnComponent <KoopaTroopa>();
bool hidden1 = koopa1._hide.isHidden();
bool hidden2 = koopa2._hide.isHidden();
bool bouncing1 = koopa1.bounce.isBouncing();
bool bouncing2 = koopa2.bounce.isBouncing();
// avoid koopa1 pushes hidden koopa2
Chase chase1 = shape1.GetComponent <Chase>();
if (chase1 != null && chase1.isChasing())
{
chase1.stop();
chase1.enableOperateWhenOutOfSensor();
}
// avoid koopa2 pushes hidden koopa1
Chase chase2 = shape2.GetComponent <Chase>();
if (chase2 != null && chase2.isChasing())
{
chase2.stop();
chase2.enableOperateWhenOutOfSensor();
}
// is koopa1 above the koopa2?
if (GameObjectTools.isGrounded(arbiter))
{
if (!hidden1 && koopa1.jump.isJumping())
{
koopa1.jump.forceJump(koopa1.jumpSpeed);
}
else if (hidden1 && koopa2.jump.isJumping())
{
koopa2.jump.forceJump(koopa1.jumpSpeed);
}
return(false); // avoid the collision since this frame
}
// hide koopa 2
else if (bouncing1 && !hidden2 && !bouncing2)
{
koopa2.hide();
}
// hide koopa 1
else if (bouncing2 && !hidden1 && !bouncing1)
{
//koopa1.die();
koopa1.hide();
}
// Returning false from a begin callback means to ignore the collision response for these two colliding shapes
// until they separate. Also for current frame. Ignore() does the same but next fixed step.
return(true);
}
bool ChipmunkBegin_KoopaTroopa_KoopaTroopa(ChipmunkArbiter arbiter)
{
if (!KoopaTroopa.beginCollisionWithKoopaTroopa(arbiter))
{
return(false);
}
return(Patrol.beginCollision(arbiter));
}
//##################### Player #################
bool ChipmunkBegin_Player_Scenery(ChipmunkArbiter arbiter)
{
if (!Player.beginCollisionWithScenery(arbiter))
{
return(false);
}
return(Jump.beginCollisionWithScenery(arbiter));
}
//##################### KoopaTroopa #################
bool ChipmunkBegin_KoopaTroopa_Scenery(ChipmunkArbiter arbiter)
{
Chase.beginCollisionWithScenery(arbiter);
if (!Patrol.beginCollision(arbiter))
{
return(false);
}
return(Jump.beginCollisionWithScenery(arbiter));
}
private void MarkCollision(ChipmunkArbiter arbiter)
{
ChipmunkShape a, b;
arbiter.GetShapes(out a, out b);
a.GetComponent <Ball>().parent = b.GetComponent <Ball>();
Debug.DrawLine(a.transform.position, b.transform.position, Color.white);
}
bool ChipmunkBegin_Player_Oneway(ChipmunkArbiter arbiter)
{
// if condition for oneway platform was not met then proceed as a begin collision with Scenery
if (!Player.beginCollisionWithOneway(arbiter))
{
return(ChipmunkBegin_Player_Scenery(arbiter));
}
return(true);
}
public static void endCollisionWithScenery(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
// The order of the arguments matches the order in the function name.
arbiter.GetShapes(out shape1, out shape2);
shape1.GetComponent <Player>().exitedFromScenery = true;
}
public static void endCollisionWithPlayer(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
// The order of the arguments matches the order in the function name.
arbiter.GetShapes(out shape1, out shape2);
shape1.getOwnComponent <Goal>().flagTargetOutside(shape1._handle.ToInt32());
}
protected bool ChipmunkBegin_player_pit(ChipmunkArbiter arbiter)
{
ChipmunkShape player, pit;
arbiter.GetShapes(out player, out pit);
player.SendMessage("OnFellInPit");
return(true);
}
protected bool ChipmunkPreSolve_ball_oneway(ChipmunkArbiter arbiter)
{
if (arbiter.GetNormal(0).y > -0.7f)
{
arbiter.Ignore();
return(false);
}
return(true);
}
public static bool beginCollisionWithPlayer(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
arbiter.GetShapes(out shape1, out shape2);
KoopaTroopa koopa = shape1.getOwnComponent <KoopaTroopa>();
Player player = shape2.getOwnComponent <Player>();
if (player.isDying())
{
arbiter.Ignore(); // avoid the collision to continue since this frame
return(false); // avoid the collision to continue since this frame
}
bool collisionFromAbove = GameObjectTools.isHitFromAbove(koopa.transform.position.y, shape2.body, arbiter);
if (collisionFromAbove)
{
// if koopa was jumping then stop forever jumping
if (koopa.jump.isJumping())
{
koopa.stopJumping();
}
// hide the koopa troopa or stop the bouncing of the hidden koopa
else if (!koopa._hide.isHidden() || koopa.bounce.isBouncing())
{
koopa.hide();
}
// kills the koopa
else
{
koopa.die();
}
// makes the player jumps a little upwards
player.forceJump();
}
// koopa starts bouncing
else if (koopa._hide.isHidden() && !koopa.bounce.isBouncing())
{
koopa.stop();
koopa.bounce.bounce(Mathf.Sign(koopa.transform.position.x - player.transform.position.x));
}
// kills Player
else
{
koopa.stop();
arbiter.Ignore(); // avoid the collision to continue since this frame
LevelManager.Instance.loseGame(true); // force die animation
}
// Returning false from a begin callback means to ignore the collision response for these two colliding shapes
// until they separate. Also for current frame. Ignore() does the same but next fixed step.
return(true);
}
protected bool ChipmunkBegin_player_bumpable(ChipmunkArbiter arbiter)
{
if (arbiter.GetNormal(0).y > 0.9f)
{
ChipmunkShape player, bonusBlock;
arbiter.GetShapes(out player, out bonusBlock);
bonusBlock.SendMessage("Bump");
}
return(true);
}
public static bool isCeiling(ChipmunkArbiter arbiter)
{
/// The collision normal is the direction of the surfaces where the two objects collided.
/// Keep in mind that the normal points out of the first object and into the second.
/// If you switch the order of your collision types in the method name, it will flip the normal around.
if (-arbiter.GetNormal(0).y < -COS_45)
{
return(true);
}
return(false);
}
public static bool beginCollisionWithPlayer(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
arbiter.GetShapes(out shape1, out shape2);
LevelManager.Instance.updateLastSpawnPosition(shape2.GetComponent <SpawnPositionTrigger>().sps);
// Returning false from a begin callback means to ignore the collision response for these two colliding shapes
// until they separate. Also for current frame. Ignore() does the same but next frame.
return(false);
}
public static bool isGrounded(ChipmunkArbiter arbiter)
{
/// The collision normal is the direction of the surfaces where the two objects collided.
/// Keep in mind that the normal points out of the first object and into the second.
/// If you switch the order of your collision types in the method name, it will flip the normal around.
// if normal.y is near to 1 it means it's a hit from above
if (Mathf.Abs(arbiter.GetNormal(0).y) > COS_45)
{
return(true);
}
return(false);
}
public static void endCollisionWithPlayer(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
// The order of the arguments matches the order in the function name.
arbiter.GetShapes(out shape1, out shape2);
Chase chase = shape1.GetComponent <Chase>();
chase.stopChasing();
chase.target = null;
chase.enableOperate();
}
public static bool beginCollisionWithPlayer(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
// The order of the arguments matches the order in the function name.
arbiter.GetShapes(out shape1, out shape2);
shape1.getOwnComponent <Goal>().flagTargetInside(shape1._handle.ToInt32());
// Returning false from a begin callback means to ignore the collision response for these two colliding shapes
// until they separate. Also for current frame. Ignore() does the same but next fixed step.
return(false);
}
public static bool beginCollisionWithUnlockSensor(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
// The order of the arguments matches the order in the function name.
arbiter.GetShapes(out shape1, out shape2);
Player player = shape1.GetComponent <Player>();
player.restoreWalkVel();
// Returning false from a begin callback means to ignore the collision response for these two colliding shapes
// until they separate. Also for current frame. Ignore() does the same but next frame.
return(false);
}
public static bool beginCollisionWithPowerUp(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
arbiter.GetShapes(out shape1, out shape2);
Ghost ghost = shape1.GetComponent <Ghost>();
PowerUp powerUp = shape2.GetComponent <PowerUp>();
powerUp.Invoke("destroy", 0f); // a replacement for Destroy
ghost.die();
// Returning false from a begin callback means to ignore the collision response for these two colliding shapes
// until they separate. Also for current frame. Ignore() does the same but next frame.
return(false);
}
public static void endCollisionWithOneway(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
// The order of the arguments matches the order in the function name.
arbiter.GetShapes(out shape1, out shape2);
Player player = shape1.getOwnComponent <Player>();
//player.jump.resetStatus(); // set state as if were jumping
player.exitedFromScenery = true;
// If was traversing the platform from below then the player is over the platform.
// Correct inner state is treated by the invoked method
player.GetComponent <ClimbDownFromPlatform>().handleSeparation();
}
protected bool ChipmunkBegin_player_jumpshroom(ChipmunkArbiter arbiter)
{
ChipmunkShape player, shroom;
arbiter.GetShapes(out player, out shroom);
if (arbiter.GetNormal(0).y < -0.9f)
{
ChipmunkBody body = player.GetComponent <ChipmunkBody>();
body.velocity = new Vector2(body.velocity.x, 50f);
return(false);
}
else
{
return(true);
}
}
public static bool beginCollisionWithPlayer(ChipmunkArbiter arbiter)
{
ChipmunkShape shape1, shape2;
arbiter.GetShapes(out shape1, out shape2);
Ghost ghost = shape1.GetComponent <Ghost>();
ghost.stop();
// kills player
arbiter.Ignore(); // avoid the collision to continue since this frame
LevelManager.Instance.loseGame(true); // force die animation
// Returning false from a begin callback means to ignore the collision response for these two colliding shapes
// until they separate. Also for current frame. Ignore() does the same but next frame.
return(false);
}
protected bool ChipmunkPreSolve_player_oneway(ChipmunkArbiter arbiter)
{
// If we're pressing the down arrow key.
if (Input.GetAxis("Vertical") < -0.5f)
{
// Fall through the floor
arbiter.Ignore();
return(false);
}
if (arbiter.GetNormal(0).y > -0.7f)
{
arbiter.Ignore();
return(false);
}
return(true);
}
