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);
}
}
}
public void GenerateTerrain_WithHexMapWithUnchangeable_CreatesTerrainMap(TileTerrainType tileTerrainType)
{
var heightMapGeneratorMock = new Mock <IHeightMapGenerator>();
var provinceMock = new Mock <IProvince>();
provinceMock.Setup(p => p.IsWater).Returns(tileTerrainType == TileTerrainType.Water);
var hexMap = HexMapBuilder.New
.WithHeight(10)
.WithWidth(10)
.WithTiles(
TileBuilder.New
.WithType(tileTerrainType)
.WithProvince(provinceMock.Object)
).Build();
var terrainGenerator = new TerrainGenerator(heightMapGeneratorMock.Object);
terrainGenerator.DesertBelt = 1;
terrainGenerator.PoleBelt = 1;
terrainGenerator.GenerateTerrain(hexMap);
Assert.IsTrue(hexMap.All(t => t.TileTerrainType == tileTerrainType), $"The map does not only consist of {tileTerrainType}");
}
public void SetTerrainOnTile(TileTerrain terrain)
{
terrainOnTile = terrain;
if (terrain == null)
{
tileTerrainType = TileTerrainType.floor;
}
else if (terrain is Stairs)
{
Stairs s = terrain as Stairs;
if (s.IsUp)
{
tileTerrainType = TileTerrainType.stairsUp;
}
else
{
tileTerrainType = TileTerrainType.stairsDown;
}
}
else if (terrain is Trap)
{
tileTerrainType = TileTerrainType.trap;
}
}
internal void Initialize(IMapReadable map, UnwrappedTileId tileId, float scale, int zoom, Texture2D loadingTexture = null)
{
ElevationType = TileTerrainType.None;
TileScale = scale;
_relativeScale = 1 / Mathf.Cos(Mathf.Deg2Rad * (float)map.CenterLatitudeLongitude.x);
Rect = Conversions.TileBounds(tileId);
UnwrappedTileId = tileId;
CanonicalTileId = tileId.Canonical;
_loadingTexture = loadingTexture;
float scaleFactor = 1.0f;
if (_isInitialized == false)
{
_isInitialized = true;
InitialZoom = zoom;
}
CurrentZoom = zoom;
scaleFactor = Mathf.Pow(2, (map.InitialZoom - zoom));
gameObject.transform.localScale = new Vector3(scaleFactor, scaleFactor, scaleFactor);
gameObject.SetActive(true);
IsRecycled = false;
//MeshRenderer.enabled = true;
// Setup Loading as initial state - Unregistered
// When tile registers with factories, it will set the appropriate state.
// None, if Factory source is None, Loading otherwise.
}
public bool markToDelete(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).markToDelete();
_buildingPanel.GetComponent <MultipleBuildingPanel>().addUnits(+1, +WorldTerrain.PRICE_Clean);
return(true);
}
/*
* if (type == TileTerrainType.CANAL) {
* wt.canalMarkToDelete(i, j);
* _buildingPanel.GetComponent<MultipleBuildingPanel>().addUnits (+1, +WorldTerrain.PRICE_Clean);
* return true;
* }
* if (type == TileTerrainType.RICE_TERRAIN) {
* wt.riceChunkMarkToDelete(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.Add (terrainPos);
* _buildingPanel.GetComponent<MultipleBuildingPanel>().addUnits (+1, +WorldTerrain.PRICE_Clean);
*
* }
* return true;
* }
*/
return(false);
}
// +++ BUILDING +++
public void startBuilding(TileTerrainType terrainID, BUILDINGS buildingId = 0)
{
BUILDING_INFO.terrainID = terrainID;
BUILDING_INFO.buildingID = buildingId;
if (BUILDING_INFO.terrainID == TileTerrainType.BUILDING)
{
//setBuildingBuildingRepresentation ();
//createSingleBuildingPanel ();
createSingleBuildingFirstPanel();
}
else if (BUILDING_INFO.terrainID == TileTerrainType.RICE_TERRAIN)
{
//setBuildingRiceChunkRepresentation ();
//createSingleBuildingPanel ();
createSingleBuildingFirstPanel();
}
else if (BUILDING_INFO.terrainID == TileTerrainType.CANAL)
{
createMultipleBuildingPanel();
}
if (_actionPanel != null)
{
_actionPanel.SendMessage("kill");
}
logicState = LOGIC_STATE.BUILDING;
}
public bool isEmptyForRiceChunk(uint row, uint col)
{
for (uint i = row - RICE_CHUNK_SEPARATION; i < row + RICE_CHUNK_H + RICE_CHUNK_SEPARATION; ++i)
{
for (uint j = col - RICE_CHUNK_SEPARATION; j < col + RICE_CHUNK_W + RICE_CHUNK_SEPARATION; ++j)
{
TileTerrainType terrainType = worldTerrainType [row + i, col + j];
if (i < row || i >= row + RICE_CHUNK_H ||
j < col || j >= col + RICE_CHUNK_W)
{
if (!(terrainType == TileTerrainType.FREE || terrainType == TileTerrainType.SEPARATOR || terrainType == TileTerrainType.CANAL))
{
return(false);
}
}
else
{
if (!(terrainType == TileTerrainType.SEPARATOR || terrainType == TileTerrainType.CANAL))
{
return(false);
}
}
}
}
return(true);
}
private void updateTileRepresentation(uint i, uint j)
{
if (worldTerrainRepresentation[i, j] != null)
{
GameObject.Destroy(worldTerrainRepresentation[i, j]);
}
TileTerrainType tileType = worldTerrainType[i, j];
if (tileType == TileTerrainType.FREE || tileType == TileTerrainType.DECORATION ||
tileType == TileTerrainType.BUILDING)
{
float worldPositionX = getTileWorldPositionX(i, j);
float worldPositionY = getTileWorldPositionY(i, j);
Vector3 worldPosition = new Vector3(worldPositionX, worldPositionY, TERRAIN_Z_LAYER);
//Debug.Assert(resources.ContainsKey(tileType));
worldTerrainRepresentation [i, j] = (GameObject)GameObject.Instantiate(resources [worldTerrainID [i, j]], worldPosition, Quaternion.identity);
}
else if (tileType == TileTerrainType.SEPARATOR)
{
float worldPositionX = getTileWorldPositionX(i, j);
float worldPositionY = getTileWorldPositionY(i, j);
Vector3 worldPosition = new Vector3(worldPositionX, worldPositionY, TERRAIN_Z_LAYER);
worldTerrainRepresentation [i, j] = (GameObject)GameObject.Instantiate(resources [TileTerrainIDs.SEPARATOR], worldPosition, Quaternion.identity);
}
}
private int GetResourceCapacity(TileTerrainType terrainType)
{
if (terrainType == TileTerrainType.Hills || terrainType == TileTerrainType.Mountains)
{
return(2);
}
return(1);
}
private GameObject CreateTile(TileTerrainType type, Vector3 position, int x, int y)
{
var hexTile = Instantiate(HexTile, position, MapStartPoint.transform.rotation);
var tile = hexTile.GetComponent <Tile>();
tile.TileTerrainType = type;
tile.Position.X = x;
tile.Position.Y = y;
_map.AddTile(x, y, tile);
return(hexTile);
}
public IEnumerable <TileBase> GetTilesOfTerrainType(TileTerrainType terrainType)
{
for (var i = 0; i < _map.GetLength(0); i++)
{
for (var j = 0; j < _map.GetLength(1); j++)
{
var tile = _map[i, j];
if (tile.TileTerrainType == terrainType)
{
yield return(tile);
}
}
}
}
public void unselectTile(uint i, uint j)
{
TileTerrainType tileType = getTypeTerrainOfTile(i, j);
if (tileType == TileTerrainType.RICE_TERRAIN)
{
RiceTerrainTile tile = getRiceTerrain(i, j);
unselectChunk(tile.getChunkNumber());
//tile.unselect ();
}
else if (tileType == TileTerrainType.BUILDING)
{
BuildingsManager.GetInstance().unselectBuildingAt(i, j);
}
}
public bool isEmpty(uint row, uint col, uint height, uint width)
{
for (int i = 0; i < height; ++i)
{
for (int j = 0; j < width; ++j)
{
TileTerrainType terrainType = worldTerrainType [row + i, col + j];
if (terrainType != TileTerrainType.FREE)
{
return(false);
}
}
}
return(true);
}
// +++ ACTIONS +++
private void createActionPanel()
{
if (_actionPanel != null)
{
Destroy(_actionPanel);
}
WorldTerrain terrain = WorldTerrain.GetInstance();
TileTerrainType typeOfTileSelected = terrain.getTypeTerrainOfTile(_tileSelectedPosition[0], _tileSelectedPosition[1]);
if (typeOfTileSelected == TileTerrainType.BUILDING && BuildingsManager.GetInstance().getTypeOfBuildingInPosition(_tileSelectedPosition[0], _tileSelectedPosition[1]) == BUILDINGS.PLANTER)
{
_tutMan.eventDone(TutorialManager.EVENTS.PLANTELL_ACTIONS_OPENED);
}
if (typeOfTileSelected == TileTerrainType.RICE_TERRAIN)
{
RiceTerrainTile riceTerrain = terrain.getRiceTerrain(_tileSelectedPosition [0], _tileSelectedPosition [1]);
//int chunk = terrain.getRiceTerrain(_tileSelectedPosition[0], _tileSelectedPosition[1]).getChunkNumber();
//if (!PenalizationManager.GetInstance().isChunkDisabled(chunk)) {
if (!riceTerrain.isDisabled())
{
GameObject actionPanelTemplate = Resources.Load("Prefabs/ActionPanelLostFocusLayer") as GameObject;
_actionPanel = Instantiate(actionPanelTemplate);
_actionPanel.SendMessage("setRiceTerrain", riceTerrain);
_tutMan.eventDone(TutorialManager.EVENTS.RICE_CHUNK_ACTIONS_OPENED);
}
else
{
GameObject disabledPanel = Resources.Load("Prefabs/DisabledChunkPanelLostFocusLayer") as GameObject;
Instantiate(disabledPanel);
return;
}
}
else if (typeOfTileSelected == TileTerrainType.BUILDING)
{
GameObject actionPanelTemplate = Resources.Load("Prefabs/ActionBuildingPanelLostFocusLayer") as GameObject; // OR Planta
_actionPanel = Instantiate(actionPanelTemplate);
BUILDINGS b = BuildingsManager.GetInstance().getTypeOfBuildingInPosition(_tileSelectedPosition[0], _tileSelectedPosition[1]);
_actionPanel.BroadcastMessage("setActionsForBuilding", b);
}
}
public bool tileCloseTo(uint i, uint j, TileTerrainType type)
{
for (int dir_i = -1; dir_i <= 1; ++dir_i)
{
for (int dir_j = -1; dir_j <= 1; ++dir_j)
{
int tile_i = (int)i + dir_i;
int tile_j = (int)j + dir_j;
if (!tilePosInside(tile_i, tile_j))
{
continue;
}
if (getTypeTerrainOfTile((uint)tile_i, (uint)tile_j) == type)
{
return(true);
}
}
}
return(false);
}
public void deletingConfirm()
{
foreach (uintPair pos in tilesToDelete)
{
uint i = pos.First;
uint j = pos.Second;
WorldTerrain wt = WorldTerrain.GetInstance();
TileTerrainType type = wt.getTypeTerrainOfTile(i, j);
if (type == TileTerrainType.FREE && wt.tileContainsVegetation(i, j))
{
wt.deleteVegetation(i, j);
}
else if (type == TileTerrainType.CANAL)
{
wt.deleteCanal(i, j);
}
else if (type == TileTerrainType.RICE_TERRAIN)
{
wt.deleteRiceChunk(i, j);
}
}
UserDataManager.GetInstance().gold.espendGold(_buildingPanel.GetComponent <MultipleBuildingPanel> ().getCost());
logicState = LOGIC_STATE.DEFAULT;
}
public void clickOn(float x, float y)
{
WorldTerrain worldTerrain = WorldTerrain.GetInstance();
uint i = (uint)worldTerrain.getMatrixRow(x, y);
uint j = (uint)worldTerrain.getMatrixCol(x, y);
if (logicState == LOGIC_STATE.DEFAULT)
{
//TileTerrainType terrainType = worldTerrain.getTypeTerrainOfTile (i, j);
selectTile(new uint[2] {
i, j
});
}
else if (logicState == LOGIC_STATE.BUILDING)
{
selectTile(new uint[2] {
i, j
});
if (BUILDING_INFO.terrainID == TileTerrainType.BUILDING)
{
setBuildingBuildingRepresentation();
}
else if (BUILDING_INFO.terrainID == TileTerrainType.RICE_TERRAIN)
{
setBuildingRiceChunkRepresentation();
}
else if (BUILDING_INFO.terrainID == TileTerrainType.CANAL)
{
WorldTerrain wt = WorldTerrain.GetInstance();
TileTerrainType tileType = wt.getTypeTerrainOfTile(i, j);
if ((tileType == TileTerrainType.FREE || tileType == TileTerrainType.SEPARATOR) && !wt.tileContainsVegetation(i, j))
{
if (!wt.canalManager.tileHasCanalTmp(i, j))
{
_buildingPanel.GetComponent <MultipleBuildingPanel>().addUnits(+1, +WorldTerrain.PRICE_Canal);
}
else
{
_buildingPanel.GetComponent <MultipleBuildingPanel>().addUnits(-1, -WorldTerrain.PRICE_Canal);
}
wt.addRmvCanalTmp(i, j);
}
}
}
else if (logicState == LOGIC_STATE.DELETING)
{
selectTile(new uint[2] {
i, j
}, false);
if (tilesToDelete.Contains(new uintPair(i, j)))
{
unmarkToDelete(i, j);
tilesToDelete.Remove(new uintPair(i, j));
foreach (uintPair pos in tilesToDelete)
{
Debug.Log(pos);
}
}
else
{
if (markToDelete(i, j))
{
tilesToDelete.Add(new uintPair(i, j));
foreach (uintPair pos in tilesToDelete)
{
Debug.Log(pos);
}
}
}
}
}
private GameObject CreateTile(TileTerrainType type, Vector3 position, int x, int y)
{
var hexTile = TileFactory.Instance.CreateTile(Instantiate, HexTile, type, position, MapStartPoint.transform.rotation, x, y, _map);
return(hexTile);
}
public static HexGrid CreateMap(GameObject mapStartPoint, HexMap map, GameObject hexTile, TileTerrainType type = TileTerrainType.Plain)
{
mapStartPoint.transform.position = new Vector3(0, 0, 0);
mapStartPoint.transform.localScale = new Vector3(1, 1, 1);
var hexGrid = new HexGrid(map.Height, map.Width, hexTile);
var mapObject = new GameObject("Map");
for (var y = 0; y < hexGrid.Height; y++)
{
for (var x = 0; x < hexGrid.Width; x++)
{
var position = hexGrid.Get(x, y);
var tile = CreateTile(hexTile, mapStartPoint, map, type, position, x, y);
tile.transform.SetParent(mapObject.transform);
}
}
return(hexGrid);
}
private decimal GetTerrainRatio(ICollection <TileBase> map, TileTerrainType tileTerrainType) => map.Where(t => t.TileTerrainType == tileTerrainType).Count() / (decimal)map.Count();
public void SetTileTerrainType(TileTerrainType type)
{
tileTerrainType = type;
}
public TileBuilder WithType(TileTerrainType type)
{
_type = type;
return(this);
}
public TileTerrainTypeMap CreateMap(int width, int height)
{
if (MapGenerator == null)
{
return(null);
}
_equator = (int)Math.Round(height / 2m);
var map = MapGenerator.Generate(width, height);
var terrainMap = new TileTerrainTypeMap(width, height);
var gaussianBlur = new GaussianBlur();
int[,] blurredMap = map;
for (var i = 0; i < FilterCount; i++)
{
blurredMap = gaussianBlur.Filter(blurredMap);
}
var terrainTypes = new Dictionary <TileTerrainType, double>
{
{ TileTerrainType.Bosk, 0.1 },
{ TileTerrainType.Forest, 0.1 },
{ TileTerrainType.Marsh, 0.02 },
{ TileTerrainType.GrainField, 0.2 },
{ TileTerrainType.Orchard, 0.05 },
{ TileTerrainType.CattleMeadows, 0.05 },
{ TileTerrainType.CottonField, 0.05 },
{ TileTerrainType.SheepMeadows, 0.05 },
{ TileTerrainType.StudFarm, 0.01 }
};
var random = new System.Random();
for (var y = 0; y < height; y++)
{
for (var x = 0; x < width; x++)
{
var value = blurredMap[x, y];
// In the map border regions only use water
if (value == 0 || (x < 2 || y < 2 || y > height - 3 || x > width - 3))
{
terrainMap.Add(TileTerrainType.Water, x, y);
continue;
}
if (value >= MinHillsValue && value < MinMountainsValue)
{
terrainMap.Add(TileTerrainType.Hills, x, y);
continue;
}
if (value >= MinMountainsValue)
{
terrainMap.Add(TileTerrainType.Mountains, x, y);
continue;
}
if (IsWithinDesertBelt(y))
{
terrainMap.Add(TileTerrainType.Desert, x, y);
continue;
}
if (IsWithinPoleBelt(y, height))
{
terrainMap.Add(TileTerrainType.Tundra, x, y);
continue;
}
TileTerrainType plainTerrain = TileTerrainType.Plain;
// Generate busk, forest and agriculture tiles
foreach (var terrainType in terrainTypes.Keys)
{
var randomValue = random.NextDouble();
if (randomValue > terrainTypes[terrainType])
{
continue;
}
plainTerrain = terrainType;
break;
}
terrainMap.Add(plainTerrain, x, y);
}
}
return(terrainMap);
}
public void SetTileTerrainType(TileTerrainType type)
{
// tileCategory = TileMap.TileMapCategory.Terrain;
tileTerrainType = type;
}
private static GameObject CreateTile(GameObject tile, GameObject mapStartPoint, HexMap map, TileTerrainType type, Vector3 position, int x, int y)
{
var hexTile = TileFactory.Instance.CreateTile(UnityEngine.Object.Instantiate, tile, type, position, mapStartPoint.transform.rotation, x, y, map);
hexTile.GetComponent <Tile>().Setup();
return(hexTile);
}
public GameObject CreateTile(Func <GameObject, Vector3, Quaternion, GameObject> instantiate, GameObject tileObject, TileTerrainType type, Vector3 position, Quaternion rotation, int x, int y, IHexMap map)
{
var hexTile = instantiate(tileObject, position, rotation);
var tile = hexTile.GetComponent <Tile>();
tile.TileTerrainType = type;
tile.Position.X = x;
tile.Position.Y = y;
map.AddTile(x, y, tile);
return(hexTile);
}
private TileBuilder()
{
_type = TileTerrainType.Water;
_position = new Position(0, 0);
}
