public override void ExecuteCard()
{
damageDir = GameMaster.Instance.GetRandomDirection();
GameMaster.Instance.currentPlayer.character.Turn(damageDir);
GameMaster.Instance.currentPlayer.character.ExecuteActions();
base.ExecuteCard();
}
public override Dictionary <MapSquare, MapSquare.Interactable> GetValidInputSquares()
{
inputSquares.Clear();
inputOptionFacings.Clear();
CheckTowingStatus();
Tools.Facing[] possibleFacings;
if (doneMoves == 0)
{
possibleFacings = new Tools.Facing[] { Tools.Facing.Left, Tools.Facing.Right, Tools.Facing.Forward }
}
;
else
{
possibleFacings = new Tools.Facing[] { moveFacing }
};
foreach (Tools.Facing facing in possibleFacings)
{
Tools.Direction moveDir = Tools.GetDirectionFromFacing(facing, startFacingDirection);
foreach (KeyValuePair <MapSquare, MapSquare.Interactable> kvp in GetInputsForOneDirection(moveDir))
{
inputSquares.Add(kvp.Key, kvp.Value);
inputOptionFacings.Add(kvp.Key, facing);
}
}
return(inputSquares);
}
public override void IsCollided(Unit collidingUnit, Tools.Direction collisionDirection)
{
if (collidingUnit is Champion)
{
collidingUnit.GetComponent <Champion>().PickUpCrystal(this);
}
}
public virtual void MoveToSquare(Unit movingUnit, Tools.Direction direction)
{
if (unit)
{
movingUnit.Collide(unit, direction);
unit.IsCollided(movingUnit, direction);
}
}
public bool HasNeighbour(Tools.Direction direction)
{
if (neighbours.ContainsKey(direction))
{
return(true);
}
return(false);
}
public virtual void InitializeCardExecution(Unit executingUnit)
{
cardState = CardState.RequiresInput;
unit = executingUnit;
startSquare = executingUnit.mapSquare;
startFacingDirection = executingUnit.facingDirection;
actionsExecuted = false;
}
private void MoveMultiple(Tools.Direction dir)
{
Player.Move(dir);
Player.Move(dir);
Player.Move(dir);
Player.ExecuteActions();
StartCoroutine(DisableInput());
}
public override void MoveToSquare(Unit unit, Tools.Direction direction)
{
base.MoveToSquare(unit, direction);
if (unit is IRepairable)
{
(unit as IRepairable).RepairUnit();
}
}
public virtual void ChangeSquare(MapSquare newSquare, Tools.Direction moveDirection)
{
newSquare.MoveToSquare(this, moveDirection);
mapSquare.unit = null;
mapSquare = newSquare;
newSquare.unit = this;
}
public override void Collide(Unit collisionTarget, Tools.Direction collisionDirection)
{
base.Collide(collisionTarget, collisionDirection);
if (collisionTarget is Minion)
{
TakeDamage();
}
}
private void MoveAndRotate(Tools.Direction dir1, Tools.Direction dir2, Tools.Direction dir3)
{
Player.Move(dir1);
Player.Turn(dir2);
Player.Move(dir3);
Player.ExecuteActions();
StartCoroutine(DisableInput());
}
public Tools.Direction GetRandomDirection()
{
// NOTE: Could change this to roll a color and get direction from compass for scenario specific differences
Tools.Direction[] dirOptions = new Tools.Direction[] { Tools.Direction.North, Tools.Direction.South, Tools.Direction.East, Tools.Direction.West };
Tools.Direction randomDir = dirOptions[Random.Range(0, 4)];
// TODO: Add UI functionality
return(randomDir);
}
public override void MoveToSquare(Unit movingUnit, Tools.Direction direction)
{
if (movingUnit is Minion && damageMinions)
{
movingUnit.TakeDamage();
GameMaster.Instance.scenario.MinionReachedSchool();
}
base.MoveToSquare(movingUnit, direction);
}
public override void ExecuteCard()
{
damageDir = GameMaster.Instance.GetRandomDirection();
for (int i = 0; i < 2; i++)
{
GameMaster.Instance.currentPlayer.character.Move(damageDir);
}
GameMaster.Instance.currentPlayer.character.ExecuteActions();
base.ExecuteCard();
}
public virtual void IsCollided(Unit collidingUnit, Tools.Direction collisionDirection)
{
Debug.Log(name + " got collided by " + collidingUnit.name);
if (canBePushed && collidingUnit.canPush)
{
mapSquare.unit = collidingUnit;
Move(collisionDirection);
ExecuteActions();
}
}
public MapSquare GetNeighbour(Tools.Direction direction)
{
if (neighbours.ContainsKey(direction))
{
return(neighbours[direction]);
}
else
{
return(null);
}
}
public virtual void AttemptMove(Tools.Direction direction)
{
if (CanMove(direction))
{
ChangeSquare(mapSquare.GetNeighbour(direction), direction);
}
else
{
mapSquare.GetNeighbour(direction).FailedEnteringSquare(this);
}
}
public override void IsCollided(Unit collidingUnit, Tools.Direction collisionDirection)
{
base.IsCollided(collidingUnit, collisionDirection);
TakeDamage(Tools.Color.None);
// Implementation for Skewer card. Optimally should be in the Skewer script itself.
if (GameMaster.Instance.cardBeingExecuted != null && (GameMaster.Instance.cardBeingExecuted is Skewer))
{
(GameMaster.Instance.cardBeingExecuted as Skewer).hasMinionToken = true;
}
}
public override bool CanBeReplaced(Unit replacingUnit, Tools.Direction direction)
{
if (replacingUnit is Minion)
{
return(false);
}
else if (replacingUnit is Champion || replacingUnit is Bomb)
{
return(CanMove(direction));
}
return(true);
}
public KeyValuePair <Tools.Direction, MapSquare> CheckNeighbourState(MapSquare origin, MapSquare other)
{
// If squares are not neighbours or they are the same one, return a none value.
float distance = Vector3.Distance(origin.transform.position, other.transform.position);
if (distance > 1.7f || distance < 0.9f)
{
return(new KeyValuePair <Tools.Direction, MapSquare>(Tools.Direction.None, other));
}
Tools.Direction dir = Tools.GetDirection(origin, other);
return(new KeyValuePair <Tools.Direction, MapSquare>(dir, other));
}
public override void MoveMinions()
{
Stack <KeyValuePair <Unit, Tools.Direction> > minionMoves = new Stack <KeyValuePair <Unit, Tools.Direction> >();
Tools.Direction[] directions = { Tools.Direction.East, Tools.Direction.North, Tools.Direction.South, Tools.Direction.West };
Tools.Direction moveDirection = directions[Random.Range(0, directions.Length)];
// Sort minionsList by a custom function
foreach (Unit minion in GameMaster.Instance.gearTracker.minionsList)
{
if (minion is Minion)
{
minionMoves.Push(new KeyValuePair <Unit, Tools.Direction>(minion, moveDirection));
}
}
GameMaster.Instance.MoveMinions(minionMoves);
}
public override void Input(MapSquare inputSquare)
{
MapSquare temp = unit.mapSquare;
Tools.Direction moveDirection = Tools.GetDirectionFromFacing(moveFacing, startFacingDirection);
while (temp != inputSquare)
{
if (unit.CanMove(moveDirection))
{
doneMoves++;
}
else
{
doneMoves = minMaxMoves.Item2;
}
temp = temp.GetNeighbour(moveDirection);
actions.Push(new MoveAction(unit, moveDirection));
}
}
protected Dictionary <MapSquare, MapSquare.Interactable> GetInputsForOneDirection(Tools.Direction targetDirection)
{
Dictionary <MapSquare, MapSquare.Interactable> directionInputSquares = new Dictionary <MapSquare, MapSquare.Interactable>();
MapSquare temp = unit.mapSquare.GetNeighbour(targetDirection);
encounteredUntenterableSquare = false;
for (int i = 1; i <= minMaxMoves.Item2 - doneMoves; i++)
{
if (temp != null)
{
if (encounteredUntenterableSquare)
{
directionInputSquares.Add(temp, MapSquare.Interactable.InactiveChoice);
}
else if (i + doneMoves < minMaxMoves.Item1)
{
directionInputSquares.Add(temp, MapSquare.Interactable.NonfinalChoice);
}
else if (i + doneMoves <= minMaxMoves.Item2)
{
directionInputSquares.Add(temp, MapSquare.Interactable.ActiveChoice);
if (!temp.CanEnterSquare(unit, targetDirection))
{
encounteredUntenterableSquare = true;
}
}
temp = temp.GetNeighbour(targetDirection);
}
else
{
break;
}
}
return(directionInputSquares);
}
public TurnAction(Unit targetUnit, Tools.Direction direction)
{
goalDirection = direction;
goalRotation = Tools.GetRotation(goalDirection);
unit = targetUnit;
}
public void SpawnChampion(MapSquare square, Tools.Direction facing)
{
character = GameMaster.Instance.SpawnUnit(Prefabs.Instance.genericChampion, square) as Champion;
character.facingDirection = facing;
character.model.transform.eulerAngles = Tools.GetRotation(facing);
}
public override void Collide(Unit collidingUnit, Tools.Direction collisionDirection)
{
// Handle whatever happens to this unit
}
public override void IsCollided(Unit collidingUnit, Tools.Direction collisionDirection)
{
base.IsCollided(collidingUnit, collisionDirection);
TakeDamage(Tools.Color.None);
}
public override bool CanBeReplaced(Unit replacingUnit, Tools.Direction direction)
{
return(true);
}
public TurnAction(Unit targetUnit, Tools.Facing facing)
{
goalDirection = Tools.GetDirectionFromFacing(facing, unit.facingDirection);
goalRotation = Tools.GetRotation(goalDirection);
unit = targetUnit;
}
private void Rotate(Tools.Direction dir)
{
Player.Turn(dir);
Player.ExecuteActions();
StartCoroutine(DisableInput());
}
