/// <summary> /// Starts turn for this brain. /// </summary> /// <param name="brainController">BrainController</param> public void StartTurn(BrainController brainController) { // TODO: if the enemy is too close, step back a little to attack distance. var brainVariables = brainController.GetComponent <FightBrainVariables>(); brainVariables.turn = true; brainVariables.turnEnded = false; // Check the enemy. It can be dead. if (brainVariables.currentEnemy.avatarController.avatarStats.IsAlive == false) { brainVariables.currentEnemy = brainVariables.fightController.GetClosestEnemy(brainController); Logger.LogMessage($"{brainController.gameObject.name}::StartTurn " + $"-- enemy is dead. Getting new enemy : {brainVariables.currentEnemy}"); } var distanceToEnemy = Mathf.Abs(brainController.transform.position.x - brainVariables.currentEnemy.transform.position.x); // FIXME: Change this check if any other moving action will be implemented. if (distanceToEnemy > brainController.Stats.attackDistance && brainVariables.nextAction != runAction) { brainVariables.nextAction = GetNextAction(brainController); } if (brainVariables.nextAction == null) { Logger.LogMessage($"{name}::StartTurn -- nextAction is null.", LogType.Error); return; } brainVariables.currentAction = brainVariables.nextAction; Logger.LogMessage($"{brainController.gameObject.name}::StartTurn -- currentEnemy = {brainVariables.currentEnemy.gameObject.name}; " + $"currentAction = {brainVariables.currentAction.name}"); brainVariables.currentAction.InitAction(brainController); brainVariables.spriteSortOrder = brainController.animationController.SpriteSortOrder; // HACK: Hardcoded max sort order. // TODO: Also reorder text panels. brainController.animationController.SpriteSortOrder = 300; }
/// <summary> /// Update function to be called once each update. /// </summary> /// <param name="brainController">BrainController</param> /// <returns>actionEnded</returns> public override void UpdateBrain(BrainController brainController) { var brainVariables = brainController.GetComponent <FightBrainVariables>(); if (brainVariables.turn != false) { //Logger.LogMessage($"{brainController.gameObject.name}::UpdateBrain -- ") if (brainVariables.turnEnded) { EndTurn(brainController); } else if (brainVariables.currentAction != null) { brainVariables.turnEnded = brainVariables.currentAction.Act(brainController); } } else if (brainVariables.currentAction != null) { if (brainVariables.currentAction.Act(brainController)) { brainVariables.currentAction = null; //brainController.animationController.TriggerAnimation(ildeAnimationTrigger); } } }
/// <summary> /// Act function to be called once each update. /// </summary> /// <param name="brainController">BrainController</param> /// <returns>actionEnded</returns> public override bool Act(BrainController brainController) { var brainVariables = brainController.GetComponent <FightBrainVariables>(); if (brainController.animationEventHandler.damageDealt && brainController.animationEventHandler.animationTrigger == animationTrigger) { DealDamage(brainController); brainController.animationEventHandler.damageDealt = false; } var animationEnded = brainController.animationEventHandler.animationEnded; var sameAnimationTrigger = brainController.animationEventHandler.animationTrigger == animationTrigger; Logger.LogMessage($"{brainController.gameObject.name}::FightAttackAction::Act -- animationEnded = {animationEnded}, " + $"sameAnimationTrigger = {sameAnimationTrigger}"); bool enemyIsActing = false; var enemyFightVariables = brainVariables.currentEnemy.GetComponent <FightBrainVariables>(); if (enemyFightVariables == null) { Logger.LogMessage($"{brainVariables.currentEnemy.gameObject.name} is in fight but has no FightBrainVariables", LogType.Error); } else { enemyIsActing = enemyFightVariables.currentAction != null; } return(animationEnded && sameAnimationTrigger && enemyIsActing == false); }
/// <summary> /// Initializing function for brain. /// </summary> /// <param name="brainController">BrainController</param> public override void InitBrain(BrainController brainController) { var brainVariables = brainController.GetComponent <FightBrainVariables>(); if (brainVariables == null) { brainVariables = brainController.gameObject.AddComponent <FightBrainVariables>(); } if (actionList.Length == 0) { Logger.LogMessage($"{name}::InitBrain -- actionList is empty.", LogType.Error); } if (runAction == null) { Logger.LogMessage($"{name}::InitBrain -- runAction is not set.", LogType.Error); } if (string.IsNullOrEmpty(ildeAnimationTrigger)) { Logger.LogMessage($"{name}::InitBrain -- ildeAnimationTrigger is not set.", LogType.Error); } // FIXME: Make initiative roll dependent on some stat like dexterity. brainVariables.initiative = UnityEngine.Random.value; brainController.animationController.TriggerAnimation(ildeAnimationTrigger); // Set combat runSpeed to min run speed of Avatar. brainVariables.runSpeed = brainController.Stats.runSpeed.x; // HACK: We can't call GetNextAction yet, cause we dont have fightController passed to brain. // We will call first GetNextAction in SetFightController. // ---- brainVariables.nextAction = GetNextAction(brainController); brainVariables.turnEnded = false; brainController.avatarController.avatarStats.ShowHP = true; // FIXME: For first combat build. Add hp regeneration later. brainController.avatarController.avatarStats.ResetHP(); }
protected virtual bool CheckClipEvents(BrainController brainController) { var eventsList = brainController.animationController.GetClipAnimationEvents(animationTrigger); if (eventsList == null) { return(false); } Dictionary <string, bool> eventDictionary = new Dictionary <string, bool>(); foreach (var eventFunctionName in eventFunctionNames) { eventDictionary.Add(eventFunctionName, false); } foreach (var clipEvent in eventsList) { if (eventDictionary.ContainsKey(clipEvent.functionName)) { eventDictionary[clipEvent.functionName] = true; } } bool result = true; foreach (var hasEvent in eventDictionary) { if (hasEvent.Value == false) { result = false; Logger.LogMessage($"{brainController.gameObject.name}::FightAttackAction " + $"-- {hasEvent.Key} animation event is missing.", LogType.Error); } } return(result); }
public void OnDeath(BrainController deadFighter) { int teamID = GetFighterTeamID(deadFighter); if (turnQueue.Contains(deadFighter)) { turnQueue = new Queue <BrainController>(turnQueue.Where(t => t != deadFighter)); } turnTimersDictionary.Remove(deadFighter); Logger.LogMessage($"FightController::{deadFighter.gameObject.name} removed from turnTimersDictionary"); fighters = turnTimersDictionary.Keys.ToArray(); initiativeDictionary.Remove(deadFighter); Logger.LogMessage($"FightController::{deadFighter.gameObject.name} removed from initiativeDictionary"); teamsDictionary[teamID].Remove(deadFighter); Logger.LogMessage($"FightController::{deadFighter.gameObject.name} removed from teamsDictionary"); // FIXME: DictionaryKeyNotFound excepntion beggining from second combat. if (teamsDictionary[teamID].Count <= 0) { teamsDictionary.Remove(teamID); if (teamsDictionary.Count <= 1) { fightEnded = true; } } }
private void Awake() { animationController = GetComponent <AnimationController>(); messageQueue = GetComponent <MessageQueue>(); avatarStats = GetComponent <AvatarStats>(); brainController = GetComponent <BrainController>(); zombify = GetComponent <Zombify>(); }
public void EndFight(BrainController brainController) { var brainVariables = brainController.GetComponent <FightBrainVariables>(); // brainController.animationController.TriggerAnimation(ildeAnimationTrigger); brainController.avatarController.avatarStats.ShowHP = false; brainVariables.TeamID = 0; }
/// <summary> /// Initializing function for action. /// </summary> /// <param name="brainController">BrainController</param> public override void InitAction(BrainController brainController) { var brainVariables = brainController.GetComponent <IdleBrainVariables>(); //brainController.animationController.Direction = Random.Range(-1, 1) > 0 ? 1 : -1; Vector2 idleTime = brainController.Stats.idleTime; brainVariables.currentDistance = Random.Range(idleTime.x, idleTime.y); brainController.animationController.TriggerAnimation(animationTrigger); }
/// <summary> /// Gets random brainController from opposing team. /// </summary> /// <param name="brainController">Current fighter.</param> /// <returns>Random enemy.</returns> public BrainController GetRandomEnemy(BrainController brainController) { List <BrainController> possibleEnemies = GetPossibleEnemiesList(brainController); int enemyID = UnityEngine.Random.Range(0, possibleEnemies.Count); BrainController enemy = possibleEnemies.ToArray()[enemyID]; Debug.Log(brainController.gameObject.name + " chooses to attack " + enemy.gameObject.name); return(enemy); }
/// <summary> /// Saves current FightController to variables and rolls for initiative. /// </summary> /// <param name="brainController">BrainController</param> /// <param name="fightController">FightController</param> /// <returns>Initiative</returns> public float SetFightController(BrainController brainController, FightController fightController, int teamID) { var brainVariables = brainController.GetComponent <FightBrainVariables>(); brainVariables.fightController = fightController; brainVariables.nextAction = GetNextAction(brainController); brainVariables.TeamID = teamID; brainController.avatarController.avatarStats.OnDeath += fightController.OnDeath; return(brainVariables.initiative); }
private void DealDamage(BrainController brainController) { var brainVariables = brainController.GetComponent <FightBrainVariables>(); FightBrain fightBrain = (FightBrain)brainController.currentBrain; var avatarStats = brainController.Stats; int crit = Random.value <= avatarStats.critChance ? 1 : 0; float damage = Random.Range(avatarStats.damage.x, avatarStats.damage.y) * (1 + crit * (avatarStats.critMultiplayer - 1)); fightBrain.TakeDamage(brainVariables.currentEnemy, damage, crit == 1); }
private void EndTurn(BrainController brainController) { var brainVariables = brainController.GetComponent <FightBrainVariables>(); brainVariables.nextAction = GetNextAction(brainController); brainVariables.currentAction = null; brainVariables.turn = false; //brainController.animationController.TriggerAnimation(ildeAnimationTrigger); brainController.animationController.SpriteSortOrder = brainVariables.spriteSortOrder; brainVariables.fightController.EndTurn(lastFighter: brainController, cooldown: brainVariables.ActionCooldown); }
private void Awake() { brainController = GetComponent <BrainController>(); if (hpText == null) { Logger.LogMessage($"{gameObject.name}::AvatarStats -- hpText feild is not set.", LogType.Error); } if (hpPanel == null) { Logger.LogMessage($"{gameObject.name}::AvatarStats -- hpPanel feild is not set.", LogType.Error); } }
/// <summary> /// Act function to be called once each update. /// </summary> /// <param name="brainController">BrainController</param> /// <returns>actionEnded</returns> public override bool Act(BrainController brainController) { var brainVariables = brainController.GetComponent <IdleBrainVariables>(); if (brainVariables.currentDistance > 0) { brainVariables.currentDistance -= Time.deltaTime; return(false); } else { return(true); } }
private List <BrainController> GetPossibleEnemiesList(BrainController brainController) { List <BrainController> possibleEnemies = new List <BrainController>(); int fighterTeamID = GetFighterTeamID(brainController); foreach (var teamID in teamsDictionary.Keys) { if (teamID != fighterTeamID) { possibleEnemies.AddRange(teamsDictionary[teamID]); } } return(possibleEnemies); }
private int GetFighterTeamID(BrainController brainController) { foreach (var team in teamsDictionary) { foreach (var fighter in team.Value) { if (fighter == brainController) { return(team.Key); } } } return(0); }
/// <summary> /// Update function to be called once each update. /// </summary> /// <param name="brainController">BrainController</param> /// <returns>actionEnded</returns> public override void UpdateBrain(BrainController brainController) { var brainVariables = brainController.GetComponent <IdleBrainVariables>(); if (brainVariables == null) { Logger.LogMessage($"{name}::Update -- brainVariables are not found. Brain has not been initialized", LogType.Error); return; } if (brainVariables.currentAction.Act(brainController)) { brainVariables.currentAction = GetRandomAction(); brainVariables.currentAction.InitAction(brainController); } }
// TODO: Check if enemy is close enough or set weight to 0. /// <summary> /// Initializing function for action. /// </summary> /// <param name="brainController">BrainController.</param> public override void InitAction(BrainController brainController) { var brainVariables = brainController.GetComponent <FightBrainVariables>(); if (CheckClipEvents(brainController) == false) { return; } brainController.animationController.TriggerAnimation(animationTrigger); float attackDirection = brainController.transform.position.x > brainVariables.currentEnemy.transform.position.x ? -1 : 1; brainController.animationController.Direction = attackDirection; brainController.animationEventHandler.Init(); CheckClipEvents(brainController); }
/// <summary> /// Act function to be called once each update. /// </summary> /// <param name="brainController">BrainController</param> /// <returns>actionEnded</returns> public override bool Act(BrainController brainController) { var brainVariables = brainController.GetComponent <FightBrainVariables>(); float runDistance = Mathf.Min(brainVariables.runSpeed * Time.deltaTime, brainVariables.distanceToRun); brainVariables.distanceToRun -= runDistance; brainController.transform.Translate(runDistance * brainVariables.runDirection, 0, 0); bool actionEnded = brainVariables.distanceToRun <= 0; if (actionEnded) { brainController.animationController.TriggerAnimation(ildeAnimationTrigger); } // TODO: Decide what to do with small side steps. return(actionEnded); }
/// <summary> /// Gets closest enemy brainController. /// </summary> /// <param name="brainController">Current fighter.</param> /// <returns>Closest enemy.</returns> public BrainController GetClosestEnemy(BrainController brainController) { float nearestRange = Mathf.Infinity; BrainController closestEnemy = null; foreach (var enemy in GetPossibleEnemiesList(brainController)) { var range = Mathf.Abs(enemy.transform.position.x - brainController.transform.position.x); if (range < nearestRange) { nearestRange = range; closestEnemy = enemy; } } return(closestEnemy); }
/// <summary> /// Initializing function for brain. /// </summary> /// <param name="brainController">BrainController</param> public override void InitBrain(BrainController brainController) { var brainVariables = brainController.GetComponent <IdleBrainVariables>(); if (brainVariables == null) { brainVariables = brainController.gameObject.AddComponent <IdleBrainVariables>(); } if (actionList.Length == 0) { Logger.LogMessage($"{name}::InitBrain -- actionList is empty.", LogType.Error); } else { brainVariables.currentAction = GetRandomAction(); brainVariables.currentAction.InitAction(brainController); } }
/// <summary> /// Initializing function for action. /// </summary> /// <param name="brainController">BrainController</param> public override void InitAction(BrainController brainController) { var brainVariables = brainController.GetComponent <IdleBrainVariables>(); var avatarStats = brainController.Stats; Vector2 position = brainController.transform.position; float leftBorder = BackgroundController.Instance.leftBorder.position.x; float rightBorder = BackgroundController.Instance.rightBorder.position.x; float newDistance = Random.Range(avatarStats.walkTravelDistance.x, avatarStats.walkTravelDistance.y) * (Random.value > 0.5 ? 1 : -1); float newDestinationPoint = position.x + newDistance; newDestinationPoint = Mathf.Clamp(newDestinationPoint, leftBorder, rightBorder); newDistance = newDestinationPoint - position.x; brainController.animationController.Direction = newDistance >= 0 ? 1 : -1; brainVariables.currentDistance = Mathf.Abs(newDistance); brainVariables.currentSpeed = Random.Range(avatarStats.walkSpeed.x, avatarStats.walkSpeed.y); brainController.animationController.TriggerAnimation(animationTrigger); }
/// <summary> /// Act function to be called once each update. /// </summary> /// <param name="brainController">BrainController</param> /// <returns>actionEnded</returns> public override bool Act(BrainController brainController) { var brainVariables = brainController.GetComponent <IdleBrainVariables>(); if (brainVariables.currentDistance > 0) { Vector2 newTransform = brainController.transform.position; float movement = Mathf.Min(brainVariables.currentDistance, brainVariables.currentSpeed * Time.deltaTime); newTransform.x += brainController.animationController.Direction * movement; brainController.transform.position = newTransform; brainVariables.currentDistance -= movement; return(false); } else { return(true); } }
/// <summary> /// Initializing function for action. /// </summary> /// <param name="brainController">BrainController.</param> public override void InitAction(BrainController brainController) { var brainVariables = brainController.GetComponent <FightBrainVariables>(); brainController.animationController.TriggerAnimation(animationTrigger); float distanceToEnemy = brainVariables.currentEnemy.transform.position.x - brainController.transform.position.x; brainVariables.runDirection = Mathf.Sign(distanceToEnemy); if (Mathf.Abs(distanceToEnemy) < brainController.Stats.attackDistance) { brainVariables.distanceToRun = 0; } else { brainVariables.distanceToRun = Mathf.Min(Mathf.Abs(distanceToEnemy) - brainController.Stats.attackDistance, brainController.Stats.maxCombatRunDistance); } brainController.animationController.Direction = brainVariables.runDirection; }
private AvatarCombatAction GetNextAction(BrainController brainController) { var brainVariables = brainController.GetComponent <FightBrainVariables>(); AvatarCombatAction nextAction; // FIXME: Check if Avatar need to attack other closest enemy. if (brainVariables.currentEnemy == null) { brainVariables.currentEnemy = brainVariables.fightController.GetClosestEnemy(brainController); } // FIXME: Rewrite this code using new clever action weight property. var distanceToEnemy = Mathf.Abs(brainController.transform.position.x - brainVariables.currentEnemy.transform.position.x); if (distanceToEnemy > brainController.Stats.attackDistance) { nextAction = runAction; } else { nextAction = (AvatarCombatAction)GetRandomAction(); } return(nextAction); }
public void TakeDamage(BrainController brainController, float damage, bool crit) { var brainVariables = brainController.GetComponent <FightBrainVariables>(); if (crit) { Logger.LogMessage($"{brainController.gameObject.name} has taken {damage} damage! Its a crit!"); } else { Logger.LogMessage($"{brainController.gameObject.name} has taken {damage} damage."); } if (brainController.avatarController.avatarStats.TakeDamage(damage) == 0) { brainVariables.TeamID = 0; brainVariables.currentAction = deathAction; } else { brainVariables.currentAction = hurtAction; } brainVariables.currentAction.InitAction(brainController); }
/// <summary> /// Update function to be called once each update. /// </summary> /// <param name="brainController">BrainController</param> /// <returns>actionEnded</returns> public abstract void UpdateBrain(BrainController brainController);
/// <summary> /// Initializing function for brain. /// </summary> /// <param name="brainController">BrainController</param> public abstract void InitBrain(BrainController brainController);
/// <summary> /// Act function to be called once each update. /// </summary> /// <param name="brainController">BrainController</param> /// <returns>actionEnded</returns> public abstract bool Act(BrainController brainController);