// Use this for initialization void Start() { _rc = FindObjectOfType<RoachController> (); _hero = FindObjectOfType<HeroStateMachine> (); _crystals = FindObjectsOfType<DomeCrystal>(); _dsc = FindObjectOfType<DomeStateController> (); }
// Update is called once per frame private void Update() { switch (battleState) { case PerformAction.Waiting: if (actions.Count > 0) { battleState = PerformAction.PrepareAction; } break; case PerformAction.PrepareAction: BattleAction action = actions[0]; GameObject performer = action.attackerGameObject; if (action.attackerType == BattleAction.ToonType.Enemy) { EnemyStateMachine esm = performer.GetComponent <EnemyStateMachine>(); esm.heroToAttack = action.defenderGameObject; esm.currentState = EnemyStateMachine.TurnState.PerformAction; } else // if hero { HeroStateMachine hsm = performer.GetComponent <HeroStateMachine>(); hsm.enemyToAttack = action.defenderGameObject; hsm.currentState = HeroStateMachine.TurnState.PerformAction; } battleState = PerformAction.PerformAction; break; case PerformAction.PerformAction: // idle break; default: throw new ArgumentOutOfRangeException(); } switch (HeroInput) { case HeroGui.Activate: if (heroesToManage.Count > 0) { // heroesToManage[0].transform.Find("Selector").gameObject.SetActive(true); heroesToManage[0].GetComponent <HeroStateMachine>().Selector.SetActive(true); AttackPanel.SetActive(true); HeroInput = HeroGui.Waiting; } break; case HeroGui.Waiting: // idle; break; default: throw new ArgumentOutOfRangeException(); } }
// Update is called once per frame void Update() { switch (battleStates) { case (PerformAction.WAIT): if (performList.Count > 0) { battleStates = PerformAction.TAKEACTION; } break; case (PerformAction.TAKEACTION): GameObject performer = GameObject.Find(performList[0].attacker); if (performList[0].type == "Enemy") { EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine>(); ESM.targetToAttack = performList[0].targetOfAttacker; ESM.currentState = EnemyStateMachine.TurnState.ACTION; } if (performList[0].type == "Hero") { HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>(); HSM.targetToAttack = performList[0].targetOfAttacker; HSM.currentState = HeroStateMachine.TurnState.ACTION; } battleStates = PerformAction.PERFORMACTION; break; case (PerformAction.PERFORMACTION): break; } switch (heroInput) { case (HeroGUI.ACTIVATE): if (heroesToManage.Count > 0) { heroesToManage[0].transform.FindChild("Selector").gameObject.SetActive(true); heroChoice = new TurnHandler(); attackPanel.SetActive(true); heroInput = HeroGUI.WAITING; } break; case (HeroGUI.WAITING): //idle break; case (HeroGUI.DONE): heroInputDone(); break; } }
void Update() { switch (battleStates) { case (PerformAction.Wait): if (PerformList.Count > 0) { battleStates = PerformAction.ActionTake; } break; case (PerformAction.ActionTake): GameObject performer = PerformList[0].AttacksGameObject; if (PerformList[0].Type == "Enemy") { EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine>(); ESM.HeroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.Action; } if (PerformList[0].Type == "Hero") { HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>(); HSM.EnemyToAttack = PerformList[0].AttackersTarget; HSM.currentState = HeroStateMachine.TurnState.Action; } battleStates = PerformAction.ActionPerform; break; case (PerformAction.ActionPerform): //Idle break; } switch (HeroInput) { case (HeroGUI.Activate): if (HeroesToManage.Count > 0) { //FIXME HeroesToManage[0].transform.Find("Selector").gameObject.SetActive(true); HeroChoice = new HandleTurn(); attackPanel.SetActive(true); HeroInput = HeroGUI.Wait; } break; case (HeroGUI.Wait): //Idle break; case (HeroGUI.Done): HeroInputDone(); break; } }
public void InputEnemy(GameObject enemySelected) { HeroStateMachine hsm = HeroSelected.GetComponent <HeroStateMachine>(); hsm.MakeNewAction(enemySelected); hsm.Selector.SetActive(false); heroesToManage.RemoveAt(0); EnemySelectPanel.SetActive(false); HeroInput = HeroGui.Activate; }
void HeroButtons() { foreach (GameObject hero in HeroesInBattle) { GameObject newButton = Instantiate(heroButton) as GameObject; HeroSelectButton button = newButton.GetComponent <HeroSelectButton>(); HeroStateMachine cur_hero = hero.GetComponent <HeroStateMachine>(); Text buttonText = newButton.transform.Find("Text").gameObject.GetComponent <Text>(); buttonText.text = cur_hero.hero.theName; button.HeroPrefab = hero; newButton.transform.SetParent(Spacer2, false); } }
// Update is called once per frame void Update() { currentState = Hero.GetComponent <HeroStateMachine>(); battleState = BattleManager.GetComponent <BattleStateMachine>(); if (currentState.currentState == HeroStateMachine.TurnState.Action) { anim.SetTrigger("Attack"); } if (currentState.currentState == HeroStateMachine.TurnState.Processing || currentState.currentState == HeroStateMachine.TurnState.Waiting) { anim.SetTrigger("Stationary"); } if (battleState.battlestates == BattleStateMachine.PerformAction.Win) { anim.SetTrigger("Victory"); } }
void HeroButtons() { foreach (GameObject hero in HeroesInBattle) { if (hero.tag != "DeadHero") { GameObject targetButton = Instantiate(heroButton) as GameObject; HeroSelectButton button = targetButton.GetComponent <HeroSelectButton>(); HeroStateMachine cur_Hero = hero.GetComponent <HeroStateMachine>(); Text targetButtonText = targetButton.transform.Find("Text").gameObject.GetComponent <Text>(); targetButtonText.text = cur_Hero.hero.characterName; button.HeroPrefab = hero; TargetButtons.Add(targetButton); targetButton.transform.SetParent(TargetPanelSpacer, false); } } }
// Update is called once per frame void Update() { switch (battleStates) { case (PerformAction.WAIT): if (PerformList.Count > 0) { battleStates = PerformAction.TAKEACTION; } break; case (PerformAction.TAKEACTION): GameObject performer = GameObject.Find(PerformList[0].Attacker); if (PerformList[0].Type == "Enemy") { EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine>(); for (int i = 0; i < HerosInBattle.Count; i++) { if (PerformList[0].AttackersTarget == HerosInBattle[i]) { ESM.HeroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.ACTION; break; } else { PerformList[0].AttackersTarget = HerosInBattle[Random.Range(0, HerosInBattle.Count)]; ESM.HeroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.ACTION; } } } if (PerformList[0].Type == "Hero") { HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>(); HSM.EnemyToAttack = PerformList[0].AttackersTarget; HSM.currentState = HeroStateMachine.TurnState.ACTION; } battleStates = PerformAction.PERFORMACTION; break; case (PerformAction.PERFORMACTION): break; case (PerformAction.CHECKALIVE): if (HerosInBattle.Count < 1) { battleStates = PerformAction.LOSE; } else if (EnemysInBattle.Count < 1) { battleStates = PerformAction.WIN; } else { clearAttackPanel(); //call a function HeroInput = HeroGUI.ACTIVATE; } break; case (PerformAction.LOSE): { Debug.Log("YOU LOST!"); } break; case (PerformAction.WIN): { Debug.Log("YOU WON!"); for (int i = 0; i < HerosInBattle.Count; i++) { HerosInBattle[i].GetComponent <HeroStateMachine>().currentState = HeroStateMachine.TurnState.WAITING; } GameManager.instance.LoadSceneAfterBattle(); GameManager.instance.gameState = GameManager.GameStates.WORLD_STATE; GameManager.instance.enemysToBattle.Clear(); } break; } switch (HeroInput) { case (HeroGUI.ACTIVATE): if (HerosToManage.Count > 0) { HerosToManage[0].transform.Find("Selector").gameObject.SetActive(true); HeroChoice = new HandleTurn(); AttackPanel.SetActive(true); CreateAttackbuttons(); HeroInput = HeroGUI.WAITING; } break; case (HeroGUI.WAITING): break; case (HeroGUI.DONE): HeroInputDone(); break; } }
// Update is called once per frame void Update() { switch (battleState) { //truong hop battle dang trong trang thai wait case PerformAction.WAIT: //neu list hanh dong can thuc hien > 0 if (PerformList.Count > 0) { //chuyen trang thai ve tackeaction battleState = PerformAction.TAKEACTION; } break; //truong hop battle dang trong trang thai takeaction case PerformAction.TAKEACTION: //tim gameobject co ten la ten phan tu dau tien trong list thuc hien GameObject performer = GameObject.Find(PerformList[0].attacker); //neu ng thuc hien thuoc type monster if (PerformList[0].type == "Monster") { //get component MSM cua no MonsterStateMachine MSM = performer.GetComponent <MonsterStateMachine>(); MSM.playerToAttack = PerformList[0].AttackersTarget; //chuyen trang thai cua monster sang action MSM.currentState = MonsterStateMachine.TurnState.ACTION; } else if (PerformList[0].type == "Player") { HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>(); HSM.enemyToAttack = PerformList[0].AttackersTarget; HSM.currentState = HeroStateMachine.TurnState.ACTION; } //chuyen trang thai cua battle sang perform action battleState = PerformAction.PERFORMACTION; break; case PerformAction.PERFORMACTION: break; } switch (playerInput) { case PlayerGUI.ACTIVATE: //neu player quan li > 0 if (PlayerToManager.Count > 0) { //tim gameobject selector va set active = true PlayerToManager[0].transform.Find("selector").gameObject.SetActive(true); //tao moi 1 handler turn playerChoice = new HandleTurn(); //hien thi attack panel AttackPanel.SetActive(true); //chuyen trang thai playerGUI ve waiting playerInput = PlayerGUI.WAITING; } break; case PlayerGUI.WAITING: break; case PlayerGUI.DONE: //thuc hien ham PlayerInputDone() PlayerInputDone(); break; } }
// Update is called once per frame void Update() { switch (battleStates) { case (PerformAction.WAIT): if (performList.Count > 0) { battleStates = PerformAction.TAKEACTION; } break; case (PerformAction.TAKEACTION): GameObject performer = GameObject.Find(performList[0].attacker); if (performList[0].type == "Enemy") { EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine>(); for (int i = 0; i < playersInBattle.Count; i++) { if (performList[0].targetOfAttacker == playersInBattle[i]) { ESM.targetToAttack = performList[0].targetOfAttacker; ESM.currentState = EnemyStateMachine.TurnState.ACTION; break; } else { performList[0].targetOfAttacker = playersInBattle[Random.Range(0, playersInBattle.Count)]; ESM.targetToAttack = performList[0].targetOfAttacker; ESM.currentState = EnemyStateMachine.TurnState.ACTION; } } } if (performList[0].type == "Hero") { HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>(); HSM.targetToAttack = performList[0].targetOfAttacker; HSM.currentState = HeroStateMachine.TurnState.ACTION; } battleStates = PerformAction.PERFORMACTION; break; case (PerformAction.PERFORMACTION): //idle state break; case (PerformAction.CHECKALIVE): if (playersInBattle.Count < 1) { battleStates = PerformAction.LOSE; } else if (enemiesInBattle.Count < 1) { battleStates = PerformAction.WIN; } else { ClearAttackPanel(); heroInput = HeroGUI.ACTIVATE; } break; case (PerformAction.WIN): Debug.Log("You have won the battle!"); for (int i = 0; i < playersInBattle.Count; i++) { playersInBattle[i].GetComponent <HeroStateMachine>().currentState = HeroStateMachine.TurnState.WAITING; } winPanel.SetActive(true); break; case (PerformAction.LOSE): Debug.Log("You have died."); break; } switch (heroInput) { case (HeroGUI.ACTIVATE): if (heroesToManage.Count > 0) { heroesToManage[0].transform.Find("Selector").gameObject.SetActive(true); heroChoice = new TurnHandler(); actionPanel.SetActive(true); CreateAttackButtons(); heroInput = HeroGUI.WAITING; } break; case (HeroGUI.WAITING): //idle break; case (HeroGUI.DONE): heroInputDone(); break; } }
// Update is called once per frame void Update() { switch (battleStates) { case (PerformAction.WAIT): if (PerformList.Count > 0) { battleStates = PerformAction.TAKEACTION; } if (HerosInBattle.Count < 1 || EnemysInBattle.Count < 1) { battleStates = PerformAction.CHECKALIVE; } break; case (PerformAction.TAKEACTION): GameObject performer = GameObject.Find(PerformList [0].Attacker); if (PerformList[0].Type == "Hero") { if (EnemysInBattle.Count != 0) { HeroStateMachine hsm = performer.GetComponent <HeroStateMachine>(); hsm.EnemyToAttack = PerformList[0].AttackersTarget; hsm.currentState = HeroStateMachine.TurnState.ACTION; } } if (PerformList [0].Type == "Enemy") { Debug.Log(PerformList[0].Attacker); EnemyStateMachine esm = performer.GetComponent <EnemyStateMachine> (); for (int i = 0; i < HerosInBattle.Count; i++) { if (HerosInBattle.Count == 0 || esm.EnemyStats.curHP <= 0) { break; } else if (PerformList[0].AttackersTarget == HerosInBattle[i]) { esm.HeroToAttack = PerformList[0].AttackersTarget; esm.currentState = EnemyStateMachine.TurnState.ACTION; break; } else { PerformList[0].AttackersTarget = HerosInBattle[Random.Range(0, HerosInBattle.Count)]; esm.HeroToAttack = PerformList[0].AttackersTarget; esm.currentState = EnemyStateMachine.TurnState.ACTION; } } } battleStates = PerformAction.PERFORMACTION; break; case (PerformAction.PERFORMACTION): break; case (PerformAction.CHECKALIVE): if (HerosInBattle.Count < 1) { battleStates = PerformAction.LOSE; // lose game } else if (EnemysInBattle.Count < 1) { battleStates = PerformAction.WIN; // win game } else { clearAttackPanel(); HeroInput = HeroGUI.ACTIVATE; //call function } break; case (PerformAction.LOSE): { if (Input.GetMouseButtonDown(0) || Input.GetTouch(0).phase == TouchPhase.Began) { clicksCount++; } Debug.Log("You lost the Battle"); //Defeat.SetActive(true); if (clicksCount == 1) { audioManager.GameOver(); EndBattlePanel.transform.FindChild("Text").GetComponent <Text>().text = "You lost the Battle"; EndBattlePanel.SetActive(true); } if (clicksCount == 2) { SceneManager.LoadScene(0); } } break; case (PerformAction.WIN): { if (Input.GetMouseButtonDown(0) || Input.GetTouch(0).phase == TouchPhase.Began) { clicksCount++; } Debug.Log("You won the Battle"); for (int i = 0; i < HerosInBattle.Count; i++) { HerosInBattle[i].GetComponent <HeroStateMachine>().currentState = HeroStateMachine.TurnState.WAITING; } if (clicksCount == 1) { En.GetComponent <EnemyStateMachine>().EnemyStats.timesDefeated++; audioManager.GameWin(); EndBattlePanel.transform.FindChild("Text").GetComponent <Text>().text = "You won the Battle\n" + "You earned:\n " + En.GetComponent <EnemyStateMachine>().EnemyStats.coinsToGive + " coins\n" + En.GetComponent <EnemyStateMachine>().EnemyStats.expToGive + " expierence"; EndBattlePanel.SetActive(true); } if (!expadd && clicksCount == 2) { EndBattlePanel.transform.FindChild("Text").GetComponent <Text>().text = "Click again to end the battle\n"; GameManager.instance.Player.GetComponent <Player>().coins += En.GetComponent <EnemyStateMachine>().EnemyStats.coinsToGive; IncreaseExp.AddExperience(En.GetComponent <EnemyStateMachine>().EnemyStats.expToGive); expadd = true; GameObject.Find("GameManager(Clone)").GetComponent <GameManager>().saveData(); //levelUpText(0); } if (clicksCount == 3) { SceneManager.LoadScene(0); } } break; } switch (HeroInput) { case (HeroGUI.ACTIVATE): if (HeroesToManage.Count > 0) { HeroesToManage [0].transform.FindChild("Selector").gameObject.SetActive(true); HeroChoise = new HandleTurns(); ActionPanel.SetActive(true); CreateAttackButtons(); HeroInput = HeroGUI.WAITING; } break; case (HeroGUI.WAITING): break; case (HeroGUI.DONE): HeroInputDone(); break; } }
// Use this for initialization void Start() { _hero = FindObjectOfType<HeroStateMachine> (); _crystals = FindObjectsOfType<DomeCrystal>(); _bubbles = FindObjectsOfType<LightBubble>(); }
// Update is called once per frame private void Update() { if (PerformList.Count == charactersCount) { ExecutePerformList = new List <HandleTurn>(PerformList); SortTurnOrder(ExecutePerformList); PerformList.Clear(); }//*/ switch (BattleStates) { case (PerformAction.WAIT): { // if at least one character has // pushed action data to turn list if (ExecutePerformList.Count > 0) { BattleStates = PerformAction.TAKEACTION; Debug.Log("TAKEACTION started"); } break; } case (PerformAction.TAKEACTION): { GameObject performer = GameObject.Find(ExecutePerformList[0].Attacker); if (ExecutePerformList[0].Type == "Enemy") { EnemyStateMachine esm = performer.GetComponent <EnemyStateMachine>(); esm.HeroToAttack = ExecutePerformList[0].AttackersTarget; esm.CurrentState = EnemyStateMachine.TurnState.ACTION; } if (ExecutePerformList[0].Type == "Hero") { HeroStateMachine hsm = performer.GetComponent <HeroStateMachine>(); hsm.EnemyToAttack = ExecutePerformList[0].AttackersTarget; hsm.CurrentState = HeroStateMachine.TurnState.ACTION; } BattleStates = PerformAction.PERFORMACTION; break; } case (PerformAction.PERFORMACTION): { // placeholder state while // characters perform action // Resets to WAIT // when action is completed break; } } // switch (BattleStates) switch (HeroInput) { case (HeroGUI.ACTIVATE): { if (HerosToManage.Count > 0 && ExecutePerformList.Count == 0) { HerosToManage[0].transform.Find("Selector").gameObject.SetActive(true); heroChoice = new HandleTurn(); AttackPanel.SetActive(true); HeroInput = HeroGUI.WAITING; } break; } case (HeroGUI.WAITING): { // idle state break; } case (HeroGUI.INPUT1): { // not used yet break; } case (HeroGUI.INPUT2): { // not used yet break; } case (HeroGUI.DONE): { HeroInputDone(); break; } } // switch (HeroInput) } // void Update()
// Update is called once per frame void Update() { if (Gamemanager.instance.detectE == true) { enemysinBattle.AddRange(GameObject.FindGameObjectsWithTag("Enemy")); characterInput = characterGUI.activate; attackPanel.SetActive(false); EnemySelect.SetActive(false); SkillsPanel.SetActive(false); EnemyButtons(); Gamemanager.instance.noEnemys = false; Gamemanager.instance.detectE = false; } switch (battlestates) { case (performAction.wait): if (PerformList.Count > 0) { battlestates = performAction.takeaction; } break; case (performAction.takeaction): GameObject performer = GameObject.Find(PerformList [0].attacker); if (PerformList [0].Type == "Enemy") { EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine> (); for (int i = 0; i < charactersinBattle.Count; i++) { if (PerformList [0].attackersTarget == charactersinBattle [i]) { ESM.charactertoattack = PerformList [0].attackersTarget; ESM.currentState = EnemyStateMachine.TurnState.action; break; } else { PerformList[0].attackersTarget = charactersinBattle[Random.Range(0, charactersinBattle.Count)]; ESM.charactertoattack = PerformList [0].attackersTarget; ESM.currentState = EnemyStateMachine.TurnState.action; } } } if (PerformList [0].Type == "Player c") { HeroStateMachine HSM = performer.GetComponent <HeroStateMachine> (); HSM.enemytoAttack = PerformList [0].attackersTarget; HSM.currentState = HeroStateMachine.TurnState.action; } battlestates = performAction.performaction; break; case (performAction.performaction): //idle break; case (performAction.checkAlive): if (charactersinBattle.Count < 1) { battlestates = performAction.lose; //lose } else if (enemysinBattle.Count < 1) { Gamemanager.instance.noEnemys = true; battlestates = performAction.win; //win } else { clearAttackPanel(); characterInput = characterGUI.activate; battlestates = performAction.wait; } break; case (performAction.lose): { Debug.Log("lose"); } break; case (performAction.win): { Debug.Log("win"); for (int i = 0; i < charactersinBattle.Count; i++) { charactersinBattle[i].GetComponent <HeroStateMachine>().currentState = HeroStateMachine.TurnState.waiting; } battlestates = performAction.wait; } break; } switch (characterInput) { case (characterGUI.activate): if (charactersToManage.Count > 0) { characterChoise = new HandleTurn(); attackPanel.SetActive(true); CreateAttackButtons(); characterInput = characterGUI.waiting; } break; case (characterGUI.waiting): //Idle break; case (characterGUI.done): characterInputDone(); break; } }
// Update is called once per frame void Update() { switch (BattleStates) { case (PerformAction.Wait): if (PerformList.Count > 0) { BattleStates = PerformAction.TakeAction; } break; case (PerformAction.TakeAction): GameObject performer = GameObject.Find(PerformList[0].Attacker); if (PerformList[0].type == "enemy") { EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine>(); ESM.HeroToAttack = PerformList[0].AttackersTarget; ESM.CurrentState = EnemyStateMachine.Turnstate.Action; } if (PerformList[0].type == "Hero") { HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>(); HSM.EnemyToAttack = PerformList[0].AttackersTarget; HSM.CurrentState = HeroStateMachine.Turnstate.Action; } BattleStates = PerformAction.PerformAction; break; case (PerformAction.PerformAction): break; } switch (HeroInput) { case (HeroGUI.Activate): if (HerosToManage.Count > 0) { HerosToManage[0].transform.Find("Selector").gameObject.SetActive(true); HeroChoice = new HandleTurns(); AttackPanel.SetActive(true); HeroInput = HeroGUI.Waiting; } break; case (HeroGUI.Waiting): break; case (HeroGUI.Done): HeroInputDone(); break; } }
// Update is called once per frame void Update() { switch (battleStates) { case (PerformAction.WAIT): if (PerformList.Count > 0) { battleStates = PerformAction.TAKEACTION; } break; case (PerformAction.TAKEACTION): GameObject performer = PerformList[0].AttackersGameObject; if (PerformList[0].Type == "Enemy") { EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine>(); ESM.Target = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.ACTION; } if (PerformList[0].Type == "Hero") { HSM = performer.GetComponent <HeroStateMachine>(); HSM.Target = PerformList[0].AttackersTarget; HSM.currentState = HeroStateMachine.TurnState.ACTION; } foreach (GameObject unit in EnemiesInBattle) { if (unit.tag != "DeadEnemy") { unit.GetComponent <EnemyStateMachine>().ApplyDotDamage(); } } foreach (GameObject unit in HeroesInBattle) { if (unit.tag != "DeadHero") { unit.GetComponent <HeroStateMachine>().ApplyDotDamage(); } } battleStates = PerformAction.PERFORMACTION; break; case (PerformAction.PERFORMACTION): //idle break; } switch (HeroInput) { case (HeroGUI.ACTIVATE): if (HeroesToManage.Count > 0 && PerformList.Count == 0) { HeroesToManage[0].transform.Find("Selector").gameObject.SetActive(true); HeroChoice = new HandleTurn(); ActionPanel.SetActive(true); //populate action buttons CreateActionButtons(); HeroInput = HeroGUI.WAITING; } break; case (HeroGUI.WAITING): //idle break; case (HeroGUI.DONE): HeroInputDone(); break; } if (EnemiesAlive == 0 && battleStarted == true && BattleOver == false) { GameObject.Find("WorldState").GetComponent <WorldState>().PlayVictoryMusic(); EndingText.text = "Victory!"; EndBattleButton.SetActive(true); ActionPanel.SetActive(false); TargetSelectPanel.SetActive(false); HSM = null; HeroesToManage.Clear(); battleStates = PerformAction.WAIT; HeroInput = HeroGUI.WAITING; performer = null; //clean actionpanel foreach (GameObject ActionButton in ActionButtons) { Destroy(ActionButton); } ActionButtons.Clear(); foreach (GameObject targetButton in TargetButtons) { Destroy(targetButton); } TargetButtons.Clear(); GameObject.Find("WorldState").GetComponent <WorldState>().heroVictory = true; BattleOver = true; } if (HeroesAlive == 0 && battleStarted == true && BattleOver == false) { GameObject.Find("WorldState").GetComponent <WorldState>().PlayDefeatMusic(); EndingText.text = "Defeat"; EndBattleButton.SetActive(true); ActionPanel.SetActive(false); TargetSelectPanel.SetActive(false); HSM = null; HeroesToManage.Clear(); battleStates = PerformAction.WAIT; HeroInput = HeroGUI.WAITING; performer = null; //clean actionpanel foreach (GameObject ActionButton in ActionButtons) { Destroy(ActionButton); } ActionButtons.Clear(); foreach (GameObject targetButton in TargetButtons) { Destroy(targetButton); } TargetButtons.Clear(); GameObject.Find("WorldState").GetComponent <WorldState>().heroVictory = false; BattleOver = true; } if (CharacterBarsCreated == true) { UpdateCharacterBars(); } }
void FixedUpdate() { switch (battleStates) { case (PerformAction.Wait): if (PerformList.Count > 0) { battleStates = PerformAction.TakeAction; } break; case (PerformAction.TakeAction): GameObject performer = GameObject.Find(PerformList[0].Attacker); if (PerformList[0].Type == "Enemy") { StartCoroutine(AiWait()); /* EnemyStateMachine ESM = performer.GetComponent<EnemyStateMachine>(); * ESM.HeroToAttack = PerformList[0].AttackersTarget; * ESM.currentState = EnemyStateMachine.TurnState.Action;*/ } if (PerformList[0].Type == "Hero") { HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>(); HSM.EnemyToAttack = PerformList[0].AttackersTarget; HSM.currentState = HeroStateMachine.TurnState.Action; } battleStates = PerformAction.PerformAction; break; case (PerformAction.PerformAction): break; case (PerformAction.Checkalive): if (HeroesInBattle.Count < 1) { battleStates = PerformAction.Lose; } else if (EnemiesInBattle.Count < 1) { battleStates = PerformAction.Win; } else { clearActionPanel(); HeroInput = HeroGui.Activate; } break; case (PerformAction.Win): { Time.timeScale = 1f; if (!victoryBool) { Instantiate(VictoryTextPrefab); goBackButton.SetActive(true); victoryBool = true; Debug.Log("victoryBool = " + victoryBool); } Debug.Log("You win"); for (int i = 0; i < HeroesInBattle.Count; i++) { HeroesInBattle[i].GetComponent <HeroStateMachine>().currentState = HeroStateMachine.TurnState.Waiting; //int tempshit = i + 1; //string heroValue = "Hero" + tempshit.ToString() + "HP"; //Debug.Log (heroValue); //float hpTemp = PlayerPrefs.GetFloat (heroValue); //float hpTemp = HeroesInBattle[i].GetComponent<BaseHero>().curHP; //PlayerPrefs.SetFloat (heroValue, hpTemp); } } break; case (PerformAction.Lose): { Time.timeScale = 1f; if (!loseBool) { Instantiate(LoseTextPrefab); goBackButton.SetActive(true); loseBool = true; } Debug.Log("You lose"); } break; } switch (HeroInput) { case (HeroGui.Activate): if (HeroesToManage.Count > 0) { //Time.timeScale = 0.3f; HeroesToManage[0].transform.Find("Selector").gameObject.SetActive(true); HeroChoise = new HandleTurn(); ActionPanel.SetActive(true); //populate buttons CreateAttackButtons(); HeroInput = HeroGui.Waiting; } break; case (HeroGui.Waiting): break; case (HeroGui.Done): HeroInputDone(); break; } }
// Update is called once per frame void Update() { switch (battleStates) { case (PerformAction.WAIT): if (PerformList.Count > 0) { battleStates = PerformAction.TAKEACTION; } break; case (PerformAction.TAKEACTION): GameObject performer = PerformList[0].AttackersGameObject; if (PerformList[0].Type == "Enemy") { EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine>(); for (int i = 0; i < HerosInBattle.Count; i++) { if (PerformList[0].AttackersTarget == HerosInBattle[i]) { ESM.HeroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.ACTION; break; } else { PerformList[0].AttackersTarget = HerosInBattle[Random.Range(0, HerosInBattle.Count)]; ESM.HeroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.ACTION; } } } if (PerformList[0].Type == "Hero") { HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>(); HSM.EnemyToAttack = PerformList[0].AttackersTarget; HSM.currentState = HeroStateMachine.TurnState.ACTION; } battleStates = PerformAction.PERFORMACTION; break; case (PerformAction.PERFORMACTION): //idle break; case (PerformAction.CHECKALIVE): if (HerosInBattle.Count < 1) { battleStates = PerformAction.LOSE; //lose game } else if (gameManager.enemiesToBattle.Count < 1) { battleStates = PerformAction.WIN; //win game } else { //call function clearAttackPanel(); HeroInput = HeroGUI.ACTIVATE; } break; case (PerformAction.LOSE): { SceneManager.LoadScene(1); } break; case (PerformAction.WIN): { SceneManager.LoadScene(2); for (int i = 0; i < HerosInBattle.Count; i++) { HerosInBattle[i].GetComponent <HeroStateMachine>().currentState = HeroStateMachine.TurnState.WAITING; } } break; } switch (HeroInput) { case (HeroGUI.ACTIVATE): if (HerosToManage.Count > 0) { HerosToManage[0].transform.Find("Selector").gameObject.SetActive(true); //create new handleturn instance HeroChoice = new HandleTurn(); AttackPanel.SetActive(true); //populate action buttons CreateAttackButtons(); HeroInput = HeroGUI.WAITING; } break; case (HeroGUI.WAITING): break; case (HeroGUI.DONE): HeroInputDone(); break; } }
// Update is called once per frame void Update() { switch (BattleStates) { case (PerformAction.Wait): if (PerformList.Count > 0) { BattleStates = PerformAction.TakeAction; } break; case (PerformAction.TakeAction): GameObject performer = GameObject.Find(PerformList[0].Attacker); if (PerformList[0].Type == "Enemy") { EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine>(); for (int i = 0; i < HerosInBattle.Count; i++) { if (PerformList[0].AttackersTarget == HerosInBattle[i]) { ESM.HeroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.Action; break; } else { PerformList[0].AttackersTarget = HerosInBattle[Random.Range(0, HerosInBattle.Count)]; ESM.HeroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.Action; } } } if (PerformList[0].Type == "Hero") { HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>(); HSM.EnemyToAttack = PerformList[0].AttackersTarget; HSM.currentState = HeroStateMachine.TurnState.Action; } BattleStates = PerformAction.PerformAction; break; case (PerformAction.PerformAction): //idle break; case (PerformAction.CheckAlive): if (HerosInBattle.Count < 1) { BattleStates = PerformAction.Lose; //lose the battle } else if (EnemysInBattle.Count < 1) { BattleStates = PerformAction.Win; //win the battle } else { ClearAttackPanel(); //call function HeroInput = HeroGUI.Activate; } break; case (PerformAction.Lose): { Debug.Log("KAYBETTİN"); } break; case (PerformAction.Win): { Debug.Log("KAZANDIN"); for (int i = 0; i < HerosInBattle.Count; i++) { HerosInBattle[i].GetComponent <HeroStateMachine>().currentState = HeroStateMachine.TurnState.Waiting; } GameManager.instance.LoadSceneAfterBattle(); GameManager.instance.gameStates = GameManager.GameStates.World_State; GameManager.instance.enemysToBattle.Clear(); } break; } switch (HeroInput) { case (HeroGUI.Activate): if (HerosToManage.Count > 0) { HerosToManage[0].transform.Find("Selector").gameObject.SetActive(true); //create new handleturn instance HeroChoise = new HandleTurn(); AttackPanel.SetActive(true); //populate action buttons CreateAttackButtons(); HeroInput = HeroGUI.Waiting; } break; case (HeroGUI.Waiting): break; case (HeroGUI.Done): HeroInputDone(); break; } }
// Update is called once per frame void Update() { switch (battleStates) { case (PerformAction.WAIT): { if (PerformList.Count > 0) { battleStates = PerformAction.TAKEACTION; } break; } case (PerformAction.TAKEACTION): { GameObject performer = GameObject.Find(PerformList[0].Attacker); if (PerformList[0].Type == "Enemy") { EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine>(); for (int i = 0; i < HerosInBattle.Count; i++) { if (PerformList[0].AttackersTarget == HerosInBattle[i]) { ESM.HeroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.ACTION; break; } else { PerformList[0].AttackersTarget = HerosInBattle[Random.Range(0, HerosInBattle.Count)]; ESM.HeroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.ACTION; } } } if (PerformList[0].Type == "Hero") { HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>(); HSM.EnemyToAttack = PerformList[0].AttackersTarget; HSM.currentState = HeroStateMachine.TurnState.ACTION; } battleStates = PerformAction.PERFORMACTION; break; } case (PerformAction.PERFORMACTION): { break; } case (PerformAction.CHECKALIVE): { if (HerosInBattle.Count < 1) { battleStates = PerformAction.LOSE; //lose game } else if (EnemysInBattle.Count < 1) { battleStates = PerformAction.WIN; //win game } else { ClearAttackPanel(); HeroInput = HeroGUI.ACTIVATE; } break; } case (PerformAction.WIN): { for (int i = 0; i < HerosInBattle.Count; i++) { HerosInBattle[i].GetComponent <HeroStateMachine>().currentState = HeroStateMachine.TurnState.WAITING; } break; } case (PerformAction.LOSE): { break; } } switch (HeroInput) { case (HeroGUI.ACTIVATE): { HerosToManage[0].transform.Find("Selector").gameObject.SetActive(true); HeroChoice = new HandleTurn(); AttackPanel.SetActive(true); CreateAttackButtons(); HeroInput = HeroGUI.WAITING; break; } case (HeroGUI.WAITING): { break; } case (HeroGUI.DONE): { HeroInputDone(); break; } } }
// Update is called once per frame void Update() { switch (battleState) { case PerformAction.WAIT: if (performList.Count > 0) { battleState = PerformAction.TAKEACTION; } break; case PerformAction.TAKEACTION: GameObject performer = GameObject.Find(performList[0].attacker); if (performList[0].type == "Enemy") { EnemyStateMachine enemySM = performer.GetComponent <EnemyStateMachine>(); for (int i = 0; i < heroesInBattle.Count; i++) { if (performList[0].targetGameObject == heroesInBattle[i]) { enemySM.actionTarget = performList[0].targetGameObject; enemySM.currentState = EnemyStateMachine.TurnState.ACTION; break; } else { performList[0].targetGameObject = heroesInBattle[Random.Range(0, heroesInBattle.Count)]; enemySM.actionTarget = performList[0].targetGameObject; enemySM.currentState = EnemyStateMachine.TurnState.ACTION; } } battleState = PerformAction.PERFORMACTION; } if (performList[0].type == "Hero") { HeroStateMachine heroSM = performer.GetComponent <HeroStateMachine>(); heroSM.actionTarget = performList[0].targetGameObject; if (heroSM.currentState != HeroStateMachine.TurnState.DEAD) { heroSM.currentState = HeroStateMachine.TurnState.ACTION; battleState = PerformAction.PERFORMACTION; } else { performList.Remove(performList[0]); battleState = PerformAction.CHECKALIVE; } } break; case PerformAction.PERFORMACTION: //idle break; case PerformAction.CHECKALIVE: if (heroesInBattle.Count < 1) { battleState = PerformAction.LOSE; } else if (enemiesInBattle.Count < 1) { battleState = PerformAction.WIN; } else { ClearAttackPanel(); heroInput = HeroGUI.ACTIVATE; } break; case PerformAction.WIN: for (int i = 0; i < heroesInBattle.Count; i++) { heroesInBattle[i].GetComponent <HeroStateMachine>().currentState = HeroStateMachine.TurnState.WAITING; } resultScreen.GetComponentInChildren <Text>().text = "YOU WIN"; resultScreen.SetActive(true); StartCoroutine(WinBattle()); break; case PerformAction.LOSE: resultScreen.GetComponentInChildren <Text>().text = "YOU LOSE"; resultScreen.SetActive(true); StartCoroutine(LoseBattle()); break; } switch (heroInput) { case HeroGUI.ACTIVATE: if (heroesToManage.Count > 0) { heroesToManage[0].transform.Find("Selector").gameObject.SetActive(true); heroChoice = new HandleTurn(); actionPanel.SetActive(true); backPanel.SetActive(false); CreateAttackButtons(); heroInput = HeroGUI.WAITING; } break; case HeroGUI.WAITING: //idle break; case HeroGUI.DONE: HeroInputDone(); break; } }
// Update is called once per frame void Update() { //Debug.Log(battleStates); switch (battleStates) { case (PerformAction.WAIT): if (performList.Count > 0) { battleStates = PerformAction.TAKEACTION; } break; case (PerformAction.TAKEACTION): //get attacker and the name of the attacker GameObject performer = performList[0].attacksGameObject; //target list if (performList[0].type == "Enemy") //who is going to this animation { EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine>(); //checking is currently attacked hero is in battle for (int i = 0; i < heroesInBattle.Count; i++) { //checking attacker target same with hero in battle if (performList[0].attackersTarget == heroesInBattle[i]) { ESM.heroToAttack = performList[0].attackersTarget; ESM.currentState = EnemyStateMachine.TurnState.ACTION; break; } else { //prevent attack on dead hero performList[0].attackersTarget = heroesInBattle[UnityEngine.Random.Range(0, heroesInBattle.Count)]; ESM.heroToAttack = performList[0].attackersTarget; ESM.currentState = EnemyStateMachine.TurnState.ACTION; } } } if (performList[0].type == "Hero") { HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>(); HSM.enemyToAttack = performList[0].attackersTarget; HSM.currentState = HeroStateMachine.TurnState.ACTION; } battleStates = PerformAction.PERFORMACTION; break; case (PerformAction.PERFORMACTION): //idle break; case (PerformAction.CHECKLIFE): if (heroesInBattle.Count < 1) { //lose the battle battleStates = PerformAction.LOSE; } else if (enemyInBattle.Count < 1) { //win the battle battleStates = PerformAction.WIN; } else { ClearAttackButton(); heroInput = HeroGUI.ACTIVATE; } break; case (PerformAction.WIN): for (int i = 0; i < heroesInBattle.Count; i++) { heroesInBattle[i].GetComponent <HeroStateMachine>().currentState = HeroStateMachine.TurnState.WAITING; } GameManager.gameInstance.LoadSceneAfterBattle(); GameManager.gameInstance.gameState = GameManager.GameStates.WORLD_STATE; GameManager.gameInstance.enemiesToBattle.Clear(); break; case (PerformAction.LOSE): break; } //hero panel input switch (heroInput) { case (HeroGUI.ACTIVATE): if (heroesToManage.Count > 0) { heroesToManage[0].transform.Find("Selector").gameObject.SetActive(true); heroChoise = new HandleTurn(); attackPanel.SetActive(true); CreateButton(); heroInput = HeroGUI.WAITING; //set to waiting after activa } break; case (HeroGUI.WAITING): break; case (HeroGUI.DONE): HeroInputDone(); break; } }
// Update is called once per frame private void Update() { if (PerformersList.Count == charactersCount) { ExecutePerformersList = new List <HandleTurn>(PerformersList); SortTurnOrder(ExecutePerformersList); PerformersList.Clear(); }//*/ switch (BattleState) { case (ActionState.WAIT): { winLoseCheck(); // if at least one character has // pushed action data to turn list if (ExecutePerformersList.Count > 0) { BattleState = ActionState.TAKEACTION; Debug.Log("TAKEACTION Started"); } break; } case (ActionState.TAKEACTION): { GameObject performer = GameObject.Find(ExecutePerformersList[0].AttackersName); if (ExecutePerformersList[0].Type == "Enemy") { EnemyStateMachine esm = performer.GetComponent <EnemyStateMachine>(); // Check if target is still alive if (HeroesInBattle.Count > 0) { esm.CheckTargetDead(ExecutePerformersList[0]); } // Set Enemy's current target esm.HeroToAttack = ExecutePerformersList[0].AttackersTarget; // Attack Target esm.CurrentState = EnemyStateMachine.TurnState.ACTION; } if (ExecutePerformersList[0].Type == "Hero") { HeroStateMachine hsm = performer.GetComponent <HeroStateMachine>(); hsm.Action = ExecutePerformersList[0].Action; //if (EnemiesInBattle.Count > 0 && hsm.EnemyToAttack != null) { hsm.CheckTargetDead(ExecutePerformersList[0]); } if (hsm.Action != ActionType.GUARD) { hsm.EnemyToAttack = ExecutePerformersList[0].AttackersTarget; } // review this code when more actions become developed hsm.CurrentState = HeroStateMachine.TurnState.ACTION; } BattleState = ActionState.PERFORMACTION; break; } case (ActionState.PERFORMACTION): { // placeholder state while // characters perform action // Resets to WAIT // when action is completed break; } } // switch (BattleState) switch (PlayerInput) { case (HeroGUI.ACTIVATE): { if (HeroesToManage.Count > 0 && ExecutePerformersList.Count == 0) { HeroesToManage.Sort(SortHeroesByTurnPriority); HeroesToManage[0].transform.Find("Selector").gameObject.SetActive(true); herosChoice = new HandleTurn(); AttackPanel.SetActive(true); PlayerInput = HeroGUI.WAITING; } break; } case (HeroGUI.WAITING): { // idle state break; } case (HeroGUI.INPUT1): { // not used yet break; } case (HeroGUI.INPUT2): { // not used yet break; } case (HeroGUI.DONE): { HeroInputDone(); break; } } // switch (HeroInput) } // void Update()
// Update is called once per frame void Update() { switch (battleStates) { case (PerformAction.WAIT): if (PerformList.Count > 0) { battleStates = PerformAction.TAKEACTION; } break; case (PerformAction.TAKEACTION): GameObject performer = GameObject.Find(PerformList[0].AttackersGameObject.name); //Debug.Log(GameObject.Find(PerformList[0].AttackersGameObject.name)); if (PerformList[0].Type == "Enemy") { //Debug.Log(performer); EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine>(); //Check hero is dead for (int i = 0; i < HeroesInGame.Count; i++) // we don't need a for loop because we have just 1 hero. { //if attackers target is hero and not dead go on. if (PerformList[0].AttackersTarget == HeroesInGame[i]) { ESM.heroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.ACTION; break; } //if the attackers target is hero and dead select another hero and go on //this is not necessary too. else { PerformList[0].AttackersTarget = HeroesInGame[Random.Range(0, HeroesInGame.Count)]; ESM.heroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.ACTION; } } ESM.heroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.ACTION; } randomEnemyAttack = Random.Range(0, 2); //Debug.Log(randomEnemyAttack); if (PerformList[0].Type == "Hero") { // Debug.Log("Hero is ready"); HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>(); HSM.EnemyToAttack = PerformList[0].AttackersTarget; HSM.EnemyToAttackCube = PerformList[0].AttackersTargetCube; HSM.currentState = HeroStateMachine.TurnState.ACTION; } if (PerformList[0].Type == "Enemy") { if (randomEnemyAttack == 0) { enemyisSpell = true; } else { enemyisSpell = false; } } battleStates = PerformAction.PERFORMACTION; break; case (PerformAction.PERFORMACTION): break; case (PerformAction.CHECKALIVE): if (HeroesInGame.Count < 1) { battleStates = PerformAction.LOSE; //Lose the battle } else if (EnemiesInGame.Count < 1) { battleStates = PerformAction.WIN; //Win the battle } else { clearAttackPanel(); HeroInput = HeroGUI.ACTIVATE; } break; case (PerformAction.LOSE): Debug.Log("You LOSE the battle"); SceneManager.LoadScene(youlose); break; case (PerformAction.WIN): Debug.Log("You win the battle"); for (int i = 0; i < HeroesInGame.Count; i++) { HeroesInGame[i].GetComponent <HeroStateMachine>().currentState = HeroStateMachine.TurnState.WAITING; } SceneManager.LoadScene(youwin); break; } switch (HeroInput) { case (HeroGUI.ACTIVATE): if (HeroesToManage.Count > 0) { HeroChoice = new HandleTurns(); ActionPanel.SetActive(true); CreateAttackButtons(); HeroInput = HeroGUI.WAITING; } break; case (HeroGUI.WAITING): //idle break; case (HeroGUI.DONE): HeroInputDone(); break; } }
// Update is called once per frame void Update() { switch (battlestates) { case (PerformAction.Wait): if (PerformList.Count > 0) { battlestates = PerformAction.TakeAction; } break; case (PerformAction.TakeAction): GameObject performer = GameObject.Find(PerformList[0].Attacker); if (PerformList[0].Type == "Enemy") { EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine>(); for (int i = 0; i < HerosInBattle.Count; i++) { if (PerformList[0].AttackersTarget == HerosInBattle[i]) { ESM.heroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.Action; break; } else { PerformList[0].AttackersTarget = HerosInBattle[Random.Range(0, HerosInBattle.Count)]; ESM.heroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.Action; } } } if (PerformList[0].Type == "Hero") { HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>(); HSM.EnemyToAttack = PerformList[0].AttackersTarget; HSM.currentState = HeroStateMachine.TurnState.Action; } battlestates = PerformAction.PerformAction; break; case (PerformAction.PerformAction): //idle break; case (PerformAction.CheckAlive): if (HerosInBattle.Count < 1) { battlestates = PerformAction.Lose; //lose the battle } else if (EnemiesInBattle.Count < 1) { battlestates = PerformAction.Win; //win the battle //gain experience //gain money } else { //call function ClearAttackPanel(); HeroInput = HeroGui.Activate; } break; case (PerformAction.Win): { Debug.Log("You won the battle!"); for (int i = 0; i < HerosInBattle.Count; i++) { HerosInBattle[i].GetComponent <HeroStateMachine>().currentState = HeroStateMachine.TurnState.Waiting; } } break; case (PerformAction.Lose): { Debug.Log("You lost the battle!"); } break; } switch (HeroInput) { case (HeroGui.Activate): if (HeroesToManage.Count > 0) { HeroesToManage[0].transform.Find("Selector").gameObject.SetActive(true); HeroChoice = new HandleTurn(); AttackPanel.SetActive(true); //populate action buttons CreateAttackButtons(); HeroInput = HeroGui.Waiting; } break; case (HeroGui.Waiting): break; case (HeroGui.Input1): break; case (HeroGui.Input2): break; case (HeroGui.Done): HeroInputDone(); break; } }
// Update is called once per frame void Update() { switch (m_battleStates) { case (PerformAction.WAIT): // if (m_performList.Count > 0) { m_battleStates = PerformAction.TAKEACTION; } break; case (PerformAction.TAKEACTION): GameObject performer = GameObject.Find(m_performList[0].Attacker); // if (m_performList[0].Type == "Enemy") { EnemyStateMachine esm = performer.GetComponent <EnemyStateMachine>(); for (int i = 0; i < m_heroes.Count; i++) { if (m_performList[0].Target == m_heroes[i]) { esm.m_heroTarget = m_performList[0].Target; esm.m_currentState = EnemyStateMachine.TurnState.ACTION; break; } else { int j = Random.Range(0, m_heroes.Count); m_performList[0].Target = m_heroes[j]; esm.m_heroTarget = m_performList[0].Target; esm.m_currentState = EnemyStateMachine.TurnState.ACTION; } } } // if (m_performList[0].Type == "Hero") { HeroStateMachine hsm = performer.GetComponent <HeroStateMachine>(); hsm.m_enemyTarget = m_performList[0].Target; hsm.m_currentState = HeroStateMachine.TurnState.ACTION; } m_battleStates = PerformAction.PERFORMACTION; break; case (PerformAction.PERFORMACTION): // Idle break; case (PerformAction.CHECKALIVE): // Lose battle if (m_heroToManage.Count < 1) { m_battleStates = PerformAction.LOSE; } // Win battle else if (m_enemies.Count < 1) { m_battleStates = PerformAction.WIN; } else { clearAttackPanel(); m_heroInput = HeroGUI.ACTIVATE; } break; case (PerformAction.WIN): Debug.Log("You Win!"); break; case (PerformAction.LOSE): Debug.Log("You Lose!"); break; } switch (m_heroInput) { case (HeroGUI.ACTIVATE): if (m_heroToManage.Count > 0) { m_herosChoice = new HandleTurn(); m_actionPanel.SetActive(true); createAttackButtons(); m_heroInput = HeroGUI.WAITING; } break; case (HeroGUI.WAITING): break; case (HeroGUI.DONE): heroInputDone(); for (int i = 0; i < m_heroes.Count; i++) { m_heroes[i].GetComponent <HeroStateMachine>().m_currentState = HeroStateMachine.TurnState.WAITING; } break; } m_heroHPs[0] = m_heroes[0].GetComponent <HeroStateMachine>().m_hero.m_currentHP; m_heroHPs[1] = m_heroes[1].GetComponent <HeroStateMachine>().m_hero.m_currentHP; m_heroHPs[2] = m_heroes[2].GetComponent <HeroStateMachine>().m_hero.m_currentHP; }
void Update() { switch (battleState) { case (PerformAction.WAIT): if (PerformList.Count > 0) { battleState = PerformAction.TAKEACTION; } break; case (PerformAction.TAKEACTION): //Grabbing the performer that should currently be attacking GameObject performer = GameObject.Find(PerformList [0].Attacker); if (PerformList [0].Type == "Enemy") { //Getting the state machine from the enemy that is currently attacking EnemyStateMachine ESM = performer.GetComponent <EnemyStateMachine> (); //Checks if the hero they are attacking is still alive for (int i = 0; i < HeroesInBattle.Count; i++) { if (PerformList [0].AttackersTarget == HeroesInBattle [i]) { //Setting the hero to attack based on the handleturn object that was sent over to the performlist ESM.heroToAttack = PerformList [0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.ACTION; break; } else { //Makes enemy attack a new targer if old target is dead PerformList[0].AttackersTarget = HeroesInBattle[Random.Range(0, HeroesInBattle.Count)]; ESM.heroToAttack = PerformList [0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.ACTION; } } } if (PerformList [0].Type == "Hero") { //Getting the state machine from the hero that is currently attacking HeroStateMachine HSM = performer.GetComponent <HeroStateMachine>(); //WE'RE ALL IN THIS TOGETHER //Setting the enemy to attack based on the handleturn object that was sent over to the performlist HSM.enemyToAttack = PerformList[0].AttackersTarget; HSM.currentState = HeroStateMachine.TurnState.ACTION; } battleState = PerformAction.PERFORMACTION; break; case (PerformAction.PERFORMACTION): //idle break; //visual studio crapped out on me so monogames if f#$king with all the spacing when putting in new code.... case (PerformAction.CHECKALIVE): //This handles win and lose changes and dead hero cleanup if (HeroesInBattle.Count < 1) { //lose battle battleState = PerformAction.LOSE; } else if (EnemiesInBattle.Count < 1) { //win battle battleState = PerformAction.WIN; } else { //call function ClearActionPanel(); heroInput = HeroGUI.ACTIVATE; } break; case (PerformAction.WIN): Debug.Log("You win"); for (int i = 0; i < HeroesInBattle.Count; i++) { HeroesInBattle [i].GetComponent <HeroStateMachine> ().currentState = HeroStateMachine.TurnState.WAITING; } break; case (PerformAction.LOSE): Debug.Log("You lose"); break; } switch (heroInput) { case (HeroGUI.ACTIVATE): //Checks to see if there are any heroes to manage if (heroesToManage.Count > 0) { heroesToManage[0].transform.Find("Selector").gameObject.SetActive(true); //vreates new handleturn instance heroChoice = new HandleTurn(); actionPanel.SetActive(true); //populates action buttons CreateAttackButtons(); heroInput = HeroGUI.WAITING; } break; case (HeroGUI.WAITING): //idle state break; case (HeroGUI.DONE): HeroInputDone(); break; } }
void Update() { switch(battleStates) { case (PerformAction.Wait): if(PerformList.Count > 0) { battleStates = PerformAction.TakeAction; } break; case (PerformAction.TakeAction): GameObject performer = GameObject.Find(PerformList[0].Attacker); if(PerformList[0].Type == "Enemy") { StartCoroutine(AiWait()); /* EnemyStateMachine ESM = performer.GetComponent<EnemyStateMachine>(); ESM.HeroToAttack = PerformList[0].AttackersTarget; ESM.currentState = EnemyStateMachine.TurnState.Action;*/ } if (PerformList[0].Type == "Hero") { HeroStateMachine HSM = performer.GetComponent<HeroStateMachine>(); HSM.EnemyToAttack = PerformList[0].AttackersTarget; HSM.currentState = HeroStateMachine.TurnState.Action; } battleStates = PerformAction.PerformAction; break; case (PerformAction.PerformAction): break; case (PerformAction.Checkalive): if(HeroesInBattle.Count < 1) { battleStates = PerformAction.Lose; } else if(EnemiesInBattle.Count < 1) { battleStates = PerformAction.Win; } else { clearActionPanel(); HeroInput = HeroGui.Activate; } break; case (PerformAction.Win): { if(!victoryBool) { Instantiate(VictoryTextPrefab); victoryBool = true; } Debug.Log("You win"); for(int i = 0; i< HeroesInBattle.Count; i++) { HeroesInBattle[i].GetComponent<HeroStateMachine>().currentState = HeroStateMachine.TurnState.Waiting; } } break; case (PerformAction.Lose): { if(!loseBool) { Instantiate(LoseTextPrefab); loseBool = true; } Debug.Log("You lose"); } break; } switch(HeroInput) { case (HeroGui.Activate): if(HeroesToManage.Count > 0) { HeroesToManage[0].transform.Find("Selector").gameObject.SetActive(true); HeroChoise = new HandleTurn(); ActionPanel.SetActive(true); //populate buttons CreateAttackButtons(); HeroInput = HeroGui.Waiting; } break; case (HeroGui.Waiting): break; case (HeroGui.Done): HeroInputDone(); break; } }
// Update is called once per frame void Update() { switch (battleState) { case (performAction.WAIT): if (list.Count > 0) { battleState = performAction.TAKEACTION; } break; case (performAction.TAKEACTION): Debug.Log(list[0].Attacker); GameObject performer = GameObject.Find(list[0].Attacker); Debug.Log(performer); if (list[0].Type == "Enemy") { EnemyStateMachine esm = performer.GetComponent <EnemyStateMachine>(); for (int i = 0; i < heroes.Count; i++) { if (list[0].attackersTarget == heroes[i]) { esm.hero = list[0].attackersTarget; esm.currentState = EnemyStateMachine.TurnState.ACTION; break; } /*else * { * list[0].attackersTarget = heroes[Random.Range(0, heroes.Count)]; * }*/ } } if (list[0].Type == "Hero") { HeroStateMachine hsm = performer.GetComponent <HeroStateMachine>(); hsm.enemyToAttack = list[0].attackersTarget; hsm.currentState = HeroStateMachine.TurnState.ACTION; } battleState = performAction.PERFORMACTION; break; case (performAction.CHECKALIVE): if (heroes.Count == 0) { //lose game Debug.Log("Lost"); battleState = performAction.LOSE; } else if (enemies.Count == 0) { //win battle Debug.Log("Win"); for (int i = 0; i < heroes.Count; i++) { heroes[i].GetComponent <HeroStateMachine>().currentState = HeroStateMachine.TurnState.WAITING; } battleState = performAction.WIN; } else { //call function //ActionList.SetActive(false); gameManager.GetComponent <GameStates>().List.SetActive(false); heroInput = heroGUI.ACTIVATE; } break; case (performAction.PERFORMACTION): break; case (performAction.LOSE): break; case (performAction.WIN): Destroy(GameObject.FindGameObjectWithTag("Dead enemy")); Destroy(GameObject.Find("BattleManager(Clone)")); gameManager.GetComponent <GameStates>().state = GameStates.GameState.WORLDSTATE; break; } switch (heroInput) { case (heroGUI.ACTIVATE): if (heroesToManage.Count > 0) { //heroesToManage[0] heroChoice = new HandleTurn(); //ActionList.SetActive(true); gameManager.GetComponent <GameStates>().List.SetActive(true); heroInput = heroGUI.WAITING; } break; case (heroGUI.WAITING): break; case (heroGUI.DONE): heroInputDone(); break; } }
static void Main(string[] args) { Console.WriteLine("状态模式:"); Context context = new Context(new StateA()); context.Request(); context.Request(); context.Request(); context.Request(); #region 角色系统 //Role role = new Role(new Primary(), 0.0f); //role.IsVictory = true; //role.Play(); //role.IsVictory = true; //role.Play(); //role.IsVictory = true; //role.Play(); //role.IsVictory = true; //role.Play(); //role.IsVictory = true; //role.Play(); //role.IsVictory = true; //role.Play(); //role.IsVictory = false; //role.Play(); //role.IsVictory = false; //role.Play(); //role.IsVictory = false; //role.Play(); //role.IsVictory = false; //role.Play(); //role.IsVictory = false; //role.Play(); //role.IsVictory = false; //role.Play(); //role.IsVictory = false; //role.Play(); //role.IsVictory = false; //role.Play(); //role.IsVictory = false; //role.Play(); //role.IsVictory = false; //role.Play(); #endregion #region 输门 //TransmissionGate transGate = new TransmissionGate(new Closed()); //transGate.Complete(); //transGate.Click(); //transGate.TimeOut(); //transGate.Click(); //transGate.Complete(); //transGate.TimeOut(); //transGate.Click(); //transGate.Complete(); //transGate.TimeOut(); //transGate.Click(); //transGate.Complete(); //transGate.Click(); //transGate.Click(); //transGate.Complete(); #endregion Idle idle = new Idle(); Walk walk = new Walk(); Jump jump = new Jump(); Attack attack = new Attack(); idle.AddTransition(new JyTransition(idle, walk, 'w')); idle.AddTransition(new JyTransition(idle, jump, 'j')); idle.AddTransition(new JyTransition(idle, attack, 'k')); walk.AddTransition(new JyTransition(walk, idle, 's')); walk.AddTransition(new JyTransition(walk, jump, 'j')); walk.AddTransition(new JyTransition(walk, attack, 'k')); jump.AddTransition(new JyTransition(jump, idle, 's')); jump.AddTransition(new JyTransition(jump, walk, 'w')); jump.AddTransition(new JyTransition(jump, attack, 'k')); attack.AddTransition(new JyTransition(attack, idle, 's')); attack.AddTransition(new JyTransition(attack, walk, 'w')); attack.AddTransition(new JyTransition(attack, jump, 'j')); HeroStateMachine heroStateMachine = new HeroStateMachine(idle); heroStateMachine.AddState(walk); heroStateMachine.AddState(jump); heroStateMachine.AddState(attack); ConsoleKeyInfo ConsoleKeyInfo = new ConsoleKeyInfo(); while (ConsoleKeyInfo.Key != ConsoleKey.Escape) { ConsoleKeyInfo = Console.ReadKey(); Console.WriteLine(ConsoleKeyInfo.Key.ToString()); heroStateMachine.Word = ConsoleKeyInfo.KeyChar; heroStateMachine.OnStay(); } }
// Update is called once per frame void Update() { endCombatCheck = true; foreach (GameObject enemy in Enemies) { if (enemy.GetComponent <EnemyStateMachine>().currentState != EnemyStateMachine.TurnState.DEAD) { endCombatCheck = false; } } if (endCombatCheck) { endCombatWin(); } endCombatCheck = true; foreach (GameObject hero in Heros) { if (hero.GetComponent <HeroStateMachine>().currentState != HeroStateMachine.TurnState.DEAD) { endCombatCheck = false; } } if (endCombatCheck) { endCombatLoss(); } switch (battleState) { case (PerformAction.WAIT): if (PerformList.Count > 0) { battleState = PerformAction.TAKEACTION; } break; case (PerformAction.TAKEACTION): GameObject performer = GameObject.Find(PerformList[0].AttackerName); if (PerformList[0].Type == "Enemy") { EnemyStateMachine ESM; try { ESM = performer.GetComponent <EnemyStateMachine>(); } catch { PerformList.RemoveAt(0); battleState = PerformAction.WAIT; break; } ESM.heroToAttack = PerformList[0].Defender; ESM.currentState = EnemyStateMachine.TurnState.ACTION; battleState = PerformAction.PERFORMACTION; } else if (PerformList[0].Type == "Hero") { HeroStateMachine HSM; try { HSM = performer.GetComponent <HeroStateMachine>(); } catch { PerformList.RemoveAt(0); battleState = PerformAction.WAIT; break; } HSM.enemyToAttack = PerformList[0].Defender; HSM.currentState = HeroStateMachine.TurnState.ACTION; battleState = PerformAction.PERFORMACTION; } break; case (PerformAction.PERFORMACTION): GameObject person = GameObject.Find(PerformList[0].AttackerName); if (PerformList[0].Type == "Enemy") { EnemyStateMachine ESM = person.GetComponent <EnemyStateMachine>(); if (ESM.currentState == EnemyStateMachine.TurnState.DEAD) { PerformList.RemoveAt(0); battleState = PerformAction.WAIT; } } else if (PerformList[0].Type == "Hero") { HeroStateMachine HSM = person.GetComponent <HeroStateMachine>(); if (HSM.currentState == HeroStateMachine.TurnState.DEAD) { PerformList.RemoveAt(0); battleState = PerformAction.WAIT; } } break; } switch (HeroInput) { case (HeroGUI.ACTIVATE): pause = false; if (HerosToManage.Count > 0) { pause = true; HerosToManage[0].transform.Find("Selector").gameObject.SetActive(true); HeroTurn = new BattleTurn(); attackPanel.SetActive(true); HeroInput = HeroGUI.WAITING; } break; case (HeroGUI.WAITING): break; case (HeroGUI.DONE): HeroInputDone(); break; } }