/**
* Retourne true ssi le stock associé à ce StockLock peut accueillir le
* chargement passé en paramètre sans violer les limitations qu'il impose.
**/
public bool AvailableFor(ResourceShipment shipment)
{
bool stockNotFull = _stock.totalStock + shipment.amount <= totalStockLimit;
bool resourceLimitOk = _stock.StockFor(shipment.resourceName) <= LimitFor(shipment.resourceName);
return(stockNotFull && resourceLimitOk);
}
public void AddShipment(ResourceShipment toAdd)
{
if (toAdd != null && toAdd.resourceName == resourceName)
{
amount += toAdd.amount;
}
}
public void DeliverKeptAsideOrderTo(ResourceCarrier recipient)
{
ResourceShipment orderedShipment = null;
IEnumerator <AgoraMerchant> merchantsEnumerator = _agora.MerchantsEnumerator();
while (merchantsEnumerator.MoveNext())
{
AgoraMerchant merchant = merchantsEnumerator.Current;
KeepAsideOrderManager merchantOrderManager = merchant.GetComponent <KeepAsideOrderManager>();
if (merchantOrderManager != null)
{
if (orderedShipment != null)
{
orderedShipment.AddShipment(merchantOrderManager.DeliverKeptAside(recipient));
}
else
{
orderedShipment = merchantOrderManager.DeliverKeptAside(recipient);
}
}
}
recipient.shipment = orderedShipment;
}
private IEnumerator DeliveryCoroutine(ResourceCarrier carrier)
{
KeepAsideOrderManager keepAsideOrderManager = freightAreaData.parentStock.GetComponent <KeepAsideOrderManager>();
yield return(new WaitForSeconds(waterDeliveryTime));
ResourceShipment order = keepAsideOrderManager.DeliverKeptAside(carrier);
carrier.shipment = order;
carrier.destination = carrier.origin;
carrier.GetComponent <RoadRouteManager>().MoveTo(carrier.destination.freightAreaData.freightAreaIn.road);
}
/**
* Coroutine à lancer pour découvrir la FreightArea de l'entrepôt le plus proche
* capable d'accueillir le chargement passé en paramètre.
**/
public IEnumerator FindNearestFreeWarehouseFor(ResourceShipment shipment, Cell <FreightAreaIn> rslt, HashSet <FreightAreaIn> toIgnore)
{
Cell <Warehouse> nearestFree = new Cell <Warehouse>();
Func <Warehouse, bool> acceptanceFunction = (Warehouse toTest) => toTest.orderManager.stock.stockLock.AvailableFor(shipment);
yield return(StartCoroutine(StockManager.FindNearestWarehouseSatisfyingCondition(this, acceptanceFunction, nearestFree, toIgnore)));
if (nearestFree.value != null)
{
rslt.value = nearestFree.value.orderManager.freightAreaData.freightAreaIn;
}
}
public override int OrderedAmountFor(string resourceName)
{
int count = base.OrderedAmountFor(resourceName);
foreach (ResourceOrder keptAside in _keptAsideOrders.Values)
{
ResourceShipment shipment = keptAside.shipment;
if (shipment.resourceName == resourceName)
{
count += shipment.amount;
}
}
return(count);
}
private IEnumerator ManageWarehouseDispatching()
{
FreightAreaData freightData = _currentStock.freightAreaData;
RoadLock freightOutLock = freightData.freightAreaOut.road.roadLock;
while (true)
{
if (!orderManager.SendOrderIfPossible() && _warehouseOrders.Count <= WAREHOUSE_ORDERS_LIMIT) //L'appel à la méthode envoie une commande si elle retourne true, d'où l'aspect un peu étrange de la condition
{
foreach (ResourceShipment productionShipment in production) //TODO: si on produit plusieurs ressources et qu'on veut définir l'ordre dans lequel elles partent, c'est ici
{
int resourceStock = _currentStock.StockFor(productionShipment.resourceName);
for (int i = 0; i < freightData.availableCarriers && resourceStock > 0; i++)
{
int amountToShip = Math.Min(freightData.carrierPrefab.capacity, resourceStock);
ResourceShipment toShip = new ResourceShipment(productionShipment.resourceName, amountToShip);
Cell <FreightAreaIn> nestedCoroutineReturnHelper = new Cell <FreightAreaIn>();
yield return(StartCoroutine(freightData.freightAreaOut.road.FindNearestFreeWarehouseFor(toShip, nestedCoroutineReturnHelper, new HashSet <FreightAreaIn>())));
FreightAreaIn nearestFreeWarehouse = nestedCoroutineReturnHelper.value;
if (nearestFreeWarehouse != null)
{
while (!freightOutLock.IsFree(Orientation.SOUTH))//TODO orientation
{
yield return(new WaitForSeconds(0.2f));
}
_warehouseOrders.Enqueue(new ResourceOrder(new ResourceShipment(productionShipment.resourceName, amountToShip), nearestFreeWarehouse.GetComponentInParent <BuildingStock>()));
}
resourceStock = _currentStock.StockFor(productionShipment.resourceName);
}
}
}
yield return(new WaitForSeconds(0.5f));
}
}
/**
* Coroutine se chargeant d'envoyer tout ce qui a été produit par le bâtiment
* et se trouve contenu dans son stock à l'entrepôt le plus proche capable
* de l'accueillir ou à un bâtiment l'ayant commandé. Tout cela se voit bien
* entendu diviser entre les transporteurs
* disponibles pour le bâtiment.
**/
private IEnumerator ManageProductionStorage()
{
FreightAreaData freightData = orderManager.freightAreaData;
while (true)
{
if (!orderManager.SendOrderIfPossible() && !orderManager.OrdersToTreat() && _warehouseOrders.Count > 0)//L'appel à la méthode envoie une commande si elle retourne true, d'où l'aspect un peu étrange de la condition
{
ResourceOrder warehouseOrder = _warehouseOrders.Dequeue();
ResourceShipment orderShipment = warehouseOrder.shipment;
FreightAreaIn destinationIn = warehouseOrder.deliveryPlace.freightAreaData.freightAreaIn;
if (orderManager.stock.StockFor(orderShipment.resourceName) >= orderShipment.amount && RoadsPathfinding.RouteStar(destinationIn.road, freightData.freightAreaOut.road, 10, Orientation.SOUTH) != null)//TODO orientation
{
_currentStock.RemoveFromStock(orderShipment.resourceName, orderShipment.amount);
freightData.SendCarrier(warehouseOrder.deliveryPlace, Orientation.SOUTH, orderShipment);//TODO orientation
}
}
yield return(new WaitForSeconds(0.5f));
}
}
private void RegisterOrderToPick(ResourceCarrier carrier, string resource, int amount)
{
_ordersToPick[carrier] = new ResourceShipment(resource, amount);
}
/**
* Annule une commande passée (car le transporteur s'est trouvé bloqué trop
* longtemps ou que le bâtiment a perdu son lien au réseau routier avant
* expédition de sa commande) en réindiquant le chargement comme "à commander".
**/
public void CancelResourceOrder(ResourceShipment order)
{
_resourcesToOrder[order.resourceName] += order.amount;
}
/**
* Retire du stock le chargement passé en paramètre.
**/
public void RemoveFromStock(ResourceShipment shipment)
{
RemoveFromStock(shipment.resourceName, shipment.amount);
}
/**
* Ajoute le chargement passé en paramètre au stock.
**/
public void AddToStock(ResourceShipment shipment)
{
AddToStock(shipment.resourceName, shipment.amount);
}
/**
* Envoie un transporteur (généré AVANT l'appel à la méthode) vers destination,
* avec pour orientation de départ orientation et pour chargement shipment.
**/
public void SendCarrier(ResourceCarrier toSend, BuildingStock destination, string orientation, ResourceShipment shipment)
{//TODO: la nouvelle version de ceci, qui enqueue sur la FreightAreaOut, permet de faire moins de vérifications avant l'appel de cette méthode=> il y a sans doute des trucs à simplifier ailleurs dans le code.
toSend.shipment = shipment;
toSend.origin = parentStock;
toSend.destination = destination;
toSend.GetComponent <MoveManager>().orientation = orientation;//TODO orientation: faire en sorte que les appels à cette méthode donnent bien tous la bonne orientation pour sortir de FAout
freightAreaOut.EnqueueCarrierToSend(toSend);
}
/**
* Envoie un nouveau transporteur vers destination, avec pour orientation de
* départ orientation et pour chargement shipment.
**/
public void SendCarrier(BuildingStock destination, string orientation, ResourceShipment shipment)
{//TODO: la nouvelle version de ceci, qui enqueue sur la FreightAreaOut, permet de faire moins de vérifications avant l'appel de cette méthode=> il y a sans doute des trucs à simplifier ailleurs dans le code.
ResourceCarrier newCarrier = InstantiateCarrierWithoutCollider();
SendCarrier(newCarrier, destination, orientation, shipment);
}
/**
* Renvoie un transporteur en lui assignant un chargement.
**/
public void SendBack(ResourceCarrier carrier, ResourceShipment shipment)
{
carrier.shipment = shipment;
SendBack(carrier);
}
public ResourceOrder(ResourceShipment shipment, BuildingStock deliveryPlace)
{
this.shipment = shipment;
this.deliveryPlace = deliveryPlace;
}
