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);
}
/// <summary>
/// Returns true if projectile is still alive
/// </summary>
/// <param name="gameTime"></param>
/// <returns>True if projectile is still alive</returns>
public bool Update(GameTime gameTime, Map map, ParticleTools particleTools)
{
offset += (float)gameTime.ElapsedGameTime.TotalMilliseconds * ProjectileSpeed;
TileInfo.SideType direction = TileInfo.FromFacing(horizontalDirection, verticalDirection);
Rectangle rectangle = CollisionRectangle;
List <CollisionTile> collidingTiles = map.GetCollidingTiles(rectangle, direction);
for (int i = 0; i < collidingTiles.Count; i++)
{
TileInfo.SideType side = TileInfo.OppositeSide(direction);
GameUnit perpendicularPosition = TileInfo.Vertical(side) ?
rectangle.Center.X : rectangle.Center.Y;
GameUnit leadingPosition = rectangle.Side(direction);
bool shouldTestSlopes = true;
TestCollisionInfo testInfo = collidingTiles[i].TestCollision(side, perpendicularPosition,
leadingPosition, shouldTestSlopes);
if (testInfo.isColliding)
{
GameUnit collisionX;
if (TileInfo.Vertical(side))
{
collisionX = perpendicularPosition;
}
else
{
collisionX = testInfo.position;
}
GameUnit collisionY;
if (TileInfo.Vertical(side))
{
collisionY = testInfo.position;
}
else
{
collisionY = perpendicularPosition;
}
particleTools.FrontSystem.AddNewParticle(ProjectileWallParticle.Create(particleTools.Content,
collisionX - Units.HalfTile, collisionY - Units.HalfTile));
return(false);
}
}
if (!alive)
{
return(false);
}
else if (offset >= ProjectileMaxOffsets[gunLevel - 1])
{
particleTools.FrontSystem.AddNewParticle(ProjectileStarParticle.Create(particleTools.Content, X, Y));
return(false);
}
else
{
return(true);
}
}
private void Update(ICollisionRectangle collisionRectangle,
IAccelerator accelerator,
Kinematics kinematicsX, Kinematics kinematicsY,
GameTime gameTime, Map map,
BitArray maybeGroundTile,
Kinematics kinematics, AxisType axis)
{
Func <Map, Rectangle, TileInfo.SideType, BitArray, CollisionInfo?> testMapCollisionFunc;
if (collisionType == CollisionType.BouncingCollision)
{
testMapCollisionFunc = TestMapBouncingCollision;
}
else
{
testMapCollisionFunc = TestMapStickyCollision;
}
accelerator.UpdateVelocity(kinematics, gameTime);
GameUnit delta = kinematics.velocity * (float)gameTime.ElapsedGameTime.TotalMilliseconds;
TileInfo.SideType direction = axis == AxisType.XAxis ?
(delta > 0 ? TileInfo.SideType.RightSide : TileInfo.SideType.LeftSide) :
(delta > 0 ? TileInfo.SideType.BottomSide : TileInfo.SideType.TopSide);
CollisionInfo?maybeInfo = testMapCollisionFunc(map,
collisionRectangle.Collision(direction, kinematicsX.position, kinematicsY.position, delta),
direction, maybeGroundTile);
if (maybeInfo.HasValue)
{
kinematics.position = maybeInfo.Value.position - collisionRectangle.BoundingBox.Side(direction);
debugCollidingTiles.Add(maybeInfo.Value.tilePosition);
OnCollision(direction, true, maybeInfo.Value.tileType);
}
else
{
kinematics.position += delta;
OnDelta(direction);
}
maybeInfo = null;
TileInfo.SideType oppositeDirection = TileInfo.OppositeSide(direction);
maybeInfo = testMapCollisionFunc(map,
collisionRectangle.Collision(oppositeDirection, kinematicsX.position, kinematicsY.position, 0),
oppositeDirection, null);
if (maybeInfo.HasValue)
{
kinematics.position = maybeInfo.Value.position - collisionRectangle.BoundingBox.Side(oppositeDirection);
debugOppositeCollidingTiles.Add(maybeInfo.Value.tilePosition);
OnCollision(oppositeDirection, false, maybeInfo.Value.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);
}
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);
}
