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);
}
}
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();
}
}
}
}
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();
}
}
