Esempio n. 1
0
        private void MergeDublicates(ExternalTradingResources tradingResources)
        {
            tradingResources.TradingResourceList.RemoveAll(r => r.Amount <= 0);
            if (tradingResources.Count() < 2)
            {
                return;
            }

            var toKepp = new List <TradingResource>();

            foreach (var groupedTradingResources in tradingResources.TradingResourceList.GroupBy(r => r.Owner))
            {
                BuildCombinedResourceList(toKepp, groupedTradingResources);
            }

            tradingResources.TradingResourceList.RemoveAll(r => !toKepp.Any(re => re.TradingResourceId == r.TradingResourceId));
        }
        public void ComputeExternalTrade(ExternalTradingResources externalTradingResources, double demand, ResourceTypes.ResourceType resourceType,
                                         double resourceRatio, InternalMarket internalMarket)
        {
            double externalPrice = GetBestCost(resourceType, out TradeRegion destination, out TradeRegion worstTradeRegion);

            IncreaseTradeWith(resourceType, destination, worstTradeRegion);

            double priceRatio = externalPrice / internalMarket.GetSupplyToDemandRatio(resourceType).ResourcesPrice;

            DoExternalTradeWithExternalResources(priceRatio, demand, externalTradingResources, resourceType);

            if (priceRatio <= 1.05)
            {
                return;
            }
            DoExternalTradeWithInternalResources(internalMarket.GetSupply(resourceType).TradingResourceList, resourceType, resourceRatio);
        }
 public void Init()
 {
     ExternatlTradingResourcesInTransit = new ExternalTradingResources().Init();
     TradeRegions = new List <TradeRegion>();
 }
 public ExternalMarket()
 {
     NewExternatlTradingResources = new ExternalTradingResources().Init();
 }
        private void DoExternalTradeWithExternalResources(double priceRatio, double demand, ExternalTradingResources externalTradingResources, ResourceTypes.ResourceType resourceType)
        {
            double amountOfResources = externalTradingResources.TradingResourceList.Count;

            if (amountOfResources == 0)
            {
                return;
            }
            double transportTimeOutOfRigion = Ownregion.GetTransportTime() / 2;
            double keepAmount = getSendRatio(demand, priceRatio);

            if (keepAmount >= amountOfResources)
            {
                return;
            }
            double exportRatio = (amountOfResources - keepAmount) / amountOfResources;

            foreach (ExternalTradingResource externalTradingResource in externalTradingResources.TradingResourceList)
            {
                double totalSellAmount = externalTradingResource.Amount * exportRatio;

                foreach (TradeRegion tradeRegion in TradeRegions)
                {
                    double tradeRegionRatio = tradeRegion.GetTransportAmount(resourceType);
                    if (tradeRegionRatio <= 0)
                    {
                        continue;
                    }

                    if (externalTradingResource.AffordTransport(tradeRegionRatio, externalTradingResource.Amount))
                    {
                        ExternatlTradingResourcesInTransit.TradingResourceList.Add(externalTradingResource.SplitAmountExternal(totalSellAmount * tradeRegionRatio,
                                                                                                                               tradeRegion.GetExternalMarket(), transportTimeOutOfRigion));
                    }
                }
            }
        }