public Building(ActorInitializer init)
{
this.self = init.self;
this.topLeft = init.Get<LocationInit,int2>();
this.Info = self.Info.Traits.Get<BuildingInfo>();
this.PlayerPower = init.self.Owner.PlayerActor.Trait<PowerManager>();
}
public Transforms(ActorInitializer init, TransformsInfo info)
{
self = init.self;
this.info = info;
bi = self.World.Map.Rules.Actors[info.IntoActor].Traits.GetOrDefault<BuildingInfo>();
race = init.Contains<RaceInit>() ? init.Get<RaceInit, string>() : self.Owner.Country.Race;
}
public static bool IsCellBuildable(this World world, CPos a, BuildingInfo bi, Actor toIgnore)
{
if (world.WorldActor.Trait<BuildingInfluence>().GetBuildingAt(a) != null) return false;
if (world.ActorMap.GetUnitsAt(a).Any(b => b != toIgnore)) return false;
return world.Map.IsInMap(a) && bi.TerrainTypes.Contains(world.GetTerrainType(a));
}
public override void GetDecorationDirections(out bool negX, out bool posX, out bool negZ, out bool posZ, BuildingInfo info)
{
negX = (info.m_zoningMode == BuildingInfo.ZoningMode.CornerRight);
posX = (info.m_zoningMode == BuildingInfo.ZoningMode.CornerLeft);
negZ = false;
posZ = true;
}
public PlaceBuildingOrderGenerator(ProductionQueue queue, string name)
{
producer = queue.Actor;
placeBuildingInfo = producer.Owner.PlayerActor.Info.Traits.Get<PlaceBuildingInfo>();
building = name;
// Clear selection if using Left-Click Orders
if (Game.Settings.Game.UseClassicMouseStyle)
producer.World.Selection.Clear();
var map = producer.World.Map;
var tileset = producer.World.TileSet.Id.ToLowerInvariant();
var info = map.Rules.Actors[building];
buildingInfo = info.Traits.Get<BuildingInfo>();
var buildableInfo = info.Traits.Get<BuildableInfo>();
var mostLikelyProducer = queue.MostLikelyProducer();
race = buildableInfo.ForceRace ?? (mostLikelyProducer.Trait != null ? mostLikelyProducer.Trait.Race : producer.Owner.Faction.InternalName);
buildOk = map.SequenceProvider.GetSequence("overlay", "build-valid-{0}".F(tileset)).GetSprite(0);
buildBlocked = map.SequenceProvider.GetSequence("overlay", "build-invalid").GetSprite(0);
buildingInfluence = producer.World.WorldActor.Trait<BuildingInfluence>();
}
// Called every frame on building upgrade
public static BuildingInfo GetRandomBuildingInfo_Upgrade(Vector3 position, ushort prefabIndex, ref Randomizer r, ItemClass.Service service, ItemClass.SubService subService, ItemClass.Level level, int width, int length, BuildingInfo.ZoningMode zoningMode, int style)
{
// This method is very fragile, no logging here!
var districtId = Singleton<DistrictManager>.instance.GetDistrict(position);
// See if there is a special upgraded building
var buildingInfo = BuildingThemesManager.instance.GetUpgradeBuildingInfo(prefabIndex, districtId);
if (buildingInfo != null)
{
return buildingInfo;
}
var areaIndex = BuildingThemesManager.GetAreaIndex(service, subService, level, width, length, zoningMode);
// list of possible prefabs
var fastList = Singleton<BuildingThemesManager>.instance.GetAreaBuildings(districtId, areaIndex);
if (fastList == null || fastList.m_size == 0)
{
return (BuildingInfo)null;
}
// select a random prefab from the list
int index = r.Int32((uint)fastList.m_size);
return PrefabCollection<BuildingInfo>.GetPrefab((uint)fastList.m_buffer[index]);
}
public static bool CanPlaceBuilding(this World world, string name, BuildingInfo building, int2 topLeft, Actor toIgnore)
{
var res = world.WorldActor.Trait<ResourceLayer>();
return FootprintUtils.Tiles(name, building, topLeft).All(
t => world.Map.IsInMap(t.X, t.Y) && res.GetResource(t) == null &&
world.IsCellBuildable(t, building.WaterBound, toIgnore));
}
protected override bool IsPlacementRelevant(BuildingInfo info)
{
if (info.GetService() == ItemClass.Service.Residential)
{
return true;
}
return base.IsPlacementRelevant(info);
}
public List<HashSet<ushort>> GetMapping(BuildingInfo building)
{
int prefabID = building.m_prefabDataIndex;
if (!_mapping.PrefabMapped(prefabID))
CategorizePrefab(building);
return _mapping.GetMapping(prefabID);
}
public static bool CanPlaceBuilding(this World world, string name, BuildingInfo building, CPos topLeft, Actor toIgnore)
{
if (building.AllowInvalidPlacement)
return true;
var res = world.WorldActor.Trait<ResourceLayer>();
return FootprintUtils.Tiles(world.Map.Rules, name, building, topLeft).All(
t => world.Map.Contains(t) && res.GetResource(t) == null &&
world.IsCellBuildable(t, building, toIgnore));
}
public PlaceBuildingOrderGenerator(Actor producer, string name)
{
Producer = producer;
Building = name;
var tileset = producer.World.TileSet.Id.ToLower();
BuildingInfo = Rules.Info[Building].Traits.Get<BuildingInfo>();
buildOk = SequenceProvider.GetSequence("overlay", "build-valid-{0}".F(tileset)).GetSprite(0);
buildBlocked = SequenceProvider.GetSequence("overlay", "build-invalid").GetSprite(0);
}
public override void GetDecorationArea(out int width, out int length, out float offset, BuildingInfo info)
{
width = info.m_cellWidth;
length = ((info.m_zoningMode != BuildingInfo.ZoningMode.Straight) ? info.m_cellLength : 4);
offset = (float)(length - info.m_cellLength) * 4f;
if (!info.m_expandFrontYard)
{
offset = -offset;
}
}
/// <summary>
/// Creates a new BuildingInfo with from the references passed in via the info variable
/// </summary>
/// <param name="info"></param>
public void CopyFromOther(BuildingInfo info)
{
// It is easier to just have a single info parameter as if we ever need to add additional info
// everything can be easily changed here rather than having to change the variables passed in
// throughout the entire code base of anything that calls this method
this.BuildingName = info.BuildingName;
this.RequiredBuildUnits = info.RequiredBuildUnits;
this.requiredResources = info.requiredResources;
this.requiredResourceAmount = info.requiredResourceAmount;
this.placeType = info.placeType;
}
private void DispatchAutobulldozeEffect(BuildingInfo info, ref Vector3 pos, ref float angle, int length)
{
EffectInfo mBulldozeEffect = this._buildingManager.m_properties.m_bulldozeEffect;
if (mBulldozeEffect == null)
{
return;
}
InstanceID instanceID = new InstanceID();
EffectInfo.SpawnArea spawnArea = new EffectInfo.SpawnArea(Matrix4x4.TRS(Building.CalculateMeshPosition(info, pos, angle, length), Building.CalculateMeshRotation(angle), Vector3.one), info.m_lodMeshData);
this._effectManager.DispatchEffect(mBulldozeEffect, instanceID, spawnArea, Vector3.zero, 0f, 1f, this._nullAudioGroup);
}
/// <summary>
/// Initializes a new instance of the <see cref="TileInfo"/> class.
/// </summary>
/// <param name="t_info">Tile information in JToken object.</param>
public TileInfo (JToken t_info)
{
if (t_info != null) {
id = t_info ["tile_id"].Value<string> ();
type = t_info ["tile_type"].Value<int> ();
}
//Buildings
if (t_info["player_building"] != null){
building = new BuildingInfo (t_info["player_building"]);
}
}
public PlaceBuildingOrderGenerator(Actor producer, string name)
{
Producer = producer;
Building = name;
BuildingInfo = Rules.Info[Building].Traits.Get<BuildingInfo>();
Preview = Rules.Info[Building].Traits.Get<RenderBuildingInfo>()
.RenderPreview(Rules.Info[Building], producer.Owner);
buildOk = SequenceProvider.GetSequence("overlay", "build-valid").GetSprite(0);
buildBlocked = SequenceProvider.GetSequence("overlay", "build-invalid").GetSprite(0);
}
protected override bool IsPlacementRelevant(BuildingInfo info)
{
bool flag = true;
if (this.isMapEditor)
{
for (int index = 0; index < info.m_paths.Length; ++index)
flag &= HelperExtensions.IsFlagSet(info.m_paths[index].m_netInfo.m_availableIn, Singleton<ToolManager>.instance.m_properties.m_mode);
}
if (base.IsPlacementRelevant(info))
return flag;
return false;
}
public PlaceBuildingOrderGenerator(ProductionQueue queue, string name)
{
Producer = queue.Actor;
Building = name;
var map = Producer.World.Map;
var tileset = Producer.World.TileSet.Id.ToLowerInvariant();
BuildingInfo = map.Rules.Actors[Building].Traits.Get<BuildingInfo>();
buildOk = map.SequenceProvider.GetSequence("overlay", "build-valid-{0}".F(tileset)).GetSprite(0);
buildBlocked = map.SequenceProvider.GetSequence("overlay", "build-invalid").GetSprite(0);
}
public void removeBuilding(BuildingInfo building)
{
Utility.Log(string.Format("removeBuilding() building.getPosition().mX = {0} mY = {1} mZ = {2}", building.Position.x, building.Position.y, building.Position.z));
/*
if(mBuildings.Contains(building))
{
int removeindex = mBuildings.IndexOf(building);
mBuildings.RemoveAt(removeindex);
}
*/
mBuildings.RemoveAll(item => item.mIndex == building.mIndex);
}
public static bool IsCellBuildable(this World world, CPos cell, BuildingInfo bi, Actor toIgnore = null)
{
if (!world.Map.Contains(cell))
return false;
if (world.WorldActor.Trait<BuildingInfluence>().GetBuildingAt(cell) != null)
return false;
if (!bi.AllowInvalidPlacement && world.ActorMap.GetUnitsAt(cell).Any(a => a != toIgnore))
return false;
return bi.TerrainTypes.Contains(world.Map.GetTerrainInfo(cell).Type);
}
public static void LoadDecorations(BuildingInfo source)
{
//Debug.Log("LoadDecorations called.");
Building building = default(Building);
building.m_position = new Vector3(0f, 60f, 0f);
// begin mod
building.m_width = (byte)source.m_cellWidth;
building.m_length = (byte)source.m_cellLength;
// end mod
BuildingDecoration.LoadPaths(source, 0, ref building, 0f);
BuildingDecoration.LoadProps(source, 0, ref building);
}
public static void SaveDecorations(BuildingInfo target)
{
//Debug.Log("SaveDecorations called.");
Building building = default(Building);
building.m_position = new Vector3(0f, 60f, 0f);
// begin mod
building.m_width = (byte)target.m_cellWidth;
building.m_length = (byte)target.m_cellLength;
// end mod
BuildingDecoration.SavePaths(target, 0, ref building);
BuildingDecoration.SaveProps(target, 0, ref building);
}
public static IEnumerable<CPos> Tiles(string name, BuildingInfo buildingInfo, CPos topLeft)
{
var dim = (CVec)buildingInfo.Dimensions;
var footprint = buildingInfo.Footprint.Where(x => !char.IsWhiteSpace(x));
if (Rules.Info[ name ].Traits.Contains<BibInfo>())
{
dim += new CVec(0, 1);
footprint = footprint.Concat(new char[dim.X]);
}
return TilesWhere( name, dim, footprint.ToArray(), a => a != '_' ).Select( t => t + topLeft );
}
public static IEnumerable<CPos> Tiles(Ruleset rules, string name, BuildingInfo buildingInfo, CPos topLeft)
{
var dim = (CVec)buildingInfo.Dimensions;
var footprint = buildingInfo.Footprint.Where(x => !char.IsWhiteSpace(x));
var bibInfo = rules.Actors[name].TraitInfoOrDefault<BibInfo>();
if (bibInfo != null && !bibInfo.HasMinibib)
{
dim += new CVec(0, 1);
footprint = footprint.Concat(new char[dim.X]);
}
return TilesWhere(name, dim, footprint.ToArray(), a => a != '_').Select(t => t + topLeft);
}
private void CategorizePrefab(BuildingInfo building)
{
BuildingAI ai = building.m_buildingAI;
int prefabID = building.m_prefabDataIndex;
_mapping.AddMapping(prefabID, _data._Buildings);
if (ai is PlayerBuildingAI)
{
_mapping.AddMapping(prefabID, _data._PlayerBuildings);
if (ai is CemeteryAI)
_mapping.AddMapping(prefabID, _data._Cemeteries);
else if (ai is LandfillSiteAI)
_mapping.AddMapping(prefabID, _data._LandfillSites);
else if (ai is FireStationAI)
_mapping.AddMapping(prefabID, _data._FireStations);
else if (ai is PoliceStationAI)
_mapping.AddMapping(prefabID, _data._PoliceStations);
else if (ai is HospitalAI)
_mapping.AddMapping(prefabID, _data._Hospitals);
else if (ai is ParkAI)
_mapping.AddMapping(prefabID, _data._Parks);
else if (ai is PowerPlantAI)
_mapping.AddMapping(prefabID, _data._PowerPlants);
else
_mapping.AddMapping(prefabID, _data._PlayerOther);
}
else if (ai is PrivateBuildingAI)
{
_mapping.AddMapping(prefabID, _data._PrivateBuildings);
if (ai is ResidentialBuildingAI)
_mapping.AddMapping(prefabID, _data._ResidentialBuildings);
else if (ai is CommercialBuildingAI)
_mapping.AddMapping(prefabID, _data._CommercialBuildings);
else if (ai is IndustrialBuildingAI)
_mapping.AddMapping(prefabID, _data._IndustrialBuildings);
else if (ai is OfficeBuildingAI)
_mapping.AddMapping(prefabID, _data._OfficeBuildings);
else
_mapping.AddMapping(prefabID, _data._PrivateOther);
}
else
_mapping.AddMapping(prefabID, _data._BuildingOther);
}
public static bool IsCellBuildable(this World world, CPos cell, BuildingInfo bi, Actor toIgnore = null)
{
if (!world.Map.Contains(cell))
return false;
if (world.WorldActor.Trait<BuildingInfluence>().GetBuildingAt(cell) != null)
return false;
if (!bi.AllowInvalidPlacement && world.ActorMap.GetActorsAt(cell).Any(a => a != toIgnore))
return false;
var tile = world.Map.Tiles[cell];
var tileInfo = world.Map.Rules.TileSet.GetTileInfo(tile);
// TODO: This is bandaiding over bogus tilesets.
if (tileInfo != null && tileInfo.RampType > 0)
return false;
return bi.TerrainTypes.Contains(world.Map.GetTerrainInfo(cell).Type);
}
private static void FindClosestZone(BuildingTool _this, BuildingInfo info, ushort block, Vector3 refPos, ref float minD, ref float min2, ref Vector3 minPos, ref float minAngle)
{
if ((int)block == 0)
return;
ZoneBlock zoneBlock = Singleton<ZoneManager>.instance.m_blocks.m_buffer[(int)block];
if ((double)Mathf.Abs(zoneBlock.m_position.x - refPos.x) >= 52.0 || (double)Mathf.Abs(zoneBlock.m_position.z - refPos.z) >= 52.0)
return;
int rowCount = zoneBlock.RowCount;
int columnCount = ZoneBlockDetour.GetColumnCount(ref zoneBlock); // modified
Vector3 lhs = new Vector3(Mathf.Cos(zoneBlock.m_angle), 0.0f, Mathf.Sin(zoneBlock.m_angle)) * 8f;
Vector3 vector3_1 = new Vector3(lhs.z, 0.0f, -lhs.x);
for (int row = 0; row < rowCount; ++row)
{
Vector3 vector3_2 = ((float)row - 3.5f) * vector3_1;
for (int column = 0; (long)column < columnCount; ++column) // modified
{
if (((long)zoneBlock.m_valid & 1L << (row << 3 | column)) != 0L)
{
Vector3 vector3_3 = ((float)column - 3.5f) * lhs;
Vector3 vector3_4 = zoneBlock.m_position + vector3_3 + vector3_2;
float num1 = Mathf.Sqrt((float)(((double)vector3_4.x - (double)refPos.x) * ((double)vector3_4.x - (double)refPos.x) + ((double)vector3_4.z - (double)refPos.z) * ((double)vector3_4.z - (double)refPos.z)));
float num2 = Vector3.Dot(lhs, refPos - zoneBlock.m_position);
if ((double)num1 <= (double)minD - 0.200000002980232 || (double)num1 < (double)minD + 0.200000002980232 && (double)num2 < (double)min2)
{
minD = num1;
min2 = num2;
if ((info.m_cellWidth & 1) == 0)
{
Vector3 vector3_5 = vector3_4 + vector3_1 * 0.5f;
Vector3 vector3_6 = vector3_4 - vector3_1 * 0.5f;
minPos = ((double)vector3_5.x - (double)refPos.x) * ((double)vector3_5.x - (double)refPos.x) + ((double)vector3_5.z - (double)refPos.z) * ((double)vector3_5.z - (double)refPos.z) >= ((double)vector3_6.x - (double)refPos.x) * ((double)vector3_6.x - (double)refPos.x) + ((double)vector3_6.z - (double)refPos.z) * ((double)vector3_6.z - (double)refPos.z) ? zoneBlock.m_position + (float)((double)info.m_cellLength * 0.5 - 4.0) * lhs + ((float)row - 4f) * vector3_1 : zoneBlock.m_position + (float)((double)info.m_cellLength * 0.5 - 4.0) * lhs + ((float)row - 3f) * vector3_1;
}
else
minPos = zoneBlock.m_position + (float)((double)info.m_cellLength * 0.5 - 4.0) * lhs + ((float)row - 3.5f) * vector3_1;
minPos.y = refPos.y;
minAngle = zoneBlock.m_angle + 1.570796f;
}
}
}
}
}
// called before a new building spawns on empty land (ZoneBlock.SimulationStep)
public static BuildingInfo GetRandomBuildingInfo_Spawn(Vector3 position, ref Randomizer r, ItemClass.Service service, ItemClass.SubService subService, ItemClass.Level level, int width, int length, BuildingInfo.ZoningMode zoningMode, int style)
{
if (Debugger.Enabled)
{
Debugger.Log("GetRandomBuildingInfo_Spawn called!");
}
var areaIndex = BuildingThemesManager.GetAreaIndex(service, subService, level, width, length, zoningMode);
var districtId = Singleton<DistrictManager>.instance.GetDistrict(position);
FastList<ushort> fastList = Singleton<BuildingThemesManager>.instance.GetAreaBuildings(districtId, areaIndex);
if (fastList == null || fastList.m_size == 0)
{
return (BuildingInfo)null;
}
// select a random prefab from the list
int index = r.Int32((uint)fastList.m_size);
return PrefabCollection<BuildingInfo>.GetPrefab((uint)fastList.m_buffer[index]);
}
public static IEnumerable<CPos> GetLineBuildCells(World world, CPos location, string name, BuildingInfo bi)
{
var lbi = world.Map.Rules.Actors[name].Traits.Get<LineBuildInfo>();
var topLeft = location; // 1x1 assumption!
if (world.IsCellBuildable(topLeft, bi))
yield return topLeft;
// Start at place location, search outwards
// TODO: First make it work, then make it nice
var vecs = new[] { new CVec(1, 0), new CVec(0, 1), new CVec(-1, 0), new CVec(0, -1) };
int[] dirs = { 0, 0, 0, 0 };
for (int d = 0; d < 4; d++)
{
for (int i = 1; i < lbi.Range; i++)
{
if (dirs[d] != 0)
continue;
var cell = topLeft + i * vecs[d];
if (world.IsCellBuildable(cell, bi))
continue; // Cell is empty; continue search
// Cell contains an actor. Is it the type we want?
if (world.ActorsWithTrait<LineBuildNode>().Any(a =>
(
a.Actor.Location == cell &&
a.Actor.Info.Traits.Get<LineBuildNodeInfo>().Types.Intersect(lbi.NodeTypes).Any()
)))
dirs[d] = i; // Cell contains actor of correct type
else
dirs[d] = -1; // Cell is blocked by another actor type
}
// Place intermediate-line sections
if (dirs[d] > 0)
for (int i = 1; i < dirs[d]; i++)
yield return topLeft + i * vecs[d];
}
}
public static IEnumerable<CPos> GetLineBuildCells(World world, CPos location, string name, BuildingInfo bi)
{
var lbi = world.Map.Rules.Actors[name].TraitInfo<LineBuildInfo>();
var topLeft = location; // 1x1 assumption!
if (world.IsCellBuildable(topLeft, bi))
yield return topLeft;
// Start at place location, search outwards
// TODO: First make it work, then make it nice
var vecs = new[] { new CVec(1, 0), new CVec(0, 1), new CVec(-1, 0), new CVec(0, -1) };
int[] dirs = { 0, 0, 0, 0 };
for (var d = 0; d < 4; d++)
{
for (var i = 1; i < lbi.Range; i++)
{
if (dirs[d] != 0)
continue;
var cell = topLeft + i * vecs[d];
if (world.IsCellBuildable(cell, bi))
continue; // Cell is empty; continue search
// Cell contains an actor. Is it the type we want?
var hasConnector = world.ActorMap.GetActorsAt(cell)
.Any(a => a.Info.TraitInfos<LineBuildNodeInfo>()
.Any(info => info.Types.Overlaps(lbi.NodeTypes) && info.Connections.Contains(vecs[d])));
dirs[d] = hasConnector ? i : -1;
}
// Place intermediate-line sections
if (dirs[d] > 0)
for (var i = 1; i < dirs[d]; i++)
yield return topLeft + i * vecs[d];
}
}
public void Start()
{
try
{
ModLogger.Debug("WorkshopAssetMonitor is loading workshop assets");
// The package manager monitors the list of workshop assets, so retrieve the packageid from each item
var workshopIds = PackageManager
.FilterAssets(UserAssetType.CustomAssetMetaData)
.Where(a => a.isWorkshopAsset)
.Select(a => new { Asset = a, Metadata = a.Instantiate <CustomAssetMetaData>() })
.Select(a => ulong.Parse(a.Asset.package.packageName))
.Distinct();
// The PrefabCollections monitor the list of all prefabs available in the game, which includes the default CS prefabs and the custom prefabs from workshop assets
// Try to match the prefabs with the workshop packageid list to make sure only workshopassets are loaded.
for (int i = 0; i < PrefabCollection <PropInfo> .PrefabCount(); i++)
{
PropInfo propPrefab = PrefabCollection <PropInfo> .GetPrefab((uint)i);
if (propPrefab != null)
{
var workshopPropMatch = Regex.Match(propPrefab.name, RegexExpression.BuildingName, RegexOptions.IgnoreCase);
if (workshopPropMatch.Success)
{
var workshopPropId = ulong.Parse(workshopPropMatch.Groups["packageid"].Value);
if (workshopIds.Any(id => id == workshopPropId))
{
_workshopAssets.Add(new WorkshopProp(workshopPropId, workshopPropMatch.Groups["prefabname"].Value, propPrefab.name));
}
}
}
}
for (int i = 0; i < PrefabCollection <TreeInfo> .PrefabCount(); i++)
{
TreeInfo treePrefab = PrefabCollection <TreeInfo> .GetPrefab((uint)i);
if (treePrefab != null)
{
var workshopTreeMatch = Regex.Match(treePrefab.name, RegexExpression.BuildingName, RegexOptions.IgnoreCase);
if (workshopTreeMatch.Success)
{
var workshopPropId = ulong.Parse(workshopTreeMatch.Groups["packageid"].Value);
if (workshopIds.Any(id => id == workshopPropId))
{
_workshopAssets.Add(new WorkshopTree(workshopPropId, workshopTreeMatch.Groups["prefabname"].Value, treePrefab.name));
}
}
}
}
for (int i = 0; i < PrefabCollection <BuildingInfo> .PrefabCount(); i++)
{
BuildingInfo buildingPrefab = PrefabCollection <BuildingInfo> .GetPrefab((uint)i);
if (buildingPrefab != null)
{
var workshopBuildingMatch = Regex.Match(buildingPrefab.name, RegexExpression.BuildingName, RegexOptions.IgnoreCase);
if (workshopBuildingMatch.Success)
{
var workshopBuildingId = ulong.Parse(workshopBuildingMatch.Groups["packageid"].Value);
if (workshopIds.Any(id => id == workshopBuildingId))
{
_workshopAssets.Add(new WorkshopBuilding(workshopBuildingId, workshopBuildingMatch.Groups["prefabname"].Value, buildingPrefab.name, buildingPrefab.GetService().ToAssetType()));
}
}
}
}
ModLogger.Debug("WorkshopAssetMonitor loaded {0} workshop assets", GetWorkshopAssetCount());
}
catch (Exception ex)
{
ModLogger.Error("An error occured while starting the workshop monitor, no workshop assets where loaded");
ModLogger.Exception(ex);
}
}
void Start()
{
info = new BuildingInfo(0, 0, 0, 0);
isclear = true;
}
// Detours
public static void SimulationStep(ref ZoneBlock zoneBlock, ushort blockID)
{
// This is the decompiled ZoneBlock.SimulationStep() method
// Segments which were changed are marked with "begin mod" and "end mod"
if (Debugger.Enabled && debugCount < 10)
{
debugCount++;
Debugger.LogFormat("Building Themes: Detoured ZoneBlock.SimulationStep was called. blockID: {0}, position: {1}.", blockID, zoneBlock.m_position);
}
ZoneManager zoneManager = Singleton <ZoneManager> .instance;
int rowCount = zoneBlock.RowCount;
float m_angle = zoneBlock.m_angle;
Vector2 xDirection = new Vector2(Mathf.Cos(m_angle), Mathf.Sin(m_angle)) * 8f;
Vector2 zDirection = new Vector2(xDirection.y, -xDirection.x);
ulong num = zoneBlock.m_valid & ~(zoneBlock.m_occupied1 | zoneBlock.m_occupied2);
int spawnpointRow = 0;
ItemClass.Zone zone = ItemClass.Zone.Unzoned;
int num3 = 0;
while (num3 < 4 && zone == ItemClass.Zone.Unzoned)
{
spawnpointRow = Singleton <SimulationManager> .instance.m_randomizer.Int32((uint)rowCount);
if ((num & 1uL << (spawnpointRow << 3)) != 0uL)
{
zone = zoneBlock.GetZone(0, spawnpointRow);
}
num3++;
}
DistrictManager instance2 = Singleton <DistrictManager> .instance;
Vector3 m_position = (Vector3)zoneBlock.m_position;
byte district = instance2.GetDistrict(m_position);
int num4;
switch (zone)
{
case ItemClass.Zone.ResidentialLow:
num4 = zoneManager.m_actualResidentialDemand;
num4 += instance2.m_districts.m_buffer[(int)district].CalculateResidentialLowDemandOffset();
break;
case ItemClass.Zone.ResidentialHigh:
num4 = zoneManager.m_actualResidentialDemand;
num4 += instance2.m_districts.m_buffer[(int)district].CalculateResidentialHighDemandOffset();
break;
case ItemClass.Zone.CommercialLow:
num4 = zoneManager.m_actualCommercialDemand;
num4 += instance2.m_districts.m_buffer[(int)district].CalculateCommercialLowDemandOffset();
break;
case ItemClass.Zone.CommercialHigh:
num4 = zoneManager.m_actualCommercialDemand;
num4 += instance2.m_districts.m_buffer[(int)district].CalculateCommercialHighDemandOffset();
break;
case ItemClass.Zone.Industrial:
num4 = zoneManager.m_actualWorkplaceDemand;
num4 += instance2.m_districts.m_buffer[(int)district].CalculateIndustrialDemandOffset();
break;
case ItemClass.Zone.Office:
num4 = zoneManager.m_actualWorkplaceDemand;
num4 += instance2.m_districts.m_buffer[(int)district].CalculateOfficeDemandOffset();
break;
default:
return;
}
Vector2 a = VectorUtils.XZ(m_position);
Vector2 vector3 = a - 3.5f * xDirection + ((float)spawnpointRow - 3.5f) * zDirection;
int[] tmpXBuffer = zoneManager.m_tmpXBuffer;
for (int i = 0; i < 13; i++)
{
tmpXBuffer[i] = 0;
}
Quad2 quad = default(Quad2);
quad.a = a - 4f * xDirection + ((float)spawnpointRow - 10f) * zDirection;
quad.b = a + 3f * xDirection + ((float)spawnpointRow - 10f) * zDirection;
quad.c = a + 3f * xDirection + ((float)spawnpointRow + 2f) * zDirection;
quad.d = a - 4f * xDirection + ((float)spawnpointRow + 2f) * zDirection;
Vector2 vector4 = quad.Min();
Vector2 vector5 = quad.Max();
//begin mod
int num5 = Mathf.Max((int)((vector4.x - 46f) / 64f + _zoneGridHalfResolution), 0);
int num6 = Mathf.Max((int)((vector4.y - 46f) / 64f + _zoneGridHalfResolution), 0);
int num7 = Mathf.Min((int)((vector5.x + 46f) / 64f + _zoneGridHalfResolution), _zoneGridResolution - 1);
int num8 = Mathf.Min((int)((vector5.y + 46f) / 64f + _zoneGridHalfResolution), _zoneGridResolution - 1);
//end mod
for (int j = num6; j <= num8; j++)
{
for (int k = num5; k <= num7; k++)
{
//begin mod
ushort num9 = zoneManager.m_zoneGrid[j * _zoneGridResolution + k];
//end mod
int num10 = 0;
while (num9 != 0)
{
Vector3 positionVar = zoneManager.m_blocks.m_buffer[(int)num9].m_position;
float num11 = Mathf.Max(Mathf.Max(vector4.x - 46f - positionVar.x, vector4.y - 46f - positionVar.z),
Mathf.Max(positionVar.x - vector5.x - 46f, positionVar.z - vector5.y - 46f));
if (num11 < 0f)
{
_CheckBlock.Invoke(zoneBlock, new object[] { zoneManager.m_blocks.m_buffer[(int)num9], tmpXBuffer, zone, vector3, xDirection, zDirection, quad });
}
num9 = zoneManager.m_blocks.m_buffer[(int)num9].m_nextGridBlock;
if (++num10 >= 49152)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
for (int l = 0; l < 13; l++)
{
uint num12 = (uint)tmpXBuffer[l];
int num13 = 0;
bool flag = (num12 & 196608u) == 196608u;
bool flag2 = false;
while ((num12 & 1u) != 0u)
{
num13++;
flag2 = ((num12 & 65536u) != 0u);
num12 >>= 1;
}
if (num13 == 5 || num13 == 6)
{
if (flag2)
{
num13 -= Singleton <SimulationManager> .instance.m_randomizer.Int32(2u) + 2;
}
else
{
num13 = 4;
}
num13 |= 131072;
}
else if (num13 == 7)
{
num13 = 4;
num13 |= 131072;
}
if (flag)
{
num13 |= 65536;
}
tmpXBuffer[l] = num13;
}
int num14 = tmpXBuffer[6] & 65535;
if (num14 == 0)
{
return;
}
bool flag3 = (bool)_IsGoodPlace.Invoke(zoneBlock, new object[] { vector3 });
if (Singleton <SimulationManager> .instance.m_randomizer.Int32(100u) >= num4)
{
if (flag3)
{
zoneManager.m_goodAreaFound[(int)zone] = 1024;
}
return;
}
if (!flag3 && zoneManager.m_goodAreaFound[(int)zone] > -1024)
{
if (zoneManager.m_goodAreaFound[(int)zone] == 0)
{
zoneManager.m_goodAreaFound[(int)zone] = -1;
}
return;
}
int num15 = 6;
int num16 = 6;
bool flag4 = true;
while (true)
{
if (flag4)
{
while (num15 != 0)
{
if ((tmpXBuffer[num15 - 1] & 65535) != num14)
{
break;
}
num15--;
}
while (num16 != 12)
{
if ((tmpXBuffer[num16 + 1] & 65535) != num14)
{
break;
}
num16++;
}
}
else
{
while (num15 != 0)
{
if ((tmpXBuffer[num15 - 1] & 65535) < num14)
{
break;
}
num15--;
}
while (num16 != 12)
{
if ((tmpXBuffer[num16 + 1] & 65535) < num14)
{
break;
}
num16++;
}
}
int num17 = num15;
int num18 = num16;
while (num17 != 0)
{
if ((tmpXBuffer[num17 - 1] & 65535) < 2)
{
break;
}
num17--;
}
while (num18 != 12)
{
if ((tmpXBuffer[num18 + 1] & 65535) < 2)
{
break;
}
num18++;
}
bool flag5 = num17 != 0 && num17 == num15 - 1;
bool flag6 = num18 != 12 && num18 == num16 + 1;
if (flag5 && flag6)
{
if (num16 - num15 > 2)
{
break;
}
if (num14 <= 2)
{
if (!flag4)
{
goto Block_34;
}
}
else
{
num14--;
}
}
else if (flag5)
{
if (num16 - num15 > 1)
{
goto Block_36;
}
if (num14 <= 2)
{
if (!flag4)
{
goto Block_38;
}
}
else
{
num14--;
}
}
else if (flag6)
{
if (num16 - num15 > 1)
{
goto Block_40;
}
if (num14 <= 2)
{
if (!flag4)
{
goto Block_42;
}
}
else
{
num14--;
}
}
else
{
if (num15 != num16)
{
goto IL_884;
}
if (num14 <= 2)
{
if (!flag4)
{
goto Block_45;
}
}
else
{
num14--;
}
}
flag4 = false;
}
num15++;
num16--;
Block_34:
goto IL_891;
Block_36:
num15++;
Block_38:
goto IL_891;
Block_40:
num16--;
Block_42:
Block_45:
IL_884:
IL_891:
int num19;
int num20;
if (num14 == 1 && num16 - num15 >= 1)
{
num15 += Singleton <SimulationManager> .instance.m_randomizer.Int32((uint)(num16 - num15));
num16 = num15 + 1;
num19 = num15 + Singleton <SimulationManager> .instance.m_randomizer.Int32(2u);
num20 = num19;
}
else
{
do
{
num19 = num15;
num20 = num16;
if (num16 - num15 == 2)
{
if (Singleton <SimulationManager> .instance.m_randomizer.Int32(2u) == 0)
{
num20--;
}
else
{
num19++;
}
}
else if (num16 - num15 == 3)
{
if (Singleton <SimulationManager> .instance.m_randomizer.Int32(2u) == 0)
{
num20 -= 2;
}
else
{
num19 += 2;
}
}
else if (num16 - num15 == 4)
{
if (Singleton <SimulationManager> .instance.m_randomizer.Int32(2u) == 0)
{
num16 -= 2;
num20 -= 3;
}
else
{
num15 += 2;
num19 += 3;
}
}
else if (num16 - num15 == 5)
{
if (Singleton <SimulationManager> .instance.m_randomizer.Int32(2u) == 0)
{
num16 -= 3;
num20 -= 2;
}
else
{
num15 += 3;
num19 += 2;
}
}
else if (num16 - num15 >= 6)
{
if (num15 == 0 || num16 == 12)
{
if (num15 == 0)
{
num15 = 3;
num19 = 2;
}
if (num16 == 12)
{
num16 = 9;
num20 = 10;
}
}
else if (Singleton <SimulationManager> .instance.m_randomizer.Int32(2u) == 0)
{
num16 = num15 + 3;
num20 = num19 + 2;
}
else
{
num15 = num16 - 3;
num19 = num20 - 2;
}
}
}while (num16 - num15 > 3 || num20 - num19 > 3);
}
int depth_A = 4;
int width_A = num16 - num15 + 1;
BuildingInfo.ZoningMode zoningMode = BuildingInfo.ZoningMode.Straight;
bool flag7 = true;
for (int m = num15; m <= num16; m++)
{
depth_A = Mathf.Min(depth_A, tmpXBuffer[m] & 65535);
if ((tmpXBuffer[m] & 131072) == 0)
{
flag7 = false;
}
}
if (num16 > num15)
{
if ((tmpXBuffer[num15] & 65536) != 0)
{
zoningMode = BuildingInfo.ZoningMode.CornerLeft;
num20 = num15 + num20 - num19;
num19 = num15;
}
if ((tmpXBuffer[num16] & 65536) != 0 && (zoningMode != BuildingInfo.ZoningMode.CornerLeft || Singleton <SimulationManager> .instance.m_randomizer.Int32(2u) == 0))
{
zoningMode = BuildingInfo.ZoningMode.CornerRight;
num19 = num16 + num19 - num20;
num20 = num16;
}
}
int depth_B = 4;
int width_B = num20 - num19 + 1;
BuildingInfo.ZoningMode zoningMode2 = BuildingInfo.ZoningMode.Straight;
bool flag8 = true;
for (int n = num19; n <= num20; n++)
{
depth_B = Mathf.Min(depth_B, tmpXBuffer[n] & 65535);
if ((tmpXBuffer[n] & 131072) == 0)
{
flag8 = false;
}
}
if (num20 > num19)
{
if ((tmpXBuffer[num19] & 65536) != 0)
{
zoningMode2 = BuildingInfo.ZoningMode.CornerLeft;
}
if ((tmpXBuffer[num20] & 65536) != 0 && (zoningMode2 != BuildingInfo.ZoningMode.CornerLeft || Singleton <SimulationManager> .instance.m_randomizer.Int32(2u) == 0))
{
zoningMode2 = BuildingInfo.ZoningMode.CornerRight;
}
}
ItemClass.SubService subService = ItemClass.SubService.None;
ItemClass.Level level = ItemClass.Level.Level1;
ItemClass.Service service;
switch (zone)
{
case ItemClass.Zone.ResidentialLow:
service = ItemClass.Service.Residential;
subService = ItemClass.SubService.ResidentialLow;
break;
case ItemClass.Zone.ResidentialHigh:
service = ItemClass.Service.Residential;
subService = ItemClass.SubService.ResidentialHigh;
break;
case ItemClass.Zone.CommercialLow:
service = ItemClass.Service.Commercial;
subService = ItemClass.SubService.CommercialLow;
break;
case ItemClass.Zone.CommercialHigh:
service = ItemClass.Service.Commercial;
subService = ItemClass.SubService.CommercialHigh;
break;
case ItemClass.Zone.Industrial:
service = ItemClass.Service.Industrial;
break;
case ItemClass.Zone.Office:
service = ItemClass.Service.Office;
subService = ItemClass.SubService.None;
break;
default:
return;
}
BuildingInfo buildingInfo = null;
Vector3 vector6 = Vector3.zero;
int num25_row = 0;
int length = 0;
int width = 0;
BuildingInfo.ZoningMode zoningMode3 = BuildingInfo.ZoningMode.Straight;
int num28 = 0;
// begin mod
int depth_alt = Mathf.Min(depth_A, 4);
int width_alt = width_A;
// end mod
while (num28 < 8) // while (num28 < 6)
{
switch (num28)
{
// Corner cases
case 0:
if (zoningMode != BuildingInfo.ZoningMode.Straight)
{
num25_row = num15 + num16 + 1;
length = depth_A;
width = width_A;
zoningMode3 = zoningMode;
goto IL_D6A;
}
break;
case 1:
if (zoningMode2 != BuildingInfo.ZoningMode.Straight)
{
num25_row = num19 + num20 + 1;
length = depth_B;
width = width_B;
zoningMode3 = zoningMode2;
goto IL_D6A;
}
break;
case 2:
if (zoningMode != BuildingInfo.ZoningMode.Straight)
{
if (depth_A >= 4)
{
num25_row = num15 + num16 + 1;
length = ((!flag7) ? 2 : 3);
width = width_A;
zoningMode3 = zoningMode;
goto IL_D6A;
}
}
break;
case 3:
if (zoningMode2 != BuildingInfo.ZoningMode.Straight)
{
if (depth_B >= 4)
{
num25_row = num19 + num20 + 1;
length = ((!flag8) ? 2 : 3);
width = width_B;
zoningMode3 = zoningMode2;
goto IL_D6A;
}
}
break;
// begin mod
case 4:
if (zoningMode != BuildingInfo.ZoningMode.Straight)
{
if (width_alt > 1)
{
width_alt--;
}
else if (depth_alt > 1)
{
depth_alt--;
width_alt = width_A;
}
else
{
break;
}
if (width_alt == width_A)
{
num25_row = num15 + num16 + 1;
}
else
{
if (zoningMode == BuildingInfo.ZoningMode.CornerLeft)
{
num25_row = num15 + num16 + 1 - (width_A - width_alt);
}
else
{
num25_row = num15 + num16 + 1 + (width_A - width_alt);
}
}
length = depth_alt;
width = width_alt;
zoningMode3 = zoningMode;
num28--;
goto IL_D6A;
}
break;
// end mod
// Straight cases
case 5:
num25_row = num15 + num16 + 1;
length = depth_A;
width = width_A;
zoningMode3 = BuildingInfo.ZoningMode.Straight;
goto IL_D6A;
case 6:
// begin mod
// reset variables
depth_alt = Mathf.Min(depth_A, 4);
width_alt = width_A;
// end mod
//int width_B = num20 - num19 + 1;
num25_row = num19 + num20 + 1;
length = depth_B;
width = width_B;
zoningMode3 = BuildingInfo.ZoningMode.Straight;
goto IL_D6A;
// begin mod
case 7:
if (width_alt > 1)
{
width_alt--;
}
else
{
break;
}
if (width_alt == width_A)
{
num25_row = num15 + num16 + 1;
}
else if (width_A % 2 != width_alt % 2)
{
num25_row = num15 + num16;
}
else
{
num25_row = num15 + num16 + 1;
}
length = depth_alt;
width = width_alt;
zoningMode3 = BuildingInfo.ZoningMode.Straight;
num28--;
goto IL_D6A;
// end mod
default:
goto IL_D6A;
}
IL_DF0:
num28++;
continue;
IL_D6A:
vector6 = m_position + VectorUtils.X_Y(((float)length * 0.5f - 4f) * xDirection + ((float)num25_row * 0.5f + (float)spawnpointRow - 10f) * zDirection);
if (zone == ItemClass.Zone.Industrial)
{
ZoneBlock.GetIndustryType(vector6, out subService, out level);
}
else if (zone == ItemClass.Zone.CommercialLow || zone == ItemClass.Zone.CommercialHigh)
{
ZoneBlock.GetCommercialType(vector6, zone, width, length, out subService, out level);
}
byte district2 = instance2.GetDistrict(vector6);
ushort style = instance2.m_districts.m_buffer[(int)district2].m_Style;
// begin mod
// Here we are calling a custom getRandomBuildingInfo method
buildingInfo = BuildingManagerDetour.GetRandomBuildingInfo_Spawn(vector6, ref Singleton <SimulationManager> .instance.m_randomizer, service, subService, level, width, length, zoningMode3, style);
// end mod
if (buildingInfo != null)
{
// begin mod
// If the depth of the found prefab is smaller than the one we were looking for, recalculate the size
// This is done by checking the position of every prop
// Plots only get shrinked when no assets are placed on the extra space
// This is needed for themes which only contain small buildings (e.g. 1x2)
// because those buildings would occupy more space than needed!
if (buildingInfo.GetWidth() == width && buildingInfo.GetLength() != length)
{
// Calculate the z position of the furthest away prop
float biggestPropPosZ = 0;
if (buildingInfo.m_props != null)
{
foreach (var prop in buildingInfo.m_props)
{
if (prop == null)
{
continue;
}
biggestPropPosZ = Mathf.Max(biggestPropPosZ, buildingInfo.m_expandFrontYard ? prop.m_position.z : -prop.m_position.z);
}
}
// Check if the furthest away prop is outside of the bounds of the prefab
float occupiedExtraSpace = biggestPropPosZ - buildingInfo.GetLength() * 4;
if (occupiedExtraSpace <= 0)
{
// No? Then shrink the plot to the prefab length so no space is wasted!
length = buildingInfo.GetLength();
}
else
{
// Yes? Shrink the plot so all props are in the bounds
int newLength = buildingInfo.GetLength() + Mathf.CeilToInt(occupiedExtraSpace / 8);
length = Mathf.Min(length, newLength);
}
vector6 = m_position + VectorUtils.X_Y(((float)length * 0.5f - 4f) * xDirection + ((float)num25_row * 0.5f + (float)spawnpointRow - 10f) * zDirection);
}
// This block handles Corner buildings. We always shrink them
else if (buildingInfo.GetLength() == width && buildingInfo.GetWidth() != length)
{
length = buildingInfo.GetWidth();
vector6 = m_position + VectorUtils.X_Y(((float)length * 0.5f - 4f) * xDirection + ((float)num25_row * 0.5f + (float)spawnpointRow - 10f) * zDirection);
}
// end mod
if (Debugger.Enabled)
{
Debugger.LogFormat("Found prefab: {5} - {0}, {1}, {2}, {3} x {4}", service, subService, level, width, length, buildingInfo.name);
}
break;
}
if (Debugger.Enabled)
{
}
goto IL_DF0;
}
if (buildingInfo == null)
{
if (Debugger.Enabled)
{
Debugger.LogFormat("No prefab found: {0}, {1}, {2}, {3} x {4}", service, subService, level, width, length);
}
return;
}
float num29 = Singleton <TerrainManager> .instance.WaterLevel(VectorUtils.XZ(vector6));
if (num29 > vector6.y)
{
return;
}
float num30 = m_angle + 1.57079637f;
if (zoningMode3 == BuildingInfo.ZoningMode.CornerLeft && buildingInfo.m_zoningMode == BuildingInfo.ZoningMode.CornerRight)
{
num30 -= 1.57079637f;
length = width;
}
else if (zoningMode3 == BuildingInfo.ZoningMode.CornerRight && buildingInfo.m_zoningMode == BuildingInfo.ZoningMode.CornerLeft)
{
num30 += 1.57079637f;
length = width;
}
ushort num31;
if (Singleton <BuildingManager> .instance.CreateBuilding(out num31, ref Singleton <SimulationManager> .instance.m_randomizer, buildingInfo, vector6, num30, length, Singleton <SimulationManager> .instance.m_currentBuildIndex))
{
Singleton <SimulationManager> .instance.m_currentBuildIndex += 1u;
switch (service)
{
case ItemClass.Service.Residential:
zoneManager.m_actualResidentialDemand = Mathf.Max(0, zoneManager.m_actualResidentialDemand - 5);
break;
case ItemClass.Service.Commercial:
zoneManager.m_actualCommercialDemand = Mathf.Max(0, zoneManager.m_actualCommercialDemand - 5);
break;
case ItemClass.Service.Industrial:
zoneManager.m_actualWorkplaceDemand = Mathf.Max(0, zoneManager.m_actualWorkplaceDemand - 5);
break;
case ItemClass.Service.Office:
zoneManager.m_actualWorkplaceDemand = Mathf.Max(0, zoneManager.m_actualWorkplaceDemand - 5);
break;
}
switch (zone)
{
case ItemClass.Zone.ResidentialHigh:
case ItemClass.Zone.CommercialHigh:
{
Building[] expr_FD7_cp_0 = Singleton <BuildingManager> .instance.m_buildings.m_buffer;
ushort expr_FD7_cp_1 = num31;
expr_FD7_cp_0[(int)expr_FD7_cp_1].m_flags = (expr_FD7_cp_0[(int)expr_FD7_cp_1].m_flags | Building.Flags.HighDensity);
break;
}
}
}
zoneManager.m_goodAreaFound[(int)zone] = 1024;
}
public GameObject CreateGameObject(Map map, uint faction)
{
uint entry = EmptyGameObjectId;
if (BuildingInfo.PacketInfo.HasValue)
{
GarrPlotInstanceRecord plotInstance = CliDB.GarrPlotInstanceStorage.LookupByKey(PacketInfo.GarrPlotInstanceID);
GarrPlotRecord plot = CliDB.GarrPlotStorage.LookupByKey(plotInstance.GarrPlotID);
GarrBuildingRecord building = CliDB.GarrBuildingStorage.LookupByKey(BuildingInfo.PacketInfo.Value.GarrBuildingID);
entry = faction == GarrisonFactionIndex.Horde ? plot.HordeConstructObjID : plot.AllianceConstructObjID;
if (BuildingInfo.PacketInfo.Value.Active || entry == 0)
{
entry = faction == GarrisonFactionIndex.Horde ? building.HordeGameObjectID : building.AllianceGameObjectID;
}
}
if (Global.ObjectMgr.GetGameObjectTemplate(entry) == null)
{
Log.outError(LogFilter.Garrison, "Garrison attempted to spawn gameobject whose template doesn't exist ({0})", entry);
return(null);
}
GameObject go = GameObject.CreateGameObject(entry, map, PacketInfo.PlotPos, Rotation, 255, GameObjectState.Ready);
if (!go)
{
return(null);
}
if (BuildingInfo.CanActivate() && BuildingInfo.PacketInfo.HasValue && !BuildingInfo.PacketInfo.Value.Active)
{
FinalizeGarrisonPlotGOInfo finalizeInfo = Global.GarrisonMgr.GetPlotFinalizeGOInfo(PacketInfo.GarrPlotInstanceID);
if (finalizeInfo != null)
{
Position pos2 = finalizeInfo.factionInfo[faction].Pos;
GameObject finalizer = GameObject.CreateGameObject(finalizeInfo.factionInfo[faction].GameObjectId, map, pos2, Quaternion.fromEulerAnglesZYX(pos2.GetOrientation(), 0.0f, 0.0f), 255, GameObjectState.Ready);
if (finalizer)
{
// set some spell id to make the object delete itself after use
finalizer.SetSpellId(finalizer.GetGoInfo().Goober.spell);
finalizer.SetRespawnTime(0);
ushort animKit = finalizeInfo.factionInfo[faction].AnimKitId;
if (animKit != 0)
{
finalizer.SetAnimKitId(animKit, false);
}
map.AddToMap(finalizer);
}
}
}
if (go.GetGoType() == GameObjectTypes.GarrisonBuilding && go.GetGoInfo().garrisonBuilding.SpawnMap != 0)
{
foreach (var cellGuids in Global.ObjectMgr.GetMapObjectGuids((uint)go.GetGoInfo().garrisonBuilding.SpawnMap, (byte)map.GetDifficultyID()))
{
foreach (var spawnId in cellGuids.Value.creatures)
{
Creature spawn = BuildingSpawnHelper <Creature>(go, spawnId, map);
if (spawn)
{
BuildingInfo.Spawns.Add(spawn.GetGUID());
}
}
foreach (var spawnId in cellGuids.Value.gameobjects)
{
GameObject spawn = BuildingSpawnHelper <GameObject>(go, spawnId, map);
if (spawn)
{
BuildingInfo.Spawns.Add(spawn.GetGUID());
}
}
}
}
BuildingInfo.Guid = go.GetGUID();
return(go);
}
public Stats()
{
//GDP
ServiceSubServicePair[] servAndSubServ = new ServiceSubServicePair[] {
new ServiceSubServicePair(ItemClass.Service.Residential, ItemClass.SubService.ResidentialHigh),
new ServiceSubServicePair(ItemClass.Service.Residential, ItemClass.SubService.ResidentialHighEco),
new ServiceSubServicePair(ItemClass.Service.Residential, ItemClass.SubService.ResidentialLow),
new ServiceSubServicePair(ItemClass.Service.Residential, ItemClass.SubService.ResidentialLowEco),
new ServiceSubServicePair(ItemClass.Service.Commercial, ItemClass.SubService.CommercialEco),
new ServiceSubServicePair(ItemClass.Service.Commercial, ItemClass.SubService.CommercialHigh),
new ServiceSubServicePair(ItemClass.Service.Commercial, ItemClass.SubService.CommercialLeisure),
new ServiceSubServicePair(ItemClass.Service.Commercial, ItemClass.SubService.CommercialLow),
new ServiceSubServicePair(ItemClass.Service.Commercial, ItemClass.SubService.CommercialTourist),
new ServiceSubServicePair(ItemClass.Service.Industrial, ItemClass.SubService.IndustrialFarming),
new ServiceSubServicePair(ItemClass.Service.Industrial, ItemClass.SubService.IndustrialForestry),
new ServiceSubServicePair(ItemClass.Service.Industrial, ItemClass.SubService.IndustrialGeneric),
new ServiceSubServicePair(ItemClass.Service.Industrial, ItemClass.SubService.IndustrialOil),
new ServiceSubServicePair(ItemClass.Service.Industrial, ItemClass.SubService.IndustrialOre),
new ServiceSubServicePair(ItemClass.Service.Office, ItemClass.SubService.OfficeGeneric),
new ServiceSubServicePair(ItemClass.Service.Office, ItemClass.SubService.OfficeHightech)
};
long outable;
int[] taxRates = new int[servAndSubServ.Length];
long[] incomes = new long[servAndSubServ.Length];
float expendableIncome = 0; //Non taxed income
for (int i = 0; i < servAndSubServ.Length; i++)
{
taxRates[i] = Singleton <EconomyManager> .instance.GetTaxRate(servAndSubServ[i].service, servAndSubServ[i].subService, ItemClass.Level.None);
Singleton <EconomyManager> .instance.GetIncomeAndExpenses(servAndSubServ[i].service, servAndSubServ[i].subService, ItemClass.Level.None, out incomes[i], out outable);
expendableIncome += incomes[i] / taxRates[i] * (100 - taxRates[i]);
}
long govtExpLong;
float governmentExpenses;
long income; //Al pedo...
Singleton <EconomyManager> .instance.GetIncomeAndExpenses(ItemClass.Service.None, ItemClass.SubService.None, ItemClass.Level.None, out income, out govtExpLong);
expendableIncome /= 100;
governmentExpenses = govtExpLong / 100;
float loanExpenses = Singleton <EconomyManager> .instance.GetLoanExpenses() / 100;
this.gdp = expendableIncome + governmentExpenses - loanExpenses;
this.privateSpending = expendableIncome;
this.govtSpending = governmentExpenses;
this.population = Singleton <CitizenManager> .instance.m_citizenCount;
//GDP PER CAPITA
if (this.population == 0)
{
this.gdpPerCapita = -1;
}
else
{
this.gdpPerCapita = (gdp / this.population);
}
//GINI
BuildingManager buildingManager = BuildingManager.instance;
List <byte> coefficientsGiniRes = new List <byte>();
List <byte> coefficientsGiniBuildings = new List <byte>();
for (int i = 0; i < buildingManager.m_buildings.m_size; i++)
{
BuildingInfo info = buildingManager.m_buildings.m_buffer[i].Info;
byte level = buildingManager.m_buildings.m_buffer[i].m_level;
if (info.GetService() == ItemClass.Service.Residential)
{
byte citizenCount = buildingManager.m_buildings.m_buffer[i].m_citizenCount;
for (byte j = 0; j < citizenCount; j++)
{
coefficientsGiniRes.Add(level);
}
}
coefficientsGiniBuildings.Add(level);
}
this.gini = calculateGINI(coefficientsGiniRes);
this.giniBuildings = calculateGINI(coefficientsGiniBuildings);
//CITY VALUE PER CAPITA
float cityValue = Singleton <StatisticsManager> .instance.Get(StatisticType.CityValue).GetLatestFloat();
if (this.population == 0)
{
this.cityValuePC = -1;
}
else
{
this.cityValuePC = cityValue / this.population;
}
//CITY VALUE - CURRENT MONEY AMOUNT PER CAPITA
if (this.population == 0)
{
this.cityValuePCNoMoney = -1;
}
else
{
long lastCashAmount = Singleton <EconomyManager> .instance.LastCashAmount / 100;
this.cityValuePCNoMoney = (cityValue - lastCashAmount) / this.population;
}
}
private List <BuildingItem> GetBuildingItemList(Configuration.Theme theme)
{
List <BuildingItem> list = new List <BuildingItem>();
// List of all growables prefabs
Dictionary <string, BuildingItem> buildingDictionary = new Dictionary <string, BuildingItem>();
for (uint i = 0; i < PrefabCollection <BuildingInfo> .PrefabCount(); i++)
{
BuildingInfo prefab = PrefabCollection <BuildingInfo> .GetPrefab(i);
if (prefab != null && prefab.m_placementStyle == ItemClass.Placement.Automatic)
{
BuildingItem item = new BuildingItem();
item.prefab = PrefabCollection <BuildingInfo> .GetPrefab(i);
if (!buildingDictionary.ContainsKey(item.name))
{
buildingDictionary.Add(item.name, item);
}
if (!BuildingVariationManager.instance.IsVariation(item.name))
{
list.Add(item);
}
}
}
// Combine growables with buildings in configuration
Configuration.Building[] buildings = theme.buildings.ToArray();
for (int i = 0; i < buildings.Length; i++)
{
if (buildingDictionary.ContainsKey(buildings[i].name))
{
// Associate building with prefab
BuildingItem item = buildingDictionary[buildings[i].name];
item.building = buildings[i];
if (!list.Contains(item))
{
list.Add(item);
}
}
else
{
// Prefab not found, adding building without prefab
if (buildings[i].dlc != null && !PlatformService.IsDlcInstalled(Convert.ToUInt32(buildings[i].dlc)))
{
continue;
}
if (buildings[i].environments != null &&
(buildings[i].environments.Contains("-" + SimulationManager.instance.m_metaData.m_environment) ||
!buildings[i].environments.Contains("+" + SimulationManager.instance.m_metaData.m_environment)))
{
continue;
}
BuildingItem item = new BuildingItem();
item.building = buildings[i];
list.Add(item);
}
}
// Sorting
try
{
list.Sort(BuildingCompare);
}
catch (Exception e)
{
Debug.LogException(e);
// ignore this error. seems harmless
}
return(list);
}
private StorageInfo GetStorageInfo(BuildingInfo buildingInfo)
{
return(_worldData.StorageInfos.First(info => info.BuildingId == buildingInfo.Id));
}
void BuildingBClicked(UIComponent component, UIMouseEventParameter eventParam, BuildingInfo Binf)
{
var buildingTool = ToolsModifierControl.SetTool <BuildingTool> ();
{
buildingTool.m_prefab = Binf;
buildingTool.m_relocate = 0;
BuildingPanel.isVisible = true;
}
}
/// <summary>
/// Called whenever the currently selected building is changed to update the panel display.
/// </summary>
/// <param name="building"></param>
public void SelectionChanged(BuildingInfo building)
{
string buildingName = building.name;
// Hide message.
messageLabel.isVisible = false;
// Set current selecion.
currentSelection = building;
// Blank all textfields and deselect checkboxes to start with.
homeJobsCount.textField.text = string.Empty;
UpdateFloorTextFields(string.Empty, string.Empty);
popCheck.isChecked = false;
floorCheck.isChecked = false;
// Disable buttons and exit if no valid building is selected.
if (building == null || building.name == null)
{
saveButton.Disable();
deleteButton.Disable();
return;
}
// Set label by building type.
if (building.GetService() == ItemClass.Service.Residential)
{
// Residential building - homes.
homeJobLabel.text = Translations.Translate("RPR_LBL_HOM");
}
else if (building.GetService() == ItemClass.Service.Education)
{
// Schoool building - students.
homeJobLabel.text = Translations.Translate("RPR_LBL_STU");
}
else
{
// Workplace building - jobs.
homeJobLabel.text = Translations.Translate("RPR_LBL_JOB");
}
// Get any population override.
int homesJobs = PopData.instance.GetOverride(buildingName);
// If custom settings were found (return value was non-zero), then display the result, rename the save button, and enable the delete button.
if (homesJobs != 0)
{
// Valid custom settings found; display the result, rename the save button, and enable the delete button.
homeJobsCount.textField.text = homesJobs.ToString();
saveButton.text = Translations.Translate("RPR_CUS_UPD");
deleteButton.Enable();
// Select the 'has population override' check.
popCheck.isChecked = true;
}
else
{
// No population override - check for custom floor override.
FloorDataPack overridePack = FloorData.instance.HasOverride(buildingName);
if (overridePack != null)
{
// Valid custom settings found; display the result, rename the save button, and enable the delete button.
UpdateFloorTextFields(overridePack.firstFloorMin.ToString(), overridePack.floorHeight.ToString());
saveButton.text = Translations.Translate("RPR_CUS_UPD");
deleteButton.Enable();
// Select the 'has floor override' check.
floorCheck.isChecked = true;
}
else
{
// No valid selection - rename the save button, and disable the delete button.
saveButton.text = Translations.Translate("RPR_CUS_ADD");
deleteButton.Disable();
}
// Communicate override to panel.
BuildingDetailsPanel.Panel.OverrideFloors = overridePack;
}
// We've at least got a valid building, so enable the save button.
saveButton.Enable();
}
/// <summary>
/// Renders a building.
/// </summary>
/// <param name="cameraInfo">A <see cref="RenderManager.CameraInfo"/> object</param>
/// <param name="position">The position of the building</param>
/// <param name="angle">The angle of the building</param>
/// <param name="buildingPrefab">A <see cref="BuildingInfo"/> object</param>
/// <param name="selectionColor">The color to aply to the overlay</param>
public static void RenderBuildingGeometry(RenderManager.CameraInfo cameraInfo, ref Matrix4x4 matrixTRS, Vector3 center, Vector3 position, float angle, BuildingInfo buildingPrefab, Color buildingColor)
{
Vector3 buildingPosition = matrixTRS.MultiplyPoint(position - center);
buildingPrefab.m_buildingAI.RenderBuildGeometry(cameraInfo, buildingPosition, angle, 0);
BuildingTool.RenderGeometry(cameraInfo, buildingPrefab, 0, buildingPosition, angle, false, buildingColor);
if (buildingPrefab.m_subBuildings != null && buildingPrefab.m_subBuildings.Length != 0)
{
Matrix4x4 subMatrix4x = Matrix4x4.identity;
subMatrix4x.SetTRS(buildingPosition, Quaternion.identity, Vector3.one);
for (int n = 0; n < buildingPrefab.m_subBuildings.Length; n++)
{
BuildingInfo buildingInfo2 = buildingPrefab.m_subBuildings[n].m_buildingInfo;
Vector3 subPosition = subMatrix4x.MultiplyPoint(buildingPrefab.m_subBuildings[n].m_position);
var subAngle = buildingPrefab.m_subBuildings[n].m_angle * Mathf.Deg2Rad + angle;
buildingInfo2.m_buildingAI.RenderBuildGeometry(cameraInfo, subPosition, subAngle, 0);
BuildingTool.RenderGeometry(cameraInfo, buildingInfo2, 0, subPosition, subAngle, true, buildingColor);
}
}
}
// reset all selection params.
private void ResetSelection()
{
selectedPrefab = null;
prefabNetTypes.Clear();
expandedTypes.Clear();
}
/// <summary>
/// Renders the overlay building in the terrain.
/// </summary>
/// <param name="cameraInfo">A <see cref="RenderManager.CameraInfo"/> object</param>
/// <param name="position">The position of the building</param>
/// <param name="angle">The angle of the building</param>
/// <param name="buildingPrefab">A <see cref="BuildingInfo"/> object</param>
/// <param name="buildingColor">The color of the building</param>
public static void RenderBuildingOverlay(RenderManager.CameraInfo cameraInfo, ref Matrix4x4 matrixTRS, Vector3 center, Vector3 position, float angle, BuildingInfo buildingPrefab, Color buildingColor)
{
Vector3 buildingPosition = matrixTRS.MultiplyPoint(position - center);
buildingPrefab.m_buildingAI.RenderBuildOverlay(cameraInfo, buildingColor, position, angle, default);
BuildingTool.RenderOverlay(cameraInfo, buildingPrefab, 0, buildingPosition, angle, buildingColor, true);
if (buildingPrefab.m_subBuildings != null && buildingPrefab.m_subBuildings.Length != 0)
{
Matrix4x4 subMatrix4x = default;
subMatrix4x.SetTRS(buildingPosition, Quaternion.AngleAxis(angle * Mathf.Rad2Deg, Vector3.down), Vector3.one);
for (int i = 0; i < buildingPrefab.m_subBuildings.Length; i++)
{
BuildingInfo buildingInfo2 = buildingPrefab.m_subBuildings[i].m_buildingInfo;
Vector3 position2 = subMatrix4x.MultiplyPoint(buildingPrefab.m_subBuildings[i].m_position);
float angle2 = buildingPrefab.m_subBuildings[i].m_angle * Mathf.Deg2Rad + angle;
buildingInfo2.m_buildingAI.RenderBuildOverlay(cameraInfo, buildingColor, position2, angle2, default);
BuildingTool.RenderOverlay(cameraInfo, buildingInfo2, 0, position2, angle2, buildingColor, true);
}
}
}
protected override void StartActions()
{
if (m_ghostMode)
{
for (ushort a = 1; a < BuildingManager.instance.m_buildings.m_buffer.Length; a++)
{
if (BuildingManager.instance.m_buildings.m_buffer[a].Info.m_buildingAI is PrivateBuildingAI)
{
Vector3 position = BuildingManager.instance.m_buildings.m_buffer[a].m_position;
int num = Mathf.Max((int)((position.x - 35f) / 64f + 135f), 0);
int num2 = Mathf.Max((int)((position.z - 35f) / 64f + 135f), 0);
int num3 = Mathf.Min((int)((position.x + 35f) / 64f + 135f), 269);
int num4 = Mathf.Min((int)((position.z + 35f) / 64f + 135f), 269);
Array16 <Building> buildings = Singleton <BuildingManager> .instance.m_buildings;
ushort[] buildingGrid = Singleton <BuildingManager> .instance.m_buildingGrid;
for (int i = num2; i <= num4; i++)
{
for (int j = num; j <= num3; j++)
{
ushort num5 = buildingGrid[i * 270 + j];
int num6 = 0;
while (num5 != 0)
{
ushort nextGridBuilding = buildings.m_buffer[num5].m_nextGridBuilding;
Building.Flags flags = buildings.m_buffer[num5].m_flags;
if ((flags & (Building.Flags.Created | Building.Flags.Deleted | Building.Flags.Demolishing | Building.Flags.Collapsed)) == Building.Flags.Created)
{
BuildingInfo info = buildings.m_buffer[num5].Info;
if (info != null && info.m_placementStyle == ItemClass.Placement.Automatic)
{
ItemClass.Zone zone = info.m_class.GetZone();
ItemClass.Zone secondaryZone = info.m_class.GetSecondaryZone();
if (zone != ItemClass.Zone.None && VectorUtils.LengthSqrXZ(buildings.m_buffer[num5].m_position - position) <= 1225f)
{
buildings.m_buffer[num5].CheckZoning(zone, secondaryZone, true);
}
}
}
num5 = nextGridBuilding;
if (++num6 >= 49152)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
}
}
}
for (ushort i = 1; i < ZoneManager.instance.m_blocks.m_buffer.Length; i++)
{
bool changed = false;
for (int x = 0; x < 4; x++)
{
for (int z = 0; z < 8; z++)
{
changed = ZoneMixerOverrides.GetBlockZoneSanitize(ref ZoneManager.instance.m_blocks.m_buffer[i], x, z) | changed;
}
}
if (changed)
{
ZoneManager.instance.m_blocks.m_buffer[i].RefreshZoning(i);
}
}
K45DialogControl.ShowModal(new K45DialogControl.BindProperties()
{
icon = ZoneMixerMod.Instance.IconName,
title = Locale.Get("K45_ZM_GHOST_MODE_MODAL_TITLE"),
message = Locale.Get("K45_ZM_GHOST_MODE_MODAL_MESSAGE"),
showButton1 = true,
textButton1 = Locale.Get("K45_ZM_OK_BUTTON")
}, (x) => true);
}
}
public static void RecalculateSpawnPoints(BuildingInfo info)
{
var buildingAI = info?.GetComponent <TransportStationAI>();
var paths = info?.m_paths;
if (buildingAI == null || paths == null || buildingAI.m_transportLineInfo == null)
{
return;
}
var allSpawnPoints = (from path in paths
where IsVehicleStop(path)
select new KeyValuePair <Vector3, ItemClass>(GetMiddle(path), path.m_netInfo.m_class)).Distinct()
.ToArray();
Vector3[] primarySpawnPoints;
Vector3[] secondarySpawnPoints;
if (buildingAI.m_secondaryTransportInfo == null)
{
primarySpawnPoints = allSpawnPoints.Select(kvp => kvp.Key).ToArray();
secondarySpawnPoints = new Vector3[] { };
}
else
{
primarySpawnPoints = allSpawnPoints
.Where(kvp => kvp.Value.m_subService == buildingAI.m_transportInfo.m_class.m_subService ||
kvp.Value.m_subService == ItemClass.SubService.None &&
kvp.Value.m_service == ItemClass.Service.Road &&
buildingAI.m_transportInfo.m_class.m_subService ==
ItemClass.SubService.PublicTransportBus)
.Select(kvp => kvp.Key)
.ToArray();
secondarySpawnPoints = allSpawnPoints
.Where(kvp => kvp.Value.m_subService == buildingAI.m_secondaryTransportInfo.m_class.m_subService ||
kvp.Value.m_subService == ItemClass.SubService.None &&
kvp.Value.m_service == ItemClass.Service.Road &&
buildingAI.m_secondaryTransportInfo.m_class.m_subService ==
ItemClass.SubService.PublicTransportBus)
.Select(kvp => kvp.Key)
.ToArray();
}
if (!(buildingAI.m_transportLineInfo.m_class.m_service == ItemClass.Service.PublicTransport &&
(buildingAI.m_transportLineInfo.m_class.m_subService == ItemClass.SubService.PublicTransportShip ||
buildingAI.m_transportLineInfo.m_class.m_subService == ItemClass.SubService.PublicTransportPlane) &&
buildingAI.m_transportLineInfo.m_class.m_level == ItemClass.Level.Level2))
{
switch (primarySpawnPoints.Length)
{
case 0:
buildingAI.m_spawnPosition = Vector3.zero;
buildingAI.m_spawnTarget = Vector3.zero;
buildingAI.m_spawnPoints = new DepotAI.SpawnPoint[] { };
break;
case 1:
buildingAI.m_spawnPosition = primarySpawnPoints[0];
buildingAI.m_spawnTarget = primarySpawnPoints[0];
buildingAI.m_spawnPoints = new[]
{
new DepotAI.SpawnPoint
{
m_position = primarySpawnPoints[0],
m_target = primarySpawnPoints[0]
}
};
break;
default:
buildingAI.m_spawnPosition = Vector3.zero;
buildingAI.m_spawnTarget = Vector3.zero;
buildingAI.m_spawnPoints = primarySpawnPoints.Select(p => new DepotAI.SpawnPoint
{
m_position = p,
m_target = p
})
.ToArray();
break;
}
}
if (buildingAI.m_secondaryTransportInfo != null &&
!(buildingAI.m_secondaryTransportInfo.m_class.m_service == ItemClass.Service.PublicTransport &&
(buildingAI.m_secondaryTransportInfo.m_class.m_subService == ItemClass.SubService.PublicTransportShip ||
buildingAI.m_secondaryTransportInfo.m_class.m_subService == ItemClass.SubService.PublicTransportPlane) &&
buildingAI.m_secondaryTransportInfo.m_class.m_level == ItemClass.Level.Level2))
{
switch (secondarySpawnPoints.Length)
{
case 0:
buildingAI.m_spawnPosition2 = Vector3.zero;
buildingAI.m_spawnTarget2 = Vector3.zero;
buildingAI.m_spawnPoints2 = new DepotAI.SpawnPoint[] { };
break;
case 1:
buildingAI.m_spawnPosition2 = secondarySpawnPoints[0];
buildingAI.m_spawnTarget2 = secondarySpawnPoints[0];
buildingAI.m_spawnPoints2 = new[]
{
new DepotAI.SpawnPoint
{
m_position = secondarySpawnPoints[0],
m_target = secondarySpawnPoints[0]
}
};
break;
default:
buildingAI.m_spawnPosition2 = Vector3.zero;
buildingAI.m_spawnTarget2 = Vector3.zero;
buildingAI.m_spawnPoints2 = secondarySpawnPoints.Select(p => new DepotAI.SpawnPoint
{
m_position = p,
m_target = p
})
.ToArray();
break;
}
}
}
public void updateBidings()
{
BuildingInfo basicInfo = Singleton <BuildingManager> .instance.m_buildings.m_buffer[m_buildingIdSelecionado.Building].Info;
DepotAI basicAI = basicInfo.GetAI() as DepotAI;
if (basicAI == null)
{
closeDepotInfo(null, null);
return;
}
TransportStationAI stationAI = basicInfo.GetAI() as TransportStationAI;
HarborAI harborAI = basicInfo.GetAI() as HarborAI;
vehiclesInUseLabel.text = LocaleFormatter.FormatGeneric("TRANSPORT_LINE_VEHICLECOUNT", new object[] { basicAI.GetVehicleCount(m_buildingIdSelecionado.Building, ref Singleton <BuildingManager> .instance.m_buildings.m_buffer[m_buildingIdSelecionado.Building]).ToString() });
if (stationAI != null)
{
passengersLastWeek.isVisible = true;
int passengerCount = stationAI.GetPassengerCount(m_buildingIdSelecionado.Building, ref Singleton <BuildingManager> .instance.m_buildings.m_buffer[m_buildingIdSelecionado.Building]);
passengersLastWeek.text = LocaleFormatter.FormatGeneric("AIINFO_PASSENGERS_SERVICED", new object[] { passengerCount });
}
else
{
passengersLastWeek.isVisible = false;
}
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[] { basicAI.m_workPlaceCount0, basicAI.m_workPlaceCount1, basicAI.m_workPlaceCount2, basicAI.m_workPlaceCount3 });
}
private static void AddBollards(this NetInfo info, NetInfoVersion version, PropInfo bollardInfo = null, BuildingInfo pillarInfo = null, float?bridgePillarYOffset = null, float?bollardYOffset = null)
{
if (version == NetInfoVersion.Bridge || version == NetInfoVersion.Elevated)
{
if (pillarInfo == null)
{
pillarInfo = Prefabs.Find <BuildingInfo>("Pedestrian Elevated Pillar", false);
}
var bridgeAI = info.GetComponent <RoadBridgeAI>();
if (pillarInfo != null && bridgeAI != null)
{
bridgeAI.m_doubleLength = false;
bridgeAI.m_bridgePillarInfo = pillarInfo;
bridgeAI.m_middlePillarInfo = null;
if (bridgePillarYOffset != null)
{
bridgeAI.m_bridgePillarOffset = (float)bridgePillarYOffset;
}
else
{
bridgeAI.m_bridgePillarOffset = 0;
}
}
}
if (bollardInfo != null)
{
var bollardProp1 = new NetLaneProps.Prop()
{
m_prop = bollardInfo,
m_finalProp = bollardInfo,
m_probability = 100,
m_segmentOffset = 1,
m_minLength = 10,
m_endFlagsRequired = NetNode.Flags.Transition
};
bollardProp1.m_position.x = -3.5f;
if (bollardYOffset != null)
{
bollardProp1.m_position.y = (float)bollardYOffset;
}
else
{
bollardProp1.m_position.y = -0.3f;
}
var bollardProp2 = bollardProp1.ShallowClone();
bollardProp2.m_segmentOffset = -1;
bollardProp2.m_endFlagsRequired = NetNode.Flags.None;
bollardProp2.m_startFlagsRequired = NetNode.Flags.Transition;
var bollardProp3 = bollardProp1.ShallowClone();
bollardProp3.m_position.x = 3.5f;
var bollardProp4 = bollardProp2.ShallowClone();
bollardProp4.m_position.x = 3.5f;
var bollardProp5 = bollardProp1.ShallowClone();
bollardProp5.m_position.x = 0;
var bollardProp6 = bollardProp2.ShallowClone();
bollardProp6.m_position.x = 0;
var propPedLane = info
.m_lanes
.First(l => l.m_position == 0f && l.m_laneType == NetInfo.LaneType.Pedestrian);
propPedLane.m_laneProps.m_props = propPedLane
.m_laneProps
.m_props
.Union(new[] { bollardProp1, bollardProp2, bollardProp3, bollardProp4, bollardProp5, bollardProp6 })
.ToArray();
}
}
public void Update(InstanceID instanceId)
{
id = instanceId;
if (!MITE.Settings.ShowDebugPanel)
{
return;
}
if (id == null)
{
return;
}
if (id == InstanceID.Empty)
{
lastId = id;
HoverLarge.textColor = new Color32(255, 255, 255, 255);
return;
}
if (lastId == id)
{
return;
}
HoverLarge.textColor = new Color32(127, 217, 255, 255);
HoverLarge.text = "";
HoverSmall.text = "";
if (id.Building > 0)
{
BuildingInfo info = BuildingManager.instance.m_buildings.m_buffer[id.Building].Info;
HoverLarge.text = $"B:{id.Building} {info.name}";
HoverSmall.text = $"{info.GetType()} ({info.GetAI().GetType()})\n{info.m_class.name}\n({info.m_class.m_service}.{info.m_class.m_subService})";
if (isModToolsEnabled())
{
ModTools.Id = id;
}
}
if (id.Prop > 0)
{
string type = "P";
PropInfo info = PropManager.instance.m_props.m_buffer[id.Prop].Info;
if (info.m_isDecal)
{
type = "D";
}
HoverLarge.text = $"{type}:{id.Prop} {info.name}";
HoverSmall.text = $"{info.GetType()}\n{info.m_class.name}";
if (isModToolsEnabled())
{
ModTools.Id = id;
}
}
if (id.Tree > 0)
{
TreeInfo info = TreeManager.instance.m_trees.m_buffer[id.Tree].Info;
HoverLarge.text = $"T:{id.Tree} {info.name}";
HoverSmall.text = $"{info.GetType()}\n{info.m_class.name}";
if (isModToolsEnabled())
{
ModTools.Id = id;
}
}
if (id.NetNode > 0)
{
NetInfo info = NetManager.instance.m_nodes.m_buffer[id.NetNode].Info;
HoverLarge.text = $"N:{id.NetNode} {info.name}";
HoverSmall.text = $"{info.GetType()} ({info.GetAI().GetType()})\n{info.m_class.name}";
if (isModToolsEnabled())
{
ModTools.Id = id;
}
}
if (id.NetSegment > 0)
{
NetInfo info = NetManager.instance.m_segments.m_buffer[id.NetSegment].Info;
HoverLarge.text = $"S:{id.NetSegment} {info.name}";
HoverSmall.text = $"{info.GetType()} ({info.GetAI().GetType()})\n{info.m_class.name}";
if (isModToolsEnabled())
{
ModTools.Id = id;
}
}
lastId = id;
}
public ProceduralObject(CacheProceduralObject sourceCacheObj, int id, Vector3 position)
{
if (sourceCacheObj.baseInfoType == "PROP")
{
PropInfo sourceProp = sourceCacheObj._baseProp;
if (sourceCacheObj._baseProp == null)
{
sourceProp = Resources.FindObjectsOfTypeAll <PropInfo>().FirstOrDefault(info => info.name == sourceCacheObj.basePrefabName);
}
this._baseProp = sourceProp;
this.id = id;
this.basePrefabName = sourceCacheObj.basePrefabName;
this.baseInfoType = "PROP";
this.isPloppableAsphalt = sourceProp.IsPloppableAsphalt();
renderDistance = sourceCacheObj.renderDistance;
m_position = position;
m_rotation = sourceCacheObj.m_rotation;
m_mesh = sourceProp.m_mesh.InstantiateMesh();
allVertices = sourceCacheObj.allVertices;
m_mesh.SetVertices(new List <Vector3>(allVertices));
m_material = GameObject.Instantiate(sourceProp.m_material);
if (sourceProp.m_mesh.name == "ploppableasphalt-prop" || sourceProp.m_mesh.name == "ploppableasphalt-decal")
{
m_material.ApplyPloppableColor();
}
}
else if (sourceCacheObj.baseInfoType == "BUILDING")// building
{
BuildingInfo sourceBuilding = sourceCacheObj._baseBuilding;
if (sourceCacheObj._baseBuilding == null)
{
sourceBuilding = Resources.FindObjectsOfTypeAll <BuildingInfo>().FirstOrDefault(info => info.name == sourceCacheObj.basePrefabName);
}
this._baseBuilding = sourceBuilding;
this.id = id;
this.basePrefabName = sourceCacheObj.basePrefabName;
this.baseInfoType = "BUILDING";
this.isPloppableAsphalt = false;
renderDistance = sourceCacheObj.renderDistance;
m_position = position;
m_rotation = sourceCacheObj.m_rotation;
m_mesh = sourceBuilding.m_mesh.InstantiateMesh();
allVertices = sourceCacheObj.allVertices;
m_mesh.SetVertices(new List <Vector3>(allVertices));
m_mesh.colors = new Color[] { };
m_mesh.colors32 = new Color32[] { };
m_material = GameObject.Instantiate(sourceBuilding.m_material);
}
if (sourceCacheObj.customTexture != null)
{
m_material.mainTexture = sourceCacheObj.customTexture as Texture;
customTexture = sourceCacheObj.customTexture;
}
m_visibility = sourceCacheObj.visibility;
historyEditionBuffer = new HistoryBuffer(this);
if (sourceCacheObj.textParam != null)
{
m_textParameters = TextParameters.Clone(sourceCacheObj.textParam, false);
// m_textParameters.SetFonts();
var originalTex = new Texture2D(m_material.mainTexture.width, m_material.mainTexture.height, TextureFormat.RGBA32, false);
originalTex.SetPixels(((Texture2D)m_material.mainTexture).GetPixels());
originalTex.Apply();
m_material.mainTexture = m_textParameters.ApplyParameters(originalTex);
}
else
{
m_textParameters = null;
}
// this.flipFaces = sourceCacheObj.flipFaces;
// if (this.flipFaces)
// VertexUtils.flipFaces(this);
disableRecalculation = sourceCacheObj.disableRecalculation;
this.tilingFactor = sourceCacheObj.tilingFactor;
}
/// <summary>
/// Creates a new item.
/// </summary>
/// <param name="buildingManager">The building manager.</param>
/// <param name="configuration">The configuration.</param>
/// <param name="identityType">Type of the identity.</param>
/// <param name="buildingId">The building identifier.</param>
/// <param name="buildingInfo">The building information.</param>
/// <returns>
/// A new item.
/// </returns>
public Configuration.Item NewItem(BuildingManager buildingManager, Configuration configuration, string identityType, ushort buildingId, BuildingInfo buildingInfo)
{
Configuration.Item item = configuration.NewItem();
item.Identity.Set(identityType, buildingInfo.name);
item.Values.Set("LowWealthTourists", buildingInfo.m_buildingAI.GetLowWealthTourists());
item.Values.Set("MediumWealthTourists", buildingInfo.m_buildingAI.GetMediumWealthTourists());
item.Values.Set("HighWealthTourists", buildingInfo.m_buildingAI.GetHighWealthTourists());
if (configuration.ItemType == Configuration.ItemTypes.Objects)
{
string name = buildingManager.GetBuildingName(buildingId, buildingInfo.m_instanceID);
if (!string.IsNullOrEmpty(name))
{
item.Values.Set("Building", name);
}
}
return(item);
}
private void AttackUnit(GameObject closestUnit)
{
if (closestUnit.tag == "TeamA" || closestUnit.tag == "TeamB")
{
UnitAController unitInfo = closestUnit.GetComponent <UnitAController>();
Vector3 currentPos = transform.position;
float dist = Vector3.Distance(closestUnit.transform.position, currentPos);
if (this.unitType == "Ranged")
{
if (dist <= rangedAttackRange)
{
unitInfo.Health -= rangedAttackDamage;
if (unitInfo.Health <= 0)
{
Debug.Log("Killed");
Destroy(closestUnit);
}
}
else
{
Move();
}
}
else
{
if (dist <= meleeAttackRange)
{
unitInfo.Health -= meleeAttackDamage;
if (unitInfo.Health <= 0)
{
Debug.Log("Killed by melee");
Destroy(closestUnit);
}
}
else
{
Move();
}
}
}
else if (closestUnit.tag == "Wizard")
{
WizardController unitInfo = closestUnit.GetComponent <WizardController>();
Vector3 currentPos = transform.position;
float dist = Vector3.Distance(closestUnit.transform.position, currentPos);
if (this.unitType == "Ranged")
{
if (dist <= rangedAttackRange)
{
unitInfo.Health -= rangedAttackDamage;
if (unitInfo.Health <= 0)
{
Debug.Log("Killed");
Destroy(closestUnit);
}
}
else
{
Move();
}
}
else
{
if (dist <= meleeAttackRange)
{
unitInfo.Health -= meleeAttackDamage;
if (unitInfo.Health <= 0)
{
Debug.Log("Killed by melee");
Destroy(closestUnit);
}
}
else
{
Move();
}
}
}
else
{
BuildingInfo unitInfo = closestUnit.GetComponent <BuildingInfo>();
Vector3 currentPos = transform.position;
float dist = Vector3.Distance(closestUnit.transform.position, currentPos);
if (this.unitType == "Ranged")
{
if (dist <= rangedAttackRange)
{
unitInfo.Health -= rangedAttackDamage;
if (unitInfo.Health <= 0)
{
Debug.Log("Killed");
Destroy(closestUnit);
}
}
else
{
Move();
}
}
else
{
if (dist <= meleeAttackRange)
{
unitInfo.Health -= meleeAttackDamage;
if (unitInfo.Health <= 0)
{
Debug.Log("Killed by melee");
Destroy(closestUnit);
}
}
else
{
Move();
}
}
}
}
public HackyAI(HackyAIInfo Info)
{
this.Info = Info;
// temporary hack.
this.rallypointTestBuilding = Rules.Info[Info.RallypointTestBuilding].Traits.Get <BuildingInfo>();
}
private bool GetStopPosition(TransportInfo info, ushort segment, ushort building, ushort firstStop, ref Vector3 hitPos, out bool fixedPlatform)
{
//begin mod(+): detect key
bool alternateMode = Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift);
//end mod
NetManager instance1 = Singleton <NetManager> .instance;
BuildingManager instance2 = Singleton <BuildingManager> .instance;
TransportManager instance3 = Singleton <TransportManager> .instance;
fixedPlatform = false;
if (info.m_transportType == TransportInfo.TransportType.Pedestrian)
{
Vector3 position = Vector3.zero;
float laneOffset = 0.0f;
uint laneID = 0;
int laneIndex;
if ((int)segment != 0 && !instance1.m_segments.m_buffer[(int)segment].GetClosestLanePosition(hitPos, NetInfo.LaneType.Pedestrian, VehicleInfo.VehicleType.None, VehicleInfo.VehicleType.None, out position, out laneID, out laneIndex, out laneOffset))
{
laneID = 0U;
if ((instance1.m_segments.m_buffer[(int)segment].m_flags & NetSegment.Flags.Untouchable) != NetSegment.Flags.None && (int)building == 0)
{
building = NetSegment.FindOwnerBuilding(segment, 363f);
}
}
if ((int)building != 0)
{
if (instance2.m_buildings.m_buffer[(int)building].Info.m_hasPedestrianPaths)
{
laneID = instance2.m_buildings.m_buffer[(int)building].FindLane(NetInfo.LaneType.Pedestrian, VehicleInfo.VehicleType.None, hitPos, out position, out laneOffset);
}
if ((int)laneID == 0)
{
Vector3 sidewalkPosition = instance2.m_buildings.m_buffer[(int)building].CalculateSidewalkPosition();
laneID = instance2.m_buildings.m_buffer[(int)building].FindAccessLane(NetInfo.LaneType.Pedestrian, VehicleInfo.VehicleType.None, sidewalkPosition, out position, out laneOffset);
}
}
if ((int)laneID == 0)
{
return(false);
}
if ((double)laneOffset < 0.00392156885936856)
{
laneOffset = 0.003921569f;
position = instance1.m_lanes.m_buffer[laneID].CalculatePosition(laneOffset);
}
else if ((double)laneOffset > 0.996078431606293)
{
laneOffset = 0.9960784f;
position = instance1.m_lanes.m_buffer[laneID].CalculatePosition(laneOffset);
}
if ((int)this.m_line != 0)
{
firstStop = instance3.m_lines.m_buffer[(int)this.m_line].m_stops;
ushort stop = firstStop;
int num = 0;
while ((int)stop != 0)
{
if ((int)instance1.m_nodes.m_buffer[(int)stop].m_lane == (int)laneID)
{
hitPos = instance1.m_nodes.m_buffer[(int)stop].m_position;
fixedPlatform = true;
return(true);
}
stop = TransportLine.GetNextStop(stop);
if ((int)stop != (int)firstStop)
{
if (++num >= 32768)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + System.Environment.StackTrace);
break;
}
}
else
{
break;
}
}
}
hitPos = position;
fixedPlatform = true;
return(true);
}
if ((int)segment != 0)
{
if ((instance1.m_segments.m_buffer[(int)segment].m_flags & NetSegment.Flags.Untouchable) != NetSegment.Flags.None)
{
building = NetSegment.FindOwnerBuilding(segment, 363f);
if ((int)building != 0)
{
BuildingInfo info1 = instance2.m_buildings.m_buffer[(int)building].Info;
TransportInfo transportLineInfo1 = info1.m_buildingAI.GetTransportLineInfo();
TransportInfo transportLineInfo2 = info1.m_buildingAI.GetSecondaryTransportLineInfo();
//begin mod(*): check for !alternateMode
if (!alternateMode && transportLineInfo1 != null && transportLineInfo1.m_transportType == info.m_transportType || !alternateMode && transportLineInfo2 != null && transportLineInfo2.m_transportType == info.m_transportType)
{
//end mod
segment = (ushort)0;
}
else
{
building = (ushort)0;
}
}
}
Vector3 position1;
uint laneID1;
int laneIndex1;
float laneOffset1;
if ((int)segment != 0 && instance1.m_segments.m_buffer[(int)segment].GetClosestLanePosition(hitPos, NetInfo.LaneType.Pedestrian, VehicleInfo.VehicleType.None, info.m_vehicleType, out position1, out laneID1, out laneIndex1, out laneOffset1))
{
if (info.m_vehicleType == VehicleInfo.VehicleType.None)
{
NetLane.Flags flags1 = (NetLane.Flags)((int)instance1.m_lanes.m_buffer[laneID1].m_flags & 768);
NetLane.Flags flags2 = info.m_stopFlag;
NetInfo info1 = instance1.m_segments.m_buffer[(int)segment].Info;
if (info1.m_vehicleTypes != VehicleInfo.VehicleType.None)
{
flags2 = NetLane.Flags.None;
}
if (flags1 != NetLane.Flags.None && flags2 != NetLane.Flags.None && flags1 != flags2)
{
return(false);
}
float stopOffset = info1.m_lanes[laneIndex1].m_stopOffset;
if ((instance1.m_segments.m_buffer[(int)segment].m_flags & NetSegment.Flags.Invert) != NetSegment.Flags.None)
{
stopOffset = -stopOffset;
}
Vector3 direction;
instance1.m_lanes.m_buffer[laneID1].CalculateStopPositionAndDirection(0.5019608f, stopOffset, out hitPos, out direction);
fixedPlatform = true;
return(true);
}
Vector3 position2;
uint laneID2;
int laneIndex2;
float laneOffset2;
if (instance1.m_segments.m_buffer[(int)segment].GetClosestLanePosition(position1, NetInfo.LaneType.Vehicle | NetInfo.LaneType.TransportVehicle, info.m_vehicleType, out position2, out laneID2, out laneIndex2, out laneOffset2))
{
NetLane.Flags flags = (NetLane.Flags)((int)instance1.m_lanes.m_buffer[laneID1].m_flags & 768);
if (flags != NetLane.Flags.None && info.m_stopFlag != NetLane.Flags.None && flags != info.m_stopFlag)
{
return(false);
}
float stopOffset = instance1.m_segments.m_buffer[(int)segment].Info.m_lanes[laneIndex2].m_stopOffset;
if ((instance1.m_segments.m_buffer[(int)segment].m_flags & NetSegment.Flags.Invert) != NetSegment.Flags.None)
{
stopOffset = -stopOffset;
}
Vector3 direction;
instance1.m_lanes.m_buffer[laneID2].CalculateStopPositionAndDirection(0.5019608f, stopOffset, out hitPos, out direction);
fixedPlatform = true;
return(true);
}
}
}
//begin mod(*): check for !alternateMode
if (!alternateMode && (int)building != 0)
{
//end mod
ushort num1 = 0;
if ((instance2.m_buildings.m_buffer[(int)building].m_flags & Building.Flags.Untouchable) != Building.Flags.None)
{
num1 = Building.FindParentBuilding(building);
}
if (this.m_building != 0 && (int)firstStop != 0 && (this.m_building == (int)building || this.m_building == (int)num1))
{
hitPos = instance1.m_nodes.m_buffer[(int)firstStop].m_position;
return(true);
}
VehicleInfo randomVehicleInfo = Singleton <VehicleManager> .instance.GetRandomVehicleInfo(ref Singleton <SimulationManager> .instance.m_randomizer, info.m_class.m_service, info.m_class.m_subService, info.m_class.m_level);
if (randomVehicleInfo != null)
{
BuildingInfo info1 = instance2.m_buildings.m_buffer[(int)building].Info;
TransportInfo transportLineInfo1 = info1.m_buildingAI.GetTransportLineInfo();
if (transportLineInfo1 == null && (int)num1 != 0)
{
building = num1;
info1 = instance2.m_buildings.m_buffer[(int)building].Info;
transportLineInfo1 = info1.m_buildingAI.GetTransportLineInfo();
}
TransportInfo transportLineInfo2 = info1.m_buildingAI.GetSecondaryTransportLineInfo();
if (transportLineInfo1 != null && transportLineInfo1.m_transportType == info.m_transportType || transportLineInfo2 != null && transportLineInfo2.m_transportType == info.m_transportType)
{
Vector3 vector3 = Vector3.zero;
int num2 = 1000000;
for (int index = 0; index < 12; ++index)
{
Randomizer randomizer = new Randomizer((ulong)index);
Vector3 position;
Vector3 target;
info1.m_buildingAI.CalculateSpawnPosition(building, ref instance2.m_buildings.m_buffer[(int)building], ref randomizer, randomVehicleInfo, out position, out target);
int num3 = 0;
if (info.m_avoidSameStopPlatform)
{
num3 = this.GetLineCount(position, target - position, info.m_transportType);
}
if (num3 < num2)
{
vector3 = position;
num2 = num3;
}
else if (num3 == num2 && (double)Vector3.SqrMagnitude(position - hitPos) < (double)Vector3.SqrMagnitude(vector3 - hitPos))
{
vector3 = position;
}
}
if ((int)firstStop != 0)
{
Vector3 position = instance1.m_nodes.m_buffer[(int)firstStop].m_position;
if ((double)Vector3.SqrMagnitude(position - vector3) < 16384.0)
{
uint lane = instance1.m_nodes.m_buffer[(int)firstStop].m_lane;
if ((int)lane != 0)
{
ushort segment1 = instance1.m_lanes.m_buffer[lane].m_segment;
if ((int)segment1 != 0 && (instance1.m_segments.m_buffer[(int)segment1].m_flags & NetSegment.Flags.Untouchable) != NetSegment.Flags.None)
{
ushort ownerBuilding = NetSegment.FindOwnerBuilding(segment1, 363f);
if ((int)building == (int)ownerBuilding)
{
hitPos = position;
return(true);
}
}
}
}
}
hitPos = vector3;
return(num2 != 1000000);
}
}
}
return(false);
}
void BuildingBHovered(UIComponent component, UIMouseEventParameter eventParam, BuildingInfo Binf)
{
var tooltipBoxa = UIView.GetAView().FindUIComponent <UIPanel> ("InfoAdvancedTooltip");
var tooltipBox = UIView.GetAView().FindUIComponent <UIPanel> ("InfoAdvancedTooltipDetail");
var spritea = tooltipBoxa.Find <UISprite> ("Sprite");
var sprite = tooltipBox.Find <UISprite> ("Sprite");
sprite.atlas = Binf.m_Atlas;
spritea.atlas = Binf.m_Atlas;
}
public override ToolBase.ToolErrors CheckBuildPosition(bool test, bool visualize, bool overlay, bool autofix, ref NetTool.ControlPoint startPoint, ref NetTool.ControlPoint middlePoint, ref NetTool.ControlPoint endPoint, out BuildingInfo ownerBuilding, out Vector3 ownerPosition, out Vector3 ownerDirection, out int productionRate)
{
ToolBase.ToolErrors toolErrors = base.CheckBuildPosition(test, visualize, overlay, autofix, ref startPoint, ref middlePoint, ref endPoint, out ownerBuilding, out ownerPosition, out ownerDirection, out productionRate);
NetManager instance1 = Singleton <NetManager> .instance;
TerrainManager instance2 = Singleton <TerrainManager> .instance;
if ((int)startPoint.m_node != 0)
{
NetInfo info = instance1.m_nodes.m_buffer[(int)startPoint.m_node].Info;
if (info.m_class.m_subService != this.m_info.m_class.m_subService || info.m_class.m_level != this.m_info.m_class.m_level)
{
toolErrors |= ToolBase.ToolErrors.InvalidShape;
}
}
else if ((int)startPoint.m_segment != 0)
{
NetInfo info = instance1.m_segments.m_buffer[(int)startPoint.m_segment].Info;
if (info.m_class.m_subService != this.m_info.m_class.m_subService || info.m_class.m_level != this.m_info.m_class.m_level)
{
toolErrors |= ToolBase.ToolErrors.InvalidShape;
}
}
if ((int)endPoint.m_node != 0)
{
NetInfo info = instance1.m_nodes.m_buffer[(int)endPoint.m_node].Info;
if (info.m_class.m_subService != this.m_info.m_class.m_subService || info.m_class.m_level != this.m_info.m_class.m_level)
{
toolErrors |= ToolBase.ToolErrors.InvalidShape;
}
}
else if ((int)endPoint.m_segment != 0)
{
NetInfo info = instance1.m_segments.m_buffer[(int)endPoint.m_segment].Info;
if (info.m_class.m_subService != this.m_info.m_class.m_subService || info.m_class.m_level != this.m_info.m_class.m_level)
{
toolErrors |= ToolBase.ToolErrors.InvalidShape;
}
}
Vector3 middlePos1;
Vector3 middlePos2;
NetSegment.CalculateMiddlePoints(startPoint.m_position, middlePoint.m_direction, endPoint.m_position, -endPoint.m_direction, true, true, out middlePos1, out middlePos2);
Bezier2 bezier2;
bezier2.a = VectorUtils.XZ(startPoint.m_position);
bezier2.b = VectorUtils.XZ(middlePos1);
bezier2.c = VectorUtils.XZ(middlePos2);
bezier2.d = VectorUtils.XZ(endPoint.m_position);
int num = Mathf.CeilToInt(Vector2.Distance(bezier2.a, bezier2.d) * 0.005f) + 3;
Segment2 segment;
segment.a = bezier2.a;
for (int index = 1; index <= num; ++index)
{
segment.b = bezier2.Position((float)index / (float)num);
//begin mod
//end mod
segment.a = segment.b;
}
return(toolErrors);
}
private static RuleValidator <PropCityDataRuleXml, PropInfo> Accepts(ItemClass parentItemClass, BuildingInfo buildingInfo, NetInfo netInfo) => (id, x, district, park, info) => x.Accepts(info.m_class, parentItemClass, info.name, buildingInfo?.name, netInfo?.name, district, park);
bool IsRallyPointValid(CPos x, BuildingInfo info)
{
return(info != null && World.IsCellBuildable(x, info));
}
void DrawBuildingButton(BuildingInfo BuildingPrefab, string type)
{
BuildingButton = new UIButton(); //draw button on appropriate panel.
if (type == "reslow")
{
BuildingButton = BuildingPanels [0].AddUIComponent <UIButton> ();
}
if (type == "reshigh")
{
BuildingButton = BuildingPanels [1].AddUIComponent <UIButton> ();
}
if (type == "comlow")
{
BuildingButton = BuildingPanels [2].AddUIComponent <UIButton> ();
}
if (type == "comhigh")
{
BuildingButton = BuildingPanels [3].AddUIComponent <UIButton> ();
}
if (type == "office")
{
BuildingButton = BuildingPanels [4].AddUIComponent <UIButton> ();
}
if (type == "industrial")
{
BuildingButton = BuildingPanels [5].AddUIComponent <UIButton> ();
}
if (type == "farming")
{
BuildingButton = BuildingPanels [6].AddUIComponent <UIButton> ();
}
if (type == "oil")
{
BuildingButton = BuildingPanels [8].AddUIComponent <UIButton> ();
}
if (type == "forest")
{
BuildingButton = BuildingPanels [7].AddUIComponent <UIButton> ();
}
if (type == "ore")
{
BuildingButton = BuildingPanels [9].AddUIComponent <UIButton> ();
}
if (type == "leisure")
{
if (Util.isADinstalled())
{
BuildingButton = BuildingPanels[10].AddUIComponent <UIButton>();
}
else
{
BuildingButton = BuildingPanels[3].AddUIComponent <UIButton>();
}
}
if (type == "tourist")
{
if (Util.isADinstalled())
{
BuildingButton = BuildingPanels[11].AddUIComponent <UIButton>();
}
else
{
BuildingButton = BuildingPanels[3].AddUIComponent <UIButton>();
}
}
BuildingButton.size = new Vector2(109, 100); //apply settings to building buttons.
BuildingButton.atlas = BuildingPrefab.m_Atlas;
BuildingButton.normalFgSprite = BuildingPrefab.m_Thumbnail;
BuildingButton.focusedFgSprite = BuildingPrefab.m_Thumbnail + "Focused";
BuildingButton.hoveredFgSprite = BuildingPrefab.m_Thumbnail + "Hovered";
BuildingButton.pressedFgSprite = BuildingPrefab.m_Thumbnail + "Pressed";
BuildingButton.disabledFgSprite = BuildingPrefab.m_Thumbnail + "Disabled";
BuildingButton.objectUserData = BuildingPrefab;
BuildingButton.horizontalAlignment = UIHorizontalAlignment.Center;
BuildingButton.verticalAlignment = UIVerticalAlignment.Middle;
BuildingButton.pivot = UIPivotPoint.TopCenter;
string localizedTooltip = BuildingPrefab.GetLocalizedTooltip();
int hashCode = TooltipHelper.GetHashCode(localizedTooltip);
UIComponent tooltipBox = GeneratedPanel.GetTooltipBox(hashCode);
BuildingButton.tooltipAnchor = UITooltipAnchor.Anchored;
BuildingButton.isEnabled = enabled;
BuildingButton.tooltip = localizedTooltip;
BuildingButton.tooltipBox = tooltipBox;
BuildingButton.eventClick += (sender, e) => BuildingBClicked(sender, e, BuildingPrefab);
BuildingButton.eventMouseHover += (sender, e) => BuildingBHovered(sender, e, BuildingPrefab);
}
public static Color PreGetColor_Internal(ref Randomizer randomizer, uint randomSeed, PropInfo info, ItemClass parentItemClass, BuildingInfo buildingInfo, NetInfo netInfo, Vector3 position, ref Color?[] arr, ushort idx)
{
Color resultClr = default;
return(!ACEColorGenUtils.GetColorGeneric(
ref resultClr,
idx,
ref arr,
InfoManager.instance.CurrentMode, ColorParametersGetter(info, position), Accepts(parentItemClass, buildingInfo, netInfo), (x, y) => randomSeed)
? resultClr
: info.GetColor(ref randomizer));
}
private void RefreshAreaBuildings(FastList <ushort>[] m_areaBuildings, HashSet <Configuration.Theme> enabledThemes, HashSet <Configuration.Theme> blacklistedThemes, bool includeVariations)
{
int areaBuildingsLength = m_areaBuildings.Length;
for (int i = 0; i < areaBuildingsLength; i++)
{
m_areaBuildings[i] = null;
}
int prefabCount = PrefabCollection <BuildingInfo> .PrefabCount();
for (int j = 0; j < prefabCount; j++)
{
BuildingInfo prefab = PrefabCollection <BuildingInfo> .GetPrefab((uint)j);
if (prefab != null && prefab.m_class.m_service != ItemClass.Service.None && prefab.m_placementStyle == ItemClass.Placement.Automatic && prefab.m_class.m_service <= ItemClass.Service.Office)
{
int privateServiceIndex = ItemClass.GetPrivateServiceIndex(prefab.m_class.m_service);
if (privateServiceIndex != -1)
{
if (prefab.m_cellWidth < 1 || prefab.m_cellWidth > 4 || prefab.m_cellLength < 1 || prefab.m_cellLength > 4)
{
continue;
}
else
{
// mod begin
if (!includeVariations && BuildingVariationManager.instance.IsVariation(prefab.name))
{
continue;
}
int spawnRateSum = 0;
int hits = 0;
if (enabledThemes != null && enabledThemes.Count > 0)
{
foreach (var theme in enabledThemes)
{
var building = theme.getBuilding(prefab.name);
if (building != null && building.include)
{
hits++;
// limit spawn rate to 50
spawnRateSum += Mathf.Clamp(building.spawnRate, 0, 100);
break;
}
}
}
else
{
spawnRateSum = 1;
hits = 1;
}
if (hits == 0 && blacklistedThemes != null)
{
bool onBlacklist = false;
foreach (var theme in blacklistedThemes)
{
var building = theme.getBuilding(prefab.name);
if (building != null && building.include)
{
onBlacklist = true;
break;
}
}
if (onBlacklist)
{
continue;
}
else
{
spawnRateSum = 10;
hits = 1;
}
}
if (hits == 0 || spawnRateSum == 0)
{
continue;
}
// mod end
int areaIndex = GetAreaIndex(prefab.m_class.m_service, prefab.m_class.m_subService, prefab.m_class.m_level, prefab.m_cellWidth, prefab.m_cellLength, prefab.m_zoningMode);
if (m_areaBuildings[areaIndex] == null)
{
m_areaBuildings[areaIndex] = new FastList <ushort>();
}
// mod begin
int spawnRate = spawnRateSum / hits;
for (uint s = 0; s < spawnRate; s++)
{
// mod end
m_areaBuildings[areaIndex].Add((ushort)j);
// mod begin
}
// mod end
}
}
}
}
int num3 = 19;
for (int k = 0; k < num3; k++)
{
for (int l = 0; l < 5; l++)
{
for (int m = 0; m < 4; m++)
{
for (int n = 1; n < 4; n++)
{
int num4 = k;
num4 = num4 * 5 + l;
num4 = num4 * 4 + m;
num4 = num4 * 4 + n;
num4 *= 2;
FastList <ushort> fastList = m_areaBuildings[num4];
FastList <ushort> fastList2 = m_areaBuildings[num4 - 2];
if (fastList2 != null)
{
if (fastList == null)
{
m_areaBuildings[num4] = fastList2;
}
else
{
for (int num5 = 0; num5 < fastList2.m_size; num5++)
{
fastList.Add(fastList2.m_buffer[num5]);
}
}
}
}
}
}
}
}
public ProceduralObject(ProceduralObjectContainer container, List <Texture2D> textures, LayerManager layerManager)
{
if (container.objectType == "PROP")
{
PropInfo sourceProp = Resources.FindObjectsOfTypeAll <PropInfo>().FirstOrDefault(info => info.name == container.basePrefabName);
this._baseProp = sourceProp;
this.id = container.id;
this.basePrefabName = container.basePrefabName;
this.baseInfoType = "PROP";
this.isPloppableAsphalt = sourceProp.IsPloppableAsphalt();
renderDistance = container.renderDistance;
m_position = container.position.ToVector3();
m_rotation = container.rotation.ToQuaternion();
/*
* if (container.meshStatus == 0)
* {
* // CHECK FOR MESH REPETITION
* if (ProceduralUtils.CheckMeshEquivalence(container.vertices, sourceProp.m_mesh.vertices))
* {
* meshStatus = 1;
* m_mesh = sourceProp.m_mesh;
* allVertices = sourceProp.m_mesh.vertices;
* }
* else
* {
* meshStatus = 2;
* m_mesh = sourceProp.m_mesh.InstantiateMesh();
* allVertices = SerializableVector3.ToStandardVector3Array(container.vertices);
* if (container.scale != 0)
* {
* for (int i = 0; i < allVertices.Count(); i++)
* {
* allVertices[i] = new Vector3(allVertices[i].x * container.scale, allVertices[i].y * container.scale, allVertices[i].z * container.scale);
* }
* }
* m_mesh.SetVertices(new List<Vector3>(allVertices));
* // }
* }
* else if (container.meshStatus == 1)
* {
* m_mesh = sourceProp.m_mesh;
* allVertices = sourceProp.m_mesh.vertices;
* }
* else if (container.meshStatus == 2)
* { */
m_mesh = sourceProp.m_mesh.InstantiateMesh();
allVertices = SerializableVector3.ToStandardVector3Array(container.vertices);
if (container.scale != 0)
{
for (int i = 0; i < allVertices.Count(); i++)
{
allVertices[i] = new Vector3(allVertices[i].x * container.scale, allVertices[i].y * container.scale, allVertices[i].z * container.scale);
}
}
m_mesh.SetVertices(new List <Vector3>(allVertices));
// }
m_material = GameObject.Instantiate(sourceProp.m_material); // overkil ??
if (sourceProp.m_mesh.name == "ploppableasphalt-prop" || sourceProp.m_mesh.name == "ploppableasphalt-decal")
{
m_material.ApplyPloppableColor();
}
if (container.hasCustomTexture && textures != null)
{
if (!textures.Any(tex => tex.name == container.customTextureName))
{
Debug.LogError("[ProceduralObjects] An object was found with a texture that doesn't exist anymore with the name " + container.customTextureName + ", therefore loading the default object texture");
}
else
{
var customTex = textures.FirstOrDefault(tex => tex.name == container.customTextureName);
m_material.mainTexture = customTex as Texture;
customTexture = customTex;
}
}
}
else if (container.objectType == "BUILDING")// building
{
BuildingInfo sourceProp = Resources.FindObjectsOfTypeAll <BuildingInfo>().FirstOrDefault(info => info.name == container.basePrefabName);
this._baseBuilding = sourceProp;
this.id = container.id;
this.basePrefabName = container.basePrefabName;
this.baseInfoType = "BUILDING";
this.isPloppableAsphalt = false;
renderDistance = container.renderDistance;
m_position = container.position.ToVector3();
m_rotation = container.rotation.ToQuaternion();
/*
* if (container.meshStatus == 0)
* {
* // CHECK FOR MESH REPETITION
* if (ProceduralUtils.CheckMeshEquivalence(container.vertices, sourceProp.m_mesh.vertices))
* {
* meshStatus = 1;
* m_mesh = sourceProp.m_mesh;
* allVertices = sourceProp.m_mesh.vertices;
* }
* else
* {
* meshStatus = 2;
* m_mesh = sourceProp.m_mesh.InstantiateMesh();
* allVertices = SerializableVector3.ToStandardVector3Array(container.vertices);
* if (container.scale != 0)
* {
* for (int i = 0; i < allVertices.Count(); i++)
* {
* allVertices[i] = new Vector3(allVertices[i].x * container.scale, allVertices[i].y * container.scale, allVertices[i].z * container.scale);
* }
* }
* m_mesh.SetVertices(new List<Vector3>(allVertices));
* // m_mesh.colors = new Color[] { };
* // m_mesh.colors32 = new Color32[] { };}
* // }
* }
* else if (container.meshStatus == 1)
* {
* m_mesh = sourceProp.m_mesh;
* allVertices = sourceProp.m_mesh.vertices;
* }
* else if (container.meshStatus == 2)
* {*/
m_mesh = sourceProp.m_mesh.InstantiateMesh();
allVertices = SerializableVector3.ToStandardVector3Array(container.vertices);
if (container.scale != 0)
{
for (int i = 0; i < allVertices.Count(); i++)
{
allVertices[i] = new Vector3(allVertices[i].x * container.scale, allVertices[i].y * container.scale, allVertices[i].z * container.scale);
}
}
m_mesh.SetVertices(new List <Vector3>(allVertices));
m_mesh.colors = new Color[] { };
m_mesh.colors32 = new Color32[] { };
// }
m_material = GameObject.Instantiate(sourceProp.m_material); // overkill ??
if (container.hasCustomTexture && textures != null)
{
if (!textures.Any(tex => tex.name == container.customTextureName))
{
Debug.LogError("[ProceduralObjects] An object was found with a texture that doesn't exist anymore at the specified path " + container.hasCustomTexture + ", therefore loading the default object texture");
}
else
{
var customTex = textures.FirstOrDefault(tex => tex.name == container.customTextureName);
m_material.mainTexture = customTex as Texture;
customTexture = customTex;
}
}
}
m_visibility = container.visibility;
if (container.textParam != null)
{
m_textParameters = TextParameters.Clone(container.textParam, true);
for (int i = 0; i < m_textParameters.Count(); i++)
{
if (m_textParameters[i].m_fontColor == null)
{
if (m_textParameters[i].serializableColor != null)
{
m_textParameters[i].m_fontColor = m_textParameters[i].serializableColor.ToColor();
}
else
{
m_textParameters[i].m_fontColor = Color.white;
}
}
}
// m_textParameters.SetFonts();
var originalTex = new Texture2D(m_material.mainTexture.width, m_material.mainTexture.height, TextureFormat.RGBA32, false);
originalTex.SetPixels(((Texture2D)m_material.mainTexture).GetPixels());
originalTex.Apply();
m_material.mainTexture = m_textParameters.ApplyParameters(originalTex) as Texture;
}
else
{
m_textParameters = null;
}
disableRecalculation = container.disableRecalculation;
// this.flipFaces = container.flipFaces;
// if (this.flipFaces)
// VertexUtils.flipFaces(this);
historyEditionBuffer = new HistoryBuffer(this);
if (container.layerId != 0)
{
if (layerManager.m_layers.Any(l => l.m_id == container.layerId))
{
layer = layerManager.m_layers.Single(l => l.m_id == container.layerId);
}
else
{
Debug.LogError("[ProceduralObjects] Layer of an object not found !");
}
}
else
{
layer = null;
}
if (container.tilingFactor == 0)
{
this.tilingFactor = 8;
}
else
{
this.tilingFactor = container.tilingFactor;
}
}