TMap<FFlareResourceDescription*, WorldHelper::FlareResourceStats> SectorHelper::ComputeSectorResourceStats(UFlareSimulatedSector* Sector, bool IncludeStorage)
{
TMap<FFlareResourceDescription*, WorldHelper::FlareResourceStats> WorldStats;
// Init
for(int32 ResourceIndex = 0; ResourceIndex < Sector->GetGame()->GetResourceCatalog()->Resources.Num(); ResourceIndex++)
{
FFlareResourceDescription* Resource = &Sector->GetGame()->GetResourceCatalog()->Resources[ResourceIndex]->Data;
WorldHelper::FlareResourceStats ResourceStats;
ResourceStats.Production = 0;
ResourceStats.Consumption = 0;
ResourceStats.Balance = 0;
ResourceStats.Stock = 0;
ResourceStats.Capacity = 0;
WorldStats.Add(Resource, ResourceStats);
}
for (int SpacecraftIndex = 0; SpacecraftIndex < Sector->GetSectorSpacecrafts().Num(); SpacecraftIndex++)
{
UFlareSimulatedSpacecraft* Spacecraft = Sector->GetSectorSpacecrafts()[SpacecraftIndex];
if(!IncludeStorage && Spacecraft->HasCapability(EFlareSpacecraftCapability::Storage))
{
continue;
}
// Stock
TArray<FFlareCargo>& CargoBaySlots = Spacecraft->GetActiveCargoBay()->GetSlots();
for (int CargoIndex = 0; CargoIndex < CargoBaySlots.Num(); CargoIndex++)
{
FFlareCargo& Cargo = CargoBaySlots[CargoIndex];
if (!Cargo.Resource)
{
continue;
}
WorldHelper::FlareResourceStats *ResourceStats = &WorldStats[Cargo.Resource];
FFlareResourceUsage Usage = Spacecraft->GetResourceUseType(Cargo.Resource);
if(Usage.HasUsage(EFlareResourcePriceContext::FactoryInput) || Usage.HasUsage(EFlareResourcePriceContext::ConsumerConsumption) || Usage.HasUsage(EFlareResourcePriceContext::MaintenanceConsumption) || Usage.HasUsage(EFlareResourcePriceContext::HubInput))
{
ResourceStats->Capacity += Spacecraft->GetActiveCargoBay()->GetSlotCapacity() - Cargo.Quantity;
}
if(Usage.HasUsage(EFlareResourcePriceContext::FactoryOutput) || Usage.HasUsage(EFlareResourcePriceContext::MaintenanceConsumption) || Usage.HasUsage(EFlareResourcePriceContext::HubOutput))
{
ResourceStats->Stock += Cargo.Quantity;
}
}
for (int32 FactoryIndex = 0; FactoryIndex < Spacecraft->GetFactories().Num(); FactoryIndex++)
{
UFlareFactory* Factory = Spacecraft->GetFactories()[FactoryIndex];
if(Factory->IsShipyard() && !Factory->IsActive())
{
const FFlareProductionData* ProductionData = Spacecraft->GetNextOrderShipProductionData(Factory->IsLargeShipyard()? EFlarePartSize::L : EFlarePartSize::S);
if (ProductionData)
{
for(const FFlareFactoryResource& FactoryResource : ProductionData->InputResources)
{
const FFlareResourceDescription* Resource = &FactoryResource.Resource->Data;
WorldHelper::FlareResourceStats *ResourceStats = &WorldStats[Resource];
int64 ProductionDuration = ProductionData->ProductionTime;
float Flow = 0;
if (ProductionDuration == 0)
{
Flow = 1;
}
else
{
Flow = (float) FactoryResource.Quantity / float(ProductionDuration);
}
ResourceStats->Consumption += Flow;
}
}
continue;
}
if ((!Factory->IsActive() || !Factory->IsNeedProduction()))
{
// No resources needed
continue;
}
// Input flow
for (int32 ResourceIndex = 0; ResourceIndex < Factory->GetInputResourcesCount(); ResourceIndex++)
{
FFlareResourceDescription* Resource = Factory->GetInputResource(ResourceIndex);
WorldHelper::FlareResourceStats *ResourceStats = &WorldStats[Resource];
int64 ProductionDuration = Factory->GetProductionDuration();
float Flow = 0;
if (ProductionDuration == 0)
{
Flow = 1;
}
else
{
Flow = (float) Factory->GetInputResourceQuantity(ResourceIndex) / float(ProductionDuration);
}
ResourceStats->Consumption += Flow;
}
// Ouput flow
for (int32 ResourceIndex = 0; ResourceIndex < Factory->GetOutputResourcesCount(); ResourceIndex++)
{
FFlareResourceDescription* Resource = Factory->GetOutputResource(ResourceIndex);
WorldHelper::FlareResourceStats *ResourceStats = &WorldStats[Resource];
int64 ProductionDuration = Factory->GetProductionDuration();
if (ProductionDuration == 0)
{
ProductionDuration = 10;
}
float Flow = (float) Factory->GetOutputResourceQuantity(ResourceIndex) / float(ProductionDuration);
ResourceStats->Production+= Flow;
}
}
}
// FS
FFlareResourceDescription* FleetSupply = Sector->GetGame()->GetScenarioTools()->FleetSupply;
WorldHelper::FlareResourceStats *FSResourceStats = &WorldStats[FleetSupply];
FFlareFloatBuffer* Stats = &Sector->GetData()->FleetSupplyConsumptionStats;
float MeanConsumption = Stats->GetMean(0, Stats->MaxSize-1);
FSResourceStats->Consumption += MeanConsumption;
FSResourceStats->Capacity += Stats->GetValue(0);
// Customer flow
for (int32 ResourceIndex = 0; ResourceIndex < Sector->GetGame()->GetResourceCatalog()->ConsumerResources.Num(); ResourceIndex++)
{
FFlareResourceDescription* Resource = &Sector->GetGame()->GetResourceCatalog()->ConsumerResources[ResourceIndex]->Data;
WorldHelper::FlareResourceStats *ResourceStats = &WorldStats[Resource];
ResourceStats->Consumption += Sector->GetPeople()->GetRessourceConsumption(Resource, false);
}
// Balance
for(int32 ResourceIndex = 0; ResourceIndex < Sector->GetGame()->GetResourceCatalog()->Resources.Num(); ResourceIndex++)
{
FFlareResourceDescription* Resource = &Sector->GetGame()->GetResourceCatalog()->Resources[ResourceIndex]->Data;
WorldHelper::FlareResourceStats *ResourceStats = &WorldStats[Resource];
ResourceStats->Balance = ResourceStats->Production - ResourceStats->Consumption;
/*FLOGV("World stats for %s: Production=%f Consumption=%f Balance=%f Stock=%d",
*Resource->Name.ToString(),
ResourceStats->Production,
ResourceStats->Consumption,
ResourceStats->Balance,
ResourceStats->Stock);*/
}
return WorldStats;
}
UFlareSimulatedSpacecraft* SectorHelper::FindTradeStation(FlareTradeRequest Request)
{
//FLOGV("FindTradeStation of %s for %s (%d)", *Request.Resource->Acronym.ToString(), *Request.Client->GetImmatriculation().ToString(), (Request.Operation + 0));
if(!Request.Client || !Request.Client->GetCurrentSector())
{
FLOG("Invalid find trade query");
return NULL;
}
UFlareCompany* ClientCompany = Request.AllowUseNoTradeForMe ? Request.Client->GetCompany() : nullptr;
UFlareSimulatedSector* Sector = Request.Client->GetCurrentSector();
TArray<UFlareSimulatedSpacecraft*>& SectorStations = Sector->GetSectorStations();
float UnloadQuantityScoreMultiplier = 0;
float LoadQuantityScoreMultiplier = 0;
float SellQuantityScoreMultiplier = 0;
float BuyQuantityScoreMultiplier = 0;
float FullRatioBonus = 0;
float EmptyRatioBonus = 0;
bool NeedInput = false;
bool NeedOutput = false;
switch(Request.Operation)
{
case EFlareTradeRouteOperation::Buy:
BuyQuantityScoreMultiplier = 10.f;
FullRatioBonus = 0.1;
NeedOutput = true;
break;
case EFlareTradeRouteOperation::Sell:
SellQuantityScoreMultiplier = 10.f;
EmptyRatioBonus = 0.1;
NeedInput = true;
break;
case EFlareTradeRouteOperation::Load:
LoadQuantityScoreMultiplier = 10.f;
FullRatioBonus = 0.1;
NeedOutput = true;
break;
case EFlareTradeRouteOperation::Unload:
UnloadQuantityScoreMultiplier = 10.f;
EmptyRatioBonus = 0.1;
NeedInput = true;
break;
case EFlareTradeRouteOperation::LoadOrBuy:
LoadQuantityScoreMultiplier = 10.f;
BuyQuantityScoreMultiplier = 1.f;
FullRatioBonus = 0.1;
NeedOutput = true;
break;
case EFlareTradeRouteOperation::UnloadOrSell:
UnloadQuantityScoreMultiplier = 10.f;
SellQuantityScoreMultiplier = 1.f;
EmptyRatioBonus = 0.1;
NeedInput = true;
break;
}
float BestScore = 0;
UFlareSimulatedSpacecraft* BestStation = NULL;
uint32 AvailableQuantity = Request.Client->GetActiveCargoBay()->GetResourceQuantity(Request.Resource, ClientCompany);
uint32 FreeSpace = Request.Client->GetActiveCargoBay()->GetFreeSpaceForResource(Request.Resource, ClientCompany);
for (int32 StationIndex = 0; StationIndex < SectorStations.Num(); StationIndex++)
{
UFlareSimulatedSpacecraft* Station = SectorStations[StationIndex];
//FLOGV(" Check trade for %s", *Station->GetImmatriculation().ToString());
FText Unused;
if(!Request.Client->CanTradeWith(Station, Unused))
{
//FLOG(" cannot trade with");
continue;
}
if(!Request.AllowStorage && Station->HasCapability(EFlareSpacecraftCapability::Storage))
{
continue;
}
FFlareResourceUsage StationResourceUsage = Station->GetResourceUseType(Request.Resource);
if(NeedOutput && (!StationResourceUsage.HasUsage(EFlareResourcePriceContext::FactoryOutput) &&
!StationResourceUsage.HasUsage(EFlareResourcePriceContext::ConsumerConsumption) &&
!StationResourceUsage.HasUsage(EFlareResourcePriceContext::HubOutput)))
{
//FLOG(" need output but dont provide it");
continue;
}
if(NeedInput && (!StationResourceUsage.HasUsage(EFlareResourcePriceContext::FactoryInput) &&
!StationResourceUsage.HasUsage(EFlareResourcePriceContext::ConsumerConsumption) &&
!StationResourceUsage.HasUsage(EFlareResourcePriceContext::MaintenanceConsumption) &&
!StationResourceUsage.HasUsage(EFlareResourcePriceContext::HubInput)))
{
//FLOG(" need input but dont provide it");
continue;
}
int32 StationFreeSpace = Station->GetActiveCargoBay()->GetFreeSpaceForResource(Request.Resource, ClientCompany);
int32 StationResourceQuantity = Station->GetActiveCargoBay()->GetResourceQuantity(Request.Resource, ClientCompany);
if (!Station->IsUnderConstruction() && Station->IsComplex() && !Request.AllowFullStock)
{
if(Station->GetActiveCargoBay()->WantBuy(Request.Resource, ClientCompany) && Station->GetActiveCargoBay()->WantSell(Request.Resource, ClientCompany))
{
int32 TotalCapacity = Station->GetActiveCargoBay()->GetTotalCapacityForResource(Request.Resource, ClientCompany);
StationFreeSpace = FMath::Max(0, StationFreeSpace - TotalCapacity / 2);
StationResourceQuantity = FMath::Max(0, StationResourceQuantity - TotalCapacity / 2);
}
}
if (StationFreeSpace == 0 && StationResourceQuantity == 0)
{
//FLOG(" need quantity or resource");
continue;
}
float Score = 0;
float FullRatio = (float) StationResourceQuantity / (float) (StationResourceQuantity + StationFreeSpace);
float EmptyRatio = 1 - FullRatio;
uint32 UnloadMaxQuantity = 0;
uint32 LoadMaxQuantity = 0;
if(!Station->IsUnderConstruction())
{
// Check cargo limit
if(NeedOutput && Request.CargoLimit != -1 && FullRatio < Request.CargoLimit / Station->GetLevel())
{
continue;
}
if(NeedInput && Request.CargoLimit != -1 && FullRatio > (1.f - (1.f - Request.CargoLimit) / Station->GetLevel()))
{
continue;
}
}
else if (Station->HasCapability(EFlareSpacecraftCapability::Storage))
{
continue;
}
if(Station->GetActiveCargoBay()->WantBuy(Request.Resource, ClientCompany))
{
UnloadMaxQuantity = StationFreeSpace;
UnloadMaxQuantity = FMath::Min(UnloadMaxQuantity , AvailableQuantity);
}
if(Station->GetActiveCargoBay()->WantSell(Request.Resource, ClientCompany))
{
LoadMaxQuantity = StationResourceQuantity;
LoadMaxQuantity = FMath::Min(LoadMaxQuantity , FreeSpace);
}
if(Station->GetCompany() == Request.Client->GetCompany())
{
Score += UnloadMaxQuantity * UnloadQuantityScoreMultiplier;
Score += LoadMaxQuantity * LoadQuantityScoreMultiplier;
}
else
{
FFlareResourceUsage ResourceUsage = Station->GetResourceUseType(Request.Resource);
int32 ResourcePrice = 0;
if(NeedInput)
{
ResourcePrice = Sector->GetTransfertResourcePrice(NULL, Station, Request.Resource);
}
else
{
ResourcePrice = Sector->GetTransfertResourcePrice(Station, NULL, Request.Resource);
}
uint32 MaxBuyableQuantity = Request.Client->GetCompany()->GetMoney() / SectorHelper::GetBuyResourcePrice(Sector, Request.Resource, ResourceUsage);
LoadMaxQuantity = FMath::Min(LoadMaxQuantity , MaxBuyableQuantity);
uint32 MaxSellableQuantity = Station->GetCompany()->GetMoney() / SectorHelper::GetSellResourcePrice(Sector, Request.Resource, ResourceUsage);
UnloadMaxQuantity = FMath::Min(UnloadMaxQuantity , MaxSellableQuantity);
Score += UnloadMaxQuantity * SellQuantityScoreMultiplier;
Score += LoadMaxQuantity * BuyQuantityScoreMultiplier;
}
Score *= 1 + (FullRatio * FullRatioBonus) + (EmptyRatio * EmptyRatioBonus);
if(Station->IsUnderConstruction())
{
Score *= 10000;
/*FLOGV("Station %s is under construction. Score %f, BestScore %f",
*Station->GetImmatriculation().ToString(),
Score,
BestScore)*/
}
else if(Station->HasCapability(EFlareSpacecraftCapability::Storage))
{
Score *= 0.01;
}
if(Score > 0 && Score > BestScore)
{
BestScore = Score;
BestStation = Station;
}
}
//FLOGV("FindTradeStation result %p", BestStation);
return BestStation;
}
