public static int Side(this Rectangle rectangle, TileInfo.SideType side)
{
if (side == TileInfo.SideType.LeftSide)
{
return rectangle.Left;
}
if (side == TileInfo.SideType.RightSide)
{
return rectangle.Right;
}
if (side == TileInfo.SideType.TopSide)
{
return rectangle.Top;
}
return rectangle.Bottom;
}
public Rectangle Collision(TileInfo.SideType side, GameUnit x, GameUnit y, GameUnit delta)
{
if (side == TileInfo.SideType.LeftSide)
{
return LeftCollision(x, y, delta);
}
if (side == TileInfo.SideType.RightSide)
{
return RightCollision(x, y, delta);
}
if (side == TileInfo.SideType.TopSide)
{
return TopCollision(x, y, delta);
}
return BottomCollision(x, y, delta);
}
CollisionInfo? TestMapBouncingCollision(Map map, Rectangle rectangle,
TileInfo.SideType direction, BitArray maybeGroundTile)
{
List<CollisionTile> tiles = map.GetCollidingTiles(rectangle, direction);
CollisionInfo? result = null;
for (int i = 0; i < tiles.Count; i++)
{
TileInfo.SideType side = TileInfo.OppositeSide(direction);
GameUnit perpendicularPosition;
if (TileInfo.Vertical(side))
{
perpendicularPosition = rectangle.Center.X;
}
else
{
perpendicularPosition = rectangle.Center.Y;
}
GameUnit leadingPosition = rectangle.Side(direction);
bool shouldTestSlopes = TileInfo.Vertical(side);
TestCollisionInfo testInfo = tiles[i].TestCollision(side, perpendicularPosition,
leadingPosition, shouldTestSlopes);
if (testInfo.isColliding)
{
bool shouldReplaceResult = true;
if (result.HasValue)
{
shouldReplaceResult = TileInfo.IsMin(side) ?
testInfo.position < result.Value.position :
testInfo.position > result.Value.position;
}
if (shouldReplaceResult)
{
CollisionInfo info = new CollisionInfo(testInfo.position, tiles[i].Position, tiles[i].TileType);
result = info;
}
}
}
return result;
}
protected abstract void OnDelta(TileInfo.SideType side);
protected abstract void OnCollision(TileInfo.SideType side, bool isDeltaDirection, BitArray tileType);
CollisionInfo? TestMapStickyCollision(Map map, Rectangle rectangle,
TileInfo.SideType direction, BitArray maybeGroundTile)
{
List<CollisionTile> tiles = map.GetCollidingTiles(rectangle, direction);
for (int i = 0; i < tiles.Count; i++)
{
TileInfo.SideType side = TileInfo.OppositeSide(direction);
GameUnit perpendicularPosition;
if (TileInfo.Vertical(side))
{
perpendicularPosition = rectangle.Center.X;
}
else
{
perpendicularPosition = rectangle.Center.Y;
}
GameUnit leadingPosition = rectangle.Side(direction);
bool shouldTestSlopes = TileInfo.Vertical(side);
TestCollisionInfo testInfo = tiles[i].TestCollision(side, perpendicularPosition,
leadingPosition, shouldTestSlopes);
if (testInfo.isColliding)
{
CollisionInfo info = new CollisionInfo(testInfo.position, tiles[i].Position, tiles[i].TileType);
return info;
}
else if (maybeGroundTile != null && direction == TileInfo.SideType.BottomSide)
{
BitArray tallSlope = TileInfo.CreateTileType();
tallSlope.Set((int)TileInfo.TileFlag.Slope, true);
tallSlope.Set((int)TileInfo.TileFlag.TallSlope, true);
if ((maybeGroundTile[(int)TileInfo.TileFlag.Slope] && tiles[i].TileType[(int)TileInfo.TileFlag.Slope]) ||
(maybeGroundTile[(int)TileInfo.TileFlag.Wall] &&
(tallSlope.And(tiles[i].TileType).Equals(tallSlope))))
{
CollisionInfo info = new CollisionInfo(testInfo.position, tiles[i].Position, tiles[i].TileType);
return info;
}
}
}
return null;
}
protected override void OnDelta(TileInfo.SideType side)
{
switch (side)
{
case TileInfo.SideType.TopSide:
case TileInfo.SideType.BottomSide:
maybeGroundTile = null;
break;
case TileInfo.SideType.LeftSide:
break;
case TileInfo.SideType.RightSide:
break;
}
}
protected override void OnCollision(TileInfo.SideType side, bool isDeltaDirection, BitArray tileType)
{
switch (side)
{
case TileInfo.SideType.TopSide:
if (isDeltaDirection)
{
kinematicsY.velocity = 0;
particleTools.FrontSystem.AddNewParticle(new HeadBumpParticle(particleTools.Content, CenterX, kinematicsY.position + collisionRectangle.BoundingBox.Top));
}
break;
case TileInfo.SideType.BottomSide:
maybeGroundTile = tileType;
if (isDeltaDirection)
{
kinematicsY.velocity = 0;
}
break;
case TileInfo.SideType.LeftSide:
if (isDeltaDirection)
{
kinematicsX.velocity = 0;
}
break;
case TileInfo.SideType.RightSide:
if (isDeltaDirection)
{
kinematicsX.velocity = 0;
}
break;
}
}
public List<CollisionTile> GetCollidingTiles(Rectangle rectangle, TileInfo.SideType direction)
{
TileUnit firstPrimary = Units.GameToTile(rectangle.Side(TileInfo.OppositeSide(direction)));
TileUnit lastPrimary = Units.GameToTile(rectangle.Side(direction));
int primaryIncr = TileInfo.IsMax(direction) ? 1 : -1;
bool horizontal = TileInfo.Horizontal(direction);
TileUnit sMin = Units.GameToTile(horizontal ? rectangle.Top : rectangle.Left);
TileUnit sMid = Units.GameToTile(horizontal ? rectangle.Center.Y : rectangle.Center.X);
TileUnit sMax = Units.GameToTile(horizontal ? rectangle.Bottom : rectangle.Right);
bool sPositive = sMid - sMin < sMax - sMid;
int secondaryIncr = sPositive ? 1 : -1;
TileUnit firstSecondary = sPositive ? sMin : sMax;
TileUnit lastSecondary = sPositive ? sMin : sMax;
List<CollisionTile> collisionTiles = new List<CollisionTile>();
for (TileUnit primary = firstPrimary; primary != lastPrimary + primaryIncr; primary = Convert.ToUInt32(Convert.ToInt32(primary) + primaryIncr))
{
for (TileUnit secondary = firstSecondary; secondary != lastSecondary + secondaryIncr; secondary = Convert.ToUInt32(Convert.ToInt32(secondary) + secondaryIncr))
{
TileUnit row = !horizontal ? primary : secondary;
TileUnit col = horizontal ? primary : secondary;
collisionTiles.Add(new CollisionTile(row, col, tiles[Convert.ToInt32(row)][Convert.ToInt32(col)].tileType));
}
}
return collisionTiles;
}
protected override void OnDelta(TileInfo.SideType side)
{
}
protected override void OnCollision(TileInfo.SideType side, bool isDeltaDirection, BitArray tileType)
{
if (side == TileInfo.SideType.TopSide)
{
kinematicsY.velocity = 0;
}
else if (side == TileInfo.SideType.BottomSide)
{
kinematicsY.velocity = -BounceSpeed;
}
else
{
kinematicsX.velocity *= -1;
}
}
/// <summary>
///
/// </summary>
/// <param name="side">The side of the tile that is being collided with</param>
/// <param name="perpendicularPosition">The position on the tile on the opposite axis of side</param>
/// <param name="leadingPosition">Position of the leading edge of the colliding entity</param>
/// <param name="shouldTestSlopes">whether slopes should be considered for collision</param>
/// <returns>
/// isColliding is true if there was a collision
/// Returns the position of the collision on the same axis of side
/// </returns>
public TestCollisionInfo TestCollision(TileInfo.SideType side, GameUnit perpendicularPosition,
GameUnit leadingPosition, bool shouldTestSlopes)
{
TestCollisionInfo info = new TestCollisionInfo(false, leadingPosition);
if (tileType[(int)TileInfo.TileFlag.Wall])
{
info.isColliding = true;
if (side == TileInfo.SideType.TopSide)
{
info.position = Units.TileToGame(row);
}
else if (side == TileInfo.SideType.BottomSide)
{
info.position = Units.TileToGame(row + 1);
}
else if (side == TileInfo.SideType.LeftSide)
{
info.position = Units.TileToGame(col);
}
else
{
info.position = Units.TileToGame(col + 1);
}
}
else if (shouldTestSlopes && tileType[(int)TileInfo.TileFlag.Slope] &&
!tileType[(int)TileInfo.SlopeFlagFromSide(side)])
{
GameUnit row = Units.TileToGame(this.row);
GameUnit col = Units.TileToGame(this.col);
float slope = GetSlope(tileType);
GameUnit offset = GetOffset(tileType);
GameUnit calculatedPosition = TileInfo.Vertical(side) ?
slope * (perpendicularPosition - col) + offset + row :
(perpendicularPosition - row - offset) / slope + col;
bool isColliding = TileInfo.IsMax(side) ?
leadingPosition <= calculatedPosition :
leadingPosition >= calculatedPosition;
info.isColliding = isColliding;
info.position = calculatedPosition;
}
return info;
}
