/// <summary> /// Used to Cancel any ongoing attack and dash frames /// </summary> public void Cancel() { // Set combat state to Recovery combatState = CombatStates.Recovery; // Set attackTime to a high value to immediately end recovery frames attackTime = 9999; movement.dashTime = .00000001f; // incredibly small positive number so the next frame will end the dash }
// Start is called before the first frame update void Start() { state = CombatStates.NONE; health = 100.0f; damage = 20.0f; player = GameObject.Find("Player"); anim = GetComponent <Animator>(); }
void Awake() { userInput = GameObject.Find("Canvas").GetComponentInChildren <InputField>(); textControllerObj = GameObject.Find("TextControllerObject"); currentState = CombatStates.INITIATIVESORT; }
public void EnemyDeathCleanUp() { music.EnemyDeadSound(); GameObject.Find("Main Camera").GetComponent <FollowPlayer>().inCombat = false; Destroy(tempEnemy); combatState = CombatStates.OutofCombat; hero.GetComponent <moveCharacter>().StartMoving(); }
public Defence(GameObject parentObject, string name, float reflex, CombatStates stateThisRunsIn, bool active) : base(parentObject, name, stateThisRunsIn, active) { this.parentObject = parentObject; this.abilityName = name; this.reflex = reflex; this.runsInState = stateThisRunsIn; this.activeAbility = active; }
// Use this for initialization void Start() { S = this; currentState = CombatStates.NOTHING; //player is not in combat as soon as the game begins //main camera is turned on, combat camera is kept off cam1.enabled = true; cam2.enabled = false; }
// This is used to have a short pause between turns, need to use StartCoroutine(WaitTurn("some number")) to call this IEnumerator WaitTurn(float time) { yield return(new WaitForSecondsRealtime(time)); powersBar.SetActive(false); // ***TEMP*** itemBar.SetActive(false); // ***TEMP*** assessBar.SetActive(false); // ***TEMP*** currentState = CombatStates.START; }
// Update is called once per frame void Update() { //state machine that will do different things depending on what is going on //start will initialize combat and bring up the combat overlay //player's turn will offer the player a few decisions //enemy's turn will do different things based on the enemy switch (currentState) { case (CombatStates.START): //starting combat //print("Combat!"); if (cam2.enabled == false) { //GameObject.Find("Player").GetComponent<PlayerMovement>().enabled = false; would disable player movement while combat is going on but results in some janky movements bugs cam1.enabled = false; cam2.enabled = true; Spawn(); CombatUI.S.isShowing = true; CombatUI.S.showUI(); currentState = CombatStates.PLAYER; } break; case (CombatStates.PLAYER): //player's turn if (PlayerChoice.S.currHealth <= 0) { currentState = CombatStates.LOSE; // if the player runs out of the health, it boots them to the lose situation. Which currently does nothing but sounds ominious } break; case (CombatStates.ENEMY): //enemy's turn break; case (CombatStates.WIN): //winning condition cam1.enabled = true; cam2.enabled = false; CombatUI.S.isShowing = false; CombatUI.S.showUI(); //GameObject.Find("Player").GetComponent<PlayerMovement>().enabled = true; disabled due to bugs break; case (CombatStates.RUN): //Player flees from combat //GameObject.Find("Player").GetComponent<PlayerMovement>().enabled = false; disabled due to bugs break; case (CombatStates.LOSE): //losing condition, currently does nothing break; } }
public void ResolveEnemyAttack() { //music.FireSound(); bool dead = DamageHero(baseEnemyDmg); if (!dead) { combatState = CombatStates.InputSetup; } }
void Awake() { animator = gameObject.GetComponent <Animator>(); //Debug.Log("Player switching Combat states"); combatState = CombatStates.None; //Debug.Log("Player switching Attacks"); currentAttack = Attacks.None; entity = this.GetComponent <Entity>(); movement = this.GetComponent <PlayerMovement>(); enemyMan = GameObject.Find("EnemyManagerGO").GetComponent <EnemyManager>(); ppChange = GameObject.Find("Main Camera").GetComponent <PostProcessChange>(); hitFlashTimer = 0; }
void TurnRNG(int playAgility, int enAgility) { float ratio; ratio = (float)playAgility / (float)enAgility; Debug.Log ("ratio = " + ratio.ToString ()); float playerTurnChance = 50.0f * ratio; float rand = Random.Range (0, 101); if (rand <= playerTurnChance) { currentState = CombatStates.PlayerTurn; } else { currentState = CombatStates.EnemyTurn; } }
/** * the combat manager's psuedo update function. * GameStateMachine calls this every frame while combat is running. */ internal GameStateMachine.GameState Update2ElectricBoogaloo() { switch (currentState) { // we are in combat -> check for input and check for deaths case CombatStates.InCombat: HandleInput(); if (Input.GetKeyDown(KeyCode.Escape)) { currentState = CombatStates.Paused; pauseMenu.SetActive(true); } return(CheckHealth()); // combat ended and the player is in the post-combat menu case CombatStates.PostCombatMenu: // the player is leaving the menu -> end combat if (Input.GetKeyDown(KeyCode.Space)) { // disable some UI elements GameObject pW = GameObject.FindGameObjectWithTag("PlayerWeapons"); if (pW != null) { pW.transform.parent.parent.gameObject.SetActive(false); } GameObject.FindGameObjectWithTag("SlotUnlocked").gameObject.GetComponent <TextMeshProUGUI>().enabled = false; //equipmentBarCanvas.GetComponent<Canvas>().enabled = true; combatUI.GetComponent <Canvas>().enabled = false; //// player reached weapon slot 4 -> we win! (temporary) //if (playerStats.WeaponSlots == 4) // return GameStateMachine.GameState.PlayerWon; // we're going to the overworld return(GameStateMachine.GameState.Overworld); } // player is still in the post-combat menu return(GameStateMachine.GameState.Combat); case CombatStates.Paused: if (Input.GetKeyDown(KeyCode.Escape) || Input.GetKeyDown(KeyCode.Space)) { ResumeGame(); } return(GameStateMachine.GameState.Combat); default: throw new System.Exception(); } }
// Use this for initialization void Start() { currentState = CombatStates.Start; turnText.text = "Battle Begin"; enemyHealthText.text = "Enemy Health: " + enemyHealth.ToString (); playerHealthText.text = "Player Health: " + playerHealth.ToString (); playerPos = PositionRNG () * -2; enemyPos = PositionRNG () * 2; Vector3 temp = new Vector3(0,0,(float)enemyPos); enemy.transform.position += temp; temp = new Vector3(0,0,(float)playerPos); player.transform.position += temp; LoadCombatInfo.LoadCombatGameInfo (); }
public void NotifyHit() { if (m_CurrentCombatState == CombatStates.Regular) { m_ShieldHealth--; if (m_ShieldHealth <= 0) { m_CurrentCombatState = CombatStates.Cloning; m_EnemyAI.m_IsInvincible = true; m_Shield.SwitchToRed(); } } }
void CheckPlayerHP(int character) { switch (character) { case (1): if (teamStats.MageHealth <= 0) { Debug.Log("Mage has " + teamStats.MageHealth + " skipping"); incrTurn++; Debug.Log("turn incr to " + incrTurn); currState = CombatStates.TURN; break; } break; case (2): if (teamStats.TankHealth <= 0) { Debug.Log("Tank has " + teamStats.TankHealth + " skipping"); incrTurn++; Debug.Log("turn incr to " + incrTurn); currState = CombatStates.TURN; break; } break; case (3): if (teamStats.SupportHealth <= 0) { Debug.Log("Supp has " + teamStats.SupportHealth + " skipping"); incrTurn++; Debug.Log("turn incr to " + incrTurn); currState = CombatStates.TURN; break; } break; default: if (teamStats.PlayerHealth <= 0) { Debug.Log("Hero has " + teamStats.PlayerHealth + " skipping"); incrTurn++; Debug.Log("turn incr to " + incrTurn); currState = CombatStates.TURN; break; } break; } }
// Update is called once per frame void Update() { //state machine that will do different things depending on what is going on //start will initialize combat and bring up the combat overlay //player's turn will offer the player a few decisions //enemy's turn will do different things based on the enemy switch (currentState) { case(CombatStates.START): //starting combat //print("Combat!"); if (cam2.enabled == false) { //GameObject.Find("Player").GetComponent<PlayerMovement>().enabled = false; would disable player movement while combat is going on but results in some janky movements bugs cam1.enabled = false; cam2.enabled = true; Spawn(); CombatUI.S.isShowing = true; CombatUI.S.showUI(); currentState = CombatStates.PLAYER; } break; case(CombatStates.PLAYER): //player's turn if (PlayerChoice.S.currHealth <= 0) { currentState = CombatStates.LOSE; // if the player runs out of the health, it boots them to the lose situation. Which currently does nothing but sounds ominious } break; case(CombatStates.ENEMY): //enemy's turn break; case(CombatStates.WIN): //winning condition cam1.enabled = true; cam2.enabled = false; CombatUI.S.isShowing = false; CombatUI.S.showUI(); //GameObject.Find("Player").GetComponent<PlayerMovement>().enabled = true; disabled due to bugs break; case(CombatStates.RUN): //Player flees from combat //GameObject.Find("Player").GetComponent<PlayerMovement>().enabled = false; disabled due to bugs break; case(CombatStates.LOSE): //losing condition, currently does nothing break; } }
void CheckEnemyHP(int enemy) { switch (enemy) { case (1): if (EnemyStats.Goon2HP <= 0) { Debug.Log("goon5 has " + EnemyStats.Goon2HP + " left, skipping"); incrTurn++; Debug.Log("turn incr to " + incrTurn); currState = CombatStates.TURN; break; } break; case (2): if (EnemyStats.Goon3HP <= 0) { Debug.Log("goon6 has " + EnemyStats.Goon3HP + " left, skipping"); incrTurn++; Debug.Log("turn incr to " + incrTurn); currState = CombatStates.TURN; break; } break; case (3): if (EnemyStats.Goon4HP <= 0) { Debug.Log("goon7 has " + EnemyStats.Goon4HP + " left, skipping"); incrTurn++; Debug.Log("turn incr to " + incrTurn); currState = CombatStates.TURN; break; } break; default: if (EnemyStats.GoonHP <= 0) { Debug.Log("goon4 has " + EnemyStats.GoonHP + " left, skipping"); incrTurn++; Debug.Log("turn incr to " + incrTurn); currState = CombatStates.TURN; break; } break; } }
public void CombatStart(GameObject hero, GameObject enemy) { var levelOfRoom = GameObject.Find("TowerManager").GetComponent <LevelManager>().currentFloor; this.hero = hero; this.tempEnemy = enemy; SetWordDifficulty(GetTrueRoomLevel(levelOfRoom)); SetEnemyHealth(tempEnemy.name, GetTrueRoomLevel(levelOfRoom)); healthBarV2 = Instantiate(enemyBarPrefab, new Vector3(tempEnemy.transform.position.x, tempEnemy.transform.position.y + 2f, tempEnemy.transform.position.z + 1.5f), Quaternion.Euler(0, -90, 0)); wordDisplay.StartDisplay(OnTextCompleted, OnTimerExpired, OnIncorrectLetter); combatState = CombatStates.InputSetup; }
// Cloned combat update void Cloned() { // If the cloned timer has run out then change the combat state to regular and clear the list of clones if (m_ClonedTimer <= 0) { m_CurrentCombatState = CombatStates.Regular; m_Clones.Clear(); m_ShieldHealth = SHIELD_HEALTH; return; } // Move, attack and decrement the cloned timer Movement(); Combat(); m_ClonedTimer -= Time.deltaTime; }
IEnumerator SelectAbility(Being being) //should perhaps be called Select ability { Debug.Log("starting " + being.beingName + "'s turn" + " HP:" + being.GetResourceValue("HP", 1) + " STAMINA:" + being.GetResourceValue("STAMINA", 1)); //Any looking for passive or some such would go here being.GetUseableActiveAbilities(); if (being.useableAbilities.Count > 0) { if (being.playerControlled == true) { for (int i = 0; i < being.useableAbilities.Count; i++) { Debug.Log(i + ". " + being.useableAbilities[i].abilityName); } if (playerSelection > -1) { being.SelectTargets(being.useableAbilities[playerSelection - 1]); } if (being.selectedAbility == null) { currentState = CombatStates.WAITFORPLAYERINPUT; } savedState = CombatStates.SELECTABILITY; } if (being.playerControlled == false) { being.SelectAnAbility(); being.SelectTargets(being.selectedAbility); Debug.Log(being.beingName + " chooses " + being.selectedAbility.abilityName); yield return(new WaitForSeconds(textSpeed)); CalculateToHit(being, being.selectedAbility, being.selectedTargets); yield return(new WaitForSeconds(textSpeed)); nextTurnDone = false; } } else { Debug.Log(being.beingName + " can't do anything! (is this an error?)"); nextTurnDone = false; yield return(null); } }
/// <summary> /// This used to be a part of TakeDamage but I found it was useful to reuse it for Shine counters too /// </summary> /// <param name="knockbackMultiplier">How much the next hit of knockback will be multiplied by</param> public virtual void BreakGuard(float knockbackMultiplier) { //Flag guard broken state // guardBroken = true; //Get stunned stunTime = guardBreakStunTime; // TurnedStunOff //Modify knockback knockbackModifier = knockbackMultiplier; //Reset states ResetCombatStates(); //Update states to stun //Debug.Log("Switching Enemy states 8"); enemyState = EnemyStates.Stunned; //Debug.Log("Switching Combat states 5"); combatState = CombatStates.Stunned; Debug.Log("Guard broken @ " + Time.fixedTime); }
/// <summary> /// Resets some variables to restore the enemy to a neutral state in combat /// </summary> public void ResetCombatStates() { invincible = false; //Debug.Log("Switching Enemy states 9"); enemyState = EnemyStates.Idle; //Debug.Log("Switching Combat states 6"); combatState = CombatStates.None; isAttacking = false; attackTime = 0f; elapsedApproachTime = 0f; knockbackModifier = 1f; guarding = false; dodging = false; counterattacking = false; entity.SpeedModifier = 1f; hitPlayer = false; }
// Use this for initialization void OnLevelLoaded(Scene scene, LoadSceneMode mode) { if (scene.name.StartsWith("Combat")) { Debug.Log("Scene loading"); _player = gameObject; inCombat = true; Instance = this; flowcharts = FindObjectsOfType <Flowchart>(); ///Set up Negotiation flowchart foreach (Flowchart v in flowcharts) { if (v.name == "Negotiation") { flowchart = v; } } _state = CombatStates.StaminaFilling; _targetSelected = false; _partyCount = GameObject.FindGameObjectsWithTag("party").Length; _enemyCount = GameObject.FindGameObjectsWithTag("enemy").Length; targets = GameObject.FindGameObjectsWithTag("party").Concat(GameObject.FindGameObjectsWithTag("enemy")).ToArray(); gameObject.GetComponent <CurrentState>().OnVariableChange += VariableChangeHandler; gameObject.GetComponent <CurrentState>().OnActionChange += ActionChangeHandler; EmotionBubble(GameObject.FindGameObjectsWithTag("enemy").ToArray()); foreach (var target in targets) { //TODO: Add everyone who could be in the fight so that their status bars exist if (target.name.StartsWith("Player")) { target.GetComponent <StatsPlayer>().SetPlayerStatusBars(); } if (target.name.StartsWith("Chace")) { target.GetComponent <StatsChace>().SetPlayerStatusBars(); } if (target.name.StartsWith("Guard")) { target.GetComponent <StatsGuard>().SetPlayerStatusBars(); } } } }
void AddDamage(int wordLength) { damage = wordLength * 5; Debug.Log("Word Dmg: " + damage); damageToGive += damage; bool maxed = GameObject.FindGameObjectWithTag("HitPointBar").GetComponent <ManageHitPoints>().BuildUp(damage); if (maxed) { wordDisplay.StopDisplay(); combatState = CombatStates.HeroAttack; } else { wordDisplay.NewText(tempEnemy.transform, list.GetWord(curDifficulty)); } }
private void checkWinner() { Tools.amountDead = 0; List <DataManager> partyFolk = new List <DataManager>(); partyFolk.Add(JunakDataManager.Junak); if (SaralfDataManager.Saralf.isInParty) { partyFolk.Add(SaralfDataManager.Saralf); } List <EnemyDataManager> enemies = new List <EnemyDataManager>(); enemies.Add(EnemyDataManager.EnemyManager); if (EnemyDataManager.EnemyManager.amountOfEnemies >= 2) { enemies.Add(EnemyDataManagerTwo.EnemyManagerTwo); } foreach (DataManager member in partyFolk) { if (member.health <= 0) { Tools.amountDead += 1; } } Tools.deadEnemies = 0; for (int i = 0; i < EnemyDataManager.EnemyManager.amountOfEnemies; i++) { if (enemies[i].health <= 0) { Tools.deadEnemies += 1; } } if (Tools.amountDead == (Tools.getCombatantsAmount() - EnemyDataManager.EnemyManager.amountOfEnemies)) { Debug.Log(Tools.amountDead); combatState = CombatStates.EnemyWon; } if (Tools.deadEnemies == EnemyDataManager.EnemyManager.amountOfEnemies) { combatState = CombatStates.PlayerWon; } }
void Start() { GameObject gameObj; gameObj = GameObject.FindGameObjectWithTag("MainCamera"); camPosition = gameObj.GetComponent <Transform>(); mainCam = gameObj.GetComponent <MainCamera>(); gameObj = GameObject.FindGameObjectWithTag("Player"); playerController = gameObj.GetComponent <PlayerController>(); gameObj = GameObject.Find("Enemy Positions"); enemyPositions = gameObj.GetComponentsInChildren <Transform>(); combatPosition = GameObject.Find("combat position").GetComponent <Transform>(); state = CombatStates.START; }
public IEnumerator EnemyTurn() { UiManager.instance.PopAllScreens(); m_CurrentTurnHolder = 0; m_BattleStates = CombatStates.EnemyTurn; m_NextTurn = NextEnemyTurn; m_SwapToOtherSide = AllyTurn; m_UiTabTurnKeeper.SetIconType(false); UpdateCurrentTurnAmount(m_TurnOrderEnemy.Count); PressTurnManager.instance.StartTurn(m_TurnOrderEnemy.Count); yield return(new WaitForEndOfFrame()); StartCoroutine(m_NextTurn()); }
private void HitByPlayer() { //Check timer if (m_HitByPlayerTimer > 0.0f) { //Decrement and call movement function m_HitByPlayerTimer -= Time.deltaTime; Movement(); } else { //Reset Timer m_HitByPlayerTimer = MaxTimeAfterHitByPlayer; //Set to building up charge m_CombatState = CombatStates.BuildingUpCharge; EnemyAnimator.playAnimation(AnimatorSpinTops.Animations.ExitWobble); } }
private void CalculateToHitDefence(Being attacker, Ability ability, List <Being> targets, float toHit) { currentState = CombatStates.CALCULATETOHITDEFENCE; for (int i = 0; i < targets.Count; i++) { if (targets[i].mentalReflex < toHit) { checkForRelevantpassiveAbilities(); Print("Sorting defences..."); targets[i].sortDefences(); if (targets[i].defences[0].reflex >= toHit) { targets[i].defences[0].Use(); } else { Print(targets[i].beingName + ": Shit, I can't move fast enough!"); } } else { //you get a choice of action including attacks, defences, everything. currentState = CombatStates.PLAYERTURN; } } /* * calc tohitdefence(float tohit) * * is tohit above your concious notice (mental reflex?) * if yes * do you have any passive defences that can take something of that speed? * if yes * The first one fires * if no * "shit I can't move fast enough!" * * if no * you get a choice of action including attacks, defences, everything. * */ }
/** * we are entering combat -> set some necessary values */ internal void Init() { inCombat = true; currentState = CombatStates.InCombat; // set up combat scene combatScenes[GetCombatIndexForCurrentLevel()].SetActive(true); if (GameStateMachine.CurrentLevel == GameStateMachine.Level.Boss) { combatCamera.transform.position = bossCameraLocation.position; combatCamera.transform.rotation = bossCameraLocation.rotation; } else { combatCamera.transform.position = regularCameraLocation.position; combatCamera.transform.rotation = regularCameraLocation.rotation; } // gets the enemy engaging with the player and its stats enemy = entityManager.CombatEnemy; enemyStats = enemy.GetComponent <EnemyStats>(); enemy.GetComponent <EnemyMovement>().ToggleExcl(false); // move the enemy to the combat plane and set up its UI enemy.transform.position = enemyCombatLocation.position;//new Vector3(-4.31f, 1f, -86.92f); enemy.transform.LookAt(combatPlayer.transform); enemy.transform.GetComponentInChildren <Billboard>().cam = combatCamera.transform; // set up UI -> disable equipment bar, enable combat UI //equipmentBarCanvas.GetComponent<Canvas>().enabled = false; combatUI.GetComponent <Canvas>().enabled = true; // start combat for each of the player's weapons foreach (Weapon weapon in playerStats.weapons) { if (weapon != null) { weapon.StartCombat(); } } // start combat for the enemy enemyStats.StartCombat(); }
private void BuildingUpCharge() { m_EnemyAI.m_IsInvincible = true; //Check charge timer if (m_ChargeTimer < CHARGE_BUILD_UP_TIME) { //Increment charge Timer as long as it is less than our build up time m_ChargeTimer += Time.deltaTime; } else { //Call build up movement Movement(); //Reset timer m_ChargeTimer = 0.0f; //Switch to the charge state m_CombatState = CombatStates.Charge; } }
private void KnockedBack() { m_EnemyAI.m_IsInvincible = false; //If the knockback timer is greater than 0 if (m_KnockBackTimer > 0.0f) { //Decrement timer and call the funcion for knockback m_KnockBackTimer -= Time.deltaTime; Movement(); } else { //Reset knockback timer m_KnockBackTimer = MaxKnockBackTime; //Set to building charge m_CombatState = CombatStates.BuildingUpCharge; } }
void GetVariables() { m_Input = FindObjectOfType <Player_Input>(); m_Movement = FindObjectOfType <Player_Movement>(); m_CameraMovement = FindObjectOfType <Player_CameraMovement>(); m_UI = FindObjectOfType <Player_UI>(); m_Gun = FindObjectOfType <Player_Gun>(); m_Interact = FindObjectOfType <Player_Interact>(); MainCamera = Camera.main; CombatState = CombatStates.Idle; MovingState = MovingStates.Walking; HP = MaxHP; Shield = MaxShield; AnimationState = AnimationStates.Idle; SetUpPools(); }
void ChangeState(CombatStates To) { _fsm.Transition(_fsm.state, To); if (_transitions != null) { _transitions = null; } _transitions += CheckStates; }
public void AttemptToFlee() { Random percentageSeed = new Random(6854); Random escapeChance = new Random(); double percentage = ((this.pc.Level * this.enemy.Level) * percentageSeed.NextDouble()) + 50.0d; if ((percentage + pc.Level) >= escapeChance.Next(0, 101)) { this.currentState = CombatStates.Fled; } }
void Start() { Random.seed = 0; enemy = GetComponent<AI>(); goal = false; CurrentState = CombatStates.STARTTURN; }
public void updateMachine() { //Debug.Log(CurrentState); switch (CurrentState) { case (CombatStates.STARTTURN): BattleManager.beginTurn(); Debug.Log("(CSM) ST -> PS"); actions = BattleManager.playerParty.Count; CurrentState = CombatStates.PLAYERSELECT; break; case (CombatStates.PLAYERSELECT): //Check Unit selected. if (BattleManager.playerEnemy== true) { Debug.Log("(CSM) PS->PE"); CurrentState = CombatStates.PLAYERENEMY; BattleManager.playerEnemy = false; } else if (BattleManager.playerPlayer== true) { Debug.Log("(CSM) PS->PP"); CurrentState = CombatStates.PLAYERPLAYER; BattleManager.playerPlayer = false; } break; case (CombatStates.PLAYERENEMY): --actions; StartCoroutine("player_target_enemy"); goal = checkWin(); StartCoroutine("endAction"); Debug.Log("ACTIONS : "+ actions); if (goal == true) { Debug.Log("(CSM) PE->GOAL (Win)"); CurrentState = CombatStates.WIN; } else if (actions == 0) { Debug.Log("(CSM) PE->E"); BattleManager.endTurn(); CurrentState = CombatStates.ENEMY; } else { Debug.Log("(CSM) PE->PS"); CurrentState = CombatStates.PLAYERSELECT; } break; case (CombatStates.PLAYERPLAYER): --actions; StartCoroutine("player_target_player"); StartCoroutine("endAction"); if (actions == 0) { Debug.Log("(CSM) PP->E"); BattleManager.endTurn(); CurrentState = CombatStates.ENEMY; } else { Debug.Log("(CSM) PP->PS"); CurrentState = CombatStates.PLAYERSELECT; } break; case (CombatStates.ENEMY): actions = BattleManager.enemyParty.Count; for (int i = 0; i < actions; ++i ) StartCoroutine("enemyTurn"); goal = checkLoss(); if (goal) { Debug.Log("(CSM) E->GOAL(L)"); CurrentState = CombatStates.LOSE; } else { Debug.Log("(CSM) E->ST"); BattleManager.turnCounter++; CurrentState = CombatStates.STARTTURN; } break; case (CombatStates.LOSE): loss(); break; case (CombatStates.WIN): win(); break; } }
protected override void start() { //Call all the start functions for each movement component m_CombatComponent.start(this); m_TargetingComponent.start(this); m_MovementComponent.start(this); m_ChargeMovement.start(this); m_BuildingChargeMovement.start(this); m_KnockedBackMovement.start(this); m_HitByPlayerMovement.start(this); //Initialize variables m_CombatState = CombatStates.BuildingUpCharge; m_WobbleTimer = MaxWobbleTime; m_KnockBackTimer = MaxKnockBackTime; m_HitByPlayerTimer = MaxTimeAfterHitByPlayer; m_ChargeTimer = 0.0f; m_IsCharging = false; m_EnemyAI.m_IsInvincible = true; m_EnemyAI.addNotifyHit (this); }
public void NotifyHit() { //Call Hit ByPlayer movement m_HitByPlayerMovement.Movement(getTarget()); //Switch to the Hit player state m_CombatState = CombatStates.HitByPlayer; }
private void Charge() { m_EnemyAI.m_IsInvincible = true; //EnemyAnimator.playAnimation(AnimatorSpinTops.Animations.Attack); //Call charge movement Movement(); if (!m_PlayerHit) { //If the player hasn't been hit and we have reached our target behind the player if(GetDistanceToTarget() < m_ReachedTargetDistance) { //Set to wobble m_CombatState = CombatStates.Wobble; } } else { //If we have hit the player then get knockedback m_CombatState = CombatStates.KnockedBack; } }
public GameObject[] prefabEnemies; //collection of all the enemies to draw from #endregion Fields #region Methods //sets the combat state to whatever is given public void SetState(CombatStates cstate) { currentState = cstate; }
private void Wobble() { EnemyAnimator.playAnimation(AnimatorSpinTops.Animations.Wobble); //Set our spin top to not be invincible when wobbling m_EnemyAI.m_IsInvincible = false; //Call the wobble movement Movement(); if (m_WobbleTimer > 0.0f) { //aslong as the timer is greater than 0, decrement the timer m_WobbleTimer -= Time.deltaTime; } else { //If the timer is up then switch to BuildingUpCharge m_CombatState = CombatStates.BuildingUpCharge; EnemyAnimator.playAnimation(AnimatorSpinTops.Animations.ExitWobble); //Reset the timer m_WobbleTimer = MaxWobbleTime; } }
public void ProcessComputerTurn() { Attack enemyAttack = this.enemy.Attacks.FindLast(att => att.TPCost <= this.enemy.CurrentTP); this.enemy.Attack(enemyAttack.Name, this.pc, this); if (this.pc.CurrentHP <= 0) { this.currentState = CombatStates.Dead; } this.currentTurn = CombatTurns.Player; }
public void ProcessPlayerTurn(string attackName) { this.pc.Attack(attackName, this.enemy, this); if (this.enemy.CurrentHP <= 0) { this.currentState = CombatStates.Victory; } this.currentTurn = CombatTurns.Computer; this.ProcessComputerTurn(); }
private void init(PlayerCharacter PC, Enemy enemy) { this.pc = PC; this.enemy = enemy; this.currentState = CombatStates.InCombat; Random random = new Random(); if (random.Next(0, 101) <= 50) { this.currentTurn = CombatTurns.Player; this.firstTurn = CombatTurns.Player; } else { this.currentTurn = CombatTurns.Computer; this.firstTurn = CombatTurns.Computer; this.ProcessComputerTurn(); } }