public override void handleClick()
{
GrassTile tile = GameManager.instance.getSelectedTile();
tile.trySpawningTower("bomb");
GameManager.instance.closeMenu();
}
public World GenerateWorld(int width, int height, int numPaths)
{
World w = new World(width, height);
// setup world tiles
for (int x = 0; x < w.Width; x++)
{
for (int y = 0; y < w.Height; y++)
{
float g = (float)random.NextDouble() * 0.05f + 0.5f;
WorldTile tile = new GrassTile(new Color(0, g, 0));
w.SetTile(x, y, tile);
}
}
// generate track
List <int> usedYVals = new List <int>();
List <int> usedColorIndices = new List <int>();
for (int path = 0; path < numPaths; path++)
{
int startX = 0;
int startY = NextNotIn(random, usedYVals, 0, w.Height);
int endX = w.Width - 1;
int endY = NextNotIn(random, usedYVals, 0, w.Height);
Rail start = new BufferRail(Direction.West, false, null);
Payload payload = new Payload(payloadTexture, PayloadColors[NextNotIn(random, usedColorIndices, 0, PayloadColors.Length)]);
start.Vehicles.Add(new Wagon(0.8f, 0, Direction.East, payload));
w.SetRail(startX, startY, start);
w.SetRail(endX, endY, new BufferRail(Direction.East, false, payload));
w.StartingRails.Add(start, payload);
}
return(w);
}
public void AssignTiles()
{//initial tile generation
var rng = new Random();
for (var i = 0; i < Height; i++)
{
for (var j = 0; j < Length; j++)
{
var tileSeed = rng.Next(1, 100);
if (tileSeed < 25)
{
Tiles[i, j] = new WaterTile(i, j);
}
else if (tileSeed < 50)
{
Tiles[i, j] = new SoilTile(i, j);
}
else if (tileSeed < 75)
{
Tiles[i, j] = new GrassTile(i, j);
}
else if (tileSeed < 100)
{
Tiles[i, j] = new TreeTile(i, j);
}
}
}
}
public void SwapTile(Tile tile, double avgDepth, int depthSeed)
{
int i = tile.GetX();
int j = tile.GetY();
int tileDepth = tile.Depth;
var rng = new Random();
if (tile.GetGroundType() == "water" && tileDepth > avgDepth)
{//if tile is higher than average tiles and water, "flow" water away from tile
if (depthSeed < 33)
{
Tiles[i, j] = new SoilTile(i, j);
}
else if (depthSeed < 66)
{
Tiles[i, j] = new GrassTile(i, j);
}
else
{
Tiles[i, j] = new TreeTile(i, j);
}
//"flow" only goes in cardinal direction currently
var flowSeed = rng.Next(1, 100);
Pour(i, j, flowSeed, tileDepth);
}
}
public void CreateMapFromTiles(TempTile[] tempTiles)
{
Tile[] newTiles = new Tile[tempTiles.Length];
for (int x = 0; x < mapWidth; x++)
{
for (int y = 0; y < mapHeight; y++)
{
TempTile tile = tempTiles[(mapWidth * y) + x];
Vector2 worldLoc2 = GetTileWorldLoc(tile);
Vector3 worldLoc3 = new Vector3(worldLoc2.x, 0, worldLoc2.y);
Vector3 tilePos = new Vector3(worldLoc2.x + 0.5f, 0, worldLoc2.y + 0.5f);
int rotateAmt = Random.Range(0, 4);
Quaternion tileRot = Quaternion.Euler(0, 90 * rotateAmt, 0);
char tileType = tile.type;
int tileAutoID = tile.autotileID;
if ((tileType == 'F' || tileType == 'R') && tileAutoID == 15) // Forest Biome
{
GameObject tileObj = (GameObject)Instantiate(grassTiles[0], tilePos, tileRot);
tileObj.transform.parent = transform;
List <WorldResource> tileResources = GenerateResources(tile, worldLoc2, (tileType == 'F'));
ResourceTile rT = new ResourceTile(tile.loc, worldLoc3, 'R', tileObj, tileResources, (tileType == 'F'));
newTiles[(mapWidth * y) + x] = rT;
}
else if (tileAutoID > -1) // Grass and Coast Biome
{
if (tileAutoID == 15)
{
float flowerPercent = Random.Range(0f, (float)grassTiles.Length);
int tileNum = 0;
if (flowerPercent < flowerCutoff)
{
tileNum = 1;
}
GameObject tileObj = (GameObject)Instantiate(grassTiles[tileNum], tilePos, tileRot);
tileObj.transform.parent = transform;
GrassTile gT = new GrassTile(tile.loc, worldLoc3, 'G', tileObj);
newTiles[(mapWidth * y) + x] = gT;
}
else // Ocean Biome
{
GameObject tileObj = (GameObject)Instantiate(edgeTiles[tileAutoID], tilePos, edgeTiles[tileAutoID].transform.rotation);
tileObj.transform.parent = transform;
CoastTile cT = new CoastTile(tile.loc, worldLoc3, 'G', tileObj);
newTiles[(mapWidth * y) + x] = cT;
}
}
else if (tileType == 'W')
{
GameObject tileObj = (GameObject)Instantiate(clearTile, tilePos, clearTile.transform.rotation);
tileObj.transform.parent = transform;
tileObj.SetActive(false);
OceanTile oT = new OceanTile(tile.loc, worldLoc3, 'W', tileObj);
newTiles[(mapWidth * y) + x] = oT;
}
}
}
tiles = newTiles;
}
private void MoveExistingTower(GrassTile tile)
{
towers[index].ParentTile.RemoveTowerFromTile();
// towers[index].ParentTile.isTowerPlaced = false; //Reset isTowerPlaced for old Position
towers[index].transform.position = tile.transform.position + yOffset;
towers[index].ParentTile = tile;
tile.SetTowerToTile(towers[index]);
OnTowerPlaced?.Invoke(towers[index]);
}
private void CheckTileStatus(ObjectData droppedSeed)
{
GameObject standingTile = FindStandingTile();
GrassTile grassTile = standingTile.GetComponent <GrassTile>();
// m_Animator.SetBool("Planting", true);
if (standingTile.tag == "GroundTile")
{
grassTile.CheckIfSeedPlantable(droppedSeed);
}
}
public WorldMap()
{
_tiles = new Tile[SizeX, SizeY];
for (var x = 0; x < SizeX; ++x)
{
for (var y = 0; y < SizeY; ++y)
{
_tiles[x, y] = new GrassTile();
}
}
}
public void SetupGrid()
{
for (int x = 0; x < Columns; x++)
{
for (int y = 0; y < Rows; y++)
{
//Tile tile = new GrassTile(new Point(x, y), "Sprites/Tiles/spr_cave_sheet_0@4x8", TileType.Floor, TextureType.Grass);
Tile tile = new GrassTile(new Point(x, y), "Sprites/Tiles/spr_grass_sheet_0@4x8", TileType.Floor, TextureType.Grass);
Add(tile, x, y);
}
}
}
private void InstantiateNewTower(GrassTile tile)
{
Tower tower = Instantiate(towerPrefab, tile.transform.position + yOffset, Quaternion.identity);
towers[index] = tower;
tower.transform.SetParent(gameObject.transform);
tower.gameObject.name = "Tower " + index;
towers[index].ParentTile = tile;
tile.SetTowerToTile(tower);
OnTowerPlaced?.Invoke(tower);
}
public FlyWeightTile getTile(int i)
{
if (tiles[i] == null)
{
switch (i)
{
case 0: tiles[i] = new GrassTile(); break;
case 1: tiles[i] = new WaterTile(); break;
default:
break;
}
}
return tiles[i];
}
private void Update()
{
if (Input.GetKeyDown(KeyCode.A))
{
seed = Random.Range(-10000000, 1000000);
Generation();
}
if (Input.GetKeyDown(KeyCode.D))
{
StoneTile.ClearAllTiles();
DirtTile.ClearAllTiles();
GrassTile.ClearAllTiles();
}
}
public void PlaceTower(GrassTile tile)
{
if (tile.isTowerPlaced)
{
return;
}
if (towers.Any(item => item == null))
{
InstantiateNewTower(tile);
}
else
{
MoveExistingTower(tile);
}
index = (index + 1) % maxTowers;
}
//Creates an empty room of size (Width,Height) and fills it with grass tiles
public Room(int Height = 0, int Width = 0)
{
this.Height = Height;
this.Width = Width;
TileArray = new Tile[Width, Height];
//Goes through each index of the array and fills it with grass tiles
for (int x = 0; x < Width; x++)
{
for (int y = 0; y < Height; y++)
{
//Adds grass tiles with no block or actor.
TileArray[x, y] = new GrassTile(this, x, y);
}
}
}
public void SwitchTile(Vector2 mousepos, TileType tp, TextureType tt, TileObject to, string asset)
{
//check selected tile
Vector2 vpos = GridPosition(mousepos + new Vector2(0, cellHeight / 2));
Point pos = new Point((int)vpos.X, (int)vpos.Y);
Tile tile = Get(pos.X, pos.Y) as Tile;
if (tile != null)
{
//change tile
if (tile.TileObject == to)
{
tile.ChangeTile(tp, tt, asset);
}
else
{
//replace tile
Remove(tile.Id, pos.X, pos.Y);
Tile newtile;
switch (to)
{
case TileObject.Tile:
newtile = new Tile(pos, asset, tp, tt);
break;
case TileObject.WallTile:
newtile = new WallTile(pos, asset, tp, tt);
break;
case TileObject.TreeTile:
newtile = new TreeTile(pos, asset, tp, tt);
break;
case TileObject.GrassTile:
newtile = new GrassTile(pos, asset, tp, tt);
break;
default:
newtile = new Tile(pos);
break;
}
Add(newtile, pos.X, pos.Y);
newtile.ChangeTile(tp, tt, asset);
}
}
}
public void Test_SwapTile_Under66()
{
var controlGroup = new GrassTile(1, 1)
{
Depth = 5
};
TestWorld.AssignTiles();
TestWorld.AssignDepth();
TestWorld.Tiles[1, 1] = new WaterTile(1, 1)
{
Depth = 5
};
TestWorld.SwapTile(TestWorld.Tiles[1, 1], TestAvgDepth, GrassDepthSeed);
Assert.AreEqual(controlGroup.GetGroundType(), TestWorld.Tiles[1, 1].GetGroundType());
}
private void initialize(int id)
{
try {
Texture2D t2d = Texture2D.FromStream(engine.GraphicsDevice, File.OpenRead("Content/maps/" + id + ".png"));
this.w = t2d.Width;
this.h = t2d.Height;
tiles = new Tile[w * h];
uint[] colors = new uint[w * h];
t2d.GetData <uint>(colors);
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
uint col = colors[x + y * w] & 0xffffff;
Tile t = new GrassTile(this, x, y);
if (col == 0xffffff)
{
t = new GrassTile(this, x, y);
}
else if (col == 0x00ffff)
{
t = new ErrorTile(this, x, y);
this.player = new PlayerEntity(this, x << 4, y << 4);
}
else if (col == 0x000000)
{
t = new RockTile(this, x, y);
}
else
{
t = new ErrorTile(this, x, y);
}
tiles[x + y * w] = t;
}
}
GrassTile.GrassRandom = new Random(0xffffff);
} catch (Exception e) {
Console.WriteLine("OH SHIT: " + e);
}
}
private void InitializeMap()
{
for (var y = 0; y < Map.Height; y++)
{
for (var x = 0; x < Map.Width; x++)
{
var position = new Position(x, y);
if (y > Map.Height - 5)
{
Map[position] = new WaterTile();
}
else
{
Map[position] = new GrassTile();
}
}
}
}
public override void FinishedTargetLocation(Tile targetTile, WorldResource targetResource)
{
GameObject.Destroy(targetResource.GetResourceObject());
resourcesLeft--;
if (resourcesLeft == 0)
{
// Change tile back to Grass Tile
GrassTile gT = new GrassTile(mapLoc, worldLoc, type, tileObj);
mapScript.SetTileFromMapPos((int)mapLoc.x, (int)mapLoc.y, gT);
}
if (isTrees)
{
tm.AddResource(woodRes);
}
else
{
tm.AddResource(stoneRes);
}
}
void Generation()
{
for (int x = 0; x < width; x++)
{
//Height Generation
height = Mathf.RoundToInt(heightValue * Mathf.PerlinNoise(x / smoothness, seed));
//Max Stone Spawn Distance
int minStoneSpawnDistance = height - minStoneheight;
int maxStoneSpawnDistance = height - maxStoneheight;
int totalStoneSpawnDistance = Random.Range(minStoneSpawnDistance, maxStoneSpawnDistance);
int maxGrassHeightDistance = height;
int maxWaterSpawnDistance = maxGrassHeightDistance;
int mimWaterSpawnDistance = height - 0;
for (int y = 0; y < height; y++)
{
if (y < totalStoneSpawnDistance)
{
StoneTile.SetTile(new Vector3Int(x, y, 0), Stone);
}
else
{
DirtTile.SetTile(new Vector3Int(x, y, 0), Dirt);
}
if (totalStoneSpawnDistance == height)
{
StoneTile.SetTile(new Vector3Int(x, height, 0), Stone);
}
else
{
GrassTile.SetTile(new Vector3Int(x, height, 0), Grass);
}
}
}
}
public GameWorld()
{
WorldRender = new RenderTarget2D(ScreenManager.Instance.Graphics.GraphicsDevice, Tile.WIDTH * WORLD_WIDTH, Tile.HEIGHT * WORLD_HEIGHT);
TileGrid = new Tile[WORLD_WIDTH, WORLD_HEIGHT];
for (int i = 0; i < WORLD_WIDTH; i++)
{
for (int j = 0; j < WORLD_HEIGHT; j++)
{
TileGrid[i, j] = new GrassTile(new TileCoordinates(i, j));
}
}
PathingGrid = new PathGrid(this);
ImportantTiles = new List <Tile>();
UpdateWorldRender();
}
public void Test_AddValues()
{
var testTile = new SoilTile(1, 1);
var testWaterTile = new WaterTile(0, 0);
var testSoilTile = new SoilTile(0, 1);
var testGrassTile = new GrassTile(0, 2);
var testTreeTile = new TreeTile(1, 0);
var testForestTile = new ForestTile(2, 0);
var testValues = testTile.GetAdjacentValues();
testTile.AddTileValue(testWaterTile);
testTile.AddTileValue(testSoilTile);
testTile.AddTileValue(testGrassTile);
testTile.AddTileValue(testTreeTile);
testTile.AddTileValue(testForestTile);
Assert.AreEqual(1, testValues[0]);
Assert.AreEqual(1, testValues[1]);
Assert.AreEqual(1, testValues[2]);
Assert.AreEqual(1, testValues[3]);
Assert.AreEqual(1, testValues[4]);
}
/// <summary>
/// Calculates data used for placing grass on terrain regardless of
/// whether or not this data has already been computed previously.
/// Use <c>HasGrassData</c> to check if its already been computed.
/// This method calculates grass meshes via a coroutine which calculates a
/// mesh and then waits for the next frame before continuing to the next.
/// </summary>
public static void CalculateGrassMeshes(TerrainTile tile)
{
GrassTile gt = new GrassTile(tile, TerraSettings.Instance.GrassStepLength);
CalculatingTile = true;
tile.StartCoroutine(gt.CalculateCells((data) => {
List <GameObject> createdGos = new List <GameObject>(data.Count);
GameObject parent = SetupGrassParent(tile);
foreach (GrassTile.MeshData md in data)
{
//Apply material to each Mesh
if (md.vertices != null)
{
GameObject grassGO = new GameObject("Grass");
grassGO.transform.parent = parent.transform;
createdGos.Add(grassGO);
var mf = grassGO.AddComponent <MeshFilter>();
var mr = grassGO.AddComponent <MeshRenderer>();
mr.material = Material;
Mesh m = new Mesh();
m.SetVertices(md.vertices);
m.SetNormals(md.normals);
m.SetIndices(md.indicies.ToArray(), MeshTopology.Points, 0);
mf.mesh = m;
}
}
CachedMeshData.Add(tile, createdGos);
CalculatingTile = false;
}));
}
void ToggleTowerUIinactive(GrassTile tile) //unschön, weil Parameter hier sinnlos
{
towerUI.gameObject.SetActive(false);
}
public GrassTile FindStandingGrassTile()
{
GrassTile grassTile = FindStandingTile().GetComponent <GrassTile>();
return(grassTile);
}
public void Test_GrassTile()
{
var testGrassTile = new GrassTile(1, 1);
Assert.AreEqual("grass", testGrassTile.GetGroundType());
}
public Map()
{
map = new Tile[50, 101];
//Outer edges
//North South
for (int row = 0; row < 50; row++)
{
map[row, 0] = new RockTile();
map[row, 100] = new RockTile();
map[row, 1] = new RockTile();
map[row, 99] = new RockTile();
}
//East West
for (int column = 1; column < 101; column++)
{
map[0, column] = new RockTile();
map[49, column] = new RockTile();
}
// Initializes all other tiles
for (int row = 1; row < 49; row++)
{
for (int column = 2; column < 99; column++)
{
if (column % 2 == 0)
{
map[row, column] = new PlainTile();
}
else
{
map[row, column] = new GrassTile();
}
}
}
//Random Trees
for (int i = 0; i < 75; i++)
{
randX = rand.Next(6, 45);
randY = rand.Next(6, 95);
if (map[randX, randY].TileType == "Grass")
{
map[randX, randY] = new TreeTile();
}
}
//Random Rocks
for (int i = 0; i < 30; i++)
{
randX = rand.Next(6, 45);
randY = rand.Next(6, 87);
if (map[randX, randY].TileType == "Grass")
{
map[randX, randY] = new RockTile();
}
}
//Castle
map[39, 98] = new RockTile();
map[39, 97] = new RockTile();
map[39, 96] = new RockTile();
map[39, 95] = new RockTile();
map[39, 94] = new RockTile();
map[39, 90] = new RockTile();
map[39, 89] = new RockTile();
map[39, 88] = new RockTile();
map[39, 87] = new RockTile();
map[40, 87] = new RockTile();
map[41, 87] = new RockTile();
map[42, 87] = new RockTile();
map[43, 87] = new RockTile();
map[44, 87] = new RockTile();
map[45, 87] = new RockTile();
map[46, 87] = new RockTile();
map[47, 87] = new RockTile();
map[48, 87] = new RockTile();
//Lake
map[3, 86] = new WaterTile();
map[3, 87] = new WaterTile();
map[3, 88] = new WaterTile();
map[3, 89] = new WaterTile();
map[3, 90] = new WaterTile();
map[3, 91] = new WaterTile();
map[8, 86] = new WaterTile();
map[8, 87] = new WaterTile();
map[8, 88] = new WaterTile();
map[8, 89] = new WaterTile();
map[8, 90] = new WaterTile();
map[8, 91] = new WaterTile();
map[9, 88] = new WaterTile();
map[9, 89] = new WaterTile();
map[10, 88] = new WaterTile();
map[10, 89] = new WaterTile();
map[11, 88] = new WaterTile();
map[11, 89] = new WaterTile();
map[12, 88] = new WaterTile();
map[12, 89] = new WaterTile();
map[13, 87] = new WaterTile();
map[13, 88] = new WaterTile();
map[14, 87] = new WaterTile();
map[14, 88] = new WaterTile();
map[15, 87] = new WaterTile();
map[15, 88] = new WaterTile();
map[16, 87] = new WaterTile();
map[16, 88] = new WaterTile();
map[17, 88] = new WaterTile();
map[17, 89] = new WaterTile();
map[18, 88] = new WaterTile();
map[18, 89] = new WaterTile();
map[19, 88] = new WaterTile();
map[19, 89] = new WaterTile();
map[20, 89] = new WaterTile();
map[20, 90] = new WaterTile();
map[21, 89] = new WaterTile();
map[21, 90] = new WaterTile();
map[22, 89] = new WaterTile();
map[22, 90] = new WaterTile();
map[23, 88] = new WaterTile();
map[23, 89] = new WaterTile();
map[24, 87] = new WaterTile();
map[24, 88] = new WaterTile();
map[25, 86] = new WaterTile();
map[25, 87] = new WaterTile();
map[26, 86] = new WaterTile();
map[26, 87] = new WaterTile();
map[27, 86] = new WaterTile();
map[27, 87] = new WaterTile();
map[28, 86] = new WaterTile();
map[28, 87] = new WaterTile();
map[29, 86] = new WaterTile();
map[29, 87] = new WaterTile();
map[30, 87] = new WaterTile();
map[30, 88] = new WaterTile();
map[31, 87] = new WaterTile();
map[31, 88] = new WaterTile();
map[32, 87] = new WaterTile();
map[32, 88] = new WaterTile();
map[33, 88] = new WaterTile();
map[33, 89] = new WaterTile();
map[34, 88] = new WaterTile();
map[34, 89] = new WaterTile();
map[35, 88] = new WaterTile();
map[35, 89] = new WaterTile();
map[34, 83] = new WaterTile();
map[34, 84] = new WaterTile();
map[34, 85] = new WaterTile();
map[34, 86] = new WaterTile();
map[34, 87] = new WaterTile();
map[34, 88] = new WaterTile();
map[34, 89] = new WaterTile();
map[34, 90] = new WaterTile();
map[34, 91] = new WaterTile();
map[34, 92] = new WaterTile();
map[34, 93] = new WaterTile();
map[34, 94] = new WaterTile();
map[34, 95] = new WaterTile();
map[34, 96] = new WaterTile();
map[34, 97] = new WaterTile();
map[34, 98] = new WaterTile();
map[35, 84] = new WaterTile();
map[35, 85] = new WaterTile();
map[35, 86] = new WaterTile();
map[35, 87] = new WaterTile();
map[35, 88] = new WaterTile();
map[35, 89] = new WaterTile();
map[35, 90] = new WaterTile();
map[35, 91] = new WaterTile();
map[35, 92] = new WaterTile();
map[35, 93] = new WaterTile();
map[35, 94] = new WaterTile();
map[35, 95] = new WaterTile();
map[35, 96] = new WaterTile();
map[35, 97] = new WaterTile();
map[35, 98] = new WaterTile();
map[36, 82] = new WaterTile();
map[37, 82] = new WaterTile();
map[38, 82] = new WaterTile();
map[39, 82] = new WaterTile();
map[40, 82] = new WaterTile();
map[41, 82] = new WaterTile();
map[42, 82] = new WaterTile();
map[43, 82] = new WaterTile();
map[44, 82] = new WaterTile();
map[45, 82] = new WaterTile();
map[46, 82] = new WaterTile();
map[47, 82] = new WaterTile();
map[48, 82] = new WaterTile();
map[37, 83] = new WaterTile();
map[38, 83] = new WaterTile();
map[39, 83] = new WaterTile();
map[40, 83] = new WaterTile();
map[41, 83] = new WaterTile();
map[42, 83] = new WaterTile();
map[43, 83] = new WaterTile();
map[44, 83] = new WaterTile();
map[45, 83] = new WaterTile();
map[46, 83] = new WaterTile();
map[47, 83] = new WaterTile();
map[48, 83] = new WaterTile();
for (int row = 4; row < 8; row++)
{
for (int column = 84; column < 94; column++)
{
map[row, column] = new WaterTile();
}
}
//Forest
map[28, 4] = new TreeTile();
map[30, 4] = new TreeTile();
map[32, 4] = new TreeTile();
map[33, 4] = new TreeTile();
map[34, 4] = new TreeTile();
map[35, 4] = new TreeTile();
map[36, 4] = new TreeTile();
map[37, 4] = new TreeTile();
map[38, 4] = new TreeTile();
map[39, 4] = new TreeTile();
map[41, 4] = new TreeTile();
map[42, 4] = new TreeTile();
map[43, 4] = new TreeTile();
map[44, 4] = new TreeTile();
map[46, 4] = new TreeTile();
map[47, 4] = new TreeTile();
map[28, 5] = new TreeTile();
map[30, 5] = new TreeTile();
map[39, 5] = new TreeTile();
map[41, 5] = new TreeTile();
map[47, 5] = new TreeTile();
map[28, 6] = new TreeTile();
map[30, 6] = new TreeTile();
map[32, 6] = new TreeTile();
map[33, 6] = new TreeTile();
map[35, 6] = new TreeTile();
map[36, 6] = new TreeTile();
map[37, 6] = new TreeTile();
map[39, 6] = new TreeTile();
map[41, 6] = new TreeTile();
map[43, 6] = new TreeTile();
map[44, 6] = new TreeTile();
map[46, 6] = new TreeTile();
map[47, 6] = new TreeTile();
map[28, 7] = new TreeTile();
map[30, 7] = new TreeTile();
map[33, 7] = new TreeTile();
map[35, 7] = new TreeTile();
map[36, 7] = new TreeTile();
map[37, 7] = new TreeTile();
map[43, 7] = new TreeTile();
map[44, 7] = new TreeTile();
map[46, 7] = new TreeTile();
map[47, 7] = new TreeTile();
map[28, 8] = new TreeTile();
map[30, 8] = new TreeTile();
map[33, 8] = new TreeTile();
map[35, 8] = new TreeTile();
map[37, 8] = new TreeTile();
map[39, 8] = new TreeTile();
map[40, 8] = new TreeTile();
map[41, 8] = new TreeTile();
map[42, 8] = new TreeTile();
map[43, 8] = new TreeTile();
map[44, 8] = new TreeTile();
map[46, 8] = new TreeTile();
map[47, 8] = new TreeTile();
map[25, 9] = new TreeTile();
map[26, 9] = new TreeTile();
map[27, 9] = new TreeTile();
map[28, 9] = new TreeTile();
map[30, 9] = new TreeTile();
map[31, 9] = new TreeTile();
map[33, 9] = new TreeTile();
map[35, 9] = new TreeTile();
map[47, 9] = new TreeTile();
map[33, 10] = new TreeTile();
map[35, 10] = new TreeTile();
map[36, 10] = new TreeTile();
map[37, 10] = new TreeTile();
map[38, 10] = new TreeTile();
map[39, 10] = new TreeTile();
map[40, 10] = new TreeTile();
map[42, 10] = new TreeTile();
map[43, 10] = new TreeTile();
map[44, 10] = new TreeTile();
map[25, 11] = new TreeTile();
map[26, 11] = new TreeTile();
map[27, 11] = new TreeTile();
map[28, 11] = new TreeTile();
map[31, 11] = new TreeTile();
map[33, 11] = new TreeTile();
map[38, 11] = new TreeTile();
map[39, 11] = new TreeTile();
map[40, 11] = new TreeTile();
map[42, 11] = new TreeTile();
map[43, 11] = new TreeTile();
map[44, 11] = new TreeTile();
map[45, 11] = new TreeTile();
map[46, 11] = new TreeTile();
map[47, 11] = new TreeTile();
map[28, 12] = new TreeTile();
map[31, 12] = new TreeTile();
map[34, 12] = new TreeTile();
map[35, 12] = new TreeTile();
map[39, 12] = new TreeTile();
map[40, 12] = new TreeTile();
map[28, 13] = new TreeTile();
map[31, 13] = new TreeTile();
map[35, 13] = new TreeTile();
map[36, 13] = new TreeTile();
map[40, 13] = new TreeTile();
map[43, 13] = new TreeTile();
map[44, 13] = new TreeTile();
map[46, 13] = new TreeTile();
map[47, 13] = new TreeTile();
map[28, 14] = new TreeTile();
map[31, 14] = new TreeTile();
map[32, 14] = new TreeTile();
map[33, 14] = new TreeTile();
map[36, 14] = new TreeTile();
map[37, 14] = new TreeTile();
map[42, 14] = new TreeTile();
map[43, 14] = new TreeTile();
map[44, 14] = new TreeTile();
map[46, 14] = new TreeTile();
map[47, 14] = new TreeTile();
map[28, 15] = new TreeTile();
map[32, 15] = new TreeTile();
map[33, 15] = new TreeTile();
map[37, 15] = new TreeTile();
map[38, 15] = new TreeTile();
map[39, 15] = new TreeTile();
map[40, 15] = new TreeTile();
map[42, 15] = new TreeTile();
map[43, 15] = new TreeTile();
map[46, 15] = new TreeTile();
map[47, 15] = new TreeTile();
map[28, 16] = new TreeTile();
map[32, 16] = new TreeTile();
map[33, 16] = new TreeTile();
map[34, 16] = new TreeTile();
map[28, 17] = new TreeTile();
map[33, 17] = new TreeTile();
map[34, 17] = new TreeTile();
map[37, 17] = new TreeTile();
map[38, 17] = new TreeTile();
map[39, 17] = new TreeTile();
map[40, 17] = new TreeTile();
map[41, 17] = new TreeTile();
map[42, 17] = new TreeTile();
map[43, 17] = new TreeTile();
map[44, 17] = new TreeTile();
map[45, 17] = new TreeTile();
map[46, 17] = new TreeTile();
map[47, 17] = new TreeTile();
map[28, 18] = new TreeTile();
map[29, 18] = new TreeTile();
map[30, 18] = new TreeTile();
map[30, 19] = new TreeTile();
map[34, 19] = new TreeTile();
map[35, 19] = new TreeTile();
map[36, 19] = new TreeTile();
map[37, 19] = new TreeTile();
map[38, 19] = new TreeTile();
map[41, 19] = new TreeTile();
map[42, 19] = new TreeTile();
map[43, 19] = new TreeTile();
map[45, 19] = new TreeTile();
map[46, 19] = new TreeTile();
map[47, 19] = new TreeTile();
map[30, 20] = new TreeTile();
map[35, 20] = new TreeTile();
map[36, 20] = new TreeTile();
map[37, 20] = new TreeTile();
map[38, 20] = new TreeTile();
map[42, 20] = new TreeTile();
map[43, 20] = new TreeTile();
map[45, 20] = new TreeTile();
map[46, 20] = new TreeTile();
map[47, 20] = new TreeTile();
map[30, 21] = new TreeTile();
map[36, 21] = new TreeTile();
map[37, 21] = new TreeTile();
map[38, 21] = new TreeTile();
map[39, 21] = new TreeTile();
map[42, 21] = new TreeTile();
map[43, 21] = new TreeTile();
map[45, 21] = new TreeTile();
map[46, 21] = new TreeTile();
map[47, 21] = new TreeTile();
map[30, 22] = new TreeTile();
map[31, 22] = new TreeTile();
map[32, 22] = new TreeTile();
map[33, 22] = new TreeTile();
map[33, 23] = new TreeTile();
map[34, 23] = new TreeTile();
map[35, 23] = new TreeTile();
map[36, 23] = new TreeTile();
map[37, 23] = new TreeTile();
map[38, 23] = new TreeTile();
map[41, 23] = new TreeTile();
map[42, 23] = new TreeTile();
map[43, 23] = new TreeTile();
map[44, 23] = new TreeTile();
map[45, 23] = new TreeTile();
map[46, 23] = new TreeTile();
map[47, 23] = new TreeTile();
map[43, 24] = new TreeTile();
map[44, 24] = new TreeTile();
map[45, 24] = new TreeTile();
map[46, 24] = new TreeTile();
map[47, 24] = new TreeTile();
// House
map[27, 78] = new HouseTile();
map[27, 79] = new HouseTile();
map[27, 80] = new HouseTile();
map[28, 78] = new HouseTile();
map[28, 79] = new PlainTile();
map[28, 80] = new HouseTile();
map[28, 81] = new TreeTile();
//Road
map[16, 33] = new DirtTile();
map[17, 33] = new DirtTile();
map[16, 34] = new DirtTile();
map[17, 34] = new DirtTile();
map[15, 34] = new DirtTile();
map[14, 35] = new DirtTile();
map[15, 35] = new DirtTile();
map[16, 35] = new DirtTile();
map[13, 36] = new DirtTile();
map[14, 36] = new DirtTile();
map[15, 36] = new DirtTile();
map[13, 37] = new DirtTile();
map[14, 37] = new DirtTile();
map[13, 38] = new DirtTile();
map[14, 38] = new DirtTile();
map[13, 39] = new DirtTile();
map[14, 39] = new DirtTile();
map[13, 40] = new DirtTile();
map[14, 40] = new DirtTile();
map[13, 41] = new DirtTile();
map[14, 41] = new DirtTile();
map[13, 42] = new DirtTile();
map[14, 42] = new DirtTile();
map[13, 43] = new DirtTile();
map[14, 43] = new DirtTile();
map[13, 44] = new DirtTile();
map[14, 44] = new DirtTile();
map[13, 45] = new DirtTile();
map[14, 45] = new DirtTile();
map[13, 46] = new DirtTile();
map[14, 46] = new DirtTile();
map[13, 47] = new DirtTile();
map[14, 47] = new DirtTile();
map[15, 47] = new DirtTile();
map[14, 48] = new DirtTile();
map[15, 48] = new DirtTile();
map[16, 48] = new DirtTile();
map[15, 49] = new DirtTile();
map[16, 49] = new DirtTile();
map[17, 49] = new DirtTile();
map[18, 49] = new DirtTile();
map[19, 49] = new DirtTile();
map[16, 50] = new DirtTile();
map[17, 50] = new DirtTile();
map[18, 50] = new DirtTile();
map[19, 50] = new DirtTile();
map[20, 50] = new DirtTile();
map[19, 51] = new DirtTile();
map[20, 51] = new DirtTile();
map[21, 51] = new DirtTile();
map[20, 52] = new DirtTile();
map[21, 52] = new DirtTile();
map[20, 53] = new DirtTile();
map[21, 53] = new DirtTile();
map[20, 54] = new DirtTile();
map[21, 54] = new DirtTile();
map[20, 55] = new DirtTile();
map[21, 55] = new DirtTile();
map[20, 56] = new DirtTile();
map[21, 56] = new DirtTile();
map[20, 57] = new DirtTile();
map[21, 57] = new DirtTile();
map[20, 58] = new DirtTile();
map[21, 58] = new DirtTile();
map[20, 59] = new DirtTile();
map[21, 59] = new DirtTile();
map[20, 60] = new DirtTile();
map[21, 60] = new DirtTile();
map[20, 61] = new DirtTile();
map[21, 61] = new DirtTile();
map[22, 61] = new DirtTile();
map[20, 62] = new DirtTile();
map[21, 62] = new DirtTile();
map[22, 62] = new DirtTile();
map[21, 63] = new DirtTile();
map[22, 63] = new DirtTile();
map[23, 63] = new DirtTile();
map[22, 64] = new DirtTile();
map[23, 64] = new DirtTile();
map[24, 64] = new DirtTile();
map[23, 65] = new DirtTile();
map[24, 65] = new DirtTile();
map[25, 65] = new DirtTile();
map[24, 66] = new DirtTile();
map[25, 66] = new DirtTile();
map[26, 66] = new DirtTile();
map[25, 67] = new DirtTile();
map[26, 67] = new DirtTile();
map[25, 68] = new DirtTile();
map[26, 68] = new DirtTile();
map[25, 69] = new DirtTile();
map[26, 69] = new DirtTile();
map[25, 70] = new DirtTile();
map[26, 70] = new DirtTile();
map[25, 71] = new DirtTile();
map[26, 71] = new DirtTile();
map[25, 72] = new DirtTile();
map[26, 72] = new DirtTile();
map[25, 73] = new DirtTile();
map[26, 73] = new DirtTile();
map[25, 74] = new DirtTile();
map[26, 74] = new DirtTile();
map[25, 75] = new DirtTile();
map[26, 75] = new DirtTile();
map[25, 76] = new DirtTile();
map[26, 76] = new DirtTile();
map[25, 77] = new DirtTile();
map[26, 77] = new DirtTile();
map[25, 78] = new DirtTile();
map[26, 78] = new DirtTile();
map[25, 79] = new DirtTile();
map[26, 79] = new DirtTile();
map[25, 80] = new DirtTile();
map[26, 80] = new DirtTile();
map[25, 81] = new DirtTile();
map[26, 81] = new DirtTile();
map[25, 82] = new DirtTile();
map[26, 82] = new DirtTile();
map[25, 83] = new DirtTile();
map[26, 83] = new DirtTile();
map[25, 84] = new DirtTile();
map[26, 84] = new DirtTile();
map[25, 85] = new DirtTile();
map[26, 85] = new DirtTile();
map[26, 86] = new DirtTile();
map[25, 86] = new DirtTile();
map[25, 87] = new DirtTile();
map[26, 87] = new DirtTile();
map[25, 88] = new DirtTile();
map[26, 88] = new DirtTile();
map[25, 89] = new DirtTile();
map[26, 89] = new DirtTile();
map[25, 90] = new DirtTile();
map[26, 90] = new DirtTile();
map[25, 91] = new DirtTile();
map[26, 91] = new DirtTile();
map[27, 74] = new DirtTile();
map[27, 75] = new DirtTile();
map[27, 76] = new DirtTile();
map[28, 75] = new DirtTile();
map[28, 76] = new DirtTile();
map[28, 77] = new DirtTile();
map[29, 76] = new DirtTile();
map[29, 77] = new DirtTile();
map[29, 78] = new DirtTile();
map[30, 77] = new DirtTile();
map[30, 78] = new DirtTile();
map[30, 79] = new DirtTile();
map[31, 78] = new DirtTile();
map[31, 79] = new DirtTile();
map[31, 80] = new DirtTile();
map[32, 79] = new DirtTile();
map[32, 80] = new DirtTile();
map[32, 81] = new DirtTile();
map[33, 80] = new DirtTile();
map[33, 81] = new DirtTile();
map[33, 82] = new DirtTile();
map[34, 81] = new DirtTile();
map[34, 82] = new DirtTile();
map[34, 83] = new DirtTile();
map[35, 82] = new DirtTile();
map[35, 83] = new DirtTile();
map[35, 84] = new DirtTile();
map[36, 83] = new DirtTile();
map[36, 84] = new DirtTile();
map[36, 85] = new DirtTile();
map[37, 84] = new DirtTile();
map[37, 85] = new DirtTile();
map[37, 86] = new DirtTile();
map[37, 87] = new DirtTile();
map[37, 88] = new DirtTile();
map[37, 89] = new DirtTile();
map[37, 90] = new DirtTile();
map[37, 91] = new DirtTile();
map[37, 92] = new DirtTile();
map[37, 93] = new DirtTile();
map[37, 94] = new DirtTile();
map[37, 95] = new DirtTile();
map[37, 96] = new DirtTile();
map[37, 97] = new DirtTile();
map[37, 98] = new DirtTile();
map[38, 85] = new DirtTile();
map[38, 86] = new DirtTile();
map[38, 87] = new DirtTile();
map[38, 88] = new DirtTile();
map[38, 89] = new DirtTile();
map[38, 90] = new DirtTile();
map[38, 91] = new DirtTile();
map[38, 92] = new DirtTile();
map[38, 93] = new DirtTile();
map[38, 94] = new DirtTile();
map[38, 95] = new DirtTile();
map[38, 96] = new DirtTile();
map[38, 97] = new DirtTile();
map[38, 98] = new DirtTile();
map[38, 85] = new DirtTile();
map[39, 85] = new DirtTile();
map[40, 85] = new DirtTile();
map[41, 85] = new DirtTile();
map[42, 85] = new DirtTile();
map[43, 85] = new DirtTile();
map[44, 85] = new DirtTile();
map[45, 85] = new DirtTile();
map[46, 85] = new DirtTile();
map[47, 85] = new DirtTile();
map[48, 85] = new DirtTile();
map[38, 86] = new DirtTile();
map[39, 86] = new DirtTile();
map[40, 86] = new DirtTile();
map[41, 86] = new DirtTile();
map[42, 86] = new DirtTile();
map[43, 86] = new DirtTile();
map[44, 86] = new DirtTile();
map[45, 86] = new DirtTile();
map[46, 86] = new DirtTile();
map[47, 86] = new DirtTile();
map[48, 86] = new DirtTile();
map[38, 91] = new DirtTile();
map[38, 92] = new DirtTile();
map[38, 93] = new DirtTile();
map[39, 91] = new DirtTile();
map[39, 92] = new DirtTile();
map[39, 93] = new DirtTile();
}
private void Awake()
{
root = GetComponentInParent <GrassTile>();
mat = GetComponent <Renderer>().material;
}
private void Update()
{
updateTime -= Time.deltaTime;
if (updateTime >= 0)
{
return;
}
updateTime = 1;
if (followTarget == null)
{
return;
}
Vector3 targetPosition = transform.position;
if (followTarget)
{
targetPosition = followTarget.position;
}
Vector3 reletivePos = targetPosition - terrainPosition;
float xID = Mathf.CeilToInt(reletivePos.x / (float)chunkSize);
float zID = Mathf.CeilToInt(reletivePos.z / (float)chunkSize);
float xPos = (xID - 0.5f) * (float)chunkSize;
float zPos = (zID - 0.5f) * (float)chunkSize;
transform.position = new Vector3(xPos, transform.position.y, zPos) + terrainPosition;
if (prePos != transform.position)
{
prePos = transform.position;
for (int i = 0; i < transform.childCount; i++)
{
Transform child = transform.GetChild(i);
Vector3 pos = child.position;
pos -= terrainPosition;
float tileIDX = Mathf.FloorToInt(pos.x / (float)chunkSize);
float tileIDZ = Mathf.FloorToInt(pos.z / (float)chunkSize);
float scale = (float)chunkSize / terrinSize;
float xOffset = scale * tileIDX;
float yOffset = scale * tileIDZ;
//This is for Debug...........
#if UNITY_EDITOR
GrassTile tile = child.GetComponent <GrassTile>();
tile.scaleOffset.z = tile.scaleOffset.w = scale;
tile.scaleOffset.x = xOffset;
tile.scaleOffset.y = yOffset;
tile.tileID.x = tileIDX;
tile.tileID.y = tileIDZ;
#endif
//......................................
MeshRenderer mr = child.GetComponent <MeshRenderer>();
if (mr)
{
MaterialPropertyBlock.SetVector("_UVOffset", new Vector4(xOffset, yOffset, scale, scale));
mr.SetPropertyBlock(MaterialPropertyBlock);
}
}
}
}
//Main constructor, Makes a room based on a structure instance
public Room(Structure Structure)
{
this.Height = Structure.Height;
this.Width = Structure.Width;
this.TileArray = new Tile[Width, Height];
for (int x = 0; x < Width; x++)
{
for (int y = 0; y < Height; y++)
{
//Adds grass tiles with no block or actor.
TileArray[x, y] = new GrassTile(this, x, y);
}
}
//Goes through every TileSpawner in the structure
for (int x = 0; x < Structure.Width; x++)
{
for (int y = 0; y < Structure.Height; y++)
{
TileSpawner TileSpawner = Structure.TileSpawnerArray[x, y]; //TileSpawner at (x,y)
Tile NewTile = TileSpawner.SpawnTile(this, x, y, this.TileArray[x, y].WallDict); //Creates a new tile based on TileSpawner
//Create a new actor at the tile based on ActorSpawner
if (TileSpawner.ActorSpawner != null)
{
TileSpawner.ActorSpawner.SpawnActor(NewTile);
}
//Create a new block at the tile based on BlockSpawner
if (TileSpawner.BlockSpawner != null)
{
TileSpawner.BlockSpawner.SpawnBlock(NewTile);
}
//The WallSpawners to the left and bottom of the tile
WallSpawner LeftWallSpawner = TileSpawner.WallSpawnerDict[Vector2Int.left];
WallSpawner DownWallSpawner = TileSpawner.WallSpawnerDict[Vector2Int.down];
//Spawn a wall to the left based on LeftWallSpawner
if (LeftWallSpawner != null)
{
LeftWallSpawner.SpawnWall(NewTile, Vector2Int.left);
}
//Spawn a wall to the bottom based on DownWallSpawner
if (DownWallSpawner != null)
{
DownWallSpawner.SpawnWall(NewTile, Vector2Int.down);
}
//Walls on the top and right are only spawned on the border
//Otherwise walls would be initialized twice
if (x == Structure.Width - 1)
{
WallSpawner RightWallSpawner = TileSpawner.WallSpawnerDict[Vector2Int.right];
if (RightWallSpawner != null)
{
RightWallSpawner.SpawnWall(NewTile, Vector2Int.right);
}
}
if (y == Structure.Height - 1)
{
WallSpawner UpWallSpawner = TileSpawner.WallSpawnerDict[Vector2Int.up];
if (UpWallSpawner != null)
{
UpWallSpawner.SpawnWall(NewTile, Vector2Int.up);
}
}
}
}
}
public void setSelectedTile(GrassTile tile)
{
selectedTile = tile;
}
