protected override void ChooseAbilityToUse(UnitStateController controller)
{
Unit unit = controller.unit;
var abilities = new List <Ability>(unit.GetAbilityAgent().abilitiesMulti);
if (controller.chaseTarget)
{
var currentPosition = unit.transform.position;
abilities.ForEach(ability =>
{
if (!ability.IsReady())
{
return;
}
var reachableEnemies = WorkManager.FindReachableObjects(controller.nearbyEnemies, currentPosition, ability.range);
// use the ability if there are at least 2 enemies it is going to affect,
// or if the indicatedObject is close enough to a single enemy to start ordninary attack
if (
reachableEnemies.Count > 1 ||
(
reachableEnemies.Count == 1 &&
(reachableEnemies[0].transform.position - currentPosition).sqrMagnitude <= unit.weaponRange * unit.weaponRange)
)
{
controller.abilityToUse = ability;
}
});
}
}
protected override void DoAction(UnitStateController controller)
{
Unit unit = controller.unit;
if (!unit)
{
return;
}
WorldObject chaseTarget = controller.chaseTarget;
if (chaseTarget && !unit.holdingPosition && !WorkManager.ObjectCanReachTarget(unit, chaseTarget))
{
var newDestination = WorkManager.FindDistinationPointByTarget(chaseTarget, unit);
if (newDestination.HasValue)
{
unit.StartMove(newDestination.Value);
}
}
else
{
unit.StopMove();
}
}
void Start()
{
//Get GameController from StaticRef
gC = StaticRef.gameControllerRef.GetComponent <GameController> ();
//Get Components
agent = GetComponent <NavMeshAgent> ();
triggerCollider = GetComponent <SphereCollider> ();
health = GetComponent <UnitHealth> ();
health.unit = this;
controller = GetComponent <UnitController> ();
controller.unit = this;
stateC = GetComponent <UnitStateController> ();
if (stateC != null)
{
stateC.unit = this;
}
condM = GetComponent <UnitConditionManager> ();
condM.unit = this;
//Load unit from UnitRef
if (preset != null && loadRefValues)
{
preset.LoadUnitFromRef(this);
}
controller.InitializeController();
health.InitializeHealth();
}
protected override void DoAction(UnitStateController controller)
{
Unit unit = controller.unit;
WorldObject allyChaseTarget = controller.allyAbilityTarget;
Ability ability = controller.abilityToUse;
if (allyChaseTarget != null)
{
Vector3 currentPosition = unit.transform.position;
Vector3 currentAllyPosition = WorkManager.GetTargetClosestPoint(unit, allyChaseTarget);
Vector3 direction = currentAllyPosition - currentPosition;
if (direction.sqrMagnitude < ability.range * ability.range)
{
controller.unit.UseAbility(allyChaseTarget, ability);
controller.abilityToUse = null;
/*
* if (!unit.aiming)
* {
* controller.abilityToUse = null;
* }
*/
}
}
}
protected override bool DoDecide(UnitStateController controller)
{
return(controller.abilityToUse != null &&
!(controller.abilityToUse is AoeAbility) &&
new List <Ability>(controller.unit.GetAbilityAgent().abilities)
.Contains(controller.abilityToUse));
}
public static void AbilityHotkeyToState(TargetManager targetManager, UnitStateController stateController, int abilityIndex)
{
if (!targetManager)
{
return;
}
Unit unit = stateController.unit;
if (unit.GetAbilityAgent().CanUseAbilitySlot(abilityIndex))
{
Ability ability = null;
if (targetManager.InMultiMode)
{
ability = stateController.unit
.GetAbilityAgent()
.FindAbilityMultiByIndex(abilityIndex);
}
else
{
ability = stateController.unit
.GetAbilityAgent()
.FindAbilityByIndex(abilityIndex);
}
if (ability != null)
{
if (ability.isSelfOnly)
{
stateController.abilityToUse = ability;
stateController.allyAbilityTarget = unit;
stateController.TransitionToState(ResourceManager.GetAiState(AIStates.ALLY_ABILITY_CHASE_MANUAL));
}
else if (ability.isAllyTargetingAbility)
{
// Makes HotkeyUnitSelector to treat key press events as ability target selection
Player player = ability.user.GetPlayer();
// Healing ability targetting doesn't depend on global targetting mode, single / multi target selection
// happens later, when player hits space
player.selectedAllyTargettingAbility = stateController.unit
.GetAbilityAgent()
.FindAbilityByIndex(abilityIndex);
player.selectedAlliesTargettingAbility = stateController.unit
.GetAbilityAgent()
.FindAbilityMultiByIndex(abilityIndex);
}
else
{
string stateName = targetManager.InMultiMode
? AIStates.ABILITY_CHASE_MANUA_MULTIL
: AIStates.ABILITY_CHASE_MANUAL;
stateController.abilityToUse = ability;
stateController.TransitionToState(ResourceManager.GetAiState(stateName));
}
}
}
}
public static void AlliesAbilityTargetSelectionToState(UnitStateController stateController, Ability ability)
{
stateController.abilityToUse = ability;
Debug.Log("Changed state to Allies Ability Use Manual");
stateController.TransitionToState(ResourceManager.GetAiState(AIStates.ALLIES_ABILITY_USE_MANUAL));
}
public static void AllyAbilityTargetSelectionToState(UnitStateController stateController, Ability ability, WorldObject allyTarget)
{
stateController.abilityToUse = ability;
stateController.allyAbilityTarget = allyTarget;
stateController.TransitionToState(ResourceManager.GetAiState(AIStates.ALLY_ABILITY_CHASE_MANUAL));
}
protected override void DoAction(UnitStateController controller)
{
Unit unit = controller.unit;
Ability abilityToUse = controller.abilityToUse;
if (!abilityToUse || !(abilityToUse is AoeAbility))
{
return;
}
AoeAbility aoeAbility = (AoeAbility)abilityToUse;
if (controller.aoeAbilityTarget == new Vector3())
{
controller.unit.UseAbility(unit.transform.position, aoeAbility);
controller.abilityToUse = null;
}
Vector3 currentPosition = unit.transform.position;
Vector3 direction = controller.aoeAbilityTarget - currentPosition;
if (direction.sqrMagnitude < aoeAbility.range * aoeAbility.range)
{
controller.unit.UseAbility(controller.aoeAbilityTarget, aoeAbility);
if (!unit.aiming)
{
controller.abilityToUse = null;
}
}
}
protected override bool DoDecide(UnitStateController controller)
{
Unit self = controller.unit;
MeleeUnit closestChaser = WorkManager.FindNearestMeleeObject(
controller.nearbyEnemies
.Where(p => p && p.GetStateController() && p.GetStateController().chaseTarget&&
p.GetStateController().chaseTarget.ObjectId == self.ObjectId)
.ToList(),
self.transform.position
);
if (!closestChaser)
{
return(false);
}
Vector3 targetLocation = closestChaser.transform.position;
Vector3 direction = targetLocation - self.transform.position;
bool shouldRunAway = closestChaser != null && // target exists
closestChaser.gameObject.activeSelf && // target is alive
direction.sqrMagnitude < self.weaponRange * self.weaponRange * Constants.RUNAWAY_COEF * Constants.RUNAWAY_COEF && // target is close enough to start running away
closestChaser.GetNavMeshAgent().speed <= controller.navMeshAgent.speed - Constants.RUNAWAY_SPEED_THREASHOLD;
return(shouldRunAway);
}
protected override void DoAction(UnitStateController controller)
{
var self = controller.navMeshAgent;
var unit = controller.unit;
var target = controller.chaseTarget;
if (target && (target.transform.position - self.transform.position).sqrMagnitude < unit.detectionRange * unit.detectionRange)
{
var offset = self.transform.position - target.transform.position;
// run away from the target (oppiosite direction of where the target is relative to the self)
var destinationPoint = self.destination + offset.normalized * WALK_RADIUS;
// var destinationPoint = WorkManager.GetClosestPointOnNavMesh(initialDestination, "Walkable");
float sqrDistance = (destinationPoint - self.transform.position).sqrMagnitude;
bool reachable = NavMesh.CalculatePath(
self.transform.position,
destinationPoint,
WorkManager.GetNavMeshAreaFromName("Walkable"),
new NavMeshPath()
);
if (sqrDistance < 1 || !reachable)
{
destinationPoint = WorkManager.GetPerpendicularDestinationPoint(self, destinationPoint, WALK_RADIUS);
}
controller.unit.StartMove(destinationPoint);
}
}
protected override void ChooseAbilityToUse(UnitStateController controller)
{
Unit unit = controller.unit;
Ability ability = AbilityUtils.FindAbilityByName("CCEnemySleepMultiAbility", unit.GetAbilityAgent().abilitiesMulti);
// TODO: add logic on when to use Sleep Multi.
}
public bool Work(UnitStateController uSC)
{
if (currentJob.DoMe (uSC)) {
JobDone ();
return true;
} else
return false;
}
protected override bool DoDecide(UnitStateController controller)
{
bool isAiming = controller.unit.aiming;
return(controller.abilityToUse == null
/* && !isAiming */
? true
: false);
}
protected override void Awake()
{
base.Awake();
agent = GetComponent <NavMeshAgent>();
takeDamageEffect = GetComponentInChildren <ParticleSystem>();
stateController = GetComponent <UnitStateController>();
}
public bool DoMe(UnitStateController uSC)
{
if (jobType == GameInfo.Professions.Digger) {
return ExcavationJob (uSC);
} else {
Debug.Log ("I should be working... but I don't know how... ");
}
return false;
}
protected override void DoAction(UnitStateController controller)
{
var self = controller.navMeshAgent;
controller.unit.StartMove(controller.wayPointList[controller.nextWayPoint].position);
if (self.remainingDistance <= self.stoppingDistance && !self.pathPending)
{
controller.nextWayPoint = (controller.nextWayPoint + 1) % controller.wayPointList.Count;
}
}
protected override void ChooseAbilityToUse(UnitStateController controller)
{
Unit unit = controller.unit;
Ability ability = AbilityUtils.FindAbilityByName("DBEnemyDotAbilityMulti", unit.GetAbilityAgent().abilitiesMulti);
var reachabeEnemies = WorkManager.FindReachableObjects(controller.nearbyEnemies, unit.transform.position, ability.range);
// wait till at least 2 targets are reachable
if (ability != null && ability.IsReady() && reachabeEnemies.Count > 1)
{
controller.abilityToUse = ability;
}
}
protected override void ChooseAbilityToUse(UnitStateController controller)
{
Unit unit = controller.unit;
Ability ability = AbilityUtils.FindAbilityByName("CCEnemySilenceAbility", unit.GetAbilityAgent().abilities);
var reachabeEnemies = WorkManager.FindReachableObjects(controller.nearbyEnemies, unit.transform.position, ability.range);
if (ability != null && ability.IsReady() && reachabeEnemies.Count > 0)
{
controller.enemyAbilityTarget = WorkManager.FindMostDamagingObjectInList(reachabeEnemies);
controller.abilityToUse = ability;
}
}
protected override void ChooseAbilityToUse(UnitStateController controller)
{
Unit unit = controller.unit;
if (!controller.abilityToUse)
{
Ability ability = unit.GetAbilityAgent().GetFirstReadyAbility();
if (ability != null)
{
controller.abilityToUse = ability;
}
}
}
/*
* public static void SelectUnit(GameObject u)
* {
* currentSelect = u;
* Debug.Log(u.GetComponent<UnitData>().UnitName);
* }
*/
void ChangeTurns()
{
isPlayerTurn = !isPlayerTurn; //current turn is done, at this point forward it is the other side's turn
unitsDone = 0;
doneButton.ResetButton(isPlayerTurn);
if (isPlayerTurn)
{
turnCounter++; //only increments when it is becoming the player's turn
turnCountText.DisplayNewTurn();
}
//goes through every object of type Unit and readies/exhausts allies or enemies appropriately
//Unit[] units = FindObjectsOfType(typeof(Unit)) as Unit[];
UnitData[] units = FindObjectsOfType(typeof(UnitData)) as UnitData[];
foreach (UnitData unit in units)
{
UnitStateController usc = unit.gameObject.GetComponent <UnitStateController>();
//Debug.Log("finded a unit");
//var unitInfo = unit.GetComponentInParent<Unit>();
if (isPlayerTurn)
{
if (unit.UnitTeam == Team.HERO)
{
usc.ReadyUnit();
//Debug.Log("ally is woke");
}
else
{
usc.ExhaustUnit();
//Debug.Log("enemy is exhausted");
}
}
else
{
if (unit.UnitTeam == Team.ENEMY)
{
usc.ReadyUnit();
//Debug.Log("enemy is woke");
}
else
{
usc.ExhaustUnit();
//Debug.Log("ally is exhausted");
}
}
}
}
private static void SwitchAttackModeForOne(UnitStateController stateController)
{
switch (stateController.currentState.name)
{
case AIStates.IDLE_MANUAL:
stateController.TransitionToState(ResourceManager.GetAiState(AIStates.IDLE_MANUAL_MULTI));
break;
case AIStates.CHASE_MANUAL:
stateController.TransitionToState(ResourceManager.GetAiState(AIStates.CHASE_MANUAL_MULTI));
break;
case AIStates.BUSY_MANUAL:
stateController.TransitionToState(ResourceManager.GetAiState(AIStates.BUSY_MANUAL_MULTI));
break;
case AIStates.STOP_MANUAL:
stateController.TransitionToState(ResourceManager.GetAiState(AIStates.STOP_MANUAL_MULTI));
break;
case AIStates.ABILITY_CHASE_MANUAL:
stateController.TransitionToState(ResourceManager.GetAiState(AIStates.ABILITY_CHASE_MANUA_MULTIL));
break;
case AIStates.IDLE_MANUAL_MULTI:
stateController.TransitionToState(ResourceManager.GetAiState(AIStates.IDLE_MANUAL));
break;
case AIStates.CHASE_MANUAL_MULTI:
stateController.TransitionToState(ResourceManager.GetAiState(AIStates.CHASE_MANUAL));
break;
case AIStates.BUSY_MANUAL_MULTI:
stateController.TransitionToState(ResourceManager.GetAiState(AIStates.BUSY_MANUAL));
break;
case AIStates.STOP_MANUAL_MULTI:
stateController.TransitionToState(ResourceManager.GetAiState(AIStates.STOP_MANUAL));
break;
case AIStates.ABILITY_CHASE_MANUA_MULTIL:
stateController.TransitionToState(ResourceManager.GetAiState(AIStates.ABILITY_CHASE_MANUAL));
break;
default:
break;
}
}
private bool ExcavationJob(UnitStateController uSC)
{
SolidTileController sTC = tileInfo.GetComponent<SolidTileController> ();
float fatigueIndex = GameInfo.solidTilesFatigueIndex [tileInfo.tileType];
sTC.condition -= uSC.stats.CalculateDiggerEfficiency ();
uSC.stats.currentCondition -= fatigueIndex * Time.deltaTime;
if (sTC.condition <= 0.0f) {
GameMaster.SwapTiles(tileInfo);
return true;
}
else
return false;
}
public void Init(UnitStateController uSC)
{
this.uSC = uSC;
labelID.GetComponent<Text>().text = "#00" + uSC.stats.ID.ToString();
labelS.GetComponent<Text>().text = uSC.stats.s.ToString();
labelE.GetComponent<Text>().text = uSC.stats.e.ToString();
labelA.GetComponent<Text>().text = uSC.stats.a.ToString();
labelL.GetComponent<Text>().text = uSC.stats.l.ToString();
pIdler.GetComponent<ProfessionButton>().Init(uSC);
pDigger.GetComponent<ProfessionButton>().Init(uSC);
pSkivvy.GetComponent<ProfessionButton>().Init(uSC);
pMiner.GetComponent<ProfessionButton>().Init(uSC);
}
public static void ToBusyState(TargetManager targetManager, UnitStateController stateController, Vector3 destination)
{
if (!targetManager || !stateController || !stateController.navMeshAgent || !stateController.navMeshAgent.isActiveAndEnabled)
{
return;
}
// add new destination for nav mesh agent
stateController.navMeshAgent.SetDestination(destination);
// transition to Chase Manual State
string stateName = targetManager.InMultiMode
? AIStates.BUSY_MANUAL_MULTI
: AIStates.BUSY_MANUAL;
stateController.TransitionToState(ResourceManager.GetAiState(stateName));
}
private void PrepareAttackOn(GameObject defender)
{
GameObject attacker = gameObject;
UnitData defenderData = defender.GetComponent <UnitData>();
Parameters defenderParameters = defender.GetComponent <Parameters>();
Int2 aPos = new Int2(
(int)Mathf.Floor(this.transform.position.x),
(int)Mathf.Floor(this.transform.position.z));
Int2 dPos = new Int2(
(int)Mathf.Floor(defender.transform.position.x),
(int)Mathf.Floor(defender.transform.position.z));
if (unitData.UnitTeam == defender.GetComponent <UnitData>().UnitTeam)
{
Debug.Log("Cannot attack an ally!");
return;
}
if (Int2.Distance(aPos, dPos) > weaponRange)
{
Debug.Log("Cannot attack a unit that is out of range!");
return;
}
Debug.Log("Unit is attacking this unit for " + Attack.CalculateProjectedDamage(attacker, defender) + " damage but will take " +
Attack.CalculateProjectedDamage(defender, attacker) + " damage.");
Attack.CommenceBattle(gameObject, defender);
Debug.Log(unitData.UnitName + " is now at " + unitParameters.CHP + " HP and " + defenderData.UnitName + " now has " + defenderParameters.CHP);
if (defenderParameters.CHP == 0)
{
// Ded
UnitStateController defenderController = defender.GetComponent <UnitStateController>();
defenderController.KillUnit();
}
else if (gameObject.GetComponent <Parameters>().CHP == 0)
{
// This ded
this.KillUnit();
}
}
protected override void DoAction(UnitStateController controller)
{
Unit unit = controller.unit;
WorldObject chaseTarget = controller.chaseTarget;
if (chaseTarget && !WorkManager.ObjectCanReachTargetWithAbility(unit, controller.abilityToUse, chaseTarget))
{
var newDestination = WorkManager.FindDistinationPointByTarget(chaseTarget, unit);
if (newDestination.HasValue)
{
unit.StartMove(newDestination.Value);
}
}
else
{
controller.unit.StopMove();
}
}
protected override void ChooseAbilityToUse(UnitStateController controller)
{
Unit unit = controller.unit;
Ability ability = AbilityUtils.FindAbilityByName("DBEnemyMiniDebuffAoeAbility", unit.GetAbilityAgent().abilitiesMulti);
var reachabeEnemies = WorkManager.FindReachableObjects(controller.nearbyEnemies, unit.transform.position, ability.range);
if (ability != null && ability.IsReady() && reachabeEnemies.Count > 0)
{
var abilityTargets = reachabeEnemies;
controller.aoeAbilityTarget = AoeUtils.GetAoeTargetPosition(
ability.range,
abilityTargets.ToList(),
unit.GetPlayer()
);
controller.abilityToUse = ability;
}
}
protected override void DoAction(UnitStateController controller)
{
Unit unit = controller.unit;
WorldObject chaseTarget = controller.enemyAbilityTarget
? controller.enemyAbilityTarget
: controller.chaseTarget;
Ability ability = controller.abilityToUse;
if (!ability)
{
return;
}
if (ability is AoeAbility)
{
AoeAbility aoeAbility = (AoeAbility)ability;
// for now, all AoE are self-AoE
controller.unit.UseAbility(unit.transform.position, aoeAbility);
controller.abilityToUse = null;
return;
}
// if no target or canтot attack, return
if (!ability || chaseTarget == null || !unit.CanAttack())
{
return;
}
Vector3 currentPosition = unit.transform.position;
Vector3 currentEnemyPosition = WorkManager.GetTargetClosestPoint(unit, chaseTarget);
Vector3 direction = currentEnemyPosition - currentPosition;
if (direction.sqrMagnitude < ability.range * ability.range)
{
controller.unit.UseAbility(chaseTarget, ability);
if (!unit.aiming)
{
controller.abilityToUse = null;
}
}
}
protected override void DoAction(UnitStateController controller)
{
Unit unit = controller.unit;
if (!controller.abilityToUse)
{
Ability ability = unit.GetAbilityAgent().GetFirstReadyMultiAbility();
if (ability != null)
{
if (ability is AoeAbility && controller.chaseTarget)
{
controller.aoeAbilityTarget = controller.chaseTarget.transform.position;
}
controller.abilityToUse = ability;
}
}
}
protected override void DoAction(UnitStateController controller)
{
Unit unit = controller.unit;
var chaseTarget = AttackUtil.SetClosestEnemyAsTarget(controller);
if (chaseTarget && !unit.holdingPosition && !WorkManager.ObjectCanReachTarget(unit, chaseTarget))
{
var newDestination = WorkManager.FindDistinationPointByTarget(controller.chaseTarget, unit);
if (newDestination.HasValue)
{
unit.StartMove(newDestination.Value);
}
}
else
{
controller.unit.StopMove();
}
}
protected override void DoAction(UnitStateController controller)
{
Unit unit = controller.unit;
Ability abilityToUse = controller.abilityToUse;
Vector3 currentPosition = unit.transform.position;
List <WorldObject> reachableAllies = controller.nearbyAllies
.Where(p =>
{
Vector3 currentAllyPosition = p.transform.position;
Vector3 direction = currentAllyPosition - currentPosition;
return(direction.sqrMagnitude < unit.weaponRange * unit.weaponRange);
})
.ToList();
if (reachableAllies.Count > 0)
{
controller.unit.UseAbility(reachableAllies, abilityToUse);
controller.abilityToUse = null;
}
}
protected override void DoAction(UnitStateController controller)
{
Unit unit = controller.unit;
EnemyStateController enemyStateController = (EnemyStateController)controller;
if (!enemyStateController.abilityToUse && enemyStateController.IsReadyToChooseAbility())
{
Ability ability = AbilityUtils.ChooseRandomReadyAbility(unit.GetAbilityAgent().abilities);
if (ability != null)
{
if (ability is AoeAbility)
{
controller.aoeAbilityTarget = controller.chaseTarget.transform.position;
}
controller.abilityToUse = ability;
enemyStateController.ResetAbilityChoiceTimer();
}
}
}
public static void CommenceBattle(GameObject attacker, GameObject defender)
{
Parameters aParam = attacker.GetComponent <Parameters>();
UnitStateController aControl = attacker.GetComponent <UnitStateController>();
Parameters dParam = defender.GetComponent <Parameters>();
UnitStateController dControl = defender.GetComponent <UnitStateController>();
// NOTE: The attacker will always strike first currently
// Anything skills/items involving priority-manipulation
// is not currently accounted for
int attackerDamage = CalculateProjectedDamage(attacker, defender);
int defenderDamage = CalculateProjectedDamage(defender, attacker);
if (dParam.CHP > attackerDamage)
{
dParam.CHP -= attackerDamage;
// Note: defender may have shorter range than attack
if (aParam.CHP > defenderDamage)
{
aParam.CHP -= defenderDamage;
}
else
{
aParam.CHP = 0;
}
}
else
{
dParam.CHP = 0;
}
aControl.DoneActing();
}
public void Init(UnitStateController uSC)
{
this.uSC = uSC;
image = GetComponent<Image>();
}
public ReturnHome(UnitStateController uSC)
{
this.uSC = uSC;
}
public Idle(UnitStateController uSC)
{
this.uSC = uSC;
}
public Occupied(UnitStateController uSC)
{
this.uSC = uSC;
}
public void UpdateNeeds(UnitStateController uSC)
{
if (uSC.currentState == uSC.idle && currentCondition < maxCondition)
currentCondition += (1 / (-0.78f * e + 10.78f)) * 0.1f * Time.deltaTime;
if (!isSleeping && sleepness > 0f)
sleepness -= 1f / 180f * Time.deltaTime;
if (!isEating && hunger > 0f) {
if (isSleeping)
hunger -= 1f / 120f * Time.deltaTime / 2;
else
hunger -= 1f / 120f * Time.deltaTime;
}
}
public FullfilingNeeds(UnitStateController uSC)
{
this.uSC = uSC;
}
