public int?[][] TakeAMove(Move move)
{
Board[move.Position.X][move.Position.Y] = (int)move.Player.Symbol;
NextPlayerSymbol = (PlayerSymbol)((int)PlayerSymbol.Circle + (int)PlayerSymbol.Cross - (int)move.Player.Symbol);
CurrentPlayer = move.Player;
return(Board);
}
public static void Attack()
{
basePlayer bp = LevelManager.FindObjectOfType <basePlayer> ();
LevelManager lm = LevelManager.FindObjectOfType <LevelManager> ();
Debug.Log("Attack");
bp.DamagePlayer(2);
lm.heroTurn = true;
}
public GameBoard(PlayerSymbol firstPlayerToStartGame, List <baseRule> rules)
{
InitializeGameBoard();
CurrentErrors = new List <GameErrorTypes>();
NextPlayerSymbol = firstPlayerToStartGame;
GameEnd = false;
CurrentPlayer = null;
Winner = null;
_winningRules = rules;
}
public static void killPlayer(basePlayer player)
{
Destroy(player);
basePlayer bp = LevelManager.FindObjectOfType <basePlayer> ();
if (bp.stats.curHealth == 0)
{
SceneManager.LoadScene("gameOver");
}
}
public bool IsWinning()
{
var winning = _winningRules.Any(r => r.IsWinning(Board));
if (winning)
{
Winner = CurrentPlayer;
}
return(winning);
}
public void setActionBar(basePlayer unit)
{
if (unit.skill1.skillName == "-") {
}
else{
_buttons[0].setButton(unit.skill1);
_buttons[1].setButton(unit.skill2);
_buttons[2].setButton(unit.skill3);
_buttons[3].setButton(unit.skill4);
_buttons[4].setButton(unit.basicAttack);
}
}
public void Attack1()
{
basePlayer bp = LevelManager.FindObjectOfType <basePlayer> ();
LevelManager lm = LevelManager.FindObjectOfType <LevelManager> ();
if (lm.heroTurn == true)
{
bp.playerAttack1();
}
else
{
lm.enemyTurn();
}
}
public override int cast(basePlayer caster)
{
//skill effect
//skill experience gain
skillExperience++;
//if skill experience hits 10, skill/category level up
if (skillExperience % 10 == 0) {
skillLevel++;
caster.networkMastery++;
}
return 0;
}
public static void deadUnit(basePlayer unit)
{
for (int i = 0; i < GameInformation.players.Length; ++i) {
if (GameInformation.players[i] == unit) {
unit.currentHP = unit.maxHP;
unit.effected = false;
unit.effective_skill = null;
unit.effect = basePlayer.Status.NONE;
GameInformation.players[i] = unit;
}
}
playerParty.Remove(unit);
GUIManager.deadUnit(unit);
}
public override int cast(basePlayer caster)
{
//skill effect
// int attack = (5*skillLevel) + 10) * numberofnodes
//skill experience gain
skillExperience++;
//if skill experience hits 10, skill/category level up
if (skillExperience % 10 == 0) {
skillLevel++;
caster.networkMastery++;
}
//return attack
return 0;
}
public override int cast(basePlayer caster)
{
//skill effect
int attack = (10 + (skillLevel * 5)) * 2;
if (Random.Range(0, 1) != 0)
attack = 0;
//skill experience gain
++skillExperience;
//if skill experience hits 10, skill/category level up
if (skillExperience % 10 == 0) {
skillLevel++;
caster.networkMastery++;
}
return attack;
}
public override int cast(basePlayer caster)
{
//skill effect
int damage = (int)(caster.attack * skillPower);
//skill coolddown here
//skill experience gain
skillExperience++;
//if skill experience hits 10, skill/category level up
if (skillExperience % 10 == 0) {
skillLevel++;
skillPower += .05;
}
return damage;
}
public override int cast(basePlayer caster)
{
//skill effect
int health = 100 / (skillLevel + 1);
if(health>100)
caster.currentHP -= health; // Trading health for attack.
int attack = (skillLevel * health) + 10;
//skill experience gain
skillExperience++;
//if skill experience hits 10, skill/category level up
if (skillExperience % 10 == 0) {
skillLevel++;
caster.networkMastery++;
}
return attack;
}
public void setBattlePanel(basePlayer unit)
{
_unit = unit;
if (unit.effected)
{
battleStats.text =
_unit.name + "\n\n" +
"HP :" + _unit.currentHP + "/" + _unit.maxHP + " Attack :" + _unit.attack + "\n" +
"Status Effect : " + _unit.effect.ToString() + "\n" +
"Duration :" + _unit.duration + "\n" +
"Network Mastery: " + _unit.networkMastery;
}
else
battleStats.text =
_unit.name + "\n\n" +
"HP :" + _unit.currentHP + "/" + _unit.maxHP + " Attack :" + _unit.attack + "\n" +
"Status Effect : " + _unit.effect.ToString() + "\n" +
"Network Mastery :" + _unit.networkMastery;
}
public void playerAttack3()
{
LevelManager lm = LevelManager.FindObjectOfType <LevelManager> ();
basePlayer bp = LevelManager.FindObjectOfType <basePlayer> ();
foreach (Enemy ee in LevelManager.FindObjectsOfType <Enemy>())
{
if (Random.Range(0f, lm.E.Count) > 0)
{
if (ee == null)
{
continue;
}
ee.DamageEnemy(25);
}
}
bp.DamagePlayer(10);
bp.changeDank(25);
lm.heroTurn = false;
}
//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();
}
public override int cast(basePlayer caster)
{
//is it player?
//if (target.GetType ().IsAssignableFrom (basePlayer)) {
// Debug.Log ("its a player");
//} else
// Debug.Log ("its enemy");
//skill effect
int attack = (skillLevel * 5) + 10;
//skill experience gain
skillExperience++;
//if skill experience hits 10, skill/category level up
if (skillExperience % 10 == 0) {
skillLevel++;
caster.networkMastery++;
}
return attack;
}
public void playerAttack2()
{
LevelManager lm = LevelManager.FindObjectOfType <LevelManager> ();
basePlayer bp = LevelManager.FindObjectOfType <basePlayer> ();
if (stats.curDank - 10 <= 0)
{
bp.DamagePlayer(2);
}
else
{
Enemy ee = lm.E [Random.Range(0, lm.E.Count)];
if (ee != null)
{
ee.DamageEnemy(50);
}
else
{
playerAttack2();
}
}
changeDank(10);
lm.heroTurn = false;
}
//Death Functions- Basically make sure they cannot be interacted with.
public static void deadUnit(basePlayer unit)
{
unit.currentHP = -1;
playerPanel.fetchPlayerButton(unit).buttonDisable();
playerPanel.fetchPlayerButton(unit).GetComponent<Image>().enabled = false;
}
//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;
}
}
public static void updateUnit(basePlayer unit)
{
if (_unit == null && _skill == null)
_unit = unit;
// selected same unit before selecting skill
else if (_unit == unit && _skill == null)
{
_unit = null;
}
// selected different unit before selecting skill
else if (_unit != unit && _skill == null) {
_unit = unit;
}
// selected a buff target that may be itself.
else if (_unit != null && _skill != null)
{
_buffUnit = unit;
action = true;
attack = false;
}
}
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();
}
}
}
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();
}
}
}
//Status Effect System helper Functions
private void clearEffect(basePlayer unit,baseSkill skill)
{
if (unit.effect == basePlayer.Status.ATTACK)
unit.attack -= skill.additionalEffect.power;
else if (unit.effect == basePlayer.Status.DEFENSE)
unit.defense -= skill.additionalEffect.power;
unit.effect = basePlayer.Status.NONE;
unit.duration = 0;
unit.effected = false;
unit.effective_skill = null;
}
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");
}
//Used for initialization
void Start()
{
newPlayer = new basePlayer();
}
/*
* 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);
}
}
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 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 Move(basePlayer player, MovePosition position)
{
Player = player;
Position = position;
}
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 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");
}
public abstract int cast(basePlayer caster);
//Load in GUI based on players and enemies
public static void loadGUI(basePlayer[] players)
{
playerPanel.setPlayerButtons(players);
//enemyPanel.setEnemyButtons(enemies);
//Debug.Log("GUI Loaded.");
}
// Use this for initialization
void Start()
{
player = GameObject.FindObjectOfType<Player>();
}
private void decreaseEffect(basePlayer unit, baseSkill skill)
{
if (unit.duration == 0)
{
clearEffect(unit,skill);
}
--unit.duration;
}
private void enemyAttack(baseEnemy attacker, basePlayer target, baseSkill skill)
{
if (target.effect == basePlayer.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);
}
}
public override int cast(basePlayer caster)
{
return 0 ;
}
public void setButton(basePlayer input)
{
_player = input;
_actionBar.setActionBar(input);
_playerBattleStats.setBattlePanel(_player);
}
