public override void SimulationStep() { ToolBase.RaycastInput input = new ToolBase.RaycastInput { m_ray = MouseRay, m_length = MouseRayLength, m_rayRight = MouseRayRight }; if (ToolBase.RayCast(input, out RayOutput)) { MousePosition = RayOutput.m_hitPos; InstanceID instanceID = InstanceID.Empty; if (RayOutput.m_building != 0 && (Singleton <BuildingManager> .instance.m_buildings.m_buffer[(int)RayOutput.m_building].m_flags & Building.Flags.Untouchable) != Building.Flags.None) { RayOutput.m_building = Building.FindParentBuilding(RayOutput.m_building); } if (RayOutput.m_building != 0) { RayOutput.m_hitPos = Singleton <BuildingManager> .instance.m_buildings.m_buffer[(int)RayOutput.m_building].m_position; } else if (RayOutput.m_treeInstance != 0u) { RayOutput.m_hitPos = Singleton <TreeManager> .instance.m_trees.m_buffer[(int)((UIntPtr)RayOutput.m_treeInstance)].Position; } if (RayOutput.m_building != 0) { instanceID.Building = RayOutput.m_building; } else if (RayOutput.m_treeInstance != 0) { instanceID.Tree = RayOutput.m_treeInstance; } SetHoverInstance(instanceID); if (MouseLeftDown != MouseRightDown) { ApplyTool(); } } }
public override void SimulationStep() { ToolBase.RaycastInput input = new ToolBase.RaycastInput { m_ray = MouseRay, m_length = MouseRayLength, m_rayRight = MouseRayRight }; if (MouseRayValid && ToolBase.RayCast(input, out RayOutput)) { InstanceID instanceID = InstanceID.Empty; InstanceID instanceID2 = InstanceID.Empty; if (RayOutput.m_netSegment != 0 && !(NetManager.instance.NetAdjust is null)) { int index = NetManager.instance.NetAdjust.CheckHoverSegment(ref RayOutput.m_netSegment, RayOutput.m_hitPos); if (index != 0) { RayOutput.m_overlayButtonIndex = index; } } if (RayOutput.m_netSegment != 0) { RayOutput.m_hitPos = NetManager.instance.m_segments.m_buffer[RayOutput.m_netSegment].GetClosestPosition(RayOutput.m_hitPos); NetInfo info = NetManager.instance.m_segments.m_buffer[RayOutput.m_netSegment].Info; if (NetUtils.IsValidNet(info)) { instanceID.NetSegment = RayOutput.m_netSegment; ushort segment2 = FindSecondarySegment(RayOutput.m_netSegment); if (segment2 != 0) { instanceID2.NetSegment = segment2; } } } SetHoverInstances(instanceID, instanceID2); SubHoverIndex = RayOutput.m_overlayButtonIndex; if (MouseLeftDown != MouseRightDown) { ApplyTool(); } } }
private void RaycastHoverInstance(Ray mouseRay) { var input = new ToolBase.RaycastInput(mouseRay, Camera.main.farClipPlane); Vector3 origin = input.m_ray.origin; Vector3 normalized = input.m_ray.direction.normalized; Vector3 vector = input.m_ray.origin + (normalized * input.m_length); var ray = new Segment3(origin, vector); BuildingManager.instance.RayCast(ray, ItemClass.Service.None, ItemClass.SubService.None, ItemClass.Layer.Default, Building.Flags.None, out _, out m_hoverBuilding); if (m_parentOnly) { var i = 0; while (BuildingBuffer[m_hoverBuilding].m_parentBuilding != 0 && i < 10) { m_hoverBuilding = BuildingBuffer[m_hoverBuilding].m_parentBuilding; i++; } } }
public static void SnapToGround(this ProceduralObject obj) { obj.historyEditionBuffer.InitializeNewStep(EditingStep.StepType.position, null); ToolBase.RaycastInput rayInput = new ToolBase.RaycastInput(new Ray(obj.m_position, Vector3.down), 10000); ToolBase.RaycastOutput rayOutput; if (ProceduralTool.TerrainRaycast(rayInput, out rayOutput)) { obj.m_position = rayOutput.m_hitPos; } else { rayInput = new ToolBase.RaycastInput(new Ray(obj.m_position, Vector3.up), 10000); if (ProceduralTool.TerrainRaycast(rayInput, out rayOutput)) { obj.m_position = rayOutput.m_hitPos; } } obj.historyEditionBuffer.ConfirmNewStep(null); }
public override void SimulationStep() { base.SimulationStep(); //DefaultTool does not detect NetNodes //-> I'm using code from DefaultTool but keep NetNode var mouseRay = Camera.main.ScreenPointToRay(Input.mousePosition); var mouseRayLength = Camera.main.farClipPlane; var rayRight = Camera.main.transform.TransformDirection(Vector3.right); var mouseRayValid = !UIView.IsInsideUI() && Cursor.visible; if (mouseRayValid) { var defaultService = new ToolBase.RaycastService(ItemClass.Service.None, ItemClass.SubService.None, ItemClass.Layer.Default); var input = new ToolBase.RaycastInput(mouseRay, mouseRayLength) { m_rayRight = rayRight, m_netService = defaultService, m_ignoreNodeFlags = NetNode.Flags.None //other flags and services unnecessary -- I'm only interested in NetNodes }; RaycastOutput output; if (!RayCast(input, out output)) { DebugLog.Error("Not a valid Raycast!"); //TODO: Fehlerbehandlung? _currentNetNodeIdx = 0; return; } //test for intersection var node = GetNetNode(output.m_netNode); if ((node.m_flags & NetNode.Flags.Junction) == NetNode.Flags.Junction) { _currentNetNodeIdx = output.m_netNode; } else { _currentNetNodeIdx = 0; } } }
private void RaycastHoverInstance(Ray mouseRay) { var input = new ToolBase.RaycastInput(mouseRay, Camera.main.farClipPlane); input.m_netService.m_itemLayers = GetItemLayers(); input.m_ignoreTerrain = true; input.m_ignoreSegmentFlags = NetSegment.Flags.None; m_hoverSegment = 0; Vector3 origin = input.m_ray.origin; Vector3 normalized = input.m_ray.direction.normalized; Vector3 vector = input.m_ray.origin + (normalized * input.m_length); ToolBase.RaycastOutput output; output.m_hitPos = vector; output.m_overlayButtonIndex = 0; output.m_netNode = 0; output.m_netSegment = 0; output.m_building = 0; output.m_propInstance = 0; output.m_treeInstance = 0u; output.m_vehicle = 0; output.m_parkedVehicle = 0; output.m_citizenInstance = 0; output.m_transportLine = 0; output.m_transportStopIndex = 0; output.m_transportSegmentIndex = 0; output.m_district = 0; output.m_park = 0; output.m_disaster = 0; output.m_currentEditObject = false; var ray = new Segment3(origin, vector); RayCastSegmentAndNode(input.m_buildObject as NetInfo, ray, input.m_netSnap, input.m_segmentNameOnly, input.m_netService.m_service, input.m_netService2.m_service, input.m_netService.m_subService, input.m_netService2.m_subService, input.m_netService.m_itemLayers, input.m_netService2.m_itemLayers, input.m_ignoreNodeFlags, input.m_ignoreSegmentFlags, out _, out output.m_netNode, out output.m_netSegment); m_hoverSegment = output.m_netSegment; if (m_hoverSegment == 0) { } }
// Raycasting tools public static void RaycastTo(ObjectType type, out RaycastOutput output) { Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); ToolBase.RaycastInput input = new ToolBase.RaycastInput(ray, Camera.main.farClipPlane); input.m_ignoreSegmentFlags = type.IsFlagSet(ObjectType.NetSegment) ? NetSegment.Flags.None : NetSegment.Flags.All; input.m_ignoreNodeFlags = type.IsFlagSet(ObjectType.NetNode) ? NetNode.Flags.None : NetNode.Flags.All; input.m_ignoreParkFlags = type.IsFlagSet(ObjectType.ParkDistrict) ? DistrictPark.Flags.None : DistrictPark.Flags.All; input.m_ignorePropFlags = type.IsFlagSet(ObjectType.Prop) ? PropInstance.Flags.None : PropInstance.Flags.All; input.m_ignoreTreeFlags = type.IsFlagSet(ObjectType.Tree) ? TreeInstance.Flags.None : TreeInstance.Flags.All; input.m_ignoreCitizenFlags = type.IsFlagSet(ObjectType.Citizen) ? CitizenInstance.Flags.None : CitizenInstance.Flags.All; input.m_ignoreVehicleFlags = type.IsFlagSet(ObjectType.Vehicle) ? Vehicle.Flags.Deleted : Vehicle.Flags.Created; input.m_ignoreBuildingFlags = type.IsFlagSet(ObjectType.Building) ? Building.Flags.None : Building.Flags.All; input.m_ignoreDisasterFlags = type.IsFlagSet(ObjectType.Disaster) ? DisasterData.Flags.None : DisasterData.Flags.All; input.m_ignoreTransportFlags = type.IsFlagSet(ObjectType.TransportLine) ? TransportLine.Flags.None : TransportLine.Flags.All; input.m_ignoreParkedVehicleFlags = type.IsFlagSet(ObjectType.ParkedVehicle) ? VehicleParked.Flags.None : VehicleParked.Flags.All; input.m_ignoreDistrictFlags = type.IsFlagSet(ObjectType.District) ? District.Flags.None : District.Flags.All; input.m_ignoreTerrain = !type.IsFlagSet(ObjectType.Position); RayCast(input, out ToolBase.RaycastOutput outputx); output = outputx; }
public override void SimulationStep() { ToolBase.RaycastInput input = new ToolBase.RaycastInput(this.m_mouseRay, this.m_mouseRayLength); ToolBase.RaycastOutput raycastOutput; if (this.m_undoRequest && !this.m_strokeInProgress) { this.ApplyUndo(); this.m_undoRequest = false; } else if (this.m_strokeEnded) { this.EndStroke(); this.m_strokeEnded = false; this.m_strokeInProgress = false; } else if (this.m_mouseRayValid && ToolBase.RayCast(input, out raycastOutput)) { this.m_mousePosition = raycastOutput.m_hitPos; if (this.m_mouseLeftDown != this.m_mouseRightDown) { if (this.m_mode == Mode.ResourceSand) { this.ApplyBrushResource(!m_mouseLeftDown); } else if (m_mode == Mode.Point) { ApplyPoint(!m_mouseLeftDown, this.m_strokeInProgress); this.m_strokeInProgress = true; } else { this.m_strokeInProgress = true; ApplyBrush(); } } } }
// Expose protected method public new static bool RayCast(ToolBase.RaycastInput input, out ToolBase.RaycastOutput output) { return(NetTool.RayCast(input, out output)); }
public override void SimulationStep() { while (!Monitor.TryEnter(this.m_dataLock, SimulationManager.SYNCHRONIZE_TIMEOUT)) { } Ray mouseRay; Vector3 cameraDirection; bool mouseRayValid; try { mouseRay = this.m_mouseRay; cameraDirection = this.m_cameraDirection; mouseRayValid = this.m_mouseRayValid; } finally { Monitor.Exit(this.m_dataLock); } ToolBase.RaycastInput input = new ToolBase.RaycastInput(mouseRay, m_mouseRayLength); ToolBase.RaycastOutput raycastOutput; if (mouseRayValid && ToolBase.RayCast(input, out raycastOutput)) { if (!m_active) { while (!Monitor.TryEnter(this.m_dataLock, SimulationManager.SYNCHRONIZE_TIMEOUT)) { } try { this.m_mouseDirection = cameraDirection; this.m_mousePosition = raycastOutput.m_hitPos; } finally { Monitor.Exit(this.m_dataLock); } } else { while (!Monitor.TryEnter(this.m_dataLock, SimulationManager.SYNCHRONIZE_TIMEOUT)) { } try { if (checkMaxArea(raycastOutput.m_hitPos)) { this.m_mousePosition = raycastOutput.m_hitPos; } } finally { Monitor.Exit(this.m_dataLock); } } } }
protected override void OnToolUpdate() { base.OnToolUpdate(); switch (ProceduralObjectsLogic.toolAction) { case ToolAction.none: switch (ProceduralObjectsLogic.axisState) { case AxisEditionState.none: ToolCursor = (CursorInfo)null; break; case AxisEditionState.X: case AxisEditionState.Z: ToolCursor = terrainLevel; break; case AxisEditionState.Y: ToolCursor = terrainShift; break; } base.ShowToolInfo(false, "", Vector3.zero); break; case ToolAction.vertices: string toolInfo = ""; switch (ProceduralObjectsLogic.verticesToolType) { case 0: ToolCursor = moveVertices; toolInfo = LocalizationManager.instance.current["position"]; break; case 1: ToolCursor = rotateVertices; toolInfo = LocalizationManager.instance.current["rotation"]; break; case 2: ToolCursor = scaleVertices; toolInfo = LocalizationManager.instance.current["scale_obj"]; break; } if (ProceduralObjectsLogic.tabSwitchTimer != 0f) { Vector3 pos = Vector3.zero; ToolBase.RaycastInput rayInput = new ToolBase.RaycastInput(Camera.main.ScreenPointToRay(Input.mousePosition), Camera.main.farClipPlane); ToolBase.RaycastOutput rayOutput; if (ProceduralTool.TerrainRaycast(rayInput, out rayOutput)) { pos = rayOutput.m_hitPos; } base.ShowToolInfo(true, toolInfo, pos); } else { base.ShowToolInfo(false, "", Vector3.zero); } break; case ToolAction.build: ToolCursor = buildCursor; base.ShowToolInfo(true, LocalizationManager.instance.current["click_to_place"], ProceduralObjectsLogic.movingWholeRaycast); break; } }
public override void SimulationStep() { var district = (byte)m_district.GetValue(this); var painting = (bool)m_painting.GetValue(this); var erasing = (bool)m_erasing.GetValue(this); var mouseRayValid = (bool)m_mouseRayValid.GetValue(this); var mouseRayLength = (float)m_mouseRayLength.GetValue(this); var mouseRay = (Ray)m_mouseRay.GetValue(this); var mousePosition = (Vector3)m_mousePosition.GetValue(this); ToolBase.RaycastOutput raycastOutput; ToolBase.RaycastInput raycastInput = new ToolBase.RaycastInput(mouseRay, mouseRayLength) { m_netService = new ToolBase.RaycastService(ItemClass.Service.Road, ItemClass.SubService.None, ItemClass.Layer.Default), m_ignoreNodeFlags = NetNode.Flags.None, m_ignoreSegmentFlags = NetSegment.Flags.None }; if (mouseRayValid && ToolBase.RayCast(raycastInput, out raycastOutput)) { if (this.m_mode == DistrictTool.Mode.Paint || this.m_mode == DistrictTool.Mode.Erase) { if (this.m_layer == DistrictTool.Layer.Districts) { if (district != 0 && Singleton <DistrictManager> .instance.m_districts.m_buffer[district].m_flags == District.Flags.None) { setDistrict(0); } } else if (district != 0 && Singleton <DistrictManager> .instance.m_parks.m_buffer[district].m_flags == DistrictPark.Flags.None) { setDistrict(0); } if (painting && district != 0) { this.ApplyBrush(district); setlastPaintPosition(mousePosition); setErrors(ToolBase.ToolErrors.None); } else if (erasing) { this.ApplyBrush(0); setlastPaintPosition(mousePosition); setErrors(ToolBase.ToolErrors.None); } else if (this.m_layer != DistrictTool.Layer.Districts) { setDistrict(Singleton <DistrictManager> .instance.SamplePark(mousePosition)); setlastPaintPosition(new Vector3(-100000f, -100000f, -100000f)); if (district != 0 || Singleton <DistrictManager> .instance.CheckParkLimits()) { setErrors(ToolBase.ToolErrors.None); } else { setErrors(ToolBase.ToolErrors.TooManyObjects); } } else { setDistrict(Singleton <DistrictManager> .instance.SamplePark(mousePosition)); setlastPaintPosition(new Vector3(-100000f, -100000f, -100000f)); if (district != 0 || Singleton <DistrictManager> .instance.CheckLimits()) { setErrors(ToolBase.ToolErrors.None); } else { setErrors(ToolBase.ToolErrors.TooManyObjects); } } } else { if (this.m_layer != DistrictTool.Layer.Districts) { setDistrict(Singleton <DistrictManager> .instance.SamplePark(mousePosition)); } else { setDistrict(Singleton <DistrictManager> .instance.SamplePark(mousePosition)); } setlastPaintPosition(new Vector3(-100000f, -100000f, -100000f)); setErrors(ToolBase.ToolErrors.None); } } if (!mouseRayValid || !ToolBase.RayCast(raycastInput, out raycastOutput)) { setlastPaintPosition(new Vector3(-100000f, -100000f, -100000f)); setErrors(ToolBase.ToolErrors.RaycastFailed); } else { //begin mod var swapToggle = OptionsWrapper <Options> .Options.defaultToNoSnapping; if ((swapToggle /*&& Input.GetKey(KeyCode.LeftAlt)*/) || (!swapToggle /*&& !Input.GetKey(KeyCode.LeftAlt)*/)) { if (raycastOutput.m_netNode != 0) { raycastOutput.m_hitPos = Singleton <NetManager> .instance.m_nodes.m_buffer[raycastOutput.m_netNode].m_position; } else if (raycastOutput.m_netSegment != 0) { raycastOutput.m_hitPos = Singleton <NetManager> .instance.m_segments.m_buffer[raycastOutput.m_netSegment].GetClosestPosition(raycastOutput.m_hitPos); } } //end mod mousePosition = raycastOutput.m_hitPos; if (this.m_mode == DistrictTool.Mode.Paint || this.m_mode == DistrictTool.Mode.Erase) { if (this.m_layer == DistrictTool.Layer.Districts) { if (district != 0 && Singleton <DistrictManager> .instance.m_districts.m_buffer[district].m_flags == District.Flags.None) { setDistrict(0); } } else if (district != 0 && Singleton <DistrictManager> .instance.m_parks.m_buffer[district].m_flags == DistrictPark.Flags.None) { setDistrict(0); } if (painting && district != 0) { this.ApplyBrush(district); setlastPaintPosition(mousePosition); setErrors(ToolBase.ToolErrors.None); } else if (erasing) { this.ApplyBrush(0); setlastPaintPosition(mousePosition); setErrors(ToolBase.ToolErrors.None); } else if (this.m_layer != DistrictTool.Layer.Districts) { setDistrict(Singleton <DistrictManager> .instance.SamplePark(mousePosition)); setlastPaintPosition(new Vector3(-100000f, -100000f, -100000f)); if (district != 0 || Singleton <DistrictManager> .instance.CheckParkLimits()) { setErrors(ToolBase.ToolErrors.None); } else { setErrors(ToolBase.ToolErrors.TooManyObjects); } } else { setDistrict(Singleton <DistrictManager> .instance.SampleDistrict(mousePosition)); setlastPaintPosition(new Vector3(-100000f, -100000f, -100000f)); if (district != 0 || Singleton <DistrictManager> .instance.CheckLimits()) { setErrors(ToolBase.ToolErrors.None); } else { setErrors(ToolBase.ToolErrors.TooManyObjects); } } } else { if (this.m_layer != DistrictTool.Layer.Districts) { setDistrict(Singleton <DistrictManager> .instance.SamplePark(mousePosition)); } else { setDistrict(Singleton <DistrictManager> .instance.SampleDistrict(mousePosition)); } setlastPaintPosition(new Vector3(-100000f, -100000f, -100000f)); setErrors(ToolBase.ToolErrors.None); } } }
public override void OnUpdate(float realTimeDelta, float simulationTimeDelta) { ModDebug.LogClassAndMethodName(this.GetType().Name, System.Reflection.MethodBase.GetCurrentMethod().Name); if (loadingLevel) return; if (Input.GetKeyDown(KeyCode.Return)) { ModDebug.Log(netTool.m_prefab + " " + netTool.m_mode); } if (roadsPanel == null) { roadsPanel = UIView.Find<UIPanel>("RoadsPanel"); } if (roadsPanel == null || !roadsPanel.isVisible) { if (toolMode != ToolMode.None) { ModDebug.Log("Roads panel no longer visible"); SetToolMode(ToolMode.None, true); } return; } if (netTool == null) { foreach (var tool in ToolsModifierControl.toolController.Tools) { NetTool nt = tool as NetTool; if (nt != null && nt.m_prefab != null) { ModDebug.Log("NetTool found: " + nt.name); netTool = nt; break; } } if (netTool == null) return; raycastService = new ToolBase.RaycastService(netTool.m_prefab.m_class.m_service, netTool.m_prefab.m_class.m_subService, netTool.m_prefab.m_class.m_layer); ModDebug.Log("UI visible: " + ui.isVisible); } if (!ui.isVisible) { ui.Show(); } if (toolMode != ToolMode.None) { mouseDown = Input.GetMouseButton(0); mouseRayValid = !ToolsModifierControl.toolController.IsInsideUI && Cursor.visible; mouseRay = Camera.main.ScreenPointToRay(Input.mousePosition); mouseRayLength = Camera.main.farClipPlane; currentTime = Time.time; if (ToolsModifierControl.toolController.CurrentTool != buildTool) { ModDebug.Log("Another tool selected"); SetToolMode(ToolMode.None); } } else { ui.toolMode = ToolMode.None; if (ToolsModifierControl.toolController.CurrentTool == buildTool) { ToolsModifierControl.toolController.CurrentTool = netTool; } } //ModDebug.LogClassAndMethodName(this.GetType().Name, System.Reflection.MethodBase.GetCurrentMethod().Name); if (toolMode == ToolMode.None) return; if (!mouseDown) { prevBuiltSegmentIndex = 0; } if (buildTool != null) { buildTool.isHoveringSegment = false; buildTool.toolMode = toolMode; buildTool.ToolCursor = netTool.m_upgradeCursor; } if (!mouseRayValid) return; ToolBase.RaycastInput raycastInput = new ToolBase.RaycastInput(mouseRay, mouseRayLength); raycastInput.m_netService = raycastService; raycastInput.m_ignoreTerrain = true; raycastInput.m_ignoreNodeFlags = NetNode.Flags.All; raycastInput.m_ignoreSegmentFlags = NetSegment.Flags.Untouchable; ToolBase.RaycastOutput raycastOutput; if (BuildTool21.RayCast(raycastInput, out raycastOutput)) { int segmentIndex = raycastOutput.m_netSegment; if (segmentIndex != 0) { NetManager net = Singleton<NetManager>.instance; NetInfo newRoadPrefab = null; NetInfo prefab = net.m_segments.m_buffer[segmentIndex].Info; NetTool.ControlPoint startPoint; NetTool.ControlPoint middlePoint; NetTool.ControlPoint endPoint; GetSegmentControlPoints(segmentIndex, out startPoint, out middlePoint, out endPoint); ushort node; ushort outSegment; int cost; int productionRate; // Check for out-of-area error and initialized collide arrays for visualization ToolBase.ToolErrors errors = NetTool.CreateNode(net.m_segments.m_buffer[segmentIndex].Info, startPoint, middlePoint, endPoint, NetTool.m_nodePositionsSimulation, 1000, true, false, true, false, false, false, (ushort)0, out node, out outSegment, out cost, out productionRate); if ((errors & ToolBase.ToolErrors.OutOfArea) != 0) { toolError = ToolError.OutOfArea; } string prefabName = null; if (!roadPrefabNames.TryGetValue(prefab.GetInstanceID(), out prefabName) || prefabName == null) { ModDebug.Error("Prefab name not found"); toolError = ToolError.Unknown; return; } NetInfo newPrefab; if (!roadPrefabs.TryGetValue(prefabName, out newPrefab) || newPrefab == null) { ModDebug.Error("Prefab not found: " + prefabName); toolError = ToolError.Unknown; return; } newRoadPrefab = newPrefab; // ModDebug.Log("Going to rebuild segment"); int newIndex = RebuildSegment(segmentIndex, newPrefab, raycastOutput.m_hitPos, hitPosDelta, ref toolError); if (newIndex != 0) { // ModDebug.Log("newIndex: " + newIndex); if (toolError != ToolError.None) return; prevBuiltSegmentIndex = segmentIndex; prevRebuildTime = currentTime; segmentIndex = newIndex; } if (buildTool != null) { // ModDebug.Log("Using segment from buffer"); buildTool.segment = net.m_segments.m_buffer[segmentIndex]; buildTool.segmentIndex = segmentIndex; buildTool.isHoveringSegment = toolError != ToolError.Unknown; if (newRoadPrefab != null) buildTool.newPrefab = newRoadPrefab; GetSegmentControlPoints(segmentIndex, out buildTool.startPoint, out buildTool.middlePoint, out buildTool.endPoint); } } } if (buildTool != null) { buildTool.toolError = toolError; } }
public override void SimulationStep() { base.SimulationStep(); var mouseRayValid = !UIView.IsInsideUI() && Cursor.visible && !cursorInSecondaryPanel; if (mouseRayValid) { var mouseRay = Camera.main.ScreenPointToRay(Input.mousePosition); var mouseRayLength = Camera.main.farClipPlane; var rayRight = Camera.main.transform.TransformDirection(Vector3.right); var defaultService = new ToolBase.RaycastService(ItemClass.Service.Road, ItemClass.SubService.None, ItemClass.Layer.Default); var input = new ToolBase.RaycastInput(mouseRay, mouseRayLength) { m_rayRight = rayRight, m_netService = defaultService, m_ignoreNodeFlags = NetNode.Flags.None, m_ignoreSegmentFlags = NetSegment.Flags.Untouchable }; RaycastOutput output; if (!RayCast(input, out output)) { _hoveredSegmentIdx = 0; _hoveredNetNodeIdx = 0; return; } _hoveredNetNodeIdx = output.m_netNode; _hoveredSegmentIdx = output.m_netSegment; } if (toolMode == ToolMode.None) { ToolCursor = null; } else { NetTool netTool = null; foreach (var tool in ToolsModifierControl.toolController.Tools) { NetTool nt = tool as NetTool; if (nt != null && nt.m_prefab != null) { netTool = nt; break; } } if (netTool != null && mouseRayValid) { ToolCursor = netTool.m_upgradeCursor; } } }
public override void SimulationStep() { var district = (byte) m_district .GetValue(this); var painting = (bool) m_painting .GetValue(this); var erasing = (bool) m_erasing .GetValue(this); var mouseRayValid = (bool) m_mouseRayValid .GetValue(this); var mouseRayLength = (float) m_mouseRayLength.GetValue(this); var mouseRay = (Ray) m_mouseRay .GetValue(this); var mousePosition = (Vector3)m_mousePosition .GetValue(this); ToolBase.RaycastInput input = new ToolBase.RaycastInput(mouseRay, mouseRayLength); input.m_netService = new ToolBase.RaycastService(ItemClass.Service.Road, ItemClass.SubService.None, ItemClass.Layer.Default); input.m_ignoreNodeFlags = NetNode.Flags.None; input.m_ignoreSegmentFlags = NetSegment.Flags.None; ToolBase.RaycastOutput raycastOutput; if (mouseRayValid && ToolBase.RayCast(input, out raycastOutput)) { //begin mod var swapToggle = OptionsWrapper<Options>.Options.defaultToNoSnapping; if ((swapToggle && Input.GetKey(KeyCode.LeftAlt)) || (!swapToggle && !Input.GetKey(KeyCode.LeftAlt))) { if (raycastOutput.m_netNode != 0) { raycastOutput.m_hitPos = Singleton<NetManager>.instance.m_nodes.m_buffer[(int)raycastOutput.m_netNode].m_position; } else if (raycastOutput.m_netSegment != 0) { raycastOutput.m_hitPos = Singleton<NetManager>.instance.m_segments.m_buffer[(int)raycastOutput.m_netSegment].GetClosestPosition(raycastOutput.m_hitPos); } } //end mod setMousePosition(raycastOutput.m_hitPos); if (this.m_mode == DistrictTool.Mode.Paint || this.m_mode == DistrictTool.Mode.Erase) { if (district != 0 && Singleton<DistrictManager>.instance.m_districts.m_buffer[(int)district].m_flags == District.Flags.None) { setDistrict(0); } if (painting && district != 0) { this.ApplyBrush(district); setlastPaintPosition(mousePosition); setErrors(ToolBase.ToolErrors.None); } else if (erasing) { this.ApplyBrush(0); setlastPaintPosition(mousePosition); setErrors(ToolBase.ToolErrors.None); } else { var value = Singleton<DistrictManager>.instance.SampleDistrict(mousePosition); setDistrict(value); setlastPaintPosition(new Vector3(-100000f, -100000f, -100000f)); if (district == 0 && !Singleton<DistrictManager>.instance.CheckLimits()) { setErrors(ToolBase.ToolErrors.TooManyObjects); } else { setErrors(ToolBase.ToolErrors.None); } } } else { var value = Singleton<DistrictManager>.instance.SampleDistrict(mousePosition); setDistrict(value); setlastPaintPosition(new Vector3(-100000f, -100000f, -100000f)); setErrors(ToolBase.ToolErrors.None); } } else { setlastPaintPosition(new Vector3(-100000f, -100000f, -100000f)); setErrors(ToolBase.ToolErrors.RaycastFailed); } }
void _OnBeforeSimulationTick() { if (toolMode == ToolMode.None) { return; } if (!mouseDown) { dragging = false; prevBuiltSegmentIndex = 0; } if (buildTool != null) { buildTool.isHoveringSegment = false; buildTool.toolMode = toolMode; buildTool.ToolCursor = netTool.m_upgradeCursor; } if (!mouseRayValid) { return; } ToolBase.RaycastInput raycastInput = new ToolBase.RaycastInput(mouseRay, mouseRayLength); raycastInput.m_netService = raycastService; raycastInput.m_ignoreTerrain = true; raycastInput.m_ignoreNodeFlags = NetNode.Flags.All; raycastInput.m_ignoreSegmentFlags = NetSegment.Flags.Untouchable; ToolBase.RaycastOutput raycastOutput; if (BuildTool118.RayCast(raycastInput, out raycastOutput)) { int segmentIndex = raycastOutput.m_netSegment; if (segmentIndex != 0) { NetManager net = Singleton <NetManager> .instance; NetInfo newRoadPrefab = null; NetTool.ControlPoint startPoint; NetTool.ControlPoint middlePoint; NetTool.ControlPoint endPoint; GetSegmentControlPoints(segmentIndex, out startPoint, out middlePoint, out endPoint); ushort node; ushort outSegment; int cost; int productionRate; // Check for out-of-area error and initialized collide arrays for visualization ToolBase.ToolErrors errors = NetTool.CreateNode(net.m_segments.m_buffer[segmentIndex].Info, startPoint, middlePoint, endPoint, NetTool.m_nodePositionsSimulation, 1000, true, false, true, false, false, false, (ushort)0, out node, out outSegment, out cost, out productionRate); if ((errors & ToolBase.ToolErrors.OutOfArea) != 0) { toolError = ToolError.OutOfArea; } else { if (mouseDown) { HandleMouseDrag(ref raycastOutput, ref toolError, false, ref newRoadPrefab, ref segmentIndex); if (segmentIndex == prevBuiltSegmentIndex) { toolError = ToolError.AlreadyBuilt; } } else { HandleMouseDrag(ref raycastOutput, ref toolError, true, ref newRoadPrefab, ref segmentIndex); } } if (buildTool != null) { buildTool.segment = net.m_segments.m_buffer[segmentIndex]; buildTool.segmentIndex = segmentIndex; buildTool.isHoveringSegment = toolError != ToolError.Unknown; if (newRoadPrefab != null) { buildTool.newPrefab = newRoadPrefab; } GetSegmentControlPoints(segmentIndex, out buildTool.startPoint, out buildTool.middlePoint, out buildTool.endPoint); } } } if (buildTool != null) { buildTool.toolError = toolError; } }
public override void OnUpdate(float realTimeDelta, float simulationTimeDelta) { ModDebug.LogClassAndMethodName(this.GetType().Name, System.Reflection.MethodBase.GetCurrentMethod().Name); if (loadingLevel) { return; } if (Input.GetKeyDown(KeyCode.Return)) { ModDebug.Log(netTool.m_prefab + " " + netTool.m_mode); } if (roadsPanel == null) { roadsPanel = UIView.Find <UIPanel>("RoadsPanel"); } if (roadsPanel == null || !roadsPanel.isVisible) { if (toolMode != ToolMode.None) { ModDebug.Log("Roads panel no longer visible"); SetToolMode(ToolMode.None, true); } return; } if (netTool == null) { foreach (var tool in ToolsModifierControl.toolController.Tools) { NetTool nt = tool as NetTool; if (nt != null && nt.m_prefab != null) { ModDebug.Log("NetTool found: " + nt.name); netTool = nt; break; } } if (netTool == null) { return; } raycastService = new ToolBase.RaycastService(netTool.m_prefab.m_class.m_service, netTool.m_prefab.m_class.m_subService, netTool.m_prefab.m_class.m_layer); ModDebug.Log("UI visible: " + ui.isVisible); } if (!ui.isVisible) { ui.Show(); } if (toolMode != ToolMode.None) { mouseDown = Input.GetMouseButton(0); mouseRayValid = !ToolsModifierControl.toolController.IsInsideUI && Cursor.visible; mouseRay = Camera.main.ScreenPointToRay(Input.mousePosition); mouseRayLength = Camera.main.farClipPlane; currentTime = Time.time; if (ToolsModifierControl.toolController.CurrentTool != buildTool) { ModDebug.Log("Another tool selected"); SetToolMode(ToolMode.None); } } else { ui.toolMode = ToolMode.None; if (ToolsModifierControl.toolController.CurrentTool == buildTool) { ToolsModifierControl.toolController.CurrentTool = netTool; } } //ModDebug.LogClassAndMethodName(this.GetType().Name, System.Reflection.MethodBase.GetCurrentMethod().Name); if (toolMode == ToolMode.None) { return; } if (!mouseDown) { prevBuiltSegmentIndex = 0; } if (buildTool != null) { buildTool.isHoveringSegment = false; buildTool.toolMode = toolMode; buildTool.ToolCursor = netTool.m_upgradeCursor; } if (!mouseRayValid) { return; } ToolBase.RaycastInput raycastInput = new ToolBase.RaycastInput(mouseRay, mouseRayLength); raycastInput.m_netService = raycastService; raycastInput.m_ignoreTerrain = true; raycastInput.m_ignoreNodeFlags = NetNode.Flags.All; raycastInput.m_ignoreSegmentFlags = NetSegment.Flags.Untouchable; ToolBase.RaycastOutput raycastOutput; if (BuildTool21.RayCast(raycastInput, out raycastOutput)) { int segmentIndex = raycastOutput.m_netSegment; if (segmentIndex != 0) { NetManager net = Singleton <NetManager> .instance; NetInfo newRoadPrefab = null; NetInfo prefab = net.m_segments.m_buffer[segmentIndex].Info; NetTool.ControlPoint startPoint; NetTool.ControlPoint middlePoint; NetTool.ControlPoint endPoint; GetSegmentControlPoints(segmentIndex, out startPoint, out middlePoint, out endPoint); ushort node; ushort outSegment; int cost; int productionRate; // Check for out-of-area error and initialized collide arrays for visualization ToolBase.ToolErrors errors = NetTool.CreateNode(net.m_segments.m_buffer[segmentIndex].Info, startPoint, middlePoint, endPoint, NetTool.m_nodePositionsSimulation, 1000, true, false, true, false, false, false, (ushort)0, out node, out outSegment, out cost, out productionRate); if ((errors & ToolBase.ToolErrors.OutOfArea) != 0) { toolError = ToolError.OutOfArea; } string prefabName = null; if (!roadPrefabNames.TryGetValue(prefab.GetInstanceID(), out prefabName) || prefabName == null) { ModDebug.Error("Prefab name not found"); toolError = ToolError.Unknown; return; } NetInfo newPrefab; if (!roadPrefabs.TryGetValue(prefabName, out newPrefab) || newPrefab == null) { ModDebug.Error("Prefab not found: " + prefabName); toolError = ToolError.Unknown; return; } newRoadPrefab = newPrefab; // ModDebug.Log("Going to rebuild segment"); int newIndex = RebuildSegment(segmentIndex, newPrefab, raycastOutput.m_hitPos, hitPosDelta, ref toolError); if (newIndex != 0) { // ModDebug.Log("newIndex: " + newIndex); if (toolError != ToolError.None) { return; } prevBuiltSegmentIndex = segmentIndex; prevRebuildTime = currentTime; segmentIndex = newIndex; } if (buildTool != null) { // ModDebug.Log("Using segment from buffer"); buildTool.segment = net.m_segments.m_buffer[segmentIndex]; buildTool.segmentIndex = segmentIndex; buildTool.isHoveringSegment = toolError != ToolError.Unknown; if (newRoadPrefab != null) { buildTool.newPrefab = newRoadPrefab; } GetSegmentControlPoints(segmentIndex, out buildTool.startPoint, out buildTool.middlePoint, out buildTool.endPoint); } } } if (buildTool != null) { buildTool.toolError = toolError; } }
void _OnBeforeSimulationTick() { if (toolMode == ToolMode.None) return; if (!mouseDown) { dragging = false; prevBuiltSegmentIndex = 0; } if (buildTool != null) { buildTool.isHoveringSegment = false; buildTool.toolMode = toolMode; buildTool.ToolCursor = netTool.m_upgradeCursor; } if (!mouseRayValid) return; ToolBase.RaycastInput raycastInput = new ToolBase.RaycastInput(mouseRay, mouseRayLength); raycastInput.m_netService = raycastService; raycastInput.m_ignoreTerrain = true; raycastInput.m_ignoreNodeFlags = NetNode.Flags.All; raycastInput.m_ignoreSegmentFlags = NetSegment.Flags.Untouchable; ToolBase.RaycastOutput raycastOutput; if (BuildTool118.RayCast(raycastInput, out raycastOutput)) { int segmentIndex = raycastOutput.m_netSegment; if (segmentIndex != 0) { NetManager net = Singleton<NetManager>.instance; NetInfo newRoadPrefab = null; NetTool.ControlPoint startPoint; NetTool.ControlPoint middlePoint; NetTool.ControlPoint endPoint; GetSegmentControlPoints(segmentIndex, out startPoint, out middlePoint, out endPoint); ushort node; ushort outSegment; int cost; int productionRate; // Check for out-of-area error and initialized collide arrays for visualization ToolBase.ToolErrors errors = NetTool.CreateNode(net.m_segments.m_buffer[segmentIndex].Info, startPoint, middlePoint, endPoint, NetTool.m_nodePositionsSimulation, 1000, true, false, true, false, false, false, (ushort)0, out node, out outSegment, out cost, out productionRate); if ((errors & ToolBase.ToolErrors.OutOfArea) != 0) { toolError = ToolError.OutOfArea; } else { if (mouseDown) { HandleMouseDrag(ref raycastOutput, ref toolError, false, ref newRoadPrefab, ref segmentIndex); if (segmentIndex == prevBuiltSegmentIndex) { toolError = ToolError.AlreadyBuilt; } } else { HandleMouseDrag(ref raycastOutput, ref toolError, true, ref newRoadPrefab, ref segmentIndex); } } if (buildTool != null) { buildTool.segment = net.m_segments.m_buffer[segmentIndex]; buildTool.segmentIndex = segmentIndex; buildTool.isHoveringSegment = toolError != ToolError.Unknown; if (newRoadPrefab != null) buildTool.newPrefab = newRoadPrefab; GetSegmentControlPoints(segmentIndex, out buildTool.startPoint, out buildTool.middlePoint, out buildTool.endPoint); } } } if (buildTool != null) { buildTool.toolError = toolError; } }
public override void SimulationStep() { ToolBase.RaycastInput input = new ToolBase.RaycastInput(m_mouseRay, m_mouseRayLength); if (m_undoRequest && !m_strokeInProgress) { ApplyUndo(); m_undoRequest = false; } else if (m_strokeEnded) { EndStroke(); m_strokeEnded = false; m_strokeInProgress = false; //begin mod ditchHeights = null; //end mod } else { ToolBase.RaycastOutput output; if (!m_mouseRayValid || !ToolBase.RayCast(input, out output)) return; m_mousePosition = output.m_hitPos; if (m_mouseLeftDown == m_mouseRightDown) return; //begin mod if (ditchHeights == null && isDitch) { ditchHeights = new ushort[1168561]; const ushort trenchDepth = 20; var diff = m_mouseLeftDown ? trenchDepth : -trenchDepth; var finalStrength = m_strength * diff; var i = 0; foreach (var originalHeight in TerrainManager.instance.FinalHeights) { var from = originalHeight * 1.0f / 64.0f; ditchHeights[i++] = (ushort)Math.Max(0, from + finalStrength); } } //end mod m_strokeInProgress = true; ApplyBrush(); } }
public override void SimulationStep() { if (this.m_prefab == null) { this.m_wasPrefab = (PropInfo)null; this.m_propInfo = (PropInfo)null; } else { if (this.m_propInfo == null || this.m_wasPrefab != this.m_prefab) { this.m_wasPrefab = this.m_prefab; Randomizer r = this.m_randomizer; this.m_propInfo = (Singleton <ToolManager> .instance.m_properties.m_mode & ItemClass.Availability.AssetEditor) == ItemClass.Availability.None ? this.m_prefab.GetVariation(ref r) : this.m_prefab; m_randomizer = this.m_randomizer; } ToolBase.RaycastInput input = new ToolBase.RaycastInput(this.m_mouseRay, this.m_mouseRayLength); //begin mod input.m_ignoreBuildingFlags = Building.Flags.None; input.m_ignoreNodeFlags = NetNode.Flags.None; input.m_ignoreSegmentFlags = NetSegment.Flags.None; input.m_buildingService = new RaycastService(ItemClass.Service.None, ItemClass.SubService.None, ItemClass.Layer.Default); input.m_netService = new RaycastService(ItemClass.Service.None, ItemClass.SubService.None, ItemClass.Layer.Default); input.m_netService2 = new RaycastService(ItemClass.Service.None, ItemClass.SubService.None, ItemClass.Layer.Default); //end mod ulong[] collidingSegments; ulong[] collidingBuildings; this.m_toolController.BeginColliding(out collidingSegments, out collidingBuildings); try { ToolBase.RaycastOutput output; if (this.m_mouseRayValid && ToolBase.RayCast(input, out output)) { if (this.m_mode == PropTool.Mode.Brush) { this.m_mousePosition = output.m_hitPos; this.m_placementErrors = !Singleton <PropManager> .instance.CheckLimits() ? ToolBase.ToolErrors.TooManyObjects : ToolBase.ToolErrors.Pending; if (this.m_mouseLeftDown == this.m_mouseRightDown) { return; } this.ApplyBrush(); } else { if (this.m_mode != PropTool.Mode.Single) { return; } //begin mod //end mod Randomizer r = this.m_randomizer; ushort id = Singleton <PropManager> .instance.m_props.NextFreeItem(ref r); ToolBase.ToolErrors toolErrors = PropTool.CheckPlacementErrors(this.m_propInfo, output.m_hitPos, /*output.m_currentEditObject*/ false, id, collidingSegments, collidingBuildings); if ((Singleton <ToolManager> .instance.m_properties.m_mode & ItemClass.Availability.Game) != ItemClass.Availability.None) { int constructionCost = this.m_propInfo.GetConstructionCost(); if (constructionCost != 0 && constructionCost != Singleton <EconomyManager> .instance.PeekResource( EconomyManager.Resource.Construction, constructionCost)) { toolErrors |= ToolBase.ToolErrors.NotEnoughMoney; } } if (!Singleton <PropManager> .instance.CheckLimits()) { toolErrors |= ToolBase.ToolErrors.TooManyObjects; } this.m_mousePosition = output.m_hitPos; this.m_placementErrors = toolErrors; //begin mod //end mod } } else { this.m_placementErrors = ToolBase.ToolErrors.RaycastFailed; } } finally { this.m_toolController.EndColliding(); } } }
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(); } }