//in a normal controlled division this will do nothing, but the ai controller will override
public virtual void OnEmptyOrder(ControlledDivision Host)
{
if (EndOnEmptyOrder)
{
Canceled = true;
}
}
public void UpdateCalculatedValues(ControlledDivision Host)
{
_ai.canMove = true;
Host.RecalculateAggrigateValues();
Host.RefreshDiscoveredTiles();
_ai.maxSpeed = Host.Speed * GameManager.GameSpeed * Host.CommandingOfficer.SupplyUsage.Value;
}
private void EngageDivision(ControlledDivision Host)
{
var rememberedTarget = GetRememberedDivisionFromHost(Host, RememberedTargetId);
//if the target has been destroyed do nothing and to end the order
if (rememberedTarget.HasBeenDestroyed)
{
OngoingOrder = new EmptyOrder();
Canceled = true;
return;
}
if (Host.FindVisibleDivision(RememberedTargetId, out ControlledDivision division))
{
var distanceToTarget = (division.Controller.transform.position - Host.Controller.transform.position).magnitude;
//need to move closer
if (distanceToTarget > Host.MaxHitRange)
{
StartOrder(Host, new Move(Host, CommanderSendingOrderId, division.Position, Host.MaxHitRange * .5f));
}
else
{
//if the target is within range attack
StartOrder(Host, new AttackOrder(Host, CommanderSendingOrderId, division.DivisionId, Host.MaxHitRange));
}
}
else
{
//else go find him again
StartOrder(Host, new FindDivision(Host, CommanderSendingOrderId, RememberedTargetId, Host.MaxSightDistance));
}
}
public override void Proceed(ControlledDivision Host)
{
if (!IsFinished && Host.FindVisibleDivision(RememberedTargetId, out ControlledDivision division))
{
var distanceToTarget = (division.Controller.transform.position - Host.Controller.transform.position).magnitude;
if (distanceToTarget > Host.MaxHitRange)
{
IsFinished = true;
return;
}
float totalAttackerDamage = 0;
for (int i = 0; i < Host.Soldiers.Count; i++)
{
Soldier soldier = Host.Soldiers[i];
if (distanceToTarget > soldier.MinRange && distanceToTarget < soldier.MaxRange)
{
var result = soldier.Attack(ref division, distanceToTarget);
totalAttackerDamage += result.DamageToDefender;
}
}
bool isDestroyed = division.CheckDamageDone(Host);
bool isHostDestroyed = Host.CheckDamageDone(division);
if (isDestroyed)
{
RememberedDivision RememberedTarget = GetRememberedDivisionFromHost(Host, RememberedTargetId);
RememberedTarget.HasBeenDestroyed = true;
RememberedTarget.TimeStamp = GameManager.Instance.GameTime;
IsFinished = true;
}
}
}
public void Resupply(ControlledDivision Host)
{
//find closest supply dump
Func <TerrainMapTile, bool> findSupplyTile = tile => {
return(tile.Supply > 100);
};
//UnityEngine.Profiling.Profiler.BeginSample("find supply");
//find closest supply
if (Host.TryFindKnownTileMatchingPred(findSupplyTile, out Vector3 foundPosition))
{
//Debug.Log($"resupply position : {foundPosition}");
this.ReceiveOrder(Host, new Move(Host, Host.DivisionId, foundPosition));
var supplyOrder = new GatherSuppliesOrder(Host, Host.DivisionId);
// add the supply to Host
Host.ReceiveOrder(supplyOrder);
this.ReceiveOrder(Host, new WaitOrder(Host, Host.DivisionId, 2, x => {
x.CancelOrder(supplyOrder.orderId);
}));
}
else
{
RandomMove(Host);
}
//UnityEngine.Profiling.Profiler.EndSample();
}
private void SendHeartBeat(ControlledDivision Host)
{
RememberedDivision CommanderSendingOrder = GetRememberedDivisionFromHost(Host, CommanderSendingOrderId);
RememberedDivision rememberedTarget = GetRememberedDivisionFromHost(Host, RememberedTargetId);
Host.SendOrdersTo(rememberedTarget, new List <Order>(), ref Host.RememberedDivisions);
/*
* DivisionController HeartBeatMessenger;
* if (Host.TryCreateNewDivision(out HeartBeatMessenger))
* {
* HeartBeatMessenger.name = "Heatbeat messenger";
*
* Debug.Log($" heartbeat {Host.DivisionId} {RememberedTargetId}");
* HeartBeatMessenger.AttachedDivision.ReceiveOrders(
* new List<Order>()
* {
* new FindDivision(
* HeartBeatMessenger.AttachedDivision,
* Host.DivisionId,
* RememberedTargetId),
* new SendMessage(
* HeartBeatMessenger.AttachedDivision,
* Host.DivisionId,
* new List<Order>(),
* RememberedTargetId,
* Host.DivisionId)
* });
*
* }
*/
}
public SendMessage(Division controller, int commanderSendingOrderId, List <Order> message, int targetId, int endTargetId)
: base(controller, commanderSendingOrderId, "Send Message", targetId)
{
this._visibleTarget = null;
this._message = message;
this._endTargetId = endTargetId;
}
public virtual CombatResult Attack(ref ControlledDivision division, float distanceToTarget)
{
CombatResult result = new CombatResult();
if (distanceToTarget < MinRange || distanceToTarget > MaxRange)
{
result.AttackSuccess = false;
return(result);
}
result.Attacker = this;
foreach (var defender in division.Soldiers)
{
if (defender.Health > 0)
{
result.DamageToDefender = DoDamage(this, defender);
result.Defender = defender;
result.DamageToAttacker = defender.Defend(this, distanceToTarget);
break;
}
}
return(result);
}
public virtual void DoOrders(ControlledDivision Host)
{
if (OngoingOrder.Canceled)
{
OngoingOrder.End(Host);
TryStartNextOrder(Host);
}
else if (GameManager.Instance.IsPaused)
{
OngoingOrder.Pause(Host);
}
else if (OngoingOrder.GetType() != typeof(EmptyOrder))
{
//if we are finished stop
if (OngoingOrder.TestIfFinished(Host))
{
OngoingOrder.End(Host);
OngoingOrder = new EmptyOrder();
Host.OnChange();
}
else
{
ContinueOrder(Host);
}
}
//grab a new order
else if (TryStartNextOrder(Host))
{
}
}
public void CancelOrders(ControlledDivision Host, HashSet <int> orderIdsToCancel)
{
CancelOrders(OrderQueue, orderIdsToCancel);
CancelOrders(BackgroundOrderList, orderIdsToCancel);
CancelOrder(OngoingOrder, orderIdsToCancel);
//DoOrders(Host);
}
private void AddMoveToTarget(ControlledDivision Host)
{
RememberedDivision rememberedTarget;
if (TryGetRememberedDivisionFromHost(Host, RememberedTargetId, out rememberedTarget))
{
if (rememberedTarget.HasBeenDestroyed)
{
RememberedTargetId = rememberedTarget.Commander;
if (RememberedTargetId == rememberedTarget.Commander)
{
//the command chain is dead so give up
Canceled = true;
}
AddMoveToTarget(Host);
}
else
{
this.OrderQueue.Add(new Move(Host, CommanderSendingOrderId, rememberedTarget.PredictedPosition, _thresholdDistance * .5f));
}
}
else
{
//add wait order to wait until we find the remembered division
this.OrderQueue.Add(new WaitOrder(Host, CommanderSendingOrderId, .1f));
}
}
public void OnEnemiesSeen(ControlledDivision Host, List <ControlledDivision> enemies)
{
//Debug.Log("ENEMY!!!!!!!!!!!!!!!");
if (Division.PredictCombatResult(Host, enemies.ConvertAll(x => (Division)x)) > Host.CommandingOfficer.EngagementThreshold.Value)
{
//Debug.Log("ATTACK");
_currentBehavior = $"Attack: {enemies[0].DivisionId}";
StartOrder(Host, new EngageOrder(Host, Host.DivisionId, enemies[0].DivisionId));
}
else
{
//Debug.Log("RUN AWAY");
_currentBehavior = $"Running Away";
Vector3 enemiesCentoid = Vector3.zero;
foreach (var enemy in enemies)
{
enemiesCentoid += enemy.Position;
}
enemiesCentoid /= enemies.Count;
Vector3 delta = (Host.Position - enemiesCentoid) * Host.CommandingOfficer.RunAwayDistance.Value;
Vector3 retreatPos = Host.Position + delta;
StartOrder(Host, new Move(Host, Host.DivisionId, MapManager.Instance.ClampPositionToInBounds(retreatPos)));
}
//descide whether to attack or not
//attack if we can win and it doesnt put us out of position
//run if we cant win also send messengers to nearby units to call for help
}
public override void Start(ControlledDivision Host)
{
//generate zones
//startup background orders to look for enemies/may just make this a controlled division thing with a callback
base.Start(Host);
OnEnemiesSeenCallback = enemies => OnEnemiesSeen(Host, enemies);
Host.RegisterOnEnemiesSeenCallback(OnEnemiesSeenCallback);
}
public virtual void GenerateZones(ControlledDivision Host)
{
//make zones for things
//for commander units use zones to bound where they can move and stuff
//maybe use zones to trigger behaviors, like have a close zone to trigger a defensive behavior
}
public override void Proceed(ControlledDivision Host)
{
if (Host.FindVisibleDivision(TargetId, out ControlledDivision divisionToMergeWith))
{
Host.ShareMapInformation(divisionToMergeWith);
FinishedSharing = true;
}
}
public override void Start(ControlledDivision Host)
{
base.Start(Host);
Host.MergeZones(ZoneInfo);
//end the order
Canceled = true;
}
public override void Proceed(ControlledDivision Host)
{
if (OrderQueue.Count == 0)
{
AddMoveToTarget(Host);
}
base.Proceed(Host);
}
public override void Start(ControlledDivision Host)
{
//look for enemies with some units
//recruit with others
//once enemies found generate zones to set up defencive paremeter, and allocate troops to front line
//also generate zones for potential advancement or retreat
base.Start(Host);
}
/// <summary>
/// starts a new order
/// </summary>
/// <param name="Host"></param>
/// <param name="order"></param>
protected virtual void StartOrder(ControlledDivision Host, Order order)
{
OngoingOrder = order;
OngoingOrder.Start(Host);
//DOES not use continueOrder to proceed the order, this is because sub classes of multi use the continue order to start new orders and can cause infinite recursion
OngoingOrder.Proceed(Host);
Host.OnChange();
name = $"{_baseName} {OngoingOrder.name}";
}
public override void End(ControlledDivision Host)
{
RememberedDivision CommanderSendingOrder = GetRememberedDivisionFromHost(Host, CommanderSendingOrderId);
RememberedDivision commander = Host.RememberedDivisions[CommanderSendingOrder.DivisionId];
Host.ReceiveOrder(new FindDivision(Host, _visibleTarget.DivisionId, commander.DivisionId));
Host.ReceiveOrder(new MergeDivisions(Host, commander.DivisionId, commander.DivisionId));
base.End(Host);
}
public override void Proceed(ControlledDivision Host)
{
base.Proceed(Host);
TimeSinceLastHeartbeat += GameManager.DeltaTime;
if (TimeSinceLastHeartbeat > SecondsPerHeartbeat)
{
SendHeartBeat(Host);
TimeSinceLastHeartbeat = 0;
}
}
public override bool TestIfFinished(ControlledDivision Host)
{
if (TimeRemaining < 0)
{
OnFinish?.Invoke(Host);
return(true);
}
return(false);
}
public override void Proceed(ControlledDivision Host)
{
_timeSinceLastTick += GameManager.DeltaTime;
if (_timeSinceLastTick > _timeBetweenTicks)
{
_timeSinceLastTick = 0;
OnTick(Host);
}
}
public void RandomMove(ControlledDivision Host)
{
_currentBehavior = $"Random Move";
Vector3 pos = UnityEngine.Random.insideUnitCircle * UnityEngine.Random.Range(2, 10);
pos.z = 0;
pos += Host.Position;
pos = MapManager.Instance.ClampPositionToInBounds(pos);
StartOrder(Host, new Move(Host, Host.DivisionId, pos));
}
private string Serializeremembered(ControlledDivision division)
{
string str = "";
foreach (KeyValuePair <int, RememberedDivision> remembered in division.RememberedDivisions)
{
str += $"<{remembered.Value.ToString()}> \n";
}
return(str);
}
public override void OnTick(ControlledDivision Host)
{
var tile = MapManager.Instance.GetTileFromPosition(Host.Controller.transform.position);
if (tile.Supply > 50)
{
foreach (var soldier in Host.Soldiers)
{
soldier.GatherSupplies(tile);
}
}
}
public override void Proceed(ControlledDivision Host)
{
/*
* Vector3 currLoc = Host.Controller.transform.position;
* Vector3 dir = (finish - currLoc).normalized;
* Vector3 moveVec = dir * Host.Speed;
* //set start moving twords finish
* Host.Controller.GetComponent<Rigidbody>().velocity = moveVec * GameManager.Instance.GameSpeed;
*/
//MoveToTarget(Host);
UpdateCalculatedValues(Host);
}
public bool TakeDamage(float damage, ControlledDivision from)
{
base.TakeDamage(damage, from);
if (Soldiers.Count == 0)
{
from.DestroyDivision(this);
return(true);
}
RecalculateAggrigateValues();
return(false);
}
public bool CheckDamageDone(ControlledDivision from)
{
base.CheckDamageDone(from);
if (Soldiers.Count == 0)
{
from.DestroyDivision(this);
return(true);
}
RecalculateAggrigateValues();
return(false);
}
public override bool TestIfFinished(ControlledDivision Host)
{
Vector3 currLoc = Host.Controller.transform.position;
float distanceToFinish = (finish - currLoc).magnitude;
if (distanceToFinish <= _thresholdDistance)
{
return(true);
}
return(false);
//for whatever reason the pathPending doesnt get updated for a few frames
//return !_ai.pathPending && _ai.reachedEndOfPath;
}
