public static void Prefix(MoveItTool __instance)
{
if (__instance.toolState == MoveItTool.ToolState.AligningHeights && Mod.mode != Mod.Mode.Off)
{
// User switched tool
Mod.mode = Mod.Mode.Off;
}
}
public static void Postfix(MoveItTool __instance)
{
//Debug.Log($"toolState:{__instance.toolState}");
if (__instance.toolState == MoveItTool.ToolState.AligningHeights)
{
MITE.AlignMode = MITE.AlignModes.Height;
UI.UpdateAlignTools();
}
return;
}
public static bool Prefix(MoveItTool __instance)
{
//Debug.Log($"toolState:{__instance.toolState}");
if (__instance.toolState == MoveItTool.ToolState.AligningHeights)
{
// User switched tool
__instance.toolState = MoveItTool.ToolState.Default;
MITE.AlignMode = MITE.AlignModes.Off;
UI.UpdateAlignTools();
}
return(false);
}
public static bool Deactivate(bool switchMode = true)
{
if (switchMode)
{
mode = Mode.Off;
}
MoveItTool tool = (MoveItTool)ColossalFramework.Singleton <ToolController> .instance.CurrentTool;
tool.toolState = MoveItTool.ToolState.Default;
UIToolOptionPanel.RefreshAlignHeightButton();
Action.UpdateArea(Action.GetTotalBounds(false));
return(false);
}
public static bool Prefix(MoveItTool __instance, ref Instance ___m_hoverInstance, ref int ___m_nextAction)
{
if (__instance == null)
{
//Debug.Log("Null instance!");
return(true);
}
if (Mod.mode != Mod.Mode.Off)
{
float angle;
if (___m_hoverInstance is MoveableBuilding mb)
{
Building building = Singleton <BuildingManager> .instance.m_buildings.m_buffer[mb.id.Building];
angle = building.m_angle;
}
else if (___m_hoverInstance is MoveableProp mp)
{
PropInstance prop = Singleton <PropManager> .instance.m_props.m_buffer[mp.id.Prop];
angle = prop.Angle;
}
else if (___m_hoverInstance is MoveableSegment ms)
{
PropInstance segment = Singleton <PropManager> .instance.m_props.m_buffer[ms.id.Prop];
NetSegment[] segmentBuffer = NetManager.instance.m_segments.m_buffer;
Vector3 startPos = NetManager.instance.m_nodes.m_buffer[segmentBuffer[ms.id.NetSegment].m_startNode].m_position;
Vector3 endPos = NetManager.instance.m_nodes.m_buffer[segmentBuffer[ms.id.NetSegment].m_endNode].m_position;
//Debug.Log($"Vector:{endNode.x - startNode.x},{endNode.z - startNode.z} Start:{startNode.x},{startNode.z} End:{endNode.x},{endNode.z}");
angle = (float)Math.Atan2(endPos.z - startPos.z, endPos.x - startPos.x);
}
else
{
//Debug.Log($"Wrong hover asset type <{___m_hoverInstance.GetType()}>");
return(Mod.Deactivate());
}
// Add action to queue, also enables Undo/Redo
AlignRotationAction action;
switch (Mod.mode)
{
case Mod.Mode.All:
action = new AlignGroupRotationAction();
break;
default:
action = new AlignEachRotationAction();
break;
}
action.newAngle = angle;
action.followTerrain = MoveItTool.followTerrain;
ActionQueue.instance.Push(action);
___m_nextAction = Mod.TOOL_ACTION_DO;
//Debug.Log($"Angle:{angle}, from {___m_hoverInstance}");
return(Mod.Deactivate(false));
}
return(true);
}
public static bool Prefix(MoveItTool __instance, ref Instance ___m_hoverInstance, ref int ___m_nextAction)
{
if (___m_hoverInstance == null)
{
return(true);
}
if (MITE.AlignMode != MITE.AlignModes.Off && MITE.AlignMode != MITE.AlignModes.Height)
{
float angle;
if (___m_hoverInstance is MoveableBuilding mb)
{
Building building = Singleton <BuildingManager> .instance.m_buildings.m_buffer[mb.id.Building];
angle = building.m_angle;
}
else if (___m_hoverInstance is MoveableProp mp)
{
PropInstance prop = Singleton <PropManager> .instance.m_props.m_buffer[mp.id.Prop];
angle = prop.Angle;
}
else if (___m_hoverInstance is MoveableSegment ms)
{
PropInstance segment = Singleton <PropManager> .instance.m_props.m_buffer[ms.id.Prop];
NetSegment[] segmentBuffer = NetManager.instance.m_segments.m_buffer;
Vector3 startPos = NetManager.instance.m_nodes.m_buffer[segmentBuffer[ms.id.NetSegment].m_startNode].m_position;
Vector3 endPos = NetManager.instance.m_nodes.m_buffer[segmentBuffer[ms.id.NetSegment].m_endNode].m_position;
//Debug.Log($"Vector:{endPos.x - startPos.x},{endPos.z - startPos.z} Start:{startPos.x},{startPos.z} End:{endPos.x},{endPos.z}");
angle = (float)Math.Atan2(endPos.z - startPos.z, endPos.x - startPos.x);
}
else
{
//Debug.Log($"Wrong hover asset type <{___m_hoverInstance.GetType()}>");
return(MITE.DeactivateAlignTool());
}
// Add action to queue, also enables Undo/Redo
AlignRotationAction action;
switch (MITE.AlignMode)
{
case MITE.AlignModes.Group:
action = new AlignGroupAction();
break;
default:
action = new AlignIndividualAction();
break;
}
action.newAngle = angle;
action.followTerrain = MoveItTool.followTerrain;
ActionQueue.instance.Push(action);
___m_nextAction = MITE.Tool_Action_Do;
//Debug.Log($"Angle:{angle}, from {___m_hoverInstance}");
return(MITE.DeactivateAlignTool(false));
}
if (__instance.toolState == MoveItTool.ToolState.AligningHeights)
{
//Debug.Log($"toolState is AligningHeights, AlignMode:{MITE.AlignMode} hB:{___m_hoverInstance.id.Building} hN:{___m_hoverInstance.id.NetNode} hS:{___m_hoverInstance.id.NetSegment}");
if (MITE.AlignMode == MITE.AlignModes.Height)
{
MITE.AlignMode = MITE.AlignModes.Off;
}
UI.UpdateAlignTools();
}
return(true);
}
private static bool Prefix(Ray mouseRay, MoveItTool __instance, ref Instance ___m_hoverInstance)
{
Traverse _MIT = Traverse.Create(__instance);
// MoveIt code
___m_hoverInstance = null;
Vector3 origin = mouseRay.origin;
Vector3 normalized = mouseRay.direction.normalized;
Vector3 vector = mouseRay.origin + normalized * Camera.main.farClipPlane;
Segment3 ray = new Segment3(origin, vector);
Building[] buildingBuffer = BuildingManager.instance.m_buildings.m_buffer;
PropInstance[] propBuffer = PropManager.instance.m_props.m_buffer;
NetNode[] nodeBuffer = NetManager.instance.m_nodes.m_buffer;
NetSegment[] segmentBuffer = NetManager.instance.m_segments.m_buffer;
TreeInstance[] treeBuffer = TreeManager.instance.m_trees.m_buffer;
Vector3 location = _MIT.Method("RaycastMouseLocation", mouseRay).GetValue <Vector3>();
InstanceID id = InstanceID.Empty;
ItemClass.Layer itemLayers = _MIT.Method("GetItemLayers").GetValue <ItemClass.Layer>();
bool selectBuilding = true;
bool selectProps = true;
bool selectDecals = true;
bool selectSurfaces = true;
bool selectNodes = true;
bool selectSegments = true;
bool selectTrees = true;
bool _repeatSearch = false;
if (MoveItTool.marqueeSelection)
{
selectBuilding = MoveItTool.filterBuildings;
selectProps = MoveItTool.filterProps;
selectDecals = MoveItTool.filterDecals;
selectSurfaces = MITE.filterSurfaces;
selectNodes = MoveItTool.filterNodes;
selectSegments = MoveItTool.filterSegments;
selectTrees = MoveItTool.filterTrees;
}
float smallestDist = 640000f;
do
{
int gridMinX = Mathf.Max((int)((location.x - 16f) / 64f + 135f) - 1, 0);
int gridMinZ = Mathf.Max((int)((location.z - 16f) / 64f + 135f) - 1, 0);
int gridMaxX = Mathf.Min((int)((location.x + 16f) / 64f + 135f) + 1, 269);
int gridMaxZ = Mathf.Min((int)((location.z + 16f) / 64f + 135f) + 1, 269);
for (int i = gridMinZ; i <= gridMaxZ; i++)
{
for (int j = gridMinX; j <= gridMaxX; j++)
{
if (selectBuilding || selectSurfaces)
{
ushort building = BuildingManager.instance.m_buildingGrid[i * 270 + j];
int count = 0;
while (building != 0u)
{
if (MITE.StepOver.isValidB(building) && Detour_Utils.IsBuildingValid(ref buildingBuffer[building], itemLayers) && buildingBuffer[building].RayCast(building, ray, out float t) && t < smallestDist)
{
//Debug.Log($"Building:{building}");
if (Filters.Filter(buildingBuffer[building].Info, true))
{
id.Building = Building.FindParentBuilding(building);
if (id.Building == 0)
{
id.Building = building;
}
smallestDist = t;
}
}
building = buildingBuffer[building].m_nextGridBuilding;
if (++count > 49152)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
break;
}
}
}
if (selectProps || selectDecals || selectSurfaces)
{
ushort prop = PropManager.instance.m_propGrid[i * 270 + j];
int count = 0;
while (prop != 0u)
{
if (MITE.StepOver.isValidP(prop) && Filters.Filter(propBuffer[prop].Info) && MITE.StepOver.isValidP(prop))
{
//Debug.Log($"Prop:{prop}");
if (propBuffer[prop].RayCast(prop, ray, out float t, out float targetSqr) && t < smallestDist)
{
id.Prop = prop;
smallestDist = t;
}
}
prop = propBuffer[prop].m_nextGridProp;
if (++count > 65536)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
}
}
}
if (selectNodes || selectBuilding)
{
ushort node = NetManager.instance.m_nodeGrid[i * 270 + j];
int count = 0;
while (node != 0u)
{
if (MITE.StepOver.isValidN(node) && Detour_Utils.IsNodeValid(ref nodeBuffer[node], itemLayers) && Detour_Utils.RayCastNode(ref nodeBuffer[node], ray, -1000f, out float t, out float priority) && t < smallestDist)
{
//Debug.Log($"Node:{node}");
ushort building = 0;
if (!Event.current.alt)
{
building = NetNode.FindOwnerBuilding(node, 363f);
}
if (building != 0)
{
if (selectBuilding)
{
id.Building = Building.FindParentBuilding(building);
if (id.Building == 0)
{
id.Building = building;
}
smallestDist = t;
}
}
else if (selectNodes)
{
if (Filters.Filter(nodeBuffer[node]))
{
id.NetNode = node;
smallestDist = t;
}
}
}
node = nodeBuffer[node].m_nextGridNode;
if (++count > 32768)
{
CODebugBase <LogChannel> .Error(LogChannel.Core, "Invalid list detected!\n" + Environment.StackTrace);
}
}
}
if (selectSegments || selectBuilding)
{
ushort segment = NetManager.instance.m_segmentGrid[i * 270 + j];
int count = 0;
while (segment != 0u)
{
if (MITE.StepOver.isValidS(segment) && Detour_Utils.IsSegmentValid(ref segmentBuffer[segment], itemLayers) &&
segmentBuffer[segment].RayCast(segment, ray, -1000f, false, out float t, out float priority) && t < smallestDist)
{
//Debug.Log($"Segment:{segment}");
ushort building = 0;
if (!Event.current.alt)
{
building = MoveItTool.FindOwnerBuilding(segment, 363f);
}
if (building != 0)
{
if (selectBuilding)
{
id.Building = Building.FindParentBuilding(building);
if (id.Building == 0)
{
id.Building = building;
}
smallestDist = t;
}
}
else if (selectSegments)
{
if (!selectNodes || (
!Detour_Utils.RayCastNode(ref nodeBuffer[segmentBuffer[segment].m_startNode], ray, -1000f, out float t2, out priority) &&
