/// <summary>
/// Switch on the UI element indicating where a given defender should move, or switch it off when the defender arrives.
/// </summary>
/// <param name="defender">The moving defender, or null if all notices should be off.</param>
private void ToggleMoveNotice(DefenderSandbox defender, Indicate startOrStop)
{
if (defender == null)
{
foreach (GameObject notice in moveNotices)
{
notice.SetActive(false);
}
return;
}
bool newState = startOrStop == Indicate.Start ? true : false;
switch (defender.gameObject.name)
{
case RANGER:
rangerNotice.SetActive(newState);
break;
case GUARDIAN:
guardianNotice.SetActive(newState);
break;
case BRAWLER:
brawlerNotice.SetActive(newState);
break;
}
}
/// <summary>
/// Selects a defender for movement or attacking. Players cannot select a new defender while one is in the middle of a move.
/// </summary>
/// <param name="selected">The selected defender.</param>
public void SelectDefenderForMovement(DefenderSandbox selected)
{
//this is no longer a concern with dragging movement--the player should be able to re-select a defender after an undone move
//if (selected.Selected) return; //if the player is re-selecting the already-selected defender, do nothing
//if a defender is in the middle of a move, stop
foreach (DefenderSandbox defender in defenders)
{
if (defender.IsMoving())
{
return;
}
}
//de-select everyone
foreach (DefenderSandbox defender in defenders)
{
defender.BeUnselected();
}
//select the chosen defender
selectedDefender = selected;
selected.BeSelectedForMovement();
}
/// <summary>
/// When a defender finishes with the current phase, it adds itself to this list
/// </summary>
/// <param name="defender">Defender.</param>
public void DeclareSelfDone(DefenderSandbox defender)
{
if (!doneDefenders.Contains(defender))
{
doneDefenders.Add(defender);
}
}
//constructor
public DefenderData(DefenderSandbox defender)
{
Defender = defender;
//default initializations; these are nonsense values that can be used for error checking
Loc = new TwoDLoc(-1, -1);
Movement = -1;
}
/////////////////////////////////////////////
/// Functions
/////////////////////////////////////////////
//constructor
public SelectIconMoveTask(DefenderSandbox defender)
{
this.defender = defender;
selectableIcon = this.defender.transform.Find(PRIVATE_UI_CANVAS).Find(SELECTABLE_ICON_OBJ);
Services.Events.Register <NotSelectableEvent>(ListenForDefenderDone);
Services.Events.Register <PhaseStartEvent>(ListenForCombatEnd);
}
/// <summary>
/// Select a defender in the fight phase
/// </summary>
/// <param name="selected">The chosen defender.</param>
public void SelectDefenderForFight(DefenderSandbox selected)
{
//de-select everyone
foreach (DefenderSandbox defender in defenders)
{
defender.BeUnselected();
}
selectedDefender = selected;
selected.BeSelectedForFight();
}
/// <summary>
/// Remove an upgrading defender from the list of defenders who need to upgrade. If that was the last defender who needed to upgrade,
/// move on.
/// </summary>
/// <param name="defender">The defender who upgraded.</param>
public void CheckForAllFinished(DefenderSandbox defender)
{
Debug.Assert(upgraders.Contains(defender), "Trying to remove a defender who doesn't need to upgrade.");
upgraders.Remove(defender);
if (upgraders.Count <= 0)
{
Services.Events.Unregister <TutorialPowerChoiceEvent>(HandlePowerChoice);
Services.Defenders.NoSelectedDefender();
}
}
/// <summary>
/// Remove an upgrading defender from the list of defenders who need to upgrade. If that was the last defender who needed to upgrade,
/// move on.
/// </summary>
/// <param name="defender">The defender who upgraded.</param>
public void CheckForAllFinished(DefenderSandbox defender)
{
Debug.Assert(upgraders.Contains(defender), "Trying to remove a defender who doesn't need to upgrade.");
upgraders.Remove(defender);
if (upgraders.Count <= 0)
{
//unregister here rather than in OnExit because there may not have been a registration if no defender needed to upgrade
Services.Events.Unregister <PowerChoiceEvent>(HandlePowerChoice);
Services.Defenders.NoSelectedDefender();
}
}
/// <summary>
/// Defenders call this when they fight to explain the result of the combat.
/// </summary>
/// <param name="playerValue">The value of the player's card.</param>
/// <param name="defender">The defender's script.</param>
/// <param name="attackerMod">The attacker's attacker modifier.</param>
/// <param name="attackerArmor">The attacker's armor.</param>
/// <param name="attackerValue">The value of the attacker's card.</param>
/// <param name="damage">The damage inflicted. If none, any value is fine; this will be discarded.</param>
public void ExplainCombat(int playerValue, DefenderSandbox defender, int defenderMod, AttackerSandbox attacker, int attackerValue, int attackerMod, int damage)
{
string YOU_MSG = "You played a ";
string BONUS_MSG = ", plus a bonus of ";
string ATK_MSG = "I played a ";
string YOU_WIN_MSG = "You beat me by ";
string I_WIN_MSG = "You didn't beat me, so I won.";
string ARMOR_MSG = "My armor of ";
string REDUCE_MSG = " reduces the damage.";
string TAKE_DAMAGE_MSG = "My piece takes ";
string DAMAGE_MSG = " damage, and has ";
string HEALTH_MSG = " health left.";
string PERIOD = ".";
string NEWLINE = "\n";
int defenderTotal = playerValue + defenderMod;
int attackerTotal = attackerValue + attackerMod;
string explanation = YOU_MSG + playerValue.ToString() + BONUS_MSG + defenderMod.ToString() + PERIOD + NEWLINE +
ATK_MSG + attackerValue.ToString() + BONUS_MSG + attackerMod.ToString() + PERIOD + NEWLINE;
if (defenderTotal > attackerTotal)
{
explanation += YOU_WIN_MSG + (defenderTotal - attackerTotal).ToString() + PERIOD + NEWLINE;
if (attacker.Armor > 0)
{
explanation += ARMOR_MSG + attacker.Armor + REDUCE_MSG + NEWLINE;
}
//calculate what the attacker's health is now; don't rely on the attacker having updated information, since
//all of this is happening in the same frame
int newHealth = attacker.Health - ((playerValue + defenderMod) - (attackerValue + attackerMod + attacker.Armor));
newHealth = newHealth < 0 ? 0 : newHealth; //don't let newHealth be less than zero
explanation += TAKE_DAMAGE_MSG + damage.ToString() + DAMAGE_MSG + newHealth + HEALTH_MSG;
}
else
{
explanation += I_WIN_MSG;
}
OpponentStatement(explanation);
}
/////////////////////////////////////////////
/// Functions
/////////////////////////////////////////////
//constructor
public CombatExplanationTask(AttackerSandbox attacker,
DefenderSandbox defender,
int attackerValue,
int defenderValue,
int attackerMod,
int defenderMod,
int damage)
{
attackerScript = attacker;
defenderScript = defender;
int index = 0;
index = attacker.gameObject.name.IndexOf(AttackerManager.DIVIDER);
attackerName = attacker.gameObject.name.Substring(0, index);
defenderName = defender.gameObject.name;
this.attackerValue = attackerValue;
this.defenderValue = defenderValue;
this.attackerMod = attackerMod;
this.defenderMod = defenderMod;
this.damage = damage;
}
/////////////////////////////////////////////
/// Functions
/////////////////////////////////////////////
//constructor
public ChooseToDefeatTask(DefenderSandbox defender, AttackerTypes attackerType)
{
this.defender = defender;
this.attackerType = attackerType;
}
/////////////////////////////////////////////
/// Functions
/////////////////////////////////////////////
//constructor
public PowerChoiceEvent(DefenderSandbox defender, int tree)
{
this.defender = defender;
this.tree = tree;
}
/////////////////////////////////////////////
/// Functions
/////////////////////////////////////////////
//constructor
public TeleportDefenderTask(DefenderSandbox defender, PossibleDestinations destination)
{
this.defender = defender;
this.destination = destination;
}
/////////////////////////////////////////////
/// Functions
/////////////////////////////////////////////
//constructor
public DelayedUpgradeTask(DefenderSandbox defender)
{
this.defender = defender;
}
/// <summary>
/// Get a defender's location for an undo.
/// </summary>
/// <returns>The defender's location.</returns>
/// <param name="defender">The defender.</param>
public TwoDLoc GetDefenderLoc(DefenderSandbox defender)
{
return(defenders[defender].Loc);
}
/// <summary>
/// Get a defender's available movement for an undo.
/// </summary>
/// <returns>The defender's movement.</returns>
/// <param name="defender">The defender.</param>
public int GetDefenderMovement(DefenderSandbox defender)
{
return(defenders[defender].Movement);
}
//put a new defender into the dictionary
public void AddDefender(DefenderSandbox defender)
{
defenders.Add(defender, new DefenderData(defender));
}
/// <summary>
/// Changes the information associated with a defender.
/// </summary>
/// <param name="defender">The defender.</param>
/// <param name="loc">The defender's current location.</param>
/// <param name="movement">The defender's movement available.</param>
public void ReviseDefenderState(DefenderSandbox defender, TwoDLoc loc)
{
defenders[defender].Loc = new TwoDLoc(loc.x, loc.z);
}
/////////////////////////////////////////////
/// Functions
/////////////////////////////////////////////
//constructor
public ResetHandTask(DefenderSandbox defender)
{
this.defender = defender;
}
/////////////////////////////////////////////
/// Functions
/////////////////////////////////////////////
//constructor
public DamageRemotelyTask(TwoDLoc loc, int damage, DefenderSandbox defender)
{
this.loc = loc;
this.damage = damage;
this.defender = defender;
}
public NotSelectableEvent(DefenderSandbox defender)
{
this.defender = defender;
}
/// <summary>
/// Reports whether a defender has said it's finished with the current phase.
/// </summary>
/// <returns><c>true</c> if the defender has marked itself done, <c>false</c> otherwise.</returns>
/// <param name="defender">Defender.</param>
public bool IsDone(DefenderSandbox defender)
{
bool temp = (doneDefenders.Contains(defender));
return(temp);
}
private float moveMax = 0.1f; //maximum movement per frame, to translate screen coordinate movement into reasonable-speed world space movement
//operate the unmoving model that stays behind as the defender moves
/////////////////////////////////////////////
/// Functions
/////////////////////////////////////////////
//constructor
public DefenderMoveTask(DefenderSandbox defender)
{
this.defender = defender;
mini = this.defender.transform.Find(MODEL_OBJ);
}
/// <summary>
/// This function sets selectedDefender to null, so that it behaves as expected.
/// </summary>
public void NoSelectedDefender()
{
selectedDefender = null;
}
/// <summary>
/// Selects a defender for upgrading.
///
/// This doesn't do anything with the defender; it just allows the manager to know who's upgrading, so that PowerChoiceEvents
/// know which defender is doing the upgrading.
/// </summary>
/// <param name="selected">The defender who will upgrade.</param>
public void SelectDefenderForUpgrade(DefenderSandbox selected)
{
selectedDefender = selected;
}
