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