public Color getTileColor(int tileX, int tileY)
{
Color tileColor = Color.White;
int xFragment = tileX / (LevelContent.LEVEL_SIZE_HALF);
int yFragment = tileY / (LevelContent.LEVEL_SIZE_HALF);
if (tileX == 0 || tileY == 0)
{
if (xPos == 0 || yPos == 0)
{
tileColor = Color.White;
}
else if (tileX == 0 && tileY == 0) // tile at topleft corner between levels
{
Color leftColor = RetroGame.getLevels()[xPos - 1, yPos].getTileColor(GRID_SIZE - 1, tileY);
Color topColor = RetroGame.getLevels()[xPos, yPos - 1].getTileColor(tileX, GRID_SIZE - 1);
Color cornerColor = RetroGame.getLevels()[xPos - 1, yPos - 1].getTileColor(GRID_SIZE - 1, GRID_SIZE - 1);
tileColor = Color.Lerp(Color.Lerp(leftColor, topColor, 0.5f), Color.Lerp(cornerColor, getTileColor(1, 1), 0.5f), 0.5f);
}
else if (tileX == 0) // tile in between levels on left
{
tileColor = Color.Lerp(RetroGame.getLevels()[xPos - 1, yPos].getTileColor(GRID_SIZE - 1, tileY), getTileColor(1, tileY), 0.5f);
}
else if (tileY == 0) // tile in between levels on top
{
tileColor = Color.Lerp(RetroGame.getLevels()[xPos, yPos - 1].getTileColor(tileX, GRID_SIZE - 1), getTileColor(tileX, 1), 0.5f);
}
}
else if (tileX == LevelContent.LEVEL_SIZE_HALF - 1 && tileY == LevelContent.LEVEL_SIZE_HALF - 1) // tile at center of 4 fragments
{
tileColor = Color.Lerp(Color.Lerp(fragmentGrid[0, 0].color, fragmentGrid[1, 0].color, 0.5f),
Color.Lerp(fragmentGrid[0, 1].color, fragmentGrid[1, 1].color, 0.5f), 0.5f);
}
else if (tileX == LevelContent.LEVEL_SIZE_HALF - 1) // tile in between fragments
{
tileColor = Color.Lerp(fragmentGrid[0, yFragment].color, fragmentGrid[1, yFragment].color, 0.5f);
}
else if (tileY == LevelContent.LEVEL_SIZE_HALF - 1) // tile in between fragments
{
tileColor = Color.Lerp(fragmentGrid[xFragment, 0].color, fragmentGrid[xFragment, 1].color, 0.5f);
}
else
{
tileColor = fragmentGrid[xFragment, yFragment].color;
}
return(tileColor);
}
public bool collidesWithWall(Vector2 position)
{
int x = (int)position.X;
int y = (int)position.Y;
if (x <= 0 || y <= 0)
{
return(true);
}
int levelX = x / Level.TEX_SIZE; // get which level you are in
int levelY = y / Level.TEX_SIZE;
if (levelX >= MAX_LEVELS || levelY >= MAX_LEVELS)
{
return(true);
}
Level level = RetroGame.getLevels()[levelX, levelY];
if (level == null)
{
return(true);
}
int tileX = (x % Level.TEX_SIZE) / Level.TILE_SIZE; // get which tile you are moving to
int tileY = (y % Level.TEX_SIZE) / Level.TILE_SIZE;
LevelContent.LevelTile tile = level.grid[tileX, tileY];
switch (tile)
{
case LevelContent.LevelTile.Wall:
return(true);
default:
break;
}
return(false);
}
public override void Update(GameTime gameTime)
{
//reset per-frame powerup modification fields BEFORE updating controls
globalMoveSpeedMultiplier = 1;
powerupCooldownModifier = 1;
teleportedThisFrame = false;
if (!Alive)
{
Powerups = (from pair in Powerups orderby pair.Value ascending select pair).ToDictionary(pair => pair.Key, pair => pair.Value);
foreach (Powerup p in Powerups.Values)
{
p.Update(gameTime);
}
return;
}
UpdateControls(bindings, gameTime);
#if DEBUG
if (this == RetroGame.getHeroes()[0])
{
UpdateDebugKeys();
}
#endif
//remove expendable powerups
for (int i = 0; i < Powerups.Count; i++)
{
Powerup p = Powerups.Values.ElementAt(i);
if (p.toRemove)
{
RemovePowerup(p.GenericName, false);
i--;
}
}
Powerups = (from pair in Powerups orderby pair.Value ascending select pair).ToDictionary(pair => pair.Key, pair => pair.Value);
foreach (Powerup p in Powerups.Values)
{
p.Update(gameTime);
}
float seconds = gameTime.getSeconds(HERO_TIMESCALE);
movement = dirVector * MOVE_SPEED * globalMoveSpeedMultiplier * seconds;
updateCurrentLevelAndTile();
Level level = RetroGame.getLevels()[levelX, levelY];
float nextX = position.X + movement.X;
float nextY = position.Y + movement.Y;
moved = true;
int n;
if (HERO_TIMESCALE > 0f)
{
switch (controllerDirection)
{
case Direction.Up:
case Direction.Down:
moved = canMove(movement);
if (!moved)
{
n = (int)position.Y;
nextY = n - (n % Level.TILE_SIZE) + Level.TILE_SIZE / 2;
}
break;
case Direction.Left:
case Direction.Right:
moved = canMove(new Vector2(movement.X, 0));
if (!moved)
{
n = (int)position.X;
nextX = n - (n % Level.TILE_SIZE) + Level.TILE_SIZE / 2;
}
break;
default:
nextX = position.X;
nextY = position.Y;
break;
}
}
if (controllerDirection != Direction.None)
{
direction = controllerDirection;
}
rotation = DIR_TO_ROTATION[direction];
position = new Vector2(nextX, nextY);
// check corners
LevelManager levelManager = RetroGame.TopLevelManagerScreen.levelManager;
if (moved &&
(levelManager.collidesWithWall(new Vector2(getLeft().X, getTop().Y)) || //topleft
levelManager.collidesWithWall(new Vector2(getLeft().X, getBottom().Y)) || //botleft
levelManager.collidesWithWall(new Vector2(getRight().X, getBottom().Y)) || //botright
levelManager.collidesWithWall(new Vector2(getRight().X, getTop().Y)))) //topright
{
switch (controllerDirection)
{
case Direction.Up:
case Direction.Down:
n = (int)position.X;
nextX = n - (n % Level.TILE_SIZE) + Level.TILE_SIZE / 2;
break;
case Direction.Left:
case Direction.Right:
n = (int)position.Y;
nextY = n - (n % Level.TILE_SIZE) + Level.TILE_SIZE / 2;
break;
default:
break;
}
}
position = new Vector2(nextX, nextY);
nextTileX = -1;
nextTileY = -1;
switch (direction)
{
case Direction.Up:
nextTileX = tileX;
nextTileY = tileY - 1;
break;
case Direction.Down:
nextTileX = tileX;
nextTileY = tileY + 1;
break;
case Direction.Left:
nextTileX = tileX - 1;
nextTileY = tileY;
break;
case Direction.Right:
nextTileX = tileX + 1;
nextTileY = tileY;
break;
}
nextLevelX = -1;
nextLevelY = -1;
nextLevel = null;
if (nextTileX < 0)
{
nextLevelX = levelX - 1;
nextLevelY = levelY;
if (nextLevelX >= 0)
{
nextLevel = RetroGame.getLevels()[nextLevelX, nextLevelY];
}
nextTileX = Level.GRID_SIZE - 1;
}
else if (nextTileX >= Level.GRID_SIZE)
{
nextLevelX = levelX + 1;
nextLevelY = levelY;
if (nextLevelX < LevelManager.MAX_LEVELS)
{
nextLevel = RetroGame.getLevels()[nextLevelX, nextLevelY];
}
nextTileX = 0;
}
else if (nextTileY < 0)
{
nextLevelX = levelX;
nextLevelY = levelY - 1;
if (nextLevelY >= 0)
{
nextLevel = RetroGame.getLevels()[nextLevelX, nextLevelY];
}
nextTileY = Level.GRID_SIZE - 1;
}
else if (nextTileY >= Level.GRID_SIZE)
{
nextLevelX = levelX;
nextLevelY = levelY + 1;
if (nextLevelY < LevelManager.MAX_LEVELS)
{
nextLevel = RetroGame.getLevels()[nextLevelX, nextLevelY];
}
nextTileY = 0;
}
else
{
nextLevel = level;
}
//collision with collectables
if (Alive)
{
foreach (Level l in levelManager.CurrentLevels)
{
foreach (Collectable c in l.collectables)
{
if (c.ableToBeCollected && hitbox.intersects(c.hitbox))
{
c.collectedBy(this);
}
}
foreach (Prisoner p in l.prisoners)
{
if (p.ableToBeCollected && hitbox.intersects(p.hitbox))
{
p.collectedBy(this);
}
}
foreach (PowerupIcon p in l.powerups)
{
if (p.ableToBeCollected && hitbox.intersects(p.hitbox))
{
p.collectedBy(this);
}
}
}
}
//flashing
float flashTotalDuration = individualFlashDuration * flashCount;
if (flashTime < flashTotalDuration)
{
flashTime += seconds;
float flashInterp = (flashTime % individualFlashDuration) / individualFlashDuration;
float colorInterp = 1f - (Math.Abs(flashInterp - 0.5f) * 2); //map 0.0 - 0.5 to 0.0 - 1.0 and 0.5 - 1.0 to 1.0 - 0.0
maskingColor = Color.Lerp(color, flashColor, colorInterp);
}
else
{
maskingColor = color;
}
base.Update(gameTime);
}
public bool attemptScroll(Entity entity, Vector2 offset)
{
Vector2 topEdge = (entity.getTop() + offset);
Vector2 bottomEdge = (entity.getBottom() + offset);
Vector2 leftEdge = entity.getLeft() + offset;
Vector2 rightEdge = entity.getRight() + offset;
Vector2 leadEdge = Vector2.Zero;
Direction dir = Direction.None;
if (offset.X < 0 && offset.X != 0)
{
dir = Direction.Left;
leadEdge = leftEdge;
}
else if (offset.X > 0 && offset.X != 0)
{
dir = Direction.Right;
leadEdge = rightEdge;
}
else if (offset.Y < 0 && offset.Y != 0)
{
dir = Direction.Up;
leadEdge = topEdge;
}
else if (offset.Y > 0 && offset.Y != 0)
{
dir = Direction.Down;
leadEdge = bottomEdge;
}
int x = (int)leadEdge.X;
int y = (int)leadEdge.Y;
if (x <= 0 || y <= 0)
{
return(false);
}
int levelX = x / Level.TEX_SIZE; // get which level you are going to
int levelY = y / Level.TEX_SIZE;
if (levelX >= MAX_LEVELS || levelY >= MAX_LEVELS)
{
return(false);
}
Level level = RetroGame.getLevels()[levelX, levelY];
if (level == null)
{
return(false);
}
int tileX = (x % Level.TEX_SIZE) / Level.TILE_SIZE; // get which tile you are moving to
int tileY = (y % Level.TEX_SIZE) / Level.TILE_SIZE;
LevelContent.LevelTile tile = level.grid[tileX, tileY];
if (tile == LevelContent.LevelTile.Wall)
{
return(false);
}
else if (entity is Enemy && level.enemyGrid[tileX, tileY] != null && level.enemyGrid[tileX, tileY] != entity)
{
return(false);
}
return(true);
}
