} //Disable
public void WarriorsReturnAbility()
{
hero = GetComponentInParent <HeroManager>();
Player allyPlayer = hero.GetComponentInParent <Player>();
int deadHeroesCount = allyPlayer.deadHeroes.Count;
if (hero.GetComponentInParent <Player>().isActive)
{
if (remainingCooldown == 0)
{
canUseAbility = true;
if (deadHeroesCount > 0)
{
GameObject revivedHero = allyPlayer.deadHeroes[Random.Range(0, deadHeroesCount)];
allyPlayer.deadHeroes.Remove(revivedHero);
HeroManager heroRevived = revivedHero.GetComponent <HeroManager>();
GameManager.Instance.ReviveHero(heroRevived);
heroRevived.maxHealth = 400;
GameManager.Instance.AddBuff("IncreaseAttack", 2, hero, heroRevived);
heroRevived.UpdateUI();
ResetCooldown();
}
} //if cooldown = 0
}
}
} //AddBuff
public void AddBuffComponentRandom(string buffName, int duration, HeroManager source, HeroManager target, int targetCount)
{
List <HeroManager> heroList = new List <HeroManager>();
heroList.AddRange(target.GetComponentInParent <Player>().GetComponentsInChildren <HeroManager>());
List <HeroManager> randomHeroList = RandomHeroList(heroList);
int count = 0;
int heroCounter = 0;
while (count < targetCount && heroCounter < randomHeroList.Count)
{
target = randomHeroList[heroCounter];
if (target.hasAntiBuff)
{
Debug.Log("Target Hero has AntiBuff");
//AddBuff(buffName, duration, source, target);
}
else if (source.hasSilence)
{
Debug.Log("Source Hero has Silence");
//Crippled Strike Implementation
}
else if (IsChanceSuccess(source)) //check for Chance
{
AddBuff(buffName, duration, source, target);
count++;
}
heroCounter++;
}
}
} //Disable Passives
public IEnumerator KillHeroEvent(HeroManager hero)
{
hero.isDead = true;
hero.GetComponentInParent <Player>().DeadHeroes(hero);
hero.gameObject.SetActive(false);
e_HeroKilled();
yield return(null);
}
// void OnEnable(){
// GameManager.Instance.e_PlayerMainPhase += IncreaseDefense;
// //Debug.Log("Subscribed");
// }
public void IncreaseDefense()
{
hero = this.GetComponentInParent <HeroManager>();
//Debug.Log("hero");
if (hero.GetComponentInParent <Player>().isActive&& hero.isSelected)
{
GameManager.Instance.AddBuff("IncreaseDefense", 1, hero, hero);
}
} //Increase Defense
public void DreamyLeaderAbility()
{
hero = gameObject.GetComponentInParent <HeroManager>();
player = hero.GetComponentInParent <Player>();
if (hero.isSelected && player.isActive)
{
List <HeroManager> enemies = GameManager.Instance.EnemyHeroList(hero);
int targetCount = enemies.Count;
if (hero.GetComponentInParent <Player>().isActive)
{
foreach (HeroManager enemy in enemies)
{
//Remove a buff
Buff[] buffs = enemy.GetComponents <Buff>();
if (buffs.Length > 0)
{
Buff buff = buffs[Random.Range(0, buffs.Length)];
//buff.OnDestroy();
Destroy(buff);
//Debug.Log("Buff Destroyeda " +buff +" from hero: " +enemy );
//addstun
if (enemy.hasImmunity || enemy.hasPermanentImmunity)
{
Debug.Log("Has Immunity");
}
else
{
GameManager.Instance.AddDebuff("Stun", 1, hero, enemy);
}
}
}
} //if playerisActive
//base.UseAbility(attacker);
}
}
public void RandomAllyImmunity()
{
hero = this.GetComponentInParent <HeroManager>();
if (hero.GetComponentInParent <Player>().isActive&& hero.isSelected)
{
//Debug.Log("hero");
List <HeroManager> allies = GameManager.Instance.AllyHeroList(hero);
HeroManager randomAlly = allies[Random.Range(0, allies.Count)];
GameManager.Instance.AddBuff("Immunity", 1, hero, randomAlly);
} //if hero is Active
} //RandomAllyImmunity
} //Extra Turn
public void ExtraTurnCheck(HeroManager source)
{
List <HeroManager> extraTurnHeroes = AllyHeroList(source);
if (!isTurnPaused)
{
//NORMAL ROUTE - NO EXTRA TURN
//Resolve frozen heroes from an extra turn
if (extraTurn)
{
foreach (HeroManager extraTurnhero in extraTurnHeroes)
{
//reset hasExtraturn back to normal
extraTurnhero.hasExtraTurn = false;
//Disable access to skills/abilities
extraTurnhero.gameObject.GetComponent <HeroManager>().heroPanel.SetActive(true);
List <Button> skillsButton = extraTurnhero.gameObject.GetComponentInChildren <HeroPanel>().skillsBtn;
for (int i = 0; i < skillsButton.Count; i++)
{
skillsButton[i].interactable = true;
skillsButton[i].GetComponent <Ability>().skillType = extraTurnhero.abilityAssets[i].skillType;
//hero.transform.Find("HeroUI").gameObject.transform.Find("Image").GetComponent<Image>().color = GameManager.Instance.origColor;
}
extraTurnhero.gameObject.GetComponent <HeroManager>().heroPanel.SetActive(false);
//Restore Original Color (grayed-out from Extra Turn)
//hero.transform.Find("HeroUI").gameObject.transform.Find("Image").GetComponent<Image>().color = GameManager.Instance.origColor;
extraTurnhero.transform.Find("HeroUI").gameObject.transform.Find("Image").GetComponent <Image>().color = Color.white;
} //foreach
} //if
//set Extra Turn to false and End the Turn
extraTurn = false;
source.GetComponentInParent <Player>().isEndTurn = true;
EndTurn();
}
else
{
//EXTRA TURN
//Unpause GameManager during Extra Turn
isTurnPaused = false;
}
} //Extra Turn Check
} //CriticalStrike
public void CheckThreat(HeroManager attacker, HeroManager defender)
{
//For Defender
//Check 3 states: 1) No Defender 2) Target has Defender 3) If you're target is an Ally
if (NoThreat(defender.GetComponentInParent <Player>()) || defender.hasThreat || defender.GetComponentInParent <Player>().tag == attacker.GetComponentInParent <Player>().tag)
{
canTargetHero = true;
checkDefender = true;
}
else
{
canTargetHero = false;
checkDefender = false;
Debug.Log("Invalid Target: Attack Defender Only");
}
} //CheckDefender
// void OnEnable(){
// GameManager.Instance.e_PlayerStartPhase += GainKnowledge;
// GetComponentInChildren<Text>().enabled = true;
// Debug.Log("Learn Knowledge Enabled");
// }
// void OnDisable(){
// GameManager.Instance.e_PlayerStartPhase -= GainKnowledge;
// GetComponentInChildren<Text>().enabled = false;
// Debug.Log("Learn Knowledge Disabled");
// }
public void GainKnowledge()
{
hero = this.GetComponentInParent <HeroManager>();
List <HeroManager> allies = GameManager.Instance.AllyHeroList(hero);
List <HeroManager> enemies = GameManager.Instance.EnemyHeroList(hero);
List <HeroManager> heroes = new List <HeroManager>();
heroes.AddRange(allies);
heroes.AddRange(enemies);
//Get all buffs from each Player
if (hero.GetComponentInParent <Player>().isActive&& hero.isSelected)
{
foreach (HeroManager hero1 in heroes)
{
Buff[] buffs1 = hero1.GetComponents <Buff>();
foreach (Buff buff in buffs1)
{
sumKnowledgePoints++;
} //foreach Buff in buffs
} //foreach Hero Manager
if (sumKnowledgePoints == 0)
{
sumKnowledgePoints = 1;
}
knowledgePoints += sumKnowledgePoints;
sumKnowledgePoints = 0;
if (knowledgePoints < 1)
{
knowledgePoints = 1;
}
else if (knowledgePoints > 5)
{
knowledgePoints = 5;
}
GetComponentInChildren <Text>().text = knowledgePoints.ToString();
//Debug.Log("Knowledge Points Total: " +knowledgePoints);
} //if hero is Active
} //Gain Knowledge
public override void UseAbility(HeroManager attacker, HeroManager defender)
{
List <HeroManager> enemies = GameManager.Instance.EnemyHeroList(attacker);
//attack all enemies
GameManager.Instance.AttackAll(attacker, defender);
if (attacker.GetComponentInParent <Player>().isActive)
{
foreach (HeroManager enemy in enemies)
{
//Remove a buff
Buff[] buffs = enemy.GetComponents <Buff>();
if (buffs.Length > 0)
{
foreach (Buff buff in buffs)
{
//buff.OnDestroy();
Destroy(buff);
//Debug.Log("Buff Destroyeda " +buff +" from hero: " +enemy );
}
//addstun
if (enemy.hasImmunity || enemy.hasPermanentImmunity)
{
Debug.Log("Has Immunity");
}
else
{
if (GameManager.Instance.IsChanceSuccess(attacker))
{
GameManager.Instance.AddDebuff("Stun", 1, attacker, enemy);
}
}
}
}
} //if playerisActive
base.UseAbility(attacker);
}
} //RandomAllyImmunity
void AmeliaUnicorn(HeroManager oldHero)
{
//Unsubscribe passive ability
GameManager.Instance.e_PlayerMainPhase -= RandomAllyImmunity;
//DisableAbilityActive();
//Create New Hero
//Get AmeliaHiman
heroAsset = Resources.Load <HeroAsset>("SO Assets/Hero/Final/AmeliaUnicorn");
heroPrefab = Resources.Load <HeroManager>("Prefabs/Hero");
//Init Heroes Routine
Transform heroLocation = oldHero.gameObject.transform;
newHero = Instantiate(heroPrefab, heroLocation.position, heroLocation.rotation, transform);
HeroManager heroManager = newHero.GetComponent <HeroManager>();
heroManager.heroName = heroAsset.heroName;
heroManager.image = heroAsset.image;
heroManager.maxHealth = heroAsset.maxHealth;
heroManager.attack = heroAsset.attack;
heroManager.defense = heroAsset.defense;
heroManager.chance = heroAsset.chance;
heroManager.rarity = heroAsset.rarity;
heroManager.player = this.GetComponentInParent <Player>();
heroManager.tag = this.GetComponentInParent <Player>().tag;
newHero.GetComponentInChildren <Image>().sprite = heroAsset.image;
newHero.name = heroManager.heroName;
newHero.GetComponentInChildren <OverheadText>().FloatingText(newHero.name.ToString());
for (int j = 0; j < heroAsset.abilityAsset2.Count; j++)
{
string spellScriptName = heroAsset.abilityAsset2[j].abilityEffect;
if (spellScriptName != null)
{
heroManager.abilityAssets.Add(heroAsset.abilityAsset2[j]);
}
}
heroManager.origHealth = heroManager.maxHealth;
heroManager.origAttack = heroManager.attack;
heroManager.origDefense = heroManager.defense;
heroManager.origChance = heroManager.chance;
heroManager.origShield = heroManager.shield;
//END OF INITHEROES Routine
//Init Hero UI
heroManager.transform.Find("HeroUI").gameObject.transform.Find("Health").gameObject.SetActive(true);
heroManager.transform.Find("HeroUI").gameObject.transform.Find("Attack").gameObject.SetActive(true);
heroManager.transform.Find("HeroUI").gameObject.transform.Find("Defense").gameObject.SetActive(true);
heroManager.UpdateUI();
//CreateHero Panel
heroManager.CreateHeroPanel();
//Set Glow
var image = heroManager.glow.GetComponent <Image>().color;
image.a = 1f;
heroManager.glow.GetComponent <Image>().color = image;
//Trigger Automatic Effects or Passive/Active effects
newHero.gameObject.transform.Find("HeroPanel(Clone)").gameObject.SetActive(true);
Ability[] abilities = newHero.GetComponentsInChildren <Ability>();
foreach (Ability ability in abilities)
{
//ability.remainingCooldown = 0;
ability.remainingCooldown = ability.abilityCooldown;
ability.GetComponentInChildren <Text>().text = ability.remainingCooldown.ToString();
if (ability.skillType == Type.Passive)
{
ability.UseAbilityPassive();
}
//For active skills with Passive
if (ability.skillType == Type.Active)
{
ability.UseAbilityActive();
}
}
newHero.gameObject.transform.Find("HeroPanel(Clone)").gameObject.SetActive(false);
//Fix UI
newHero.gameObject.transform.SetParent(oldHero.GetComponentInParent <Player>().gameObject.transform);
newHero.gameObject.transform.localScale = oldHero.gameObject.transform.localScale;
newHero.gameObject.transform.Find("HeroPanel(Clone)").transform.localScale = oldHero.gameObject.transform.Find("HeroPanel(Clone)").transform.localScale;
newHero.gameObject.transform.Find("HeroPanel(Clone)").transform.position = oldHero.gameObject.transform.Find("HeroPanel(Clone)").transform.position;
//need to revisit if there will be HP effects
newHero.maxHealth = oldHero.maxHealth;
newHero.UpdateUI();
//Transfer All existing buffs and debuffs
Buff[] buffs = oldHero.GetComponents <Buff>();
foreach (Buff buff in buffs)
{
GameManager.Instance.AddBuff(buff.buff.buff.ToString(), buff.duration, oldHero, newHero);
Destroy(buff);
}
Debuff[] debuffs = oldHero.GetComponents <Debuff>();
foreach (Debuff debuff in debuffs)
{
GameManager.Instance.AddDebuff(debuff.debuff.debuff.ToString(), debuff.duration, oldHero, newHero);
Destroy(debuff);
}
heroManager.SelectHero();
int x = heroManager.GetComponentInParent <Player>().teamHeroes.Count;
for (int y = 0; y < x; y++)
{
if (heroManager.GetComponentInParent <Player>().teamHeroes[y] == oldHero.gameObject)
{
heroManager.GetComponentInParent <Player>().teamHeroes[y] = newHero.gameObject;
}
}
Destroy(oldHero.gameObject.transform.Find("HeroPanel(Clone)").gameObject);
Destroy(oldHero.gameObject);
//oldHero.enabled = false;
} //Create Hero
} //CheckDefender
public void CheckTaunt(HeroManager attacker, HeroManager defender)
{
if (attacker.GetComponent <Taunt>() != null)
{
if (attacker.GetComponent <Taunt>().source.GetComponent <HeroManager>() == defender || defender.GetComponentInParent <Player>().tag == attacker.GetComponentInParent <Player>().tag)
{
canTargetHero = true;
Debug.Log("attacker.GetComponent<Taunt>() != null");
}
else
{
canTargetHero = false;
}
}
else
{
CheckThreat(attacker, defender);
}
}
//Checks and resolves resolution of Reflect, Echo, and Revenge
public void AttackStatusChecks(HeroManager attacker, HeroManager defender)
{
int attackersDefense = attacker.defense;
int defendersDefense = defender.defense;
attackersAttack = attacker.attack;
defendersAttack = defender.attack;
if (attackersDefense < 0)
{
attackersDefense = 0;
}
if (defendersDefense < 0)
{
defendersDefense = 0;
}
if (attackersAttack < 0)
{
attackersAttack = 0;
}
if (defendersAttack < 0)
{
defendersAttack = 0;
}
CriticalStrikeCheck(attacker, defender);
if (defender.hasReflect)
{
if (!defender.GetComponentInParent <Player>().isActive)
{
atk_damage = attackersAttack - attackersDefense;
//attacker.TakeDamage (atk_damage, defender);
DealDamage(atk_damage, defender, attacker);
Debug.Log("Damage Reflected");
attacker.DisplayDamageText(atk_damage);
}
}
else
{
if (defender.hasDefend)
{
HeroManager defenderHero = defender.GetComponent <Defend>().source.GetComponent <HeroManager>();
int defenderHerosDefense = defenderHero.defense;
atk_damage = attackersAttack - defenderHerosDefense;
DealDamage(atk_damage, attacker, defenderHero);
defenderHero.DisplayDamageText(atk_damage);
Debug.Log("Defend!");
}
else
{
//Normal Damage route
atk_damage = attackersAttack - defendersDefense;
DealDamage(atk_damage, attacker, defender);
defender.DisplayDamageText(atk_damage);
}
}
//Revenge
if (defender.hasRevenge)
{
if (!defender.GetComponentInParent <Player>().isActive)
{
Attack(defender, attacker);
Debug.Log("Revenge!");
}
// atk_damage = defendersAttack-attackersDefense;
// //attacker.TakeDamage (atk_damage, defender);
// DealDamage(atk_damage, defender, attacker);
// Debug.Log("Revenge!");
// attacker.DisplayDamageText(atk_damage);
}
} //Attack Status Checks
