// selects tile
private void select(TopTile tileData)
{
scoreHandler.score += 15;
tileData.ownerId = id;
tileData.tileObject.GetComponent <Renderer>().material = selectionMaterial;
}
private void spawnHouse()
{
TopTile tile = (TopTile)TileData.hash[inputHandler.clickedTile];
if (tile.ownerId == id)
{
Tower tower = new Tower(tile.tileObject.transform.position, towerModel, tile.x, tile.y);
selectTeritory(tower);
}
}
private void spawnFort()
{
TopTile tile = (TopTile)TileData.hash[inputHandler.clickedTile];
if (tile.ownerId == -1)
{
Fort fort = new Fort(tile.tileObject.transform.position, fortModel, tile.x, tile.y);
selectTeritory(fort);
}
}
// tile can be island and isn't already
private bool validTile(TopTile tile)
{
if (tile != null)
{
if (tile.islandId == -1)
{
return(true);
}
}
return(false);
}
private void crawl(TopTile tile, int x, int y, int range, TopTile[] tempOwnedTiles)
{
tempOwnedTiles[ownedCount] = tile;
ownedCount++;
if (y % 2 == 0)
{
for (int kernelY = y - 1; kernelY <= y + 1; kernelY++)
{
int offset = 0;
if (kernelY == y)
{
offset = 1;
}
for (int kernelX = x - offset; kernelX <= x + 1; kernelX++)
{
if (kernelY >= 0 && kernelX >= 0 && kernelY < TileData.y && kernelX < TileData.x)
{
TopTile _tile = TileData.tiles[kernelX, kernelY];
if (_tile != null && _tile.ownerId == -1 && range > 1)
{
crawl(_tile, kernelX, kernelY, range - 1, tempOwnedTiles);
}
}
}
}
}
else
{
for (int kernelY = y - 1; kernelY <= y + 1; kernelY++)
{
int offset = 0;
if (kernelY == y)
{
offset = 1;
}
for (int kernelX = x - 1; kernelX <= x + offset; kernelX++)
{
if (kernelY >= 0 && kernelX >= 0 && kernelY < TileData.y && kernelX < TileData.x)
{
TopTile _tile = TileData.tiles[kernelX, kernelY];
if (_tile != null && _tile.ownerId == -1 && range > 1)
{
crawl(_tile, kernelX, kernelY, range - 1, tempOwnedTiles);
}
}
}
}
}
}
// crawl whole island for tiles recursively
private void crawl(TopTile tile, int x, int y)
{
tile.islandId = id;
if (y % 2 == 0)
{
for (int kernelY = y - 1; kernelY <= y + 1; kernelY++)
{
int offset = 0;
if (kernelY == y)
{
offset = 1;
}
for (int kernelX = x - offset; kernelX <= x + 1; kernelX++)
{
if (kernelY >= 0 && kernelX >= 0 && kernelY < lengthY && kernelX < lengthX)
{
tile = TileData.tiles[kernelX, kernelY];
if (validTile(tile))
{
crawl(tile, kernelX, kernelY);
}
}
}
}
}
else
{
for (int kernelY = y - 1; kernelY <= y + 1; kernelY++)
{
int offset = 0;
if (kernelY == y)
{
offset = 1;
}
for (int kernelX = x - 1; kernelX <= x + offset; kernelX++)
{
if (kernelY >= 0 && kernelX >= 0 && kernelY < lengthY && kernelX < lengthX)
{
tile = TileData.tiles[kernelX, kernelY];
if (validTile(tile))
{
crawl(tile, kernelX, kernelY);
}
}
}
}
}
}
public void generate(Vector3 size, int maxHeight, int smoothness)
{
// get heightmap data
HeightMap heightMap = new HeightMap(lengthX, lengthY, maxHeight);
heightMap.smooth(smoothness);
// map offset for centering
Vector3 start = new Vector3(-lengthX * size.x / 2, 0, -lengthY * size.y / 2);
// cache data of each tile
GameObject tileModel = Resources.Load("Tile") as GameObject;
GameObject TopTileModel = Resources.Load("TopTile") as GameObject;
GameObject parent = GameObject.Find("Tiles");
int waterHeightLevel = GameObject.Find("Water").GetComponent <WaterController>().waterHeightLevel;
for (int x = 0; x < lengthX; x++)
{
for (int y = 0; y < lengthY; y++)
{
// cache height
int height = heightMap.height[x, y];
int lowestNeighbour = heightMap.lowestNeighbour(x, y) + 1;
// exclude not visible tiles
if (lowestNeighbour > height)
{
lowestNeighbour = height;
}
for (int z = lowestNeighbour; z <= height; z++)
{
// create tiles
if (z < height || z < waterHeightLevel)
{
BotTile botTile = new BotTile(new Vector3(start.x + x * size.x - (size.x / 2) * (y % 2), z * size.z, start.z + y * size.y), z, tileModel, parent, waterHeightLevel);
}
else
{
TopTile topTile = new TopTile(new Vector3(start.x + x * size.x - (size.x / 2) * (y % 2), z * size.z, start.z + y * size.y), x, y, z, TopTileModel, parent);
}
}
}
}
// move ocean to tile
GameObject.Find("Ocean").transform.position = new Vector3(0, heightMap.lowestHeigh() * size.z, 0);
}
void SetRules()
{
patterns[0] = new OutsideTopLeftTile();
patterns[1] = new TopTile();
patterns[2] = new OutsideTopRightTile();
patterns[3] = new LeftTile();
patterns[4] = new MiddleTile();
patterns[5] = new RightTile();
patterns[6] = new OutsideDownLeftTile();
patterns[7] = new DownTile();
patterns[8] = new OutsideDownRightTile();
patterns[9] = new InsideTopLeftTile();
patterns[10] = new InsideTopRightTile();
patterns[11] = new InsideDownLeftTile();
patterns[12] = new InsideDownRightTile();
}
// fills ownedTiles array with tiles around building
protected void select(int range)
{
TopTile[] tempOwnedTiles = new TopTile[range * range * 4];
ownedCount = 0;
// get temporary large array of owned tiles
//TODO OPTIMIZE THIS !
crawl(TileData.tiles[x, y], x, y, range, tempOwnedTiles);
// transfer data to compact array
ownedTiles = new TopTile[ownedCount];
for (int i = 0; i < ownedCount; i++)
{
ownedTiles[i] = tempOwnedTiles[i];
}
}
