public static void updateSkill(baseSkill skill)
{
if (_skill == skill) {
_skill = null;
playerPanel.disableTargetMode();
enemyPanel.disableTargetMode();
playerPanel.fetchActionBar(_unit).hideActionBar();
_unit = null;
playerPanel._currentPlayer = null;
}
else
_skill = skill;
if (_skill != null)
{
//Buff Spell Target only Players
if (skill.targetPlayer == true && skill.targetEnemy == false)
{
playerPanel.enableTargetMode();
enemyPanel.disableTargetMode();
}
//Any other spell is considered hostile. Target enemies
else
{
enemyPanel.enableTargetMode();
playerPanel.enemyTargetMode();
}
}
}
public void OnPointerClick(PointerEventData eventData)
{
Debug.Log ("Skill Script onclick fired");
this.skill = this.GetComponentInParent<SlotScript> ().skill;
description = skill.skillName + "\n"
+ "Skill Level: " + skill.skillLevel.ToString() + "\n"
+ "Experience: " + skill.skillExperience.ToString() + "\n"
+ "Cooldown: " + skill.skillCoolDown.ToString() + "\n"
+ "Description: " + skill.skillDescription + "\n";
TextArea.GetComponent<Text> ().text = description;
}
public void setButton(baseSkill in_skill)
{
_skill = in_skill;
if (_skill.skillName == "Basic Attack")
_skillButton.image.sprite = Resources.Load<Sprite>("Skill/Basic Attack");
else
_skillButton.image.sprite = in_skill.skillIcon;
_skillPanel.setSkillPanel(in_skill);
cooldown_duration = _skill.skillCoolDown;
_skillPanel.hidePanel();
}
public void endAction()
{
for (int i = 0; i < _buttons.Length; ++i) {
if (_buttons[i]._skill == _skill)
{
_buttons[i].applyCooldown();
}
}
_hasSelected = false;
_skill = null;
hideActionBar();
}
//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);
}
}
// Use this for initialization
void Start()
{
_skill = new NoSkill();
cooldown_duration = 0;
onCoolDown = false;
selected = false;
cooldown_duration = 0;
}
private void applyEffect(basePlayer unit, baseSkill skill)
{
unit.effect = (basePlayer.Status)skill.additionalEffect.status;
unit.duration = skill.additionalEffect.duration;
unit.effected = true;
unit.effective_skill = skill;
}
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");
}
private void unitStunned(basePlayer 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! CANT ATTACK THIS ACTION TAKING AWAY 1 ACTION POINT");
}
private void unitSkipped(baseEnemy unit,basePlayer target,baseSkill skill)
{
if (unit.duration == 0)
{
unit.currentHP -= skill.cast(unit);
clearEffect(target,skill);
}
else
--unit.duration;
}
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]);
}
}
}
}
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;
}
public void updateSelected()
{
for (int i = 0; i < _buttons.Length; ++i) {
if (_buttons[i].selected)
{
if (_skill == null) {
_skill = _buttons[i]._skill;
_buttons[i].selected = false;
_hasSelected = true;
}
else if (_skill == _buttons[i]._skill)
{
_skill = null;
_buttons[i].selected = false;
_hasSelected = false;
}
else {
_skill = _buttons[i]._skill;
_buttons[i].selected = false;
_hasSelected = true;
}
}
}
}
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?
}
}
private void playerAttack(basePlayer unit, basePlayer 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 == basePlayer.Status.GOD)
{
target.currentHP -= 0;
Debug.Log("(CSM) PlayerAttack Player/Player Damage = 0; God Moded");
clearEffect(target, skill);
}
else
{
target.currentHP -= skill.cast(unit);
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 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 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);
}
}
private void unitDOTed(basePlayer unit,baseSkill skill)
{
//Apply DOT on turn attacking before attack, check for health.
if (unit.duration == 0){
clearEffect(unit,skill);
}
else{
unit.currentHP -= skill.additionalEffect.power;
--unit.duration;
}
}
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);
}
void Start()
{
this.skill = this.GetComponentInParent<SlotScript> ().skill;
TextArea = GameObject.Find("SkillDescription");
description = "";
}
private void AOEattack(basePlayer unit, basePlayer target, baseSkill skill)
{
int playersLeft = BattleManager.playerParty.Count;
int damage = skill.cast(unit);
for (int i = 0; i < playersLeft; ++i)
{
if (BattleManager.playerParty[i] != null)
{
BattleManager.playerParty[i].currentHP -= damage;
if (BattleManager.playerParty[i].currentHP <= 0)
{
BattleManager.deadUnit(BattleManager.playerParty[i]);
}
}
}
}
