/// <summary>
/// Logs the transfer offers.
/// </summary>
/// <param name="direction">The direction.</param>
/// <param name="offers">The offers.</param>
/// <param name="count">The count.</param>
/// <param name="amount">The amount.</param>
/// <param name="buildings">The buildings.</param>
/// <param name="material">The material.</param>
private static void DebugListLog(
string direction,
TransferManager.TransferOffer[] offers,
ushort[] count,
int[] amount,
Building[] buildings,
TransferManager.TransferReason material)
{
for (int priority = 0; priority < 8; priority++)
{
int index = ((int)material * 8) + priority;
for (int i = 0; i < count[index]; i++)
{
Log.InfoList info = new Log.InfoList();
TransferManager.TransferOffer offer = offers[(index * 256) + i];
info.Add("Active", offer.Active);
info.Add("Amount", offer.Amount);
info.Add("Priority", offer.Priority);
info.Add("Vehicle", offer.Vehicle, VehicleHelper.GetVehicleName(offer.Vehicle));
info.Add("Citizen", offer.Citizen, CitizenHelper.GetCitizenName(offer.Citizen));
info.Add("TransportLine", offer.TransportLine, TransportLineHelper.GetLineName(offer.TransportLine));
info.Add("Building", offer.Building, BuildingHelper.GetBuildingName(offer.Building), BuildingHelper.GetDistrictName(offer.Building));
if (buildings != null && offer.Building > 0 && buildings[offer.Building].Info != null && (buildings[offer.Building].m_flags & Building.Flags.Created) == Building.Flags.Created)
{
info.Add("Garbage", buildings[offer.Building].m_garbageBuffer);
info.Add("Dead", buildings[offer.Building].m_deathProblemTimer);
}
Log.DevDebug(typeof(TransferManagerHelper), "DebugListLog", direction, material, info);
}
}
}
/// <summary>
/// Adds the service building information to debug information message.
/// </summary>
/// <param name="info">The information.</param>
/// <param name="buildings">The buildings.</param>
/// <param name="serviceBuilding">The service building.</param>
/// <param name="tagSuffix">The tag suffix.</param>
private static void AddServiceBuildingInfoToDebugInfoMsg(Log.InfoList info, Building[] buildings, ServiceBuildingInfo serviceBuilding, string tagSuffix)
{
if (serviceBuilding != null)
{
info.Add("CanReceive" + tagSuffix, serviceBuilding.CanReceive);
info.Add("CapacityLevel" + tagSuffix, serviceBuilding.CapacityLevel);
info.Add("CapacityFree" + tagSuffix, serviceBuilding.CapacityFree);
info.Add("CapacityMax" + tagSuffix, serviceBuilding.CapacityMax);
info.Add("CapacityOverflow" + tagSuffix, serviceBuilding.CurrentTargetCapacityOverflow);
info.Add("CapacityPercent" + tagSuffix, serviceBuilding.CapacityPercent);
info.Add("Range" + tagSuffix, serviceBuilding.Range);
info.Add("VehiclesFree" + tagSuffix, serviceBuilding.VehiclesFree);
info.Add("VehiclesSpare" + tagSuffix, serviceBuilding.VehiclesSpare);
info.Add("VehiclesMade" + tagSuffix, serviceBuilding.VehiclesMade);
info.Add("VehiclesTotal" + tagSuffix, serviceBuilding.VehiclesTotal);
info.Add("CanReceive" + tagSuffix, serviceBuilding.CanReceive);
info.Add("CanEmptyOther" + tagSuffix, serviceBuilding.CanEmptyOther);
info.Add("CanBeEmptied" + tagSuffix, serviceBuilding.CanBeEmptied);
info.Add("IsEmptying" + tagSuffix, serviceBuilding.IsEmptying);
info.Add("IsAutoEmptying" + tagSuffix, serviceBuilding.IsAutoEmptying);
info.Add("NeedsEmptying" + tagSuffix, serviceBuilding.NeedsEmptying);
info.Add("EmptyingIsDone" + tagSuffix, serviceBuilding.EmptyingIsDone);
info.Add("ServiceProblemCount" + tagSuffix, serviceBuilding.ServiceProblemCount);
info.Add("ServiceProblemSize" + tagSuffix, serviceBuilding.ServiceProblemSize);
ServiceBuildingInfo.AddToInfoMsg(info, serviceBuilding.BuildingId, ref buildings[serviceBuilding.BuildingId], tagSuffix);
}
}
/// <summary>
/// Log debug info.
/// </summary>
public void DebugLog()
{
Log.InfoList info = new Log.InfoList();
this.AddDebugInfoData(info, true);
Log.DevDebug(this, "DebugLog", this.VehicleId, info);
}
/// <summary>
/// Creates a new instance of an information list with garbage vehicle info.
/// </summary>
/// <param name="vehicleId">The vehicle identifier.</param>
/// <param name="vehicle">The vehicle.</param>
/// <param name="dirtyBuildingId">The dirty building identifier.</param>
/// <param name="dirtyBuilding">The dirty building.</param>
/// <returns>The information list.</returns>
private static Log.InfoList NewGarbageVehicleInfoList(ushort vehicleId, ref Vehicle vehicle, ushort dirtyBuildingId, ref Building dirtyBuilding)
{
Log.InfoList infoList = new Log.InfoList();
infoList.Add("SourceBuilding", vehicle.m_sourceBuilding, BuildingHelper.GetBuildingName(vehicle.m_sourceBuilding));
infoList.Add("Vehicle", vehicleId, VehicleHelper.GetVehicleName(vehicleId));
infoList.Add("DirtyBuilding", dirtyBuildingId, BuildingHelper.GetBuildingName(dirtyBuildingId));
infoList.Add("TargetBuilding", vehicle.m_targetBuilding, BuildingHelper.GetBuildingName(vehicle.m_targetBuilding));
return(infoList);
}
/// <summary>
/// Returns a <see cref="System.String" /> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="System.String" /> that represents this instance.
/// </returns>
public override string ToString()
{
Log.InfoList info = new Log.InfoList("StuckVehicleInfo: ");
info.Add("VehicleId", this.VehicleId);
info.Add("CheckFlags", this.checkFlags);
info.Add("DispatcherType", this.dispatcherType);
info.Add("DispatchersResponsibility", this.DispatchersResponsibility);
return(info.ToString());
}
/// <summary>
/// Adds the target building information to debug information message.
/// </summary>
/// <param name="info">The information.</param>
/// <param name="targetBuilding">The target building.</param>
/// <param name="tagSuffix">The tag suffix.</param>
private static void AddTargetBuildingInfoToDebugInfoMsg(Log.InfoList info, TargetBuildingInfo targetBuilding, string tagSuffix)
{
if (targetBuilding != null)
{
info.Add("Demand" + tagSuffix, targetBuilding.Demand);
info.Add("HasProblem" + tagSuffix, targetBuilding.HasProblem);
info.Add("ProblemSize" + tagSuffix, targetBuilding.ProblemSize);
info.Add("ProblemValue" + tagSuffix, targetBuilding.ProblemValue);
info.Add("ProblemWeight" + tagSuffix, targetBuilding.ProblemWeight);
info.Add("ServiceProblemCount" + tagSuffix, targetBuilding.ServiceProblemCount);
info.Add("ServiceProblemSize" + tagSuffix, targetBuilding.ServiceProblemSize);
}
}
public void DebugListLog()
{
Log.InfoList info = new Log.InfoList();
info.Add("ServiceBuildingId", this.ServiceBuilding);
info.Add("TargetBuildingId", this.TargetBuilding);
info.Add("Problem", this.ServiceProblem);
info.Add("Weight", this.ProblemWeight);
info.Add("ServiceBuildingName", BuildingHelper.GetBuildingName(this.ServiceBuilding));
info.Add("TargetBuildingName", BuildingHelper.GetBuildingName(this.TargetBuilding));
Log.DevDebug(this, "DebugListLog", info.ToString());
}
/// <summary>
/// Logs building info for debug use.
/// </summary>
/// <param name="buildings">The buildings.</param>
/// <param name="vehicles">The vehicles.</param>
/// <param name="districtManager">The district manager.</param>
/// <param name="citizenManager">The citizen manager.</param>
/// <param name="buildingId">The building identifier.</param>
/// <param name="serviceBuilding">The service building.</param>
/// <param name="targetBuilding">The target building.</param>
/// <param name="buildingStamp">The building stamp.</param>
private static void DebugListLog(
Building[] buildings,
Vehicle[] vehicles,
DistrictManager districtManager,
CitizenManager citizenManager,
ushort buildingId,
ServiceBuildingInfo serviceBuilding,
TargetBuildingInfo targetBuilding,
BuildingStamp buildingStamp)
{
if (buildings[buildingId].Info != null && (buildings[buildingId].m_flags & Building.Flags.Created) == Building.Flags.Created)
{
Log.InfoList info = DebugInfoMsg(buildings, vehicles, districtManager, citizenManager, buildingId, serviceBuilding, targetBuilding, buildingStamp);
Log.DevDebug(typeof(BuildingHelper), "DebugListLog", info.ToString());
}
}
/// <summary>
/// Logs a list of vehicle info for debug use.
/// </summary>
public void DebugListLogVehicles()
{
try
{
if (this.StuckVehicles != null)
{
foreach (StuckVehicleInfo vehicle in this.StuckVehicles.Values)
{
Log.InfoList info = new Log.InfoList();
vehicle.AddDebugInfoData(info);
Log.DevDebug(this, "DebugListLog", "StuckVehicle", info.ToString());
}
}
}
catch (Exception ex)
{
Log.Error(this, "DebugListLogVehicles", ex);
}
}
/// <summary>
/// Logs a list of service problem info for debug use.
/// </summary>
public void DebugListLogServiceProblems()
{
try
{
foreach (KeyValuePair <uint, uint> size in this.ProblemSizes)
{
ushort serviceBuildingId = GetServiceBuildingFromBuildingKey(size.Key);
ushort targetBuildingId = GetTargetBuildingFromBuildingKey(size.Key);
Log.InfoList info = new Log.InfoList("ProblemSize");
info.Add("ServiceBuildingId", serviceBuildingId);
info.Add("TargetBuildingId", targetBuildingId);
info.Add("ProblemSize", size.Value);
info.Add("ServiceBuildingName", BuildingHelper.GetBuildingName(serviceBuildingId));
info.Add("TargetBuildingName", BuildingHelper.GetBuildingName(targetBuildingId));
Log.DevDebug(this, "DebugListLog", info.ToString());
}
foreach (KeyValuePair <ushort, BuildingProblem> problem in TargetBuildingProblems)
{
Log.InfoList info = new Log.InfoList("TargetBuildingProblem");
info.Add("TargetBuildingId", problem.Key);
info.Add("ProblemCount", problem.Value.Count);
info.Add("ProblemSize", problem.Value.Size);
info.Add("TargetBuildingName", BuildingHelper.GetBuildingName(problem.Key));
Log.DevDebug(this, "DebugListLog", info.ToString());
}
}
catch (Exception ex)
{
Log.Error(this, "AddServiceProblemNote", ex);
}
}
/// <summary>
/// Adds debug information data to information list.
/// </summary>
/// <param name="info">The information list.</param>
/// <param name="complete">If set to <c>true</c> add complete information.</param>
private void AddDebugInfoData(Log.InfoList info, bool complete)
{
if (complete)
{
info.Add("VehicleId", this.VehicleId);
Vehicle vehicle = Singleton <VehicleManager> .instance.m_vehicles.m_buffer[this.VehicleId];
info.Add("LeadingVehicle", vehicle.m_leadingVehicle);
info.Add("TrailingVehicle", vehicle.m_trailingVehicle);
info.Add("CargoParent", vehicle.m_cargoParent);
info.Add("Spawned", vehicle.m_flags & Vehicle.Flags.Spawned);
info.Add("Flags", vehicle.m_flags);
info.Add("Info", vehicle.Info);
if (vehicle.Info != null)
{
info.Add("IsLargeVehicle", vehicle.Info.m_isLargeVehicle);
}
}
if (this.isStuck || this.isBroken)
{
info.Add("Problem", this.isStuck ? "Stuck" : null, this.isBroken ? "Broken" : null);
}
if (this.confusedSinceFrame > 0 || this.confusedSinceTime > 0)
{
info.Add("Confused", this.ConfusedForSeconds, this.ConfusedForFrames);
}
if (this.checkFlagSinceFrame > 0 || this.checkFlagSinceTime > 0)
{
info.Add("Flagged", this.checkFlags, this.CheckFlaggedForSeconds, this.CheckFlaggedForFrames);
}
info.Add("Dispatcher", this.dispatcherType);
info.Add("Responsible", this.DispatchersResponsibility);
}
/// <summary>
/// Returns a <see cref="System.String" /> that represents this instance.
/// </summary>
/// <param name="vehicle">The vehicle.</param>
/// <param name="vehicles">The vehicles.</param>
/// <param name="buildings">The buildings.</param>
/// <param name="getHead">if set to <c>true</c> get header instead of data.</param>
/// <returns>
/// A <see cref="System.String" /> that represents this instance.
/// </returns>
private static string InfoString(StuckVehicleInfo vehicle, Vehicle[] vehicles, Building[] buildings, bool getHead)
{
Log.InfoList info = new Log.InfoList();
List <string> status = null;
List <string> dispatch = null;
string ai = null;
if (!getHead)
{
if (vehicles == null)
{
vehicles = Singleton <VehicleManager> .instance.m_vehicles.m_buffer;
}
if (buildings == null)
{
buildings = Singleton <BuildingManager> .instance.m_buildings.m_buffer;
}
status = new List <string>(1);
if (vehicle.isStuck)
{
status.Add("Stuck");
}
if (vehicle.isBroken)
{
status.Add("Broken");
}
if (vehicle.isLost)
{
status.Add("Lost");
}
if (vehicle.isConfused)
{
status.Add("Confused");
}
if (vehicle.isFlagged)
{
status.Add("Flagged");
}
if (status.Count == 0)
{
status.Add("Checking");
}
dispatch = new List <string>(2);
if (IsDispatchersResponsibility(vehicle.dispatcherType))
{
dispatch.Add("IsResponsible");
}
if (vehicle.dispatcherType != Dispatcher.DispatcherTypes.None)
{
dispatch.Add(vehicle.dispatcherType.ToString());
}
try
{
if (vehicles[vehicle.VehicleId].Info != null)
{
if (vehicles[vehicle.VehicleId].Info.m_vehicleAI != null)
{
ai = vehicles[vehicle.VehicleId].Info.m_vehicleAI.GetType().ToString();
}
}
}
catch { }
}
if (getHead)
{
info.Add("<Status>", "<Status>");
info.Add("<Vehicle>", "<VehicleId>", "[VehicleName]", "[VehicleAI]", "[ExtraInfo]");
}
else
{
info.Add("Status", status);
info.Add("Vehicle", vehicle.VehicleId, vehicle.VehicleName, ai, vehicle.ExtraInfo);
}
if (getHead)
{
info.Add("[Dispatch]", "[Responsibility]", "[DispatcherType]");
}
else if (dispatch.Count > 0)
{
info.Add("Dispatch", dispatch);
}
if (getHead)
{
info.Add("[Confused]", "<ConfusedForSeconds>", "<ConfusedForFrames>");
}
else if (vehicle.confusedSinceFrame > 0 || vehicle.confusedSinceTime > 0.0)
{
info.Add("Confused", vehicle.ConfusedForSeconds, vehicle.ConfusedForFrames);
}
if (getHead)
{
info.Add("[Flagged]", "<FlaggedForSeconds>", "<FlaggedForFrames>", "[Flags]", "[Position]");
}
else if (vehicle.checkFlagSinceFrame > 0 || vehicle.checkFlagSinceTime > 0.0)
{
info.Add("Flagged", vehicle.CheckFlaggedForSeconds, vehicle.CheckFlaggedForFrames, vehicle.checkFlags, vehicle.checkFlagPosition);
}
if (getHead)
{
info.Add("[Lost]", "<LostForSeconds>", "<LostForFrames>", "[LostReason]");
}
else if (vehicle.lostSinceFrame > 0 || vehicle.lostSinceTime > 0.0)
{
info.Add("Lost", vehicle.LostForSeconds, vehicle.LostForFrames, vehicle.lostReason);
}
if (getHead)
{
info.Add("[District]", "<districtId>", "[DistrictName]");
}
else if (vehicle.checkFlagSinceFrame > 0 || vehicle.checkFlagSinceTime > 0.0)
{
try
{
byte districtId = DistrictHelper.GetDistrict(vehicle.checkFlagPosition);
if (districtId != 0)
{
info.Add("District", districtId, DistrictHelper.GetDistrictName(districtId));
}
}
catch { }
}
if (getHead)
{
InfoStringInfoForBuilding(null, null, null, true, 0, "SourceBuilding", info);
InfoStringInfoForBuilding(null, null, null, true, 0, "TargetBuilding", info);
}
else
{
try
{
InfoStringInfoForBuilding(vehicle, vehicles, buildings, false, vehicles[vehicle.VehicleId].m_sourceBuilding, "SourceBuilding", info);
InfoStringInfoForBuilding(vehicle, vehicles, buildings, false, vehicles[vehicle.VehicleId].m_targetBuilding, "TargetBuilding", info);
}
catch { }
}
if (getHead)
{
info.Add("[Handling]", "<HandledForFrames>", "<HandlingErrors>");
}
else if (vehicle.handlingErrors > 0 || vehicle.lastHandledStamp > 0)
{
info.Add("Handling", (vehicle.lastHandledStamp > 0 && vehicle.lastHandledStamp < Global.CurrentFrame) ? Global.CurrentFrame - vehicle.lastHandledStamp : 0, vehicle.handlingErrors);
}
return(info.ToString());
}
/// <summary>
/// Creates a new instance of an information list with garbage vehicle info.
/// </summary>
/// <param name="vehicleId">The vehicle identifier.</param>
/// <param name="vehicle">The vehicle.</param>
/// <param name="dirtyBuildingId">The dirty building identifier.</param>
/// <param name="dirtyBuilding">The dirty building.</param>
/// <returns>The information list.</returns>
private static Log.InfoList NewGarbageVehicleInfoList(ushort vehicleId, ref Vehicle vehicle, ushort dirtyBuildingId, ref Building dirtyBuilding)
{
Log.InfoList infoList = new Log.InfoList();
infoList.Add("SourceBuilding", vehicle.m_sourceBuilding, BuildingHelper.GetBuildingName(vehicle.m_sourceBuilding));
infoList.Add("Vehicle", vehicleId, VehicleHelper.GetVehicleName(vehicleId));
infoList.Add("DirtyBuilding", dirtyBuildingId, BuildingHelper.GetBuildingName(dirtyBuildingId));
infoList.Add("TargetBuilding", vehicle.m_targetBuilding, BuildingHelper.GetBuildingName(vehicle.m_targetBuilding));
return infoList;
}
/// <summary>
/// Returns a <see cref="System.String" /> that represents this instance.
/// </summary>
/// <returns>
/// A <see cref="System.String" /> that represents this instance.
/// </returns>
public override string ToString()
{
Log.InfoList info = new Log.InfoList("BuldingCheckParams: ");
info.Add("OnlyProblematic", this.OnlyProblematic);
info.Add("IncludeUneedy", this.IncludeUneedy);
info.Add("IgnoreRange", this.IgnoreRange);
info.Add("MinProblemValue", this.MinProblemValue);
info.Add("AllowCreateSpares", this.AllowCreateSpares);
return info.ToString();
}
/// <summary>
/// Logs the component data.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="block">The block.</param>
/// <param name="component">The component.</param>
/// <param name="componentName">Name of the component.</param>
/// <param name="connectedName">Name of the connected component.</param>
/// <param name="depth">The recursion depth.</param>
private static void LogComponent(object source, string block, UIComponent component, string componentName, string connectedName, int depth)
{
string componentPath = null;
try
{
if (component != null && component is UIComponent)
{
Log.InfoList info = new Log.InfoList();
componentPath = componentName;
if (String.IsNullOrEmpty(componentPath))
{
componentPath = component.cachedName;
if (String.IsNullOrEmpty(componentPath))
{
componentPath = "?";
}
}
if (!String.IsNullOrEmpty(connectedName))
{
componentPath = connectedName + "/" + componentPath;
}
try
{
foreach (var property in component.GetType().GetProperties())
{
if (property != null)
{
try
{
info.Add(property.Name, property.GetValue(component, null));
}
catch
{
}
}
}
}
catch
{
}
Log.Debug(source, block, depth, componentPath, component.GetType(), component, info);
if (depth < 32)
{
depth++;
foreach (UIComponent child in component.components)
{
if (child != null)
{
LogComponent(source, block, child, null, componentPath, depth);
}
}
}
}
}
catch (Exception ex)
{
if (String.IsNullOrEmpty(componentPath))
{
Log.Debug(source, block, connectedName, componentName, ex.GetType(), ex.Message);
}
else
{
Log.Debug(source, block, componentPath, ex.GetType(), ex.Message);
}
}
}
/// <summary>
/// Collects vehicle debug information.
/// </summary>
/// <param name="vehicles">The vehicles.</param>
/// <param name="buildings">The buildings.</param>
/// <param name="vehicleId">The vehicle identifier.</param>
/// <param name="verbose">If set to <c>true</c> include more information.</param>
/// <returns>
/// Vehicle information.
/// </returns>
private static Log.InfoList DebugInfoMsg(Vehicle[] vehicles, Building[] buildings, ushort vehicleId, bool verbose = false)
{
Log.InfoList info = new Log.InfoList();
InstanceID instanceId;
float prgCur, prgMax;
int bufCur, bufMax;
string localeKey;
float distance;
string name;
info.Add("VehicleId", vehicleId);
if (verbose)
{
info.Add("LeadingVehicle", vehicles[vehicleId].m_leadingVehicle);
info.Add("TrailingVehicle", vehicles[vehicleId].m_trailingVehicle);
info.Add("CargoParent", vehicles[vehicleId].m_cargoParent);
}
try
{
info.Add("AI", vehicles[vehicleId].Info.m_vehicleAI.GetType());
info.Add("InfoName", vehicles[vehicleId].Info.name);
name = GetVehicleName(vehicleId);
if (!String.IsNullOrEmpty(name) && name != vehicles[vehicleId].Info.name)
{
info.Add("VehicleName", name);
}
}
catch
{
info.Add("Error", "Info");
}
try
{
TransferManager.TransferReason reason;
if (Enums.TryConvertToTransferReason(vehicles[vehicleId].m_transferType, out reason))
{
info.Add("Type", reason);
}
else
{
info.Add("Type", vehicles[vehicleId].m_transferType);
}
}
catch
{
info.Add("Error", "Transfer");
}
try
{
if (vehicles[vehicleId].m_sourceBuilding != 0 && buildings[vehicles[vehicleId].m_sourceBuilding].Info != null)
{
distance = (vehicles[vehicleId].GetLastFramePosition() - buildings[vehicles[vehicleId].m_sourceBuilding].m_position).sqrMagnitude;
name = BuildingHelper.GetBuildingName(vehicles[vehicleId].m_sourceBuilding);
if (String.IsNullOrEmpty(name))
{
name = buildings[vehicles[vehicleId].m_sourceBuilding].Info.name;
}
info.Add("Source", vehicles[vehicleId].m_sourceBuilding, name, distance);
}
}
catch
{
info.Add("Error", "SourceBuilding");
}
try
{
if (vehicles[vehicleId].m_targetBuilding != 0 && buildings[vehicles[vehicleId].m_targetBuilding].Info != null)
{
distance = (vehicles[vehicleId].GetLastFramePosition() - buildings[vehicles[vehicleId].m_targetBuilding].m_position).sqrMagnitude;
name = BuildingHelper.GetBuildingName(vehicles[vehicleId].m_targetBuilding);
if (String.IsNullOrEmpty(name))
{
name = buildings[vehicles[vehicleId].m_targetBuilding].Info.name;
}
info.Add("Target", vehicles[vehicleId].m_targetBuilding, name, distance);
}
}
catch
{
info.Add("Error", "TargetBuilding");
}
try
{
string flags = vehicles[vehicleId].m_flags.ToString();
if (flags.IndexOfAny(new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }) >= 0)
{
foreach (Vehicle.Flags flag in Enum.GetValues(typeof(Vehicle.Flags)))
{
if ((vehicles[vehicleId].m_flags & flag) == flag)
{
flags += ", " + flag.ToString();
}
}
}
info.Add("Flags", flags);
}
catch
{
info.Add("Error", "Flags");
}
try
{
info.Add("Enabled", vehicles[vehicleId].Info.enabled);
info.Add("Active", vehicles[vehicleId].Info.isActiveAndEnabled);
info.Add("AIEnabled", vehicles[vehicleId].Info.m_vehicleAI.enabled);
info.Add("AIActive", vehicles[vehicleId].Info.m_vehicleAI.isActiveAndEnabled);
}
catch
{
info.Add("Error", "Info");
}
try
{
if (vehicles[vehicleId].Info.m_vehicleAI.GetProgressStatus(vehicleId, ref vehicles[vehicleId], out prgCur, out prgMax))
{
info.Add("PrgCur", prgCur);
info.Add("PrgMax", prgMax);
}
}
catch
{
info.Add("Error", "Progress");
}
try
{
vehicles[vehicleId].Info.m_vehicleAI.GetBufferStatus(vehicleId, ref vehicles[vehicleId], out localeKey, out bufCur, out bufMax);
if (!String.IsNullOrEmpty(localeKey))
{
info.Add("BufLocKey", localeKey);
}
info.Add("BufCur", bufCur);
info.Add("BufMax", bufMax);
}
catch
{
info.Add("Error", "Buffer");
}
info.Add("TransferSize", vehicles[vehicleId].m_transferSize);
try
{
if (vehicles[vehicleId].Info.m_vehicleAI is HearseAI)
{
info.Add("Capacity", ((HearseAI)vehicles[vehicleId].Info.m_vehicleAI).m_corpseCapacity);
}
else if (vehicles[vehicleId].Info.m_vehicleAI is GarbageTruckAI)
{
info.Add("Capacity", ((GarbageTruckAI)vehicles[vehicleId].Info.m_vehicleAI).m_cargoCapacity);
}
else if (vehicles[vehicleId].Info.m_vehicleAI is AmbulanceAI)
{
info.Add("Capacity", ((AmbulanceAI)vehicles[vehicleId].Info.m_vehicleAI).m_patientCapacity);
}
}
catch
{
info.Add("Error", "Capacity");
}
try
{
string status = vehicles[vehicleId].Info.m_vehicleAI.GetLocalizedStatus(vehicleId, ref vehicles[vehicleId], out instanceId);
if (!String.IsNullOrEmpty(status))
{
info.Add("Status", status);
}
}
catch
{
info.Add("Error", "Status");
}
if (verbose)
{
try
{
if (vehicles[vehicleId].m_leadingVehicle == 0 && vehicles[vehicleId].m_trailingVehicle != 0)
{
ushort trailerCount = 0;
ushort trailerId = vehicles[vehicleId].m_trailingVehicle;
while (trailerId != 0 && trailerCount < ushort.MaxValue)
{
trailerId = vehicles[trailerId].m_trailingVehicle;
trailerCount++;
}
info.Add("TrailerCount", trailerCount);
}
}
catch
{
info.Add("Error", "Trailing");
}
info.Add("WaitCounter", vehicles[vehicleId].m_waitCounter);
try
{
info.Add("Position", vehicles[vehicleId].GetLastFramePosition());
}
catch
{
info.Add("Error", "Position");
}
if (Global.Vehicles != null)
{
try
{
if (Global.Vehicles.StuckVehicles != null)
{
StuckVehicleInfo stuckVehicle;
if (Global.Vehicles.StuckVehicles.TryGetValue(vehicleId, out stuckVehicle))
{
stuckVehicle.AddDebugInfoData(info);
}
}
}
catch
{
info.Add("Error", "Stuck");
}
}
}
try
{
info.Add("AI", vehicles[vehicleId].Info.m_vehicleAI.GetType().AssemblyQualifiedName);
}
catch
{
info.Add("Error", "AI");
}
return(info);
}
/// <summary>
/// Collects building info for debug use.
/// </summary>
/// <param name="buildings">The buildings.</param>
/// <param name="vehicles">The vehicles.</param>
/// <param name="districtManager">The district manager.</param>
/// <param name="citizenManager">The citizen manager.</param>
/// <param name="buildingId">The building identifier.</param>
/// <param name="serviceBuilding">The service building.</param>
/// <param name="targetBuilding">The target building.</param>
/// <param name="buildingStamp">The building stamp.</param>
/// <param name="verbose">If set to <c>true</c> include more information.</param>
/// <returns>The debug information.</returns>
private static Log.InfoList DebugInfoMsg(
Building[] buildings,
Vehicle[] vehicles,
DistrictManager districtManager,
CitizenManager citizenManager,
ushort buildingId,
ServiceBuildingInfo serviceBuilding,
TargetBuildingInfo targetBuilding,
BuildingStamp buildingStamp,
bool verbose = false)
{
Log.InfoList info = new Log.InfoList();
info.Add("BuildingId", buildingId);
if (buildingStamp != null)
{
info.Add("O", "BuildingStamp");
}
if (serviceBuilding != null)
{
info.Add("O", "ServiceBuilding");
}
if (targetBuilding != null)
{
info.Add("O", "TargetBuilding");
}
List <KeyValuePair <string, TargetBuildingInfo> > targetBuildings = null;
List <KeyValuePair <string, ServiceBuildingInfo> > serviceBuildings = null;
if (verbose && Global.Buildings != null)
{
//if (serviceBuilding == null)
//{
// serviceBuilding = Global.Buildings.GetServiceBuilding(buildingId);
//}
//if (targetBuilding == null)
//{
// targetBuilding = Global.Buildings.GetTargetBuilding(buildingId);
//}
targetBuildings = new List <KeyValuePair <string, TargetBuildingInfo> >();
serviceBuildings = new List <KeyValuePair <string, ServiceBuildingInfo> >();
if (serviceBuilding == null)
{
if (Global.Buildings.Garbage.ServiceBuildings != null && Global.Buildings.Garbage.ServiceBuildings.TryGetValue(buildingId, out serviceBuilding))
{
serviceBuildings.Add(new KeyValuePair <string, ServiceBuildingInfo>("GB", serviceBuilding));
}
if (Global.Buildings.DeathCare.ServiceBuildings != null && Global.Buildings.DeathCare.ServiceBuildings.TryGetValue(buildingId, out serviceBuilding))
{
serviceBuildings.Add(new KeyValuePair <string, ServiceBuildingInfo>("DCB", serviceBuilding));
}
if (Global.Buildings.HealthCare.ServiceBuildings != null && Global.Buildings.HealthCare.ServiceBuildings.TryGetValue(buildingId, out serviceBuilding))
{
serviceBuildings.Add(new KeyValuePair <string, ServiceBuildingInfo>("HCB", serviceBuilding));
}
serviceBuilding = null;
}
if (targetBuilding == null)
{
if (Global.Buildings.DeathCare.TargetBuildings != null && Global.Buildings.DeathCare.TargetBuildings.TryGetValue(buildingId, out targetBuilding))
{
targetBuildings.Add(new KeyValuePair <string, TargetBuildingInfo>("DPB", targetBuilding));
}
if (Global.Buildings.Garbage.TargetBuildings != null && Global.Buildings.Garbage.TargetBuildings.TryGetValue(buildingId, out targetBuilding))
{
targetBuildings.Add(new KeyValuePair <string, TargetBuildingInfo>("DB", targetBuilding));
}
if (Global.Buildings.HealthCare.TargetBuildings != null && Global.Buildings.HealthCare.TargetBuildings.TryGetValue(buildingId, out targetBuilding))
{
targetBuildings.Add(new KeyValuePair <string, TargetBuildingInfo>("SPB", targetBuilding));
}
targetBuilding = null;
}
}
try
{
info.Add("AI", buildings[buildingId].Info.m_buildingAI.GetType());
info.Add("InfoName", buildings[buildingId].Info.name);
string name = GetBuildingName(buildingId);
if (!String.IsNullOrEmpty(name) && name != buildings[buildingId].Info.name)
{
info.Add("BuildingName", name);
}
}
catch
{
info.Add("Error", "Info");
}
try
{
byte district = districtManager.GetDistrict(buildings[buildingId].m_position);
info.Add("District", district);
info.Add("DistrictName", districtManager.GetDistrictName(district));
}
catch (Exception ex)
{
info.Add("Exception", "District", ex.GetType().ToString(), ex.Message);
}
if (buildingStamp != null)
{
info.Add("Source", buildingStamp.Source);
info.Add("SimulationTimeStamp", buildingStamp.SimulationTimeStamp);
info.Add("SimulationTimeDelta", buildingStamp.SimulationTimeDelta);
}
AddServiceBuildingInfoToDebugInfoMsg(info, buildings, serviceBuilding, "B");
if (serviceBuildings != null)
{
foreach (KeyValuePair <string, ServiceBuildingInfo> building in serviceBuildings)
{
AddServiceBuildingInfoToDebugInfoMsg(info, buildings, building.Value, building.Key);
}
}
AddTargetBuildingInfoToDebugInfoMsg(info, targetBuilding, "B");
if (targetBuildings != null)
{
foreach (KeyValuePair <string, TargetBuildingInfo> building in targetBuildings)
{
AddTargetBuildingInfoToDebugInfoMsg(info, building.Value, building.Key);
}
}
if (verbose && Global.Buildings != null)
{
info.Add("Categories", Global.Buildings.GetCategories(buildingId));
}
float radius = float.NaN;
int materialMax = 0;
int materialAmount = 0;
int serviceVehicleCount = 0;
try
{
if (GetCapacityAmount(buildingId, ref buildings[buildingId], out materialAmount, out materialMax, out serviceVehicleCount))
{
info.Add("CapacityAmount", materialAmount);
info.Add("CapacityMax", materialMax);
info.Add("ServiceVehicleCount", serviceVehicleCount);
}
serviceVehicleCount = 0;
if (buildings[buildingId].Info.m_buildingAI is CemeteryAI)
{
radius = ((CemeteryAI)buildings[buildingId].Info.m_buildingAI).m_deathCareRadius;
info.Add("DeathCareRadius", ((CemeteryAI)buildings[buildingId].Info.m_buildingAI).m_deathCareRadius);
info.Add("CorpseCapacity", ((CemeteryAI)buildings[buildingId].Info.m_buildingAI).m_corpseCapacity);
info.Add("GraveCount", ((CemeteryAI)buildings[buildingId].Info.m_buildingAI).m_graveCount);
info.Add("CustomBuffer1", buildings[buildingId].m_customBuffer1); // GraveUsed?
info.Add("CustomBuffer2", buildings[buildingId].m_customBuffer2);
info.Add("PR_HC_Calc", ((buildings[buildingId].m_productionRate * ((CemeteryAI)buildings[buildingId].Info.m_buildingAI).m_hearseCount) + 99) / 100); // Hearse capacity?
info.Add("IsFull", buildings[buildingId].Info.m_buildingAI.IsFull(buildingId, ref buildings[buildingId]));
buildings[buildingId].Info.m_buildingAI.GetMaterialAmount(buildingId, ref buildings[buildingId], TransferManager.TransferReason.Dead, out materialAmount, out materialMax);
}
else if (buildings[buildingId].Info.m_buildingAI is LandfillSiteAI)
{
radius = ((LandfillSiteAI)buildings[buildingId].Info.m_buildingAI).m_collectRadius;
info.Add("CollectRadius", ((LandfillSiteAI)buildings[buildingId].Info.m_buildingAI).m_collectRadius);
info.Add("GarbageAmount", ((LandfillSiteAI)buildings[buildingId].Info.m_buildingAI).GetGarbageAmount(buildingId, ref buildings[buildingId]));
info.Add("GarbageCapacity", ((LandfillSiteAI)buildings[buildingId].Info.m_buildingAI).m_garbageCapacity);
info.Add("GarbageBuffer", buildings[buildingId].m_garbageBuffer);
info.Add("CustomBuffer1", buildings[buildingId].m_customBuffer1); // Garbage?
info.Add("IsFull", buildings[buildingId].Info.m_buildingAI.IsFull(buildingId, ref buildings[buildingId]));
buildings[buildingId].Info.m_buildingAI.GetMaterialAmount(buildingId, ref buildings[buildingId], TransferManager.TransferReason.Garbage, out materialAmount, out materialMax);
}
else if (buildings[buildingId].Info.m_buildingAI is HospitalAI)
{
radius = ((HospitalAI)buildings[buildingId].Info.m_buildingAI).m_healthCareRadius;
info.Add("HealthCareRadius", ((HospitalAI)buildings[buildingId].Info.m_buildingAI).m_healthCareRadius);
info.Add("PatientCapacity", ((HospitalAI)buildings[buildingId].Info.m_buildingAI).m_patientCapacity);
info.Add("IsFull", buildings[buildingId].Info.m_buildingAI.IsFull(buildingId, ref buildings[buildingId]));
buildings[buildingId].Info.m_buildingAI.GetMaterialAmount(buildingId, ref buildings[buildingId], TransferManager.TransferReason.Sick, out materialAmount, out materialMax);
}
info.Add("materialMax", materialMax);
info.Add("materialAmount", materialAmount);
info.Add("materialFree", materialMax - materialAmount);
}
catch
{
info.Add("Error", "Material");
}
ushort ownVehicleCount = 0;
ushort madeVehicleCount = 0;
try
{
ushort vehicleId = buildings[buildingId].m_ownVehicles;
while (vehicleId != 0 && ownVehicleCount < ushort.MaxValue)
{
ownVehicleCount++;
try
{
if ((vehicles[vehicleId].m_transferType == (byte)TransferManager.TransferReason.Garbage || vehicles[vehicleId].m_transferType == (byte)TransferManager.TransferReason.Dead) &&
vehicles[vehicleId].Info != null &&
(vehicles[vehicleId].m_flags & Vehicle.Flags.Created) == Vehicle.Flags.Created &&
(vehicles[vehicleId].m_flags & VehicleHelper.VehicleExists) != ~VehicleHelper.VehicleAll)
{
madeVehicleCount++;
}
}
catch
{
info.Add("Error", "Vehicle");
}
vehicleId = vehicles[vehicleId].m_nextOwnVehicle;
}
info.Add("OwnVehicles", ownVehicleCount);
info.Add("MadeVehicles", madeVehicleCount);
}
catch
{
info.Add("Error", "Vehicles");
}
int productionRate = buildings[buildingId].m_productionRate;
info.Add("VehicleCount", serviceVehicleCount);
info.Add("ProductionRate", productionRate);
info.Add("VehicleCountNominal", ((productionRate * serviceVehicleCount) + 99) / 100);
try
{
int budget = Singleton <EconomyManager> .instance.GetBudget(buildings[buildingId].Info.m_buildingAI.m_info.m_class);
productionRate = PlayerBuildingAI.GetProductionRate(productionRate, budget);
int productionRate100 = PlayerBuildingAI.GetProductionRate(100, budget);
int actualVehicleCount = ((productionRate * serviceVehicleCount) + 99) / 100;
int actualVehicleCount100 = ((productionRate100 * serviceVehicleCount) + 99) / 100;
if (!float.IsNaN(radius))
{
info.Add("Radius", radius);
}
info.Add("Budget", budget);
info.Add("ProductionRateActual", productionRate, productionRate100);
info.Add("VehicleCountActual", actualVehicleCount, actualVehicleCount100);
info.Add("SpareVehicles", actualVehicleCount - ownVehicleCount, actualVehicleCount100 - ownVehicleCount);
if (!float.IsNaN(radius))
{
info.Add("ProductionRange", (double)productionRate * (double)radius * 0.00999999977648258);
}
}
catch
{
info.Add("Error", "Budget");
}
try
{
float range = buildings[buildingId].Info.m_buildingAI.GetCurrentRange(buildingId, ref buildings[buildingId]);
range = range * range * Global.Settings.RangeModifier;
if (range < Global.Settings.RangeMinimum)
{
info.Add("Range", range, '<', Global.Settings.RangeMinimum);
}
else if (range > Global.Settings.RangeMaximum)
{
info.Add("Range", range, '>', Global.Settings.RangeMaximum);
}
else
{
info.Add("Range", range, ">=<");
}
}
catch
{
info.Add("Error", "Range");
}
try
{
List <string> needs = new List <string>();
if (buildings[buildingId].m_garbageBuffer >= Global.Settings.Garbage.MinimumAmountForDispatch)
{
needs.Add("Filthy");
}
else if (buildings[buildingId].m_garbageBuffer >= Global.Settings.Garbage.MinimumAmountForPatrol)
{
needs.Add("Dirty");
}
else if (buildings[buildingId].m_garbageBuffer > 0)
{
needs.Add("Dusty");
}
if (buildings[buildingId].m_deathProblemTimer > 0)
{
needs.Add("Dead");
}
if (buildings[buildingId].m_garbageBuffer * Dispatcher.ProblemBufferModifier >= Dispatcher.ProblemLimitForgotten ||
buildings[buildingId].m_deathProblemTimer * Dispatcher.ProblemTimerModifier >= Dispatcher.ProblemLimitForgotten)
{
needs.Add("Forgotten");
}
info.Add("Needs", needs);
}
catch
{
info.Add("Error", "Needs");
}
info.Add("DeathProblemTimer", buildings[buildingId].m_deathProblemTimer);
info.Add("HealthProblemTimer", buildings[buildingId].m_healthProblemTimer);
info.Add("MajorProblemTimer", buildings[buildingId].m_majorProblemTimer);
try
{
int citizens = 0;
int count = 0;
uint unitId = buildings[buildingId].m_citizenUnits;
while (unitId != 0)
{
CitizenUnit unit = citizenManager.m_units.m_buffer[unitId];
try
{
for (int i = 0; i < 5; i++)
{
uint citizenId = unit.GetCitizen(i);
if (citizenId != 0)
{
Citizen citizen = citizenManager.m_citizens.m_buffer[citizenId];
if (citizen.Dead && citizen.GetBuildingByLocation() == buildingId)
{
citizens++;
}
}
}
}
catch
{
info.Add("Error", "Citizen");
}
count++;
if (count > (int)ushort.MaxValue * 10)
{
break;
}
unitId = unit.m_nextUnit;
}
info.Add("DeadCitizens", citizens);
}
catch
{
info.Add("Error", "Citizens");
}
try
{
info.Add("GarbageAmount", buildings[buildingId].Info.m_buildingAI.GetGarbageAmount(buildingId, ref buildings[buildingId]));
info.Add("GarbageBuffer", buildings[buildingId].m_garbageBuffer);
}
catch
{
info.Add("Error", "Garbage");
}
try
{
string problems = buildings[buildingId].m_problems.ToString();
if (problems.IndexOfAny(new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }) >= 0)
{
foreach (Notification.Problem problem in Enum.GetValues(typeof(Notification.Problem)))
{
if (problem != Notification.Problem.None && (buildings[buildingId].m_problems & problem) == problem)
{
problems += ", " + problem.ToString();
}
}
}
info.Add("Problems", problems);
}
catch
{
info.Add("Error", "Problems");
}
info.Add("FireIntensoty", buildings[buildingId].m_fireIntensity);
try
{
string flags = buildings[buildingId].m_flags.ToString();
if (flags.IndexOfAny(new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }) >= 0)
{
foreach (Building.Flags flag in Enum.GetValues(typeof(Building.Flags)))
{
if (flag != Building.Flags.None && (buildings[buildingId].m_flags & flag) == flag)
{
flags += ", " + flag.ToString();
}
}
}
info.Add("Flags", flags);
}
catch
{
info.Add("Error", "Flags");
}
try
{
string status = buildings[buildingId].Info.m_buildingAI.GetLocalizedStatus(buildingId, ref buildings[buildingId]);
if (!String.IsNullOrEmpty(status))
{
info.Add("Status", status);
}
}
catch
{
info.Add("Error", "Status");
}
try
{
info.Add("AI", buildings[buildingId].Info.m_buildingAI.GetType().AssemblyQualifiedName);
}
catch
{
info.Add("Error", "AI");
}
return(info);
}
/// <summary>
/// Log debug info.
/// </summary>
private void DebugLog()
{
Vehicle vehicle = Singleton<VehicleManager>.instance.m_vehicles.m_buffer[this.vehicleId];
Log.InfoList info = new Log.InfoList();
this.AddDebugInfoData(info, true);
Log.DevDebug(this, "DebugLog", this.vehicleId, info);
}
/// <summary>
/// Adds debug information data to information list.
/// </summary>
/// <param name="info">The information list.</param>
public void AddDebugInfoData(Log.InfoList info)
{
this.AddDebugInfoData(info, false);
}
/// <summary>
/// Collects vehicle debug information.
/// </summary>
/// <param name="vehicles">The vehicles.</param>
/// <param name="buildings">The buildings.</param>
/// <param name="vehicleId">The vehicle identifier.</param>
/// <param name="verbose">If set to <c>true</c> include more information.</param>
/// <returns>
/// Vehicle information.
/// </returns>
private static Log.InfoList DebugInfoMsg(Vehicle[] vehicles, Building[] buildings, ushort vehicleId, bool verbose = false)
{
Log.InfoList info = new Log.InfoList();
InstanceID instanceId;
float prgCur, prgMax;
int bufCur, bufMax;
string localeKey;
float distance;
info.Add("VehicleId", vehicleId);
if (verbose)
{
info.Add("LeadingVehicle", vehicles[vehicleId].m_leadingVehicle);
info.Add("TrailingVehicle", vehicles[vehicleId].m_trailingVehicle);
info.Add("CargoParent", vehicles[vehicleId].m_cargoParent);
}
info.Add("AI", vehicles[vehicleId].Info.m_vehicleAI.GetType());
info.Add("InfoName", vehicles[vehicleId].Info.name);
string name = GetVehicleName(vehicleId);
if (!String.IsNullOrEmpty(name) && name != vehicles[vehicleId].Info.name)
{
info.Add("VehicleName", name);
}
string type = vehicles[vehicleId].m_transferType.ToString();
foreach (TransferManager.TransferReason reason in Enum.GetValues(typeof(TransferManager.TransferReason)))
{
if ((byte)reason == vehicles[vehicleId].m_transferType)
{
type = reason.ToString();
break;
}
}
info.Add("Type", type);
if (vehicles[vehicleId].m_sourceBuilding != 0 && buildings[vehicles[vehicleId].m_sourceBuilding].Info != null)
{
distance = (vehicles[vehicleId].GetLastFramePosition() - buildings[vehicles[vehicleId].m_sourceBuilding].m_position).sqrMagnitude;
name = BuildingHelper.GetBuildingName(vehicles[vehicleId].m_sourceBuilding);
if (String.IsNullOrEmpty(name))
{
name = buildings[vehicles[vehicleId].m_sourceBuilding].Info.name;
}
info.Add("Source", vehicles[vehicleId].m_sourceBuilding, name, distance);
}
if (vehicles[vehicleId].m_targetBuilding != 0 && buildings[vehicles[vehicleId].m_targetBuilding].Info != null)
{
distance = (vehicles[vehicleId].GetLastFramePosition() - buildings[vehicles[vehicleId].m_targetBuilding].m_position).sqrMagnitude;
name = BuildingHelper.GetBuildingName(vehicles[vehicleId].m_targetBuilding);
if (String.IsNullOrEmpty(name))
{
name = buildings[vehicles[vehicleId].m_targetBuilding].Info.name;
}
info.Add("Target", vehicles[vehicleId].m_targetBuilding, name, distance);
}
string flags = vehicles[vehicleId].m_flags.ToString();
if (flags.IndexOfAny(new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }) >= 0)
{
foreach (Vehicle.Flags flag in Enum.GetValues(typeof(Vehicle.Flags)))
{
if ((vehicles[vehicleId].m_flags & flag) == flag)
{
flags += ", " + flag.ToString();
}
}
}
info.Add("Flags", flags);
info.Add("Enabled", vehicles[vehicleId].Info.enabled);
info.Add("Active", vehicles[vehicleId].Info.isActiveAndEnabled);
info.Add("AIEnabled", vehicles[vehicleId].Info.m_vehicleAI.enabled);
info.Add("AIActive", vehicles[vehicleId].Info.m_vehicleAI.isActiveAndEnabled);
if (vehicles[vehicleId].Info.m_vehicleAI.GetProgressStatus(vehicleId, ref vehicles[vehicleId], out prgCur, out prgMax))
{
info.Add("PrgCur", prgCur);
info.Add("PrgMax", prgMax);
}
vehicles[vehicleId].Info.m_vehicleAI.GetBufferStatus(vehicleId, ref vehicles[vehicleId], out localeKey, out bufCur, out bufMax);
if (!String.IsNullOrEmpty(localeKey))
{
info.Add("BufLocKey", localeKey);
}
info.Add("BufCur", bufCur);
info.Add("BufMax", bufMax);
info.Add("TransferSize", vehicles[vehicleId].m_transferSize);
if (vehicles[vehicleId].Info.m_vehicleAI is HearseAI)
{
info.Add("Capacity", ((HearseAI)vehicles[vehicleId].Info.m_vehicleAI).m_corpseCapacity);
}
else if (vehicles[vehicleId].Info.m_vehicleAI is GarbageTruckAI)
{
info.Add("Capacity", ((GarbageTruckAI)vehicles[vehicleId].Info.m_vehicleAI).m_cargoCapacity);
}
else if (vehicles[vehicleId].Info.m_vehicleAI is AmbulanceAI)
{
info.Add("Capacity", ((AmbulanceAI)vehicles[vehicleId].Info.m_vehicleAI).m_patientCapacity);
}
string status = vehicles[vehicleId].Info.m_vehicleAI.GetLocalizedStatus(vehicleId, ref vehicles[vehicleId], out instanceId);
if (!String.IsNullOrEmpty(status))
{
info.Add("Status", status);
}
if (verbose)
{
if (vehicles[vehicleId].m_leadingVehicle == 0 && vehicles[vehicleId].m_trailingVehicle != 0)
{
ushort trailerCount = 0;
ushort trailerId = vehicles[vehicleId].m_trailingVehicle;
while (trailerId != 0 && trailerCount < ushort.MaxValue)
{
trailerId = vehicles[trailerId].m_trailingVehicle;
trailerCount++;
}
info.Add("TrailerCount", trailerCount);
}
info.Add("WaitCounter", vehicles[vehicleId].m_waitCounter);
info.Add("Position", vehicles[vehicleId].GetLastFramePosition());
if (Global.Vehicles != null)
{
if (Global.Vehicles.StuckVehicles != null)
{
StuckVehicleInfo stuckVehicle;
if (Global.Vehicles.StuckVehicles.TryGetValue(vehicleId, out stuckVehicle))
{
stuckVehicle.AddDebugInfoData(info);
}
}
}
}
info.Add("AI", vehicles[vehicleId].Info.m_vehicleAI.GetType().AssemblyQualifiedName);
return info;
}
/// <summary>
/// Adds the building information to the string information.
/// </summary>
/// <param name="vehicle">The vehicle.</param>
/// <param name="vehicles">The vehicles.</param>
/// <param name="buildings">The buildings.</param>
/// <param name="getHead">if set to <c>true</c> get for header instead of data.</param>
/// <param name="buildingId">The building identifier.</param>
/// <param name="buildingType">Type of the building.</param>
/// <param name="info">The information.</param>
private static void InfoStringInfoForBuilding(StuckVehicleInfo vehicle, Vehicle[] vehicles, Building[] buildings, bool getHead, ushort buildingId, string buildingType, Log.InfoList info)
{
if (getHead)
{
info.Add("[" + buildingType + "]", "<buildingId>", "[BuildingName]", "[districtId]", "[DistrictName]");
return;
}
if (buildingId == 0)
{
return;
}
byte districtId = BuildingHelper.GetDistrict(buildingId);
if (districtId == 0)
{
info.Add(
buildingType,
buildingId,
BuildingHelper.GetBuildingName(vehicles[vehicle.VehicleId].m_sourceBuilding));
}
else
{
info.Add(
buildingType,
buildingId,
BuildingHelper.GetBuildingName(vehicles[vehicle.VehicleId].m_sourceBuilding),
districtId,
DistrictHelper.GetDistrictName(districtId));
}
}
/// <summary>
/// Logs the component data.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="block">The block.</param>
/// <param name="component">The component.</param>
/// <param name="componentName">Name of the component.</param>
/// <param name="connectedName">Name of the connected component.</param>
/// <param name="depth">The recursion depth.</param>
private static void LogComponent(object source, string block, UIComponent component, string componentName, string connectedName, int depth)
{
string componentPath = null;
try
{
if (component != null && component is UIComponent)
{
Log.InfoList info = new Log.InfoList();
componentPath = componentName;
if (String.IsNullOrEmpty(componentPath))
{
componentPath = component.cachedName;
if (String.IsNullOrEmpty(componentPath))
{
componentPath = "?";
}
}
if (!String.IsNullOrEmpty(connectedName))
{
componentPath = connectedName + "/" + componentPath;
}
try
{
foreach (var property in component.GetType().GetProperties())
{
if (property != null)
{
try
{
info.Add(property.Name, property.GetValue(component, null));
}
catch
{
}
}
}
}
catch
{
}
Log.Debug(source, block, depth, componentPath, component.GetType(), component, info);
if (depth < 32)
{
depth++;
foreach (UIComponent child in component.components)
{
if (child != null)
{
LogComponent(source, block, child, null, componentPath, depth);
}
}
}
}
}
catch (Exception ex)
{
if (String.IsNullOrEmpty(componentPath))
{
Log.Debug(source, block, connectedName, componentName, ex.GetType(), ex.Message);
}
else
{
Log.Debug(source, block, componentPath, ex.GetType(), ex.Message);
}
}
}
/// <summary>
/// Collects building info for debug use.
/// </summary>
/// <param name="buildings">The buildings.</param>
/// <param name="vehicles">The vehicles.</param>
/// <param name="districtManager">The district manager.</param>
/// <param name="citizenManager">The citizen manager.</param>
/// <param name="buildingId">The building identifier.</param>
/// <param name="serviceBuilding">The service building.</param>
/// <param name="targetBuilding">The target building.</param>
/// <param name="buildingStamp">The building stamp.</param>
/// <param name="verbose">If set to <c>true</c> include more information.</param>
/// <returns>The debug information.</returns>
private static Log.InfoList DebugInfoMsg(
Building[] buildings,
Vehicle[] vehicles,
DistrictManager districtManager,
CitizenManager citizenManager,
ushort buildingId,
ServiceBuildingInfo serviceBuilding,
TargetBuildingInfo targetBuilding,
BuildingStamp buildingStamp,
bool verbose = false)
{
Log.InfoList info = new Log.InfoList();
if (buildingStamp != null)
{
info.Add("O", "BuildingStamp");
}
if (serviceBuilding != null)
{
info.Add("O", "ServiceBuilding");
}
if (targetBuilding != null)
{
info.Add("O", "TargetBuilding");
}
List<TargetBuildingInfo> targetBuildings = null;
List<ServiceBuildingInfo> serviceBuildings = null;
if (verbose && Global.Buildings != null)
{
targetBuildings = new List<TargetBuildingInfo>();
serviceBuildings = new List<ServiceBuildingInfo>();
if (serviceBuilding == null)
{
if (Global.Buildings.GarbageBuildings == null || !Global.Buildings.GarbageBuildings.TryGetValue(buildingId, out serviceBuilding))
{
serviceBuildings.Add(serviceBuilding);
}
if (Global.Buildings.DeathCareBuildings == null || !Global.Buildings.DeathCareBuildings.TryGetValue(buildingId, out serviceBuilding))
{
serviceBuildings.Add(serviceBuilding);
}
if (Global.Buildings.HealthCareBuildings == null || !Global.Buildings.HealthCareBuildings.TryGetValue(buildingId, out serviceBuilding))
{
serviceBuildings.Add(serviceBuilding);
}
}
if (targetBuilding == null)
{
if (Global.Buildings.DeadPeopleBuildings == null || !Global.Buildings.DeadPeopleBuildings.TryGetValue(buildingId, out targetBuilding))
{
targetBuildings.Add(targetBuilding);
}
if (Global.Buildings.DirtyBuildings == null || !Global.Buildings.DirtyBuildings.TryGetValue(buildingId, out targetBuilding))
{
targetBuildings.Add(targetBuilding);
}
if (Global.Buildings.SickPeopleBuildings == null || !Global.Buildings.SickPeopleBuildings.TryGetValue(buildingId, out targetBuilding))
{
targetBuildings.Add(targetBuilding);
}
}
}
info.Add("BuildingId", buildingId);
info.Add("AI", buildings[buildingId].Info.m_buildingAI.GetType());
info.Add("InfoName", buildings[buildingId].Info.name);
string name = GetBuildingName(buildingId);
if (!String.IsNullOrEmpty(name) && name != buildings[buildingId].Info.name)
{
info.Add("BuildingName", name);
}
byte district = districtManager.GetDistrict(buildings[buildingId].m_position);
info.Add("District", district);
info.Add("DistrictName", districtManager.GetDistrictName(district));
if (buildingStamp != null)
{
info.Add("Source", buildingStamp.Source);
info.Add("SimulationTimeStamp", buildingStamp.SimulationTimeStamp);
info.Add("SimulationTimeDelta", buildingStamp.SimulationTimeDelta);
}
if (serviceBuilding != null)
{
info.Add("CanReceive", serviceBuilding.CanReceive);
info.Add("CapacityLevel", serviceBuilding.CapacityLevel);
info.Add("CapactyFree", serviceBuilding.CapacityFree);
info.Add("CapactyMax", serviceBuilding.CapacityMax);
info.Add("CapactyOverflow", serviceBuilding.CapacityOverflow);
info.Add("Range", serviceBuilding.Range);
info.Add("VehiclesFree", serviceBuilding.VehiclesFree);
info.Add("VehiclesSpare", serviceBuilding.VehiclesSpare);
info.Add("VehiclesMade", serviceBuilding.VehiclesMade);
info.Add("VehiclesTotal", serviceBuilding.VehiclesTotal);
}
if (serviceBuildings != null)
{
for (int i = 0; i < serviceBuildings.Count; i++)
{
serviceBuilding = serviceBuildings[i];
string n = (i + 1).ToString();
info.Add("CanReceive" + n, serviceBuilding.CanReceive);
info.Add("CapacityLevel" + n, serviceBuilding.CapacityLevel);
info.Add("CapactyFree" + n, serviceBuilding.CapacityFree);
info.Add("CapactyMax" + n, serviceBuilding.CapacityMax);
info.Add("CapactyOverflow" + n, serviceBuilding.CapacityOverflow);
info.Add("Range" + n, serviceBuilding.Range);
info.Add("VehiclesFree" + n, serviceBuilding.VehiclesFree);
info.Add("VehiclesSpare" + n, serviceBuilding.VehiclesSpare);
info.Add("VehiclesMade" + n, serviceBuilding.VehiclesMade);
info.Add("VehiclesTotal" + n, serviceBuilding.VehiclesTotal);
}
}
if (targetBuilding != null)
{
info.Add("Demand", targetBuilding.Demand);
info.Add("HasProblem", targetBuilding.HasProblem);
info.Add("ProblemSize", targetBuilding.ProblemSize);
info.Add("ProblemValue", targetBuilding.ProblemValue);
}
if (targetBuildings != null)
{
for (int i = 0; i < targetBuildings.Count; i++)
{
targetBuilding = targetBuildings[i];
string n = (i + 1).ToString();
info.Add("Demand" + n, targetBuilding.Demand);
info.Add("HasProblem" + n, targetBuilding.HasProblem);
info.Add("ProblemSize" + n, targetBuilding.ProblemSize);
info.Add("ProblemValue" + n, targetBuilding.ProblemValue);
}
}
if (verbose && Global.Buildings != null)
{
Double desolate;
if (Global.Buildings.DesolateBuildings != null && Global.Buildings.DesolateBuildings.TryGetValue(buildingId, out desolate))
{
info.Add("Desolate", desolate);
}
}
int materialMax = 0;
int materialAmount = 0;
int serviceVehicleCount = 0;
if (buildings[buildingId].Info.m_buildingAI is CemeteryAI)
{
serviceVehicleCount = ((CemeteryAI)buildings[buildingId].Info.m_buildingAI).m_hearseCount;
info.Add("CorpseCapacity", ((CemeteryAI)buildings[buildingId].Info.m_buildingAI).m_corpseCapacity);
info.Add("GraveCount", ((CemeteryAI)buildings[buildingId].Info.m_buildingAI).m_graveCount);
info.Add("CustomBuffer1", buildings[buildingId].m_customBuffer1); // GraveCapacity?
info.Add("CustomBuffer2", buildings[buildingId].m_customBuffer2);
info.Add("PR_HC_Calc", ((buildings[buildingId].m_productionRate * ((CemeteryAI)buildings[buildingId].Info.m_buildingAI).m_hearseCount) + 99) / 100); // Hearse capacity?
buildings[buildingId].Info.m_buildingAI.GetMaterialAmount(buildingId, ref buildings[buildingId], TransferManager.TransferReason.Dead, out materialAmount, out materialMax);
}
else if (buildings[buildingId].Info.m_buildingAI is LandfillSiteAI)
{
serviceVehicleCount = ((LandfillSiteAI)buildings[buildingId].Info.m_buildingAI).m_garbageTruckCount;
buildings[buildingId].Info.m_buildingAI.GetMaterialAmount(buildingId, ref buildings[buildingId], TransferManager.TransferReason.Garbage, out materialAmount, out materialMax);
}
else if (buildings[buildingId].Info.m_buildingAI is HospitalAI)
{
serviceVehicleCount = ((HospitalAI)buildings[buildingId].Info.m_buildingAI).m_ambulanceCount;
info.Add("", ((HospitalAI)buildings[buildingId].Info.m_buildingAI).m_patientCapacity);
buildings[buildingId].Info.m_buildingAI.GetMaterialAmount(buildingId, ref buildings[buildingId], TransferManager.TransferReason.Sick, out materialAmount, out materialMax);
}
info.Add("materialMax", materialMax);
info.Add("materialAmount", materialAmount);
info.Add("materialFree", materialMax - materialAmount);
int productionRate = buildings[buildingId].m_productionRate;
ushort ownVehicleCount = 0;
ushort madeVehicleCount = 0;
ushort vehicleId = buildings[buildingId].m_ownVehicles;
while (vehicleId != 0 && ownVehicleCount < ushort.MaxValue)
{
ownVehicleCount++;
if ((vehicles[vehicleId].m_transferType == (byte)TransferManager.TransferReason.Garbage || vehicles[vehicleId].m_transferType == (byte)TransferManager.TransferReason.Dead) &&
vehicles[vehicleId].Info != null &&
(vehicles[vehicleId].m_flags & Vehicle.Flags.Created) == Vehicle.Flags.Created &&
(vehicles[vehicleId].m_flags & VehicleHelper.VehicleExists) != ~Vehicle.Flags.All)
{
madeVehicleCount++;
}
vehicleId = vehicles[vehicleId].m_nextOwnVehicle;
}
info.Add("OwnVehicles", ownVehicleCount);
info.Add("MadeVehicles", madeVehicleCount);
info.Add("VehicleCount", serviceVehicleCount);
info.Add("ProductionRate", productionRate);
info.Add("VehicleCountNominal", ((productionRate * serviceVehicleCount) + 99) / 100);
int budget = Singleton<EconomyManager>.instance.GetBudget(buildings[buildingId].Info.m_buildingAI.m_info.m_class);
productionRate = PlayerBuildingAI.GetProductionRate(100, budget);
int actualVehicleCount = ((productionRate * serviceVehicleCount) + 99) / 100;
info.Add("Budget", budget);
info.Add("ProductionRateActual", productionRate);
info.Add("VehicleCountActual", actualVehicleCount);
info.Add("SpareVehicles", actualVehicleCount - ownVehicleCount);
float range = buildings[buildingId].Info.m_buildingAI.GetCurrentRange(buildingId, ref buildings[buildingId]);
range = range * range * Global.Settings.RangeModifier;
if (range < Global.Settings.RangeMinimum)
{
info.Add("Range", range, Global.Settings.RangeMinimum);
}
else if (range > Global.Settings.RangeMaximum)
{
info.Add("Range", range, Global.Settings.RangeMaximum);
}
else
{
info.Add("Range", range);
}
List<string> needs = new List<string>();
if (buildings[buildingId].m_garbageBuffer >= Global.Settings.Garbage.MinimumAmountForDispatch)
{
needs.Add("Filthy");
}
if (buildings[buildingId].m_garbageBuffer >= Global.Settings.Garbage.MinimumAmountForPatrol)
{
needs.Add("Dirty");
}
else if (buildings[buildingId].m_garbageBuffer > 0)
{
needs.Add("Dusty");
}
if (buildings[buildingId].m_deathProblemTimer > 0)
{
needs.Add("Dead");
}
if (buildings[buildingId].m_garbageBuffer * Dispatcher.ProblemBufferModifier >= Dispatcher.ProblemLimitForgotten ||
buildings[buildingId].m_deathProblemTimer * Dispatcher.ProblemTimerModifier >= Dispatcher.ProblemLimitForgotten)
{
needs.Add("Forgotten");
}
info.Add("Needs", needs);
info.Add("DeathProblemTimer", buildings[buildingId].m_deathProblemTimer);
info.Add("HealthProblemTimer", buildings[buildingId].m_healthProblemTimer);
info.Add("MajorProblemTimer", buildings[buildingId].m_majorProblemTimer);
int citizens = 0;
int count = 0;
uint unitId = buildings[buildingId].m_citizenUnits;
while (unitId != 0)
{
CitizenUnit unit = citizenManager.m_units.m_buffer[unitId];
for (int i = 0; i < 5; i++)
{
uint citizenId = unit.GetCitizen(i);
if (citizenId != 0)
{
Citizen citizen = citizenManager.m_citizens.m_buffer[citizenId];
if (citizen.Dead && citizen.GetBuildingByLocation() == buildingId)
{
citizens++;
}
}
}
count++;
if (count > (int)ushort.MaxValue * 10)
{
break;
}
unitId = unit.m_nextUnit;
}
info.Add("DeadCitizens", citizens);
info.Add("GarbageAmount", buildings[buildingId].Info.m_buildingAI.GetGarbageAmount(buildingId, ref buildings[buildingId]));
info.Add("GarbageBuffer", buildings[buildingId].m_garbageBuffer);
string problems = buildings[buildingId].m_problems.ToString();
if (problems.IndexOfAny(new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }) >= 0)
{
foreach (Notification.Problem problem in Enum.GetValues(typeof(Notification.Problem)))
{
if (problem != Notification.Problem.None && (buildings[buildingId].m_problems & problem) == problem)
{
problems += ", " + problem.ToString();
}
}
}
info.Add("Problems", problems);
string flags = buildings[buildingId].m_flags.ToString();
if (flags.IndexOfAny(new char[] { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' }) >= 0)
{
foreach (Building.Flags flag in Enum.GetValues(typeof(Building.Flags)))
{
if (flag != Building.Flags.None && (buildings[buildingId].m_flags & flag) == flag)
{
flags += ", " + flag.ToString();
}
}
}
info.Add("Flags", flags);
string status = buildings[buildingId].Info.m_buildingAI.GetLocalizedStatus(buildingId, ref buildings[buildingId]);
if (!String.IsNullOrEmpty(status))
{
info.Add("Status", status);
}
info.Add("AI", buildings[buildingId].Info.m_buildingAI.GetType().AssemblyQualifiedName);
return info;
}
