public ImmutableArray <Order> GetAll()
{
using (_contextFactory.GetReadSyncContext($"{nameof(OrdersCache)}.{nameof(GetAll)}"))
return(ActiveOrders.GetAllOrders()
.Union(WaitingForExecutionOrders.GetAllOrders())
.Union(ClosingOrders.GetAllOrders()).ToImmutableArray());
}
public void RefreshView()
{
Menu.Clear();
Clients.Clear();
ActiveOrders.Clear();
CompletedOrders.Clear();
ActiveDelivery.Clear();
CompletedDeliveries.Clear();
foreach (Dish dish in restaurantManager.GetMenu())
{
Menu.Add(dish);
}
foreach (Client client in restaurantManager.GetAllClients())
{
Clients.Add(client);
}
foreach (Order order in restaurantManager.GetActiveOrders())
{
ActiveOrders.Add(order);
}
foreach (Order order in restaurantManager.GetCompletedOrders())
{
CompletedOrders.Add(order);
}
foreach (Order order in restaurantManager.GetActiveDeliveries())
{
ActiveDelivery.Add(order);
}
foreach (Order order in restaurantManager.GetCompletedDeliveries())
{
CompletedDeliveries.Add(order);
}
}
public void RefreshView()
{
Menu.Clear();
Clients.Clear();
ActiveOrders.Clear();
CompletedOrders.Clear();
ActiveDelivery.Clear();
CompletedDeliveries.Clear();
foreach (DishDTG dish in restaurantManager.GetMenu())
{
Menu.Add(new DishModel(dish));
}
foreach (ClientDTG client in restaurantManager.GetAllClients())
{
Clients.Add(new ClientModel(client));
}
foreach (OrderDTG order in restaurantManager.GetActiveOrders())
{
ActiveOrders.Add(new OrderModel(order));
}
foreach (OrderDTG order in restaurantManager.GetCompletedOrders())
{
CompletedOrders.Add(new OrderModel(order));
}
foreach (OrderDTG order in restaurantManager.GetActiveDeliveries())
{
ActiveDelivery.Add(new OrderModel(order));
}
foreach (OrderDTG order in restaurantManager.GetCompletedDeliveries())
{
CompletedDeliveries.Add(new OrderModel(order));
}
}
public void CompleteOrder(int Id)
{
Order tmp = ActiveOrders.Find(x => x.Id == Id);
CompletedOrders.Add(new Order(tmp.Id, tmp.Client, tmp.OrderDate, tmp.Dishes, tmp.Delivery, tmp.DeliveryAdress, tmp.DeliveryEndTime));
CompletedOrders[CompletedOrders.Count - 1].CompleteOrderDate = DateTime.Now;
ActiveOrders.RemoveAll(x => x.Id == Id);
}
public void DeliveringProcess() // Процесс доставки
{
for (int i = 0; i < DelayedOrders.Count; i++)
{
try
{
if (DelayedOrders[i].WeatherCheck())
{
DelayedOrders.Remove(DelayedOrders[i]);
}
}
catch { }
}
for (int i = 0; i < ActiveOrders.Count; i++)
{
string tmp = ActiveOrders[i].OrderInProgress();
if (tmp == "Delivered")
{
if (ActiveOrders.Count != 0 && ActiveOrders[i].Highway && ActiveOrders[i].TransportType != "Plane")
{
totalHighwayDistance += ActiveOrders[i].DeliveringDistance;
totalHighwayWeight += ActiveOrders[i].Weight;
totalHighwayIncome += ActiveOrders[i].Price;
}
else if (!ActiveOrders[i].Highway && ActiveOrders[i].TransportType != "Plane")
{
totalRegularDistance += ActiveOrders[i].DeliveringDistance;
totalRegularWeight += ActiveOrders[i].Weight;
totalRegularIncome += ActiveOrders[i].Price;
}
ActiveOrders.Remove(ActiveOrders[i]);
if (i == ActiveOrders.Count)
{
break;
}
}
else if (tmp == "Accident")
{
if (ActiveOrders.Count != 0 && ActiveOrders[i].Highway && ActiveOrders[i].TransportType != "Plane")
{
totalHighwayIncome -= ActiveOrders[i].Price;
}
else if (!ActiveOrders[i].Highway && ActiveOrders[i].TransportType != "Plane")
{
totalRegularIncome -= ActiveOrders[i].Price;
}
ActiveOrders.Remove(ActiveOrders[i]);
if (i == ActiveOrders.Count)
{
break;
}
}
}
}
public void Update(float deltaTime)
{
foreach (Pair <Order, float> order in ActiveOrders)
{
order.Second -= deltaTime;
}
ActiveOrders.RemoveAll(o => o.Second <= 0.0f);
UpdateConversations(deltaTime);
UpdateProjectSpecific(deltaTime);
}
public void CreateOrder(int currentOrderIndex, Client client, DateTime orderDate, List <DishDTG> dishes, bool delivery, Address deliveryAddress, DateTime deliveryEndTime)
{
List <Dish> dataDishes = new List <Dish>();
foreach (DishDTG dtg in dishes)
{
int cat = Convert.ToInt32(dtg.Category);
dataDishes.Add(new Dish(dtg.Id, dtg.Name, dtg.Description, null, (Category)cat, dtg.Price));
}
Order order = new Order(currentOrderIndex, client, orderDate, dataDishes, delivery, deliveryAddress, deliveryEndTime);
ActiveOrders.Add(order);
}
public Order GetOrderById(string orderId)
{
if (WaitingForExecutionOrders.TryGetOrderById(orderId, out var result))
{
return(result);
}
if (ActiveOrders.TryGetOrderById(orderId, out result))
{
return(result);
}
throw new Exception(string.Format(MtMessages.OrderNotFound, orderId));
}
public bool AddOrder(Order order, float?fadeOutTime)
{
if (order.TargetEntity == null)
{
DebugConsole.ThrowError("Attempted to add an order with no target entity to CrewManager!\n" + Environment.StackTrace.CleanupStackTrace());
return(false);
}
// Ignore orders work a bit differently since the "unignore" order counters the "ignore" order
var isUnignoreOrder = order.Identifier == "unignorethis";
var orderPrefab = !isUnignoreOrder ? order.Prefab : Order.GetPrefab("ignorethis");
Pair <Order, float?> existingOrder = ActiveOrders.Find(o =>
o.First.Prefab == orderPrefab && MatchesTarget(o.First.TargetEntity, order.TargetEntity) &&
(o.First.TargetType != Order.OrderTargetType.WallSection || o.First.WallSectionIndex == order.WallSectionIndex));
if (existingOrder != null)
{
if (!isUnignoreOrder)
{
existingOrder.Second = fadeOutTime;
return(false);
}
else
{
ActiveOrders.Remove(existingOrder);
return(true);
}
}
else if (!isUnignoreOrder)
{
ActiveOrders.Add(new Pair <Order, float?>(order, fadeOutTime));
return(true);
}
bool MatchesTarget(Entity existingTarget, Entity newTarget)
{
if (existingTarget == newTarget)
{
return(true);
}
if (existingTarget is Hull existingHullTarget && newTarget is Hull newHullTarget)
{
return(existingHullTarget.linkedTo.Contains(newHullTarget));
}
return(false);
}
return(false);
}
public NodeOrderService(IContainer container)
{
this.container = container;
orderRoot = container.GetById(OrderRootId);
if (orderRoot == null)
{
container.RootNode.Add(new HiddenNode()
{
Id = OrderRootId
});
}
else
{
foreach (var order in orderRoot.Children.OfType <NodeOrder>())
{
ActiveOrders.Add(order);
}
}
}
public void Update(float deltaTime)
{
foreach (Pair <Order, float?> order in ActiveOrders)
{
if (order.Second.HasValue)
{
order.Second -= deltaTime;
}
}
ActiveOrders.RemoveAll(o => o.Second.HasValue && o.Second <= 0.0f);
UpdateConversations(deltaTime);
UpdateProjectSpecific(deltaTime);
ActiveReadyCheck?.Update(deltaTime);
if (ActiveReadyCheck != null && ActiveReadyCheck.IsFinished)
{
ActiveReadyCheck = null;
}
}
public bool AddOrder(Order order, float fadeOutTime)
{
if (order.TargetEntity == null)
{
DebugConsole.ThrowError("Attempted to add an order with no target entity to CrewManager!\n" + Environment.StackTrace.CleanupStackTrace());
return(false);
}
Pair <Order, float> existingOrder = ActiveOrders.Find(o => o.First.Prefab == order.Prefab && o.First.TargetEntity == order.TargetEntity);
if (existingOrder != null)
{
existingOrder.Second = fadeOutTime;
return(false);
}
else
{
ActiveOrders.Add(new Pair <Order, float>(order, fadeOutTime));
return(true);
}
}
// Removes the order where OrderNumber == orderNumber from ActiveOrders
// Returns true if successful, false otherwise
public static bool FillOrder(long orderNumber)
{
int orderIndex = 0;
for (int i = 0; i < ActiveOrders.Count; i++)
{
if (ActiveOrders[i].OrderNumber == orderNumber)
{
orderIndex = i;
}
}
// Order found
if (orderIndex > 0)
{
ActiveOrders.RemoveAt(orderIndex);
return(true);
}
// Order not found
return(false);
}
public void ServerWriteActiveOrders(IWriteMessage msg)
{
ushort count = (ushort)ActiveOrders.Count(o => o.First != null && !o.Second.HasValue);
msg.Write(count);
if (count > 0)
{
foreach (var activeOrder in ActiveOrders)
{
if (!(activeOrder?.First is Order order) || activeOrder.Second.HasValue)
{
continue;
}
OrderChatMessage.WriteOrder(msg, order, null, order.TargetSpatialEntity, null, 0, order.WallSectionIndex);
bool hasOrderGiver = order.OrderGiver != null;
msg.Write(hasOrderGiver);
if (hasOrderGiver)
{
msg.Write(order.OrderGiver.ID);
}
}
}
}
public ImmutableArray <Order> GetActive()
{
return(ActiveOrders.GetAllOrders().ToImmutableArray());
}
public Order FindOrder(int orderID)
{
return(ActiveOrders.FirstOrDefault(o => o.OrderID == orderID));
}
public void RemoveOrder(Order order)
{
ActiveOrders.RemoveAll(o => o.First == order);
}
public bool TryGetOrderById(string orderId, out Order order)
{
return(WaitingForExecutionOrders.TryGetOrderById(orderId, out order) ||
ActiveOrders.TryGetOrderById(orderId, out order));
}
public Order GetActiveOrderById(int Id)
{
return(ActiveOrders.Find(o => o.Id == Id));
}
public static void AddOrder(Order newOrder)
{
ActiveOrders.Add(newOrder);
}
