private static void ScanPrefabs(ZoneSystem __instance)
{
var prefabs = ZNetScene.instance.m_prefabs;
{
var prefabsWithDropTables = new List <Tuple <GameObject, CharacterDrop> >();
foreach (var prefab in prefabs)
{
var characterDrop = prefab.GetComponent <CharacterDrop>();
if (characterDrop)
{
prefabsWithDropTables.Add(new Tuple <GameObject, CharacterDrop>(prefab, characterDrop));
}
}
if (ConfigurationManager.GeneralConfig?.WriteCharacterDropsToFile?.Value == true)
{
CharacterDropFileWriter.WriteToFile(prefabsWithDropTables);
}
if (ConfigurationManager.GeneralConfig?.WriteCreatureItemsToFile?.Value == true)
{
CreatureItemFileWriter.WriteToFile(prefabsWithDropTables);
}
}
}
public void HouseholdIterationComplete(ITashaHousehold household, int hhldIteration, int totalHouseholdIterations)
{
foreach (var person in household.Persons)
{
if (person.Age < MinimumAge)
{
continue;
}
var expansionFactor = person.ExpansionFactor;
foreach (var tripChain in person.TripChains)
{
foreach (var trip in tripChain.Trips)
{
var tripTime = trip.TripStartTime;
if (tripTime >= StartTime && tripTime < EndTime)
{
var index = GetIndex(trip.Mode);
var oIndex = ZoneSystem.GetFlatIndex(trip.OriginalZone.ZoneNumber);
var dIndex = ZoneSystem.GetFlatIndex(trip.DestinationZone.ZoneNumber);
if (oIndex >= 0 & dIndex >= 0)
{
bool taken = false;
DataLock[index].Enter(ref taken);
if (taken)
{
Data[index][oIndex][dIndex] += expansionFactor;
DataLock[index].Exit(true);
}
}
}
}
}
}
}
public void Start()
{
if (FirstLoad)
{
ZoneSystem.LoadData();
foreach (var network in NetworkData)
{
network.LoadData();
}
TourLoader.LoadData();
FirstLoad = false;
}
// the model needs to be loaded every time
AccessStationChoiceModel.Load();
var tours = TourLoader.ToArray();
float result = ComputeError(tours);
Completed = 0;
// ReSharper disable once PossibleLossOfFraction
_Progress = () => Completed / tours.Length;
Root.RetrieveValue = () =>
{
return(result);
};
if (ConfusionMatrix != null)
{
ProduceConfusionMatrix(tours);
}
_Progress = () => 1.0f;
}
public void IterationFinished(int iteration, int totalIterations)
{
var zones = ZoneSystem.ValidIndexArray();
using (StreamWriter writer = new StreamWriter(SaveLocation))
{
writer.WriteLine("Mode,Origin,Destination,ExpandedTrips");
for (int m = 0; m < Data.Length; m++)
{
string modeName = Modes[m].ModeName + ",";
var oRow = Data[m];
for (int o = 0; o < oRow.Length; o++)
{
var dRow = oRow[o];
for (int d = 0; d < dRow.Length; d++)
{
if (dRow[d] > 0)
{
// this includes the comma already
writer.Write(modeName);
writer.Write(zones[o]);
writer.Write(',');
writer.Write(zones[d]);
writer.Write(',');
writer.WriteLine(dRow[d]);
}
}
}
}
}
Data = null;
}
// Token: 0x0600107E RID: 4222 RVA: 0x00074C6C File Offset: 0x00072E6C
private static List <DungeonDB.RoomData> SetupRooms()
{
GameObject[] array = Resources.FindObjectsOfTypeAll <GameObject>();
GameObject gameObject = null;
foreach (GameObject gameObject2 in array)
{
if (gameObject2.name == "_Rooms")
{
gameObject = gameObject2;
break;
}
}
if (gameObject == null || (DungeonDB.m_instance && gameObject.activeSelf))
{
if (DungeonDB.m_instance)
{
DungeonDB.m_instance.m_error = true;
}
ZLog.LogError("Rooms are f****d, missing _Rooms or its enabled");
}
List <DungeonDB.RoomData> list = new List <DungeonDB.RoomData>();
for (int j = 0; j < gameObject.transform.childCount; j++)
{
Room component = gameObject.transform.GetChild(j).GetComponent <Room>();
DungeonDB.RoomData roomData = new DungeonDB.RoomData();
roomData.m_room = component;
ZoneSystem.PrepareNetViews(component.gameObject, roomData.m_netViews);
ZoneSystem.PrepareRandomSpawns(component.gameObject, roomData.m_randomSpawns);
list.Add(roomData);
}
return(list);
}
static void Prefix(ZoneSystem __instance, Dictionary <Vector2i, ZoneSystem.LocationInstance> ___m_locationInstances)
{
if (!modEnabled.Value)
{
return;
}
Dbgl($"Starting ZoneSystem, relocating merchant");
for (int i = 0; i < ___m_locationInstances.Count; i++)
{
Vector2i v = ___m_locationInstances.Keys.ToArray()[i];
ZoneSystem.LocationInstance loc = ___m_locationInstances[v];
if (loc.m_location.m_prefabName == "Vendor_BlackForest")
{
if (merchantPosition.Value != Vector3.zero)
{
___m_locationInstances.Remove(v);
loc.m_position = merchantPosition.Value;
Vector2i zone = __instance.GetZone(merchantPosition.Value);
}
break;
}
}
}
public void Start()
{
if (ZoneSystem != null)
{
ZoneSystem.LoadData();
}
int i = 0;
_Progress = () =>
{
if (i < ToExecute.Length)
{
return(((float)i / ToExecute.Length) + (1.0f / ToExecute.Length) * ToExecute[i].Progress);
}
return(1.0f);
};
_Status = () =>
{
return(ToExecute[i].ToString());
};
for (; i < ToExecute.Length; i++)
{
ToExecute[i].Start();
}
if (ZoneSystem != null)
{
ZoneSystem.UnloadData();
}
}
public void Start()
{
if (FirstTime || LoadTruthEveryTime)
{
ZoneSystem.LoadData();
foreach (var network in NetworkData)
{
network.LoadData();
}
truth = TruthData.AcquireResource <SparseTwinIndex <float> >().GetFlatData();
TruthData.ReleaseResource();
}
var model = ModelData.AcquireResource <SparseTriIndex <float> >().GetFlatData();
var zones = ZoneSystem.ZoneArray.GetFlatData();
// sum up the truth
if (FirstTime || LoadTruthEveryTime)
{
// we only need to do this once
TruthRows = (from row in truth
select row.Sum()).ToArray();
InverseOfTotalTrips = 1.0f / TruthRows.Sum();
if (AggregateToPlanningDistricts)
{
PDError = ZoneSystemHelper.CreatePDTwinArray <float>(ZoneSystem.ZoneArray);
ZoneToPDIndexMap = (from zone in zones
select PDError.GetFlatIndex(zone.PlanningDistrict)).ToArray();
// transform the truth to be PD based
truth = AggregateResults((new float[][][] { truth }), zones)
.Select(row => row.Select(element => element).ToArray()).ToArray();
}
FirstTime = false;
}
var aggregated = AggregateResults(model, zones);
// calculate the error
float error = ComputeError(truth, aggregated);
// set the value in the root
Root.RetrieveValue = () => error;
if (ModelSaveFile != null)
{
SaveData.SaveMatrix(zones, AggregateResults(model, zones), ModelSaveFile);
}
if (this.DistanceHistogram != null)
{
var distances = ZoneSystem.Distances.GetFlatData();
this.DistanceHistogram.Export(distances, model);
}
ModelData.ReleaseResource();
for (int i = 0; i < PostRun.Length; i++)
{
PostRun[i].Start();
}
}
private static void AddCustomMobs(On.ZoneSystem.orig_Awake orig, ZoneSystem self)
{
orig(self);
var spawnSystem = self.m_zoneCtrlPrefab.GetComponent <SpawnSystem>();
OnAfterInit.SafeInvoke(spawnSystem);
OnAfterInit = null;
}
private static void SpawnZone_Postfix(ZoneSystem __instance, Vector2i zoneID, GameObject root)
{
if (!(root == null))
{
HMAPManager.SetGameObject(zoneID, root.GetComponentInChildren <Heightmap>().gameObject);
HMAPManager.SetHeightmap(zoneID, root.GetComponentInChildren <Heightmap>());
HMAPManager.CalcTMods(zoneID);
HMAPManager.GetZoneInfo(zoneID).hmap.Regenerate();
}
}
private static void PrintLocations(ZoneSystem __instance)
{
if (__instance.m_locations is null)
{
return;
}
if (ConfigurationManager.GeneralConfig.WriteLocationsToFile)
{
LocationsFileWriter.WriteToList(__instance.m_locations);
}
}
private static void ScanAndWriteLocations(ZoneSystem __instance)
{
if (__instance.m_locations is null)
{
return;
}
if (ConfigurationManager.GeneralConfig?.WriteCreatureSpawnersToFile?.Value == true)
{
CreatureSpawnerFileDumper.WriteToFile(__instance.m_locations);
}
}
public void Execute(ITashaHousehold household, int iteration)
{
lock (this)
{
var householdZone = ZoneSystem.GetFlatIndex(household.HomeZone.ZoneNumber);
Households.Add(household);
foreach (var pool in PopulationPools)
{
pool.AddIfContained(household, householdZone, Households.Count - 1);
}
}
}
private static void LocationAwake_Postfix(ZoneSystem __instance, GameObject __result, Vector3 pos)
{
Vector2i zone2 = ZoneSystem.instance.GetZone(pos);
BetterTerrain.ZoneInfo zone = HMAPManager.GetZoneInfo(zone2);
if (HMAPManager.IsZoneKnown(zone2))
{
if (zone.has_location)
{
zone.hmap.Regenerate();
}
zone.has_location = true;
}
}
private static bool GenerateLocationsPrefix(ZoneSystem __instance, ZoneSystem.ZoneLocation location)
{
var groupName = string.IsNullOrEmpty(location.m_group) ? "<unnamed>" : location.m_group;
Log($"Generating location of group {groupName}, required {location.m_quantity}, unique {location.m_unique}, name {location.m_prefabName}");
if (Settings.EnabledForThisWorld)
{
if (Settings.HasSpawnmap)
{
// Place all locations specified by the spawn map, ignoring counts specified in the prefab
int placed = 0;
foreach (var normalizedPosition in Settings.GetAllSpawns(location.m_prefabName))
{
var worldPos = NormalizedToWorld(normalizedPosition);
var position = new Vector3(
worldPos.x,
WorldGenerator.instance.GetHeight(worldPos.x, worldPos.y),
worldPos.y
);
RegisterLocation(__instance, location, position, false);
Log($"Position of {location.m_prefabName} ({++placed}/{location.m_quantity}) overriden: set to {position}");
}
// The vanilla placement algorithm considers already placed zones, but we can early out here anyway if we place them all
// (this is required in the case of the StartTemple as we don't want to place it twice if OverrideStartPosition is specified)
if (placed >= location.m_quantity)
{
return(false);
}
}
if (Settings.OverrideStartPosition && location.m_prefabName == "StartTemple")
{
var position = new Vector3(
Settings.StartPositionX,
WorldGenerator.instance.GetHeight(Settings.StartPositionX, Settings.StartPositionY),
Settings.StartPositionY
);
RegisterLocation(__instance, location, position, false);
Log($"Start position overriden: set to {position}");
return(false);
}
if (location.m_prefabName != "StartTemple" && ConfigDebugSkipDefaultLocationPlacement.Value)
{
return(false);
}
}
return(true);
}
private void AddToMatrix(float expFactor, Time startTime, IZone origin, IZone destination)
{
if (startTime >= StartTime & startTime < EndTime)
{
var originIndex = ZoneSystem.GetFlatIndex(origin.ZoneNumber);
var destinationIndex = ZoneSystem.GetFlatIndex(destination.ZoneNumber);
bool gotLock = false;
WriteLock.Enter(ref gotLock);
Matrix[originIndex][destinationIndex] += expFactor;
if (gotLock)
{
WriteLock.Exit(true);
}
}
}
public void Start()
{
ZoneSystem.LoadData();
for (int i = 0; i < PreRun.Length; i++)
{
_status = () => PreRun[i].ToString();
PreRun[i].Start();
}
foreach (var model in RunYearly)
{
_status = () => model.ToString();
model.BeforeFirstYear(StartYear);
}
for (int year = 0; year < NumberOfYears && !_exit; year++)
{
for (int i = 0; i < RunYearly.Length && !_exit; i++)
{
_status = () => RunYearly[i].ToString();
RunYearly[i].BeforeYearlyExecute(StartYear + year);
}
for (int i = 0; i < RunYearly.Length && !_exit; i++)
{
_status = () => (year + this.StartYear) + ": " + RunYearly[i].ToString();
Progress = (float)year / NumberOfYears + (1.0f / NumberOfYears) * ((float)i / RunYearly.Length);
RunYearly[i].Execute(StartYear + year);
}
for (int i = 0; i < RunYearly.Length && !_exit; i++)
{
_status = () => RunYearly[i].ToString();
RunYearly[i].AfterYearlyExecute(StartYear + year);
}
}
foreach (var model in RunYearly)
{
_status = () => model.ToString();
model.RunFinished(StartYear + NumberOfYears - 1);
}
for (int i = 0; i < PostRun.Length; i++)
{
_status = () => PostRun[i].ToString();
PostRun[i].Start();
}
ZoneSystem.UnloadData();
}
public static bool HasGlobalKey(this ZoneSystem zoneSystem, string playerName, string key)
{
HashSet <string> globalKeys = _globalKeysField.GetValue(zoneSystem) as HashSet <string>;
#if DEBUG
Log.LogDebug($"Checking for {key} in keys: " + globalKeys.Join());
#endif
if (globalKeys is null)
{
Log.LogWarning("Unable to find/access global keys.");
return(false);
}
if (Enum.TryParse(ConfigurationManager.GeneralConfig.KeyMode.Value, true, out KeyMode keyMode))
{
switch (keyMode)
{
case KeyMode.Player:
#if DEBUG
Log.LogDebug($"Checking key {key} for player {playerName}");
#endif
return(EnhancedGlobalKey.HasPlayerKey(playerName, key, globalKeys));
case KeyMode.Tribe:
#if DEBUG
Log.LogDebug($"Checking key {key} for tribe of {playerName}");
#endif
return(EnhancedGlobalKey.HasTribeKey(playerName, key, globalKeys));
default:
return(globalKeys.Contains(key));
}
}
//If no key-mode is set, use default global keys.
Log.LogWarning("Unable to find valid key-mode configuration. Will fallback to Default mode.");
return(globalKeys.Contains(key));
}
static void Postfix(ref ZoneSystem __instance, ref bool __result, PrefixState __state)
{
if (__result)
{
return;
}
if (__state.isDungeon)
{
var locationInstances = AccessTools.FieldRefAccess <ZoneSystem, Dictionary <Vector2i, ZoneSystem.LocationInstance> >(__instance, "m_locationInstances");
foreach (ZoneSystem.LocationInstance locationInstance in locationInstances.Values)
{
var prefabName = locationInstance.m_location.m_prefabName;
if ((IsDungeon(prefabName) || IsTrollCave(prefabName)) &&
Vector3.Distance(locationInstance.m_position, __state.point) < __state.radius)
{
__result = true;
return;
}
}
}
return;
}
public void Start()
{
if (ZoneSystem != null)
{
ZoneSystem.LoadData();
}
int i = 0;
_Progress = () =>
{
if (i < ToExecute.Length)
{
return(((float)i / ToExecute.Length) + (1.0f / ToExecute.Length) * ToExecute[i].Progress);
}
return(1.0f);
};
_Status = () =>
{
return(ToExecute[i].ToString());
};
Parallel.For(0, NetworkData.Count, (int n) =>
{
NetworkData[n].LoadData();
});
for (; i < ToExecute.Length; i++)
{
ToExecute[i].Start();
}
Parallel.For(0, NetworkData.Count, (int n) =>
{
NetworkData[n].UnloadData();
});
if (ZoneSystem != null)
{
ZoneSystem.UnloadData();
}
}
private static void ReplaceHeightmapTextures()
{
Dbgl($"Reloading Heightmap textures for {Heightmap.GetAllHeightmaps().Count} heightmaps");
ZoneSystem zoneSystem = (ZoneSystem)typeof(ZoneSystem).GetField("m_instance", BindingFlags.NonPublic | BindingFlags.Static).GetValue(null);
logDump.Clear();
Heightmap hm = (Heightmap)typeof(EnvMan).GetField("m_cachedHeightmap", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(EnvMan.instance);
if (hm != null)
{
Material mat = hm.m_material;
if (mat != null)
{
outputDump.Add($"terrain {zoneSystem.name}, prefab {zoneSystem.m_zonePrefab}");
ReplaceMaterialTextures(zoneSystem.m_zonePrefab.name, mat, zoneSystem.name, "terrain", "Terrain", zoneSystem.m_zonePrefab.name);
hm.Regenerate();
}
}
foreach (Heightmap h in Heightmap.GetAllHeightmaps())
{
Material mat = h.m_material;
if (mat != null)
{
outputDump.Add($"terrain {zoneSystem.name}, prefab {zoneSystem.m_zonePrefab}");
ReplaceMaterialTextures(zoneSystem.m_zonePrefab.name, mat, zoneSystem.name, "terrain", "Terrain", zoneSystem.m_zonePrefab.name);
}
}
if (logDump.Any())
{
Dbgl("\n" + string.Join("\n", logDump));
}
}
private static void ReplaceZoneSystemTextures(ZoneSystem __instance)
{
Dbgl($"Reloading ZoneSystem textures {__instance.name} {__instance.m_zonePrefab.name}");
ReplaceOneZoneTextures(__instance.name, __instance.m_zonePrefab);
}
public void Start()
{
if (!ZoneSystem.Loaded)
{
ZoneSystem.LoadData();
}
var truth = TruthData.AcquireResource <SparseTriIndex <float> >().GetFlatData();
if (first)
{
TotalTruth = truth.Select(category => category.Sum(row => VectorHelper.Sum(row, 0, row.Length))).ToArray();
TotalTruthByZone = new float[TotalTruth.Length][];
for (int category = 0; category < TotalTruth.Length; category++)
{
TotalTruthByZone[category] = new float[truth[category].Length];
//normalize the truth data
Parallel.For(0, truth[category].Length, (int i) =>
{
float[] truthRow = truth[category][i];
TotalTruthByZone[category][i] = VectorHelper.Sum(truthRow, 0, truthRow.Length);
VectorHelper.Multiply(truthRow, 0, truthRow, 0, 1.0f / TotalTruth[category], truthRow.Length);
});
}
for (int i = 0; i < NetworkData.Count; i++)
{
NetworkData[i].LoadData();
}
first = false;
}
var model = ModelData.AcquireResource <SparseTriIndex <float> >().GetFlatData();
ModelData.ReleaseResource();
// Normalize the model data
float[] modelTotalByCategory = model.Select(cateogry => cateogry.Sum(row => VectorHelper.Sum(row, 0, row.Length))).ToArray();
for (int category = 0; category < modelTotalByCategory.Length; category++)
{
//normalize the truth data
Parallel.For(0, model[category].Length, (int i) =>
{
float[] modelRow = model[category][i];
VectorHelper.Multiply(modelRow, 0, modelRow, 0, 1.0f / modelTotalByCategory[category], modelRow.Length);
});
}
float fitness = 0.0f;
for (int category = 0; category < truth.Length; category++)
{
Parallel.For(0, truth[category].Length,
() =>
{
return(new float[truth[category].Length]);
},
(int i, ParallelLoopState _, float[] errorForHomeZone) =>
{
var observedLinkagesForZone = TotalTruthByZone[category][i];
var truthRow = truth[category][i];
var modelRow = model[category][i];
if (observedLinkagesForZone > 0.0f)
{
var local = 0.0f;
for (int j = 0; j < truthRow.Length; j++)
{
local += (truthRow[j] * (float)Math.Max(Math.Log(modelRow[j]), MaximumError));
}
errorForHomeZone[i] += observedLinkagesForZone * local;
}
return(errorForHomeZone);
},
(float[] errorData) =>
{
var sumOfError = VectorHelper.Sum(errorData, 0, errorData.Length);
lock (this)
{
fitness += sumOfError;
}
});
}
Root.RetrieveValue = () => VectorHelper.Sum(TotalTruth, 0, TotalTruth.Length) * fitness;
}
static void Prefix(ZoneSystem __instance)
{
ReplaceZoneSystemTextures(__instance);
}
public void Start()
{
ZoneSystem.LoadData();
this.SelfContainedModule.Start();
ZoneSystem.UnloadData();
}
private int GetFlatIndex(IZone zone)
{
return(ZoneSystem.GetFlatIndex(zone.ZoneNumber));
}
static void Postfix(ZoneSystem __instance)
{
Vector3 startPos;
ZoneSystem.instance.GetLocationIcon("StartTemple", out startPos);
WebMapConfig.WORLD_START_POS = startPos;
if (mapDataServer.mapImageData != null)
{
Debug.Log("WebMap: MAP ALREADY BUILT!");
return;
}
Debug.Log("WebMap: BUILD MAP!");
int num = WebMapConfig.TEXTURE_SIZE / 2;
float num2 = WebMapConfig.PIXEL_SIZE / 2f;
Color32[] colorArray = new Color32[WebMapConfig.TEXTURE_SIZE * WebMapConfig.TEXTURE_SIZE];
Color32[] treeMaskArray = new Color32[WebMapConfig.TEXTURE_SIZE * WebMapConfig.TEXTURE_SIZE];
float[] heightArray = new float[WebMapConfig.TEXTURE_SIZE * WebMapConfig.TEXTURE_SIZE];
for (int i = 0; i < WebMapConfig.TEXTURE_SIZE; i++)
{
for (int j = 0; j < WebMapConfig.TEXTURE_SIZE; j++)
{
float wx = (float)(j - num) * WebMapConfig.PIXEL_SIZE + num2;
float wy = (float)(i - num) * WebMapConfig.PIXEL_SIZE + num2;
Heightmap.Biome biome = WorldGenerator.instance.GetBiome(wx, wy);
float biomeHeight = WorldGenerator.instance.GetBiomeHeight(biome, wx, wy);
colorArray[i * WebMapConfig.TEXTURE_SIZE + j] = GetPixelColor(biome);
treeMaskArray[i * WebMapConfig.TEXTURE_SIZE + j] = GetMaskColor(wx, wy, biomeHeight, biome);
heightArray[i * WebMapConfig.TEXTURE_SIZE + j] = biomeHeight;
}
}
var waterLevel = ZoneSystem.instance.m_waterLevel;
var sunDir = new Vector3(-0.57735f, 0.57735f, 0.57735f);
var newColors = new Color[colorArray.Length];
for (var t = 0; t < colorArray.Length; t++)
{
var h = heightArray[t];
var tUp = t - WebMapConfig.TEXTURE_SIZE;
if (tUp < 0)
{
tUp = t;
}
var tDown = t + WebMapConfig.TEXTURE_SIZE;
if (tDown > colorArray.Length - 1)
{
tDown = t;
}
var tRight = t + 1;
if (tRight > colorArray.Length - 1)
{
tRight = t;
}
var tLeft = t - 1;
if (tLeft < 0)
{
tLeft = t;
}
var hUp = heightArray[tUp];
var hRight = heightArray[tRight];
var hLeft = heightArray[tLeft];
var hDown = heightArray[tDown];
var va = new Vector3(2f, 0f, hRight - hLeft).normalized;
var vb = new Vector3(0f, 2f, hUp - hDown).normalized;
var normal = Vector3.Cross(va, vb);
var surfaceLight = Vector3.Dot(normal, sunDir) * 0.25f + 0.75f;
float shoreMask = Mathf.Clamp(h - waterLevel, 0, 1);
float shallowRamp = Mathf.Clamp((h - waterLevel + 0.2f * 12.5f) * 0.5f, 0, 1);
float deepRamp = Mathf.Clamp((h - waterLevel + 1f * 12.5f) * 0.1f, 0, 1);
var mapColor = colorArray[t];
Color ans = Color.Lerp(ShoreColor, mapColor, shoreMask);
ans = Color.Lerp(ShallowWaterColor, ans, shallowRamp);
ans = Color.Lerp(DeepWaterColor, ans, deepRamp);
newColors[t] = new Color(ans.r * surfaceLight, ans.g * surfaceLight, ans.b * surfaceLight, ans.a);
}
var newTexture = new Texture2D(WebMapConfig.TEXTURE_SIZE, WebMapConfig.TEXTURE_SIZE, TextureFormat.RGBA32, false);
newTexture.SetPixels(newColors);
byte[] pngBytes = newTexture.EncodeToPNG();
mapDataServer.mapImageData = pngBytes;
try {
File.WriteAllBytes(Path.Combine(worldDataPath, "map"), pngBytes);
} catch {
Debug.Log("WebMap: FAILED TO WRITE MAP FILE!");
}
Debug.Log("WebMap: BUILDING MAP DONE!");
}
static void Prefix(ZoneSystem __instance)
{
outputDump.Clear();
ReplaceZoneSystemTextures(__instance);
}
public void Start()
{
// setup the status to be initializing
_Status = null;
_Progress = () => 0f;
CurrentIteration = 0;
if (!VehicleTypes.Contains(AutoType))
{
VehicleTypes.Add(AutoType);
}
ZoneSystem.LoadData();
if (PreRun != null)
{
foreach (var module in PreRun)
{
module.Start();
}
}
IterationPercentage = 1f / TotalIterations;
if (PostScheduler != null)
{
foreach (var module in PostScheduler)
{
module.Load(TotalIterations);
}
}
if (PostHousehold != null)
{
foreach (var module in PostHousehold)
{
module.Load(TotalIterations);
}
}
if (OverrideModeParameters)
{
InitializeParameters();
}
LoadNetworkData(0);
if (Scheduler != null)
{
Scheduler.LoadOneTimeLocalData();
}
if (ModeChoice != null)
{
ModeChoice.LoadOneTimeLocalData();
}
for (int i = 0; i < TotalIterations; i++)
{
if (!_ExitRequested)
{
CurrentHousehold = 0;
CurrentIteration = i;
CompletedIterationPercentage = i * IterationPercentage;
if (LoadAllHouseholds)
{
if (!SkipLoadingHouseholds)
{
HouseholdLoader.LoadData();
}
}
RunIteration(i);
}
}
if (PostRun != null)
{
foreach (var module in PostRun)
{
module.Start();
}
}
ZoneSystem.UnloadData();
}
public static bool HasGlobalKey(this ZoneSystem zoneSystem, Player player, string key)
{
string playerName = player.GetHoverName();
return(HasGlobalKey(zoneSystem, playerName, key));
}