public void unmarkToDelete(uint i, uint j)
{
WorldTerrain wt = WorldTerrain.GetInstance();
TileTerrainType type = wt.getTypeTerrainOfTile(i, j);
if (type == TileTerrainType.FREE && wt.tileContainsVegetation(i, j))
{
wt.getTileVegetation(i, j).unmarkToDelete();
_buildingPanel.GetComponent <MultipleBuildingPanel>().addUnits(-1, -WorldTerrain.PRICE_Clean);
}
else if (type == TileTerrainType.CANAL)
{
wt.canalUnmarkToDelete(i, j);
_buildingPanel.GetComponent <MultipleBuildingPanel>().addUnits(-1, -WorldTerrain.PRICE_Clean);
}
else if (type == TileTerrainType.RICE_TERRAIN)
{
wt.riceChunkUnmarkToDelete(i, j);
uintPair clickedPos = new uintPair(i, j);
foreach (Pair <uint, uint> pos in wt.getChunkTilesPositions(wt.getRiceTerrain(i, j).getChunkNumber()))
{
uintPair terrainPos = new uintPair(pos.First, pos.Second);
if (clickedPos != terrainPos)
{
tilesToDelete.Remove(terrainPos);
}
_buildingPanel.GetComponent <MultipleBuildingPanel>().addUnits(-1, -WorldTerrain.PRICE_Clean);
}
}
}
private void createInstFlamingo(uintPair position)
{
try {
uint row = position.First;
uint col = position.Second;
Debug.Log(" instantiating Flamingo at " + row + " " + col);
GameObject flamingoGameObject = Resources.Load <GameObject>(getRandomFlamingoPath());
WorldTerrain wt = WorldTerrain.GetInstance();
Vector3 worldPosition = wt.getTileWorldPosition(row, col);
float map_top = wt.getTileWorldPositionY(wt.getNumTilesY() - 1, 0);
float map_h = wt.getTileWorldPositionY(0, wt.getNumTilesX() - 1) - wt.getTileWorldPositionY(wt.getNumTilesY() - 1, 0);
Vector3 flamingoSize = flamingoGameObject.GetComponent <SpriteRenderer> ().bounds.size;
//worldPosition.x += WorldTerrain.TILE_WIDTH_UNITS/2 - flamingoSize.x / 2;
worldPosition.y += flamingoSize.y * 0.3f;
worldPosition.z = WorldTerrain.BUILDING_Z_LAYER - (map_top - (worldPosition.y)) / map_h;
instancesFlamingos[position] = GameObject.Instantiate(flamingoGameObject, worldPosition, Quaternion.identity);
}
catch (Exception e) {
Debug.LogError("Error trying to instantiate flamingo");
Debug.LogError(e.ToString());
}
}
public void deleteVegetation(uint i, uint j)
{
Debug.Assert(tileContainsVegetation(i, j));
uintPair matrixPos = new uintPair(i, j);
vegetation [matrixPos].delete();
vegetation.Remove(matrixPos);
}
private List <uintPair> getFlamingoPositions()
{
WorldTerrain wt = WorldTerrain.GetInstance();
List <uintPair> newFlamingoPositions = new List <uintPair> ();
while (newFlamingoPositions.Count < MAX_FLAMINGOS)
{
uintPair newPos = new uintPair((uint)UnityEngine.Random.Range(0, 3), (uint)UnityEngine.Random.Range(0, (int)wt.getNumTilesX()));
if (!wt.tileContainsVegetation(newPos.First, newPos.Second) && !newFlamingoPositions.Contains(newPos))
{
newFlamingoPositions.Add(newPos);
}
}
return(newFlamingoPositions);
}
public override bool Equals(object obj)
{
if ((object)obj == null)
{
return(false);
}
try {
uintPair uintPairObj = obj as uintPair;
if (uintPairObj != null)
{
return((First == uintPairObj.First) && (Second == uintPairObj.Second));
}
else
{
return(false);
}
}
catch (Exception ex) {
Debug.Log(ex.Message);
return(false);
}
}
public void updateCanals()
{
for (uint i = 0; i < _mapH; ++i)
{
for (uint j = 0; j < _mapW; ++j)
{
if (tileHasCanal(i, j))
{
CANAL_CONEXION conexion = calculateCanalConexion(i, j);
_canalsMatrix [i, j].setHasWater(false, false);
_canalsMatrix [i, j].setConexionType(conexion, true);
}
else if (tileHasCanalTmp(i, j))
{
CANAL_CONEXION conexion = calculateCanalConexion(i, j);
_canalsMatrixTmp [i, j].setHasWater(false, false);
_canalsMatrixTmp [i, j].setConexionType(conexion, true);
}
}
}
// Calculate Water
bool[,] visited = new bool[_mapH, _mapW];
Stack <uintPair> toVisit = new Stack <uintPair> (_waterSources);
//_riceChunkHasWater.Clear ();
List <int> riceChunkIDs = new List <int>(_riceChunkHasWater.Keys);
foreach (int key in riceChunkIDs)
{
_riceChunkHasWater [key] = false;
}
while (toVisit.Count > 0)
{
uintPair pos = toVisit.Pop();
if (visited [pos.First, pos.Second])
{
continue;
}
visited [pos.First, pos.Second] = true;
if (tileHasCanal(pos.First, pos.Second))
{
_canalsMatrix [pos.First, pos.Second].setHasWater(true, false);
}
else if (tileHasCanalTmp(pos.First, pos.Second))
{
_canalsMatrixTmp [pos.First, pos.Second].setHasWater(true, false);
}
else if (tileHasRice(pos.First, pos.Second))
{
int riceChunkID = _riceChunkMatrix [pos.First, pos.Second];
_riceChunkHasWater [riceChunkID] = true;
}
else
{
continue;
}
CANAL_CONEXION conexion = calculateCanalConexion(pos.First, pos.Second);
int[,] dirs_matrix = new int[4, 2] {
{ -1, 0 },
{ 0, -1 }, { 0, +1 },
{ +1, 0 }
};
for (int k = 0; k < 4; ++k)
{
int tile_i = (int)pos.First + dirs_matrix [k, 0];
int tile_j = (int)pos.Second + dirs_matrix [k, 1];
bool tile_outside = tile_i < 0 || tile_j < 0 || tile_i >= _mapH || tile_j >= _mapW;
if (!tile_outside && conexionMatrixs[conexion][1 + dirs_matrix [k, 0], 1 + dirs_matrix [k, 1]])
{
toVisit.Push(new uintPair((uint)tile_i, (uint)tile_j));
}
}
}
for (uint i = 0; i < _mapH; ++i)
{
for (uint j = 0; j < _mapW; ++j)
{
if (tileHasCanal(i, j))
{
_canalsMatrix [i, j].updateRepresentation();
}
else if (tileHasCanalTmp(i, j))
{
_canalsMatrixTmp [i, j].updateRepresentation();
}
}
}
}
private void initWorldData()
{
TextAsset file = Resources.Load("TiledMap/map.json", typeof(TextAsset)) as TextAsset;
Debug.Assert(file != null);
JSONNode node = JSON.Parse(file.text);
numTilesX = (uint)node ["width"].AsInt;
numTilesY = (uint)node ["height"].AsInt;
Debug.Log("MapW: " + numTilesX);
Debug.Log("MapH: " + numTilesY);
Debug.Log("Map Sice: " + numTilesX + " W, " + numTilesY + " H");
worldTerrainType = new TileTerrainType[numTilesY, numTilesX];
worldTerrainID = new TileTerrainIDs[numTilesY, numTilesX];
worldTerrainRepresentation = new GameObject[numTilesY, numTilesX];
riceTerrains = new RiceTerrainTile[numTilesY, numTilesX];
chunkTilesPos = new Dictionary <int, List <Pair <uint, uint> > >();
vegetation = new Dictionary <uintPair, Vegetation> ();
canalManager = new CanalManager(numTilesX, numTilesY);
_weedFactory = new WeedFactory(this, RICE_CHUNK_W * RICE_CHUNK_H);
chunkNextID = 0;
// TERRAIN
for (uint k = 0; k < numTilesX * numTilesY; ++k)
{
uint i = k / numTilesX;
uint j = k % numTilesX;
//Debug.Log("Data["+i+","+j+"]="+node ["layers"] [0] ["data"] [k]);
TileTerrainIDs v = (TileTerrainIDs)node ["layers"] [0] ["data"] [(int)k].AsInt;
worldTerrainID [i, j] = v;
worldTerrainType [i, j] = (v == TileTerrainIDs.HERBS) ? TileTerrainType.FREE : TileTerrainType.DECORATION;
}
// VEGETATION
for (uint k = 0; k < numTilesX * numTilesY; ++k)
{
uint i = k / numTilesX;
uint j = k % numTilesX;
//Debug.Log("Data["+i+","+j+"]="+node ["layers"] [0] ["data"] [k]);
int v = node ["layers"] [1] ["data"] [(int)k].AsInt;
if (v != 0)
{
uintPair matrixPos = new uintPair(i, j);
vegetation [matrixPos] = new Vegetation(i, j, (VegID)v);
}
}
// CANALS
for (uint k = 0; k < numTilesX * numTilesY; ++k)
{
uint i = k / numTilesX;
uint j = k % numTilesX;
//Debug.Log("Data["+i+","+j+"]="+node ["layers"] [0] ["data"] [k]);
int v = node ["layers"] [2] ["data"] [(int)k].AsInt;
if ((TileOthersIDs)v == TileOthersIDs.CANAL)
{
addCanal(i, j);
}
else if ((TileOthersIDs)v == TileOthersIDs.WATER_SOURCE)
{
addCanal(i, j);
canalManager.addWaterSource(3, 6);
}
}
canalManager.updateCanals();
//RICE CHUNKS
for (uint k = 0; k < numTilesX * numTilesY; ++k)
{
uint i = k / numTilesX;
uint j = k % numTilesX;
//Debug.Log("Data["+i+","+j+"]="+node ["layers"] [0] ["data"] [k]);
int v = node ["layers"] [2] ["data"] [(int)k].AsInt;
if ((TileOthersIDs)v == TileOthersIDs.RICE_CHUNK)
{
createRiceChunk(i, j, true);
}
}
canalManager.updateCanals();
}
private void deleteInstFlamingo(uintPair position)
{
Debug.Log(" deleting Flamingo at " + position.First + " " + position.Second);
GameObject.Destroy(instancesFlamingos [position]);
instancesFlamingos.Remove(position);
}
