public override void RenderOverlay(RenderManager.CameraInfo cameraInfo) { base.RenderOverlay(cameraInfo); if (!enabled) { return; } if (np_hoveredObject.NetSegment != 0) { NetSegment hoveredSegment = np_hoveredObject.NetSegment.S(); NetTool.RenderOverlay(cameraInfo, ref hoveredSegment, _hovc, new Color(1f, 0f, 0f, 1f)); } else if (np_hoveredObject.NetNode != 0 && np_hoveredObject.NetNode < 32768) { NetNode hoveredNode = np_hoveredObject.NetNode.N(); RenderManager.instance.OverlayEffect.DrawCircle(cameraInfo, _hovc, hoveredNode.m_position, Mathf.Max(6f, hoveredNode.Info.m_halfWidth * 2f), -1f, 1280f, false, true); } else if (np_hoveredObject.Building != 0) { Building hoveredBuilding = np_hoveredObject.Building.B(); BuildingTool.RenderOverlay(cameraInfo, ref hoveredBuilding, _hovc, _hovc); } else if (np_hoveredObject.Tree != 0) { TreeInstance hoveredTree = np_hoveredObject.Tree.T(); TreeTool.RenderOverlay(cameraInfo, hoveredTree.Info, hoveredTree.Position, hoveredTree.Info.m_minScale, _hovc); } else if (np_hoveredObject.Prop != 0) { PropInstance hoveredTree = np_hoveredObject.Prop.P(); PropTool.RenderOverlay(cameraInfo, hoveredTree.Info, hoveredTree.Position, hoveredTree.Info.m_minScale, hoveredTree.Angle, _hovc); } }
protected override void OnButtonClicked(UIComponent comp) { object objectUserData = comp.objectUserData; NetInfo netInfo = objectUserData as NetInfo; BuildingInfo buildingInfo = objectUserData as BuildingInfo; if ((UnityEngine.Object)netInfo != (UnityEngine.Object)null) { if ((UnityEngine.Object) this.roadsOptionPanel != (UnityEngine.Object)null) { this.roadsOptionPanel.Show(); } NetToolFine netTool = ToolsModifierControl.SetTool <NetToolFine>(); if ((UnityEngine.Object)netTool != (UnityEngine.Object)null) { netTool.m_prefab = netInfo; } } if (!((UnityEngine.Object)buildingInfo != (UnityEngine.Object)null)) { return; } if ((UnityEngine.Object) this.roadsOptionPanel != (UnityEngine.Object)null) { this.roadsOptionPanel.Hide(); } BuildingTool buildingTool = ToolsModifierControl.SetTool <BuildingTool>(); if (!((UnityEngine.Object)buildingTool != (UnityEngine.Object)null)) { return; } buildingTool.m_prefab = buildingInfo; buildingTool.m_relocate = 0; }
public override void RenderCloneGeometry(InstanceState instanceState, ref Matrix4x4 matrix4x, Vector3 deltaPosition, float deltaAngle, Vector3 center, bool followTerrain, RenderManager.CameraInfo cameraInfo, Color toolColor) { BuildingState state = instanceState as BuildingState; BuildingInfo buildingInfo = state.info as BuildingInfo; Color color = GetColor(state.instance.id.Building, buildingInfo); Vector3 newPosition = matrix4x.MultiplyPoint(state.position - center); newPosition.y = state.position.y + deltaPosition.y; if (followTerrain) { newPosition.y = newPosition.y - state.terrainHeight + TerrainManager.instance.SampleOriginalRawHeightSmooth(newPosition); } float newAngle = state.angle + deltaAngle; buildingInfo.m_buildingAI.RenderBuildGeometry(cameraInfo, newPosition, newAngle, 0); BuildingTool.RenderGeometry(cameraInfo, buildingInfo, state.length, newPosition, newAngle, false, color); if (buildingInfo.m_subBuildings != null && buildingInfo.m_subBuildings.Length != 0) { Matrix4x4 subMatrix4x = default(Matrix4x4); subMatrix4x.SetTRS(newPosition, Quaternion.AngleAxis(newAngle * Mathf.Rad2Deg, Vector3.down), Vector3.one); for (int i = 0; i < buildingInfo.m_subBuildings.Length; i++) { BuildingInfo buildingInfo2 = buildingInfo.m_subBuildings[i].m_buildingInfo; Vector3 position = subMatrix4x.MultiplyPoint(buildingInfo.m_subBuildings[i].m_position); float angle = buildingInfo.m_subBuildings[i].m_angle * 0.0174532924f + newAngle; buildingInfo2.m_buildingAI.RenderBuildGeometry(cameraInfo, position, angle, 0); BuildingTool.RenderGeometry(cameraInfo, buildingInfo2, 0, position, angle, true, color); } } }
public override void OnUpdate(float realTimeDelta, float simulationTimeDelta) { if (Event.current.alt && Input.GetKeyDown(KeyCode.T)) { var manager = Singleton <InfoManager> .instance; UIView.playSoundDelegate(UIView.GetAView().defaultClickSound, 1f); if (manager.CurrentMode != InfoManager.InfoMode.TerrainHeight) { BuildingTool currentTool = ToolsModifierControl.GetCurrentTool <BuildingTool>(); if (currentTool != null && currentTool.m_relocate != 0) { currentTool.CancelRelocate(); } Singleton <InfoViewsPanel> .instance.CloseToolbar(); WorldInfoPanel.HideAllWorldInfoPanels(); if (Singleton <InfoManager> .exists) { m_previousMode = manager.CurrentMode; m_previousSubInfoMode = manager.CurrentSubMode; Singleton <InfoManager> .instance.SetCurrentMode(InfoManager.InfoMode.TerrainHeight, InfoManager.SubInfoMode.Default); Singleton <GuideManager> .instance.InfoViewUsed(); } } else { Singleton <InfoViewsPanel> .instance.CloseToolbar(); manager.SetCurrentMode(m_previousMode, m_previousSubInfoMode); Singleton <GuideManager> .instance.InfoViewUsed(); } } }
protected override void OnButtonClicked(UIComponent comp) { object objectUserData = comp.objectUserData; BuildingInfo buildingInfo = objectUserData as BuildingInfo; NetInfo netInfo = objectUserData as NetInfo; TreeInfo treeInfo = objectUserData as TreeInfo; PropInfo propInfo = objectUserData as PropInfo; if (buildingInfo != null) { BuildingTool buildingTool = ToolsModifierControl.SetTool <BuildingTool>(); if (buildingTool != null) { if (base.pathsOptionPanel != null) { base.pathsOptionPanel.Hide(); } buildingTool.m_prefab = buildingInfo; buildingTool.m_relocate = 0; } } if (netInfo != null) { NetToolFine netTool = ToolsModifierControl.SetTool <NetToolFine>(); if (netTool != null) { if (base.pathsOptionPanel != null) { base.pathsOptionPanel.Show(); } netTool.m_prefab = netInfo; } } if (treeInfo != null) { TreeTool treeTool = ToolsModifierControl.SetTool <TreeTool>(); if (treeTool != null) { if (base.pathsOptionPanel != null) { base.pathsOptionPanel.Hide(); } treeTool.m_prefab = treeInfo; treeTool.m_mode = TreeTool.Mode.Single; } } if (propInfo != null) { PropTool propTool = ToolsModifierControl.SetTool <PropTool>(); if (propTool != null) { if (base.pathsOptionPanel != null) { base.pathsOptionPanel.Hide(); } propTool.m_prefab = propInfo; propTool.m_mode = PropTool.Mode.Single; } } }
public override ToolBase.ToolErrors CheckBuildPosition( ushort relocateID, ref Vector3 position, ref float angle, float waterHeight, float elevation, ref Segment3 connectionSegment, out int productionRate, out int constructionCost) { ToolBase.ToolErrors toolErrors1 = ToolBase.ToolErrors.None; Vector3 pos; Vector3 dir; bool isQuay; if (this.m_info.m_placementMode == BuildingInfo.PlacementMode.Shoreline && BuildingTool.SnapToCanal(position, out pos, out dir, out isQuay, 40f, false)) { angle = Mathf.Atan2(dir.x, -dir.z); pos += dir * this.m_quayOffset; position.x = pos.x; position.z = pos.z; if (!isQuay) { toolErrors1 |= ToolBase.ToolErrors.ShoreNotFound; } } ToolBase.ToolErrors toolErrors2 = toolErrors1 | base.CheckBuildPosition(relocateID, ref position, ref angle, waterHeight, elevation, ref connectionSegment, out productionRate, out constructionCost); return(toolErrors2); }
public void Start() { animator = GetComponent <Animator>(); roadTool = GetComponent <RoadTool>(); buildingTool = GetComponent <BuildingTool>(); moveUI = GetComponent <MoveUI>(); tileHighlighter = GetComponent <TileHighlighter>(); Menus = new GameObject[] { buildingMenu, mainMenu, buildMenu }; foreach (CompoundButton menuButton in buildMenuButtons) { menuButton.OnButtonClicked += BuildMenuButtonPressed; } foreach (CompoundButton menuButton in mainMenuButtons) { menuButton.OnButtonClicked += MainMenuButtonPressed; } foreach (CompoundButton timeButton in timeButtons) { timeButton.OnButtonClicked += TimeButtonPressed; } }
public static void RenderCloneGeometryImplementation(InstanceState instanceState, ref Matrix4x4 matrix4x, Vector3 deltaPosition, float deltaAngle, Vector3 center, bool followTerrain, RenderManager.CameraInfo cameraInfo) { BuildingInfo info = instanceState.Info.Prefab as BuildingInfo; Color color = GetColor(instanceState.instance.id.Building, info); Vector3 newPosition = matrix4x.MultiplyPoint(instanceState.position - center); newPosition.y = instanceState.position.y + deltaPosition.y; if (followTerrain) { newPosition.y = newPosition.y - instanceState.terrainHeight + TerrainManager.instance.SampleOriginalRawHeightSmooth(newPosition); } float newAngle = instanceState.angle + deltaAngle; info.m_buildingAI.RenderBuildGeometry(cameraInfo, newPosition, newAngle, 0); BuildingTool.RenderGeometry(cameraInfo, info, info.GetLength(), newPosition, newAngle, false, color); if (info.m_subBuildings != null && info.m_subBuildings.Length != 0) { Matrix4x4 subMatrix4x = default; subMatrix4x.SetTRS(newPosition, Quaternion.AngleAxis(newAngle * Mathf.Rad2Deg, Vector3.down), Vector3.one); for (int i = 0; i < info.m_subBuildings.Length; i++) { BuildingInfo buildingInfo2 = info.m_subBuildings[i].m_buildingInfo; Vector3 position = subMatrix4x.MultiplyPoint(info.m_subBuildings[i].m_position); float angle = info.m_subBuildings[i].m_angle * Mathf.Deg2Rad + newAngle; buildingInfo2.m_buildingAI.RenderBuildGeometry(cameraInfo, position, angle, 0); BuildingTool.RenderGeometry(cameraInfo, buildingInfo2, 0, position, angle, true, color); } } }
public static void Prefix(out CallState __state, object __instance) { __state = new CallState(); if (IgnoreHelper.IsIgnored()) { __state.run = false; return; } BuildingTool tool = ReflectionHelper.GetAttr <BuildingTool>(__instance, "$this"); int counter = ReflectionHelper.GetAttr <int>(__instance, "$PC"); ToolBase.ToolErrors ___m_placementErrors = ReflectionHelper.GetAttr <ToolBase.ToolErrors>(tool, "m_placementErrors"); if (counter != 0 || ___m_placementErrors != ToolBase.ToolErrors.None) { __state.run = false; return; } __state.run = true; __state.relocate = tool.m_relocate; // Save relocate state as it will be cleared at the end of the method IgnoreHelper.StartIgnore(); ArrayHandler.StartCollecting(); }
protected override void Handle(BuildingToolCreateCommand command) { BuildingTool tool = ToolSimulator.GetTool <BuildingTool>(command.SenderId); IgnoreHelper.StartIgnore(); ArrayHandler.StartApplying(command.Array16Ids, command.Array32Ids); BuildingInfo prefab = null; if (command.Relocate == 0) { prefab = PrefabCollection <BuildingInfo> .GetPrefab(command.Prefab); } tool.m_prefab = prefab; tool.m_relocate = command.Relocate; ReflectionHelper.SetAttr(tool, "m_mousePosition", command.MousePosition); ReflectionHelper.SetAttr(tool, "m_mouseAngle", command.MouseAngle); ReflectionHelper.SetAttr(tool, "m_elevation", command.Elevation); ReflectionHelper.SetAttr(tool, "m_placementErrors", ToolBase.ToolErrors.None); ReflectionHelper.SetAttr(tool, "m_constructionCost", 0); ToolController controller = ReflectionHelper.GetAttr <ToolController>(tool, "m_toolController"); ReflectionHelper.SetAttr(controller, "m_collidingSegments1", command.CollidingSegments); ReflectionHelper.SetAttr(controller, "m_collidingBuildings1", command.CollidingBuildings); ReflectionHelper.SetAttr(controller, "m_collidingDepth", 1); ReflectionHelper.Call <IEnumerator>(tool, "CreateBuilding")?.MoveNext(); ArrayHandler.StopApplying(); IgnoreHelper.EndIgnore(); }
private static ushort CreateBuilding(BuildingTool _this, BuildingInfo info, Vector3 position, float angle, int relocating, bool needMoney, bool fixedHeight) { Debug.Log("BuildIndex is : " + Singleton <SimulationManager> .instance.m_currentBuildIndex); //call original method try { RICOBuildingManager.AddBuilding(info, Singleton <SimulationManager> .instance.m_currentBuildIndex); } catch (Exception e) { Debug.LogException(e); } CreateBuildingRedirector.Revert(); CreateBuildingAlt(_this, info, position, angle, relocating, needMoney, fixedHeight); CreateBuildingRedirector.Apply(); //Add plopped building to RICOBuildingManager ushort num = 0; return(num); //no clue why it needs to return a ushort, source code doesnt appear to do anything with it. }
// Method based on UpgradeBuilding from BuildingManager public static bool ForceLevelBuilding(ushort buildingID, Level level) { BuildingManager instance = Singleton <BuildingManager> .instance; if (buildingID == 0 || (instance.m_buildings.m_buffer[(int)buildingID].m_flags & Building.Flags.Created) == Building.Flags.None) { return(false); } BuildingInfo info = instance.m_buildings.m_buffer[(int)buildingID].Info; if (info == null) { return(false); } if ((Level)info.m_class.m_level == level) { return(false); } BuildingInfo upgradeInfo = Buildings.GetInfoForLevel(buildingID, ref instance.m_buildings.m_buffer[(int)buildingID], (ItemClass.Level)level); if (upgradeInfo == null || upgradeInfo == info) { return(false); } instance.UpdateBuildingInfo(buildingID, upgradeInfo); upgradeInfo.m_buildingAI.BuildingUpgraded(buildingID, ref instance.m_buildings.m_buffer[(int)buildingID]); int constructionCost = upgradeInfo.m_buildingAI.GetConstructionCost(); Singleton <EconomyManager> .instance.FetchResource(EconomyManager.Resource.Construction, constructionCost, upgradeInfo.m_class); int num = 0; while (buildingID != 0) { BuildingInfo info2 = instance.m_buildings.m_buffer[(int)buildingID].Info; if (info2 != null) { Vector3 position = instance.m_buildings.m_buffer[(int)buildingID].m_position; float angle = instance.m_buildings.m_buffer[(int)buildingID].m_angle; BuildingTool.DispatchPlacementEffect(info2, 0, position, angle, info2.m_cellWidth, info2.m_cellLength, false, false); } buildingID = instance.m_buildings.m_buffer[(int)buildingID].m_subBuilding; if (++num > 49152) { CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace); break; } } return(true); }
public static void SelectPrefab(PrefabInfo prefab) { BuildingInfo buildingInfo = prefab as BuildingInfo; NetInfo netInfo = prefab as NetInfo; TransportInfo transportInfo = prefab as TransportInfo; TreeInfo treeInfo = prefab as TreeInfo; PropInfo propInfo = prefab as PropInfo; if (buildingInfo != null) { BuildingTool buildingTool = ToolsModifierControl.SetTool <BuildingTool>(); if (buildingTool != null) { buildingTool.m_prefab = buildingInfo; buildingTool.m_relocate = 0; } } if (netInfo != null) { NetTool netTool = ToolsModifierControl.SetTool <NetTool>(); if (netTool != null) { netTool.Prefab = netInfo; } } if (transportInfo != null) { TransportTool transportTool = ToolsModifierControl.SetTool <TransportTool>(); if (transportTool != null) { transportTool.m_prefab = transportInfo; transportTool.m_building = 0; } } if (treeInfo != null) { TreeTool treeTool = ToolsModifierControl.SetTool <TreeTool>(); if (treeTool != null) { treeTool.m_prefab = treeInfo; treeTool.m_mode = TreeTool.Mode.Single; } } if (propInfo != null) { PropTool propTool = ToolsModifierControl.SetTool <PropTool>(); if (propTool != null) { propTool.m_prefab = propInfo; propTool.m_mode = PropTool.Mode.Single; } } }
/// <summary> /// Selects an item, including setting the current tool to plop the selected building. /// </summary> /// <param name="index">Display list index number of building to select</param> public void Select(int index) { // Focus the icon. component.normalFgSprite = currentData.DisplayName + "Focused"; component.hoveredFgSprite = currentData.DisplayName + "Focused"; // Apply building prefab to the tool. BuildingTool buildingTool = ToolsModifierControl.SetTool <BuildingTool>(); { buildingTool.m_prefab = currentData.prefab; buildingTool.m_relocate = 0; } }
public override void Start() { m_buildingTool = FindObjectOfType <BuildingTool>(); if (m_buildingTool == null) { #if DEBUG Next.Debug.Log("BuildingTool Not Found"); #endif enabled = false; return; } m_bulldozeTool = FindObjectOfType <BulldozeTool>(); if (m_bulldozeTool == null) { #if DEBUG Next.Debug.Log("BulldozeTool Not Found"); #endif enabled = false; return; } m_netTool = FindObjectOfType <NetTool>(); if (m_netTool == null) { #if DEBUG Next.Debug.Log("NetTool Not Found"); #endif enabled = false; return; } try { m_upgradeButtonTemplate = GameObject.Find("RoadsSmallPanel").GetComponent <GeneratedScrollPanel>().m_OptionsBar.Find <UIButton>("Upgrade"); } catch { #if DEBUG Next.Debug.Log("Upgrade button template not found"); #endif } CreateUI(); SetDict[ToggleType.Depth] = SetStationCustomizations.DEF_DEPTH; SetDict[ToggleType.Length] = SetStationCustomizations.DEF_LENGTH; SetDict[ToggleType.Angle] = SetStationCustomizations.DEF_ANGLE; SetDict[ToggleType.Bend] = SetStationCustomizations.DEF_BEND_STRENGTH; m_oldAngle = 0; }
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo, Color toolColor, Color despawnColor) { if (!isValid) { return; } if (MoveItTool.m_isLowSensitivity) { return; } ushort building = id.Building; BuildingInfo buildingInfo = buildingBuffer[building].Info; if (WillBuildingDespawn(building)) { toolColor = despawnColor; } float alpha = 1f; BuildingTool.CheckOverlayAlpha(buildingInfo, ref alpha); toolColor.a *= alpha; int length = buildingBuffer[building].Length; BuildingTool.RenderOverlay(cameraInfo, buildingInfo, length, OverlayPosition, OverlayAngle, toolColor, false); foreach (Instance subInstance in subInstances) { if (subInstance is MoveableNode mn) { ushort node = mn.id.NetNode; for (int k = 0; k < 8; k++) { ushort segment = netManager.m_nodes.m_buffer[node].GetSegment(k); if (segment != 0 && netManager.m_segments.m_buffer[segment].m_startNode == node && (netManager.m_segments.m_buffer[segment].m_flags & NetSegment.Flags.Untouchable) != NetSegment.Flags.None) { NetTool.RenderOverlay(cameraInfo, ref netManager.m_segments.m_buffer[segment], toolColor, toolColor); } } } else if (subInstance is MoveableBuilding mb) { Building b = buildingBuffer[mb.id.Building]; BuildingTool.RenderOverlay(cameraInfo, (BuildingInfo)mb.Info.Prefab, b.Length, mb.OverlayPosition, mb.OverlayAngle, toolColor, false); } } }
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; } } } } }
public override void RenderGeometry(RenderManager.CameraInfo cameraInfo, Color toolColor) { BuildingInfo buildingInfo = Info.Prefab as BuildingInfo; Color color = GetColor(id.Building, buildingInfo); buildingInfo.m_buildingAI.RenderBuildGeometry(cameraInfo, OverlayPosition, OverlayAngle, 0); BuildingTool.RenderGeometry(cameraInfo, buildingInfo, Length, OverlayPosition, OverlayAngle, false, color); foreach (Instance subInstance in subInstances) { if (subInstance is MoveableBuilding msb) { msb.RenderGeometry(cameraInfo, toolColor); } } }
public override void Start() { m_buildingTool = FindObjectOfType <BuildingTool>(); if (m_buildingTool == null) { #if DEBUG Next.Debug.Log("BuildingTool Not Found"); #endif enabled = false; return; } m_bulldozeTool = FindObjectOfType <BulldozeTool>(); if (m_bulldozeTool == null) { #if DEBUG Next.Debug.Log("BulldozeTool Not Found"); #endif enabled = false; return; } m_netTool = FindObjectOfType <NetTool>(); if (m_netTool == null) { #if DEBUG Next.Debug.Log("NetTool Not Found"); #endif enabled = false; return; } try { m_upgradeButtonTemplate = GameObject.Find("RoadsSmallPanel").GetComponent <GeneratedScrollPanel>().m_OptionsBar.Find <UIButton>("Upgrade"); } catch { #if DEBUG Next.Debug.Log("Upgrade button template not found"); #endif } CreateUI(); trackStyle = 0; }
protected override void OnButtonClicked(UIComponent comp) { Logger.logInfo(PanelHelper.LOG_CUSTOM_PANELS, "CustomBasePanel.OnButtonClicked -- Component Clicked: {0}", comp); BuildingInfo buildingInfo = comp.objectUserData as BuildingInfo; if (!((Object)buildingInfo != (Object)null)) { return; } BuildingTool buildingTool = ToolsModifierControl.SetTool <BuildingTool>(); if (!((Object)buildingTool != (Object)null)) { return; } buildingTool.m_prefab = buildingInfo; buildingTool.m_relocate = 0; }
public void Render(RenderManager.CameraInfo cameraInfo) { if (!IsValidData()) { return; } BuildingManager buildingManager = BuildingManager.instance; uint buildingId = _data.BuildingID; BuildingInfo info = buildingManager.m_buildings.m_buffer[buildingId].Info; int length = buildingManager.m_buildings.m_buffer[buildingId].Length; Vector3 position = buildingManager.m_buildings.m_buffer[buildingId].m_position; float angle = buildingManager.m_buildings.m_buffer[buildingId].m_angle; Color color = Color.red; color.a = 0.7f; BuildingTool.RenderOverlay(cameraInfo, info, length, position, angle, color, false); }
//similar to BulldozeTool.DeleteBuildingImpl public void Destroy(ushort buildingId, Building building) { BuildingManager instance = Singleton <BuildingManager> .instance; BuildingInfo info = building.Info; Vector3 position = building.m_position; float angle = building.m_angle; int width = building.Width; int length = building.Length; bool collapsed = (building.m_flags & Building.Flags.Collapsed) != Building.Flags.None; instance.ReleaseBuilding(buildingId); int publicServiceIndex = ItemClass.GetPublicServiceIndex(info.m_class.m_service); if (publicServiceIndex != -1) { Singleton <CoverageManager> .instance.CoverageUpdated(info.m_class.m_service, info.m_class.m_subService, info.m_class.m_level); } BuildingTool.DispatchPlacementEffect(info, buildingId, position, angle, width, length, true, collapsed); }
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; } } } } }
/// <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); } } }
/// <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); } } }
public static void Postfix(ref CallState __state, object __instance) { if (!__state.run) { return; } ArrayHandler.StopCollecting(); IgnoreHelper.EndIgnore(); BuildingTool tool = ReflectionHelper.GetAttr <BuildingTool>(__instance, "$this"); ToolController controller = ReflectionHelper.GetAttr <ToolController>(tool, "m_toolController"); ushort prefab = 0; if (__state.relocate == 0) { prefab = (ushort)Mathf.Clamp(tool.m_prefab.m_prefabDataIndex, 0, 65535); } Vector3 mousePosition = ReflectionHelper.GetAttr <Vector3>(tool, "m_mousePosition"); float mouseAngle = ReflectionHelper.GetAttr <float>(tool, "m_mouseAngle"); int elevation = ReflectionHelper.GetAttr <int>(tool, "m_elevation"); ulong[] collidingSegments = ReflectionHelper.GetAttr <ulong[]>(controller, "m_collidingSegments1"); ulong[] collidingBuildings = ReflectionHelper.GetAttr <ulong[]>(controller, "m_collidingBuildings1"); Command.SendToAll(new BuildingToolCreateCommand() { Array16Ids = ArrayHandler.Collected16, Array32Ids = ArrayHandler.Collected32, Prefab = prefab, Relocate = __state.relocate, CollidingSegments = collidingSegments, CollidingBuildings = collidingBuildings, MousePosition = mousePosition, MouseAngle = mouseAngle, Elevation = elevation }); }
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo) { base.RenderOverlay(cameraInfo); if (!enabled) { return; } if (hoveredId.NetSegment != 0) { NetSegment hoveredSegment = hoveredId.NetSegment.S(); NetTool.RenderOverlay(cameraInfo, ref hoveredSegment, hoverColor, hoverColor); } //else if (hoveredObject.NetNode != 0 && hoveredObject.NetNode < 32768) //{ // NetNode hoveredNode = hoveredObject.NetNode.N(); // RenderManager.instance.OverlayEffect.DrawCircle(cameraInfo, hoverColor, hoveredNode.m_position, Mathf.Max(6f, hoveredNode.Info.m_halfWidth * 2f), -1f, 1280f, false, true); //} else if (hoveredId.Building != 0) { Building hoveredBuilding = hoveredId.Building.B(); BuildingTool.RenderOverlay(cameraInfo, ref hoveredBuilding, hoverColor, hoverColor); while (hoveredBuilding.m_subBuilding > 0) { hoveredBuilding = BuildingManager.instance.m_buildings.m_buffer[hoveredBuilding.m_subBuilding]; BuildingTool.RenderOverlay(cameraInfo, ref hoveredBuilding, hoverColor, hoverColor); } } else if (hoveredId.Tree != 0) { TreeInstance hoveredTree = hoveredId.Tree.T(); TreeTool.RenderOverlay(cameraInfo, hoveredTree.Info, hoveredTree.Position, hoveredTree.Info.m_minScale, hoverColor); } else if (hoveredId.Prop != 0) { PropInstance hoveredProp = hoveredId.Prop.P(); PropTool.RenderOverlay(cameraInfo, hoveredProp.Info, hoveredProp.Position, hoveredProp.Info.m_minScale, hoveredProp.Angle, hoverColor); } }
public override void RenderCloneOverlay(InstanceState instanceState, ref Matrix4x4 matrix4x, Vector3 deltaPosition, float deltaAngle, Vector3 center, bool followTerrain, RenderManager.CameraInfo cameraInfo, Color toolColor) { if (MoveItTool.m_isLowSensitivity && MoveItTool.hideSelectorsOnLowSensitivity) { return; } BuildingState state = instanceState as BuildingState; BuildingInfo buildingInfo = state.Info.Prefab as BuildingInfo; Vector3 newPosition = matrix4x.MultiplyPoint(state.position - center); newPosition.y = state.position.y + deltaPosition.y; if (followTerrain) { newPosition.y = newPosition.y - state.terrainHeight + TerrainManager.instance.SampleOriginalRawHeightSmooth(newPosition); } float newAngle = state.angle + deltaAngle; buildingInfo.m_buildingAI.RenderBuildOverlay(cameraInfo, toolColor, newPosition, newAngle, default); BuildingTool.RenderOverlay(cameraInfo, buildingInfo, state.length, newPosition, newAngle, toolColor, false); if (buildingInfo.m_subBuildings != null && buildingInfo.m_subBuildings.Length != 0) { Matrix4x4 subMatrix4x = default; subMatrix4x.SetTRS(newPosition, Quaternion.AngleAxis(newAngle * Mathf.Rad2Deg, Vector3.down), Vector3.one); for (int i = 0; i < buildingInfo.m_subBuildings.Length; i++) { BuildingInfo buildingInfo2 = buildingInfo.m_subBuildings[i].m_buildingInfo; Vector3 position = subMatrix4x.MultiplyPoint(buildingInfo.m_subBuildings[i].m_position); float angle = buildingInfo.m_subBuildings[i].m_angle * 0.0174532924f + newAngle; buildingInfo2.m_buildingAI.RenderBuildOverlay(cameraInfo, toolColor, position, angle, default); BuildingTool.RenderOverlay(cameraInfo, buildingInfo2, 0, position, angle, toolColor, true); } } }
public static void SimulationStep(BuildingTool b) { if (mouseRay == null) { Init(b); } BuildingInfo buildingInfo; int num; GetPrefabInfo(b,out buildingInfo, out num); if (buildingInfo == null) { return; } ulong[] collidingSegmentBuffer; ulong[] collidingBuildingBuffer; ToolController m_toolController = ToolManager.instance.m_properties; if (m_toolController == null) { return; } m_toolController.BeginColliding(out collidingSegmentBuffer, out collidingBuildingBuffer); try { Ray m_mouseRay = (Ray)mouseRay.GetValue(b); float m_mouseRayLength = (float)mouseRayLength.GetValue(b); ToolBase.RaycastInput input = new ToolBase.RaycastInput(m_mouseRay, m_mouseRayLength); ToolBase.RaycastOutput raycastOutput; bool m_mouseRayValid = (bool)mouseRayValid.GetValue(b); if (m_mouseRayValid && RayCast(input, out raycastOutput)) { Vector3 vector = raycastOutput.m_hitPos; float m_mouseAngle = (float)mouseAngle.GetValue(b); float num2 = m_mouseAngle; bool flag = (Singleton<ToolManager>.instance.m_properties.m_mode & ItemClass.Availability.Game) != ItemClass.Availability.None; float num3 = 0f; ToolBase.ToolErrors toolErrors; if (buildingInfo.m_placementMode == BuildingInfo.PlacementMode.Roadside) { toolErrors = ToolBase.ToolErrors.GridNotFound; float num4 = raycastOutput.m_hitPos.x - 8f; float num5 = raycastOutput.m_hitPos.z - 8f; float num6 = raycastOutput.m_hitPos.x + 8f; float num7 = raycastOutput.m_hitPos.z + 8f; ZoneManager instance = Singleton<ZoneManager>.instance; float num8 = 8f; float num9 = 1000000f; int num10 = Mathf.Max((int)((num4 - 46f) / 64f + FakeZoneManager.HALFGRID), 0); int num11 = Mathf.Max((int)((num5 - 46f) / 64f + FakeZoneManager.HALFGRID), 0); int num12 = Mathf.Min((int)((num6 + 46f) / 64f + FakeZoneManager.HALFGRID), FakeZoneManager.GRIDSIZE - 1); int num13 = Mathf.Min((int)((num7 + 46f) / 64f + FakeZoneManager.HALFGRID), FakeZoneManager.GRIDSIZE - 1); for (int i = num11; i <= num13; i++) { for (int j = num10; j <= num12; j++) { ushort num14 = FakeZoneManager.zoneGrid[i * FakeZoneManager.GRIDSIZE + j]; int num15 = 0; while (num14 != 0) { Vector3 position = instance.m_blocks.m_buffer[(int)num14].m_position; float num16 = Mathf.Max(Mathf.Max(num4 - 46f - position.x, num5 - 46f - position.z), Mathf.Max(position.x - num6 - 46f, position.z - num7 - 46f)); if (num16 < 0f) { FindClosestZone(buildingInfo, num14, raycastOutput.m_hitPos, ref num8, ref num9, ref vector, ref num2); } num14 = instance.m_blocks.m_buffer[(int)num14].m_nextGridBlock; if (++num15 >= 32768) { CODebugBase<LogChannel>.Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace); break; } } } } if (num8 < 8f) { int num17; if (Singleton<ZoneManager>.instance.CheckSpace(vector, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, out num17)) { float num18; float num19; float num20; Building.SampleBuildingHeight(vector, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, buildingInfo, out num18, out num19, out num20); ToolBase.ToolErrors toolErrors2 = (ToolBase.ToolErrors)CheckSpace.Invoke(b, new object[] { buildingInfo, num, vector, num18, num20 + buildingInfo.m_size.y, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, true, collidingSegmentBuffer, collidingBuildingBuffer }); if (num19 - num18 > buildingInfo.m_maxHeightOffset) { toolErrors2 |= ToolBase.ToolErrors.SlopeTooSteep; } if (toolErrors2 == ToolBase.ToolErrors.None) { vector.y = num20; } toolErrors = toolErrors2; } else if (num17 < 0) { Vector3 a = new Vector3(Mathf.Cos(num2), 0f, Mathf.Sin(num2)) * 8f; int num21 = buildingInfo.m_cellWidth >> 1; for (int k = 1; k <= num21; k++) { Vector3 vector2 = vector - a * (float)k; if (Singleton<ZoneManager>.instance.CheckSpace(vector2, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, out num17)) { float num22; float num23; float num24; Building.SampleBuildingHeight(vector2, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, buildingInfo, out num22, out num23, out num24); ToolBase.ToolErrors toolErrors3 = (ToolBase.ToolErrors)CheckSpace.Invoke(b, new object[] { buildingInfo, num, vector2, num22, num24 + buildingInfo.m_size.y, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, true, collidingSegmentBuffer, collidingBuildingBuffer }); if (num23 - num22 > buildingInfo.m_maxHeightOffset) { toolErrors3 |= ToolBase.ToolErrors.SlopeTooSteep; } if (toolErrors3 == ToolBase.ToolErrors.None) { vector2.y = num24; vector = vector2; } toolErrors = toolErrors3; break; } } } else if (num17 > 0) { Vector3 a2 = new Vector3(Mathf.Cos(num2), 0f, Mathf.Sin(num2)) * 8f; int num25 = buildingInfo.m_cellWidth >> 1; for (int l = 1; l <= num25; l++) { Vector3 vector3 = vector + a2 * (float)l; if (Singleton<ZoneManager>.instance.CheckSpace(vector3, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, out num17)) { float num26; float num27; float num28; Building.SampleBuildingHeight(vector3, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, buildingInfo, out num26, out num27, out num28); ToolBase.ToolErrors toolErrors4 = (ToolBase.ToolErrors)CheckSpace.Invoke(b, new object[] { buildingInfo, num, vector3, num26, num28 + buildingInfo.m_size.y, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, true, collidingSegmentBuffer, collidingBuildingBuffer }); if (num27 - num26 > buildingInfo.m_maxHeightOffset) { toolErrors4 |= ToolBase.ToolErrors.SlopeTooSteep; } if (toolErrors4 == ToolBase.ToolErrors.None) { vector3.y = num28; vector = vector3; } toolErrors = toolErrors4; break; } } } if (toolErrors != ToolBase.ToolErrors.None) { float num29; float num30; float num31; Building.SampleBuildingHeight(vector, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, buildingInfo, out num29, out num30, out num31); m_toolController.ResetColliding(); toolErrors = (ToolBase.ToolErrors)CheckSpace.Invoke(b, new object[] { buildingInfo, num, vector, num29, num31 + buildingInfo.m_size.y, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, true, collidingSegmentBuffer, collidingBuildingBuffer }); if (num30 - num29 > buildingInfo.m_maxHeightOffset) { toolErrors |= ToolBase.ToolErrors.SlopeTooSteep; } vector.y = num31; } } } else if (buildingInfo.m_placementMode == BuildingInfo.PlacementMode.Shoreline) { toolErrors = ToolBase.ToolErrors.ShoreNotFound; Vector3 vector4; Vector3 vector5; if (Singleton<TerrainManager>.instance.GetShorePos(vector, 50f, out vector4, out vector5, out num3)) { vector = vector4; if (Singleton<TerrainManager>.instance.GetShorePos(vector, 50f, out vector4, out vector5, out num3)) { vector = vector4; num2 = Mathf.Atan2(vector5.x, -vector5.z); float num32; float num33; float num34; Building.SampleBuildingHeight(vector, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, buildingInfo, out num32, out num33, out num34); num32 = Mathf.Min(num3, num32); num34 = Mathf.Max(vector.y, num34); toolErrors = (ToolBase.ToolErrors)CheckSpace.Invoke(b, new object[] { buildingInfo, num, vector, num32, num34 + buildingInfo.m_size.y, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, true, collidingSegmentBuffer, collidingBuildingBuffer }); if (vector.y - num3 > 128f) { toolErrors |= ToolBase.ToolErrors.HeightTooHigh; } vector.y = num34; } } } else if (buildingInfo.m_placementMode == BuildingInfo.PlacementMode.OnSurface) { Quaternion rotation = Quaternion.AngleAxis(b.m_angle, Vector3.down); vector -= rotation * buildingInfo.m_centerOffset; num2 = b.m_angle * 0.0174532924f; float minY; float num35; float num36; Building.SampleBuildingHeight(vector, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, buildingInfo, out minY, out num35, out num36); toolErrors = (ToolBase.ToolErrors)CheckSpace.Invoke(b, new object[] { buildingInfo, num, vector, minY, num36 + buildingInfo.m_size.y, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, true, collidingSegmentBuffer, collidingBuildingBuffer }); vector.y = num36; } else if (buildingInfo.m_placementMode == BuildingInfo.PlacementMode.OnGround) { Quaternion rotation2 = Quaternion.AngleAxis(b.m_angle, Vector3.down); vector -= rotation2 * buildingInfo.m_centerOffset; num2 = b.m_angle * 0.0174532924f; float num37; float num38; float num39; Building.SampleBuildingHeight(vector, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, buildingInfo, out num37, out num38, out num39); toolErrors = (ToolBase.ToolErrors)CheckSpace.Invoke(b, new object[] { buildingInfo, num, vector, num37, num39 + buildingInfo.m_size.y, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, true, collidingSegmentBuffer, collidingBuildingBuffer }); if (num38 - num37 > buildingInfo.m_maxHeightOffset) { toolErrors |= ToolBase.ToolErrors.SlopeTooSteep; } vector.y = num39; } else if (buildingInfo.m_placementMode == BuildingInfo.PlacementMode.OnWater) { Quaternion rotation3 = Quaternion.AngleAxis(b.m_angle, Vector3.down); vector -= rotation3 * buildingInfo.m_centerOffset; num2 = b.m_angle * 0.0174532924f; float minY2; float num40; float num41; Building.SampleBuildingHeight(vector, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, buildingInfo, out minY2, out num40, out num41); toolErrors = (ToolBase.ToolErrors)CheckSpace.Invoke(b, new object[] { buildingInfo, num, vector, minY2, num41 + buildingInfo.m_size.y, num2, buildingInfo.m_cellWidth, buildingInfo.m_cellLength, true, collidingSegmentBuffer, collidingBuildingBuffer }); vector.y = num41; } else { toolErrors = ToolBase.ToolErrors.Pending; } Segment3 connectionSegment = default(Segment3); float elevation = GetElevation(b, buildingInfo); int productionRate; int num42; toolErrors |= buildingInfo.m_buildingAI.CheckBuildPosition((ushort)num, ref vector, ref num2, num3, elevation, ref connectionSegment, out productionRate, out num42); if (buildingInfo.m_subBuildings != null && buildingInfo.m_subBuildings.Length != 0) { Matrix4x4 matrix4x = default(Matrix4x4); matrix4x.SetTRS(vector, Quaternion.AngleAxis(num2 * 57.29578f, Vector3.down), Vector3.one); for (int m = 0; m < buildingInfo.m_subBuildings.Length; m++) { BuildingInfo buildingInfo2 = buildingInfo.m_subBuildings[m].m_buildingInfo; Vector3 vector6 = matrix4x.MultiplyPoint(buildingInfo.m_subBuildings[m].m_position); float num43 = buildingInfo.m_subBuildings[m].m_angle * 0.0174532924f + (float)cachedAngle.GetValue(b); Segment3 segment = default(Segment3); int num44; int num45; toolErrors |= buildingInfo2.m_buildingAI.CheckBuildPosition((ushort)num, ref vector6, ref num43, num3, elevation, ref segment, out num44, out num45); num42 += num45; } } if (flag && Singleton<EconomyManager>.instance.PeekResource(EconomyManager.Resource.Construction, num42) != num42) { toolErrors |= ToolBase.ToolErrors.NotEnoughMoney; } if (!Singleton<BuildingManager>.instance.CheckLimits()) { toolErrors |= ToolBase.ToolErrors.TooManyObjects; } FakeBuildingTool.mousePosition.SetValue(b, vector); FakeBuildingTool.mouseAngle.SetValue(b, num2); FakeBuildingTool.connectionSegment.SetValue(b, connectionSegment); FakeBuildingTool.productionRate.SetValue(b, productionRate); FakeBuildingTool.constructionCost.SetValue(b, num42); FakeBuildingTool.placementErrors.SetValue(b, toolErrors); } else { FakeBuildingTool.placementErrors.SetValue(b, ToolBase.ToolErrors.RaycastFailed); FakeBuildingTool.connectionSegment.SetValue(b, new Segment3()); } } finally { m_toolController.EndColliding(); } }
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo, Color toolColor, Color despawnColor) { if (!isValid) { return; } ushort building = id.Building; BuildingInfo buildingInfo = buildingBuffer[building].Info; if (WillBuildingDespawn(building)) { toolColor = despawnColor; } float alpha = 1f; BuildingTool.CheckOverlayAlpha(buildingInfo, ref alpha); toolColor.a *= alpha; int length = buildingBuffer[building].Length; Vector3 position = buildingBuffer[building].m_position; float angle = buildingBuffer[building].m_angle; BuildingTool.RenderOverlay(cameraInfo, buildingInfo, length, position, angle, toolColor, false); ushort node = buildingBuffer[building].m_netNode; int count = 0; while (node != 0) { for (int k = 0; k < 8; k++) { ushort segment2 = netManager.m_nodes.m_buffer[node].GetSegment(k); if (segment2 != 0 && netManager.m_segments.m_buffer[segment2].m_startNode == node && (netManager.m_segments.m_buffer[segment2].m_flags & NetSegment.Flags.Untouchable) != NetSegment.Flags.None) { NetTool.RenderOverlay(cameraInfo, ref netManager.m_segments.m_buffer[segment2], toolColor, toolColor); } } node = netManager.m_nodes.m_buffer[node].m_nextBuildingNode; if (++count > 32768) { CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace); break; } } ushort subBuilding = buildingBuffer[building].m_subBuilding; count = 0; while (subBuilding != 0) { BuildingInfo subBuildingInfo = buildingBuffer[subBuilding].Info; int subLength = buildingBuffer[subBuilding].Length; Vector3 subPosition = buildingBuffer[subBuilding].m_position; float subAngle = buildingBuffer[subBuilding].m_angle; BuildingTool.RenderOverlay(cameraInfo, subBuildingInfo, subLength, subPosition, subAngle, toolColor, false); subBuilding = buildingBuffer[subBuilding].m_subBuilding; if (++count > 49152) { CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace); break; } } }
public void Start() { NetSkins_Support.Init(); // Getting NetTool m_netTool = GameObject.FindObjectOfType <NetTool>(); if (m_netTool == null) { DebugUtils.Warning("NetTool not found."); enabled = false; return; } // Getting BulldozeTool m_bulldozeTool = GameObject.FindObjectOfType <BulldozeTool>(); if (m_bulldozeTool == null) { DebugUtils.Warning("BulldozeTool not found."); enabled = false; return; } // Getting BuildingTool m_buildingTool = GameObject.FindObjectOfType <BuildingTool>(); if (m_buildingTool == null) { DebugUtils.Warning("BuildingTool not found."); enabled = false; return; } // Getting NetTool private fields m_elevationField = m_netTool.GetType().GetField("m_elevation", BindingFlags.NonPublic | BindingFlags.Instance); m_elevationUpField = m_netTool.GetType().GetField("m_buildElevationUp", BindingFlags.NonPublic | BindingFlags.Instance); m_elevationDownField = m_netTool.GetType().GetField("m_buildElevationDown", BindingFlags.NonPublic | BindingFlags.Instance); m_buildingElevationField = m_buildingTool.GetType().GetField("m_elevation", BindingFlags.NonPublic | BindingFlags.Instance); m_controlPointCountField = m_netTool.GetType().GetField("m_controlPointCount", BindingFlags.NonPublic | BindingFlags.Instance); m_upgradingField = m_netTool.GetType().GetField("m_upgrading", BindingFlags.NonPublic | BindingFlags.Instance); m_placementErrorsField = m_buildingTool.GetType().GetField("m_placementErrors", BindingFlags.NonPublic | BindingFlags.Instance); if (m_elevationField == null || m_elevationUpField == null || m_elevationDownField == null || m_buildingElevationField == null || m_controlPointCountField == null || m_upgradingField == null || m_placementErrorsField == null) { DebugUtils.Warning("NetTool fields not found"); m_netTool = null; enabled = false; return; } // Getting Upgrade button template try { m_upgradeButtonTemplate = GameObject.Find("RoadsSmallPanel").GetComponent <GeneratedScrollPanel>().m_OptionsBar.Find <UIButton>("Upgrade"); } catch { DebugUtils.Warning("Upgrade button template not found"); } // Creating UI CreateToolOptionsButton(); // Store segment count m_segmentCount = NetManager.instance.m_segmentCount; // Getting control points try { m_controlPoints = m_netTool.GetType().GetField("m_controlPoints", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(m_netTool) as NetTool.ControlPoint[]; m_cachedControlPoints = m_netTool.GetType().GetField("m_cachedControlPoints", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(m_netTool) as NetTool.ControlPoint[]; } catch { DebugUtils.Warning("ControlPoints not found"); } // Init dictionary RoadPrefab.Initialize(); m_inEditor = (ToolManager.instance.m_properties.m_mode & ItemClass.Availability.AssetEditor) != ItemClass.Availability.None; RoadPrefab.singleMode = m_inEditor; if (changeMaxTurnAngle.value) { RoadPrefab.SetMaxTurnAngle(maxTurnAngle.value); } // Update Catenary UpdateCatenary(); // Fix nodes FixNodes(); DebugUtils.Log("Initialized"); }
public override void SimulationStep() { BuildingInfo info; int relocating; this.GetPrefabInfo(out info, out relocating); if (info == null) { return; } ulong[] collidingSegments; ulong[] collidingBuildings; this.m_toolController.BeginColliding(out collidingSegments, out collidingBuildings); try { ToolBase.RaycastOutput output; if (m_mouseRayValid && ToolBase.RayCast(new ToolBase.RaycastInput(this.m_mouseRay, this.m_mouseRayLength), out output)) { Vector3 vector3_1 = output.m_hitPos; float num1 = this.m_mouseAngle; bool flag = (Singleton <ToolManager> .instance.m_properties.m_mode & ItemClass.Availability.Game) != ItemClass.Availability.None; float waterHeight = 0.0f; Segment3 connectionSegment1 = new Segment3(); float elevation = this.GetElevation(info); int productionRate1; int constructionCost1; ToolBase.ToolErrors toolErrors1; if (info.m_placementMode == BuildingInfo.PlacementMode.Roadside) { ToolBase.ToolErrors toolErrors2 = ToolBase.ToolErrors.GridNotFound; float num2 = output.m_hitPos.x - 8f; float num3 = output.m_hitPos.z - 8f; float num4 = output.m_hitPos.x + 8f; float num5 = output.m_hitPos.z + 8f; ZoneManager instance = Singleton <ZoneManager> .instance; float minD = 8f; float min2 = 1000000f; //begin mod int num6 = Mathf.Max((int)(((double)num2 - 46.0) / 64.0 + FakeZoneManager.HALFGRID), 0); int num7 = Mathf.Max((int)(((double)num3 - 46.0) / 64.0 + FakeZoneManager.HALFGRID), 0); int num8 = Mathf.Min((int)(((double)num4 + 46.0) / 64.0 + FakeZoneManager.HALFGRID), FakeZoneManager.GRIDSIZE - 1); int num9 = Mathf.Min((int)(((double)num5 + 46.0) / 64.0 + FakeZoneManager.HALFGRID), FakeZoneManager.GRIDSIZE - 1); //end mod this.m_tempZoneBuffer.Clear(); if (relocating != 0) { this.GetAllZoneBlocks((ushort)relocating, this.m_tempZoneBuffer); } for (int index1 = num7; index1 <= num9; ++index1) { for (int index2 = num6; index2 <= num8; ++index2) { //begin mod ushort nextGridBlock = instance.m_zoneGrid[index1 * FakeZoneManager.GRIDSIZE + index2]; //end mod int num10 = 0; while ((int)nextGridBlock != 0) { if (!this.m_tempZoneBuffer.Contains(nextGridBlock)) { Vector3 position = instance.m_blocks.m_buffer[(int)nextGridBlock].m_position; if ((double)Mathf.Max(Mathf.Max(num2 - 46f - position.x, num3 - 46f - position.z), Mathf.Max((float)((double)position.x - (double)num4 - 46.0), (float)((double)position.z - (double)num5 - 46.0))) < 0.0) { this.FindClosestZone(info, nextGridBlock, output.m_hitPos, ref minD, ref min2, ref vector3_1, ref num1); } } nextGridBlock = instance.m_blocks.m_buffer[(int)nextGridBlock].m_nextGridBlock; if (++num10 >= 49152) { CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + System.Environment.StackTrace); break; } } } } if ((double)minD < 8.0) { int offset; if (Singleton <ZoneManager> .instance.CheckSpace(vector3_1, num1, info.m_cellWidth, info.m_cellLength, out offset)) { float minY; float maxY; float buildingY; Building.SampleBuildingHeight(vector3_1, num1, info.m_cellWidth, info.m_cellLength, info, out minY, out maxY, out buildingY); Vector3 pos = vector3_1; pos.y = buildingY; ToolBase.ToolErrors toolErrors3 = BuildingTool.CheckSpace(info, info.m_placementMode, relocating, pos, minY, buildingY + info.m_collisionHeight, num1, info.m_cellWidth, info.m_cellLength, true, collidingSegments, collidingBuildings); if ((double)maxY - (double)minY > (double)info.m_maxHeightOffset) { toolErrors3 |= ToolBase.ToolErrors.SlopeTooSteep; } if (toolErrors3 == ToolBase.ToolErrors.None) { vector3_1.y = buildingY; } toolErrors2 = toolErrors3; } else if (offset < 0) { Vector3 vector3_2 = new Vector3(Mathf.Cos(num1), 0.0f, Mathf.Sin(num1)) * 8f; int num10 = info.m_cellWidth >> 1; for (int index = 1; index <= num10; ++index) { Vector3 vector3_3 = vector3_1 - vector3_2 * (float)index; if (Singleton <ZoneManager> .instance.CheckSpace(vector3_3, num1, info.m_cellWidth, info.m_cellLength, out offset)) { float minY; float maxY; float buildingY; Building.SampleBuildingHeight(vector3_3, num1, info.m_cellWidth, info.m_cellLength, info, out minY, out maxY, out buildingY); Vector3 pos = vector3_3; pos.y = buildingY; ToolBase.ToolErrors toolErrors3 = BuildingTool.CheckSpace(info, info.m_placementMode, relocating, pos, minY, buildingY + info.m_collisionHeight, num1, info.m_cellWidth, info.m_cellLength, true, collidingSegments, collidingBuildings); if ((double)maxY - (double)minY > (double)info.m_maxHeightOffset) { toolErrors3 |= ToolBase.ToolErrors.SlopeTooSteep; } if (toolErrors3 == ToolBase.ToolErrors.None) { vector3_3.y = buildingY; vector3_1 = vector3_3; } toolErrors2 = toolErrors3; break; } } } else if (offset > 0) { Vector3 vector3_2 = new Vector3(Mathf.Cos(num1), 0.0f, Mathf.Sin(num1)) * 8f; int num10 = info.m_cellWidth >> 1; for (int index = 1; index <= num10; ++index) { Vector3 vector3_3 = vector3_1 + vector3_2 * (float)index; if (Singleton <ZoneManager> .instance.CheckSpace(vector3_3, num1, info.m_cellWidth, info.m_cellLength, out offset)) { float minY; float maxY; float buildingY; Building.SampleBuildingHeight(vector3_3, num1, info.m_cellWidth, info.m_cellLength, info, out minY, out maxY, out buildingY); Vector3 pos = vector3_3; pos.y = buildingY; ToolBase.ToolErrors toolErrors3 = BuildingTool.CheckSpace(info, info.m_placementMode, relocating, pos, minY, buildingY + info.m_collisionHeight, num1, info.m_cellWidth, info.m_cellLength, true, collidingSegments, collidingBuildings); if ((double)maxY - (double)minY > (double)info.m_maxHeightOffset) { toolErrors3 |= ToolBase.ToolErrors.SlopeTooSteep; } if (toolErrors3 == ToolBase.ToolErrors.None) { vector3_3.y = buildingY; vector3_1 = vector3_3; } toolErrors2 = toolErrors3; break; } } } if (toolErrors2 != ToolBase.ToolErrors.None) { float minY; float maxY; float buildingY; Building.SampleBuildingHeight(vector3_1, num1, info.m_cellWidth, info.m_cellLength, info, out minY, out maxY, out buildingY); Vector3 pos = vector3_1; pos.y = buildingY; this.m_toolController.ResetColliding(); toolErrors2 = BuildingTool.CheckSpace(info, info.m_placementMode, relocating, pos, minY, buildingY + info.m_collisionHeight, num1, info.m_cellWidth, info.m_cellLength, true, collidingSegments, collidingBuildings); if ((double)maxY - (double)minY > (double)info.m_maxHeightOffset) { toolErrors2 |= ToolBase.ToolErrors.SlopeTooSteep; } vector3_1.y = buildingY; } } toolErrors1 = toolErrors2 | info.m_buildingAI.CheckBuildPosition((ushort)relocating, ref vector3_1, ref num1, waterHeight, elevation, ref connectionSegment1, out productionRate1, out constructionCost1); } else if (info.m_placementMode == BuildingInfo.PlacementMode.Shoreline || info.m_placementMode == BuildingInfo.PlacementMode.ShorelineOrGround) { Vector3 pos; Vector3 dir; bool isQuay; bool canal = BuildingTool.SnapToCanal(vector3_1, out pos, out dir, out isQuay, 40f, false); Vector3 position; Vector3 direction; bool shorePos = Singleton <TerrainManager> .instance.GetShorePos(pos, 50f, out position, out direction, out waterHeight); if (canal) { vector3_1 = pos; num1 = Mathf.Atan2(dir.x, -dir.z); float buildWaterHeight = Mathf.Max(0.0f, pos.y); float minY1; float maxY; float buildingY; Building.SampleBuildingHeight(vector3_1, num1, info.m_cellWidth, info.m_cellLength, info, out minY1, out maxY, out buildingY, ref buildWaterHeight); float minY2 = minY1 - 20f; float num2 = Mathf.Max(vector3_1.y, buildingY); float y = vector3_1.y; vector3_1.y = num2; toolErrors1 = info.m_buildingAI.CheckBuildPosition((ushort)relocating, ref vector3_1, ref num1, waterHeight, elevation, ref connectionSegment1, out productionRate1, out constructionCost1) | BuildingTool.CheckSpace(info, BuildingInfo.PlacementMode.Shoreline, relocating, vector3_1, minY2, num2 + info.m_collisionHeight, num1, info.m_cellWidth, info.m_cellLength, true, collidingSegments, collidingBuildings); if ((double)y - (double)minY2 > 128.0) { toolErrors1 |= ToolBase.ToolErrors.HeightTooHigh; } } else if (shorePos) { vector3_1 = position; if (Singleton <TerrainManager> .instance.GetShorePos(vector3_1, 50f, out position, out direction, out waterHeight)) { position += direction.normalized * info.m_placementOffset; vector3_1 = position; num1 = Mathf.Atan2(direction.x, -direction.z); float minY; float maxY; float buildingY; Building.SampleBuildingHeight(vector3_1, num1, info.m_cellWidth, info.m_cellLength, info, out minY, out maxY, out buildingY); minY = Mathf.Min(waterHeight, minY); float num2 = Mathf.Max(vector3_1.y, buildingY); float y = vector3_1.y; vector3_1.y = num2; toolErrors1 = info.m_buildingAI.CheckBuildPosition((ushort)relocating, ref vector3_1, ref num1, waterHeight, elevation, ref connectionSegment1, out productionRate1, out constructionCost1) | BuildingTool.CheckSpace(info, BuildingInfo.PlacementMode.Shoreline, relocating, vector3_1, minY, num2 + info.m_collisionHeight, num1, info.m_cellWidth, info.m_cellLength, true, collidingSegments, collidingBuildings); if ((double)y - (double)waterHeight > 128.0) { toolErrors1 |= ToolBase.ToolErrors.HeightTooHigh; } if ((double)num2 <= (double)waterHeight) { toolErrors1 = toolErrors1 & ~(ToolBase.ToolErrors.HeightTooHigh | ToolBase.ToolErrors.CannotConnect | ToolBase.ToolErrors.CannotBuildOnWater) | ToolBase.ToolErrors.ShoreNotFound; } } else { toolErrors1 = info.m_buildingAI.CheckBuildPosition((ushort)relocating, ref vector3_1, ref num1, waterHeight, elevation, ref connectionSegment1, out productionRate1, out constructionCost1) & ~(ToolBase.ToolErrors.HeightTooHigh | ToolBase.ToolErrors.CannotConnect | ToolBase.ToolErrors.CannotBuildOnWater) | ToolBase.ToolErrors.ShoreNotFound; } } else if (info.m_placementMode == BuildingInfo.PlacementMode.ShorelineOrGround) { Quaternion quaternion = Quaternion.AngleAxis(this.m_angle, Vector3.down); vector3_1 -= quaternion * info.m_centerOffset; num1 = this.m_angle * ((float)System.Math.PI / 180f); float minY; float maxY; float buildingY; Building.SampleBuildingHeight(vector3_1, num1, info.m_cellWidth, info.m_cellLength, info, out minY, out maxY, out buildingY); vector3_1.y = buildingY; toolErrors1 = info.m_buildingAI.CheckBuildPosition((ushort)relocating, ref vector3_1, ref num1, waterHeight, elevation, ref connectionSegment1, out productionRate1, out constructionCost1) | BuildingTool.CheckSpace(info, BuildingInfo.PlacementMode.OnGround, relocating, vector3_1, minY, buildingY + info.m_collisionHeight, num1, info.m_cellWidth, info.m_cellLength, true, collidingSegments, collidingBuildings); if ((toolErrors1 & ToolBase.ToolErrors.CannotBuildOnWater) == ToolBase.ToolErrors.None && (double)maxY - (double)minY > (double)info.m_maxHeightOffset) { toolErrors1 |= ToolBase.ToolErrors.SlopeTooSteep; } } else { toolErrors1 = info.m_buildingAI.CheckBuildPosition((ushort)relocating, ref vector3_1, ref num1, waterHeight, elevation, ref connectionSegment1, out productionRate1, out constructionCost1) & ~(ToolBase.ToolErrors.HeightTooHigh | ToolBase.ToolErrors.CannotConnect | ToolBase.ToolErrors.CannotBuildOnWater) | ToolBase.ToolErrors.ShoreNotFound; } } else if (info.m_placementMode == BuildingInfo.PlacementMode.PathsideOrGround) { Vector3 pos; Vector3 dir; if (BuildingTool.SnapToPath(vector3_1, out pos, out dir, (float)Mathf.Min(info.m_cellWidth, info.m_cellLength) * 3.9f, info.m_hasPedestrianPaths)) { vector3_1 = pos - dir * (float)info.m_cellLength * 4f; num1 = Mathf.Atan2(-dir.x, dir.z); float minY; float maxY; float buildingY; Building.SampleBuildingHeight(vector3_1, num1, info.m_cellWidth, info.m_cellLength, info, out minY, out maxY, out buildingY); toolErrors1 = info.m_buildingAI.CheckBuildPosition((ushort)relocating, ref vector3_1, ref num1, waterHeight, elevation, ref connectionSegment1, out productionRate1, out constructionCost1) | BuildingTool.CheckSpace(info, BuildingInfo.PlacementMode.PathsideOrGround, relocating, vector3_1, minY, vector3_1.y + info.m_collisionHeight, num1, info.m_cellWidth, info.m_cellLength, true, collidingSegments, collidingBuildings); if ((double)maxY - (double)minY > (double)info.m_maxHeightOffset) { toolErrors1 |= ToolBase.ToolErrors.SlopeTooSteep; } } else { Quaternion quaternion = Quaternion.AngleAxis(this.m_angle, Vector3.down); vector3_1 -= quaternion * info.m_centerOffset; num1 = this.m_angle * ((float)System.Math.PI / 180f); float minY; float maxY; float buildingY; Building.SampleBuildingHeight(vector3_1, num1, info.m_cellWidth, info.m_cellLength, info, out minY, out maxY, out buildingY); vector3_1.y = buildingY; toolErrors1 = info.m_buildingAI.CheckBuildPosition((ushort)relocating, ref vector3_1, ref num1, waterHeight, elevation, ref connectionSegment1, out productionRate1, out constructionCost1) | BuildingTool.CheckSpace(info, BuildingInfo.PlacementMode.OnGround, relocating, vector3_1, minY, buildingY + info.m_collisionHeight, num1, info.m_cellWidth, info.m_cellLength, true, collidingSegments, collidingBuildings); if ((double)maxY - (double)minY > (double)info.m_maxHeightOffset) { toolErrors1 |= ToolBase.ToolErrors.SlopeTooSteep; } } } else if (info.m_placementMode == BuildingInfo.PlacementMode.OnSurface || info.m_placementMode == BuildingInfo.PlacementMode.OnTerrain) { Quaternion quaternion = Quaternion.AngleAxis(this.m_angle, Vector3.down); vector3_1 -= quaternion * info.m_centerOffset; num1 = this.m_angle * ((float)System.Math.PI / 180f); float minY; float maxY; float buildingY; Building.SampleBuildingHeight(vector3_1, num1, info.m_cellWidth, info.m_cellLength, info, out minY, out maxY, out buildingY); vector3_1.y = buildingY; toolErrors1 = info.m_buildingAI.CheckBuildPosition((ushort)relocating, ref vector3_1, ref num1, waterHeight, elevation, ref connectionSegment1, out productionRate1, out constructionCost1) | BuildingTool.CheckSpace(info, info.m_placementMode, relocating, vector3_1, minY, buildingY + info.m_collisionHeight, num1, info.m_cellWidth, info.m_cellLength, true, collidingSegments, collidingBuildings); } else if (info.m_placementMode == BuildingInfo.PlacementMode.OnGround) { Quaternion quaternion = Quaternion.AngleAxis(this.m_angle, Vector3.down); vector3_1 -= quaternion * info.m_centerOffset; num1 = this.m_angle * ((float)System.Math.PI / 180f); float minY; float maxY; float buildingY; Building.SampleBuildingHeight(vector3_1, num1, info.m_cellWidth, info.m_cellLength, info, out minY, out maxY, out buildingY); vector3_1.y = buildingY; toolErrors1 = info.m_buildingAI.CheckBuildPosition((ushort)relocating, ref vector3_1, ref num1, waterHeight, elevation, ref connectionSegment1, out productionRate1, out constructionCost1) | BuildingTool.CheckSpace(info, info.m_placementMode, relocating, vector3_1, minY, buildingY + info.m_collisionHeight, num1, info.m_cellWidth, info.m_cellLength, true, collidingSegments, collidingBuildings); if ((double)maxY - (double)minY > (double)info.m_maxHeightOffset) { toolErrors1 |= ToolBase.ToolErrors.SlopeTooSteep; } } else if (info.m_placementMode == BuildingInfo.PlacementMode.OnWater) { Quaternion quaternion = Quaternion.AngleAxis(this.m_angle, Vector3.down); vector3_1 -= quaternion * info.m_centerOffset; num1 = this.m_angle * ((float)System.Math.PI / 180f); float minY; float maxY; float buildingY; Building.SampleBuildingHeight(vector3_1, num1, info.m_cellWidth, info.m_cellLength, info, out minY, out maxY, out buildingY); vector3_1.y = buildingY; toolErrors1 = info.m_buildingAI.CheckBuildPosition((ushort)relocating, ref vector3_1, ref num1, waterHeight, elevation, ref connectionSegment1, out productionRate1, out constructionCost1) | BuildingTool.CheckSpace(info, info.m_placementMode, relocating, vector3_1, minY, buildingY + info.m_collisionHeight, num1, info.m_cellWidth, info.m_cellLength, true, collidingSegments, collidingBuildings); } else { toolErrors1 = ToolBase.ToolErrors.Pending | info.m_buildingAI.CheckBuildPosition((ushort)relocating, ref vector3_1, ref num1, waterHeight, elevation, ref connectionSegment1, out productionRate1, out constructionCost1); } if (info.m_subBuildings != null && info.m_subBuildings.Length != 0) { Matrix4x4 matrix4x4 = new Matrix4x4(); matrix4x4.SetTRS(vector3_1, Quaternion.AngleAxis(num1 * 57.29578f, Vector3.down), Vector3.one); for (int index = 0; index < info.m_subBuildings.Length; ++index) { BuildingInfo buildingInfo = info.m_subBuildings[index].m_buildingInfo; Vector3 position = matrix4x4.MultiplyPoint(info.m_subBuildings[index].m_position); float angle = info.m_subBuildings[index].m_angle * ((float)System.Math.PI / 180f) + num1; Segment3 connectionSegment2 = new Segment3(); int productionRate2; int constructionCost2; toolErrors1 |= buildingInfo.m_buildingAI.CheckBuildPosition((ushort)relocating, ref position, ref angle, waterHeight, elevation, ref connectionSegment2, out productionRate2, out constructionCost2); constructionCost1 += constructionCost2; if ((productionRate2 & 268435456) != 0) { connectionSegment1 = connectionSegment2; productionRate1 = productionRate2 & 268435455; } } } if (flag && Singleton <EconomyManager> .instance.PeekResource(EconomyManager.Resource.Construction, constructionCost1) != constructionCost1) { toolErrors1 |= ToolBase.ToolErrors.NotEnoughMoney; } if (!Singleton <BuildingManager> .instance.CheckLimits()) { toolErrors1 |= ToolBase.ToolErrors.TooManyObjects; } if ((Singleton <ToolManager> .instance.m_properties.m_mode & ItemClass.Availability.AssetEditor) != ItemClass.Availability.None && (UnityEngine.Object) this.m_toolController.m_editPrefabInfo != (UnityEngine.Object)null) { BuildingInfo editPrefabInfo = this.m_toolController.m_editPrefabInfo as BuildingInfo; if ((UnityEngine.Object)editPrefabInfo != (UnityEngine.Object)null && (UnityEngine.Object)editPrefabInfo.m_buildingAI != (UnityEngine.Object)null && !(editPrefabInfo.m_buildingAI is IntersectionAI)) { toolErrors1 = ToolBase.ToolErrors.None; } } this.m_mousePosition = vector3_1; m_mouseAngle = (Singleton <ToolManager> .instance.m_properties.m_mode & ItemClass.Availability.AssetEditor) != ItemClass.Availability.None ? this.m_angle * ((float)System.Math.PI / 180f) : num1; m_connectionSegment = connectionSegment1; this.m_productionRate = productionRate1; this.m_constructionCost = constructionCost1; this.m_placementErrors = toolErrors1; } else { this.m_placementErrors = ToolBase.ToolErrors.RaycastFailed; this.m_connectionSegment = new Segment3(); } } finally { this.m_toolController.EndColliding(); } }
private static void GetPrefabInfo(BuildingTool b, out BuildingInfo info, out int relocating) { info = b.m_prefab; relocating = b.m_relocate; if (info != null) { relocating = 0; return; } if (relocating != 0) { BuildingManager instance = Singleton<BuildingManager>.instance; if ((instance.m_buildings.m_buffer[relocating].m_flags & (Building.Flags.Created | Building.Flags.Deleted)) == Building.Flags.Created) { info = instance.m_buildings.m_buffer[relocating].Info; return; } } info = null; relocating = 0; }
private static void Init(BuildingTool b) { CheckSpace = b.GetType().GetMethod("CheckSpace", BindingFlags.NonPublic | BindingFlags.Instance); mouseRayValid = b.GetType().GetField("m_mouseRayValid", BindingFlags.NonPublic | BindingFlags.Instance); mouseAngle = b.GetType().GetField("m_mouseAngle", BindingFlags.NonPublic | BindingFlags.Instance); mouseRay = b.GetType().GetField("m_mouseRay", BindingFlags.NonPublic | BindingFlags.Instance); mouseRayLength = b.GetType().GetField("m_mouseRayLength", BindingFlags.NonPublic | BindingFlags.Instance); mousePosition = b.GetType().GetField("m_mousePosition", BindingFlags.NonPublic | BindingFlags.Instance); connectionSegment = b.GetType().GetField("m_connectionSegment", BindingFlags.NonPublic | BindingFlags.Instance); productionRate = b.GetType().GetField("m_productionRate", BindingFlags.NonPublic | BindingFlags.Instance); constructionCost = b.GetType().GetField("m_constructionCost", BindingFlags.NonPublic | BindingFlags.Instance); placementErrors = b.GetType().GetField("m_placementErrors", BindingFlags.NonPublic | BindingFlags.Instance); cachedAngle = b.GetType().GetField("m_cachedAngle", BindingFlags.NonPublic | BindingFlags.Instance); elevation = b.GetType().GetField("m_elevation", BindingFlags.NonPublic | BindingFlags.Instance); }
private static float GetElevation(BuildingTool b,BuildingInfo info) { if (info == null) { return 0f; } int num; int num2; info.m_buildingAI.GetElevationLimits(out num, out num2); if (num == num2) { return 0f; } float m_elevation = (float)elevation.GetValue(b); return (float)Mathf.Clamp(m_elevation, num, num2) * 12f; }