private IEnumerator CreateProp()
{
Debug.Log("CreateProp detour");
UndoMod.Instsance.BeginObserving("Build prop", "Vanilla");
IEnumerator result = null;
RedirectionHelper.RevertRedirect(createProp_original, state);
try
{
result = (IEnumerator)createProp_original.Invoke(ToolsModifierControl.GetTool <PropTool>(), new object[] { });
AsyncTask asyncTask = new AsyncTask(result, null);
asyncTask.Execute();
}
catch (Exception e)
{
Debug.LogError(e);
UndoMod.Instsance.InvalidateAll();
}
state = RedirectionHelper.RedirectCalls(createProp_original, patch);
//Singleton<SimulationManager>.instance.AddAction(() => {
UndoMod.Instsance.EndObserving();
//});
yield return(0);
yield break;
}
public MainPanel()
{
UIView uiView = UIView.GetAView();
dialog = uiView.AddUIComponent(typeof(DropdownDialog)) as DropdownDialog;
dialog.Hide();
placeSignBtn = (UIButton)uiView.AddUIComponent(typeof(UIButton));
placeSignBtn.text = "DB";
placeSignBtn.width = 75;
placeSignBtn.height = 30;
placeSignBtn.normalBgSprite = "ButtonMenu";
placeSignBtn.disabledBgSprite = "ButtonMenuDisabled";
placeSignBtn.hoveredBgSprite = "ButtonMenuHovered";
placeSignBtn.focusedBgSprite = "ButtonMenuFocused";
placeSignBtn.pressedBgSprite = "ButtonMenuPressed";
placeSignBtn.textColor = new Color32(255, 255, 255, 255);
placeSignBtn.disabledTextColor = new Color32(7, 7, 7, 255);
placeSignBtn.hoveredTextColor = new Color32(7, 132, 255, 255);
placeSignBtn.focusedTextColor = new Color32(255, 255, 255, 255);
placeSignBtn.pressedTextColor = new Color32(30, 30, 44, 255);
placeSignBtn.eventClick += propSelectorToolBtn_eventClick;
placeSignBtn.relativePosition = new Vector3(30, 60);
propSelectorTool = ToolsModifierControl.toolController.gameObject.AddComponent <PropSelectorTool>();
ToolsModifierControl.toolController.CurrentTool = ToolsModifierControl.GetTool <DefaultTool>();
ToolsModifierControl.SetTool <DefaultTool>();
propSelectorTool.dialog = dialog;
}
public MainPanel()
{
UIView uiView = UIView.GetAView();
markRouteBtn = (UIButton)uiView.AddUIComponent(typeof(UIButton));
markRouteBtn.text = "Mark a Route";
markRouteBtn.width = 150;
markRouteBtn.height = 30;
markRouteBtn.normalBgSprite = "ButtonMenu";
markRouteBtn.disabledBgSprite = "ButtonMenuDisabled";
markRouteBtn.hoveredBgSprite = "ButtonMenuHovered";
markRouteBtn.focusedBgSprite = "ButtonMenuFocused";
markRouteBtn.pressedBgSprite = "ButtonMenuPressed";
markRouteBtn.textColor = new Color32(255, 255, 255, 255);
markRouteBtn.disabledTextColor = new Color32(7, 7, 7, 255);
markRouteBtn.hoveredTextColor = new Color32(7, 132, 255, 255);
markRouteBtn.focusedTextColor = new Color32(255, 255, 255, 255);
markRouteBtn.pressedTextColor = new Color32(30, 30, 44, 255);
markRouteBtn.eventClick += markRouteBtn_eventClick;
markRouteBtn.relativePosition = new Vector3(180f, 60f);
ToolsModifierControl.toolController.CurrentTool = ToolsModifierControl.GetTool <DefaultTool>();
ToolsModifierControl.SetTool <DefaultTool>();
}
protected override void HandleSignPlaced()
{
RouteManager.Instance().SetSign(this.m_cachedPosition, this.m_cachedAngle, routePrefix, routeStr, destination, this.signType);
RenderingManager.instance.ForceUpdate();
ToolsModifierControl.toolController.CurrentTool = ToolsModifierControl.GetTool <DefaultTool>();
ToolsModifierControl.SetTool <DefaultTool>();
}
public void Update()
{
var tool = ToolsModifierControl.GetTool <SelectionTool>();
if (tool == null)
{
return;
}
if (!tool.enabled && bar.isVisible)
{
bar.Hide();
}
if (ModInfo.ClipboardToolShortcut.IsPressed())
{
if (!_keyPressProcessed)
{
_keyPressProcessed = true;
ToggleTool();
}
}
else
{
_keyPressProcessed = false;
}
}
public static void SetUpUndoModififcationPanel(UIComponent optionsBar)
{
if (GameObject.Find("UndoTerrainPanel") != null)
{
return;
}
var undoPanel = optionsBar.AddUIComponent <UIPanel>();
undoPanel.name = "UndoTerrainPanel";
undoPanel.backgroundSprite = "MenuPanel2";
undoPanel.size = new Vector2(231, 106);
undoPanel.isVisible = false;
undoPanel.relativePosition = new Vector3(-256, -594);
UIUtil.SetupTitle("", undoPanel);
var applyButton = undoPanel.AddUIComponent <UIButton>();
applyButton.name = "Apply";
applyButton.localeID = "MAPEDITOR_UNDO_TERRAIN";
applyButton.size = new Vector2(191, 38);
applyButton.relativePosition = new Vector3(20, 54);
applyButton.normalBgSprite = "ButtonMenu";
applyButton.hoveredBgSprite = "ButtonMenuHovered";
applyButton.pressedBgSprite = "ButtonMenuPressed";
applyButton.disabledBgSprite = "ButtonMenuDisabled";
applyButton.canFocus = false;
var utoPanel = undoPanel.gameObject.AddComponent <UndoTerrainOptionPanel>();
applyButton.eventClick += (component, eventParam) => { utoPanel.UndoTerrain(); };
var toolField = typeof(UndoTerrainOptionPanel).GetField("m_TerrainTool", BindingFlags.Instance | BindingFlags.NonPublic);
toolField.SetValue(utoPanel, ToolsModifierControl.GetTool <TerrainTool>());
}
private static void DisableTool()
{
if (ToolsModifierControl.toolController.CurrentTool == _simpleSelectionTool)
{
ToolsModifierControl.toolController.CurrentTool = ToolsModifierControl.GetTool <DefaultTool>();
ToolsModifierControl.SetTool <DefaultTool>();
}
}
public new void OnPoliciesClick()
{
if ((Object)ToolsModifierControl.GetTool <DistrictTool>() != (Object)ToolsModifierControl.GetCurrentTool <DistrictTool>())
{
ToolsModifierControl.keepThisWorldInfoPanel = true;
}
ToolsModifierControl.mainToolbar.ShowPoliciesPanel(this.m_InstanceID.District);
UIView.Find <UIPanel>("PoliciesPanel").Find <UITabstrip>("Tabstrip").selectedIndex = 0;
}
protected override void OnToolUpdate()
{
if (m_toolController != null && !m_toolController.IsInsideUI && Cursor.visible)
{
RaycastOutput raycastOutput;
if (RaycastRoad(out raycastOutput))
{
ushort netSegmentId = raycastOutput.m_netSegment;
if (netSegmentId != 0)
{
NetManager netManager = Singleton <NetManager> .instance;
NetSegment netSegment = netManager.m_segments.m_buffer[(int)netSegmentId];
if (netSegment.m_flags.IsFlagSet(NetSegment.Flags.Created))
{
if (Event.current.type == EventType.MouseDown /*&& Event.current.button == (int)UIMouseButton.Left*/)
{
Vector3 pos1;
Vector3 pos2;
Vector3 rot1;
Vector3 rot2;
bool smooth1;
bool smooth2;
netSegment.CalculateCorner(netSegmentId, true, true, true, out pos1, out rot1, out smooth1);
netSegment.CalculateCorner(netSegmentId, true, false, true, out pos2, out rot2, out smooth2);
LoggerUtils.Log(string.Format("pos:{0},rot:{1}", pos1, rot1));
LoggerUtils.Log(string.Format("pos:{0},rot:{1}", pos2, rot2));
Vector3 diff = pos2 - pos1;
float angle = Mathf.Atan2(diff.y, diff.x) * Mathf.Rad2Deg;
LoggerUtils.Log(string.Format("angle:{0}", angle));
ShowToolInfo(false, null, new Vector3());
VehicleInfo info = VehicleHolder.getInstance().getVehicleInfo();
VehicleHolder.getInstance().setActive(netSegment.m_middlePosition, Vector3.zero);
//unset self as tool
ToolsModifierControl.toolController.CurrentTool = ToolsModifierControl.GetTool <DefaultTool>();
ToolsModifierControl.SetTool <DefaultTool>();
UnityEngine.Object.Destroy(this);
}
else
{
ShowToolInfo(true, "Spawn Vehicle", netSegment.m_bounds.center);
}
}
}
}
}
else
{
ShowToolInfo(false, null, new Vector3());
}
}
public override void OnLoadData()
{
if ((CSLTraffic.Options & OptionsManager.ModOptions.BetaTestRoadCustomizerTool) == OptionsManager.ModOptions.None || (CSLTraffic.Options & OptionsManager.ModOptions.GhostMode) == OptionsManager.ModOptions.GhostMode)
{
return;
}
Debug.Log("Traffic++: Loading road data!");
byte[] data = serializableDataManager.LoadData(LANE_DATA_ID);
if (data == null)
{
Debug.Log("Traffic++: No road data to load!");
return;
}
MemoryStream memStream = new MemoryStream();
memStream.Write(data, 0, data.Length);
memStream.Position = 0;
BinaryFormatter binaryFormatter = new BinaryFormatter();
try
{
RoadManager.sm_lanes = (Lane[])binaryFormatter.Deserialize(memStream);
FastList <ushort> nodesList = new FastList <ushort>();
foreach (Lane lane in RoadManager.sm_lanes)
{
if (lane == null)
{
continue;
}
lane.UpdateArrows();
if (lane.ConnectionCount() > 0)
{
nodesList.Add(lane.m_nodeId);
}
}
RoadCustomizerTool customizerTool = ToolsModifierControl.GetTool <RoadCustomizerTool>();
foreach (ushort nodeId in nodesList)
{
customizerTool.SetNodeMarkers(nodeId);
}
}
catch (Exception e)
{
Debug.Log("Traffic++: Unexpected " + e.GetType().Name + " loading road data.");
}
finally
{
memStream.Close();
}
}
public void UndoTerrain()
{
var terrainTool = ToolsModifierControl.GetTool <TerrainTool>();
if (terrainTool == null || !terrainTool.IsUndoAvailable())
{
return;
}
TerrainToolDetour.Undo(terrainTool);
}
/// <summary>
/// This method initializes mod's first time loading.
/// If <see cref="NetTool" /> is detected we initialize all the support structures, load the available networks and
/// finally create the UI.
/// </summary>
public void Start()
{
try
{
// Find NetTool and deploy
if (ToolsModifierControl.GetTool <NetTool>() == null)
{
Log.Warning($"[{nameof(ParallelRoadTool)}.{nameof(Start)}] Net Tool not found, can't deploy!");
enabled = false;
return;
}
Log.Info($"[{nameof(ParallelRoadTool)}.{nameof(Start)}] Loading version: {ModInfo.ModName} ({nameof(IsInGameMode)} is {IsInGameMode})");
// Init support data
SelectedRoadTypes = new List <NetTypeItem>();
IsSnappingEnabled = false;
IsLeftHandTraffic = Singleton <SimulationManager> .instance.m_metaData.m_invertTraffic ==
SimulationMetaData.MetaBool.True;
_isToolActive = _isToolEnabled = false;
LoadNetworks();
// Subscribe to milestones updated, but only if we're not in map editor
if (IsInGameMode)
{
Singleton <UnlockManager> .instance.m_milestonesUpdated += OnMilestoneUpdate;
}
Log._Debug($"[{nameof(ParallelRoadTool)}.{nameof(Start)}] Adding UI components");
// Main UI init
var view = UIView.GetAView();
_mainWindow ??= view.FindUIComponent <UIMainWindow>($"{Configuration.ResourcePrefix}MainWindow");
if (_mainWindow != null)
{
DestroyImmediate(_mainWindow);
}
_mainWindow = view.AddUIComponent(typeof(UIMainWindow)) as UIMainWindow;
SubscribeToUIEvents();
_mainWindow.OnToolChanged += ToolBaseDetour_OnToolChanged;
Log.Info($"[{nameof(ParallelRoadTool)}.{nameof(Start)}] Loaded");
}
catch (Exception e)
{
Log._DebugOnlyError($"[{nameof(ParallelRoadTool)}.{nameof(Start)}] Loading failed");
Log.Exception(e);
enabled = false;
}
}
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
}
private void OnEnable()
{
this.RefreshPanel();
RoadCustomizerTool rct = ToolsModifierControl.GetTool <RoadCustomizerTool>();
if (rct != null)
{
rct.OnStartLaneCustomization += EnableIcons;
rct.OnEndLaneCustomization += DisableIcons;
}
}
private static void SetUpNaturalResourcesTool(ICollection <ToolBase> extraTools)
{
var resourceTool = ToolsModifierControl.GetTool <ResourceTool>();
if (resourceTool == null)
{
resourceTool = ToolsModifierControl.toolController.gameObject.AddComponent <ResourceTool>();
extraTools.Add(resourceTool);
}
resourceTool.m_brush = ToolsModifierControl.toolController.m_brushes[0];
}
private void DestroyTool()
{
if (TrafficManagerTool != null)
{
ToolsModifierControl.toolController.CurrentTool = ToolsModifierControl.GetTool <DefaultTool>();
ToolsModifierControl.SetTool <DefaultTool>();
Object.Destroy(TrafficManagerTool);
TrafficManagerTool = null;
}
}
/// <summary>
/// Destroy the EnhancedDistrictServicesTool object.
/// </summary>
public override void OnReleased()
{
if (ToolsModifierControl.toolController != null && ToolsModifierControl.toolController.gameObject != null)
{
ToolsModifierControl.toolController.CurrentTool = ToolsModifierControl.GetTool <DefaultTool>();
var tool = ToolsModifierControl.toolController.gameObject.GetComponent <EnhancedDistrictServicesTool>();
if (tool != null)
{
UnityEngine.Object.Destroy(tool);
}
}
}
public void Update()
{
if ((Input.GetKey(KeyCode.RightShift) || Input.GetKey(KeyCode.LeftShift)) && Input.GetKeyDown(KeyCode.N))
{
var tool = ToolsModifierControl.GetTool <NodeElevationTool>();
if (tool == null)
{
return;
}
tool.enabled = true;
}
}
private void MainWindowOnNetworkItemAdded(object sender, EventArgs e)
{
// Previous item's offset so that we can try to separate this one from previous one without overlapping
var prevOffset = SelectedRoadTypes.Any() ? SelectedRoadTypes.Last().HorizontalOffset : 0;
var netInfo = ToolsModifierControl.GetTool <NetTool>().Prefab;
var item = new NetTypeItem(netInfo, prevOffset + netInfo.m_halfWidth * 2, 0, false);
SelectedRoadTypes.Add(item);
_mainWindow.AddItem(item);
NetManagerDetour.NetworksCount = SelectedRoadTypes.Count;
}
private void propSelectorToolBtn_eventClick(UIComponent component, UIMouseEventParameter eventParam)
{
if (ToolsModifierControl.toolController.CurrentTool == propSelectorTool)
{
ToolsModifierControl.toolController.CurrentTool = ToolsModifierControl.GetTool <DefaultTool>();
ToolsModifierControl.SetTool <DefaultTool>();
}
else
{
ToolsModifierControl.toolController.CurrentTool = propSelectorTool;
ToolsModifierControl.SetTool <PropSelectorTool>();
}
}
public static void DisableTool()
{
Log._Debug("LoadingExtension.DisableTool: called");
if (ToolsModifierControl.toolController != null)
{
ToolsModifierControl.toolController.CurrentTool = ToolsModifierControl.GetTool <DefaultTool>();
ToolsModifierControl.SetTool <DefaultTool>();
}
else
{
Log.Warning("LoadingExtensions.DisableTool: ToolsModifierControl.toolController is null!");
}
}
private void OnDisable()
{
RoadCustomizerTool rct = ToolsModifierControl.GetTool <RoadCustomizerTool>();
if (rct != null)
{
if (m_panelType == Panel.VehicleRestrictions)
{
rct.OnStartLaneCustomization -= EnableIcons;
rct.OnEndLaneCustomization -= DisableIcons;
}
}
}
public static void Update()
{
if (ploppedPrefab == null)
{
return;
}
var toolManager = Singleton <ToolManager> .instance;
if (toolManager?.m_properties == null)
{
return;
}
if (Input.GetKeyDown(KeyCode.Escape))
{
Singleton <ToolManager> .instance.m_properties.CurrentTool = ToolsModifierControl.GetTool <DefaultTool>();
ploppedPrefab = null;
return;
}
var currentTool = toolManager.m_properties.CurrentTool;
if (currentTool == null)
{
return;
}
if (currentTool is BuildingTool || currentTool is NetTool || currentTool is TreeTool ||
currentTool is PropTool)
{
var prefabField = currentTool.GetType()
.GetField("m_prefab", BindingFlags.Instance | BindingFlags.Public);
if (prefabField != null)
{
var prefab = prefabField.GetValue(currentTool);
if ((PrefabInfo)prefab != ploppedPrefab)
{
ploppedPrefab = null;
}
}
else
{
ploppedPrefab = null;
}
}
else
{
ploppedPrefab = null;
}
}
private void markRouteBtn_eventClick(UIComponent component, UIMouseEventParameter eventParam)
{
ToolsModifierControl.toolController.CurrentTool = ToolsModifierControl.GetTool <DefaultTool>();
ToolsModifierControl.SetTool <DefaultTool>();
if (m_isUiShowing)
{
hideUI();
}
else
{
showUI();
}
}
/// <summary>
/// Create the EnhancedDistrictServicesTool object.
/// </summary>
public override void OnLevelLoaded(LoadMode mode)
{
base.OnLevelLoaded(mode);
if (mode == LoadMode.LoadGame || mode == LoadMode.NewGame)
{
var tool = ToolsModifierControl.toolController.gameObject.GetComponent <EnhancedDistrictServicesTool>();
if (tool == null)
{
ToolsModifierControl.toolController.gameObject.AddComponent <EnhancedDistrictServicesTool>();
ToolsModifierControl.toolController.CurrentTool = ToolsModifierControl.GetTool <DefaultTool>();
}
}
}
public IEnumerable <ToolBase> SetupTools(LoadMode mode)
{
if (mode != LoadMode.LoadGame && mode != LoadMode.NewGame)
{
return(new ToolBase[] { });
}
var surfaceBrushTool = ToolsModifierControl.GetTool <InGameSurfaceTool>();
if (surfaceBrushTool != null)
{
return(new ToolBase[] { });
}
surfaceBrushTool = ToolsModifierControl.toolController.gameObject.AddComponent <InGameSurfaceTool>();
return(new ToolBase[] { surfaceBrushTool });
}
private void deleteSignBtn_eventClick(UIComponent component, UIMouseEventParameter eventParam)
{
mSignDeletionTool.isDynamic = false;
if (ToolsModifierControl.toolController.CurrentTool != mSignDeletionTool)
{
ToolsModifierControl.toolController.CurrentTool = mSignDeletionTool;
ToolsModifierControl.SetTool <SignDeletionTool>();
}
else
{
ToolsModifierControl.toolController.CurrentTool = ToolsModifierControl.GetTool <DefaultTool>();
ToolsModifierControl.SetTool <DefaultTool>();
}
EventBusManager.Instance().Publish("closeAll", null);
}
private void addDynamicSignBtn_eventClick(UIComponent component, UIMouseEventParameter eventParam)
{
mRoadSelectTool.isDynamic = true;
mRoadSelectTool.angleDialog = angleDialog;
if (ToolsModifierControl.toolController.CurrentTool != mRoadSelectTool)
{
ToolsModifierControl.toolController.CurrentTool = mRoadSelectTool;
ToolsModifierControl.SetTool <RoadSelectorTool>();
}
else
{
ToolsModifierControl.toolController.CurrentTool = ToolsModifierControl.GetTool <DefaultTool>();
ToolsModifierControl.SetTool <DefaultTool>();
}
EventBusManager.Instance().Publish("closeAll", null);
}
// When one presses "ESC" they expect tools to be cleared. This fix returns that functionality.
public override void OnAfterSimulationTick()
{
if ((Input.GetKeyDown(KeyCode.Escape) || Input.GetKeyDown(KeyCode.Return)) && ResolveOverlapsTool.instance != null && ToolsModifierControl.GetTool <ResolveOverlapsTool>())
{
ToolsModifierControl.GetTool <ResolveOverlapsTool>().enabled = false;
UIView.Find("E3A")?.Unfocus();
UIView.Find("E3B")?.Unfocus();
ToolsModifierControl.SetTool <DefaultTool>();
}
// The strangest bugfix known to man
if (ToolsModifierControl.toolController.CurrentTool == null)
{
ToolsModifierControl.SetTool <DefaultTool>();
}
}
public static bool ClearLaneConnections(uint laneId)
{
bool result = false;
Lane lane = GetLane(laneId);
if (lane != null)
{
result = true;
foreach (uint connectionId in GetLaneConnections(laneId))
{
result &= lane.RemoveConnection(connectionId);
}
ToolsModifierControl.GetTool <RoadCustomizerTool>().SetNodeMarkers(lane.m_nodeId, true);
}
return(result);
}
