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)
{
return;
}
TreeState state = instanceState as TreeState;
TreeInfo info = state.Info.Prefab as TreeInfo;
Randomizer randomizer = new Randomizer(state.instance.id.Tree);
float scale = info.m_minScale + (float)randomizer.Int32(10000u) * (info.m_maxScale - info.m_minScale) * 0.0001f;
//float brightness = info.m_minBrightness + (float)randomizer.Int32(10000u) * (info.m_maxBrightness - info.m_minBrightness) * 0.0001f;
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);
}
TreeTool.RenderOverlay(cameraInfo, info, newPosition, scale, toolColor);
}
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 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);
}
}
public new void OnClick(UIComponent comp, UIMouseEventParameter p)
{
UIButton uiButton = p.source as UIButton;
int byIndex = this.GetByIndex((UIComponent)uiButton);
if (byIndex == -1)
{
return;
}
this.SelectByIndex(byIndex);
Texture2D texture2D = uiButton.objectUserData as Texture2D;
var brushesContainer =
(UIScrollablePanel)typeof(BrushOptionPanel).GetField("m_BrushesContainer", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(this);
if (!((UnityEngine.Object)uiButton.parent == (UnityEngine.Object)brushesContainer) || !((UnityEngine.Object)texture2D != (UnityEngine.Object)null))
{
return;
}
TerrainTool tool1 = ToolsModifierControl.GetTool <TerrainTool>();
if ((UnityEngine.Object)tool1 != (UnityEngine.Object)null)
{
tool1.m_brush = texture2D;
}
TreeTool tool2 = ToolsModifierControl.GetTool <TreeTool>();
if ((UnityEngine.Object)tool2 != (UnityEngine.Object)null)
{
tool2.m_brush = texture2D;
}
ResourceTool tool3 = ToolsModifierControl.GetTool <ResourceTool>();
if ((UnityEngine.Object)tool3 != (UnityEngine.Object)null)
{
tool3.m_brush = texture2D;
}
PropTool tool4 = ToolsModifierControl.GetTool <PropTool>();
if ((UnityEngine.Object)tool4 == (UnityEngine.Object)null)
{
tool4.m_brush = texture2D;
}
//begin mod
try
{
Plugins.SetBrush(texture2D);
}
catch (Exception e)
{
UnityEngine.Debug.LogException(e);
}
//end mod
}
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;
}
}
}
private void method_2()
{
if (BuildingProperty.TargetLayer == null)
{
BuildingProperty.Scene = _plugin.Scene;
BuildingProperty.TargetLayer = ((this.ibasicMap_0 as IScene).BasicGraphicsLayer as IGraphicsContainer3D);
if (!TreeTool.LayerIsExist(this.ibasicMap_0 as IScene, BuildingProperty.TargetLayer as ILayer))
{
(this.ibasicMap_0 as IScene).AddLayer(BuildingProperty.TargetLayer as ILayer, false);
}
}
}
private void SetBrushSize(float val)
{
var brushSizeSlider =
(UISlider)typeof(BrushOptionPanel).GetField("m_BrushSizeSlider", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(this);
PropTool currentTool1 = ToolsModifierControl.GetCurrentTool <PropTool>();
if ((UnityEngine.Object)currentTool1 != (UnityEngine.Object)null)
{
currentTool1.m_brushSize = val;
currentTool1.m_mode = (double)currentTool1.m_brushSize != (double)brushSizeSlider.minValue ? PropTool.Mode.Brush : PropTool.Mode.Single;
}
TerrainTool currentTool2 = ToolsModifierControl.GetCurrentTool <TerrainTool>();
//begin mod
if ((UnityEngine.Object)currentTool2 != (UnityEngine.Object)null)
{
currentTool2.m_brushSize = val;
TerrainToolDetour.m_sizeMode = (double)currentTool2.m_brushSize != (double)brushSizeSlider.minValue ? TerrainToolDetour.SizeMode.Brush : TerrainToolDetour.SizeMode.Single;
}
//end mod
TreeTool currentTool3 = ToolsModifierControl.GetCurrentTool <TreeTool>();
if ((UnityEngine.Object)currentTool3 != (UnityEngine.Object)null)
{
currentTool3.m_brushSize = val;
currentTool3.m_mode = (double)currentTool3.m_brushSize != (double)brushSizeSlider.minValue ? TreeTool.Mode.Brush : TreeTool.Mode.Single;
}
ResourceTool currentTool4 = ToolsModifierControl.GetCurrentTool <ResourceTool>();
if ((UnityEngine.Object)currentTool4 != (UnityEngine.Object)null)
{
currentTool4.m_brushSize = val;
}
//begin mod
try
{
Plugins.SetSize(val, val == (double)brushSizeSlider.minValue);
}
catch (Exception e)
{
UnityEngine.Debug.LogException(e);
}
//end mod
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo, Color toolColor, Color despawnColor)
{
if (!isValid)
{
return;
}
uint tree = id.Tree;
TreeManager treeManager = TreeManager.instance;
TreeInfo treeInfo = treeManager.m_trees.m_buffer[tree].Info;
Vector3 position = treeManager.m_trees.m_buffer[tree].Position;
Randomizer randomizer = new Randomizer(tree);
float scale = treeInfo.m_minScale + (float)randomizer.Int32(10000u) * (treeInfo.m_maxScale - treeInfo.m_minScale) * 0.0001f;
float alpha = 1f;
TreeTool.CheckOverlayAlpha(treeInfo, scale, ref alpha);
toolColor.a *= alpha;
TreeTool.RenderOverlay(cameraInfo, treeInfo, position, scale, toolColor);
}
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);
}
}
private void SetBrushStrength(float val)
{
PropTool currentTool1 = ToolsModifierControl.GetCurrentTool <PropTool>();
if ((UnityEngine.Object)currentTool1 != (UnityEngine.Object)null)
{
currentTool1.m_strength = val;
}
TerrainTool currentTool2 = ToolsModifierControl.GetCurrentTool <TerrainTool>();
if ((UnityEngine.Object)currentTool2 != (UnityEngine.Object)null)
{
currentTool2.m_strength = val;
}
TreeTool currentTool3 = ToolsModifierControl.GetCurrentTool <TreeTool>();
if ((UnityEngine.Object)currentTool3 != (UnityEngine.Object)null)
{
currentTool3.m_strength = val;
}
ResourceTool currentTool4 = ToolsModifierControl.GetCurrentTool <ResourceTool>();
if ((UnityEngine.Object)currentTool4 != (UnityEngine.Object)null)
{
currentTool4.m_strength = val;
}
//begin mod
try
{
Plugins.SetStrength(val);
}
catch (Exception e)
{
UnityEngine.Debug.LogException(e);
}
//end mod
}
//Works BEAUTIFULLY!! :DDD
public static void SwitchTools(out bool allNull)
{
allNull = true;
m_wasPLTActive = m_PLTActive;
m_wasBulldozeToolActive = m_bulldozeToolActive;
ICities.LoadMode _loadMode = PropLineToolMod.GetLoadMode();
PropTool _propTool = ToolsModifierControl.GetCurrentTool <PropTool>();
TreeTool _treeTool = ToolsModifierControl.GetCurrentTool <TreeTool>();
PropLineTool _propLineTool = ToolsModifierControl.GetCurrentTool <PropLineTool>();
BulldozeTool _bulldozeTool = ToolsModifierControl.GetCurrentTool <BulldozeTool>();
if ((_propTool == null) && (_treeTool == null) && (_propLineTool == null))
{
allNull = true;
if (!m_wasBulldozeToolActive)
{
m_PLTActive = false;
}
if (m_wasPLTActive == true)
{
PropLineTool.m_keepActiveState = true;
}
if (_bulldozeTool != null)
{
m_bulldozeToolActive = true;
}
else
{
m_bulldozeToolActive = false;
}
if (m_resetCounterActive && resetCounterElapsedTimeSeconds > RESET_THRESHOLD_SECONDS)
{
m_resetCounterActive = false;
m_resetCounterExpired = true;
}
else if (!m_resetCounterExpired && !m_resetCounterActive)
{
m_resetCounterActive = true;
m_resetCounterStartTimeSeconds = Time.time;
//Debug.Log("[PLTDEBUG]: m_resetCounterStartTimeSeconds = " + m_resetCounterStartTimeSeconds);
}
return;
}
else
{
allNull = false;
if (_propLineTool != null)
{
m_PLTActive = true;
}
//continue along
}
//single mode: signal tool switch
//not-single mode: signal standby
bool _PLTActiveExclusive = ((_propLineTool != null) && (_propTool == null) && (_treeTool == null));
//single mode: signal standby
//not-single mode: signal tool switch
bool _PLTInactiveButPropOrTreeActive = ((_propLineTool == null) && ((_propTool != null) || (_treeTool != null)));
//error checking?
bool _multipleActivePropTreeTools = ((_propLineTool != null) && ((_propTool != null) || (_treeTool != null)));
if (_multipleActivePropTreeTools)
{
Debug.LogError("[PLT]: ToolSwitch: More than one active tool!");
return;
}
//loadmode is in-game
bool _inGame = ((_loadMode == ICities.LoadMode.NewGame) || (_loadMode == ICities.LoadMode.LoadGame));
//loadmode is map-editor or asset-editor [EDIT: ACTUALLY JUST MAP EDITOR]
//bool flag4 = ( (_loadMode == ICities.LoadMode.LoadMap) || (_loadMode == ICities.LoadMode.LoadAsset) || (_loadMode == ICities.LoadMode.NewAsset) || (_loadMode == ICities.LoadMode.NewMap) );
bool _mapEditor = ((_loadMode == ICities.LoadMode.LoadMap) || (_loadMode == ICities.LoadMode.NewMap));
//test if BrushPanel was found
m_brushPanelFound = (m_brushPanel != null);
switch (PropLineTool.drawMode)
{
case PropLineTool.DrawMode.Single:
{
//reset active state
PropLineTool.m_keepActiveState = false;
if (_PLTActiveExclusive)
{
switch (PropLineTool.objectMode)
{
case PropLineTool.ObjectMode.Undefined:
{
Debug.LogError("[PLT]: ToolSwitch: Object mode is undefined!");
break;
}
case PropLineTool.ObjectMode.Props:
{
PropInfo oldPropInfo = _propLineTool.propPrefab;
PropTool newPropTool = ToolsModifierControl.SetTool <PropTool>();
if (oldPropInfo == null)
{
Debug.LogError("[PLT]: ToolSwitch: PropLineTool prop prefab is null!");
return;
}
newPropTool.m_prefab = oldPropInfo;
//new as of 190809
FindBrushPanel();
if (_mapEditor && m_brushPanelFound)
{
m_brushPanel.Show();
}
break;
}
case PropLineTool.ObjectMode.Trees:
{
TreeInfo oldTreeInfo = _propLineTool.treePrefab;
TreeTool newTreeTool = ToolsModifierControl.SetTool <TreeTool>();
if (oldTreeInfo == null)
{
Debug.LogError("[PLT]: ToolSwitch: PropLineTool tree prefab is null!");
return;
}
newTreeTool.m_prefab = _propLineTool.treePrefab;
//new as of 190809
FindBrushPanel();
if ((_mapEditor || (_inGame)) && m_brushPanelFound)
{
m_brushPanel.Show();
}
break;
}
}
return;
}
else if (_PLTInactiveButPropOrTreeActive)
{
return;
}
else
{
Debug.LogError("[PLT]: ToolSwitch: PropLineTool -> mismatch!");
return;
}
}
case PropLineTool.DrawMode.Straight:
case PropLineTool.DrawMode.Curved:
case PropLineTool.DrawMode.Freeform:
case PropLineTool.DrawMode.Circle:
{
if (_PLTInactiveButPropOrTreeActive)
{
if (m_wasPLTActive == true)
{
PropLineTool.m_keepActiveState = true;
}
else
{
if (pendingReset)
{
PropLineTool.m_keepActiveState = false;
}
else //do not reset
{
PropLineTool.m_keepActiveState = true;
}
}
m_resetCounterExpired = false;
m_resetCounterActive = false;
//continue along (no "return;" on this line)
if (_propTool != null)
{
PropInfo oldPropInfo = _propTool.m_prefab;
PropLineTool newPropLineTool = ToolsModifierControl.SetTool <PropLineTool>();
//PropLineTool.objectMode = PropLineTool.ObjectMode.Props;
if (oldPropInfo == null)
{
Debug.LogError("[PLT]: ToolSwitch: PropTool prop prefab is null!");
return;
}
newPropLineTool.propPrefab = oldPropInfo;
//calling after setting prefab
PropLineTool.objectMode = PropLineTool.ObjectMode.Props;
//new as of 190809
FindBrushPanel();
if (m_brushPanelFound)
{
m_brushPanel.Hide();
}
return;
}
if (_treeTool != null)
{
TreeInfo oldTreeInfo = _treeTool.m_prefab;
PropLineTool newPropLineTool = ToolsModifierControl.SetTool <PropLineTool>();
//PropLineTool.objectMode = PropLineTool.ObjectMode.Trees;
if (oldTreeInfo == null)
{
Debug.LogError("[PLT]: ToolSwitch: TreeTool tree prefab is null!");
return;
}
newPropLineTool.treePrefab = oldTreeInfo;
//calling after setting prefab
PropLineTool.objectMode = PropLineTool.ObjectMode.Trees;
//new as of 190809
FindBrushPanel();
if (m_brushPanelFound)
{
m_brushPanel.Hide();
}
return;
}
}
else if (_PLTActiveExclusive)
{
if ((_propLineTool.propPrefab == null) && (_propLineTool.treePrefab == null))
{
Debug.LogError("[PLT]: ToolSwitch: PropLineTool prop and tree prefabs are null!");
}
return;
}
break;
}
default:
{
Debug.LogError("[PLT]: ToolSwitch: Draw Mode is out of bounds!");
return;
}
}
//safety-net return
Debug.LogError("[PLT]: Reached safety-net return of ToolSwitch.SwitchTools");
return;
}
private static void ApplyBrush(TreeTool tt)
{
//uint useless1 = 0;
unsafe
{
float single;
float single1;
uint num;
int num1;
Vector3 vector3 = new Vector3();
Randomizer value = (Randomizer)tt.GetType().GetField("m_randomizer", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(tt);
ToolController toolController = (ToolController)tt.GetType().GetField("m_toolController", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(tt);
Vector3 value1 = (Vector3)tt.GetType().GetField("m_mousePosition", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(tt);
bool flag = (bool)tt.GetType().GetField("m_mouseLeftDown", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(tt);
bool flag1 = (bool)tt.GetType().GetField("m_mouseRightDown", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(tt);
TreeInfo treeInfo = (TreeInfo)tt.GetType().GetField("m_treeInfo", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(tt);
float[] brushData = toolController.BrushData;
float mBrushSize = tt.m_brushSize * 0.5f;
float single2 = 32f;
int num2 = 540;
TreeInstance[] mBuffer = Singleton <TreeManager> .instance.m_trees.m_buffer;
uint[] mTreeGrid = Singleton <TreeManager> .instance.m_treeGrid;
float mStrength = tt.m_strength;
int num3 = Mathf.Max((int)((value1.x - mBrushSize) / single2 + (float)num2 * 0.5f), 0);
int num4 = Mathf.Max((int)((value1.z - mBrushSize) / single2 + (float)num2 * 0.5f), 0);
int num5 = Mathf.Min((int)((value1.x + mBrushSize) / single2 + (float)num2 * 0.5f), num2 - 1);
int num6 = Mathf.Min((int)((value1.z + mBrushSize) / single2 + (float)num2 * 0.5f), num2 - 1);
for (int i = num4; i <= num6; i++)
{
float mBrushSize1 = (float)(((float)i - (float)num2 * 0.5f + 0.5f) * single2 - value1.z + mBrushSize) / tt.m_brushSize * 64f - 0.5f;
int num7 = Mathf.Clamp(Mathf.FloorToInt(mBrushSize1), 0, 63);
int num8 = Mathf.Clamp(Mathf.CeilToInt(mBrushSize1), 0, 63);
for (int j = num3; j <= num5; j++)
{
float mBrushSize2 = (float)(((float)j - (float)num2 * 0.5f + 0.5f) * single2 - value1.x + mBrushSize) / tt.m_brushSize * 64f - 0.5f;
int num9 = Mathf.Clamp(Mathf.FloorToInt(mBrushSize2), 0, 63);
int num10 = Mathf.Clamp(Mathf.CeilToInt(mBrushSize2), 0, 63);
float single3 = brushData[num7 * 64 + num9];
float single4 = brushData[num7 * 64 + num10];
float single5 = brushData[num8 * 64 + num9];
float single6 = brushData[num8 * 64 + num10];
float single7 = single3 + (float)((single4 - single3) * (mBrushSize2 - (float)num9));
float single8 = single5 + (float)((single6 - single5) * (mBrushSize2 - (float)num9));
float single9 = single7 + (float)((single8 - single7) * (mBrushSize1 - (float)num7));
int num11 = (int)(mStrength * (single9 * 1.2f - 0.2f) * 10000f);
if (flag && tt.m_prefab != null)
{
if (value.Int32(10000) < num11)
{
TreeInfo treeInfo1 = ((Singleton <ToolManager> .instance.m_properties.m_mode & ItemClass.Availability.AssetEditor) == ItemClass.Availability.None ? tt.m_prefab.GetVariation(ref value) : tt.m_prefab);
vector3.x = ((float)j - (float)num2 * 0.5f) * single2;
vector3.z = ((float)i - (float)num2 * 0.5f) * single2;
vector3.x = vector3.x + (float)(((float)value.Int32(10000) + 0.5f) * (single2 / 10000f));
vector3.z = vector3.z + (float)(((float)value.Int32(10000) + 0.5f) * (single2 / 10000f));
vector3.y = 0f;
vector3.y = Singleton <TerrainManager> .instance.SampleDetailHeight(vector3, out single, out single1);
if (Mathf.Max(Mathf.Abs(single), Mathf.Abs(single1)) < (float)value.Int32(10000) * 5E-05f)
{
float mSize = treeInfo.m_generatedInfo.m_size.y;
float mMinScale = treeInfo.m_minScale;
Randomizer randomizer = new Randomizer(Singleton <TreeManager> .instance.m_trees.NextFreeItem(ref value));
mMinScale = mMinScale + (float)randomizer.Int32(10000) * ((treeInfo.m_maxScale - treeInfo.m_minScale) * 0.0001f);
mSize = mSize * mMinScale;
float single11 = 4.5f;
Vector2 vector2 = VectorUtils.XZ(vector3);
Quad2 quad22 = new Quad2()
{
a = vector2 + new Vector2(-single11, -single11),
b = vector2 + new Vector2(-single11, single11),
c = vector2 + new Vector2(single11, single11),
d = vector2 + new Vector2(single11, -single11)
};
Quad2 quad2 = quad22;
Quad2 quad23 = new Quad2()
{
a = vector2 + new Vector2(-8f, -8f),
b = vector2 + new Vector2(-8f, 8f),
c = vector2 + new Vector2(8f, 8f),
d = vector2 + new Vector2(8f, -8f)
};
Quad2 quad21 = quad23;
float single12 = value1.y - 1000f;
float single13 = value1.y + mSize;
ItemClass.CollisionType collisionType = ItemClass.CollisionType.Terrain;
if (!Singleton <PropManager> .instance.OverlapQuad(quad2, single12, single13, collisionType, 0, 0) && !Singleton <TreeManager> .instance.OverlapQuad(quad21, single12, single13, collisionType, 0, 0) && !Singleton <NetManager> .instance.OverlapQuad(quad2, single12, single13, collisionType, treeInfo1.m_class.m_layer, 0, 0, 0) && !Singleton <BuildingManager> .instance.OverlapQuad(quad2, single12, single13, collisionType, treeInfo1.m_class.m_layer, 0, 0, 0) && !Singleton <TerrainManager> .instance.HasWater(vector2) && !Singleton <GameAreaManager> .instance.QuadOutOfArea(quad2) && !Singleton <TreeManager> .instance.CreateTree(out num, ref value, treeInfo1, vector3, false))
{
}
}
}
}
else if (flag1 || tt.m_prefab == null)
{
uint num12 = mTreeGrid[i * num2 + j];
int num13 = 0;
do
{
if (num12 == 0)
{
goto Label10;
}
uint mNextGridTree = mBuffer[num12].m_nextGridTree;
if (value.Int32(10000) < num11)
{
Singleton <TreeManager> .instance.ReleaseTree(num12);
}
num12 = mNextGridTree;
num1 = num13 + 1;
num13 = num1;
}while (num1 < LimitTreeManager.Helper.TreeLimit);
CODebugBase <LogChannel> .Error(LogChannel.Core, string.Concat("Invalid list detected!\n", Environment.StackTrace));
}
Label10:
;//useless1++;
}
}
}
}
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;
m_OptionsBrushPanel?.Hide();
if (buildingInfo != null)
{
BuildingTool buildingTool = SetTool <BuildingTool>();
if (buildingTool != null)
{
this.HideAllOptionPanels();
buildingTool.m_prefab = buildingInfo;
buildingTool.m_relocate = 0;
}
}
if (netInfo != null)
{
NetTool netTool = SetTool <NetTool>();
if (netTool != null)
{
if (netInfo.GetClassLevel() == ItemClass.Level.Level3)
{
this.ShowFloodwallsOptionPanel();
}
else if (netInfo.GetClassLevel() == ItemClass.Level.Level4)
{
this.ShowQuaysOptionPanel();
}
else if (netInfo.GetClassLevel() == ItemClass.Level.Level5)
{
this.ShowCanalsOptionPanel();
}
else
{
this.ShowPathsOptionPanel();
}
netTool.m_prefab = netInfo;
}
}
if (treeInfo != null)
{
var prevTreeTool = GetCurrentTool <TreeTool>();
TreeTool treeTool = SetTool <TreeTool>();
if (treeTool != null)
{
this.HideAllOptionPanels();
treeTool.m_prefab = treeInfo;
if (prevTreeTool == null)
{
treeTool.m_brush = toolController.m_brushes[3];
treeTool.m_brushSize = 30;
treeTool.m_mode = TreeTool.Mode.Single;
}
if (this.m_OptionsBar != null && m_OptionsBrushPanel == null)
{
m_OptionsBrushPanel = this.m_OptionsBar.Find <UIPanel>("BrushPanel");
}
m_OptionsBrushPanel.zOrder = 1;
m_OptionsBrushPanel.Show();
}
}
if (!(propInfo != null))
{
return;
}
var prevPropTool = GetCurrentTool <PropTool>();
PropTool propTool = SetTool <PropTool>();
if (!(propTool != null))
{
return;
}
this.HideAllOptionPanels();
propTool.m_prefab = propInfo;
if (prevPropTool == null)
{
propTool.m_mode = PropTool.Mode.Single;
}
}
internal static void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
//Log.DebugWait($"Managers_RenderOverlay.Postfix(): LaneIndex={LaneIndex} Info={Info}");
if (HoveredInfo is NetInfo.Lane laneInfo)
{
for (ushort segmentID = 1; segmentID < NetManager.MAX_SEGMENT_COUNT; ++segmentID)
{
if (!NetUtil.IsSegmentValid(segmentID))
{
continue;
}
var m_lanes = segmentID.ToSegment().Info.m_lanes;
int laneIndex = m_lanes.IndexOf(laneInfo);
if (laneIndex < 0)
{
continue;
}
uint laneID = NetUtil.GetlaneID(segmentID, laneIndex);
LaneData lane = new LaneData(laneID, laneIndex);
RenderUtil.RenderLaneOverlay(cameraInfo, lane, Color.yellow);
}
}
while (SegmentQueue.Count > 0)
{
var item = SegmentQueue.Dequeue();
Color color = item.TurnAround ? ORANGE : Color.yellow;
RenderUtil.RenderSegmnetOverlay(cameraInfo, item.SegmentID, color);
}
while (NodeQueue.Count > 0)
{
var item = NodeQueue.Dequeue();
bool end = item.NodeID.ToNode().m_flags.IsFlagSet(NetNode.Flags.End);
if (item.IsBendNode || end)
{
RenderUtil.DrawNodeCircle(cameraInfo, Color.yellow, item.NodeID);
}
else if (item.IsDC)
{
DrawDC(cameraInfo, item.SegmentID, item.SegmentID2, item.NodeID);
}
else
{
HighlightSegmentEnd(cameraInfo, item.SegmentID, item.NodeID, Color.yellow);
}
}
while (PropQueue.Count > 0)
{
var item = PropQueue.Dequeue();
PropTool.RenderOverlay(
cameraInfo, item.Prop, item.Pos, item.Scale, item.Angle, Color.yellow);
}
while (TreeQueue.Count > 0)
{
var item = TreeQueue.Dequeue();
TreeTool.RenderOverlay(cameraInfo, item.Tree, item.Pos, item.Scale, Color.yellow);
}
}
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;
m_OptionsBrushPanel?.Hide();
if (buildingInfo != null)
{
BuildingTool buildingTool = SetTool <BuildingTool>();
if (buildingTool != null)
{
this.HideAllOptionPanels();
buildingTool.m_prefab = buildingInfo;
buildingTool.m_relocate = 0;
}
}
if (netInfo != null)
{
NetTool netTool = ToolsModifierControl.SetTool <NetTool>();
if ((Object)netTool != (Object)null)
{
if (netInfo.GetSubService() == ItemClass.SubService.BeautificationParks)
{
this.ShowPathsOptionPanel();
}
else if (netInfo.GetClassLevel() == ItemClass.Level.Level3)
{
this.ShowFloodwallsOptionPanel();
}
else if (netInfo.GetClassLevel() == ItemClass.Level.Level4)
{
this.ShowQuaysOptionPanel();
}
else
{
this.ShowCanalsOptionPanel();
}
netTool.Prefab = netInfo;
}
}
if (treeInfo != null)
{
var prevTreeTool = GetCurrentTool <TreeTool>();
TreeTool treeTool = SetTool <TreeTool>();
if (treeTool != null)
{
this.HideAllOptionPanels();
treeTool.m_prefab = treeInfo;
//begin mod
if (prevTreeTool == null)
{
treeTool.m_brush = toolController.m_brushes[3];
treeTool.m_brushSize = 30;
treeTool.m_mode = TreeTool.Mode.Single;
}
ShowBrushOptionsPanel();
//end mod
}
}
if (!(propInfo != null))
{
return;
}
var prevPropTool = GetCurrentTool <PropTool>();
PropTool propTool = SetTool <PropTool>();
if (!(propTool != null))
{
return;
}
this.HideAllOptionPanels();
propTool.m_prefab = propInfo;
if (prevPropTool == null)
{
propTool.m_mode = PropTool.Mode.Single;
}
//begin mod
ShowBrushOptionsPanel();
//end mod
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
if (this.m_toolController.IsInsideUI || !Cursor.visible)
{
base.RenderOverlay(cameraInfo);
return;
}
switch (HoverInstance.Type)
{
case InstanceType.Building:
{
ushort building = HoverInstance.Building;
NetManager instance = Singleton <NetManager> .instance;
BuildingManager instance2 = Singleton <BuildingManager> .instance;
BuildingInfo info5 = instance2.m_buildings.m_buffer[(int)building].Info;
Color toolColor6 = GetOverlayColor();
float num = 1f;
BuildingTool.CheckOverlayAlpha(info5, ref num);
ushort num2 = instance2.m_buildings.m_buffer[(int)building].m_netNode;
int num3 = 0;
while (num2 != 0)
{
for (int j = 0; j < 8; j++)
{
ushort segment = instance.m_nodes.m_buffer[(int)num2].GetSegment(j);
if (segment != 0 && instance.m_segments.m_buffer[(int)segment].m_startNode == num2 && (instance.m_segments.m_buffer[(int)segment].m_flags & NetSegment.Flags.Untouchable) != NetSegment.Flags.None)
{
NetTool.CheckOverlayAlpha(ref instance.m_segments.m_buffer[(int)segment], ref num);
}
}
num2 = instance.m_nodes.m_buffer[(int)num2].m_nextBuildingNode;
if (++num3 > 32768)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
ushort subBuilding = instance2.m_buildings.m_buffer[(int)building].m_subBuilding;
num3 = 0;
while (subBuilding != 0)
{
BuildingTool.CheckOverlayAlpha(instance2.m_buildings.m_buffer[(int)subBuilding].Info, ref num);
subBuilding = instance2.m_buildings.m_buffer[(int)subBuilding].m_subBuilding;
if (++num3 > 49152)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
toolColor6.a *= num;
int length = instance2.m_buildings.m_buffer[(int)building].Length;
Vector3 position2 = instance2.m_buildings.m_buffer[(int)building].m_position;
float angle2 = instance2.m_buildings.m_buffer[(int)building].m_angle;
BuildingTool.RenderOverlay(cameraInfo, info5, length, position2, angle2, toolColor6, false);
num2 = instance2.m_buildings.m_buffer[(int)building].m_netNode;
num3 = 0;
while (num2 != 0)
{
for (int k = 0; k < 8; k++)
{
ushort segment2 = instance.m_nodes.m_buffer[(int)num2].GetSegment(k);
if (segment2 != 0 && instance.m_segments.m_buffer[(int)segment2].m_startNode == num2 && (instance.m_segments.m_buffer[(int)segment2].m_flags & NetSegment.Flags.Untouchable) != NetSegment.Flags.None)
{
NetTool.RenderOverlay(cameraInfo, ref instance.m_segments.m_buffer[(int)segment2], toolColor6, toolColor6);
}
}
num2 = instance.m_nodes.m_buffer[(int)num2].m_nextBuildingNode;
if (++num3 > 32768)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
subBuilding = instance2.m_buildings.m_buffer[(int)building].m_subBuilding;
num3 = 0;
while (subBuilding != 0)
{
BuildingInfo info6 = instance2.m_buildings.m_buffer[(int)subBuilding].Info;
int length2 = instance2.m_buildings.m_buffer[(int)subBuilding].Length;
Vector3 position3 = instance2.m_buildings.m_buffer[(int)subBuilding].m_position;
float angle3 = instance2.m_buildings.m_buffer[(int)subBuilding].m_angle;
BuildingTool.RenderOverlay(cameraInfo, info6, length2, position3, angle3, toolColor6, false);
subBuilding = instance2.m_buildings.m_buffer[(int)subBuilding].m_subBuilding;
if (++num3 > 49152)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
break;
}
case InstanceType.Tree:
{
uint tree = HoverInstance.Tree;
TreeManager instance11 = Singleton <TreeManager> .instance;
TreeInfo info9 = instance11.m_trees.m_buffer[(int)((UIntPtr)tree)].Info;
Vector3 position6 = instance11.m_trees.m_buffer[(int)((UIntPtr)tree)].Position;
Randomizer randomizer4 = new Randomizer(tree);
float scale4 = info9.m_minScale + (float)randomizer4.Int32(10000u) * (info9.m_maxScale - info9.m_minScale) * 0.0001f;
Color toolColor13 = GetOverlayColor();
float num13 = 1f;
TreeTool.CheckOverlayAlpha(info9, scale4, ref num13);
toolColor13.a *= num13;
TreeTool.RenderOverlay(cameraInfo, info9, position6, scale4, toolColor13);
break;
}
}
base.RenderOverlay(cameraInfo);
}
