public float GetOrderPriority(AIObjective objective)
{
if (objective == ForcedOrder)
{
return(HighestOrderPriority);
}
var currentOrder = CurrentOrders.FirstOrDefault(o => o.Objective == objective);
if (currentOrder.Objective == null)
{
return(HighestOrderPriority);
}
else if (currentOrder.ManualPriority > 0)
{
if (objective.ForceHighestPriority)
{
return(HighestOrderPriority);
}
if (objective.PrioritizeIfSubObjectivesActive && objective.SubObjectives.Any())
{
return(HighestOrderPriority);
}
return(MathHelper.Lerp(LowestOrderPriority, HighestOrderPriority - 1, MathUtils.InverseLerp(1, CharacterInfo.HighestManualOrderPriority, currentOrder.ManualPriority)));
}
#if DEBUG
DebugConsole.AddWarning("Error in order priority: shouldn't return 0!");
#endif
return(0);
}
public void UpdateObjectives(float deltaTime)
{
UpdateOrderObjective(ForcedOrder);
if (CurrentOrders.Any())
{
foreach (var order in CurrentOrders)
{
var orderObjective = order.Objective;
UpdateOrderObjective(orderObjective);
}
}
void UpdateOrderObjective(AIObjective orderObjective)
{
if (orderObjective == null)
{
return;
}
#if DEBUG
// Note: don't automatically remove orders here. Removing orders needs to be done via dismissing.
if (!orderObjective.CanBeCompleted)
{
DebugConsole.NewMessage($"{character.Name}: ORDER {orderObjective.DebugTag}, CANNOT BE COMPLETED.", Color.Red);
}
#endif
orderObjective.Update(deltaTime);
}
if (WaitTimer > 0)
{
WaitTimer -= deltaTime;
return;
}
for (int i = 0; i < Objectives.Count; i++)
{
var objective = Objectives[i];
if (objective.IsCompleted)
{
#if DEBUG
DebugConsole.NewMessage($"{character.Name}: Removing objective {objective.DebugTag}, because it is completed.", Color.LightBlue);
#endif
Objectives.Remove(objective);
}
else if (!objective.CanBeCompleted)
{
#if DEBUG
DebugConsole.NewMessage($"{character.Name}: Removing objective {objective.DebugTag}, because it cannot be completed.", Color.Red);
#endif
Objectives.Remove(objective);
FailedAutonomousObjectives = true;
}
else
{
objective.Update(deltaTime);
}
}
GetCurrentObjective();
}
public OrderInfo?GetCurrentOrderInfo()
{
if (currentOrder == null)
{
return(null);
}
return(CurrentOrders.FirstOrDefault(o => o.Objective == CurrentOrder));
}
//Side-Menu-Handling
private void NavCurrentOrder_Click(object sender, RoutedEventArgs e)
{
Content.Children.Clear();
NavigationBar.Children.Clear();
CurrentOrders page = new CurrentOrders();
Content.Children.Add(page);
page.Width = Content.Width;
page.Height = Content.Height;
}
protected void RefreshOrdersFilterXML(bool clear, bool sendMail)
{
if (clear)
{
CurrentOrders.Clear();
}
GlobalStatus.Current.IsBusy = true;
if (!sendMail)
{
OrdersClient.GetFilteredOrdersFromFilterAsync(Filter, OrdersClientContext.Current.SessionGUID);
}
else
{
OrdersClient.GetFilteredOrdersFromFilterToMailAsync(Filter, OrdersClientContext.Current.SessionGUID);
}
LastUpdate = DateTime.Now;
}
private void MoveTowardsTarget()
{
if (Move())
{
// Finish orders
Simulation.ClosedOrders.AddRange(CurrentOrders);
// Clear order-related variables
CurrentOrders.Clear();
PathToTarget.Clear();
CurrentTarget = null;
DistanceToCurrentTarget = 0d;
TimeToCurrentTarget = 0d;
DistanceTraveled = 0d;
State = VehicleState.Idle;
}
}
protected void gvOrderLineItems_RowDataBound(object sender, GridViewRowEventArgs e)
{
if (e.Row.RowType == DataControlRowType.DataRow)
{
Label lblqty = (Label)e.Row.FindControl("lblqty");
int qty = Int32.Parse(lblqty.Text.Substring(1, lblqty.Text.Length - 4));
total = total + qty;
}
if (e.Row.RowType == DataControlRowType.Footer)
{
Label lblTotalqty = (Label)e.Row.FindControl("lblTotalqty");
lblTotalqty.Text = String.Format("{0:C}", total.ToString());
}
Session["OrderTotal"] = total;
CurrentOrders.Update();
}
private void OrdersClient_GetFilteredOrdersFromFilterCompleted(object sender, GetFilteredOrdersFromFilterCompletedEventArgs e)
{
if (e.Error == null)
{
CurrentOrders.Clear();
foreach (Order order in e.Result)
{
CurrentOrders.Add(order);
}
CurrentView.Source = CurrentOrders;
LastUpdate = DateTime.Now;
}
else
{
MessageBox.Show("Ошибка при загрузке данных ");
}
GlobalStatus.Current.IsBusy = false;
}
private void DismissSelf(Order order, string option)
{
var currentOrder = CurrentOrders.FirstOrDefault(oi => oi.MatchesOrder(order, option));
if (currentOrder.Order == null)
{
#if DEBUG
DebugConsole.ThrowError("Tried to self-dismiss an order, but no matching current order was found");
#endif
return;
}
#if CLIENT
if (GameMain.GameSession?.CrewManager != null && GameMain.GameSession.CrewManager.IsSinglePlayer)
{
GameMain.GameSession?.CrewManager?.SetCharacterOrder(character, Order.GetPrefab("dismissed"), Order.GetDismissOrderOption(currentOrder), currentOrder.ManualPriority, character);
}
#else
GameMain.Server?.SendOrderChatMessage(new OrderChatMessage(Order.GetPrefab("dismissed"), Order.GetDismissOrderOption(currentOrder), currentOrder.ManualPriority, currentOrder.Order?.TargetSpatialEntity, character, character));
#endif
}
public void Set_Orders()
{
NewOrders.Clear();
ConfirmOrders.Clear();
CurrentOrders.Clear();
foreach (var order in IoC.Application_Work.All_Orders)
{
if (order.Status == StatusOfProduct.Inpprocessing || order.Status == StatusOfProduct.HoldDispetcherToDriverAccept)
{
NewOrders.Add(Make_UserProductsViewModel(order));
}
else if (order.Status == StatusOfProduct.Current)
{
CurrentOrders.Add(Make_UserProductsViewModel(order));
}
else if (order.Status == StatusOfProduct.Completed)
{
ConfirmOrders.Add(Make_UserProductsViewModel(order));
}
}
}
public bool HasOrder <T>() where T : AIObjective
{
return(ForcedOrder is T || CurrentOrders.Any(o => o.Objective is T));
}
public bool HasOrders()
{
return(ForcedOrder != null || CurrentOrders.Any());
}
public bool IsOrder(AIObjective objective)
{
return(objective == ForcedOrder || CurrentOrders.Any(o => o.Objective == objective));
}
public void SetOrder(Order order, string option, int priority, Character orderGiver, bool speak)
{
if (character.IsDead)
{
#if DEBUG
DebugConsole.ThrowError("Attempted to set an order for a dead character");
#else
return;
#endif
}
ClearIgnored();
if (order == null || order.Identifier == "dismissed")
{
if (!string.IsNullOrEmpty(option))
{
if (CurrentOrders.Any(o => o.MatchesDismissedOrder(option)))
{
var dismissedOrderInfo = CurrentOrders.First(o => o.MatchesDismissedOrder(option));
CurrentOrders.Remove(dismissedOrderInfo);
}
}
else
{
CurrentOrders.Clear();
}
}
// Make sure the order priorities reflect those set by the player
for (int i = CurrentOrders.Count - 1; i >= 0; i--)
{
var currentOrder = CurrentOrders[i];
if (currentOrder.Objective == null || currentOrder.MatchesOrder(order, option))
{
CurrentOrders.RemoveAt(i);
continue;
}
var currentOrderInfo = character.GetCurrentOrder(currentOrder.Order, currentOrder.OrderOption);
if (currentOrderInfo.HasValue)
{
int currentPriority = currentOrderInfo.Value.ManualPriority;
if (currentOrder.ManualPriority != currentPriority)
{
CurrentOrders[i] = new OrderInfo(currentOrder, currentPriority);
}
}
else
{
CurrentOrders.RemoveAt(i);
}
}
var newCurrentOrder = CreateObjective(order, option, orderGiver, isAutonomous: false);
if (newCurrentOrder != null)
{
CurrentOrders.Add(new OrderInfo(order, option, priority, newCurrentOrder));
}
if (!HasOrders())
{
// Recreate objectives, because some of them may be removed, if impossible to complete (e.g. due to path finding)
CreateAutonomousObjectives();
}
else
{
// This should be redundant, because all the objectives are reset when they are selected as active.
newCurrentOrder?.Reset();
if (speak && character.IsOnPlayerTeam)
{
character.Speak(TextManager.Get("DialogAffirmative"), null, 1.0f);
//if (speakRoutine != null)
//{
// CoroutineManager.StopCoroutines(speakRoutine);
//}
//speakRoutine = CoroutineManager.InvokeAfter(() =>
//{
// if (GameMain.GameSession == null || Level.Loaded == null) { return; }
// if (newCurrentOrder != null && character.SpeechImpediment < 100.0f)
// {
// if (newCurrentOrder is AIObjectiveRepairItems repairItems && repairItems.Targets.None())
// {
// character.Speak(TextManager.Get("DialogNoRepairTargets"), null, 3.0f, "norepairtargets");
// }
// else if (newCurrentOrder is AIObjectiveChargeBatteries chargeBatteries && chargeBatteries.Targets.None())
// {
// character.Speak(TextManager.Get("DialogNoBatteries"), null, 3.0f, "nobatteries");
// }
// else if (newCurrentOrder is AIObjectiveExtinguishFires extinguishFires && extinguishFires.Targets.None())
// {
// character.Speak(TextManager.Get("DialogNoFire"), null, 3.0f, "nofire");
// }
// else if (newCurrentOrder is AIObjectiveFixLeaks fixLeaks && fixLeaks.Targets.None())
// {
// character.Speak(TextManager.Get("DialogNoLeaks"), null, 3.0f, "noleaks");
// }
// else if (newCurrentOrder is AIObjectiveFightIntruders fightIntruders && fightIntruders.Targets.None())
// {
// character.Speak(TextManager.Get("DialogNoEnemies"), null, 3.0f, "noenemies");
// }
// else if (newCurrentOrder is AIObjectiveRescueAll rescueAll && rescueAll.Targets.None())
// {
// character.Speak(TextManager.Get("DialogNoRescueTargets"), null, 3.0f, "norescuetargets");
// }
// else if (newCurrentOrder is AIObjectivePumpWater pumpWater && pumpWater.Targets.None())
// {
// character.Speak(TextManager.Get("DialogNoPumps"), null, 3.0f, "nopumps");
// }
// }
//}, 3);
}
}
}
/// <summary>
/// Move along the path towards the specified target
/// <returns>Whether it arrived at the final target</returns>
/// </summary>
private bool Move()
{
if (CurrentTarget == null && PathToTarget.Count >= 2)
{
CurrentTarget = PathToTarget[1];
DistanceToCurrentTarget = Vehicle.TravelMode == GoogleMapsComponents.Maps.TravelMode.Transit ?
PathToTarget[0].Edges.First(e => e.Destination == PathToTarget[1]).Info.Distance :
PathToTarget[0].Edges.First(e => e.Destination == PathToTarget[1]).Info.GMapsDistanceAndTime[Vehicle.TravelMode].Item1;
TimeToCurrentTarget = Vehicle.TravelMode == GoogleMapsComponents.Maps.TravelMode.Transit ? 0d
: PathToTarget[0].Edges.First(e => e.Destination == PathToTarget[1]).Info.GMapsDistanceAndTime[Vehicle.TravelMode].Item2;
}
if (DistanceTraveled >= DistanceToCurrentTarget)
{
CurrentVertexPosition = CurrentTarget;
var currentIndexInPath = PathToTarget.IndexOf(CurrentVertexPosition);
if (currentIndexInPath == PathToTarget.Count - 1)
{
return(true);
}
CurrentTarget = PathToTarget[currentIndexInPath + 1];
DistanceTraveled = 0d;
DistanceToCurrentTarget = Vehicle.TravelMode == GoogleMapsComponents.Maps.TravelMode.Transit ?
PathToTarget[currentIndexInPath].Edges.First(e => e.Destination == PathToTarget[currentIndexInPath + 1]).Info.Distance :
PathToTarget[currentIndexInPath].Edges.First(e => e.Destination == PathToTarget[currentIndexInPath + 1]).Info.GMapsDistanceAndTime[Vehicle.TravelMode].Item1;
TimeToCurrentTarget = Vehicle.TravelMode == GoogleMapsComponents.Maps.TravelMode.Transit ? 0d
: PathToTarget[currentIndexInPath].Edges.First(e => e.Destination == PathToTarget[currentIndexInPath + 1]).Info.GMapsDistanceAndTime[Vehicle.TravelMode].Item2;
}
else
{
DistanceTraveled += GetSpeedInMetersPerSecond(DistanceToCurrentTarget, TimeToCurrentTarget, TravelMode);
if (State == VehicleState.MovingToTarget)
{
CurrentFuelLoaded -= GetFuelConsumptionForOneMeter(CurrentOrders?.Sum(o => o.Order.PayloadWeight) ?? 0d) * GetSpeedInMetersPerSecond(DistanceToCurrentTarget, TimeToCurrentTarget, TravelMode);
}
else if (State == VehicleState.PickingUpOrder)
{
CurrentFuelLoaded -= BaseFuelConsumption * GetSpeedInMetersPerSecond(DistanceToCurrentTarget, TimeToCurrentTarget, TravelMode);
}
// Record progress in order
CurrentOrders.ForEach(o =>
{
if (State == VehicleState.MovingToTarget)
{
o.DeliveryTime++;
o.DeliveryDistance += GetSpeedInMetersPerSecond(DistanceToCurrentTarget, TimeToCurrentTarget, TravelMode);
o.DeliveryCost = CalculateJourneyCost(o.DeliveryDistance, o.DeliveryTime) / CurrentOrders.Count; // divide cost depending how many orders are loaded
}
else if (State == VehicleState.PickingUpOrder)
{
o.PickupTime++;
o.PickupDistance += GetSpeedInMetersPerSecond(DistanceToCurrentTarget, TimeToCurrentTarget, TravelMode);
o.PickupCost = CalculateJourneyCost(o.PickupDistance, o.PickupTime) / CurrentOrders.Count; // divide cost depending how many orders are loaded
}
});
// Record statistics
TotalTravelDistance += GetSpeedInMetersPerSecond(DistanceToCurrentTarget, TimeToCurrentTarget, TravelMode);
TotalTravelTime++;
}
return(false);
}
private void MoveTowardsPickup()
{
if (Move())
{
PathToTarget = Simulation.Parameters.Graph.FindShortestPath(Simulation.Parameters.Graph, CurrentOrders.First().Start, CurrentOrders.First().Target, TravelMode).Item1;
DistanceToCurrentTarget = 0d;
TimeToCurrentTarget = 0d;
DistanceTraveled = 0d;
// Refuel the vehicle before heading out to deliver
State = VehicleState.Refueling;
}
}
public T GetOrder <T>() where T : AIObjective => CurrentOrders.FirstOrDefault(o => o.Objective is T).Objective as T;
protected void Insert(object sender, EventArgs e)
{
Session["OrderDate"] = DateTime.Now.ToString("MM/dd/yyyy");
CurrentOrders.Insert();
}
