/// <summary>
/// Determines if a moved hitbox intersects with a tilemap. Gives a new, valid solution if the new position is not valid.
/// </summary>
/// <param name="currentPosition">current position of the hitbox</param>
/// <param name="newPosition">new position of the hitbox</param>
/// <param name="hitBox">dimensions of the hitbox</param>
/// <returns>A Vector2 determining the hitbox's potentially new location.</returns>
public Vector2 reloactePosition(Vector2 currentPosition, Vector2 newPosition, Vector2 hitBox)
{
if (currentPosition.X < 0 || currentPosition.Y < 0 || currentPosition.X >= size.x * tileSize.X || currentPosition.Y >= size.y * tileSize.Y)
{
return(newPosition);
}
// get tile coordinates for entity+hitbox
TileDimensions tilesPosition = new TileDimensions((int)(currentPosition.X / tileSize.X), (int)(currentPosition.Y / tileSize.Y));
TileDimensions tilesPositionPlusHitBox = new TileDimensions((int)((currentPosition.X + hitBox.X) / tileSize.X), (int)((currentPosition.Y + hitBox.Y) / tileSize.Y));
Vector2 delta = newPosition - currentPosition;
Vector2 resultLocation = newPosition;
if (delta.X > 0)
{
bool breakLoop = false;
TileDimensions pos = new TileDimensions(-1, -1);
for (int i = tilesPositionPlusHitBox.x; i < size.x && !breakLoop; i++)
{
for (int j = tilesPosition.y; j <= tilesPositionPlusHitBox.y && j < size.y && !breakLoop; j++)
{
if (map[i, j] != TileType.NoWall)
{
breakLoop = true;
pos = new TileDimensions(i, j);
}
}
}
if (breakLoop)
{
resultLocation.X = Math.Min(newPosition.X, (pos.x * tileSize.X) - (hitBox.X + 1));
tilesPosition = new TileDimensions((int)(resultLocation.X / tileSize.X), (int)(currentPosition.Y / tileSize.Y));
tilesPositionPlusHitBox = new TileDimensions((int)((resultLocation.X + hitBox.X) / tileSize.X), (int)((currentPosition.Y + hitBox.Y) / tileSize.Y));
}
}
else if (delta.X < 0)
{
bool breakLoop = false;
TileDimensions pos = new TileDimensions(-1, -1);
for (int i = tilesPosition.x; i >= 0 && !breakLoop; i--)
{
for (int j = tilesPosition.y; j <= tilesPositionPlusHitBox.y && j < size.y && !breakLoop; j++)
{
if (map[i, j] != TileType.NoWall)
{
breakLoop = true;
pos = new TileDimensions(i, j);
}
}
}
if (breakLoop)
{
resultLocation.X = Math.Max(newPosition.X, ((pos.x + 1) * tileSize.X));
tilesPosition = new TileDimensions((int)(resultLocation.X / tileSize.X), (int)(currentPosition.Y / tileSize.Y));
tilesPositionPlusHitBox = new TileDimensions((int)((resultLocation.X + hitBox.X) / tileSize.X), (int)((currentPosition.Y + hitBox.Y) / tileSize.Y));
}
}
if (delta.Y > 0)
{
bool breakLoop = false;
TileDimensions pos = new TileDimensions(-1, -1);
for (int i = tilesPositionPlusHitBox.y; i < size.y && !breakLoop; i++)
{
for (int j = tilesPosition.x; j <= tilesPositionPlusHitBox.x && j < size.x && !breakLoop; j++)
{
if (map[j, i] != TileType.NoWall)
{
breakLoop = true;
pos = new TileDimensions(j, i);
}
}
}
if (breakLoop)
{
resultLocation.Y = Math.Min(newPosition.Y, (pos.y * tileSize.Y) - (hitBox.Y + 1));
}
}
else if (delta.Y < 0)
{
bool breakLoop = false;
TileDimensions pos = new TileDimensions(-1, -1);
for (int i = tilesPositionPlusHitBox.y; i > 0 && i < size.y && !breakLoop; i--)
{
for (int j = tilesPosition.x; j <= tilesPositionPlusHitBox.x && j < size.x && !breakLoop; j++)
{
if (map[j, i] != TileType.NoWall)
{
breakLoop = true;
pos = new TileDimensions(j, i);
}
}
}
if (breakLoop)
{
resultLocation.Y = Math.Max(newPosition.Y, (pos.y + 1) * tileSize.Y);
}
}
return(resultLocation);
}
private int GetTilesCount()
{
var sum = TileDimensions.Sum(tileDim => tileDim.Width * tileDim.Height);
return((int)sum);
}
public TileMap(LevelState parent, DungeonGenerator.DungeonRoom[,] room, Vector2 tileSize)
{
tileSkin = new Texture2D[5];
this.size = new TileDimensions(room.GetLength(0) * GlobalGameConstants.TilesPerRoomWide, room.GetLength(1) * GlobalGameConstants.TilesPerRoomHigh);
this.tileSize = tileSize;
this.parent = parent;
map = new TileType[size.x, size.y];
floorMap = new FloorType[size.x, size.y];
mapMod = new WallMod[size.x, size.y];
Random rand = new Random();
for (int i = 0; i < floorMap.GetLength(0); i++)
{
for (int j = 0; j < floorMap.GetLength(1); j++)
{
int randVal = Game1.rand.Next() % 100;
if (randVal > 15)
{
floorMap[i, j] = Game1.rand.Next() % 2 == 0 ? FloorType.A : FloorType.B;
}
else if (randVal > 10)
{
floorMap[i, j] = Game1.rand.Next() % 2 == 0 ? FloorType.C : FloorType.D;
}
else if (randVal > 5)
{
floorMap[i, j] = Game1.rand.Next() % 2 == 0 ? FloorType.E : FloorType.F;
}
else
{
floorMap[i, j] = Game1.rand.Next() % 2 == 0 ? FloorType.G : FloorType.H;
}
}
}
for (int i = 0; i < room.GetLength(0); i++)
{
for (int j = 0; j < room.GetLength(1); j++)
{
if (room[i, j].attributes != null)
{
ChunkManager.Chunk c = ChunkLib.getRandomChunkByValues(room[i, j].attributes.ToArray(), rand);
if (c == null)
{
throw new Exception("NO CHUNK FOR VALUES");
}
if (c != null)
{
foreach (ChunkManager.Chunk.ChunkAttribute attr in c.Attributes)
{
if (!room[i, j].attributes.Contains(attr.AttributeName))
{
room[i, j].attributes.Add(attr.AttributeName);
}
}
if (c != null)
{
for (int p = 0; p < GlobalGameConstants.TilesPerRoomWide; p++)
{
for (int q = 0; q < GlobalGameConstants.TilesPerRoomHigh; q++)
{
map[(i * GlobalGameConstants.TilesPerRoomWide) + p, (j * GlobalGameConstants.TilesPerRoomHigh) + q] = (TileType)(c.tilemap[(q * GlobalGameConstants.TilesPerRoomHigh) + p]);
}
}
room[i, j].chunkName = c.Name;
if (room[i, j].attributes.Contains("start"))
{
int startX = 0;
int startY = 0;
while (c.tilemap[startY * GlobalGameConstants.TilesPerRoomHigh + startX] == 1)
{
startX = rand.Next() % GlobalGameConstants.TilesPerRoomWide;
startY = rand.Next() % GlobalGameConstants.TilesPerRoomHigh;
}
startPosition.X = (i * GlobalGameConstants.TilesPerRoomWide * GlobalGameConstants.TileSize.X) + ((GlobalGameConstants.TilesPerRoomWide / 2) * GlobalGameConstants.TileSize.X);
startPosition.Y = (j * GlobalGameConstants.TilesPerRoomHigh * GlobalGameConstants.TileSize.Y) + ((GlobalGameConstants.TilesPerRoomHigh / 2) * GlobalGameConstants.TileSize.Y);
}
if (room[i, j].intensity > 0.95f)
{
endFlagPosition.X = (i * GlobalGameConstants.TilesPerRoomWide * GlobalGameConstants.TileSize.X) + ((GlobalGameConstants.TilesPerRoomWide / 2) * GlobalGameConstants.TileSize.X);
endFlagPosition.Y = (j * GlobalGameConstants.TilesPerRoomHigh * GlobalGameConstants.TileSize.Y) + ((GlobalGameConstants.TilesPerRoomHigh / 2) * GlobalGameConstants.TileSize.Y);
}
}
else
{
for (int p = 0; p < GlobalGameConstants.TilesPerRoomWide; p++)
{
for (int q = 0; q < GlobalGameConstants.TilesPerRoomHigh; q++)
{
map[(i * GlobalGameConstants.TilesPerRoomWide) + p, (j * GlobalGameConstants.TilesPerRoomHigh) + q] = TileType.TestWall;
}
}
}
}
}
else
{
//fill a room with empty tiles if it is empty
for (int p = 0; p < GlobalGameConstants.TilesPerRoomWide; p++)
{
for (int q = 0; q < GlobalGameConstants.TilesPerRoomHigh; q++)
{
map[(i * GlobalGameConstants.TilesPerRoomWide) + p, (j * GlobalGameConstants.TilesPerRoomHigh) + q] = TileType.TestWall;
}
}
}
}
}
convertTestWallsToWalls();
}
