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