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); }