public static void Postfix(BuildingAI __instance, BuildingInfo.Prop[] __state) { if (__state != null) { __instance.m_info.m_props = __state; } }
private bool IsMatch(uint index, BuildingAI bld) { switch (Matcher) { case MatchPatternKind.Category: Type t = bld.GetType(); while (true) { if (string.CompareOrdinal(Pattern, t.FullName) == 0) { return(true); } if (string.CompareOrdinal(t.FullName, typeof(BuildingAI).FullName) == 0) { return(false); } t = t.BaseType; } case MatchPatternKind.Name: return(string.CompareOrdinal(Pattern, PrefabCollection <BuildingInfo> .PrefabName(index)) == 0); case MatchPatternKind.Regex: return(Regex.IsMatch(PrefabCollection <BuildingInfo> .PrefabName(index), Pattern)); } return(false); }
private void Effect() { List <BuildingAI> affectedBuildings = new List <BuildingAI>(); int distanceSqrt = this.Scope * this.Scope; Vector2 targetPosition = (Vector2)this.transform.position; TilePosition targetTile = PositionConvertor.GetActorTileIndexFromWorldPosition(this.transform.position); int radius = Mathf.CeilToInt(this.Scope / (float)Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width, ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height)); List <TilePosition> affectedTiles = RoundHelper.FillCircle(targetTile.Column, targetTile.Row, radius); foreach (TilePosition tile in affectedTiles) { if (tile.IsValidActorTilePosition()) { Vector2 p = (Vector2)PositionConvertor.GetWorldPositionFromActorTileIndex(tile); Vector2 dis = p - targetPosition; if (dis.sqrMagnitude <= distanceSqrt) { GameObject building = BattleMapData.Instance.GetBulidingObjectFromActorObstacleMap(tile.Row, tile.Column); if (building != null) { BuildingAI ai = building.GetComponent <BuildingAI>(); if (ai != null && !affectedBuildings.Contains(ai)) { affectedBuildings.Add(ai); ai.SetTarget(this.gameObject, (Vector2)this.transform.position); } } } } } }
void buildingAISelection_eventSelectedIndexChanged(UIComponent component, int value) { if (ToolsModifierControl.toolController.m_editPrefabInfo is BuildingInfo) { BuildingInfo buildingInfo = (BuildingInfo)ToolsModifierControl.toolController.m_editPrefabInfo; if (buildingInfo.m_buildingAI.GetType() == buildingAITypes[value]) { return; // nothing is changed. } BuildingAI backup = buildingInfo.m_buildingAI; GameObject currentGameObject = buildingInfo.m_buildingAI.gameObject; currentGameObject.AddComponent(buildingAITypes[value]); buildingInfo.m_buildingAI = (BuildingAI)currentGameObject.GetComponent(buildingAITypes[value]); buildingInfo.m_buildingAI.m_info = backup.m_info; buildingInfo.m_buildingAI.m_info.m_buildingAI = buildingInfo.m_buildingAI; if (buildingInfo.m_buildingAI == null) { buildingInfo.m_buildingAI = backup; } else { Destroy(backup); } } }
private void deleteAllAssets() { if (LoadingFunctions.Loaded == true) { try { BuildingManager _buildingManager = Singleton <BuildingManager> .instance; int _capacity = _buildingManager.m_buildings.m_buffer.Length; int id; for (id = 0; id < _capacity; id++) { if ((_buildingManager.m_buildings.m_buffer[id].m_flags & Building.Flags.Created) == Building.Flags.None || (_buildingManager.m_buildings.m_buffer[id].m_flags & Building.Flags.Untouchable) != Building.Flags.None || (_buildingManager.m_buildings.m_buffer[id].m_flags & Building.Flags.BurnedDown) != Building.Flags.None || (_buildingManager.m_buildings.m_buffer[id].m_flags & Building.Flags.Demolishing) != Building.Flags.None || (_buildingManager.m_buildings.m_buffer[id].m_flags & Building.Flags.Deleted) != Building.Flags.None) { // Debug.Log("[RF].Hydrology Failed Flag Test: " + _buildingManager.m_buildings.m_buffer[id].m_flags.ToString()); } else { BuildingAI ai = _buildingManager.m_buildings.m_buffer[id].Info.m_buildingAI; if (ai is ParkingSpaceAssetAI) { // Debug.Log("[RF].Hydrology Failed AI Test: " + ai.ToString()); _buildingManager.ReleaseBuilding((ushort)id); } } } } catch (Exception e) { Debug.Log("[PLS].deleteAllAssets Encountered Exception " + e); } } }
internal static bool hasSpareVehicles(ushort buildingID, ref Building data, BuildingAI buildingAI) { string stats = buildingAI.GetLocalizedStats(buildingID, ref data); if ((stats == null) || (stats == "")) { return(false); } stats = stats.Substring(stats.LastIndexOf(':') + 2); Match match = new Regex(@"(\d+)\D+(\d+)").Match(stats); if (match.Success) { int vehiclesInUse = int.Parse(match.Groups[1].Value); int vehiclesAvailable = int.Parse(match.Groups[2].Value); BuildingManager buildingManager = Singleton <BuildingManager> .instance; string buildingName = buildingManager.GetBuildingName(buildingID, InstanceID.Empty); Utils.LogBuilding(String.Format(" - {0} - Capacity check: {1}/{2}, result: {3}", buildingName, vehiclesInUse, vehiclesAvailable, (vehiclesInUse < vehiclesAvailable))); return(vehiclesInUse < vehiclesAvailable); } else { return(false); } }
public static void Postfix(BuildingAI __instance, int layer, ref float maxInstanceDistance) { if (__instance.m_info.m_prefabDataLayer == layer) { maxInstanceDistance = Mathf.Max(maxInstanceDistance, TrueLodTogglerMod.ActiveConfig.BuildingLodDistance); } }
public void BuildStartClear() { MainUIHide(false); //TweenPosition.Begin(top, 0.5f, Vector3.zero); //TweenPosition.Begin(bottom, 0.5f, Vector3.zero); if (randState >= MainDataManager.instance.buildingAIList.Count) { GameObject obj = new GameObject(); BuildingAI buildingAI = obj.AddComponent <BuildingAI>(); obj.transform.parent = buildingAIPanel.transform; obj.transform.localPosition = new Vector3(randState * 1080, 0, 0); MainDataManager.instance.buildingAIList.Add(buildingAI); } List <BuildingLayer> buildingLayerDataList = buildReadyPopupController.buildLayerSelectPopup.buildingLayerDataList; string randName = buildReadyPopupController.buildStartOnPopup.gameObject.transform.FindChild("InputPanel/NameInput").GetComponent <UIInput>().value; MainDataManager.instance.buildingAIList[randState].SetData(buildingLayerDataList, randState, randName); int addMoneyValue = buildReadyPopupController.buildLayerSelectPopup.totalPriceValue; MainDataManager.instance.MoneyChange(-addMoneyValue); Destroy(buildReadyPopupController.gameObject); ArrowReset(); }
public void BuildStartClear() { TweenPosition.Begin(top, 0.5f, Vector3.zero); TweenPosition.Begin(bottom, 0.5f, Vector3.zero); if (randState >= buildingAIList.Count) { GameObject obj = new GameObject(); BuildingAI buildingAI = obj.AddComponent <BuildingAI>(); obj.transform.parent = transform.FindChild("BuildingAIPanel"); obj.transform.localPosition = new Vector3(randState * 1080, 0, 0); buildingAIList.Add(buildingAI); } List <BuildingLayer> buildingLayerDataList = buildLayerSelectPopup.GetComponent <BuildLayerSelectPopup>().buildingLayerDataList; string randName = buildStartOnPopup.transform.FindChild("InputPanel/NameInput").GetComponent <UIInput>().value; buildingAIList[randState].SetData(buildingLayerDataList, randState, randName); MainDataManager.instance.money -= buildLayerSelectPopup.GetComponent <BuildLayerSelectPopup>().totalPriceValue; MoneyChange(); Destroy(buildLayerSelectPopup); Destroy(buildStartOnPopup); ArrowReset(); }
public static void CopyFields(this BuildingInfo oldInfo, string newName) { BuildingInfo newInfo = PrefabCollection <BuildingInfo> .FindLoaded(newName); if (newInfo == null) { return; } BuildingAI oldAI = newInfo.GetComponent <BuildingAI>(); BuildingAI newAI = newInfo.gameObject.AddComponent <BuildingAI>().GetCopyOf(oldAI); Destroy(oldAI); newInfo.m_props = new BuildingInfo.Prop[oldInfo.m_props.Length]; oldInfo.m_props.CopyTo(newInfo.m_props, 0); foreach (FieldInfo fieldInfo in newInfo.GetType().GetFields(Flags)) { string fieldName = fieldInfo.Name; if (fieldName == "m_prefabDataIndex" || fieldName == "WidthCount" || fieldName == "LengthCount") { continue; } object newValue = oldInfo.GetType().GetField(fieldName, Flags).GetValue(oldInfo); if (fieldName == "m_buildingAI") { newValue = newAI; } newInfo.GetType().GetField(fieldName, Flags).SetValue(newInfo, newValue); } }
/// <summary> /// Updates the household numbers of already existing (placed/grown) residential building instances to the current prefab value. /// Called after updating a residential prefab's household count in order to apply changes to existing buildings. /// </summary> /// <param name="prefabName">The (raw BuildingInfo) name of the prefab</param> private void UpdateHouseholds(string prefabName) { // Get building manager instance. var instance = Singleton <BuildingManager> .instance; // Iterate through each building in the scene. for (ushort i = 0; i < instance.m_buildings.m_buffer.Length; i++) { // Get current building instance. Building thisBuilding = instance.m_buildings.m_buffer[i]; // Only interested in residential buildings. BuildingAI thisAI = thisBuilding.Info?.GetAI() as ResidentialBuildingAI; if (thisAI != null) { // Residential building; check for name match. if (thisBuilding.Info.name.Equals(prefabName)) { // Got one! Recalculate home and visit counts. int homeCount = ((ResidentialBuildingAI)thisAI).CalculateHomeCount((ItemClass.Level)thisBuilding.m_level, new Randomizer(i), thisBuilding.Width, thisBuilding.Length); int visitCount = ((ResidentialBuildingAI)thisAI).CalculateVisitplaceCount((ItemClass.Level)thisBuilding.m_level, new Randomizer(i), thisBuilding.Width, thisBuilding.Length); // Apply changes via direct call to EnsureCitizenUnits prefix patch from this mod. RealisticCitizenUnits.Prefix(ref thisAI, i, ref thisBuilding, homeCount, 0, visitCount, 0); } } } }
public static void CalculateUnspawnPositionPostfix(BuildingAI __instance, ushort buildingID, ref Building data, ref Randomizer randomizer, CitizenInfo info, ref Vector3 position, ref Vector3 target, ref CitizenInstance.Flags specialFlags) { if (UserModSettings.Settings.Enabled) { var simulationManager = SimulationManager.instance; var weatherManager = WeatherManager.instance; var rainPercentage = weatherManager.m_currentRain * 100f; if (data.m_eventIndex == 0) { if (data.Enterable() && rainPercentage > 0.5 && UserModSettings.Settings.Citizens_ReactToWeather) { __instance.CalculateSpawnPosition(buildingID, ref data, ref randomizer, info, out var spawnPosition, out var spawnTarget); position = spawnPosition; target = spawnTarget; specialFlags &= ~(CitizenInstance.Flags.HangAround | CitizenInstance.Flags.SittingDown); } else if (!data.Enterable() && (specialFlags & (CitizenInstance.Flags.HangAround | CitizenInstance.Flags.SittingDown)) == CitizenInstance.Flags.None) { specialFlags &= (~CitizenInstance.Flags.InsideBuilding) | CitizenInstance.Flags.HangAround; } } } }
public UniqueBuildingInfo(BuildingInfo oldInfo) { m_buildingAI = oldInfo.m_buildingAI; m_props = oldInfo.m_props; m_placementMode = oldInfo.m_placementMode; m_flattenTerrain = oldInfo.m_flattenTerrain; m_fullGravel = oldInfo.m_fullGravel; m_fullPavement = oldInfo.m_fullPavement; }
void ItemUseOkClick() { int randState = transform.parent.GetComponent <MainController>().randState; BuildingAI data = MainDataManager.instance.buildingAIList[randState]; data.skyloungeOn = true; data.SkyloungeCheck(); transform.parent.GetComponent <MainController>().ItemUserClose(); Destroy(gameObject); }
public static bool RenderInstanceBuildingAIPrefix(BuildingAI __instance, RenderManager.CameraInfo cameraInfo, ushort buildingID, ref Building data, int layerMask, ref RenderManager.Instance instance) { #if UseTask var localData = data; var localInstance = instance; Patcher.Dispatcher.Add(() => __instance.RenderMeshes(cameraInfo, buildingID, ref localData, layerMask, ref localInstance)); #else __instance.RenderMeshes(cameraInfo, buildingID, ref data, layerMask, ref instance); #endif __instance.RenderProps(cameraInfo, buildingID, ref data, layerMask, ref instance, renderFixed: true, renderNonfixed: true); return(false); }
public void EnableBuildingAI() { foreach (GameObject building in m_AttackableBuildingList) { BuildingAI ai = building.GetComponent <BuildingAI>(); ai.enabled = true; } foreach (GameObject defenseObject in this.m_DefenseObjectList) { DefenseObjectAI ai = defenseObject.GetComponent <DefenseObjectAI>(); ai.enabled = true; } }
public static void PatchEveryBuildingAI() { prefabCount = PrefabCollection <BuildingInfo> .PrefabCount(); for (int i = 0; i < prefabCount; ++i) { prefab = PrefabCollection <BuildingInfo> .GetPrefab((uint)i); if (prefab != null) { component = prefab.GetComponent <BuildingAI>(); if (component != null) { Type currentAiType = component.GetType(); Type newAiType = null; if (currentAiType == typeof(ResidentialBuildingAI)) { newAiType = typeof(MyResidentialBuildingAI); } else if (currentAiType == typeof(CommercialBuildingAI)) { newAiType = typeof(MyCommercialBuildingAI); } else if (currentAiType == typeof(IndustrialBuildingAI)) { newAiType = typeof(MyIndustrialBuildingAI); } else if (currentAiType == typeof(IndustrialExtractorAI)) { newAiType = typeof(MyIndustrialExtractorAI); } else if (currentAiType == typeof(OfficeBuildingAI)) { newAiType = typeof(MyOfficeBuildingAI); } if (newAiType != null) { BuildingAI buildingAI = (BuildingAI)prefab.gameObject.AddComponent(newAiType); buildingAI.m_info = prefab; prefab.m_buildingAI = buildingAI; buildingAI.InitializePrefab(); } } } } }
/// <summary> /// Applies settings to a BuildingInfo prefab. /// </summary> /// <param name="prefab">The prefab to modify.</param> /// <param name="ai">The building AI to apply.</param> /// <param name="aiClass">The AI class string to apply.</param> /// <param name="growable">Whether the prefab should be growable.</param> private void InitializePrefab(BuildingInfo prefab, BuildingAI ai, String aiClass, bool growable) { // Non-zero construction time important for other mods (Real Time, Real Construction) - only for private building AIs. if (ai is PrivateBuildingAI) { ((PrivateBuildingAI)ai).m_constructionTime = 30; } prefab.m_buildingAI = ai; prefab.m_buildingAI.m_info = prefab; prefab.m_class = ItemClassCollection.FindClass(aiClass); prefab.m_placementStyle = growable ? ItemClass.Placement.Automatic : ItemClass.Placement.Manual; prefab.m_autoRemove = false; }
public static void Prefix(BuildingAI __instance, ushort buildingID, ref Building data, out BuildingInfo.Prop[] __state) { var districtId = DistrictManager.instance.GetDistrict(data.m_position); if (districtId != 0 && __instance.m_info.name == "L1 3x4 Detached08") { __state = __instance.m_info.m_props; __instance.m_info.m_props = BuildingDecorationManager.instance.SampleProps; } else { __state = null; } }
/// <summary> /// Applies settings to a BuildingInfo prefab. /// </summary> /// <param name="prefab">The prefab to modify.</param> /// <param name="ai">The building AI to apply.</param> /// <param name="aiClass">The AI class string to apply.</param> /// <param name="growable">Whether the prefab should be growable.</param> private void InitializePrefab(BuildingInfo prefab, BuildingAI ai, String aiClass, bool growable) { // Non-zero construction time important for other mods (Real Time, Real Construction) - only for private building AIs. if (ai is PrivateBuildingAI privateBuildingAI) { privateBuildingAI.m_constructionTime = 30; } // Assign required fields. prefab.m_buildingAI = ai; prefab.m_buildingAI.m_info = prefab; prefab.m_class = ItemClassCollection.FindClass(aiClass); prefab.m_placementStyle = growable ? ItemClass.Placement.Automatic : ItemClass.Placement.Manual; prefab.m_autoRemove = growable || !ModSettings.warnBulldoze; }
/// <summary> /// Gets the medium wealth tourist value. /// </summary> /// <param name="ai">The building ai.</param> /// <returns>The medium wealth tourist target number.</returns> public static int GetMediumWealthTourists(this BuildingAI ai) { if (ai is MonumentAI) { return(((MonumentAI)ai).m_visitPlaceCount1); } else if (ai is ParkAI) { return(((ParkAI)ai).m_visitPlaceCount1); } else { return(GetIntProperty(ai, "m_visitPlaceCount1", 0)); } }
public static bool DisplayDistrictsButton(BuildingAI ai) { switch (ai) { case MaintenanceDepotAI _: case MedicalCenterAI _: case SnowDumpAI _: case PostOfficeAI _: case TaxiStandAI _: return(true); default: return(false); } }
/// <summary> /// Sets the low wealth tourist value. /// </summary> /// <param name="ai">The building ai.</param> /// <param name="value">The low wealth tourist target number.</param> public static void SetLowWealthTourists(this BuildingAI ai, int value) { if (ai is MonumentAI) { ((MonumentAI)ai).m_visitPlaceCount0 = value; } else if (ai is ParkAI) { ((ParkAI)ai).m_visitPlaceCount0 = value; } else { SetIntProperty(ai, "m_visitPlaceCount0", value); } }
static void SimulationStep(BuildingAI _this, ushort buildingID, ref Building data) { try { _this.SimulationStep(buildingID, ref data); } catch (Exception e) { string info = $"An exception occured during BuildingAI simulation step.\nAsset: {_this.m_info.name}" + $"\nBuildingID: {buildingID}\nType: {_this.GetType().Name}\nSeverity: High"; HealkitException e2 = new HealkitException(info, e); e2.m_uniqueData = _this.m_info.name; e2.m_supperessMsg = "Suppress similar exceptions caused by this asset"; UIView.ForwardException(e2); } }
public static List <ushort> GetAllDepotsFromCity() { var saida = new List <ushort>(); BuildingManager bm = BuildingManager.instance; FastList <ushort> buildings = bm.GetServiceBuildings(ItemClass.Service.PublicTransport); foreach (ushort i in buildings) { BuildingAI buildingAi = bm.m_buildings.m_buffer[i].Info.m_buildingAI; if ((bm.m_buildings.m_buffer[i].m_flags & Building.Flags.Untouchable) != 0 && ((buildingAi is DepotAI depotAi && depotAi.m_maxVehicleCount > 0) || (buildingAi is ShelterAI))) { saida.Add(i); } } return(saida); }
static bool CheckUnlocking(BuildingAI _this) { try { return(_this.CheckUnlocking()); } catch (Exception e) { string info = $"An exception occured during BuildingAI CheckUnlocking() method.\nAsset: {_this.m_info.name}" + $"\nBuildingID: ??\nType: {_this.GetType().Name}\nSeverity: High"; HealkitException e2 = new HealkitException(info, e); e2.m_uniqueData = _this.m_info.name; e2.m_supperessMsg = "Suppress similar exceptions caused by this asset"; UIView.ForwardException(e2); } return(false); }
public static void Prefix(BuildingInfo __instance) { if (!Mod.IsInGame && !Mod.IsInAssetEditor) { return; } if (__instance.editorCategory == "MovableBridge") { BuildingAI oldAI = __instance.gameObject.GetComponent <BuildingAI>(); if (oldAI is MovableBridgeAI) { UnityEngine.Debug.Log($"MovableBridgeAI already set for ${__instance.name}"); return; } UnityEngine.Debug.Log($"Adding MovableBridgeAI to ${__instance.name}"); MovableBridgeAI newAI = __instance.gameObject.AddComponent <MovableBridgeAI>(); newAI.m_electricityConsumption = 0; newAI.m_waterConsumption = 0; newAI.m_sewageAccumulation = 0; newAI.m_garbageAccumulation = 0; newAI.CopyFrom(oldAI); UnityEngine.Object.DestroyImmediate(oldAI); // disable building LOD __instance.m_lodObject = null; foreach (BuildingInfo.PathInfo pathInfo in __instance.m_paths) { if (pathInfo.m_netInfo.editorCategory == "MovableBridge_Movable" && pathInfo.m_nodes.Length > 1) { if (pathInfo.m_trafficLights == null) { pathInfo.m_trafficLights = new BuildingInfo.TrafficLights[pathInfo.m_nodes.Length]; } pathInfo.m_trafficLights[0] = BuildingInfo.TrafficLights.ForceOn; pathInfo.m_trafficLights[pathInfo.m_trafficLights.Length - 1] = BuildingInfo.TrafficLights.ForceOn; } } } }
public bool replaceBuildingAi <T>(BuildingInfo building, BuildingInfo medicalBuilding) where T : BuildingAI { Logger.logInfo(LOG_AI_REPLACEMENT, "AiReplacementHelper.replaceBuildingAi -- Checking Building: {0}", building); if (building == null) { Logger.logInfo(LOG_AI_REPLACEMENT, "AiReplacementHelper.replaceBuildingAi -- Null Building"); return(false); } if (this.replacedAIs.ContainsKey(building.name)) { Logger.logInfo(LOG_AI_REPLACEMENT, "AiReplacementHelper.replaceBuildingAi -- Did not replace AI for {0}, building AI has already been replaced", building.name); return(true); } if (building.m_buildingAI is DormitoryAi) { Logger.logInfo(LOG_AI_REPLACEMENT, "AiReplacementHelper.replaceBuildingAi -- Did not replace AI for {0}, building already running the DormitoryAi", building.name); return(false); } // Replace the AI BuildingAI originalAi = building.GetComponent <BuildingAI>(); BuildingAI medicalAi = medicalBuilding.GetComponent <BuildingAI>(); T to = building.gameObject.AddComponent <T>(); this.copyBuildingAIAttributes(originalAi, to, medicalAi); this.replacedAIs[building.name] = originalAi; building.m_buildingAI = to; to.m_info = building; // Set the class as a medical building building.m_class = medicalBuilding.m_class; // Set the placement style as manual building.m_placementStyle = ItemClass.Placement.Manual; Logger.logInfo(LOG_AI_REPLACEMENT, "AiReplacementHelper.replaceBuildingAi -- Successfully replaced {0}'s AI", building.name); return(true); }
private void copyBuildingAIAttributes <T>(BuildingAI from, T to, BuildingAI fallback) { var baseType = typeof(T).BaseType; if (baseType != null) { FieldInfo[] fieldInfos = baseType.GetFields(); if (fieldInfos == null) { return; } foreach (FieldInfo fieldInfo in fieldInfos) { try { fieldInfo.SetValue(to, fieldInfo.GetValue(@from)); } catch (ArgumentException e) { fieldInfo.SetValue(to, fieldInfo.GetValue(@fallback)); } } } }
public static bool Prefix(BuildingAI __instance, RenderManager.CameraInfo cameraInfo, ushort buildingID, ref Building data, int layerMask, ref RenderManager.Instance instance) { __instance.m_info.m_rendered = true; if (__instance.m_info.m_mesh != null) { BuildingAI.RenderMesh(cameraInfo, buildingID, ref data, __instance.m_info, ref instance); } if (__instance.m_info.m_subMeshes != null) { for (int i = 0; i < __instance.m_info.m_subMeshes.Length; i++) { BuildingInfo.MeshInfo meshInfo = __instance.m_info.m_subMeshes[i]; if (((meshInfo.m_flagsRequired | meshInfo.m_flagsForbidden) & data.m_flags) == meshInfo.m_flagsRequired) { BuildingInfoSub buildingInfoSub = meshInfo.m_subInfo as BuildingInfoSub; buildingInfoSub.m_rendered = true; if (buildingInfoSub.m_subMeshes != null && buildingInfoSub.m_subMeshes.Length != 0) { for (int j = 0; j < buildingInfoSub.m_subMeshes.Length; j++) { BuildingInfo.MeshInfo meshInfo2 = buildingInfoSub.m_subMeshes[j]; if (((meshInfo2.m_flagsRequired | meshInfo2.m_flagsForbidden) & data.m_flags) == meshInfo2.m_flagsRequired) { BuildingInfoSub buildingInfoSub2 = meshInfo2.m_subInfo as BuildingInfoSub; buildingInfoSub2.m_rendered = true; BuildingAI.RenderMesh(cameraInfo, __instance.m_info, buildingInfoSub2, meshInfo.m_matrix, ref instance); } } } else { BuildingAI.RenderMesh(cameraInfo, __instance.m_info, buildingInfoSub, meshInfo.m_matrix, ref instance); } } } } return(false); }
private void BuildingAIRenderInstance(BuildingAI buildingAI, RenderManager.CameraInfo cameraInfo, ushort buildingID, ref Building data, int layerMask, ref RenderManager.Instance instance) { BuildingAIRenderMeshes(buildingAI, cameraInfo, buildingID, ref data, layerMask, ref instance); }
// private void BuildingAIRenderMeshes(BuildingAI buildingAI, RenderManager.CameraInfo cameraInfo, ushort buildingID, ref Building data, int layerMask, ref RenderManager.Instance instance) { if (buildingAI.m_info.m_mesh != null) { BuildingAIRenderMesh(cameraInfo, buildingID, ref data, buildingAI.m_info, ref instance); } if (buildingAI.m_info.m_subMeshes != null) { for (int i = 0; i < buildingAI.m_info.m_subMeshes.Length; i++) { BuildingInfo.MeshInfo meshInfo = buildingAI.m_info.m_subMeshes[i]; if (((meshInfo.m_flagsRequired | meshInfo.m_flagsForbidden) & data.m_flags) == meshInfo.m_flagsRequired) { BuildingInfoBase subInfo = meshInfo.m_subInfo; BuildingAIRenderMesh(cameraInfo, buildingAI.m_info, subInfo, meshInfo.m_matrix, ref instance); } } } }