Example #1
0
        public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
        {
            base.RenderOverlay(cameraInfo);

            if (enabled == true)
            {
                if (m_seg1 != 0)
                {
                    NetSegment hoveredSegment = GetSegment(m_seg1);
                    NetTool.RenderOverlay(cameraInfo, ref hoveredSegment, scolor, new Color(1f, 0f, 0f, 1f));
                }

                if (m_seg2 != 0)
                {
                    NetSegment hoveredSegment = GetSegment(m_seg2);
                    NetTool.RenderOverlay(cameraInfo, ref hoveredSegment, scolor, new Color(1f, 0f, 0f, 1f));
                }
                if (m_hover != 0)
                {
                    NetSegment hoveredSegment = GetSegment(m_hover);
                    NetTool.RenderOverlay(cameraInfo, ref hoveredSegment, m_errors ? Color.Lerp(hcolor, new Color(1f, 0f, 0f, 1f), (float)Mathf.Sin(pulsating / 5) / 2 + 0.5f) : hcolor, new Color(1f, 0f, 0f, 1f));
                    if (m_snapFakeNode != Vector3.zero)
                    {
                        RenderManager.instance.OverlayEffect.DrawCircle(cameraInfo, hcolor, m_snapFakeNode, 10f, m_snapFakeNode.y - 1f, m_snapFakeNode.y + 1f, true, true);
                    }
                }
                //if(true) { // @TODO find circle place???
                //    Singleton<RenderManager>.instance.OverlayEffect.DrawCircle(cameraInfo, new Color(), new Vector3(), 5f)
                //}
            }
        }
Example #2
0
        private static void HttpTest()
        {
            var httpServer = NetTool.CreateHttpSever();

            httpServer.hOnReceived = new HttpOnReceived((payload) =>
            {
                Log.L(payload.Header.Option);
                Log.L(payload.Header.RelativeUri);

                if (payload.Header.Option == HttpOption.GET)
                {
                    HttpGet get = new HttpGet(payload.Header);
                    var rsp     = get.Response(DateTime.Now.ToString());

                    httpServer.Send(payload.Token, Encoding.UTF8.GetBytes(rsp));
                    httpServer.Disconnect(payload.Token);
                }
            });
            bool isOk = httpServer.Start();

            if (isOk)
            {
                Log.L("listening on:" + httpServer.Port);
            }
        }
Example #3
0
        public void Awake()
        {
            try
            {
                if (_esc == null)
                {
                    _esc = GameObject.Find("Esc").GetComponent <UIButton>();
                    ModProperties.Instance.ControlPanelDefaultPositionX = _esc.absolutePosition.x - 336f;
                    ModProperties.Instance.ControlPanelDefaultPositionY = _esc.absolutePosition.y;

                    ModProperties.Instance.InfoPanelDefaultPositionX = ModProperties.Instance.ControlPanelDefaultPositionX + 70f;
                    ModProperties.Instance.InfoPanelDefaultPositionY = ModProperties.Instance.ControlPanelDefaultPositionY;
                }

                if (_measureTool == null)
                {
                    _measureTool = MeasureTool.Instance;
                }

                if (_netTool == null)
                {
                    _netTool = FindObjectOfType <NetTool>();
                }
            }
            catch (Exception e)
            {
                Debug.Log("[Measure It!] ModManager:Awake -> Exception: " + e.Message);
            }
        }
Example #4
0
 public void MainProcess()
 {
     while (true)
     {
         Monitor.Enter(rudp);
         UdpChunk c = rudp.RecvBuffOut();
         Monitor.Exit(rudp);
         if (c == null)
         {
             break;
         }
         if (c.size < 6)
         {
             break;
         }
         int  size  = NetTool.BytesToInt32(c.buff, 0);
         int  uid   = NetTool.BytesToInt32(c.buff, 4);
         int  msgid = NetTool.BytesToInt32(c.buff, 8);
         Type type  = UdpMsg.proto(msgid);
         if (type == null)
         {
             break;
         }
     }
 }
Example #5
0
 public HttpServer(int maxPoolCount = 64, int blockSize = 4096)
 {
     sProvider = NetTool.CreateTcpSever(blockSize, maxPoolCount);
     sProvider.DisconnectedCallback   = new OnDisconnectedHandler(OnDisconnected);
     sProvider.ReceivedOffsetCallback = new OnReceivedSegmentHandler(OnReceived);
     sProvider.AcceptedCallback       = new OnAcceptedHandler(OnAccepted);
 }
Example #6
0
        private static void SnapOverride(NetTool tool, NetInfo info, ref Vector3 point, ref Vector3 direction,
                                         Vector3 refPoint,
                                         float refAngle)
        {
            if (!EnableLengthSnapping)
            {
                return;
            }

            // Original reflected method from dotPeek
            direction = new Vector3(Mathf.Cos(refAngle), 0.0f, Mathf.Sin(refAngle));
            var vector3_1 = direction * 8f;
            var vector3_2 = new Vector3(vector3_1.z, 0.0f, -vector3_1.x);

            if (info.m_halfWidth <= 4.0)
            {
                refPoint.x += (float)(vector3_1.x * 0.5 + vector3_2.x * 0.5);
                refPoint.z += (float)(vector3_1.z * 0.5 + vector3_2.z * 0.5);
            }
            var vector2 = new Vector2(point.x - refPoint.x, point.z - refPoint.z);
            var num1    =
                Mathf.Round((float)((vector2.x * (double)vector3_1.x + vector2.y * (double)vector3_1.z) * (1.0 / 64.0)));
            var num2 =
                Mathf.Round((float)((vector2.x * (double)vector3_2.x + vector2.y * (double)vector3_2.z) * (1.0 / 64.0)));

            point.x = (float)(refPoint.x + num1 * (double)vector3_1.x + num2 * (double)vector3_2.x);
            point.z = (float)(refPoint.z + num1 * (double)vector3_1.z + num2 * (double)vector3_2.z);
        }
        public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
        {
            // Log._Debug($"Restrictions overlay {_cursorInSecondaryPanel} {HoveredNodeId} {SelectedNodeId} {HoveredSegmentId} {SelectedSegmentId}");

            if (SelectedSegmentId != 0)
            {
                NetTool.RenderOverlay(
                    cameraInfo,
                    ref Singleton <NetManager> .instance.m_segments.m_buffer[SelectedSegmentId],
                    MainTool.GetToolColor(true, false),
                    MainTool.GetToolColor(true, false));
            }

            if (cursorInSecondaryPanel)
            {
                return;
            }

            if (HoveredSegmentId != 0 && HoveredSegmentId != SelectedSegmentId &&
                !overlayHandleHovered)
            {
                NetTool.RenderOverlay(
                    cameraInfo,
                    ref Singleton <NetManager> .instance.m_segments.m_buffer[HoveredSegmentId],
                    MainTool.GetToolColor(false, false),
                    MainTool.GetToolColor(false, false));
            }
        }
Example #8
0
        public static ushort CreateSegment(ushort startNodeId, ushort endNodeId, Vector3 startDirection, Vector3 endDirection, NetInfo netInfo, bool invert = false, bool switchStartAndEnd = false, bool dispatchPlacementEffects = false)
        {
            var randomizer = Singleton <SimulationManager> .instance.m_randomizer;

            NetNode startNode = Node(startNodeId);
            NetNode endNode   = Node(endNodeId);

            if ((startNode.m_flags & NetNode.Flags.Created) == NetNode.Flags.None || (endNode.m_flags & NetNode.Flags.Created) == NetNode.Flags.None)
            {
                throw new Exception("Failed to create NetSegment: Invalid node(s)");
            }

            var result = NetManager.instance.CreateSegment(out ushort newSegmentId, ref randomizer, netInfo, switchStartAndEnd ? endNodeId : startNodeId,
                                                           switchStartAndEnd ? startNodeId : endNodeId,
                                                           (switchStartAndEnd ? endDirection : startDirection), (switchStartAndEnd ? startDirection : endDirection), Singleton <SimulationManager> .instance.m_currentBuildIndex,
                                                           Singleton <SimulationManager> .instance.m_currentBuildIndex, invert);

            if (!result)
            {
                throw new Exception("Failed to create NetSegment");
            }

            Singleton <SimulationManager> .instance.m_currentBuildIndex++;

            if (dispatchPlacementEffects)
            {
                bool smoothStart = (startNode.m_flags & NetNode.Flags.Middle) != NetNode.Flags.None;
                bool smoothEnd   = (endNode.m_flags & NetNode.Flags.Middle) != NetNode.Flags.None;
                NetSegment.CalculateMiddlePoints(startNode.m_position, startDirection, endNode.m_position, endDirection, smoothStart, smoothEnd, out Vector3 b, out Vector3 c);
                NetTool.DispatchPlacementEffect(startNode.m_position, b, c, endNode.m_position, netInfo.m_halfWidth, false);
            }

            return(newSegmentId);
        }
Example #9
0
        private void InitForClient()
        {
            forClient.Init("0.0.0.0", NetConfig.LISTENER_PORT);
            var addr = NetTool.GetAddress("0.0.0.0", NetConfig.LISTENER_PORT);

            Logger.LogInfo("初始化网络监听(客户端) [{0}]".FormatStr(addr));
        }
Example #10
0
        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);
            }
        }
Example #11
0
        private void RefreshDisplayData()
        {
            if (refreshOnce)
            {
                if (isVisible)
                {
                    m_fromLabel.text = Localization.Get("From");
                    m_toLabel.text   = Localization.Get("To");
                    //DebugLog.LogToFileOnly("fromSelected = " + fromSelected.ToString() + " toSelected = " + toSelected.ToString() + " symmetry = " + symmetry.ToString() + " uturnLane: " + uturnLane.ToString() + " hasSidewalk: " + hasSidewalk.ToString());

                    //DebugLog.LogToFileOnly(m_currentModule);
                    var m_prefab = Parser.NetInfoFromUI(fromSelected, toSelected, symmetry, hasSidewalk, hasBike);
                    m_prefab = UpdateRoadVariant(m_prefab);
                    if (m_prefab != null)
                    {
                        m_netTool = ToolsModifierControl.SetTool <NetTool>();
                        UIView.Find("RoadsPanel").Show();
                        m_netTool.m_prefab  = m_prefab;
                        m_result.atlas      = m_netTool.m_prefab.m_Atlas;
                        m_result.spriteName = m_netTool.m_prefab.m_Thumbnail;
                    }
                    else
                    {
                        //ToolsModifierControl.SetTool<DefaultTool>();
                        if (m_netTool != null)
                        {
                            m_netTool.m_prefab = null;
                        }
                        m_result.atlas      = SpriteUtilities.GetAtlas(Loader.m_atlasNameNoAsset);
                        m_result.spriteName = "NOASSET";
                    }
                    refreshOnce = false;
                }
            }
        }
        private string prepareCrlCache()
        {
            string crlCache;

            if (String.IsNullOrEmpty(_crlUrl))
            {
                return(null);
            }


            Uri uri = new Uri(_crlUrl);

            crlCache = Path.Combine(Logger.LogPath, Uri.UnescapeDataString(uri.Segments[uri.Segments.Length - 1]));


            if (!File.Exists(crlCache))
            {
                NetTool.CacheUrlResource(_crlUrl, crlCache);
            }

            if (!File.Exists(crlCache))
            {
                _errMsg = String.Format("無法下載憑證廢止清單=>{0}", _crlUrl);
                return(null);
            }

            return(crlCache);
        }
Example #13
0
 public static void RenderNodeBuilding2(this NetTool tool, BuildingInfo info, Vector3 position, Vector3 direction)
 {
     if (!Singleton <ToolManager> .instance.m_properties.IsInsideUI)
     {
         if (direction.sqrMagnitude < 0.5f)
         {
             return;
         }
         if (info.m_mesh == null)
         {
             return;
         }
         direction.y  = 0f;
         direction.x += 5;
         Quaternion      rotation = Quaternion.LookRotation(direction, Vector3.up);
         Building        building = default(Building);
         BuildingManager instance = Singleton <BuildingManager> .instance;
         instance.m_materialBlock.Clear();
         instance.m_materialBlock.SetVector(instance.ID_BuildingState, new Vector4(0f, 1000f, 0f, 256f));
         instance.m_materialBlock.SetVector(instance.ID_ObjectIndex, RenderManager.DefaultColorLocation);
         instance.m_materialBlock.SetColor(instance.ID_Color, info.m_buildingAI.GetColor(0, ref building, Singleton <InfoManager> .instance.CurrentMode));
         ToolManager expr_DC_cp_0 = Singleton <ToolManager> .instance;
         expr_DC_cp_0.m_drawCallData.m_defaultCalls = expr_DC_cp_0.m_drawCallData.m_defaultCalls + 1;
         Graphics.DrawMesh(info.m_mesh, position, rotation, info.m_material, info.m_prefabDataLayer, null, 0, instance.m_materialBlock);
     }
 }
        int RebuildSegment(int segmentIndex, NetInfo newPrefab, Vector3 directionPoint, Vector3 direction, ref ToolError error)
        {
            //  ModDebug.LogClassAndMethodName(this.GetType().Name, System.Reflection.MethodBase.GetCurrentMethod().Name);

            NetManager net    = Singleton <NetManager> .instance;
            NetInfo    prefab = net.m_segments.m_buffer[segmentIndex].Info;

            NetTool.ControlPoint startPoint;
            NetTool.ControlPoint middlePoint;
            NetTool.ControlPoint endPoint;

            MethodInfo dynMethod = netTool.GetType().GetMethod("ChangeElevation", BindingFlags.NonPublic | BindingFlags.Instance);

            if (toolMode == ToolMode.RoadHeightUp)
            {
                Singleton <SimulationManager> .instance.AddAction <bool>((IEnumerator <bool>) dynMethod.Invoke(new NetTool(), new object[] { 1 }));
            }
            else if (toolMode == ToolMode.RoadHeightDown)
            {
                Singleton <SimulationManager> .instance.AddAction <bool>((IEnumerator <bool>) dynMethod.Invoke(new NetTool(), new object[] { -1 }));
            }

            GetSegmentControlPoints(segmentIndex, out startPoint, out middlePoint, out endPoint);

            if (direction.magnitude > 0.0f)
            {
                float dot       = Vector3.Dot(direction.normalized, (endPoint.m_position - startPoint.m_position).normalized);
                float threshold = Mathf.Cos(Mathf.PI / 4);

                if (dot > -threshold && dot < threshold)
                {
                    return(0);
                }
            }

            ushort node           = 0;
            ushort segment        = 0;
            int    cost           = 0;
            int    productionRate = 0;

            //  CreateNode(NetInfo info, NetTool.ControlPoint startPoint, NetTool.ControlPoint middlePoint, NetTool.ControlPoint endPoint, FastList<NetTool.NodePosition> nodeBuffer, int maxSegments, bool test, bool visualize, bool autoFix, bool needMoney, bool invert, bool switchDir, ushort relocateBuildingID, out ushort firstNode, out ushort lastNode, out ushort segment, out int cost, out int productionRate)
            if (mouseDown && ((currentTime - prevRebuildTime) > 0.4f))
            {
                newPrefab.m_minHeight = 12.0f;
                NetTool.CreateNode(newPrefab, startPoint, middlePoint, endPoint, NetTool.m_nodePositionsSimulation, 1000, false, false, true, false, false, false, (ushort)0, out node, out segment, out cost, out productionRate);
            }
            if (segment != 0)
            {
                if (newPrefab.m_class.m_service == ItemClass.Service.Road)
                {
                    Singleton <CoverageManager> .instance.CoverageUpdated(ItemClass.Service.None, ItemClass.SubService.None, ItemClass.Level.None);
                }

                error = ToolError.None;
                return(segment);
            }

            return(0);
        }
Example #15
0
 public override void Setup(string ip, int port)
 {
     base.Setup(ip, port);
     _socket            = new WebSocketSharp.WebSocket(NetTool.GetAddress(ip, port) + "/default");
     _socket.OnOpen    += (a, b) => { base.OnConnected(); };
     _socket.OnClose   += (a, b) => { base.OnClosed(); };
     _socket.OnMessage += (a, b) => { base.OnReceived(b.RawData); };
 }
Example #16
0
        public static void CalculateGuideLines(NetInfo netInfo, NetTool.ControlPoint startPoint, NetTool.ControlPoint endPoint,
			IList<GuideLine> resultList)
        {
            lock (SegmentCache) {

                var startPosition = startPoint.m_position;
                var endPosition = endPoint.m_position;

                //var segments = NetManager.instance.m_segments;
                //NetManager.instance.GetClosestSegments(endPosition, SegmentCache, out _segmentCacheCount);

                NetUtil.GetClosestSegments(netInfo, endPosition, SegmentCache, out _segmentCacheCount);
                SnapController.DebugPrint = String.Format("Closest Segment Count: {0}", _segmentCacheCount);

                var c = _segmentCacheCount;
                for (ushort i = 0; i < c; i++) {

                    var segmentId = SegmentCache[i];

                    var s = NetManager.instance.m_segments.m_buffer[segmentId];

                    // Ensure they are part of the same network
                    if (!NetUtil.AreSimilarClass(s.Info, netInfo))
                        continue;

                    if (
                        Vector3Extensions.DistanceSquared(NetManager.instance.m_nodes.m_buffer[s.m_startNode].m_position, endPosition) >
                        Settings.MaxGuideLineQueryDistanceSqr)
                        continue;

                    // Test the start and end of the segment

                    // Check if the node can branch in the guide direction (angles less than 45deg or so should be discarded)
                    if (CanNodeBranchInDirection(s.m_endNode, s.m_startDirection)) {

                        var endNode = NetManager.instance.m_nodes.m_buffer[s.m_endNode];

                        TestLine(s.Info, startPosition, endPosition,
                            endNode.m_position,
                            endNode.m_position + s.m_startDirection.Flatten(),
                            resultList, segmentId, s.m_endNode);

                    }

                    if (CanNodeBranchInDirection(s.m_startNode, s.m_endDirection)) {

                        var startNode = NetManager.instance.m_nodes.m_buffer[s.m_startNode];

                        TestLine(s.Info, startPosition, endPosition,
                            startNode.m_position,
                            startNode.m_position + s.m_endDirection.Flatten(),
                            resultList, segmentId, s.m_startNode);

                    }
                }

            }
        }
Example #17
0
        public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
        {
            if (MainTool.GetToolController().IsInsideUI || !Cursor.visible)
            {
                return;
            }

            if (Input.GetKey(KeyCode.LeftShift) || Input.GetKey(KeyCode.RightShift))
            {
                // draw hovered segments
                if (HoveredSegmentId != 0)
                {
                    Color color = MainTool.GetToolColor(Input.GetMouseButton(0), false);
                    SegmentTraverser.Traverse(
                        HoveredSegmentId,
                        TraverseDirection.AnyDirection,
                        TraverseSide.Straight,
                        SegmentStopCriterion.None,
                        data => {
                        NetTool.RenderOverlay(
                            cameraInfo,
                            ref Singleton <NetManager> .instance.m_segments.m_buffer[
                                data.CurSeg.segmentId],
                            color,
                            color);
                        return(true);
                    });
                }
                else
                {
                    massEditMode = PrioritySignsMassEditMode.MainYield;
                }

                return;
            }

            massEditMode = PrioritySignsMassEditMode.MainYield;

            if (HoveredNodeId == SelectedNodeId)
            {
                return;
            }

            // no highlight for existing priority node in sign mode
            if (TrafficPriorityManager.Instance.HasNodePrioritySign(HoveredNodeId))
            {
                // Log._Debug($"PrioritySignsTool.RenderOverlay: HasNodePrioritySign({HoveredNodeId})=true");
                return;
            }

            if (!TrafficPriorityManager.Instance.MayNodeHavePrioritySigns(HoveredNodeId))
            {
                // Log._Debug($"PrioritySignsTool.RenderOverlay: MayNodeHavePrioritySigns({HoveredNodeId})=false");
                return;
            }

            MainTool.DrawNodeCircle(cameraInfo, HoveredNodeId, Input.GetMouseButton(0));
        }
Example #18
0
        public void Login()
        {
            BMLoginRequest msg = new BMLoginRequest();

            msg.ListenerAddress = NetTool.GetAddress(NetConfig.LISTENER_IP, NetConfig.LISTENER_PORT);
            SendMessage <BMLoginRequest, BMLoginReply>(msg, (reply) =>
            {
                Logger.Log($"登录主服成功, 战场名: {reply.Name}");
            });
        }
Example #19
0
 public override void Setup(string ip, int port)
 {
     base.Setup(ip, port);
     _socket           = new WebSocketSharp.WebSocket(NetTool.GetAddress(ip, port) + "/default");
     _socket.Log.Level = WebSocketSharp.LogLevel.Error;
     // _socket.WaitTime = TimeSpan.FromSeconds(1);
     _socket.OnOpen    += (a, b) => { base.OnConnected(); };
     _socket.OnClose   += (a, b) => { base.OnClosed(); };
     _socket.OnMessage += (a, b) => { base.OnReceived(b.RawData); };
 }
Example #20
0
 public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
 {
     base.RenderOverlay(cameraInfo);
     if (enabled == true)
     {
         if (m_hover != 0)
         {
             NetSegment hoveredSegment = GetSegment(m_hover);
             NetTool.RenderOverlay(cameraInfo, ref hoveredSegment, hcolor, new Color(1f, 0f, 0f, 1f));
         }
     }
 }
Example #21
0
        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;
                }
            }
        }
Example #22
0
        public override void Start()
        {
            m_netTool = FindObjectOfType <NetTool>();
            if (m_netTool == null)
            {
#if DEBUG
                Next.Debug.Log("NetTool 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;
            trackSize      = 1;
            trackDirection = 1;
            isStation      = 1;
            stationType    = 0;
            fence          = false;
            SetNetToolPrefab();
        }
Example #23
0
 public override void Setup(string ip, int port)
 {
     base.Setup(ip, port);
     _server           = new WebSocketSharp.Server.WebSocketServer(NetTool.GetAddress(ip, port));
     _server.Log.Level = WebSocketSharp.LogLevel.Error;
     _server.AddWebSocketService(defaultServicePath, () =>
     {
         WebSocketSession session = new WebSocketSession(SendAction);
         session.onConnected      = () => { OnSessionConnected(session); };
         session.onClosed         = () => { OnSessionClosed(session); };
         session.onReceived       = (data) => { OnSessionReceived(session, data); };
         return(session.behavior);
     });
 }
Example #24
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);
                }
            }
        }
Example #25
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;
        }
Example #26
0
        public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
        {
            base.RenderOverlay(cameraInfo);

            if (isHoveringSegment)
            {
                bool  warning = toolError == ToolError.AlreadyBuilt;
                bool  error   = toolError != ToolError.None && toolError != ToolError.AlreadyBuilt;
                Color color   = GetToolColor(warning, error);
                NetTool.RenderOverlay(cameraInfo, ref segment, color, color);

                Color color2 = GetToolColor(true, false);
                m_toolController.RenderColliding(cameraInfo, color, color2, color, color2, (ushort)segmentIndex, 0);
            }
        }
Example #27
0
        //public static ToolBase.ToolErrors CreateNode(NetInfo info, NetTool.ControlPoint startPoint, NetTool.ControlPoint middlePoint, NetTool.ControlPoint endPoint, FastList<NetTool.NodePosition> nodeBuffer,
        //                                             int maxSegments, bool test, bool visualize, bool autoFix, bool needMoney, bool invert, bool switchDir, ushort relocateBuildingID,
        //                                             out ushort node, out ushort segment, out int cost, out int productionRate)

        public override void SimulationStep()
        {
            base.SimulationStep();

            if (isHoveringSegment)
            {
                ushort node;
                ushort outSegment;
                int    cost;
                int    productionRate;
                // Initializes colliding arrays
                ToolErrors errors = NetTool.CreateNode(newPrefab != null ? newPrefab : segment.Info, startPoint, middlePoint, endPoint,
                                                       NetTool.m_nodePositionsSimulation, 1000, true, false, true, false, false, false, (ushort)0, out node, out outSegment, out cost, out productionRate);
            }
        }
Example #28
0
 public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
 {
     if (currentSegment != 0)
     {
         NetTool.RenderOverlay(RenderManager.instance.CurrentCameraInfo, ref NetManager.instance.m_segments.m_buffer[currentSegment], new Color(0.0f, 0.0f, 0.5f, 0.6f), new Color(0f, 0.0f, 0.5f, 0.9f));
         LaneChangerPathManager pathManager = (LaneChangerPathManager)PathManager.instance;
         NetManager             netManager  = NetManager.instance;
         if (pathManager.laneChangerSegments[currentSegment] != null)
         {
             RenderOverlayForSegments(cameraInfo, netManager.m_nodes.m_buffer[netManager.m_segments.m_buffer[currentSegment].m_startNode]);
             RenderOverlayForSegments(cameraInfo, netManager.m_nodes.m_buffer[netManager.m_segments.m_buffer[currentSegment].m_endNode]);
         }
     }
     base.RenderOverlay(cameraInfo);
 }
        public override void Start()
        {
            name = "ThreeRoundButton";
            //text = "T";
            Vector2 resolution = UIView.GetAView().GetScreenResolution();
            var     pos        = new Vector2((145f), (resolution.y * 4f / 5f));
            Rect    rect       = new Rect(pos.x, pos.y, 30, 30);

            SpriteUtilities.ClampRectToScreen(ref rect, resolution);
            DebugLog.LogToFileOnly($"Setting ThreeRoundButton position to [{pos.x},{pos.y}]");
            absolutePosition = rect.position;
            Invalidate();
            //relativePosition = new Vector3((Loader.parentGuiView.fixedWidth / 2f - 450f), (Loader.parentGuiView.fixedHeight / 2f + 370f));
            //relativePosition = new Vector3((Loader.parentGuiView.fixedWidth - 70f), (Loader.parentGuiView.fixedHeight / 2 + 100f));
            atlas           = SpriteUtilities.GetAtlas(Loader.m_atlasName);
            normalBgSprite  = "3Round";
            hoveredBgSprite = "3Round_S";
            size            = new Vector2(30f, 30f);
            zOrder          = 11;
            eventClick     += delegate(UIComponent component, UIMouseEventParameter eventParam)
            {
                if (AdvancedTools.instance.enabled == false)
                {
                    //base.Hide();
                    ToolBase currentTool = ToolsModifierControl.GetCurrentTool <ToolBase>();
                    if (currentTool != null)
                    {
                        NetTool netTool = currentTool as NetTool;
                        if (netTool.m_prefab != null)
                        {
                            AdvancedTools.m_netInfo = netTool.m_prefab;
                        }
                    }
                    ToolsModifierControl.SetTool <DefaultTool>();
                    AdvancedTools.instance.enabled = true;
                    AdvancedTools.m_step           = 0;
                    AdvancedTools.rampMode         = 0;
                    AdvancedTools.height           = 0;
                }
                else
                {
                    ToolsModifierControl.SetTool <DefaultTool>();
                    AdvancedTools.instance.enabled = false;
                    AdvancedTools.m_step           = 0;
                    AdvancedTools.height           = 0;
                }
            };
        }
Example #30
0
        public static void BuildRoad(Vector3 startVector, Vector3 endVector, uint prefabNumber)
        {
            int     maxSegments        = 100;
            bool    test               = false;
            bool    visualize          = false;
            bool    autoFix            = true;
            bool    needMoney          = false;
            bool    invert             = false;
            bool    switchDir          = false;
            ushort  relocateBuildingID = 0;
            ushort  firstNode;
            ushort  lastNode;
            ushort  startNode;
            ushort  endNode;
            ushort  segment;
            int     cost;
            int     productionRate;
            NetTool tool = new NetTool();

            NetInfo netInfo = PrefabCollection <NetInfo> .GetPrefab(prefabNumber);

            float startHeight = NetSegment.SampleTerrainHeight(netInfo, startVector, false);
            float endHeight   = NetSegment.SampleTerrainHeight(netInfo, endVector, false);

            NetTool.ControlPoint startControlPt = new NetTool.ControlPoint();
            NetTool.ControlPoint endControlPt   = new NetTool.ControlPoint();
            startVector.y             = startHeight;
            startControlPt.m_position = startVector;
            endVector.y             = endHeight;
            endControlPt.m_position = endVector;

            NetTool.CreateNode(netInfo, startControlPt, startControlPt, startControlPt, NetTool.m_nodePositionsSimulation,
                               0, false, false, false, false, false, false, (ushort)0, out startNode, out segment, out cost, out productionRate);


            NetTool.CreateNode(netInfo, endControlPt, endControlPt, endControlPt, NetTool.m_nodePositionsSimulation,
                               0, false, false, false, false, false, false, (ushort)0, out endNode, out segment, out cost, out productionRate);

            startControlPt.m_node = startNode;
            endControlPt.m_node   = endNode;
            NetTool.ControlPoint midControlPt = endControlPt;
            midControlPt.m_position  = (startControlPt.m_position + endControlPt.m_position) * 0.5f;
            midControlPt.m_direction = VectorUtils.NormalizeXZ(midControlPt.m_position - startControlPt.m_position);
            endControlPt.m_direction = VectorUtils.NormalizeXZ(endControlPt.m_position - midControlPt.m_position);
            NetTool.CreateNode(netInfo, startControlPt, midControlPt, endControlPt, NetTool.m_nodePositionsSimulation,
                               maxSegments, test, visualize, autoFix, needMoney, invert, switchDir, relocateBuildingID, out firstNode,
                               out lastNode, out segment, out cost, out productionRate);
        }
Example #31
0
        public override void RenderOverlay(RenderManager.CameraInfo cameraInfo, Color toolColor, Color despawnColor)
        {
            if (!isValid)
            {
                return;
            }
            //if (!isVirtual() && MoveItTool.m_isLowSensitivity) return;

            ushort  node    = id.NetNode;
            NetInfo netInfo = nodeBuffer[node].Info;
            float   alpha   = 1f;

            NetTool.CheckOverlayAlpha(netInfo, ref alpha);
            toolColor.a *= alpha;
            RenderManager.instance.OverlayEffect.DrawCircle(cameraInfo, toolColor, OverlayPosition, Mathf.Max(6f, netInfo.m_halfWidth * 2f), -1f, 1280f, false, true);
        }
Example #32
0
        public static void BuildRoad(Vector3 startVector, Vector3 endVector, uint prefabNumber)
        {
            int maxSegments = 100;
            bool test = false;
            bool visualize = false;
            bool autoFix = true;
            bool needMoney = false;
            bool invert = false;
            bool switchDir = false;
            ushort relocateBuildingID = 0;
            ushort firstNode;
            ushort lastNode;
            ushort startNode;
            ushort endNode;
            ushort segment;
            int cost;
            int productionRate;
            NetTool tool = new NetTool();

            NetInfo netInfo = PrefabCollection<NetInfo>.GetPrefab(prefabNumber);
            float startHeight = NetSegment.SampleTerrainHeight(netInfo, startVector, false);
            float endHeight = NetSegment.SampleTerrainHeight(netInfo, endVector, false);
            NetTool.ControlPoint startControlPt = new NetTool.ControlPoint();
            NetTool.ControlPoint endControlPt = new NetTool.ControlPoint();
            startVector.y = startHeight;
            startControlPt.m_position = startVector;
            endVector.y = endHeight;
            endControlPt.m_position = endVector;

            NetTool.CreateNode(netInfo, startControlPt, startControlPt, startControlPt, NetTool.m_nodePositionsSimulation,
                0, false, false, false, false, false, false, (ushort)0, out startNode, out segment, out cost, out productionRate);

            NetTool.CreateNode(netInfo, endControlPt, endControlPt, endControlPt, NetTool.m_nodePositionsSimulation,
                0, false, false, false, false, false, false, (ushort)0, out endNode, out segment, out cost, out productionRate);

            startControlPt.m_node = startNode;
            endControlPt.m_node = endNode;
            NetTool.ControlPoint midControlPt = endControlPt;
            midControlPt.m_position = (startControlPt.m_position + endControlPt.m_position) * 0.5f;
            midControlPt.m_direction = VectorUtils.NormalizeXZ(midControlPt.m_position - startControlPt.m_position);
            endControlPt.m_direction = VectorUtils.NormalizeXZ(endControlPt.m_position - midControlPt.m_position);
            NetTool.CreateNode(netInfo, startControlPt, midControlPt, endControlPt, NetTool.m_nodePositionsSimulation,
                 maxSegments, test, visualize, autoFix, needMoney, invert, switchDir, relocateBuildingID, out firstNode,
                 out lastNode, out segment, out cost, out productionRate);
        }
Example #33
0
        //Test
        public static void CloneNode(NetNode node)
        {
            Log.Message("BuildRoad enter");
            int maxSegments = 100;
            bool test = false;
            bool visualize = false;
            bool autoFix = true;
            bool needMoney = false;
            bool invert = false;
            bool switchDir = false;
            ushort relocateBuildingID = 0;
            ushort firstNode;
            ushort lastNode;
            ushort startNode;
            ushort endNode;
            ushort segment;
            int cost;
            int productionRate;
            Log.Message("BuildRoad fields inied");
            NetTool tool = new NetTool();

            NetInfo netInfo = node.Info;
            float startHeight = NetSegment.SampleTerrainHeight(netInfo, node.m_position, false);
            float endHeight = NetSegment.SampleTerrainHeight(netInfo, node.m_position, false);
            Log.Message("BuildRoad netinfo");
            NetTool.ControlPoint startControlPt = new NetTool.ControlPoint();
            NetTool.ControlPoint endControlPt = new NetTool.ControlPoint();
            Log.Message("BuildRoad netcontrol set");
            node.m_position.y = startHeight;
            startControlPt.m_position = node.m_position;
            node.m_position.y = endHeight;
            endControlPt.m_position = node.m_position;
            Log.Message("BuildRoad creating node 1");

            NetTool.CreateNode(netInfo, startControlPt, startControlPt, startControlPt, NetTool.m_nodePositionsSimulation,
                0, false, false, false, false, false, false, (ushort)0, out startNode, out segment, out cost, out productionRate);

            // CreateNode(out startNode, ref rand, netInfo, new Vector2(startVector.x, startVector.z) , NetSegment.SampleTerrainHeight(netInfo, startVector, false));
            Log.Message("BuildRoad creating node 2");

            NetTool.CreateNode(netInfo, endControlPt, endControlPt, endControlPt, NetTool.m_nodePositionsSimulation,
                0, false, false, false, false, false, false, (ushort)0, out endNode, out segment, out cost, out productionRate);

            // CreateNode(out endNode, ref rand, netInfo, new Vector2(endVector.x, endVector.z), NetSegment.SampleTerrainHeight(netInfo, startVector, false));

            // Array16<NetNode> abc = NetManager.instance.m_nodes; Test

            startControlPt.m_node = startNode;
            endControlPt.m_node = endNode;
            Log.Message("BuildRoad midcontrpt setting");

            NetTool.ControlPoint midControlPt = endControlPt;
            midControlPt.m_position = (startControlPt.m_position + endControlPt.m_position) * 0.5f;
            midControlPt.m_direction = VectorUtils.NormalizeXZ(midControlPt.m_position - startControlPt.m_position);
            endControlPt.m_direction = VectorUtils.NormalizeXZ(endControlPt.m_position - midControlPt.m_position);
            NetTool.CreateNode(netInfo, startControlPt, midControlPt, endControlPt, NetTool.m_nodePositionsSimulation,
                 maxSegments, test, visualize, autoFix, needMoney, invert, switchDir, relocateBuildingID, out firstNode,
                 out lastNode, out segment, out cost, out productionRate);
            Log.Message("BuildRoad road set");
        }
        void GetSegmentControlPoints(int segmentIndex, out NetTool.ControlPoint startPoint, out NetTool.ControlPoint middlePoint, out NetTool.ControlPoint endPoint)
        {
            // ModDebug.LogClassAndMethodName(this.GetType().Name, System.Reflection.MethodBase.GetCurrentMethod().Name);
            NetManager net = Singleton<NetManager>.instance;
            NetInfo prefab = net.m_segments.m_buffer[segmentIndex].Info;

            startPoint.m_node = net.m_segments.m_buffer[segmentIndex].m_startNode;
            startPoint.m_segment = 0;
            startPoint.m_position = net.m_nodes.m_buffer[startPoint.m_node].m_position;
            startPoint.m_direction = net.m_segments.m_buffer[segmentIndex].m_startDirection;
            startPoint.m_elevation = net.m_nodes.m_buffer[startPoint.m_node].m_elevation;
            startPoint.m_outside = (net.m_nodes.m_buffer[startPoint.m_node].m_flags & NetNode.Flags.Outside) != NetNode.Flags.None;

            endPoint.m_node = net.m_segments.m_buffer[segmentIndex].m_endNode;
            endPoint.m_segment = 0;
            endPoint.m_position = net.m_nodes.m_buffer[endPoint.m_node].m_position;
            endPoint.m_direction = -net.m_segments.m_buffer[segmentIndex].m_endDirection;
            endPoint.m_elevation = net.m_nodes.m_buffer[endPoint.m_node].m_elevation;
            endPoint.m_outside = (net.m_nodes.m_buffer[endPoint.m_node].m_flags & NetNode.Flags.Outside) != NetNode.Flags.None;

            middlePoint.m_node = 0;
            middlePoint.m_segment = (ushort)segmentIndex;
            middlePoint.m_position = startPoint.m_position + startPoint.m_direction * (prefab.GetMinNodeDistance() + 1f);
            middlePoint.m_direction = startPoint.m_direction;
            middlePoint.m_elevation = Mathf.Lerp(startPoint.m_elevation, endPoint.m_elevation, 0.5f);
            middlePoint.m_outside = false;
        }
        public override void OnUpdate(float realTimeDelta, float simulationTimeDelta)
        {
            ModDebug.LogClassAndMethodName(this.GetType().Name, System.Reflection.MethodBase.GetCurrentMethod().Name);
            if (loadingLevel) return;

            if (Input.GetKeyDown(KeyCode.Return))
            {
                ModDebug.Log(netTool.m_prefab + " " + netTool.m_mode);
            }

            if (roadsPanel == null)
            {
                roadsPanel = UIView.Find<UIPanel>("RoadsPanel");
            }

            if (roadsPanel == null || !roadsPanel.isVisible)
            {
                if (toolMode != ToolMode.None)
                {
                    ModDebug.Log("Roads panel no longer visible");
                    SetToolMode(ToolMode.None, true);
                }
                return;
            }

            if (netTool == null)
            {
                foreach (var tool in ToolsModifierControl.toolController.Tools)
                {
                    NetTool nt = tool as NetTool;
                    if (nt != null && nt.m_prefab != null)
                    {
                        ModDebug.Log("NetTool found: " + nt.name);
                        netTool = nt;
                        break;
                    }
                }

                if (netTool == null) return;

                raycastService = new ToolBase.RaycastService(netTool.m_prefab.m_class.m_service, netTool.m_prefab.m_class.m_subService, netTool.m_prefab.m_class.m_layer);

                ModDebug.Log("UI visible: " + ui.isVisible);
            }

            if (!ui.isVisible)
            {
                ui.Show();
            }

            if (toolMode != ToolMode.None)
            {
                mouseDown = Input.GetMouseButton(0);
                mouseRayValid = !ToolsModifierControl.toolController.IsInsideUI && Cursor.visible;
                mouseRay = Camera.main.ScreenPointToRay(Input.mousePosition);
                mouseRayLength = Camera.main.farClipPlane;
                currentTime = Time.time;

                if (ToolsModifierControl.toolController.CurrentTool != buildTool)
                {
                    ModDebug.Log("Another tool selected");
                    SetToolMode(ToolMode.None);
                }
            }
            else
            {
                ui.toolMode = ToolMode.None;

                if (ToolsModifierControl.toolController.CurrentTool == buildTool)
                {
                    ToolsModifierControl.toolController.CurrentTool = netTool;
                }
            }

            //ModDebug.LogClassAndMethodName(this.GetType().Name, System.Reflection.MethodBase.GetCurrentMethod().Name);

            if (toolMode == ToolMode.None) return;

            if (!mouseDown)
            {
                prevBuiltSegmentIndex = 0;
            }

            if (buildTool != null)
            {
                buildTool.isHoveringSegment = false;
                buildTool.toolMode = toolMode;
                buildTool.ToolCursor = netTool.m_upgradeCursor;
            }

            if (!mouseRayValid) return;

            ToolBase.RaycastInput raycastInput = new ToolBase.RaycastInput(mouseRay, mouseRayLength);
            raycastInput.m_netService = raycastService;
            raycastInput.m_ignoreTerrain = true;
            raycastInput.m_ignoreNodeFlags = NetNode.Flags.All;
            raycastInput.m_ignoreSegmentFlags = NetSegment.Flags.Untouchable;

            ToolBase.RaycastOutput raycastOutput;

            if (BuildTool21.RayCast(raycastInput, out raycastOutput))
            {

                int segmentIndex = raycastOutput.m_netSegment;
                if (segmentIndex != 0)
                {

                    NetManager net = Singleton<NetManager>.instance;
                    NetInfo newRoadPrefab = null;
                    NetInfo prefab = net.m_segments.m_buffer[segmentIndex].Info;

                    NetTool.ControlPoint startPoint;
                    NetTool.ControlPoint middlePoint;
                    NetTool.ControlPoint endPoint;

                    GetSegmentControlPoints(segmentIndex, out startPoint, out middlePoint, out endPoint);

                    ushort node;
                    ushort outSegment;
                    int cost;
                    int productionRate;
                    // Check for out-of-area error and initialized collide arrays for visualization
                    ToolBase.ToolErrors errors = NetTool.CreateNode(net.m_segments.m_buffer[segmentIndex].Info,
                        startPoint, middlePoint, endPoint, NetTool.m_nodePositionsSimulation, 1000,
                        true, false, true, false, false, false, (ushort)0, out node, out outSegment, out cost, out productionRate);

                    if ((errors & ToolBase.ToolErrors.OutOfArea) != 0)
                    {
                        toolError = ToolError.OutOfArea;
                    }

                    string prefabName = null;
                    if (!roadPrefabNames.TryGetValue(prefab.GetInstanceID(), out prefabName) || prefabName == null)
                    {
                        ModDebug.Error("Prefab name not found");
                        toolError = ToolError.Unknown;
                        return;
                    }

                    NetInfo newPrefab;
                    if (!roadPrefabs.TryGetValue(prefabName, out newPrefab) || newPrefab == null)
                    {
                        ModDebug.Error("Prefab not found: " + prefabName);
                        toolError = ToolError.Unknown;
                        return;
                    }

                    newRoadPrefab = newPrefab;

                      //  ModDebug.Log("Going to rebuild segment");
                        int newIndex = RebuildSegment(segmentIndex, newPrefab, raycastOutput.m_hitPos, hitPosDelta, ref toolError);

                        if (newIndex != 0)
                        {
                        //    ModDebug.Log("newIndex: " + newIndex);
                            if (toolError != ToolError.None) return;

                            prevBuiltSegmentIndex = segmentIndex;
                            prevRebuildTime = currentTime;
                            segmentIndex = newIndex;
                        }

                    if (buildTool != null)
                    {
                        // ModDebug.Log("Using segment from buffer");
                         buildTool.segment = net.m_segments.m_buffer[segmentIndex];
                         buildTool.segmentIndex = segmentIndex;
                         buildTool.isHoveringSegment = toolError != ToolError.Unknown;
                         if (newRoadPrefab != null) buildTool.newPrefab = newRoadPrefab;
                         GetSegmentControlPoints(segmentIndex, out buildTool.startPoint, out buildTool.middlePoint, out buildTool.endPoint);
                    }
                }
            }

            if (buildTool != null)
            {
                buildTool.toolError = toolError;
            }
        }
#pragma warning disable 108,114
        public virtual ToolBase.ToolErrors CheckBuildPosition(bool test, bool visualize, bool overlay, bool autofix,
#pragma warning restore 108,114
            ref NetTool.ControlPoint startPoint, ref NetTool.ControlPoint middlePoint, ref NetTool.ControlPoint endPoint,
            out BuildingInfo ownerBuilding, out Vector3 ownerPosition, out Vector3 ownerDirection,
            out int productionRate)
        {
            ownerBuilding = null;
            ownerPosition = Vector3.zero;
            ownerDirection = Vector3.forward;
            productionRate = 0;
            ToolBase.ToolErrors toolErrors = ToolBase.ToolErrors.None;
            if (test)
            {
                ushort num = middlePoint.m_segment;
                if (startPoint.m_segment == num || endPoint.m_segment == num)
                {
                    num = 0;
                }
                if (num != 0 && Singleton<NetManager>.instance.m_segments.m_buffer[(int) num].Info == this.m_info)
                {
                    if (ZoneBlocksOffset.Mode == ZoneBlocksOffsetMode.Default)
                    {
                        toolErrors |= ToolBase.ToolErrors.CannotUpgrade;
                    }
                    else
                    {
                        // Do nothing
                    }
                }
            }
            if (autofix && this.m_info.m_enableBendingSegments)
            {
                Vector3 vector = middlePoint.m_direction;
                Vector3 vector2 = -endPoint.m_direction;
                Vector3 vector3 = middlePoint.m_position;
                float minNodeDistance = this.m_info.GetMinNodeDistance();
                for (int i = 0; i < 3; i++)
                {
                    bool flag = false;
                    bool flag2 = false;
                    if (startPoint.m_node != 0)
                    {
                        if (ForceValidDirection(this.m_info, ref vector, startPoint.m_node,
                            ref Singleton<NetManager>.instance.m_nodes.m_buffer[(int) startPoint.m_node]))
                        {
                            flag = true;
                        }
                    }
                    else if (startPoint.m_segment != 0 &&
                             ForceValidDirection(this.m_info, startPoint.m_position, ref vector,
                                 startPoint.m_segment,
                                 ref Singleton<NetManager>.instance.m_segments.m_buffer[(int) startPoint.m_segment]))
                    {
                        flag = true;
                    }
                    if (flag)
                    {
                        Line2 line = Line2.XZ(startPoint.m_position, startPoint.m_position + vector);
                        Line2 line2 = Line2.XZ(endPoint.m_position, endPoint.m_position + vector2);
                        bool flag3 = true;
                        float num2;
                        float num3;
                        if (line.Intersect(line2, out num2, out num3) && num2 >= minNodeDistance &&
                            num3 >= minNodeDistance)
                        {
                            vector3 = startPoint.m_position + vector*num2;
                            flag3 = false;
                        }
                        if (flag3)
                        {
                            Vector3 vector4 = endPoint.m_position - startPoint.m_position;
                            Vector3 vector5 = vector;
                            vector4.y = 0f;
                            vector5.y = 0f;
                            float num4 = Vector3.SqrMagnitude(vector4);
                            vector4 = Vector3.Normalize(vector4);
                            float num5 = Mathf.Min(1.17809725f, Mathf.Acos(Vector3.Dot(vector4, vector5)));
                            float d = Mathf.Sqrt(0.5f*num4/Mathf.Max(0.001f, 1f - Mathf.Cos(3.14159274f - 2f*num5)));
                            vector3 = startPoint.m_position + vector5*d;
                            vector2 = vector3 - endPoint.m_position;
                            vector2.y = 0f;
                            vector2.Normalize();
                        }
                    }
                    if (endPoint.m_node != 0)
                    {
                        if (ForceValidDirection(this.m_info, ref vector2, endPoint.m_node,
                            ref Singleton<NetManager>.instance.m_nodes.m_buffer[(int) endPoint.m_node]))
                        {
                            flag2 = true;
                        }
                    }
                    else if (endPoint.m_segment != 0 &&
                             ForceValidDirection(this.m_info, endPoint.m_position, ref vector2, endPoint.m_segment,
                                 ref Singleton<NetManager>.instance.m_segments.m_buffer[(int) endPoint.m_segment]))
                    {
                        flag2 = true;
                    }
                    if (flag2)
                    {
                        Line2 line3 = Line2.XZ(startPoint.m_position, startPoint.m_position + vector);
                        Line2 line4 = Line2.XZ(endPoint.m_position, endPoint.m_position + vector2);
                        bool flag4 = true;
                        float num6;
                        float num7;
                        if (line3.Intersect(line4, out num6, out num7) && num6 >= minNodeDistance &&
                            num7 >= minNodeDistance)
                        {
                            vector3 = endPoint.m_position + vector2*num7;
                            flag4 = false;
                        }
                        if (flag4)
                        {
                            Vector3 vector6 = startPoint.m_position - endPoint.m_position;
                            Vector3 vector7 = vector2;
                            vector6.y = 0f;
                            vector7.y = 0f;
                            float num8 = Vector3.SqrMagnitude(vector6);
                            vector6 = Vector3.Normalize(vector6);
                            float num9 = Mathf.Min(1.17809725f, Mathf.Acos(Vector3.Dot(vector6, vector7)));
                            float d2 = Mathf.Sqrt(0.5f*num8/Mathf.Max(0.001f, 1f - Mathf.Cos(3.14159274f - 2f*num9)));
                            vector3 = endPoint.m_position + vector7*d2;
                            vector = vector3 - startPoint.m_position;
                            vector.y = 0f;
                            vector.Normalize();
                        }
                    }
                    if (!flag && !flag2)
                    {
                        middlePoint.m_direction = vector;
                        endPoint.m_direction = -vector2;
                        middlePoint.m_position = vector3;
                        break;
                    }
                }
            }
            return toolErrors;
        }
        private void GetSegmentControlPoints(int segmentIndex, out NetTool.ControlPoint startPoint, out NetTool.ControlPoint middlePoint, out NetTool.ControlPoint endPoint)
        {
            //WriteLog("Entering GetSegmentControlPoints");
            NetManager net = Singleton<NetManager>.instance;
            startPoint = new NetTool.ControlPoint();
            middlePoint = new NetTool.ControlPoint();
            endPoint = new NetTool.ControlPoint();

            if (segmentIndex >= net.m_segments.m_buffer.Length)
            {
                ARUT.WriteLog("GetSegmentControlPoints:: segmentIndex >= net.m_segments.m_buffer.Length: segmentIndex: " + segmentIndex + " net.m_segments.m_buffer.Length: " + net.m_segments.m_buffer.Length);
                return;
            }

            NetInfo prefab = net.m_segments.m_buffer[segmentIndex].Info;

            startPoint.m_node = net.m_segments.m_buffer[segmentIndex].m_startNode;
            startPoint.m_segment = 0;
            startPoint.m_position = net.m_nodes.m_buffer[startPoint.m_node].m_position;
            startPoint.m_direction = net.m_segments.m_buffer[segmentIndex].m_startDirection;
            startPoint.m_elevation = net.m_nodes.m_buffer[startPoint.m_node].m_elevation;
            startPoint.m_outside = (net.m_nodes.m_buffer[startPoint.m_node].m_flags & NetNode.Flags.Outside) != NetNode.Flags.None;

            endPoint.m_node = net.m_segments.m_buffer[segmentIndex].m_endNode;
            endPoint.m_segment = 0;
            endPoint.m_position = net.m_nodes.m_buffer[endPoint.m_node].m_position;
            endPoint.m_direction = -net.m_segments.m_buffer[segmentIndex].m_endDirection;
            endPoint.m_elevation = net.m_nodes.m_buffer[endPoint.m_node].m_elevation;
            endPoint.m_outside = (net.m_nodes.m_buffer[endPoint.m_node].m_flags & NetNode.Flags.Outside) != NetNode.Flags.None;

            middlePoint.m_node = 0;
            middlePoint.m_segment = (ushort)segmentIndex;
            middlePoint.m_position = startPoint.m_position + startPoint.m_direction * (prefab.GetMinNodeDistance() + 1f);
            middlePoint.m_direction = startPoint.m_direction;
            middlePoint.m_elevation = Mathf.Lerp(startPoint.m_elevation, endPoint.m_elevation, 0.5f);
            middlePoint.m_outside = false;
            //WriteLog("Leaving GetSegmentControlPoints");
        }
 public static string ToString(NetTool.ControlPoint pt)
 {
     return string.Format("  Position: {0}, Direction: {1}\n\t, Node: {2}, Segment: {3}, Elevation: {4}",
         pt.m_position,
         pt.m_direction, pt.m_node, pt.m_segment, pt.m_elevation);
 }
 public static string ToString(NetTool.NodePosition pt)
 {
     return string.Format("  Position: {0}, Direction: {1}", pt.m_position, pt.m_direction);
 }
        public bool CreateNodeImpl(NetInfo info, bool needMoney, bool switchDirection, NetTool.ControlPoint startPoint, NetTool.ControlPoint middlePoint, NetTool.ControlPoint endPoint)
        {
            bool flag = endPoint.m_node != 0 || endPoint.m_segment != 0;
            ushort num;
            ushort num2;
            int num3;
            int num4;
            if (NetTool.CreateNode(info, startPoint, middlePoint, endPoint, NetTool.m_nodePositionsSimulation, 1000, true, false, true, needMoney, false, switchDirection, 0, out num, out num2, out num3, out num4) == ToolBase.ToolErrors.None)
            {
                NetTool.CreateNode(info, startPoint, middlePoint, endPoint, NetTool.m_nodePositionsSimulation, 1000, false, false, true, needMoney, false, switchDirection, 0, out num, out num2, out num3, out num4);
                NetManager instance = Singleton<NetManager>.instance;
                endPoint.m_segment = 0;
                endPoint.m_node = num;
                if (num2 != 0)
                {
                    if (CustomNetTool.FieldUpgrading)
                    {
                        while (!Monitor.TryEnter(CustomNetTool.FieldUpgradedSegments, SimulationManager.SYNCHRONIZE_TIMEOUT))
                        {
                        }
                        try
                        {
                            CustomNetTool.FieldUpgradedSegments.Add(num2);
                        }
                        finally
                        {
                            Monitor.Exit(CustomNetTool.FieldUpgradedSegments);
                        }
                    }
                    if (instance.m_segments.m_buffer[(int)num2].m_startNode == num)
                    {
                        endPoint.m_direction = -instance.m_segments.m_buffer[(int)num2].m_startDirection;
                    }
                    else if (instance.m_segments.m_buffer[(int)num2].m_endNode == num)
                    {
                        endPoint.m_direction = -instance.m_segments.m_buffer[(int)num2].m_endDirection;
                    }
                }
                CustomNetTool.FieldControlPoints[0] = endPoint;
                CustomNetTool.FieldElevation = Mathf.Max(0, Mathf.RoundToInt(endPoint.m_elevation / 12f));
                if (num != 0 && (instance.m_nodes.m_buffer[(int)num].m_flags & NetNode.Flags.Outside) != NetNode.Flags.None)
                {
                    CustomNetTool.FieldControlPointCount = 0;
                }
                else if (this.m_mode == NetTool.Mode.Freeform && CustomNetTool.FieldControlPointCount == 2)
                {
                    middlePoint.m_position = endPoint.m_position * 2f - middlePoint.m_position;
                    middlePoint.m_elevation = endPoint.m_elevation * 2f - middlePoint.m_elevation;
                    middlePoint.m_direction = endPoint.m_direction;
                    middlePoint.m_node = 0;
                    middlePoint.m_segment = 0;
                    CustomNetTool.FieldControlPoints[1] = middlePoint;
                    CustomNetTool.FieldControlPointCount = 2;
                }
                else
                {
                    CustomNetTool.FieldControlPointCount = 1;
                }
                if (info.m_class.m_service > ItemClass.Service.Office)
                {
                    int num5 = info.m_class.m_service - ItemClass.Service.Office - 1;
                    Singleton<GuideManager>.instance.m_serviceNotUsed[num5].Disable();
                    Singleton<GuideManager>.instance.m_serviceNeeded[num5].Deactivate();
                }
                if (info.m_class.m_service == ItemClass.Service.Road)
                {
                    Singleton<CoverageManager>.instance.CoverageUpdated(ItemClass.Service.None, ItemClass.SubService.None, ItemClass.Level.None);
                    Singleton<NetManager>.instance.m_roadsNotUsed.Disable();
                }
                if ((info.m_class.m_service == ItemClass.Service.Road || info.m_class.m_service == ItemClass.Service.PublicTransport || info.m_class.m_service == ItemClass.Service.Beautification) && (info.m_hasForwardVehicleLanes || info.m_hasBackwardVehicleLanes) && (!info.m_hasForwardVehicleLanes || !info.m_hasBackwardVehicleLanes))
                {
                    Singleton<NetManager>.instance.m_onewayRoadPlacement.Disable();
                }
                if (CustomNetTool.FieldUpgrading)
                {
                    Debug.Log(startPoint);
                    //var priorityList = new Dictionary<ushort, int>();

                    //if (CustomRoadAI.GetNodeSimulation(startPoint.m_node) != null)
                    //{
                    //    var nodeDict = CustomRoadAI.GetNodeSimulation(startPoint.m_node);

                    //    if (nodeDict.FlagManualTrafficLights)
                    //    {
                    //        nodeDict.FlagManualTrafficLights = false;
                    //    }
                    //    if (nodeDict.FlagTimedTrafficLights)
                    //    {
                    //        nodeDict.FlagTimedTrafficLights = false;
                    //    }

                    //    CustomRoadAI.RemoveNodeFromSimulation(startPoint.m_node);
                    //}

                    //foreach (var prioritySegment in TrafficPriority.prioritySegments.Values)
                    //{
                    //    if (prioritySegment.node_1 == startPoint.m_node && !priorityList.ContainsKey(startPoint.m_node))
                    //    {
                    //        priorityList.Add(startPoint.m_node, prioritySegment.segment);
                    //    }
                    //    if (prioritySegment.node_2 == startPoint.m_node && !priorityList.ContainsKey(startPoint.m_node))
                    //    {
                    //        priorityList.Add(startPoint.m_node, prioritySegment.segment);
                    //    }
                    //}

                    //if (CustomRoadAI.GetNodeSimulation(endPoint.m_node) != null)
                    //{

                    //    var nodeDict = CustomRoadAI.GetNodeSimulation(endPoint.m_node);

                    //    if (nodeDict.FlagManualTrafficLights)
                    //    {
                    //        nodeDict.FlagManualTrafficLights = false;
                    //    }
                    //    if (nodeDict.FlagTimedTrafficLights)
                    //    {
                    //        nodeDict.FlagTimedTrafficLights = false;
                    //    }

                    //    CustomRoadAI.RemoveNodeFromSimulation(endPoint.m_node);
                    //}

                    //foreach (var prioritySegment in TrafficPriority.prioritySegments.Values)
                    //{
                    //    if (prioritySegment.node_1 == endPoint.m_node && !priorityList.ContainsKey(endPoint.m_node))
                    //    {
                    //        priorityList.Add(endPoint.m_node, prioritySegment.segment);
                    //    }
                    //    if (prioritySegment.node_2 == endPoint.m_node && !priorityList.ContainsKey(endPoint.m_node))
                    //    {
                    //        priorityList.Add(endPoint.m_node, prioritySegment.segment);
                    //    }
                    //}

                    //foreach (var pr in priorityList)
                    //{
                    //    TrafficPriority.removePrioritySegment(pr.Key, pr.Value);
                    //}

                    info.m_netAI.UpgradeSucceeded();
                }
                else if (flag && num != 0)
                {
                    info.m_netAI.ConnectionSucceeded(num, ref Singleton<NetManager>.instance.m_nodes.m_buffer[(int)num]);
                }
                Singleton<GuideManager>.instance.m_notEnoughMoney.Deactivate();
                if (Singleton<GuideManager>.instance.m_properties != null && !CustomNetTool.FieldUpgrading && num2 != 0 && CustomNetTool.FieldBulldozerTool != null && CustomNetTool.FieldBulldozerTool.m_lastNetInfo != null && CustomNetTool.FieldBulldozerTool.m_lastNetInfo.m_netAI.CanUpgradeTo(info))
                {
                    ushort startNode = instance.m_segments.m_buffer[(int)num2].m_startNode;
                    ushort endNode = instance.m_segments.m_buffer[(int)num2].m_endNode;
                    Vector3 position = instance.m_nodes.m_buffer[(int)startNode].m_position;
                    Vector3 position2 = instance.m_nodes.m_buffer[(int)endNode].m_position;
                    Vector3 startDirection = instance.m_segments.m_buffer[(int)num2].m_startDirection;
                    Vector3 endDirection = instance.m_segments.m_buffer[(int)num2].m_endDirection;
                    if (Vector3.SqrMagnitude(CustomNetTool.FieldBulldozerTool.m_lastStartPos - position) < 1f && Vector3.SqrMagnitude(CustomNetTool.FieldBulldozerTool.m_lastEndPos - position2) < 1f && Vector2.Dot(VectorUtils.XZ(CustomNetTool.FieldBulldozerTool.m_lastStartDir), VectorUtils.XZ(startDirection)) > 0.99f && Vector2.Dot(VectorUtils.XZ(CustomNetTool.FieldBulldozerTool.m_lastEndDir), VectorUtils.XZ(endDirection)) > 0.99f)
                    {
                        Singleton<NetManager>.instance.m_manualUpgrade.Activate(Singleton<GuideManager>.instance.m_properties.m_manualUpgrade, info.m_class.m_service);
                    }
                }
                return true;
            }
            return false;
        }
        void _OnUpdate() {
            if (loadingLevel) return;

            /*if (Input.GetKeyDown(KeyCode.Delete)) {
                if (UIInput.hoveredComponent != null) {
                    ModDebug.Log(UIUtils.Instance.GetTransformPath(UIInput.hoveredComponent.transform) + " (" + UIInput.hoveredComponent.GetType() + ")");
                }
            }*/

            if (Input.GetKeyDown(KeyCode.Return)) {
                ModDebug.Log(netTool.m_prefab + " " + netTool.m_mode);
            }

            if (roadsPanel == null) {
                roadsPanel = UIView.Find<UIPanel>("RoadsPanel");
            }

            if (roadsPanel == null || !roadsPanel.isVisible) {
                if (toolMode != ToolMode.None) {
                    ModDebug.Log("Roads panel no longer visible");
                    SetToolMode(ToolMode.None, true);
                }
                return;
            }

            if (netTool == null) {
                foreach (var tool in ToolsModifierControl.toolController.Tools) {
                    NetTool nt = tool as NetTool;
                    if (nt != null && nt.m_prefab != null) {
                        ModDebug.Log("NetTool found: " + nt.name);
                        netTool = nt;
                        break;
                    }
                }

                if (netTool == null) return;

                raycastService = new ToolBase.RaycastService(netTool.m_prefab.m_class.m_service, netTool.m_prefab.m_class.m_subService, netTool.m_prefab.m_class.m_layer);

                ModDebug.Log("UI visible: " + ui.isVisible);
            }

            if (!ui.isVisible) {
                ui.Show();
            }

            /*if (Input.GetKeyDown(KeyCode.Comma)) {
                SetToolMode(ToolMode.Twoway);
            }
            else if (Input.GetKeyDown(KeyCode.Period)) {
                SetToolMode(ToolMode.Oneway);
            }*/

            if (toolMode != ToolMode.None) {
                mouseDown = Input.GetMouseButton(0);
                mouseRayValid = !ToolsModifierControl.toolController.IsInsideUI && Cursor.visible;
                mouseRay = Camera.main.ScreenPointToRay(Input.mousePosition);
                mouseRayLength = Camera.main.farClipPlane;
                currentTime = Time.time;

                if (ToolsModifierControl.toolController.CurrentTool != buildTool) {
                    ModDebug.Log("Another tool selected");
                    SetToolMode(ToolMode.None);
                }
            }
            else {
                ui.toolMode = ToolMode.None;

                if (ToolsModifierControl.toolController.CurrentTool == buildTool) {
                    ToolsModifierControl.toolController.CurrentTool = netTool;
                }
            }
        }
        void GetSegmentControlPoints(int segmentIndex, out NetTool.ControlPoint startPoint, out NetTool.ControlPoint middlePoint, out NetTool.ControlPoint endPoint) {
            NetManager net = Singleton<NetManager>.instance;
            NetInfo prefab = net.m_segments.m_buffer[segmentIndex].Info;

            startPoint.m_node = net.m_segments.m_buffer[segmentIndex].m_startNode;
            startPoint.m_segment = 0;
            startPoint.m_position = net.m_nodes.m_buffer[startPoint.m_node].m_position;
            startPoint.m_direction = net.m_segments.m_buffer[segmentIndex].m_startDirection;
            startPoint.m_elevation = net.m_nodes.m_buffer[startPoint.m_node].m_elevation;
            startPoint.m_outside = (net.m_nodes.m_buffer[startPoint.m_node].m_flags & NetNode.Flags.Outside) != NetNode.Flags.None;

            endPoint.m_node = net.m_segments.m_buffer[segmentIndex].m_endNode;
            endPoint.m_segment = 0;
            endPoint.m_position = net.m_nodes.m_buffer[endPoint.m_node].m_position;
            endPoint.m_direction = -net.m_segments.m_buffer[segmentIndex].m_endDirection;
            endPoint.m_elevation = net.m_nodes.m_buffer[endPoint.m_node].m_elevation;
            endPoint.m_outside = (net.m_nodes.m_buffer[endPoint.m_node].m_flags & NetNode.Flags.Outside) != NetNode.Flags.None;

            middlePoint.m_node = 0;
            middlePoint.m_segment = (ushort)segmentIndex;
            middlePoint.m_position = startPoint.m_position + startPoint.m_direction * (prefab.GetMinNodeDistance() + 1f);
            middlePoint.m_direction = startPoint.m_direction;
            middlePoint.m_elevation = Mathf.Lerp(startPoint.m_elevation, endPoint.m_elevation, 0.5f);
            middlePoint.m_outside = false;
        }
        public static NetTool.ControlPoint SnapDirectionGuideLines(NetTool.ControlPoint newPoint,
            NetTool.ControlPoint oldPoint,
            NetInfo info, ref bool success, ref float minDistanceSq)
        {
            var controlPoint = newPoint;

            lock (GuideLineLock)
            {
                SnappedGuideLine = null;
                GuideLines.Clear();

                Guides.CalculateGuideLines(info, oldPoint, controlPoint, GuideLines);

                if (GuideLines.Count == 0)
                {
                    if (Debug.Enabled)
                    {
                        DebugPrint += " (No GuideLines Found)";
                    }

                    return newPoint;
                }

                var minDist = float.MaxValue;
                var closestLine = GuideLines[0];

                if (GuideLines.Count > 1)
                {
                    for (var i = 0; i < GuideLines.Count; i++)
                    {
                        var gl = GuideLines[i];
                        var dist = Vector3Extensions.DistanceSquared(gl.Origin, newPoint.m_position) +
                                   gl.Distance*gl.Distance;

                        if (dist < minDist)
                        {
                            closestLine = gl;
                            minDist = dist;
                        }
                    }
                }

                if (closestLine.Distance <= Settings.GuideLinesSnapDistance + closestLine.Width)
                {
                    minDistanceSq = closestLine.Distance*closestLine.Distance;

                    if (Debug.Enabled)
                    {
                        DebugPrint += " Guide: " + closestLine.Intersect;
                    }

                    controlPoint.m_position = closestLine.Intersect;
                    controlPoint.m_position.y = newPoint.m_position.y;
                    controlPoint.m_direction = oldPoint.m_position.DirectionTo(newPoint.m_position);
                    success = true;

                    SnappedGuideLine = closestLine;
                }

                return controlPoint;
            }
        }
        private static void SnapOverride(NetTool tool, NetInfo info, ref Vector3 point, ref Vector3 direction,
            Vector3 refPoint,
            float refAngle)
        {
            if (!EnableLengthSnapping)
            {
                return;
            }

            // Original reflected method from dotPeek
            direction = new Vector3(Mathf.Cos(refAngle), 0.0f, Mathf.Sin(refAngle));
            var vector3_1 = direction*8f;
            var vector3_2 = new Vector3(vector3_1.z, 0.0f, -vector3_1.x);
            if (info.m_halfWidth <= 4.0)
            {
                refPoint.x += (float) (vector3_1.x*0.5 + vector3_2.x*0.5);
                refPoint.z += (float) (vector3_1.z*0.5 + vector3_2.z*0.5);
            }
            var vector2 = new Vector2(point.x - refPoint.x, point.z - refPoint.z);
            var num1 =
                Mathf.Round((float) ((vector2.x*(double) vector3_1.x + vector2.y*(double) vector3_1.z)*(1.0/64.0)));
            var num2 =
                Mathf.Round((float) ((vector2.x*(double) vector3_2.x + vector2.y*(double) vector3_2.z)*(1.0/64.0)));
            point.x = (float) (refPoint.x + num1*(double) vector3_1.x + num2*(double) vector3_2.x);
            point.z = (float) (refPoint.z + num1*(double) vector3_1.z + num2*(double) vector3_2.z);
        }
        public static NetTool.ControlPoint SnapDirectionOverride(NetTool.ControlPoint newPoint,
            NetTool.ControlPoint oldPoint,
            NetInfo info, out bool success, out float minDistanceSq)
        {
            if (Debug.Enabled)
            {
                DebugPrint = string.Format("oldPoint: {0}\nnewPoint:{1}", StringUtil.ToString(oldPoint),
                    StringUtil.ToString(newPoint));
            }

            GuideLines.Clear();
            SnappedGuideLine = null;

            minDistanceSq = info.GetMinNodeDistance();
            minDistanceSq = minDistanceSq*minDistanceSq;
            var controlPoint = newPoint;
            success = false;

            if (EnableSnapping)
            {
                // If dragging from a node
                if (oldPoint.m_node != 0 && !newPoint.m_outside)
                {
                    // Node the road build operation is starting from
                    var sourceNodeId = oldPoint.m_node;
                    var sourceNode = NetManager.instance.m_nodes.m_buffer[sourceNodeId];

                    // Direction and length of the line from the node to the users control point
                    var userLineDirection = (newPoint.m_position - sourceNode.m_position).Flatten();
                    var userLineLength = userLineDirection.magnitude;
                    userLineDirection.Normalize();

                    var closestSegmentId = NetNodeUtility.GetClosestSegmentId(sourceNodeId, userLineDirection);

                    if (closestSegmentId > 0)
                    {
                        // Snap to angle increments originating from this closest segment

                        var closestSegmentDirection = NetNodeUtility.GetSegmentExitDirection(sourceNodeId,
                            closestSegmentId);

                        var currentAngle = Vector3Extensions.Angle(closestSegmentDirection, userLineDirection,
                            Vector3.up);

                        var snappedAngle = Mathf.Round(currentAngle/Settings.SnapAngle)*Settings.SnapAngle;
                        var snappedDirection = Quaternion.AngleAxis(snappedAngle, Vector3.up)*closestSegmentDirection;

                        controlPoint.m_direction = snappedDirection.normalized;
                        controlPoint.m_position = sourceNode.m_position + userLineLength*controlPoint.m_direction;
                        controlPoint.m_position.y = newPoint.m_position.y;

                        minDistanceSq = (newPoint.m_position - controlPoint.m_position).sqrMagnitude;
                        success = true;

                        //minDistanceSq = olpo;
                    }
                }
                else if (oldPoint.m_segment != 0 && !newPoint.m_outside)
                {
                    // Else if dragging from a segment

                    // Segment the road build operation is starting from
                    var sourceSegmentId = oldPoint.m_segment;
                    var sourceSegment = NetManager.instance.m_segments.m_buffer[sourceSegmentId];

                    Vector3 segmentDirection;
                    Vector3 segmentPosition;

                    // Direction and length of the line between control points
                    var userLineDirection = (newPoint.m_position - oldPoint.m_position).Flatten();
                    var userLineLength = userLineDirection.magnitude;
                    userLineDirection.Normalize();

                    // Get direction of the segment at the branch position
                    sourceSegment.GetClosestPositionAndDirection(oldPoint.m_position, out segmentPosition,
                        out segmentDirection);

                    var currentAngle = Vector3Extensions.Angle(segmentDirection, userLineDirection, Vector3.up);

                    segmentDirection = segmentDirection.Flatten().normalized;

                    var snappedAngle = Mathf.Round(currentAngle/Settings.SnapAngle)*Settings.SnapAngle;
                    var snappedDirection = Quaternion.AngleAxis(snappedAngle, Vector3.up)*segmentDirection;

                    controlPoint.m_direction = snappedDirection.normalized;
                    controlPoint.m_position = oldPoint.m_position + userLineLength*controlPoint.m_direction;
                    controlPoint.m_position.y = newPoint.m_position.y;

                    minDistanceSq = (newPoint.m_position - controlPoint.m_position).sqrMagnitude;

                    success = true;
                }
                else if (oldPoint.m_direction.sqrMagnitude > 0.5f)
                {
                    if (newPoint.m_node == 0 && !newPoint.m_outside)
                    {
                        // Let's do some snapping between control point directions

                        var currentAngle = Vector3Extensions.Angle(oldPoint.m_direction, newPoint.m_direction,
                            Vector3.up);

                        var snappedAngle = Mathf.Round(currentAngle/Settings.SnapAngle)*Settings.SnapAngle;
                        var snappedDirection = Quaternion.AngleAxis(snappedAngle, Vector3.up)*
                                               oldPoint.m_direction.Flatten();

                        controlPoint.m_direction = snappedDirection.normalized;

                        controlPoint.m_position = oldPoint.m_position +
                                                  Vector3.Distance(oldPoint.m_position.Flatten(),
                                                      newPoint.m_position.Flatten())*
                                                  controlPoint.m_direction;

                        controlPoint.m_position.y = newPoint.m_position.y;

                        success = true;
                    }
                }
                else if (oldPoint.m_segment == 0 && oldPoint.m_node == 0 && newPoint.m_segment == 0 &&
                         oldPoint.m_segment == 0)
                {
                    // Snap to angles based from north

                    var userLineDirection = (newPoint.m_position - oldPoint.m_position).Flatten();
                    var userLineLength = userLineDirection.magnitude;
                    userLineDirection.Normalize();

                    var snapDirection = Vector3.forward;

                    var currentAngle = Vector3Extensions.Angle(snapDirection, userLineDirection, Vector3.up);

                    var snappedAngle = Mathf.Round(currentAngle/Settings.SnapAngle)*Settings.SnapAngle;
                    var snappedDirection = Quaternion.AngleAxis(snappedAngle, Vector3.up)*snapDirection;

                    controlPoint.m_direction = snappedDirection.normalized;
                    controlPoint.m_position = oldPoint.m_position + userLineLength*controlPoint.m_direction;
                    controlPoint.m_position.y = newPoint.m_position.y;

                    minDistanceSq = (newPoint.m_position - controlPoint.m_position).sqrMagnitude;
                    success = true;
                }
            }
            else
            {
                // Run the default snapping

                Revert();

                controlPoint = NetTool.SnapDirection(newPoint, oldPoint, info, out success, out minDistanceSq);

                Deploy();
            }

            if (EnableAdvancedSnapping)
            {
                if (controlPoint.m_segment == 0 && controlPoint.m_node == 0)
                {
                    controlPoint = SnapDirectionGuideLines(controlPoint, oldPoint, info, ref success, ref minDistanceSq);
                }
            }

            return controlPoint;
        }