public void setEnemyButtons(baseEnemy[] enemies)
{
for (int i = 0; i < enemies.Length; ++i)
{
_enemyButtons[i].setButton(enemies[i]);
}
}
public enemyButton fetchEnemyButton(baseEnemy unit)
{
for (int i = 0; i < _enemyButtons.Length; ++i) {
if (_enemyButtons[i]._enemy == unit) {
return _enemyButtons[i];
}
}
return _enemyButtons[0];
}
public void testEnemies()
{
baseEnemy[] _testEnemies;
_testEnemies = new baseEnemy[4];
_testEnemies[0] = gameObject.AddComponent<C>();
_testEnemies[1] = gameObject.AddComponent<Cpp>();
_testEnemies[2] = gameObject.AddComponent<C>();
_testEnemies[3] = gameObject.AddComponent<Python>();
setEnemyButtons(_testEnemies);
}
public void setBattlePanel(baseEnemy unit)
{
_enemyUnit = unit;
if (_enemyUnit.effected)
battleStats.text =
_enemyUnit.name + "\n\n" +
"HP :" + _enemyUnit.currentHP + "/" + _enemyUnit.maxHP + "\n" +
"Status Effect : " + _enemyUnit.effect.ToString() + "\n"+
"Duration: "+_enemyUnit.duration;
else
battleStats.text =
_enemyUnit.name + "\n\n" +
"HP :" + _enemyUnit.currentHP + "/" + _enemyUnit.maxHP + "\n" +
"Status Effect : " + _enemyUnit.effect.ToString() + "\n";
}
//handle turn and action logic
public static void endAction()
{
if (_buffUnit != null)
{
playerPanel.endAction(_unit);
}
else
playerPanel.endAction();
enemyPanel.endAction();
action = false;
attack = false;
_unit = null;
_skill = null;
_buffUnit = null;
_enemy = null;
playerPanel.disableTargetMode();
enemyPanel.disableTargetMode();
}
/*
* Effects. These effect units in some way or another
STUN - skip turn
CONFUSED - Pokemon style. attack may hit anyone
AOE - AOE effect
HEAL - Heal target
DOT - Damage over time
GOD - Block next attack
ATTACK - Buff only once, last x turns
DEFENSE - Buff only once, last y turns
SKIP - skip turn for build up of attack. Keep at 0 until we actually cast the spell.
*/
private void unitConfused(basePlayer unit, baseEnemy target, baseSkill skill)
{
// Attacks random target here
int coin = Random.Range(0, 1);
if (coin == 0)
{
//Attack allies
int unitIndex = Random.Range(0, BattleManager.playerParty.Count);
--unit.duration;
if (BattleManager.playerParty[unitIndex] != null)
playerAttack(unit, BattleManager.playerParty[unitIndex], skill);
}
else
{
// Attack Enemy
int unitIndex = Random.Range(0, BattleManager.enemyParty.Count);
--unit.duration;
if (BattleManager.enemyParty[unitIndex] != null)
playerAttack(unit, BattleManager.enemyParty[unitIndex], skill);
}
}
void updateSelected()
{
for (int i = 0; i < _enemyButtons.Length; ++i)
{
if (_enemyButtons[i].selected == true)
{
_selectedEnemy = _enemyButtons[i]._enemy;
_enemyButtons[i].selected = false;
_hasSelected = true;
Debug.Log("Enemy :" + _selectedEnemy.name);
}
}
}
private void AOEattack(baseEnemy unit, baseEnemy target, baseSkill skill)
{
int enemiesLeft = BattleManager.enemyParty.Count;
int damage = skill.cast(unit);
for (int i = 0; i < enemiesLeft; ++i)
{
if (BattleManager.enemyParty[i] != null)
{
BattleManager.enemyParty[i].currentHP -= damage;
if (BattleManager.enemyParty[i].currentHP <= 0)
{
BattleManager.deadUnit(BattleManager.enemyParty[i]);
}
}
}
}
public static void updateTarget(baseEnemy enemy)
{
if (_skill != null) {
_enemy = enemy;
action = true;
attack = true;
}
}
public void demo()
{
_enemy = GetComponent<Python>();
}
public static void deadUnit(baseEnemy unit)
{
enemyParty.Remove(unit);
GUIManager.deadUnit(unit);
}
private void clearEffect(baseEnemy unit, baseSkill skill)
{
if (unit.effect == baseEnemy.Status.ATTACK)
unit.attack -= skill.additionalEffect.power;
else if (unit.effect == baseEnemy.Status.DEFENSE)
unit.defense -= skill.additionalEffect.power;
unit.effect = baseEnemy.Status.NONE;
unit.duration = 0;
unit.effected = false;
unit.effective_skill = null;
}
private void applyEffect(baseEnemy unit, baseSkill skill)
{
unit.effect = (baseEnemy.Status)skill.additionalEffect.status;
unit.duration = skill.additionalEffect.duration;
unit.effected = true;
unit.effective_skill = skill;
}
private void playerBuff(basePlayer unit, baseEnemy target, baseSkill skill)
{
if (!target.effected)
{
if (skill.additionalEffect.status == baseSkill.Effect.Status.ATTACK && skill.targetPlayer)
{
target.attack += skill.additionalEffect.power;
applyEffect(target, skill);
}
else if (skill.additionalEffect.status == baseSkill.Effect.Status.DEFENSE && skill.targetPlayer)
{
target.defense += skill.additionalEffect.power;
applyEffect(target, skill);
}
}
else if (skill.additionalEffect.status == baseSkill.Effect.Status.HEAL && skill.targetPlayer)
{
target.currentHP += skill.cast(unit);
//Check here for effects. HOTS?
}
}
//Attack states
//Player Attack States
private void playerAttack(basePlayer unit, baseEnemy target, baseSkill skill)
{
//AOE target. Might have to look at how we Destory Units. Because bookkeeping
if (skill.additionalEffect.status == baseSkill.Effect.Status.AOE && skill.targetEnemy)
AOEattack(unit, target, skill);
else
{
//Single Target - Check if GODed
if (target.effect == baseEnemy.Status.GOD)
{
target.currentHP -= 0;
Debug.Log("(CSM) Player Attack Player/Enemy-> Damage = 0; Reason: GodModed");
clearEffect(target, skill);
}
else
{
int damage = skill.cast(unit);
Debug.Log("(CSM) Player Attack -> Damage =" + damage);
target.currentHP -= damage;
if (target.currentHP >= 0)
if (!target.effected)
applyEffect(target, skill);
else { }
else
BattleManager.deadUnit(target);
}
}
Debug.Log("Attack Successful");
}
private void enemyAttack(baseEnemy attacker, baseEnemy target, baseSkill skill)
{
if (target.effect == baseEnemy.Status.GOD)
{
target.currentHP -= 0;
clearEffect(target, skill);
}
else
{
target.currentHP -= skill.cast(attacker);
if (target.currentHP <= 0)
BattleManager.deadUnit(target);
else if (skill.hasAdditionalEffect)
if (!target.effected)
applyEffect(target, skill);
}
}
//Enemy Turn States
private void enemyAction(baseEnemy unit, basePlayer target, baseSkill skill)
{
// All possible states
switch (unit.effect)
{
case (baseEnemy.Status.ATTACK):
decreaseEffect(unit, skill);
enemyAttack(unit, target, skill);
break;
case (baseEnemy.Status.CONFUSED):
unitConfused(unit, target, skill);
break;
case (baseEnemy.Status.DEFENSE):
decreaseEffect(unit, skill);
enemyAttack(unit, target, skill);
break;
case (baseEnemy.Status.DOT):
unitDOTed(unit, skill);
enemyAttack(unit, target, skill);
break;
case (baseEnemy.Status.SKIP):
unitSkipped(unit, target, BattleManager._skill);
if (!unit.effected)
enemyAttack(unit, target, skill);
break;
case (baseEnemy.Status.STUN):
unitStunned(unit, skill);
break;
default:
enemyAttack(unit, target, skill);
break;
}
}
private void decreaseEffect(baseEnemy unit, baseSkill skill)
{
if (unit.duration == 0)
{
clearEffect(unit, skill);
}
--unit.duration;
}
public void Start()
{
demo();
_hasSelected = false;
_selectedEnemy = null;
}
private void unitConfused(baseEnemy unit, basePlayer target, baseSkill skill)
{
int coin = Random.Range(0, 1);
if (coin == 0)
{
//Attack allies - No Effect applied (For Now)
int unitIndex = Random.Range(0, BattleManager.playerParty.Count);
--unit.duration;
if (BattleManager.playerParty[unitIndex] != null)
enemyAttack(unit, BattleManager.enemyParty[unitIndex],unit.basicAttack);
}
else
{
// Attack Enemy - No Effect applied (For Now)
int unitIndex = Random.Range(0, BattleManager.enemyParty.Count);
--unit.duration;
if (BattleManager.enemyParty[unitIndex] != null)
enemyAttack(unit, BattleManager.playerParty[unitIndex], unit.basicAttack);
}
}
public void highestDamageSpell(baseEnemy enemy)
{
// return baseskill based on enemy's strongest attack
}
private void unitDOTed(baseEnemy unit,baseSkill skill)
{
//check for 0
if (unit.duration == 0){
clearEffect(unit,skill);
}
//Apply DOT on turn attacking before attack
else{
unit.currentHP -= skill.additionalEffect.power;
--unit.duration;
}
if (unit.currentHP <= 0)
BattleManager.deadUnit(unit);
}
//Set button here.
public void setButton(baseEnemy input)
{
BattleManager.enemyParty.Add(input);
_enemy = input;
_enemyBattleStats.setBattlePanel(input);
}
private void unitSkipped(baseEnemy unit,basePlayer target,baseSkill skill)
{
if (unit.duration == 0)
{
unit.currentHP -= skill.cast(unit);
clearEffect(target,skill);
}
else
--unit.duration;
}
public void updateBM()
{
if (GUIManager.action) {
if (GUIManager.attack == true) {
_unit = GUIManager._unit;
_skill = GUIManager._skill;
_attackTarget = GUIManager._enemy;
playerEnemy = true;
csm.updateMachine();
}
else {
_unit = GUIManager._unit;
_skill = GUIManager._skill;
_buffTarget = GUIManager._buffUnit;
playerPlayer = true;
csm.updateMachine();
}
}
}
private void unitStunned(baseEnemy unit,baseSkill skill)
{
// Stunned effect. Actions minus/ Player doesnt take turn
--unit.duration;
if (unit.duration == 0)
clearEffect(unit,skill);
// Maybe some text here. For now in debug log
Debug.Log("unit stunned");
}
public static void deadUnit(baseEnemy unit)
{
unit.currentHP = -1;
enemyPanel.fetchEnemyButton(unit).buttonDisable();
enemyPanel.fetchEnemyButton(unit).GetComponent<Image>().enabled = false;
}
public override int cast(baseEnemy caster)
{
return caster.attack;
}
public override int cast(baseEnemy caster)
{
return 0;
}
public abstract int cast(baseEnemy caster);
