public void SetState()
{
_resourceType = _resourceObject.ResourceType;
switch (_resourceType)
{
case ResourceTypes.ResourceType._bearFur:
_playerResources.BearFur += _resourceObject.Value;
break;
case ResourceTypes.ResourceType._birdFur:
_playerResources.BirdFur += _resourceObject.Value;
break;
case ResourceTypes.ResourceType._duckFur:
_playerResources.DuckFur += _resourceObject.Value;
break;
case ResourceTypes.ResourceType._wood:
_playerResources.Wood += _resourceObject.Value;
break;
case ResourceTypes.ResourceType._rope:
_playerResources.Rope += _resourceObject.Value;
break;
case ResourceTypes.ResourceType._bone:
_playerResources.Bone += _resourceObject.Value;
break;
}
}
public Population(int Amount, ResourceTypes.ResourceType producingType, double efficensy)
{
SetPopLevel(Amount);
Money = Amount * startMoney;
ProducingType = producingType;
Efficensy = efficensy;
}
public double GetBestCost(ResourceTypes.ResourceType resourceType, out TradeRegion bestRegion, out TradeRegion worstRegion)
{
double bestCost = 0;
double worstCost = double.MaxValue;
bestRegion = null;
worstRegion = null;
double regionalTransportCost = Ownregion.GetTransportCost();
foreach (TradeRegion tradeRegion in TradeRegions)
{
double externalTransportCost = tradeRegion.GetTransportCost();
double totalTransportCost = (regionalTransportCost + externalTransportCost) / 2;
double resourceCost = tradeRegion.GetResorceCost(resourceType);
double salesCost = resourceCost - totalTransportCost;
if (salesCost > bestCost)
{
bestCost = salesCost;
bestRegion = tradeRegion;
}
if (tradeRegion.GetTransportAmount(resourceType) > 0 && salesCost < worstCost)
{
worstCost = salesCost;
worstRegion = tradeRegion;
}
}
return(bestCost);
}
public double GetAmount(ResourceTypes.ResourceType resourceType)
{
if (ResoucreExist(resourceType) == false)
{
return(0);
}
return(GetResource(resourceType).Amount);
}
private void ComputeResourceRatio(ResourceTypes.ResourceType resourceType)
{
var supplyAmount = GetSupply(resourceType).TradingResourceList.Sum(su => su.Amount);
supplyAmount += GetExternalSupply(resourceType).TradingResourceList.Sum(su => su.Amount);
SupplySum[(int)resourceType].Amount = supplyAmount;
double demandAmount = Demand.GetAmount(resourceType);
GetSupplyToDemandRatio(resourceType).SetSupplyToDemandRatio(GetSupplyToDemandRatio(resourceType).ComputeSupplyToDemandRatio(demandAmount, supplyAmount));
}
public void BuyAmount(double ratio, double price, ResourceTypes.ResourceType resourceType)
{
double buyAmount = demand.GetDemand(resourceType) * ratio;
if (buyAmount == 0)
{
return;
}
Stock.Adjust(new PrimitivResource(resourceType, buyAmount));
Money -= buyAmount * price;
}
public Resource GetResource(ResourceTypes.ResourceType producingType)
{
Resource r = resources.Find(r => r.ResourceType.Equals(producingType));
if (r != null)
{
return(r);
}
r = new Resource(producingType, 0);
resources.Add(r);
return(r);
}
public void Update(Population population, ResourceTypes.ResourceType producingType, double amount)
{
TradingResource tradingResource = TradingResourceList.Find(tr => tr.ResourceType == producingType && tr.Owner.ID == population.ID);
if (tradingResource != null)
{
tradingResource.Amount = amount;
}
else
{
TradingResourceList.Add(new TradingResource(population, producingType, amount));
}
}
double AutoTrade(ResourceTypes.ResourceType resourceType)
{
var supply = GetSupply(resourceType);
var externalSupply = GetExternalSupply(resourceType);
var resoucreData = GetSupplyToDemandRatio(resourceType);
double price = resoucreData.ResourcesPrice;
double demmand = Demand.GetAmount(resourceType);
double initialDemand = demmand;
foreach (TradingResource tr in supply.TradingResourceList)
{
if (demmand < (initialDemand * 0.01))
{
break;
}
else if (tr.Amount < (initialDemand * 0.01))
{
demmand -= tr.Amount;
SupplySum[(int)resourceType].Amount -= tr.Amount;
tr.Trade(1, price);
}
else
{
continue;
}
}
foreach (TradingResource tr in externalSupply.TradingResourceList)
{
if (demmand < (initialDemand * 0.01))
{
break;
}
else if (tr.Amount < (initialDemand * 0.01))
{
demmand -= tr.Amount;
SupplySum[(int)resourceType].Amount -= tr.Amount;
tr.Trade(1, price);
}
else
{
continue;
}
}
supply.TradingResourceList.RemoveAll(su => su.Empty());
externalSupply.TradingResourceList.RemoveAll(su => su.Empty());
return(demmand);
}
public void SetCount(int count)
{
_itemCount = count;
_countText.text = _itemCount.ToString();
if (_itemCount == 0)
{
_hasItem = false;
_item.sprite = null;
Color c = _item.color;
c.a = 0;
_item.color = c;
_type = ResourceTypes.ResourceType._none;
_countText.text = "";
}
}
public void DecreseTrade(ResourceTypes.ResourceType resourceType)
{
if (transportAmount.ResoucreExist(resourceType) == false)
{
return;
}
double resourceAmount = transportAmount.GetResource(resourceType).Amount;
if (resourceAmount == 0)
{
return;
}
double newAmount = Math.Max(resourceAmount - tradeChange, 0);
transportAmount.SetResource(resourceType, newAmount);
}
public void IncreaseTradeWith(ResourceTypes.ResourceType resourceType, TradeRegion destination, TradeRegion worstTradeRegion)
{
foreach (TradeRegion tradeRegion in TradeRegions)
{
if (destination.ID == tradeRegion.ID)
{
if (worstTradeRegion == null || worstTradeRegion.ID == destination.ID)
{
tradeRegion.MaxTrade(resourceType);
continue;
}
tradeRegion.IncreaseTrade(resourceType);
}
else if (worstTradeRegion != null && worstTradeRegion.ID == tradeRegion.ID)
{
worstTradeRegion.DecreseTrade(resourceType);
}
}
}
public void SetState()
{
_resourceType = _resourceObject.ResourceType;
switch (_resourceType)
{
case ResourceTypes.ResourceType._fur:
_playerResources.Fur += _resourceObject.Value;
break;
case ResourceTypes.ResourceType._meat:
_playerResources.Meat += _resourceObject.Value;
break;
case ResourceTypes.ResourceType._stone:
_playerResources.Stones += _resourceObject.Value;
break;
case ResourceTypes.ResourceType._wood:
_playerResources.Wood += _resourceObject.Value;
break;
}
}
private void ComputeWhatToBuy(InternalMarket market, Population population, Dictionary <ResourceTypes.ResourceType, double> lifePriceRatioMap)
{
double money = population.Money;
IEnumerable <KeyValuePair <ResourceTypes.ResourceType, double> > orderedLifePriceRatio = lifePriceRatioMap.OrderByDescending(ratio => ratio.Value);
foreach (KeyValuePair <ResourceTypes.ResourceType, double> resoucreTypeRatio in orderedLifePriceRatio)
{
ResourceTypes.ResourceType resourceType = resoucreTypeRatio.Key;
double price = market.GetPrice(resourceType);
double buyAmount = Math.Round(Math.Min(money / price, population.GetIntegerPopLevel() * GetAmountNeeded(resourceType)), 3, MidpointRounding.ToZero);
if (buyAmount < minemumDemand)
{
continue;
}
ResourceDemand[(int)resourceType].Amount = buyAmount;
money -= buyAmount * price;
if (money <= 0)
{
break;
}
}
}
public void IncreaseTrade(ResourceTypes.ResourceType resourceType)
{
double newAmount = Math.Min(transportAmount.GetResource(resourceType).Amount + tradeChange, maxExport);
transportAmount.SetResource(resourceType, newAmount);
}
public double GetDemand(ResourceTypes.ResourceType resourceType)
{
return(ResourceDemand[(int)resourceType].Amount);
}
public void SetDemand(ResourceTypes.ResourceType resourceType, double amountNeeded, double lifeValue)
{
AmountNeeded[(int)resourceType] = amountNeeded;
LifeValues[(int)resourceType] = lifeValue;
}
public double GetLifeValueAdjusted(ResourceTypes.ResourceType resourceType)
{
return(LifeValues[(int)resourceType]);
}
public double GetAmountNeeded(ResourceTypes.ResourceType resourceType)
{
return(Convert.ToDouble(AmountNeeded[(int)resourceType]));
}
public TradingResource(Population Owner, ResourceTypes.ResourceType resourceType, double Amount)
{
ResourceType = resourceType;
this.Amount = Amount;
this.Owner = Owner;
}
public ExternalTradingResource(Population Owner, ResourceTypes.ResourceType resourceType, double Amount) :
base(Owner, resourceType, Amount)
{
}
public PrimitivResource(ResourceTypes.ResourceType ResourceType, double Amount)
{
this.ResourceType = ResourceType;
this.Amount = Amount;
}
public Artisans(int Amount, ResourceTypes.ResourceType producingType) : base(Amount, producingType, 1)
{
}
public TradingResources(ResourceTypes.ResourceType ResourceType)
{
this.ResourceType = ResourceType;
}
public double GetResorceCost(ResourceTypes.ResourceType resource)
{
return(InternalMarket.GetPrice(resource));
}
public double GetTransportAmount(ResourceTypes.ResourceType resourceType)
{
return(transportAmount.GetAmount(resourceType));
}
public TradingResource Get(ResourceTypes.ResourceType producingType)
{
return(TradingResourceList.Find(tr => tr.ResourceType == producingType));
}
public void MaxTrade(ResourceTypes.ResourceType resourceType)
{
transportAmount.SetResource(resourceType, 1);
}
public Farmer(int Amount, ResourceTypes.ResourceType producingType, double efficensy) : base(Amount, producingType, efficensy)
{
}
public double GetResorceCost(ResourceTypes.ResourceType resourceType)
{
return(Region.GetResorceCost(resourceType));
}
