float GetHeight(WorldGridTile tile)
{
float height = 0f;
Vector2Int pos = tile.Position;
WorldGrid grid = tile.ParentGrid;
for (int i = pos.x - 1; i < pos.x + 2; i++)
{
for (int j = pos.y - 1; j < pos.y + 2; j++)
{
WorldGridTile adjTile = grid.GetTile(i, j);
if (adjTile == null)
{
continue;
}
if (adjTile.Model)
{
if (adjTile.Model.GetComponent <MeshRenderer>())
{
height = (adjTile.Model.GetComponent <MeshRenderer>().bounds.size.y > height) ? adjTile.Model.GetComponent <MeshRenderer>().bounds.size.y : height;
}
else
{
height = (adjTile.Model.GetComponentInChildren <MeshRenderer>().bounds.size.y > height) ? adjTile.Model.GetComponentInChildren <MeshRenderer>().bounds.size.y : height;
}
}
}
}
return(height);
}
void CheckTarget()
{
if (GazeManager.Instance.HitObject && GazeManager.Instance.HitObject.GetComponent <FocusHighlighter>())
{
WorldGridTile tile = GazeManager.Instance.HitObject.transform.parent.GetComponent <WorldGridTile>();
CheckPlacement(tile);
if (tile == prevTile)
{
return;
}
else
{
prevTile = tile;
}
SetGhostPosition(ghostEnt, tile.transform);
}
else
{
ghostEnt.SetActive(false);
validPlace = false;
}
}
public override void OnWorldGridTileCreated(WorldGridTile tile)
{
base.OnWorldGridTileCreated(tile);
_tile = tile;
InstantiateWarningIndicators(tile);
}
void Start()
{
_tileParent = GetComponentInParent <WorldGridTile>();
_handDetection = FindObjectOfType <HandDetection>();
_cameraTransform = Camera.main.transform;
_gesturesManager = Camera.main.GetComponent <GesturesManager>();
gridTile = GetComponentInParent <WorldGridTile>().GridTileCounterpart;
}
void StopTool()
{
active = false;
startTile = null;
endTiles.Clear();
tiles.Clear();
DestroyIndicators();
tileHighlighter.ValidPlace = true;
buttonMenuPrefab.SetActive(false);
}
void UndoRoad(GameObject go)
{
if (endTiles.Count < 2)
{
return;
}
endTiles.Pop();
startTile = endTiles.Peek();
ClearLine();
DisableIndicators();
}
public void MoveToTile(WorldGridTile tile)
{
FollowGaze = false;
float height = GetHeight(tile) + 0.025f;
Vector3 pos = tile.transform.position;
pos.y += height;
menuTransform.localPosition = Vector3.zero;
transform.position = pos;
}
private WorldGridTile CreateWorldGridTile(Vector2Int tileposition)
{
GameObject newTileGameObject = new GameObject();
newTileGameObject.name = string.Format("WorldTile({0},{1})", tileposition.x, tileposition.y);
newTileGameObject.transform.SetParent(GridContainer.transform);
newTileGameObject.transform.localPosition = new Vector3(tileposition.x * TileScale, 0, tileposition.y * TileScale);
//Add WorldGridTile component and set up.
WorldGridTile tile = newTileGameObject.AddComponent <WorldGridTile>();
tile.Initialize(tileposition, this);
return(tile);
}
protected void InstantiateWarningIndicators(WorldGridTile tile)
{
float boundmax = 0.1f;
MeshRenderer renderer = tile.Model.GetComponent <MeshRenderer>();
if (renderer == null)
{
MeshRenderer[] renderers = tile.Model.GetComponentsInChildren <MeshRenderer>();
foreach (MeshRenderer rend in renderers)
{
Vector3 bounds = new Vector3(rend.bounds.max.x * rend.transform.lossyScale.x, rend.bounds.max.y * rend.transform.lossyScale.y, rend.bounds.max.z * rend.transform.lossyScale.z);
if (bounds.y > boundmax)
{
boundmax = bounds.y;
}
if (bounds.z > boundmax)
{
boundmax = bounds.z;
}
}
}
else
{
boundmax = renderer.bounds.max.y * renderer.transform.lossyScale.y;
float boundzscaled = renderer.bounds.max.z * renderer.transform.lossyScale.z;
if (boundzscaled > boundmax)
{
boundmax = boundzscaled;
}
}
//if (boundmax < tile.Model.GetComponent<MeshRenderer>().bounds.max.z) boundmax = tile.Model.GetComponent<MeshRenderer>().bounds.max.z;
Vector3 offset = tile.transform.position + new Vector3(0, boundmax, 0);
if (ElectricityWarning != null)
{
UnityEngine.Object.Destroy(ElectricityWarning);
}
ElectricityWarning = UnityEngine.Object.Instantiate(Game.CurrentSession.Cache.ElectricityWarning, ParentTile.ParentGridSystem.WorldGrid.transform);
ElectricityWarning.transform.position = offset;
if (WaterWarning != null)
{
UnityEngine.Object.Destroy(WaterWarning);
}
WaterWarning = UnityEngine.Object.Instantiate(Game.CurrentSession.Cache.WaterWarning, ParentTile.ParentGridSystem.WorldGrid.transform);
WaterWarning.transform.position = offset;
}
public void TilePressed()
{
if (tileHighlighter.ValidPlace && tiles.Count > 0)
{
if (!endTiles.Contains(endTile))
{
startTile = endTile;
endTiles.Push(endTile);
}
}
else
{
// play some error sound
// AudioManager.Instance.errorSound();
}
}
public override void OnWorldGridTileCreated(WorldGridTile tile)
{
worldTile = tile;
ApplyModelRotation();
//Tell any adjacent road tiles to check and update their models.
GridTile[] adjacentTiles = GetAdjacentGridTiles();
foreach (GridTile adjtile in adjacentTiles)
{
if (adjtile?.Entity is Road)
{
((Road)adjtile.Entity).RecheckAndApplyRoadModel();
}
}
}
void BuildingPressed(GameObject go)
{
if (!UIManager.Instance.targetTile)
{
return;
}
WorldGridTile targetTile = UIManager.Instance.targetTile;
int index = go.GetComponent <BuildingButton>().index;
buildingTool.StartTool(Buildings[index].BuildingType, index, targetTile.ParentGrid.Id);
DestroyBuildingButtons();
UIManager.Instance.SwitchState(UIManager.MenuState.Off);
}
/// <summary>
/// Swap the positions of these two tiles. Simply a data swap and visual only.
/// </summary>
/// <param name="tileA"></param>
/// <param name="tileB"></param>
public void SwapGridTiles(Vector2Int tileA, Vector2Int tileB)
{
//Get Tiles.
WorldGridTile a = GetTile(tileA);
WorldGridTile b = GetTile(tileB);
//Store the old a positions.
Vector3 oldAPos = a.transform.position;
Vector2Int oldATilePos = a.Position;
//Change a to b's data.
a.Position = b.Position;
a.transform.position = b.transform.position;
GridTiles[b.Position.x][b.Position.y] = a;
//Change b's data to a's.
b.Position = oldATilePos;
b.transform.position = oldAPos;
GridTiles[oldATilePos.x][oldATilePos.y] = b;
}
private void CheckPlacement(WorldGridTile tile)
{
validPlace = buildingMenu.CheckCanPlace(tile, buildingIndex);
validPlace = CheckCost();
if (validPlace)
{
foreach (PreviewBuilding ghostTile in ghostTiles)
{
if (ghostTile.tile == tile)
{
validPlace = false;
break;
}
}
}
SetGhostColour(validPlace);
}
public void PlaceBuilding(WorldGridTile tile, int index, TileEntity tileEnt)
{
int gridID = 0;
gridID = tile.ParentGrid.Id;
Vector2Int pos = tile.Position;
if (tile.Model)
{
tile.UpdateModel(tileEnt.GetModel());
}
else if (CheckCanPlace(tile, index))
{
Game.CurrentSession.City.GetGrid(gridID).AddTileEntityToTile(pos.x, pos.y, tileEnt);
//Take money
Game.CurrentSession.TakeFunds(Buildings[index].Cost);
}
}
public void TilePressed(WorldGridTile tile)
{
if (roadTool.active || buildingTool.active)
{
return;
}
// move the menu up if surrounding tiles have things on them.. or scale it up,.
if (targetTile == tile && menuState != MenuState.Off)
{
SwitchState(MenuState.Off);
return;
}
targetTile = tile;
moveUI.MoveToTile(targetTile);
tileHighlighter.currentTarget = targetTile.transform.GetChild(0).gameObject;
SwitchState(MenuState.BuildMenu);
}
public bool AttemptBuildingSwap(Vector3 checkPosition)
{
//Will need to update to work with multiple grids.
LayerMask layerMask = LayerMask.NameToLayer("Hologram");
RaycastHit hit;
if (Physics.Raycast(checkPosition, -Vector3.up, out hit, layerMask))
{
//Check for WorldGridTile.
WorldGridTile foundTile = hit.transform.parent.GetComponent <WorldGridTile>() ?? hit.transform.parent.GetComponentInParent <WorldGridTile>();
//Check if there was a found tile and if the found grid tile shares the same grid id.
if (foundTile != null && foundTile.ParentGrid.Id == ParentGrid.Id)
{
//Try to swap these two tiles around. if it fails we know to reset the positions.
return(ParentGrid.GridSystem.SwapTileEntities(Position, foundTile.Position));
}
}
return(false);
}
public void StartTool(WorldGridTile tile)
{
if (active)
{
return;
}
startTile = (tile != null) ? tile : null;
if (startTile == null)
{
return;
}
active = true;
endTiles.Push(startTile);
HighlightStartTile();
buttonMenuPrefab.SetActive(true);
buttonMenuPrefab.transform.parent = startTile.transform;
buttonMenuPrefab.transform.localPosition = offset;
}
public void OnInputClicked(InputClickedEventData eventData)
{
if (timeofuse + 0.5f > Time.time)
{
return;
}
timeofuse = Time.time;
eventData.Use();
if (UIManager.Instance.roadTool.active)
{
UIManager.Instance.roadTool.TilePressed();
}
else if (UIManager.Instance.buildingTool.active)
{
UIManager.Instance.buildingTool.TilePressed();
}
else if (GazeManager.Instance.HitObject && GazeManager.Instance.HitObject.GetComponent <CompoundButton>())
{
AudioManager.Instance.UISound(true);
}
else if (GazeManager.Instance.HitObject && GazeManager.Instance.HitObject.GetComponentInParent <WorldGridTile>())
{
WorldGridTile tile = GazeManager.Instance.HitObject.transform.parent.GetComponent <WorldGridTile>();
UIManager.Instance.TilePressed(tile);
AudioManager.Instance.SelectSound(true);
}
else if (!GazeManager.Instance.HitObject && UIManager.Instance.menuState != UIManager.MenuState.Off)
{
UIManager.Instance.SwitchState(UIManager.MenuState.Off);
AudioManager.Instance.SelectSound(false);
//turn off UI if player clicks away.
}
}
public void Initialize(int id, int width, int height, GridSystem gridSystem)
{
Id = id;
GridSystem = gridSystem;
GridTiles = new WorldGridTile[width][];
for (int w = 0; w < width; w++)
{
GridTiles[w] = new WorldGridTile[height];
for (int h = 0; h < height; h++)
{
GridTiles[w][h] = CreateWorldGridTile(new Vector2Int(w, h));
}
}
Width = width;
Height = height;
CenterGridTiles();
AddMoveButton(new Vector3(GridTiles[0][0].transform.localPosition.x - 0.15f, GridTiles[0][0].transform.localPosition.y, GridTiles[0][0].transform.localPosition.z));
AddScaleButton(new Vector3(GridTiles[0][0].transform.localPosition.x - 0.15f, GridTiles[0][0].transform.localPosition.y, GridTiles[0][0].transform.localPosition.z + 0.45f));
AddRotateButton(new Vector3(GridTiles[0][0].transform.localPosition.x - 0.15f, GridTiles[0][0].transform.localPosition.y, GridTiles[0][0].transform.localPosition.z + 0.90f));
AddNewGridButton(new Vector3(GridTiles[0][0].transform.localPosition.x - 0.15f, GridTiles[0][0].transform.localPosition.y, GridTiles[0][0].transform.localPosition.z + 1.35f));
//Add ambient sound
AddAmbientSound();
//Add in the resources UI.
AddResourcesUI();
//Attempt to scale the grid container
GridContainer.transform.localScale = ContainerScaleFactor;
RotateToFaceUser();
UIGuideCircle.instance.AddTarget(GridContainer.transform);
}
public PreviewBuilding(WorldGridTile Tile, GameObject GhostBuilding)
{
tile = Tile;
ghostBuilding = GhostBuilding;
}
public override void OnWorldGridTileCreated(WorldGridTile tile)
{
base.OnWorldGridTileCreated(tile);
gridtile = tile;
}
public bool CheckCanPlace(WorldGridTile tile, int index)
{
return(tile.ParentGrid.GridSystem.QueryPlaceByType(Buildings[index].BuildingType, tile.Position));
}
void GetTiles()
{
if (GazeManager.Instance.HitObject && GazeManager.Instance.HitObject.GetComponent <FocusHighlighter>() && GazeManager.Instance.HitObject != prevTarget)
{
prevTarget = GazeManager.Instance.HitObject;
endTile = GazeManager.Instance.HitObject.transform.parent.GetComponent <WorldGridTile>();
WorldGrid grid = startTile.ParentGrid;
ClearLine();
DisableIndicators();
if (startTile.Position.x == endTile.Position.x)
{
int i = (startTile.Position.y <= endTile.Position.y) ? 1 : -1;
for (int y = startTile.Position.y; ;)
{
WorldGridTile tile = grid.GetTile(startTile.Position.x, y);
if (!tiles.Contains(tile))
{
tiles.Add(tile);
}
if (y == endTile.Position.y)
{
break;
}
y += i;
}
tileHighlighter.ValidPlace = true;
}
else if (startTile.Position.y == endTile.Position.y)
{
int i = (startTile.Position.x <= endTile.Position.x) ? 1 : -1;
for (int x = startTile.Position.x; ;)
{
WorldGridTile tile = grid.GetTile(x, startTile.Position.y);
if (!tiles.Contains(tile))
{
tiles.Add(tile);
}
if (x == endTile.Position.x)
{
break;
}
x += i;
}
tileHighlighter.ValidPlace = true;
}
else
{
tileHighlighter.ValidPlace = false;
}
HighlightTiles();
}
}
public virtual void OnWorldGridTileCreated(WorldGridTile tile)
{
}
public override void OnWorldGridTileCreated(WorldGridTile tile)
{
base.OnWorldGridTileCreated(tile);
tile.Model.transform.localPosition = new Vector3(-0.075f, 0, 0.075f);
}
void Start()
{
_tileParent = GetComponentInParent <WorldGridTile>();
_gesturesManager = Camera.main.GetComponent <GesturesManager>();
}
