public void selection(GameObject g)
{
if ((srcHex != null && dstHex != null) || (srcHex == null && dstHex == null))
{
clear();
srcHex = g;
srcHexController = srcHex.GetComponent <HexController>();
srcSelected = true;
srcHexController.setSelected(true);
}
else if (srcHex != null && dstHex == null)
{
dstHex = g;
dstHexController = dstHex.GetComponent <HexController>();
dstSelected = true;
//Debug.Log (src + " - " + dst);
// action here!
Coordinate src = new Coordinate(srcHex.GetComponent <ObjectInfo>().line, srcHex.GetComponent <ObjectInfo>().column);
Coordinate dst = new Coordinate(dstHex.GetComponent <ObjectInfo>().line, dstHex.GetComponent <ObjectInfo>().column);
//clear();
if (gameState.moveStone(src, dst, gameState.getTurn()))
{
refresh = true;
}
}
//Debug.Log ( src + " - " + dst );
}
public Dictionary <Vector2, HexController> GenerateMap(Vector2 size)
{
Dictionary <Vector2, HexController> map = new Dictionary <Vector2, HexController>();
for (int i = 0; i < size.x; i++)
{
for (int j = 0; j < size.y; j++)
{
Vector3 position = new Vector3();
position.z = j * y_dif;
position.x = i * x_dif;
if (i % 2 == 0)
{
position.z += y_dif / 2;
}
GameObject instantiatedTile = Instantiate(hex, position, Quaternion.identity, this.transform);
HexController hexController = instantiatedTile.GetComponent <HexController>();
Vector2 pos2d = new Vector2(i, j);
hexController.TileInitialize(pos2d, controller);
map.Add(pos2d, hexController);
}
}
return(map);
}
public void selection(GameObject g)
{
if ((srcHex != null && dstHex != null) || (srcHex == null && dstHex == null)) {
clear();
srcHex = g;
srcHexController = srcHex.GetComponent<HexController>();
srcSelected = true;
srcHexController.setSelected(true);
}
else if (srcHex != null && dstHex == null) {
dstHex = g;
dstHexController = dstHex.GetComponent<HexController>();
dstSelected = true;
//Debug.Log (src + " - " + dst);
// action here!
Coordinate src = new Coordinate(srcHex.GetComponent<ObjectInfo>().line,srcHex.GetComponent<ObjectInfo>().column);
Coordinate dst = new Coordinate(dstHex.GetComponent<ObjectInfo>().line,dstHex.GetComponent<ObjectInfo>().column);
//clear();
if ( gameState.moveStone(src,dst,gameState.getTurn()) )
{
refresh = true;
}
}
//Debug.Log ( src + " - " + dst );
}
protected override void doWorkPart()
{
if (finished)
{
return;
}
if ((new Vector2(bee.transform.position.x - HexController.getInstance().tiles[buildTileIndexI][buildTileIndexJ].transform.position.x,
bee.transform.position.z - HexController.getInstance().tiles[buildTileIndexI][buildTileIndexJ].transform.position.z)).magnitude > 0.300f)
{
this.doneProgress = 1.0f;
if (this.doneProgress >= 1.0f)
{
this.doneProgress = 1.0f;
this.finished = true;
}
return;
}
long elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
if (lastTimeStamp == -1)
{
lastTimeStamp = elapsedMilliseconds;
}
this.doneProgress += 0.00035f * (elapsedMilliseconds - lastTimeStamp);
lastTimeStamp = elapsedMilliseconds;
if (this.doneProgress >= 1.0f)
{
this.doneProgress = 1.0f;
this.finished = true;
Hive hive = HexController.getInstance().tiles[buildTileIndexI][buildTileIndexJ].GetComponent <HiveBuildTileController>().hive;
hive.maxHoney += 1000;
GameObject newHiveTile = GameObject.Instantiate(GameController.getInstance().hiveTilePrefab, HexController.getInstance().tiles[buildTileIndexI][buildTileIndexJ].transform.position, Quaternion.identity) as GameObject;
newHiveTile.GetComponent <HiveTileController>().init(buildTileIndexI, buildTileIndexJ, hive);
HexController.getInstance().tiles[buildTileIndexI][buildTileIndexJ].GetComponent <HiveBuildTileController>().progress = this.doneProgress;
GameObject.Destroy(HexController.getInstance().tiles[buildTileIndexI][buildTileIndexJ].gameObject);
HexController.getInstance().tiles[buildTileIndexI][buildTileIndexJ] = newHiveTile.GetComponent <HiveTileController>();
}
try
{
HexController.getInstance().tiles[buildTileIndexI][buildTileIndexJ].GetComponent <HiveBuildTileController>().progress = this.doneProgress;
}catch (Exception e)
{
}
}
void SelectHex()
{
if (Input.GetMouseButtonDown(0))
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, layer))
{
Debug.Log("name " + hit.transform.name);
if (hit.transform.GetComponent <HexController>() != null)
{
if (hit.transform.gameObject != selectedHex && selectedHex != null)
{
selectedHex.GetComponent <HexController>().Fall();
hit.transform.GetComponent <HexController>().Rise();
selectedHex = hit.transform.gameObject.GetComponent <HexController>();
MainController.Players[0].Claim(selectedHex);
}
else if (selectedHex == null && hit.transform.gameObject != selectedHex)
{
hit.transform.GetComponent <HexController>().Rise();
selectedHex = hit.transform.gameObject.GetComponent <HexController>();
}
}
}
else
{
selectedHex.GetComponent <HexController>().Fall();
selectedHex = null;
}
}
}
// Use this for initialization
void Start()
{
srcHex = null;
srcHexController = null;
dstHex = null;
dstHexController = null;
}
// Use this for initialization
void Start()
{
srcHex = null;
srcHexController = null;
dstHex = null;
dstHexController = null;
}
protected override void doWorkPart()
{
if (finished)
{
return;
}
if ((new Vector2(bee.transform.position.x - HexController.getInstance().tiles[buildTileIndexI][buildTileIndexJ].transform.position.x,
bee.transform.position.z - HexController.getInstance().tiles[buildTileIndexI][buildTileIndexJ].transform.position.z)).magnitude > 5.000f)
{
this.doneProgress = 1.0f;
if (this.doneProgress >= 1.0f)
{
this.doneProgress = 1.0f;
this.finished = true;
}
return;
}
long elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
if (lastTimeStamp == -1)
{
lastTimeStamp = elapsedMilliseconds;
}
Hive hive = HexController.getInstance().tiles[buildTileIndexI][buildTileIndexJ].GetComponent <HiveTileController>().hive;
int honeyTransfer = Mathf.RoundToInt(0.3f * (elapsedMilliseconds - lastTimeStamp));
lastTimeStamp = elapsedMilliseconds;
hive.honey += honeyTransfer;
bee.honey -= honeyTransfer;
if (bee.honey < 0)
{
int diff = -bee.honey;
bee.honey += diff;
hive.honey -= diff;
}
if (hive.honey > hive.maxHoney)
{
int diff = hive.honey - hive.maxHoney;
bee.honey += diff;
hive.honey -= diff;
}
if (hive.honey == hive.maxHoney || bee.honey == 0)
{
this.doneProgress = 1.0f;
this.finished = true;
}
}
public void Claim(HexController hex)
{
if (expansionPoint > 10 && IsOurNeighbour(hex) == true) //And adjacent And in limit
{
hex.GetComponent <HexController>().SetOwner(Id);
HexList.Add(hex);
DecExpansionPoint(10);
}
}
// Start is called before the first frame update
void Start()
{
meteorController = GameObject.FindGameObjectWithTag("MeteorController").GetComponent <MeteorController>();
meteorController.ControllerStart();
hexController = GameObject.FindGameObjectWithTag("HexController").GetComponent <HexController>();
hexController.ControllerStart();
planetController = GameObject.FindGameObjectWithTag("Planet").GetComponent <PlanetController>();
planetController.ControllerStart();
cloudController = GameObject.FindGameObjectWithTag("CloudController").GetComponent <CloudController>();
cloudController.ControllerStart();
}
private void OnTransformClicked(Transform transform)
{
HexController HexController = transform.GetComponent <HexController>();
if (HexController is null)
{
return;
}
Unit unit = CGM.Battle.GetUnit(HexController.Hex);
CGM.Battle.SelectedUnit.Target = unit ?? null;
}
public HexController[] GetAdjecent()
{
if (x == 0 && z % 2 == 0)
{
HexController h1 = GameObject.Find("Hex_" + (x) + "_" + (z + 1)).GetComponent <HexController>();
HexController h2 = GameObject.Find("Hex_" + (x) + "_" + z).GetComponent <HexController>();
HexController h3 = GameObject.Find("Hex_" + (x + 1) + "_" + (z - 1)).GetComponent <HexController>();
HexController[] a = new HexController[3] {
h1, h2, h3
};
return(a);
}
else if (x == 0 && z % 2 == 1)
{
HexController h1 = GameObject.Find("Hex_" + (x + 1) + "_" + (z + 1)).GetComponent <HexController>();
HexController h2 = GameObject.Find("Hex_" + (x + 1) + "_" + z).GetComponent <HexController>();
HexController h3 = GameObject.Find("Hex_" + (x + 1) + "_" + (z - 1)).GetComponent <HexController>();
HexController h4 = GameObject.Find("Hex_" + x + "_" + (z + 1)).GetComponent <HexController>();
HexController h5 = GameObject.Find("Hex_" + x + "_" + (z - 1)).GetComponent <HexController>();
HexController[] a = new HexController[5] {
h1, h2, h3, h4, h5
};
return(a);
}
if (z % 2 == 0)
{
HexController h1 = GameObject.Find("Hex_" + (x - 1) + "_" + (z + 1)).GetComponent <HexController>();
HexController h2 = GameObject.Find("Hex_" + (x - 1) + "_" + z).GetComponent <HexController>();
HexController h3 = GameObject.Find("Hex_" + (x - 1) + "_" + (z - 1)).GetComponent <HexController>();
HexController h4 = GameObject.Find("Hex_" + x + "_" + (z - 1)).GetComponent <HexController>();
HexController h5 = GameObject.Find("Hex_" + (x + 1) + "_" + z).GetComponent <HexController>();
HexController h6 = GameObject.Find("Hex_" + x + "_" + (z + 1)).GetComponent <HexController>();
HexController[] a = new HexController[6] {
h1, h2, h3, h4, h5, h6
};
return(a);
}
else
{
HexController h1 = GameObject.Find("Hex_" + (x + 1) + "_" + (z + 1)).GetComponent <HexController>();
HexController h2 = GameObject.Find("Hex_" + (x + 1) + "_" + z).GetComponent <HexController>();
HexController h3 = GameObject.Find("Hex_" + (x + 1) + "_" + (z - 1)).GetComponent <HexController>();
HexController h4 = GameObject.Find("Hex_" + x + "_" + (z - 1)).GetComponent <HexController>();
HexController h5 = GameObject.Find("Hex_" + (x - 1) + "_" + z).GetComponent <HexController>();
HexController h6 = GameObject.Find("Hex_" + x + "_" + (z + 1)).GetComponent <HexController>();
HexController[] a = new HexController[6] {
h1, h2, h3, h4, h5, h6
};
return(a);
}
}
void ChangeUnitPosition(HexController toTile, Vector2 position)
{
map.map[activeUnit.position].state = TileState.free;
map.map[activeUnit.position].unitOnTile = null;
activeUnit.Move(map.getTilePosition(position), toTile.distanceToActiveUnit);
activeUnit.position = position;
toTile.state = TileState.occupied;
toTile.unitOnTile = activeUnit;
map.ShowRange(activeUnit.position);
}
// Use this for initialization
void Start()
{
hexController = GameObject.FindGameObjectWithTag("GameController").GetComponent <HexController>();
boardManager = GameObject.FindGameObjectWithTag("GameController").GetComponent <BoardManager>();
phaseManager = GameObject.FindGameObjectWithTag("GameController").GetComponent <PhaseManager>();
specificBehavior = this.transform.GetComponent <SpecificBehavior>();
currentHex = hexController.GetNearestHex(this.transform.position);
//If already on the board, snap to nearest hex. Only use this during development
//if (specificBehavior.active == BoardManager.Active.Board)
SnapToNearest();
this.transform.GetComponent <Rigidbody>().isKinematic = false;
}
bool IsOurNeighbour(HexController hex)
{
foreach (HexController Hex in HexList)
{
HexController[] adjecents = Hex.GetAdjecent();
foreach (HexController a in adjecents)
{
if (a == hex)
{
return(true);
}
}
}
return(false);
}
void drawHex(Hex hex)
{
GameObject hexObject = (GameObject)Instantiate(hexPrefab, Vector3.zero, Quaternion.identity);
hexObject.transform.position = HexMathHelper.hexToWorldCoords(new Vector2(hex.x, hex.y), this.getHexSize());
HexController hexController = hexObject.GetComponent <HexController>();
hexController.hexText.text = hex.x + ":" + hex.y;
hexController.hex = hex;
if (hex.regionId != 0)
{
hexObject.GetComponent <SpriteRenderer>().color = this.getRegionById(hex.regionId).color;
}
//hexObject.GetComponent<SpriteRenderer>().color = getColorByTerrainType(hex.terrainType);
}
// Update is called once per frame
void Update()
{
Vector3 target = (nextNode.transform.position + nextNode.spawnOffset) - transform.position;
if (!target.Equals(Vector3.zero) && energy > 0)
{
transform.rotation = Quaternion.RotateTowards(transform.rotation, Quaternion.LookRotation(target, Vector3.up), 5 * energy);
}
//move to the next node when we reach our target
if (target.sqrMagnitude < nodeRange)
{
//reached the end of the path
if (nextNode.nextNodes.Count <= 0)
{
manager.health -= (int)maxHealth;
GameObject.Destroy(gameObject);
}
else
{
nextNode = nextNode.getNextNode();
target = (nextNode.transform.position + nextNode.spawnOffset) - transform.position;
}
}
velocity = target.normalized * speed * Time.deltaTime;
transform.position += velocity * energy;
//update status effects
energy = 1;
for (int i = 0; i < effects.Count; i++)
{
effects[i] += Vector3.forward * Time.deltaTime;
if (effects[i].z >= effects[i].y)
{
effects.RemoveAt(i);
i--;
}
else
{
energy *= effects[i].x;
}
}
float ratio = health / maxHealth;
renderer.material.color = new Color(.9f, Mathf.Lerp(.25f, .05f, ratio), 0, energy);
}
// Start is called before the first frame update
void Start()
{
if (!(meteorController = GameObject.FindGameObjectWithTag("MeteorController").GetComponent<MeteorController>()))
meteorController.ControllerStart();
if (!(hexController = GameObject.FindGameObjectWithTag("HexController").GetComponent<HexController>()))
hexController.ControllerStart();
if (!(planetController = GameObject.FindGameObjectWithTag("Planet").GetComponent<PlanetController>()))
planetController.ControllerStart();
if (!(cloudController = GameObject.FindGameObjectWithTag("CloudController").GetComponent<CloudController>()))
cloudController.ControllerStart();
if (!(hexViewController = GameObject.FindGameObjectWithTag("HexViewController").GetComponent<HexViewController>()))
hexViewController.ControllerStart();
if (!(sunController = GameObject.FindGameObjectWithTag("SunController").GetComponent<SunController>()))
sunController.ControllerStart();
Debug.Log(sunController.name);
}
// Use this for initialization
void Start()
{
hexController = GameObject.FindGameObjectWithTag("GameController").GetComponent <HexController>();
boardManager = GameObject.FindGameObjectWithTag("GameController").GetComponent <BoardManager>();
covered = false;
GetCurrent();
pieceNumber = boardManager.DugoutRegistration(currentHex, color, type);
//If already on the board, register piece. Only use this during development
if (active == BoardManager.Active.Board)
{
NewPiecePlacement();
}
}
public TowerController spawnTower(HexController hex, TowerController tower)
{
hex.locked = true;
hex.defaultHeight = 1.5f;
hex.transform.position = new Vector3(hex.transform.position.x, 1.5f, hex.transform.position.z);
GameObject towerObject = Instantiate(tower.gameObject, hex.transform.position + hex.spawnOffset, Quaternion.identity) as GameObject;
TowerController newTower = towerObject.GetComponent <TowerController>();
hex.tower = newTower;
newTower.hex = hex;
newTower.applyUpgrade(0);
hex.setColor(newTower.upgrades[0].color);
towerObjects.Add(newTower);
return(newTower);
}
private void InstantiateMap(Map map)
{
for (int q = 0; q < map.Columns; q++)
{
for (int r = 0; r < map.Rows; r++)
{
Hex hex = map.Hexes[q, r];
GameObject prefab = new PrefabLoader().Load(hex);
Vector3 position = GetPosition(hex);
GameObject gameObject = Instantiate(prefab, position, Quaternion.identity, hexRoot);
gameObject.name = prefab.name;
HexController HexController = gameObject.GetComponent <HexController>();
HexController.Hex = hex;
hexControllers.Add(HexController);
}
}
}
void AttackUnit(HexController tile)
{
if (!activeUnit.hasAttacked)
{
activeUnit.Attack();
tile.unitOnTile.GetHit(activeUnit.damage);
Debug.Log("dealt " + activeUnit.damage + " damage");
}
else
{
Debug.Log("you had already attacked");
}
if (!tile.unitOnTile.isAlive())
{
UnitKilled(tile.unitOnTile);
}
}
// Use this for initialization
void Start()
{
boardManager = GameObject.FindGameObjectWithTag("GameController").GetComponent <BoardManager>();
hexController = GameObject.FindGameObjectWithTag("GameController").GetComponent <HexController>();
whoseTurn = BoardManager.UnitColor.White;
phase = Phase.FirstPlacement;
eligibleColor = "WhitePiece";
selectionMode = true;
//Initialize GUI display
DisableButtons();
UpdateStatus("White's Turn");
if (PhotonNetwork.isMasterClient) //Master client is white and takes the first turn
{
myTurn = true;
}
else
{
myTurn = false;
}
}
public override void start()
{
try { this.doneProgress = HexController.getInstance().tiles[buildTileIndexI][buildTileIndexJ].GetComponent <HiveBuildTileController>().progress; }
catch (Exception e)
{
bee.workQueue.Remove(this);
GameController.getInstance().workQueueChangedFlag = true;
if (started)
{
stop();
}
return;
}
workerThread = new Thread(new ThreadStart(doWork));
workerThread.Name = "BuildWorkUnit Thread";
workerThread.Start();
started = true;
}
void Awake()
{
_instance = this;
}
protected override void doWorkPart()
{
if (firstFlower == null)
{
for (int i = -HexController.getInstance().numberOfVerticalTiles + 1; i < HexController.getInstance().numberOfVerticalTiles; i++)
{
if (firstFlower != null)
{
break;
}
for (int j = -HexController.getInstance().numberOfHorizontalTiles + 1; j < HexController.getInstance().numberOfHorizontalTiles; j++)
{
if (firstFlower != null)
{
break;
}
int indexI = i + HexController.getInstance().numberOfVerticalTiles - 1;
int indexJ = j + HexController.getInstance().numberOfHorizontalTiles - 1;
TileController tile = HexController.getInstance().tiles[indexI][indexJ];
if (tile is FlowerTileController && tile.getState() == TileController.TileState.Visible && ((FlowerTileController)tile).honey > 0)
{
firstFlower = (FlowerTileController)tile;
}
if (firstFlower != null)
{
break;
}
}
if (firstFlower != null)
{
break;
}
}
}
if (firstFlower == null)
{
this.doneProgress = 1.0f;
if (this.doneProgress >= 1.0f)
{
this.doneProgress = 1.0f;
this.finished = true;
}
return;
}
endPosition = new Vector3(firstFlower.transform.position.x, endHeight, firstFlower.transform.position.z);
if (!addedCollectWorkUnit)
{
this.bee.workQueue.Add(new CollectHoneyWorkUnit(this.bee, firstFlower.indexI, firstFlower.indexJ, false));
this.bee.workQueueChanged = true;
addedCollectWorkUnit = true;
}
if (endPosition == startPosition)
{
this.doneProgress = 1.0f;
if (this.doneProgress >= 1.0f)
{
this.doneProgress = 1.0f;
this.finished = true;
}
return;
}
long elapsedMilliseconds = stopwatch.ElapsedMilliseconds;
if (lastTimeStamp == -1)
{
lastTimeStamp = elapsedMilliseconds;
}
float speedMultiplier = (endPosition - startPosition).magnitude;
this.doneProgress += 0.0035f * (elapsedMilliseconds - lastTimeStamp) / speedMultiplier;
lastTimeStamp = elapsedMilliseconds;
if (this.doneProgress >= 1.0f)
{
this.doneProgress = 1.0f;
this.finished = true;
}
Vector3 newPosition = Vector3.Lerp(startPosition, endPosition, (float)doneProgress);
try
{
bee.transform.position = newPosition;
bee.transform.LookAt(new Vector3(endPosition.x, bee.transform.position.y, endPosition.z));
if (GameController.getInstance().state == GameController.GameState.BEE_SELECTED)
{
GameController.getInstance().visibilitiesChanged = true;
}
}
catch (Exception e)
{
}
}
// Use this for initialization
void Start()
{
boardManager = GameObject.FindGameObjectWithTag("GameController").GetComponent<BoardManager>();
hexController = GameObject.FindGameObjectWithTag("GameController").GetComponent<HexController>();
whoseTurn = BoardManager.UnitColor.White;
phase = Phase.FirstPlacement;
eligibleColor = "WhitePiece";
selectionMode = true;
//Initialize GUI display
DisableButtons();
UpdateStatus("White's Turn");
if (PhotonNetwork.isMasterClient) //Master client is white and takes the first turn
{
myTurn = true;
}
else
myTurn = false;
}
// Use this for initialization
void Start()
{
hexController = GameObject.FindGameObjectWithTag("GameController").GetComponent<HexController>();
boardManager = GameObject.FindGameObjectWithTag("GameController").GetComponent<BoardManager>();
covered = false;
GetCurrent();
pieceNumber = boardManager.DugoutRegistration(currentHex, color, type);
//If already on the board, register piece. Only use this during development
if (active == BoardManager.Active.Board)
NewPiecePlacement();
}
// Use this for initialization
void Start()
{
hexController = GameObject.FindGameObjectWithTag("GameController").GetComponent<HexController>();
boardManager = GameObject.FindGameObjectWithTag("GameController").GetComponent<BoardManager>();
phaseManager = GameObject.FindGameObjectWithTag("GameController").GetComponent<PhaseManager>();
specificBehavior = this.transform.GetComponent<SpecificBehavior>();
currentHex = hexController.GetNearestHex(this.transform.position);
//If already on the board, snap to nearest hex. Only use this during development
//if (specificBehavior.active == BoardManager.Active.Board)
SnapToNearest();
this.transform.GetComponent<Rigidbody>().isKinematic = false;
}
// Start is called before the first frame update
void Start()
{
hexObjectsArray = Resources.FindObjectsOfTypeAll(typeof(HexData)) as HexData[];
hexController = FindObjectOfType <HexController>();
hexController.setObjectsArray(hexObjectsArray);
}
// Update is called once per frame
void Update()
{
AudioListener.volume = mute ? 0 : 1;
switch (gameState)
{
case GameStates.Play:
//get the grid the mouse is over
Ray mouseRay = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(mouseRay, out hit, 1000, 1 << 8))
{
HexController hex = hit.transform.gameObject.GetComponent(typeof(HexController)) as HexController;
hex.startMoving(.4f, 2f, true, true);
if (Input.GetMouseButtonDown(0))
{
if (hex.tower == null && !hex.path)
{
if (buildSelection >= 0)
{
selection = spawnTower(hex, towers[buildSelection]);
money -= towers[buildSelection].upgrades[0].cost;
towerSelection = towers[buildSelection].type;
buildSelection = -1;
}
else
{
selection = null;
towerSelection = -1;
}
}
else if (hex.tower != null)
{
selection = hex.tower;
towerSelection = hex.tower.type;
}
else
{
selection = null;
towerSelection = -1;
}
}
}
if (Input.GetMouseButtonDown(1))
{
buildSelection = -1;
towerSelection = -1;
}
if (Input.GetKeyDown(KeyCode.Alpha1))
{
buildSelection = 0;
}
if (Input.GetKeyDown(KeyCode.Alpha2))
{
buildSelection = 1;
}
if (Input.GetKeyDown(KeyCode.Alpha3))
{
buildSelection = 2;
}
if (Input.GetKeyDown(KeyCode.Alpha4))
{
buildSelection = 3;
}
if (Input.GetKeyDown(KeyCode.Alpha5))
{
buildSelection = 4;
}
if (Input.GetKeyDown(KeyCode.E) && selection != null && selection.upgradeLevel + 1 < selection.upgrades.Length)
{
upgradeTower(selection, 1);
}
if (Input.GetKeyDown(KeyCode.Space))
{
startWave();
}
if (Input.GetKeyDown(KeyCode.F))
{
Time.timeScale = Time.timeScale == 1 ? 2 : 1;
}
if (Input.GetKeyDown(KeyCode.P) || Input.GetKeyDown(KeyCode.Escape))
{
Time.timeScale = 0;
gameState = GameStates.Pause;
}
if (health <= 0)
{
gameState = GameStates.GameOver;
Time.timeScale = 0;
}
break;
case GameStates.Pause:
if (Input.GetKeyDown(KeyCode.P) || Input.GetKeyDown(KeyCode.Escape))
{
gameState = GameStates.Play;
Time.timeScale = 1;
}
break;
}
}
