public FindDivision(DivisionController controller, DivisionController commanderSendingOrder, RememberedDivision finish)
{
this.commanderSendingOrder = commanderSendingOrder;
this.controller = controller;
this.finish = finish;
this.target = null;
}
public void SendOrderTo(RememberedDivision to, Order order, ref Dictionary <int, RememberedDivision> rememberedDivisions)
{
SendOrdersTo(to, new List <Order>()
{
order
}, ref rememberedDivisions);
}
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)
* });
*
* }
*/
}
//returns the chain of command to a subordinate
public List <RememberedDivision> FindDivisionInSubordinates(RememberedDivision start, RememberedDivision end, List <RememberedDivision> prev_, ref Dictionary <int, RememberedDivision> rememberedDivisions)
{
List <RememberedDivision> prev = new List <RememberedDivision>(prev_);
prev.Add(start);
if (start.DivisionId == end.DivisionId)
{
return(prev);
}
foreach (int subordinateId in start.Subordinates)
{
if (rememberedDivisions.TryGetValue(subordinateId, out RememberedDivision division))
{
//RememberedDivision division = rememberedDivisions[subordinateId];
List <RememberedDivision> temp = FindDivisionInSubordinates(division, end, prev, ref rememberedDivisions);
if (temp != null)
{
return(temp);
}
}
}
return(null);
}
public void RefreshRememberedDivisionsFromVisibleDivisions()
{
UpdateRememberedDivision(new RememberedDivision(this));
foreach (var key in VisibleDivisions.Keys)
{
UpdateRememberedDivision(new RememberedDivision(VisibleDivisions[key]));
//only share info with same team
if (AreSameTeam(VisibleDivisions[key], this))
{
var rememberedDivisionKeys = VisibleDivisions[key].RememberedDivisions.Keys.ToList();
//foreach (var kvp in VisibleDivisions[key].RememberedDivisions)
for (int i = 0; i < rememberedDivisionKeys.Count; i++)
{
int divisionId = rememberedDivisionKeys[i];
RememberedDivision otherDiv = VisibleDivisions[key].RememberedDivisions[divisionId];
UpdateRememberedDivision(otherDiv);
}
}
}
//RefreshSubordinates(RememberedDivisions);
//RefreshOrdersRememberedDivisions(RememberedDivisions);
}
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 AddSubordinate(RememberedDivision division)
{
if (division.DivisionId != this.DivisionId)
{
Subordinates.Add(division.DivisionId);
OnChange();
}
}
public SendMessage(DivisionController controller, DivisionController commanderSendingOrder, List <Order> message, RememberedDivision target)
{
this.commanderSendingOrder = commanderSendingOrder;
this.controller = controller;
this.finish = target;
this.target = null;
this.message = message;
}
public override void End()
{
controller.GetComponent <Rigidbody>().velocity = Vector3.zero;
RememberedDivision commander = controller.rememberedDivisions[commanderSendingOrder.divisionId];
controller.ReceiveOrder(new FindDivision(controller, target, commander));
controller.ReceiveOrder(new MergeDivisions(controller, commander));
}
public override Vector3 GetPredictedPosition(RememberedDivision rememberedDivision)
{
if (OngoingOrder == null)
{
return(base.GetPredictedPosition(rememberedDivision));
}
return(OngoingOrder.GetPredictedPosition(rememberedDivision));
}
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 OnClickedInUI(Division Host, PlayerController playerController)
{
OrderDisplayManager.Instance.ClearOrders();
RememberedDivision CommanderSendingOrder = GetRememberedDivisionFromHost(playerController.GeneralDivision.AttachedDivision, CommanderSendingOrderId);
CommanderSendingOrder.SendOrderTo(
new RememberedDivision(Host),
new GatherSuppliesOrder(Host, CommanderSendingOrderId), ref playerController.GeneralDivision.AttachedDivision.RememberedDivisions);
}
public void DivisionMenuItemClicked(RememberedDivision division)
{
commander = division;
RegenerateMenuItems();
//bing up context menu for that division on the bottom right, but do different actions
GameManager.instance.localPlayer.select(division);
//need to send messengers to discover its location
//refresh the division menu with his stuff
}
public void AddAutoRunBackgroundOrders()
{
//add background orders which should continously run
RememberedDivision CommanderSendingOrder = new RememberedDivision(this);
CommanderSendingOrder.SendOrderTo(
new RememberedDivision(this),
new UseSuppliesOrder(this, DivisionId), ref RememberedDivisions);
}
public void OnUnitSelected(Division Host, RememberedDivision division, PlayerController playerController)
{
RememberedDivision CommanderSendingOrder = GetRememberedDivisionFromHost(playerController.GeneralDivision.AttachedDivision, CommanderSendingOrderId);
LocalPlayerController.Instance.UnRegisterUnitSelectCallback(UICallback);
OrderDisplayManager.Instance.ClearOrders();
CommanderSendingOrder.SendOrderTo(new RememberedDivision(Host),
new EngageOrder(Host, CommanderSendingOrder.DivisionId, division.DivisionId), ref playerController.GeneralDivision.AttachedDivision.RememberedDivisions);
}
public override void OnClickedInUI(Division Host, PlayerController playerController)
{
OrderDisplayManager.Instance.ClearOrders();
RememberedDivision CommanderSendingOrder = GetRememberedDivisionFromHost(playerController.GeneralDivision.AttachedDivision, CommanderSendingOrderId);
//Debug.Log($"heartbeat {Host.DivisionId} {CommanderSendingOrderId}");
CommanderSendingOrder.SendOrderTo(
new RememberedDivision(Host),
new HeartBeatOrder(Host, CommanderSendingOrderId, CommanderSendingOrderId), ref playerController.GeneralDivision.AttachedDivision.RememberedDivisions);
}
public void SendMessenger(RememberedDivision to, RememberedDivision endTarget, List <Order> orders)
{
//create a new division
DivisionController messenger = CreateNewDivision((int)CommandingOfficer.MessengerDivisionSoldierCnt.Value);
messenger.AttachedDivision.IsMessenger = true;
messenger.name = "messenger";
messenger.AttachedDivision.ReceiveOrder(new FindDivision(messenger.AttachedDivision, DivisionId, to.DivisionId));
messenger.AttachedDivision.ReceiveOrder(new SendMessage(messenger.AttachedDivision, DivisionId, orders, to.DivisionId, endTarget.DivisionId));
}
/// <summary>
/// commit division to a zone
/// </summary>
/// <param name="Host"></param>
/// <param name="playerController"></param>
/// <param name="zone"></param>
public virtual void OnZoneSelected(Division Host, PlayerController playerController, IZone zone)
{
RememberedDivision CommanderSendingOrder = GetRememberedDivisionFromHost(playerController.GeneralDivision.AttachedDivision, CommanderSendingOrderId);
LocalPlayerController.Instance.UnRegisterZoneSelectCallback(UICallback);
OrderDisplayManager.Instance.ClearOrders();
Debug.Log("zone" + " " + zone);
Debug.Log($"{Host.Zones.Count}");
CommanderSendingOrder.SendOrderTo(new RememberedDivision(Host),
new ZoneOrder(Host, CommanderSendingOrder.DivisionId, zone), ref playerController.GeneralDivision.AttachedDivision.RememberedDivisions);
}
public void OnClickReturn(Vector3 mousePos, Division Host, PlayerController playerController)
{
finish = new Vector3(mousePos.x, mousePos.y);
//InputController.Instance.UnRegisterOnClickCallBack(UICallback);
//clear ui
OrderDisplayManager.Instance.ClearOrders();
//need to get
RememberedDivision CommanderSendingOrder = GetRememberedDivisionFromHost(playerController.GeneralDivision.AttachedDivision, CommanderSendingOrderId);
CommanderSendingOrder.SendOrderTo(new RememberedDivision(Host), new Move(Host, CommanderSendingOrder.DivisionId, finish), ref playerController.GeneralDivision.AttachedDivision.RememberedDivisions);
}
public void AddOrderSet(List <Order> orders, RememberedDivision division, PlayerController playerController)
{
foreach (Order order in orders)
{
string name = order.GetType().Name;
GameObject temp = Instantiate(orderPrefab);
temp.transform.GetChild(0).GetComponent <Text>().text = name;
temp.GetComponent <Button>().onClick.AddListener(delegate { order.OnClickedInUI(division, playerController); });
AddToDisplay(temp);
}
}
public void Update(RememberedDivision division)
{
this.position = division.position;
this.velocity = division.velocity;
this.orderQueue = division.orderQueue;
this.soldiers = division.soldiers;
this.divisionId = division.divisionId;
this.timeStamp = division.timeStamp;
this.possibleOrders = division.possibleOrders;
this.subordinates = division.subordinates;
this.commander = division.commander;
}
public void AbsorbDivision(DivisionController other)
{
TransferSoldiers(other.soldiers);
//kick him out of his commanders subordinate list
RememberedDivision parent = other.commander;
if (parent != null)
{
parent.RemoveSubordinate(other.GenerateRememberedDivision());
}
GameObject.Destroy(other.gameObject);
GameManager.instance.RefreshAllDivisons();
}
public void select(RememberedDivision divisionController)
{
if (!UIwaitingForSelection)
{
//bing up order ui
OrderDisplayManager.instance.ClearOrders();
OrderDisplayManager.instance.AddOrderSet(divisionController.possibleOrders);
}
else
{
UIResponseRememberedDivision(divisionController);
}
}
public void OnClickReturn(Vector3 mousePos, Division Host, PlayerController playerController)
{
finish = new Vector3(mousePos.x, mousePos.y);
OrderDisplayManager.Instance.ClearOrders();
var scout = Host.CreateNewDivision((int)Host.CommandingOfficer.ScoutDivisionSoldierCnt.Value);
scout.name = "scout";
RememberedDivision CommanderSendingOrder = GetRememberedDivisionFromHost(playerController.GeneralDivision.AttachedDivision, CommanderSendingOrderId);
scout.AttachedDivision.ReceiveOrder(new Move(scout.AttachedDivision, CommanderSendingOrder.DivisionId, finish));
scout.AttachedDivision.ReceiveOrder(new FindDivision(scout.AttachedDivision, CommanderSendingOrder.DivisionId, Host.DivisionId));
scout.AttachedDivision.ReceiveOrder(new MergeDivisions(scout.AttachedDivision, Host.DivisionId, Host.DivisionId));
}
public RememberedDivision(Vector3 position, Vector3 velocity, List <Order> orders,
List <Soldier> soldiers, int divisionId, float timeStamp,
List <Order> possibleOrders, List <RememberedDivision> subordinates, RememberedDivision commander)
{
this.position = position;
this.velocity = velocity;
this.orderQueue = orders;
this.soldiers = soldiers;
this.divisionId = divisionId;
this.timeStamp = timeStamp;
this.possibleOrders = possibleOrders;
this.subordinates = subordinates;
this.commander = commander;
}
public RememberedDivision GenerateRememberedDivision()
{
List <RememberedDivision> subordinatesDeep = new List <RememberedDivision>();
foreach (RememberedDivision subordinate in subordinates)
{
//subordinatesDeep.Add()
}
RememberedDivision rememberedDivision =
new RememberedDivision(
transform.position, GetComponent <Rigidbody>().velocity, orderQueue, soldiers, divisionId, Time.time, possibleOrders, subordinatesDeep, commander);
return(rememberedDivision);
}
public void OnUnitSelected(Division Host, RememberedDivision division, PlayerController playerController)
{
RememberedDivision CommanderSendingOrder = GetRememberedDivisionFromHost(playerController.GeneralDivision.AttachedDivision, CommanderSendingOrderId);
LocalPlayerController.Instance.UnRegisterUnitSelectCallback(UICallback);
OrderDisplayManager.Instance.ClearOrders();
var orders = new List <Order>()
{
new FindDivision(Host, CommanderSendingOrder.DivisionId, division.DivisionId),
new AttackOrder(Host, CommanderSendingOrder.DivisionId, division.DivisionId, Host.MaxHitRange)
};
CommanderSendingOrder.SendOrdersTo(new RememberedDivision(Host), orders, ref playerController.GeneralDivision.AttachedDivision.RememberedDivisions);
}
public void SendOrdersTo(RememberedDivision to, List <Order> orders, ref Dictionary <int, RememberedDivision> rememberedDivisions)
{
//follow command tree to get there
List <RememberedDivision> pathToDivision = FindDivisionInSubordinatesHelper(new RememberedDivision(this), to, ref rememberedDivisions);
//if path is only size one, we're at where the order needs to go
if (pathToDivision.Count == 1)
{
Controller.AttachedDivision.ReceiveOrders(orders);
return;
}
//send order to the next commander
pathToDivision[0].Controller.SendMessenger(pathToDivision[1], to, orders);
}
public void SendOrderTo(RememberedDivision to, Order order)
{
//follow commander tree to get there
List <RememberedDivision> pathToDivision = FindDivisionInSubordinates(GenerateRememberedDivision(), to, new List <RememberedDivision>());
//if path is only size one, were at where the order needs to go
if (pathToDivision.Count == 1)
{
Debug.Log(order);
ReceiveOrder(order);
return;
}
//send order to the next commander
SendMessenger(pathToDivision[1], order);
}
public override void OnClickedInUI(Division Host, PlayerController playerController)
{
if (Host.Soldiers.Count <= 1)
{
return;
}
var soldiersWanted = new Dictionary <SoldierType, int>();
soldiersWanted.Add(SoldierType.Melee, 1);
OrderDisplayManager.Instance.ClearOrders();
RememberedDivision CommanderSendingOrder = GetRememberedDivisionFromHost(playerController.GeneralDivision.AttachedDivision, CommanderSendingOrderId);
CommanderSendingOrder.SendOrderTo(new RememberedDivision(Host), new SplitDivision(Host, CommanderSendingOrderId, soldiersWanted), ref playerController.GeneralDivision.AttachedDivision.RememberedDivisions);
}