public void RefreshLines()
{
if (Singleton <BuildingManager> .exists)
{
int count = 0;
var buildingList = SVMBuildingUtils.getAllBuildingsFromCity(Singleton <T> .instance.GetSSD());
SVMUtils.doLog("{0} buildingList = [{1}] (s={2})", GetType(), string.Join(",", buildingList.Select(x => x.ToString()).ToArray()), buildingList.Count);
foreach (ushort buildingID in buildingList)
{
Building b = Singleton <BuildingManager> .instance.m_buildings.m_buffer[buildingID];
var ext = SVMBuildingAIOverrideUtils.getBuildingOverrideExtension(b.Info);
var maxCountField = ext.GetVehicleMaxCountField(SVMSysDef <T> .instance.GetSSD().vehicleType);
var maxVehicle = SVMUtils.GetPrivateField <int>(b.Info.GetAI(), maxCountField);
if (maxCountField == null || maxVehicle > 0)
{
AddToList(buildingID, ref count);
}
}
RemoveExtraLines(count);
SVMUtils.doLog("{0} final count = {1}", GetType(), count);
m_LinesUpdated = true;
}
}
private void updateBuildingEditShortcutButton(UIPanel parent)
{
if (parent != null)
{
UIButton buildingEditShortcut = parent.Find <UIButton>("SVMBuildingShortcut");
if (!buildingEditShortcut)
{
buildingEditShortcut = initBuildingEditOnWorldInfoPanel(parent);
}
var prop = typeof(WorldInfoPanel).GetField("m_InstanceID", System.Reflection.BindingFlags.NonPublic
| System.Reflection.BindingFlags.Instance);
ushort buildingId = ((InstanceID)(prop.GetValue(parent.gameObject.GetComponent <WorldInfoPanel>()))).Building;
var ssds = ServiceSystemDefinition.from(Singleton <BuildingManager> .instance.m_buildings.m_buffer[buildingId].Info);
byte count = 0;
foreach (var ssd in ssds)
{
var maxCount = SVMBuildingUtils.GetMaxVehiclesBuilding(buildingId, ssd.vehicleType, ssd.level);
if (maxCount > 0)
{
count++;
break;
}
}
buildingEditShortcut.isVisible = count > 0;
}
}
public void RefreshData()
{
if (Singleton <BuildingManager> .exists && transform.parent.gameObject.GetComponent <UIComponent>().isVisible)
{
GetComponent <UIComponent>().isVisible = true;
Building b = Singleton <BuildingManager> .instance.m_buildings.m_buffer[this.m_buildingID];
this.m_buildingName.text = Singleton <BuildingManager> .instance.GetBuildingName(this.m_buildingID, default(InstanceID));
byte districtID = Singleton <DistrictManager> .instance.GetDistrict(b.m_position);
string districtName = districtID == 0 ? Locale.Get("SVM_DISTRICT_NONE") : Singleton <DistrictManager> .instance.GetDistrictName(districtID);
this.m_districtName.text = districtName;
int count = 0;
int cargo = 0;
int capacity = 0;
int inbound = 0;
int outbound = 0;
var extstr = SVMBuildingAIOverrideUtils.getBuildingOverrideExtensionStrict(b.Info);
var defLevel = b.Info.m_class.m_level;
SVMBuildingUtils.CalculateOwnVehicles(buildingId, ref b, extstr.GetManagedReasons(b.Info).Where(x => (x.Value.vehicleLevel ?? defLevel) == sysDef.level).Select(x => x.Key), ref count, ref cargo, ref capacity, ref inbound, ref outbound);
int maxCount = SVMBuildingUtils.GetMaxVehiclesBuilding(buildingId, sysDef.vehicleType, sysDef.level);
m_totalVehicles.prefix = count.ToString();
m_totalVehicles.suffix = maxCount > 0x3FFF ? "∞" : maxCount.ToString();
if (Singleton <T> .instance.GetSSD().outsideConnection)
{
float angle = Vector2.zero.GetAngleToPoint(VectorUtils.XZ(b.m_position));
m_directionLabel.prefix = $"{angle:n1}°";
m_directionLabel.text = " - ";
m_directionLabel.suffix = CardinalPoint.getCardinalPoint(angle).ToString();
}
}
}
public void Update()
{
if (!this.m_buildingInfoPanel.isVisible)
{
return;
}
Building b = Singleton <BuildingManager> .instance.m_buildings.m_buffer[m_buildingIdSelecionado.Building];
if (!(b.Info.GetAI() is BuildingAI basicAI))
{
closeBuildingInfo(null, null);
return;
}
var ssds = ServiceSystemDefinition.from(b.Info);
List <string> textVehicles = new List <string>();
foreach (var ssd in ssds)
{
int count = 0;
int cargo = 0;
int capacity = 0;
int inbound = 0;
int outbound = 0;
var ext = SVMBuildingAIOverrideUtils.getBuildingOverrideExtension(b.Info);
SVMBuildingUtils.CalculateOwnVehicles(m_buildingIdSelecionado.Building, ref b, ext.GetManagedReasons(b.Info).Keys, ref count, ref cargo, ref capacity, ref inbound, ref outbound);
var maxField = ext.GetVehicleMaxCountField(ssd.vehicleType);
int maxVehicles = (SVMUtils.GetPrivateField <int>(b.Info.GetAI(), maxField) * SVMBuildingUtils.GetProductionRate(ref b) / 100);
string maxVehiclesStr = maxField == null || maxVehicles > 0x3FFF ? "∞" : maxVehicles.ToString();
textVehicles.Add($"{count}/{maxVehiclesStr} ({Locale.Get("SVM_VEHICLE_TYPE", ssd.vehicleType.ToString())})");
}
vehiclesInUseLabel.text = string.Join(" | ", textVehicles.ToArray());
upkeepCost.text = LocaleFormatter.FormatUpkeep(basicAI.GetResourceRate(m_buildingIdSelecionado.Building, ref Singleton <BuildingManager> .instance.m_buildings.m_buffer[(int)m_buildingIdSelecionado.Building], EconomyManager.Resource.Maintenance), false);
uint num = Singleton <BuildingManager> .instance.m_buildings.m_buffer[m_buildingIdSelecionado.Building].m_citizenUnits;
int num2 = 0;
int num3 = 0;
int unskill = 0;
int oneSchool = 0;
int twoSchool = 0;
int threeSchool = 0;
CitizenManager instance = Singleton <CitizenManager> .instance;
while (num != 0u)
{
uint nextUnit = instance.m_units.m_buffer[(int)((UIntPtr)num)].m_nextUnit;
if ((ushort)(instance.m_units.m_buffer[(int)((UIntPtr)num)].m_flags & CitizenUnit.Flags.Work) != 0)
{
for (int i = 0; i < 5; i++)
{
uint citizen = instance.m_units.m_buffer[(int)((UIntPtr)num)].GetCitizen(i);
if (citizen != 0u && !instance.m_citizens.m_buffer[(int)((UIntPtr)citizen)].Dead && (instance.m_citizens.m_buffer[(int)((UIntPtr)citizen)].m_flags & Citizen.Flags.MovingIn) == Citizen.Flags.None)
{
num3++;
switch (instance.m_citizens.m_buffer[(int)((UIntPtr)citizen)].EducationLevel)
{
case Citizen.Education.Uneducated:
unskill++;
break;
case Citizen.Education.OneSchool:
oneSchool++;
break;
case Citizen.Education.TwoSchools:
twoSchool++;
break;
case Citizen.Education.ThreeSchools:
threeSchool++;
break;
}
}
}
}
num = nextUnit;
if (++num2 > 524288)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
workerChart.SetValues(new int[] { unskill, oneSchool, twoSchool, threeSchool }, new int[] { SVMUtils.GetPrivateField <int>(basicAI, "m_workPlaceCount0"), SVMUtils.GetPrivateField <int>(basicAI, "m_workPlaceCount1"), SVMUtils.GetPrivateField <int>(basicAI, "m_workPlaceCount2"), SVMUtils.GetPrivateField <int>(basicAI, "m_workPlaceCount3") });
}
protected virtual bool ProcessOffer(ushort buildingID, ref Building data, TransferManager.TransferReason material, TransferManager.TransferOffer offer, TransferManager.TransferReason trTarget, StartTransferCallStructure tup, U instance)
{
if (material == trTarget)
{
ServiceSystemDefinition def = ServiceSystemDefinition.from(instance.m_info, tup.vehicleType);
if (def == null)
{
SVMUtils.doLog("SSD Não definido para: {0} {1} {2} {3}", instance.m_info.m_class.m_service, instance.m_info.m_class.m_subService, tup.vehicleLevel ?? instance.m_info.m_class.m_level, tup.vehicleType);
return(false);
}
#region District Check
var ext = def.GetTransportExtension();
if (ext.GetAllowDistrictServiceRestrictions())
{
var buildingDistrict = DistrictManager.instance.GetDistrict(data.m_position);
var offerDistrict = DistrictManager.instance.GetDistrict(offer.Position);
if (buildingDistrict != offerDistrict)
{
if (ServiceVehiclesManagerMod.debugMode)
{
SVMUtils.doLog($"Building serving different district: building {data.Info} ({buildingID} - districtId {buildingDistrict} {DistrictManager.instance.GetDistrictName(buildingDistrict)}) => offerDistrict: {offerDistrict} {DistrictManager.instance.GetDistrictName(offerDistrict)}");
}
if (!ext.GetAllowOutsidersEffective(offerDistrict))
{
var districtBuildings = SVMBuildingUtils.getAllBuildingsFromCity(def, offerDistrict, true, true);
if (ServiceVehiclesManagerMod.debugMode)
{
SVMUtils.doLog($"Offer doesn't allow outsiders. Available buildings found: {districtBuildings}");
}
if (districtBuildings.Count > 0)
{
var newBuildingId = districtBuildings[Singleton <SimulationManager> .instance.m_randomizer.Int32((uint)districtBuildings.Count)];
return(ProcessOffer(newBuildingId, ref BuildingManager.instance.m_buildings.m_buffer[newBuildingId], material, offer, trTarget, tup, instance));
}
if (ServiceVehiclesManagerMod.debugMode)
{
SVMUtils.doLog($"Ignoring because no buildings can handle it");
}
}
if (!ext.GetAllowGoOutsideEffective(buildingDistrict))
{
var districtBuildings = SVMBuildingUtils.getAllBuildingsFromCity(def, offerDistrict, false, true);
if (ServiceVehiclesManagerMod.debugMode)
{
SVMUtils.doLog($"Building district doesn't allow go out. Available buildings found: {districtBuildings}");
}
if (districtBuildings.Count > 0)
{
var newBuildingId = districtBuildings[Singleton <SimulationManager> .instance.m_randomizer.Int32((uint)districtBuildings.Count)];
return(ProcessOffer(newBuildingId, ref BuildingManager.instance.m_buildings.m_buffer[newBuildingId], material, offer, trTarget, tup, instance));
}
if (ServiceVehiclesManagerMod.debugMode)
{
SVMUtils.doLog($"Ignoring because no buildings can handle it (2)");
}
}
}
}
#endregion
SVMUtils.doLog("[{1}] SSD = {0}", def, material);
VehicleInfo randomVehicleInfo = ServiceSystemDefinition.availableDefinitions[def].GetAModel(buildingID);
SVMUtils.doLog("[{1}] Veh = {0}", randomVehicleInfo?.ToString() ?? "<NULL>", material);
if (randomVehicleInfo != null)
{
Array16 <Vehicle> vehicles = Singleton <VehicleManager> .instance.m_vehicles;
instance.CalculateSpawnPosition(buildingID, ref data, ref Singleton <SimulationManager> .instance.m_randomizer, randomVehicleInfo, out Vector3 position, out Vector3 vector2);
if (Singleton <VehicleManager> .instance.CreateVehicle(out ushort num, ref Singleton <SimulationManager> .instance.m_randomizer, randomVehicleInfo, position, material, tup.tramsferToSource, tup.transferToTarget))
{
randomVehicleInfo.m_vehicleAI.SetSource(num, ref vehicles.m_buffer[(int)num], buildingID);
randomVehicleInfo.m_vehicleAI.StartTransfer(num, ref vehicles.m_buffer[(int)num], material, offer);
return(true);
}
}
}
return(false);
}
