public void RegisterPumpingStation(BaseTileData tile)
{
if (!_pumpingStationsTiles.Contains(tile))
{
_pumpingStationsTiles.Add(tile);
}
}
public void SwapNextTurnTiles(BaseTileData oldTile, BaseTileData newTile)
{
NTtiles.Remove(oldTile);
NTtiles.Add(newTile);
_modifiedNTTiles.Add(oldTile);
OnTilemapModified?.Invoke();
}
private void ManageClick()
{
// The second part of the condition prevents from interacting with the tilemap if we click on UI
if (Input.GetMouseButtonDown(0) && EventSystem.current.currentSelectedGameObject == null && !BlockingUI.IsBlocked)
{
BaseTileData tileClicked = GetTileAtMousePos();
if (tileClicked != null)
{
if (BuildingManager.Instance.IsInBuildMode)
{
BuildingManager.Instance.BuildCurrentStructure(HoveredTile);
}
else
{
tileClicked.terrainTile.DebugOnClick();
}
if (SelectedTile != null)
{
SelectedTile.SetIsSelected(false);
}
SelectedTile = tileClicked;
SelectedTile.SetIsSelected(true);
}
else
{
if (SelectedTile != null)
{
SelectedTile.SetIsSelected(false);
}
SelectedTile = null;
}
OnPlayerClick?.Invoke();
}
}
public override void DestroyStructure()
{
BaseTileData baseTileData = TilesDataManager.Instance.GetTileDataAtPos(GridPosition);
WaterClusterManager.Instance.UnregisterPumpingStation(baseTileData);
base.DestroyStructure();
}
private void PerformFill()
{
// start from the top
int h = BOARD_HEIGHT - 1;
for (int w = 0; w < BOARD_WIDTH; w++)
{
if (_board[w, h] == null)
{
// search downwards and count the number of tiles we need to fill
int hSearch = h;
while (hSearch >= 0)
{
Tile tile = _board[w, hSearch];
if (tile != null)
{
break;
}
hSearch--;
}
// once the bottom location is found, we need to iterate up to create the tiles
int offset = 1;
hSearch += 1; // we ended at a non null h, we need to move up one
while (hSearch < BOARD_HEIGHT)
{
BaseTileData tileData = PickRandomTileData();
Tile tileToDrop = CreateTileAtCoordsforDropping(tileData, w, hSearch, h + offset);
_droppingTiles.Add(tileToDrop);
offset++;
hSearch++;
}
}
}
}
public void AddTile(BaseTileData tile)
{
if (!tiles.Contains(tile) && tile.terrainTile is WaterTile)
{
tiles.Add(tile);
}
}
private Tile CreateTileAtCoords(BaseTileData data, int xCoords, int yCoords, bool tweensIn = false)
{
GameObject tileGO = GameObject.Instantiate(TilePrefab);
Tile tile = tileGO.GetComponent <Tile>();
tile.Initialize(data, xCoords, yCoords);
tileGO.transform.SetParent(TilesContainer);
tileGO.transform.position = CoordsToWorldPosition(xCoords, yCoords);
if (tweensIn)
{
tileGO.transform.localScale = Vector3.zero;
iTween.ScaleTo(tile.gameObject,
iTween.Hash("scale", Vector3.one,
"easetype", iTween.EaseType.easeOutBack,
"time", 0.5f
)
);
}
_board[xCoords, yCoords] = tile;
return(tile);
}
public BaseTileData RegisterRandomFloodableTile(WaterCluster cluster)
{
BaseTileData tile = GetRandomFloodableTile(cluster);
AddPossibleFloodTile(cluster, tile);
return(tile);
}
private void ManageHover()
{
if (!BlockingUI.IsBlocked)
{
BaseTileData tileHovered = GetTileAtMousePos();
StructureType currentBuildType = BuildingManager.Instance.CurrentBuildingStructure;
phantomBuildingSprite.sprite = BuildingManager.Instance.StructuresTemplates.GetSpriteForStructure(currentBuildType);
if (tileHovered != null)
{
HoveredTile = tileHovered;
hoveredTileSprite.transform.position = HoveredTile.worldPosition;
if (BuildingManager.Instance.IsInBuildMode)
{
bool canBuild = BuildingManager.Instance.CanBuildStructureAtPos(currentBuildType, tileHovered.GridPosition);
phantomBuildingSprite.transform.position = HoveredTile.worldPosition;
phantomBuildingSprite.color = canBuild ? _transpColor : _transpRedColor;
}
else
{
phantomBuildingSprite.color = _invisibleColor;
}
}
else
{
HoveredTile = null;
hoveredTileSprite.transform.position = _awayPos;
phantomBuildingSprite.color = _invisibleColor;
}
}
}
public static List <BaseTileData> GetNeighboursTilesOfRelay(BaseTileData baseTileData /*should be a relay tile */)
{
RelayTile relayTile = (RelayTile)(baseTileData.structureTile);
List <Vector3Int> list = GetNeighboursPositionsAtDistance(baseTileData.GridPosition, relayTile.GetActivationAreaRange());
List <BaseTileData> neighbour = TilesDataManager.Instance.GetTilesAtPos(list).ToList();
return(neighbour);
}
public BaseTileData(BaseTileData origin)
{
GridPosition = origin.GridPosition;
worldPosition = origin.worldPosition;
originTile = origin.originTile;
terrainTile = origin.terrainTile;
structureTile = origin.structureTile;
}
private void UpdateTilesDebugText()
{
foreach (Vector3Int pos in _tilemap.cellBounds.allPositionsWithin)
{
_debugTextsDico.TryGetValue(pos, out TextMeshProUGUI text);
BaseTileData data = _tileDataManager.GetTileDataAtPos(pos, true);
text.text = _isVisible ? data.terrainTile.GetDebugText() : "";
}
}
public void DestroyStructureAtPos(Vector3Int pos)
{
BaseTileData data = GetTileDataAtPos(pos);
StructureTile structure = data.structureTile;
if (structure != null && structure._building != null)
{
structure.DestroyStructure();
data.structureTile = null;
}
}
// Start is called before the first frame update
void Start()
{
_errorText.gameObject.SetActive(false);
_errorTextDico = new Dictionary<ActivationState, string>();
foreach (ErrorText errorText in _errors)
{
_errorTextDico.Add(errorText.state, errorText.errorText);
}
_previousTile = null;
MouseManager.OnPlayerClick += Refresh;
Refresh();
}
private void PredictNextTurn()
{
foreach (Vector3Int pos in TilesDataManager.Instance.GetTilemapBounds().allPositionsWithin)
{
if (TilesDataManager.Instance.HasTile(pos))
{
BaseTileData tile = TilesDataManager.Instance.GetTileDataAtPos(pos);
tile.PredictOnTurnStarts();
}
}
OnTurnPredict?.Invoke();
}
public StructureTile CreateStructureFromType(StructureType type, BaseTileData data)
{
StructureTile newTile = null;
StructureBinding structureBinding = BuildingManager.Instance.StructuresTemplates.GetStructureBindingFromType(type);
if (structureBinding != null)
{
switch (type)
{
case StructureType.PowerPlant:
newTile = new PowerPlantTile();
break;
case StructureType.Sawmill:
newTile = new SawmillTile();
break;
case StructureType.PumpingStation:
newTile = new PumpingStationTile();
WaterClusterManager.Instance.RegisterPumpingStation(data);
break;
case StructureType.Village:
newTile = new VillageTile();
break;
case StructureType.Mine:
newTile = new MineTile();
break;
case StructureType.Relay:
newTile = new RelayTile();
break;
case StructureType.MainRelay:
newTile = new MainRelayTile();
break;
default:
throw new MissingStructureTypeDefinitionException();
}
data.structureTile = newTile;
BuildingView building = Instantiate(structureBinding.building, data.worldPosition, Quaternion.identity, transform);
building.dataTile = newTile;
newTile._building = building;
newTile.GridPosition = data.GridPosition;
ResourcesManager.Instance.RegisterStructure(newTile);
RelayManager.Instance.RegisterStructure(data);
}
return(newTile);
}
public WaterCluster GetClusterForTile(BaseTileData tile)
{
WaterCluster res = null;
foreach (WaterCluster cluster in clusters)
{
if (cluster.tiles.Contains(tile))
{
res = cluster;
}
}
return(res);
}
public override void Execute()
{
_floodedTile = new BaseTileData(_originTile);
TilesDataManager.Instance.CreateTerrainFromType(TerrainType.Water, _floodedTile);
TilesDataManager.Instance.ChangeTerrainTileInTilemap(_floodedTile.GridPosition, TerrainType.Water, true);
_cluster.AddTile(_floodedTile);
_floodedStructure = _floodedTile.HandleFlood();
_originTile.HandleFloodPrevision();
_swapTilesCommand = new SwapTilesCommand(_originTile, _floodedTile);
_swapTilesCommand.Execute();
_removeFloodCommand = new WaterClusterRemoveFloodCommand(_cluster, WaterClusterManager.floodThreshold);
_removeFloodCommand.Execute();
}
private Tile CreateTileAtCoordsforDropping(BaseTileData data, int xCoords, int yCoords, int yCoordsFake)
{
GameObject tileGO = GameObject.Instantiate(TilePrefab);
Tile tile = tileGO.GetComponent <Tile>();
tile.Initialize(data, xCoords, yCoords);
tileGO.transform.SetParent(TilesContainer);
tileGO.transform.position = CoordsToWorldPosition(xCoords, yCoordsFake);
_board[xCoords, yCoords] = tile;
return(tile);
}
public IEnumerable <BaseTileData> GetTilesAtPos(IEnumerable <Vector3Int> positions, bool predict = false)
{
List <BaseTileData> res = new List <BaseTileData>();
foreach (Vector3Int pos in positions)
{
BaseTileData tile = GetTileDataAtPos(pos, predict);
if (tile != null)
{
res.Add(tile);
}
}
return(res.ToArray());
}
public IEnumerable <BaseTileData> GetTilesInBounds(BoundsInt bounds, bool predict = false)
{
List <BaseTileData> res = new List <BaseTileData>();
foreach (Vector3Int pos in bounds.allPositionsWithin)
{
BaseTileData tile = GetTileDataAtPos(pos, predict);
if (tile != null)
{
res.Add(tile);
}
}
return(res);
}
public void AddPossibleFloodTile(WaterCluster cluster, BaseTileData tile)
{
if (_possibleFloodTiles.ContainsKey(cluster))
{
_possibleFloodTiles.TryGetValue(cluster, out Stack <BaseTileData> associatedTiles);
associatedTiles.Push(tile);
}
else
{
Stack <BaseTileData> associatedTiles = new Stack <BaseTileData>();
associatedTiles.Push(tile);
_possibleFloodTiles.Add(cluster, associatedTiles);
}
}
public void RegisterStructure(BaseTileData structure)
{
if (structure.structureTile != null)
{
StructureType structureType = structure.structureTile.GetStructureType();
if (structureType == StructureType.Relay ^ structureType == StructureType.MainRelay)
{
if (structureType == StructureType.MainRelay)
{
_mainRelayTile = structure;
}
ComputeConstructibleTerrainTiles();
}
}
}
public void Initialize(BaseTileData data, int xCoord, int yCoord)
{
_tileData = data;
_spriteRenderer.sprite = data.Sprite;
_spriteRenderer.color = GetDebugColor();
_xCoord = xCoord;
_yCoord = yCoord;
if (data is ObstructionTileData)
{
_turnsTilExpired = (data as ObstructionTileData).TurnsTilExpired;
}
}
public Point2I GetSelectedTileLocation()
{
for (int x = 0; x < Tileset.Width; x++)
{
for (int y = 0; y < Tileset.Height; y++)
{
BaseTileData tileData = Tileset.GetTileData(x, y);
if (tileData != null && tileData == editorControl.SelectedTilesetTileData)
{
return(new Point2I(x, y));
}
}
}
return(new Point2I(-1, -1));
}
public void ToggleStructure()
{
BaseTileData selectedTile = MouseManager.Instance.SelectedTile;
ActivationState activationState = selectedTile.ToggleStructureIfPossible();
string currentErrorText;
if (_errorTextDico.TryGetValue(activationState, out currentErrorText))
{
_errorText.gameObject.SetActive(true);
_errorText.text = currentErrorText;
}
else
{
_errorText.gameObject.SetActive(false);
}
}
private void UpdateUI()
{
BaseTileData selectedTile = MouseManager.Instance.SelectedTile;
bool isActive = selectedTile != null;
SetVisible(isActive);
if (isActive)
{
_posText.text = selectedTile.GridPosition.ToString();
_typeText.text = selectedTile.GetTerrainText();
StructureTile structure = selectedTile.structureTile;
_structureControlView.gameObject.SetActive(structure != null);
_structureControlView.Structure = structure;
}
_errorText.gameObject.SetActive(false);
_previousTile = selectedTile;
}
public void NextTurn()
{
InitState = InitializationState.Updating;
_turnCounter++;
foreach (Vector3Int pos in TilesDataManager.Instance.GetTilemapBounds().allPositionsWithin)
{
if (TilesDataManager.Instance.HasTile(pos))
{
BaseTileData tile = TilesDataManager.Instance.GetTileDataAtPos(pos);
tile.OnTurnStarts();
}
}
OnTurnStart?.Invoke();
PredictNextTurn();
InitState = InitializationState.Ready;
}
public override IEnumerator PerformWeaponSkill(GameBoard gameBoard, Battle battle, List <Tile> match, GameBoard.Swap swap)
{
float rand = UnityEngine.Random.Range(0f, 1f);
if (match.Count == 3 && rand <= ThreeTileActivationPercentage ||
match.Count >= 4 && rand <= FourTileActivationPercentage)
{
BaseTileData matchedTileData = match[0].TileData;
gameBoard.ReplaceNRandomTiles(3, matchedTileData,
delegate(Tile tile) {
return(tile.TileType == matchedTileData.Type && !match.Contains(tile));
}
);
}
yield break;
}
public TerrainTile CreateTerrainFromType(TerrainType type, BaseTileData baseTileData)
{
TerrainTile newTile = null;
TerrainBinding terrainBinding = GetTerrainBindingFromType(type);
if (terrainBinding != null)
{
switch (type)
{
case TerrainType.Plains:
newTile = new PlainsTile();
break;
case TerrainType.Water:
newTile = new WaterTile();
break;
case TerrainType.Wood:
newTile = new WoodsTile();
break;
case TerrainType.Stone:
newTile = new StoneTile();
break;
case TerrainType.Sand:
newTile = new SandTile();
break;
default:
throw new MissingTerrainTypeDefinitionException();
}
}
baseTileData.terrainTile = newTile;
TerrainInfo terrainInfo = Instantiate(terrainBinding.terrainVisualInfo, baseTileData.worldPosition, Quaternion.identity, _terrainTilemap.transform);
terrainInfo.dataTile = newTile;
newTile.terrainInfo = terrainInfo;
newTile.GridPosition = baseTileData.GridPosition;
return(newTile);
}
