public void MaskPlayer(PlayerInfo player)
{
UnitPiece[] pieces = new UnitPiece[player.Pieces.Count];
player.Pieces.CopyTo(pieces, 0);
for (int i = 0; i < pieces.Length; i++)
{
BoardPosition boardPosition = UnitManager.GetPositionForUnitPiece(pieces[i]);
Transform transform = BoardManager.GetTransformForPosition(boardPosition);
Vector3 coverPosition = transform.position;
coverPosition.z = GOLayer.COVER_LAYER;
GameObject cover = covers[i];
if (cover.activeInHierarchy)
{
for (int j = i + 1; j < covers.Count; j++)
{
cover = covers[j];
if (!cover.activeInHierarchy)
{
break;
}
}
}
cover.transform.position = coverPosition;
cover.SetActive(true);
coverBoardPositions.Add(boardPosition, cover);
}
}
public void RemoveUnit(Point position)
{
UnitPiece unit = unitGrid[position.x, position.y];
initiativeOrder.Remove(unit);
if (unit.unit.faction == Faction.Player)
{
fallenUnits.Add(unit.identifier);
army.Remove(unit);
}
else
{
monsters.Remove(unit);
}
unitGrid[position.x, position.y] = null;
unit.Die();
// Player has lost all units
if (army.Count == 0)
{
StartCoroutine(combatManager.EndCombat(false));
}
// No enemies left
else if (monsters.Count == 0)
{
StartCoroutine(combatManager.EndCombat(true));
}
}
public UnitBattleResultEvent(UnitPiece attacker, UnitPiece defender, BoardPosition attackerPosition, BoardPosition defenderPosition, BattleResult result) : base(attacker)
{
this.defender = defender;
this.result = result;
this.attackerPosition = attackerPosition;
this.defenderPosition = defenderPosition;
}
public override void Perform(CombatMap map, Point trigger)
{
owner.Energy(-cost);
UnitPiece target = map.unitManager.GetUnit(trigger);
target.Damage(owner, Random.Range(damage, maxDamage + 1));
}
TargetType IsValidTarget(CombatMap map, Point point)
{
switch (canTarget)
{
case Target.anything:
return(TargetType.Valid);
case Target.creature:
if (map.unitManager.GetUnit(point) != null)
{
return(TargetType.Valid);
}
return(TargetType.NotValid);
case Target.enemy:
UnitPiece unit = map.unitManager.GetUnit(point);
if (unit != null && unit.unit.IsEnemy(owner))
{
return(TargetType.Valid);
}
return(TargetType.NotValid);
case Target.ally:
unit = map.unitManager.GetUnit(point);
if (unit != null && unit.unit.IsFriendly(owner))
{
return(TargetType.Valid);
}
return(TargetType.NotValid);
}
return(TargetType.NotValid);
}
public void HandleBattle(UnitPiece attacker, BoardPosition attackerPosition, UnitPiece defender, BoardPosition defenderPosition)
{
BattleResult result = UnitUtilities.ResolveBattle(attacker.Rank, defender.Rank);
// Based on result, update players
switch (result)
{
case BattleResult.Success:
{
// Remove from defender owner
defender.Owner.Pieces.Remove(defender);
break;
}
case BattleResult.Fail:
{
// Remove from attacker owner
attacker.Owner.Pieces.Remove(attacker);
break;
}
case BattleResult.Split:
{
//Remove both
attacker.Owner.Pieces.Remove(attacker);
defender.Owner.Pieces.Remove(defender);
break;
}
default:
{
break;
}
}
EventManager.Raise(new UnitBattleResultEvent(attacker, defender, attackerPosition, defenderPosition, result));
turnComplete = true;
}
public void MaskPlayer(PlayerInfo player)
{
UnitPiece[] pieces = new UnitPiece[player.Pieces.Count];
player.Pieces.CopyTo(pieces, 0);
for (int i = 0; i < pieces.Length; i++)
{
BoardPosition boardPosition = UnitManager.GetPositionForUnitPiece(pieces[i]);
Transform transform = BoardManager.GetTransformForPosition(boardPosition);
Vector3 coverPosition = transform.position;
coverPosition.z = GOLayer.COVER_LAYER;
GameObject cover = covers[i];
if (cover.activeInHierarchy)
{
for (int j = i + 1; j < covers.Count; j++)
{
cover = covers[j];
if (!cover.activeInHierarchy)
{
break;
}
}
}
cover.transform.position = coverPosition;
cover.SetActive(true);
coverBoardPositions.Add(boardPosition, cover);
}
}
public void RemoveFromLocation(UnitPiece u, BasePiece b)
{
if (unitsInOrbit.ContainsKey(b))
{
unitsInOrbit[b].Remove(u);
}
b.UnitsInOrbit.Remove(u);
}
public UnitBattleResultEvent(UnitPiece attacker, UnitPiece defender, BoardPosition attackerPosition, BoardPosition defenderPosition, BattleResult result)
: base(attacker)
{
this.defender = defender;
this.result = result;
this.attackerPosition = attackerPosition;
this.defenderPosition = defenderPosition;
}
public void AddToLocation(UnitPiece u, BasePiece b)
{
if (!unitsInOrbit.ContainsKey(b))
{
unitsInOrbit.Add(b, new List <UnitPiece>());
}
unitsInOrbit[b].Add(u);
b.UnitsInOrbit.Add(u);
}
private void SpawnUnit(Vector3 position)
{
GameObject obj = Object.Instantiate(GameManager.manager.unitObject, position, Quaternion.identity);
obj.layer = owner.data.layer;
UnitPiece unit = new UnitPiece(owner, obj);
owner.AddUnit(unit);
}
public void PerformAction()
{
//Debug.Log("AI Action");
// Collect units
List <UnitPiece> army = unitManager.army;
List <UnitPiece> monsters = unitManager.monsters;
// Can best attack somebody?
UnitPiece piece = unitManager.selectedUnit;
Action[] actions = piece.unit.actions;
int bestAction = -1;
Point targetTile = new Point(-1, -1);
for (int i = 0; i < actions.Length; i++)
{
if (actions[i] == null || !actions[i].CanUse())
{
continue;
}
List <TargetTile> targets = piece.unit.actions[i].GetTargets(map, false);
if (targets.Count > 0)
{
// Do something
if (bestAction == -1)
{
bestAction = i;
targetTile = targets[Random.Range(0, targets.Count)].point;
}
// Prefer hostile actions
else if (actions[i].IsHostile() && !actions[bestAction].IsHostile())
{
bestAction = i;
targetTile = targets[Random.Range(0, targets.Count)].point;
}
// Prefer expensive actions
else if (actions[i].IsHostile() == actions[bestAction].IsHostile() && actions[i].cost > actions[bestAction].cost)
{
bestAction = i;
targetTile = targets[Random.Range(0, targets.Count)].point;
}
}
}
if (bestAction >= 0)
{
unitManager.SelectAction(bestAction);
unitManager.PerformAction(targetTile);
return;
}
combatManager.EndTurn();
}
public UnitPiece GetUnitPieceForPosition(BoardPosition position)
{
UnitPiece piece = default(UnitPiece);
if (!pieces.TryGetValue(position, out piece))
{
piece = UnitPiece.UNKNOWN;
}
return(piece);
}
// Update is called once per frame
void Update()
{
RaycastHit[] hits = Physics.RaycastAll(mainCamera.ScreenPointToRay(Input.mousePosition), 50, mask);
bool selectable = false;
BoardPosition position = BoardPosition.OFF_BOARD;
UnitPiece unit = UnitPiece.UNKNOWN;
Vector3 tileVector = Vector3.zero;
if (hits.Length == 0)
{
hoverCube.SetActive(false);
}
else
{
// Find the board first
foreach (RaycastHit hit in hits)
{
if (hit.transform.gameObject.layer == LayerMask.NameToLayer("Board"))
{
position = BoardManager.GetPositionForGO(hit.transform.gameObject);
selectable = BoardManager.PositionIsSelectable(position);
tileVector = hit.transform.position;
if (selectable && !action)
{
MoveHover(hit.transform.position);
}
else
{
hoverCube.SetActive(false);
}
break;
}
}
// Because there's no order to raycast hit result, check if we hit a piece
foreach (RaycastHit hit in hits)
{
if (hit.transform.gameObject.layer == LayerMask.NameToLayer("Pieces"))
{
unit = UnitManager.GetUnitPieceForPosition(position);
break;
}
}
}
//Handle input based on game mode
if (GameManager.CurrentMode.Equals(GameMode.PlayerOneSetup) || GameManager.CurrentMode.Equals(GameMode.PlayerTwoSetup))
{
HandleSetup(hits, selectable, position, unit, tileVector);
}
if (!action && (GameManager.CurrentMode.Equals(GameMode.PlayerOne) || GameManager.CurrentMode.Equals(GameMode.PlayerTwo)))
{
HandleGame(hits, selectable, position, unit, tileVector);
}
}
public void HandleGameModeChange(GameModeChangedEvent e)
{
if (!flagAtEnd.ContainsKey(GameManager.PlayerOne))
{
flagAtEnd.Add(GameManager.PlayerOne, 0);
}
if (!flagAtEnd.ContainsKey(GameManager.PlayerTwo))
{
flagAtEnd.Add(GameManager.PlayerTwo, 0);
}
if (e.Current.Equals(GameMode.PlayerTransition))
{
moveWithoutChallengeCount++;
moveCount++;
}
else if (e.Current.Equals(GameMode.PlayerOne) || e.Current.Equals(GameMode.PlayerTwo))
{
bool draw = false;
//Check no challenge rule
if (NoChallengeRule && moveWithoutChallengeCount >= MoveWithoutChallengeLimit)
{
draw = true;
win = true;
}
if (!draw)
{
//Check for flag
for (int i = 0; i < 9; i++)
{
UnitPiece piece = UnitManager.GetUnitPieceForPosition(new BoardPosition(0, i));
if (piece.Rank.Equals(UnitRank.Flag) && piece.Owner.Equals(GameManager.PlayerTwo))
{
flagAtEnd[piece.Owner]++;
}
piece = UnitManager.GetUnitPieceForPosition(new BoardPosition(7, i));
if (piece.Rank.Equals(UnitRank.Flag) && piece.Owner.Equals(GameManager.PlayerOne))
{
flagAtEnd[piece.Owner]++;
}
}
foreach (KeyValuePair <PlayerInfo, int> pair in flagAtEnd)
{
if (pair.Value >= 1)
{
//Meets win condition
win = true;
winner = pair.Key;
}
}
}
}
}
public override void Perform(CombatMap map, Point trigger)
{
owner.Energy(-cost);
//owner.Armor(value);
UnitPiece target = map.unitManager.GetUnit(trigger);
if (target != null)
{
target.Effect(attribute, Random.Range(value, maxValue + 1));
}
}
void SetDestination(Vector2 destination)
{
GameObject[] playerUnits = GameObject.FindGameObjectsWithTag("PlayerUnit");
foreach (var u in playerUnits)
{
UnitPiece unit = u.GetComponent <Collider>().owner as UnitPiece;
if (unit.GetIsSelected())
{
unit.SetDestination(destination);
unit.SetIsSelected(false);
}
}
}
public void AddPiece(BoardPosition position, UnitRank rank)
{
//Check for existing piece, remove it if needed.
//Debug.Log("atteming to add " + UnitUtilities.ReadableRank(rank) + " at " + position.ToString());
bool equal = false;
if (pieces.ContainsKey(position))
{
UnitPiece existing;
if (pieces.TryGetValue(position, out existing))
{
if (existing.Rank.Equals(rank))
{
//We're not going to remove then add the same exact piece to the same position
equal = true;
}
else
{
RemovePiece(position);
}
}
}
if (!equal)
{
Transform target = BoardManager.GetTransformForPosition(position);
if (!EqualityComparer <Transform> .Default.Equals(target, default(Transform)))
{
GameObject plane = Instantiate(UnitPlane);
UnitPiece piece = GeneratePiece(rank, plane);
if (piece.Owner != null)
{
piece.Piece.transform.SetParent(piece.Owner.Holder.transform);
plane.name = UnitUtilities.ReadableRank(rank);
plane.layer = LayerMask.NameToLayer("Pieces");
Vector3 planePos = target.position;
planePos.z = GOLayer.UNIT_LAYER;
plane.transform.position = planePos;
Renderer r = plane.GetComponent <Renderer>();
r.material = MaterialManager.GetRankMaterial(rank);
pieces.Add(position, piece);
EventManager.Raise(new UnitPlacedEvent(position, piece));
}
else
{
piece.Destroy();
Destroy(plane);
}
}
}
}
public BoardPosition GetPositionForUnitPiece(UnitPiece piece)
{
BoardPosition position = BoardPosition.OFF_BOARD;
foreach (KeyValuePair <BoardPosition, UnitPiece> pair in pieces)
{
if (pair.Value.Equals(piece))
{
position = pair.Key;
break;
}
}
return(position);
}
public void EndTurn()
{
if (selectedUnit != null)
{
initiativeOrder.Remove(selectedUnit);
initiativeOrder.Add(selectedUnit);
selectedUnit.EndTurn();
if (!actionPerformed)
{
selectedUnit.Effect(Attribute.Energy, 1);
}
selectedUnit = null;
}
hasMoved = false;
actionPerformed = false;
}
private UnitPiece GeneratePiece(UnitRank rank, GameObject plane)
{
UnitPiece piece = new UnitPiece(rank, plane);
if (GameManager.CurrentMode == GameMode.PlayerOneSetup)
{
piece.Owner = GameManager.PlayerOne;
playerOnePlacementUnits[rank] -= 1;
}
else if (GameManager.CurrentMode == GameMode.PlayerTwoSetup)
{
piece.Owner = GameManager.PlayerTwo;
playerTwoPlacementUnits[rank] -= 1;
}
return(piece);
}
public void PerformAction(UnitPiece piece, Action action, Point tile, bool free = false)
{
if (!free)
{
piece.unit.hasActionLeft = false;
}
action.Perform(mapManager, tile);
piece.PerformingAction(action);
piece.Animation(action.type);
if (action.type == ActionType.Attack)
{
Unit target = GetUnit(tile).unit;
if (!target.IsAlive())
{
RemoveUnit(tile);
}
}
}
/*==================================================================
* ROUNDS
* ================================================================*/
public IEnumerator NewRound(bool firstRound = false)
{
isActive = true;
int index = 0;
while (index < initiativeOrder.Count)
{
UnitPiece piece = initiativeOrder[index];
StartCoroutine(piece.NewRound(mapManager, firstRound));
while (piece.isActive)
{
yield return(null);
}
index++;
}
isActive = false;
}
public void SelectUnit(Point tile, Faction faction)
{
UnitPiece unit = unitGrid[tile.x, tile.y];
// Unit clicked
if (unit != null && unit.unit.hasActionLeft)
{
// Friendly clicked
if (unit.unit.faction == faction && !hasMoved)
{
selectedUnit = unit;
startingTile = tile;
hasMoved = false;
actionPerformed = false;
ShowMovement();
combatManager.UnitSelected(selectedUnit.unit);
}
}
}
/*==================================================================
* UNITS
* ================================================================*/
public void AddUnit(Point position, Unit unitData, Faction faction, int identifier = -1)
{
UnitPiece unit = Instantiate(unitPrefab, transform);
unit.identifier = identifier;
unit.SetUnit(unitData);
unit.unit.faction = faction;
unitGrid[position.x, position.y] = unit;
if (faction == Faction.Player)
{
army.Add(unit);
}
else
{
unit.spriteRenderer.flipX = true;
monsters.Add(unit);
}
initiativeOrder.Add(unit);
unit.MoveTo(mapManager, position, -1);
}
public void WalkTo(Point tile, Faction faction, float speed = 3f)
{
if (PerformAction(tile))
{
return;
}
if (hasMoved)
{
return;
}
UnitPiece unit = unitGrid[tile.x, tile.y];
// Already selected unit clicked
if (selectedUnit == unit)
{
UnselectUnit();
}
else if (unit == null)
{
foreach (Point move in moves)
{
if (move == tile)
{
hasMoved = true;
Move(selectedUnit, tile);
selectedUnit.MoveTo(mapManager, move, speed);
mapManager.RemoveMarkings();
combatManager.MoveDone();
}
}
}
else if (unit.unit.faction == faction)
{
SelectUnit(tile, faction);
}
}
public void HandleBattle(UnitPiece attacker, BoardPosition attackerPosition, UnitPiece defender, BoardPosition defenderPosition)
{
BattleResult result = UnitUtilities.ResolveBattle(attacker.Rank, defender.Rank);
// Based on result, update players
switch (result)
{
case BattleResult.Success:
{
// Remove from defender owner
defender.Owner.Pieces.Remove(defender);
break;
}
case BattleResult.Fail:
{
// Remove from attacker owner
attacker.Owner.Pieces.Remove(attacker);
break;
}
case BattleResult.Split:
{
//Remove both
attacker.Owner.Pieces.Remove(attacker);
defender.Owner.Pieces.Remove(defender);
break;
}
default:
{
break;
}
}
EventManager.Raise(new UnitBattleResultEvent(attacker, defender, attackerPosition, defenderPosition, result));
turnComplete = true;
}
private void ValidateNextPosition(BoardPosition position)
{
bool add = false;
bool exists = BoardManager.PositionExists(position);
if (exists)
{
UnitPiece existing = UnitManager.GetUnitPieceForPosition(position);
if (!existing.Equals(UnitPiece.UNKNOWN))
{
bool owner = false;
if (GameManager.CurrentMode.Equals(GameMode.PlayerOne))
{
owner = existing.Owner.Equals(GameManager.PlayerOne);
}
else if (GameManager.CurrentMode.Equals(GameMode.PlayerTwo))
{
owner = existing.Owner.Equals(GameManager.PlayerTwo);
}
if (!owner)
{
//We're not the owner
add = true;
}
}
else
{
// Unoccupied space
add = true;
}
}
if (add)
{
validPositions.Add(position);
}
}
public void SetUnit(UnitPiece piece)
{
gameObject.SetActive(true);
//unitImage = image;
}
public UnitSelectedEvent(UnitPiece unit)
: base(unit)
{
}
public UnitRemovedEvent(BoardPosition position, UnitPiece unit) : base(unit)
{
this.position = position;
}
void selectEnemyUnit()
{
if (Input.GetMouseButtonDown (1) || Input.GetMouseButtonDown(0)) {
if (originRaycast.collider != null && originRaycast.collider.CompareTag ("UnitPiece")) {
if (originRaycast.collider.gameObject.GetComponent<UnitPiece>().ownership.Equals(GameManager.opposingPlayer)) {
selectedEnemy = originRaycast.collider.gameObject.GetComponent<UnitPiece> ();
if (checkAdjacentRaycast(selectedUnit.transform.position, selectedEnemy.transform.position)) {
selectedEnemy.GetComponent<SpriteRenderer> ().material = selectedMaterial;
enemySelected = true;
} else {
selectedEnemy = null;
}
}
}
}
}
public void Move(UnitPiece unit, Point tile)
{
unitGrid[unit.unit.position.x, unit.unit.position.y] = null;
unitGrid[tile.x, tile.y] = unit;
}
//text for the score
void OnGUI()
{
Vector3 pos = new Vector3(0, 75);
float buttonWidth = 150f;
float buttonHeight = 25f;
GUI.Box (new Rect (0, 25, buttonWidth, buttonHeight), "TURN: " + GameManager.currentPlayer.ToString());
//make 4 buttons
//make methods to toggle visiblity
if (unitSelected) {
GUI.Box (new Rect (pos.x, pos.y - 25, buttonWidth, buttonHeight), "HEALTH: " + selectedUnit.unitSize);
if (curUnitState == UnitState.Start) {
if (GUI.Button (new Rect (pos.x, pos.y, buttonWidth, buttonHeight), "Start Move")) {
curUnitState = UnitState.Move;
}
if (GUI.Button (new Rect (pos.x, pos.y + 25, buttonWidth, buttonHeight), "Cancel")) {
unitSelected = false;
selectedUnit.GetComponent<SpriteRenderer> ().material = defaultMaterial;
selectedUnit = null;
}
}
if (curUnitState == UnitState.Move) {
if (GUI.Button (new Rect (pos.x, pos.y + 25, buttonWidth, buttonHeight), "Next: Attack")) {
curUnitState = UnitState.Attack;
}
if (tileSelected) {
if (GUI.Button (new Rect (pos.x, pos.y, buttonWidth, buttonHeight), "Confirm")) {
selectedUnit.transform.position = new Vector3(selectedTile.transform.position.x, selectedTile.transform.position.y, selectedUnit.transform.position.z);
curUnitState = UnitState.Attack;
toggleTile();
}
} else {
GUI.Box (new Rect (pos.x, pos.y, buttonWidth, buttonHeight), "Select tile to move to");
}
}
if (curUnitState == UnitState.Attack) {
if (GUI.Button (new Rect (pos.x, pos.y + 25, buttonWidth, buttonHeight), "Next: End")) {
curUnitState = UnitState.End;
}
if (enemySelected) {
if (GUI.Button (new Rect (pos.x, pos.y, buttonWidth, buttonHeight), "Confirm")) {
selectedEnemy.unitSize -= 5;
curUnitState = UnitState.End;
toggleEnemy();
}
} else {
GUI.Box (new Rect (pos.x, pos.y, buttonWidth, buttonHeight), "Select enemy to attack");
}
}
if (curUnitState == UnitState.End) {
if (GUI.Button (new Rect (pos.x, pos.y, buttonWidth, buttonHeight), "End Unit Turn")) {
reset ();
}
}
}
if (GUI.Button (new Rect(0, 0, buttonWidth, buttonHeight), "End Turn")) {
switchTurn();
GameManager.updateUnits();
GameManager.updateFactories();
}
/*
if (unitSelected) {
GUI.Label (new Rect (pos.x, pos.y - 25, 100, 100), "Health: " + selectedUnit.unitSize);
if (GUI.Button (new Rect(pos.x, pos.y + 50, Screen.width/4, Screen.height/20), "Cancel")) {
//print ("Clicked End Game");
//selectedUnit.finishedAttack = true;
movementPhase = false;
attackPhase = false;
unitSelected = false;
tileSelected = false;
startPhase = true;
selectedUnit.GetComponent<SpriteRenderer>().material = defaultMaterial;
//selectedTile.GetComponent<SpriteRenderer>().material = defaultMaterial;
}
if (!selectedUnit.finishedMovement) {
if (GUI.Button (new Rect(pos.x, pos.y, Screen.width/4, Screen.height/20),"Start Move")) {
movementPhase = true;
unitSelected = false;
startPhase = false;
attackPhase = true;
selectedUnit.finishedMovement = true;
}
}
if (!selectedUnit.finishedAttack) {
if (GUI.Button (new Rect(pos.x, pos.y + 25, Screen.width/4, Screen.height/20),"Start Attack")) {
movementPhase = false;
unitSelected = false;
startPhase = false;
attackPhase = true;
selectedUnit.finishedAttack = true;
}
}
}
if (attackPhase) {
if (selectedEnemy != null && checkAdjacentRaycast (selectedUnit.transform.position, selectedEnemy.transform.position)) {
if (GUI.Button (new Rect(pos.x, pos.y, Screen.width/4, Screen.height/20), "Execute")) {
//print ("Clicked End Game");
selectedUnit.finishedAttack = true;
movementPhase = false;
unitSelected = false;
tileSelected = false;
attackPhase = false;
startPhase = true;
selectedEnemy.GetComponent<SpriteRenderer>().material = defaultMaterial;
selectedUnit.GetComponent<SpriteRenderer>().material = defaultMaterial;
if (selectedEnemy != null) {
Debug.Log("KILLL MEEEE PLS");
selectedEnemy.unitSize -= selectedUnit.unitSize / 2;
}
}
}
if (GUI.Button (new Rect(pos.x, pos.y + 50, Screen.width/4, Screen.height/20), "Cancel")) {
//print ("Clicked End Game");
//selectedUnit.finishedAttack = true;
movementPhase = false;
attackPhase = true;
unitSelected = false;
tileSelected = false;
startPhase = true;
selectedUnit.GetComponent<SpriteRenderer>().material = defaultMaterial;
selectedTile.GetComponent<SpriteRenderer>().material = defaultMaterial;
}
}
if (movementPhase) {
if (tileSelected) {
if (GUI.Button (new Rect(pos.x, pos.y, Screen.width/4, Screen.height/20), "Execute")) {
//print ("Clicked End Game");
selectedUnit.finishedMovement = true;
movementPhase = false;
unitSelected = false;
tileSelected = false;
startPhase = true;
selectedUnit.GetComponent<SpriteRenderer>().material = defaultMaterial;
selectedTile.GetComponent<SpriteRenderer>().material = defaultMaterial;
selectedUnit.transform.position = new Vector3(selectedTile.transform.position.x, selectedTile.transform.position.y, selectedUnit.transform.position.z);
}
if (GUI.Button (new Rect(pos.x, pos.y + 50, Screen.width/4, Screen.height/20), "Cancel")) {
//print ("Clicked End Game");
//selectedUnit.finishedMovement = true;
movementPhase = true;
attackPhase = false;
unitSelected = false;
tileSelected = false;
startPhase = true;
selectedUnit.GetComponent<SpriteRenderer>().material = defaultMaterial;
selectedTile.GetComponent<SpriteRenderer>().material = defaultMaterial;
}
}
if (GUI.Button (new Rect(pos.x, pos.y + 50, Screen.width/4, Screen.height/20), "Cancel")) {
//print ("Clicked End Game");
//selectedUnit.finishedMovement = true;
movementPhase = true;
attackPhase = false;
unitSelected = false;
tileSelected = false;
startPhase = true;
selectedUnit.GetComponent<SpriteRenderer>().material = defaultMaterial;
selectedTile.GetComponent<SpriteRenderer>().material = defaultMaterial;
}
}
*/
}
//Fires a raycast from the mouse and returns data from any object it collides with.
void rayCastCheck()
{
mousePos = Camera.main.ScreenToWorldPoint (Input.mousePosition);
Debug.DrawRay (new Vector3(mousePos.x, mousePos.y, -5), new Vector3 (0, 0, -1));
if (Input.GetMouseButton (0) || Input.GetMouseButton(1)) {
originRaycast = Physics2D.Raycast (new Vector3 (mousePos.x, mousePos.y, 0), new Vector3 (0, 0, -1), rayCastScale, layerMask);
//northRaycast = Physics2D.Raycast (new Vector3 (mousePos.x, mousePos.y + 1, 0), new Vector3 (0, 0, -1), rayCastScale, layerMask);
//southRaycast = Physics2D.Raycast (new Vector3 (mousePos.x, mousePos.y - 1, 0), new Vector3 (0, 0, -1), rayCastScale, layerMask);
//westRaycast = Physics2D.Raycast (new Vector3 (mousePos.x - 1, mousePos.y, 0), new Vector3 (0, 0, -1), rayCastScale, layerMask);
//eastRaycast = Physics2D.Raycast (new Vector3 (mousePos.x + 1, mousePos.y, 0), new Vector3 (0, 0, -1), rayCastScale, layerMask);
}
if (originRaycast.collider != null && originRaycast.collider.CompareTag ("Tile")) {
selectedTile = originRaycast.collider.gameObject.GetComponent<Tile> ();
}
if (originRaycast.collider != null && originRaycast.collider.CompareTag ("UnitPiece") && !unitSelected) {
if (originRaycast.collider.gameObject.GetComponent<UnitPiece>().ownership.Equals(GameManager.currentPlayer)) {
selectedUnit = originRaycast.collider.gameObject.GetComponent<UnitPiece> ();
}
}
}
public void AddUnit(UnitPiece unit)
{
unitsToAdd.Add(unit);
}
private void HandleGame(RaycastHit[] hits, bool selectable, BoardPosition position, UnitPiece unit, Vector3 tileVector)
{
if (Input.GetMouseButtonDown(0))
{
if (hits.Length == 0)
{
highlightCube.SetActive(false);
previous = position;
}
else if (selectable && !unit.Equals(UnitPiece.UNKNOWN))
{
//We've selected a unit
//Check if we're the owner
bool owner = false;
if (GameManager.CurrentMode.Equals(GameMode.PlayerOne))
{
owner = unit.Owner.Equals(GameManager.PlayerOne);
}
else if (GameManager.CurrentMode.Equals(GameMode.PlayerTwo))
{
owner = unit.Owner.Equals(GameManager.PlayerTwo);
}
if (owner)
{
//If the previous position was off the board, this is our first selection
if (previous.Equals(BoardPosition.OFF_BOARD))
{
previous = position;
MoveHighlight(tileVector);
//Determine what the valid next positions are
ClearValid();
//Add current position, for deselection
validPositions.Add(position);
ValidateNextPosition(new BoardPosition(position.X - 1, position.Y));
ValidateNextPosition(new BoardPosition(position.X, position.Y - 1));
ValidateNextPosition(new BoardPosition(position.X + 1, position.Y));
ValidateNextPosition(new BoardPosition(position.X, position.Y + 1));
MoveValid();
}
else if (previous.Equals(position))
{
//We selected the same space, deselect
previous = BoardPosition.OFF_BOARD;
highlightCube.SetActive(false);
ClearValid();
}
}
else if (validPositions.Contains(position))
{
//If our previous position contains a piece that we own, then we should do battle
UnitPiece previousPiece = UnitManager.GetUnitPieceForPosition(previous);
if (!previousPiece.Equals(UnitPiece.UNKNOWN))
{
bool previousOwner = false;
if (GameManager.CurrentMode.Equals(GameMode.PlayerOne))
{
previousOwner = previousPiece.Owner.Equals(GameManager.PlayerOne);
}
else if (GameManager.CurrentMode.Equals(GameMode.PlayerTwo))
{
previousOwner = previousPiece.Owner.Equals(GameManager.PlayerTwo);
}
if (previousOwner)
{
// instigate attack, with previous piece as attacker and current piece as defender
GameManager.HandleBattle(previousPiece, previous, unit, position);
previous = BoardPosition.OFF_BOARD;
highlightCube.SetActive(false);
ClearValid();
}
}
}
}
else if (selectable && !position.Equals(BoardPosition.OFF_BOARD) && !previous.Equals(BoardPosition.OFF_BOARD))
{
//We've selected a place not off the board, the previous position was not off the board either, but there is no piece occupying the space
if(validPositions.Contains(position))
{
//Move the piece
UnitManager.MovePiece(previous, position);
ClearValid();
highlightCube.SetActive(false);
action = true;
}
}
}
else if (Input.GetMouseButtonDown(1))
{
//Just clear selection
previous = BoardPosition.OFF_BOARD;
highlightCube.SetActive(false);
ClearValid();
}
}
private void HandleSetup(RaycastHit[] hits, bool selectable, BoardPosition position, UnitPiece unit, Vector3 tileVector)
{
//Handle mouse click
if (Input.GetMouseButtonDown(0))
{
if (hits.Length == 0)
{
highlightCube.SetActive(false);
}
else if (selectable && !placementRank.Equals(UnitRank.Unknown))
{
UnitManager.AddPiece(position, placementRank);
}
}
else if (Input.GetMouseButtonDown(1))
{
//Remove existing piece
if (!unit.Rank.Equals(UnitRank.Unknown))
{
UnitManager.RemovePiece(position);
}
}
}
public BoardPosition GetPositionForUnitPiece(UnitPiece piece)
{
BoardPosition position = BoardPosition.OFF_BOARD;
foreach (KeyValuePair<BoardPosition, UnitPiece> pair in pieces)
{
if (pair.Value.Equals(piece))
{
position = pair.Key;
break;
}
}
return position;
}
public UnitRemovedEvent(BoardPosition position, UnitPiece unit)
: base(unit)
{
this.position = position;
}
private UnitPiece GeneratePiece(UnitRank rank, GameObject plane)
{
UnitPiece piece = new UnitPiece(rank, plane);
if (GameManager.CurrentMode == GameMode.PlayerOneSetup)
{
piece.Owner = GameManager.PlayerOne;
playerOnePlacementUnits[rank] -= 1;
}
else if (GameManager.CurrentMode == GameMode.PlayerTwoSetup)
{
piece.Owner = GameManager.PlayerTwo;
playerTwoPlacementUnits[rank] -= 1;
}
return piece;
}
public void PerformTurn()
{
// Debug.Log("AI Move");
// Collect units
List <UnitPiece> army = unitManager.army;
List <UnitPiece> monsters = unitManager.monsters;
UnitPiece best = null;
int bestDistance = int.MaxValue;
Point bestMove = new Point();
bool adjacent = false;
foreach (UnitPiece monster in monsters)
{
if (!monster.unit.hasActionLeft)
{
continue;
}
foreach (UnitPiece soldier in army)
{
int d = Mathf.Abs(monster.unit.position.x - soldier.unit.position.x) + Mathf.Abs(monster.unit.position.y - soldier.unit.position.y);
if (d == 1)
{
best = monster;
adjacent = true;
bestDistance = 1;
break;
}
}
if (adjacent)
{
break;
}
Point closest = new Point();
int distance = int.MaxValue;
foreach (Point point in monster.GetMoves(map))
{
foreach (UnitPiece soldier in army)
{
int d = Mathf.Abs(point.x - soldier.unit.position.x) + Mathf.Abs(point.y - soldier.unit.position.y) + point.z;
if (d < distance)
{
distance = d;
closest = point;
}
}
}
if (distance < bestDistance)
{
bestDistance = distance;
bestMove = closest;
best = monster;
}
}
map.unitManager.SelectUnit(best.unit.position, Faction.Monster);
if (!adjacent)
{
map.unitManager.WalkTo(bestMove, Faction.Monster);
}
else
{
PerformAction();
}
}
public UnitMovedEvent(BoardPosition from, BoardPosition to, UnitPiece piece)
: base(piece)
{
this.from = from;
this.to = to;
}
public UnitEvent(UnitPiece unit)
{
this.unit = unit;
}
