public void Connect()
    {
        Debug.Log("CONNECT");
        if (connectUsingMatchmaking)
        {
            ConnectToMatchmaking();
            return;
        }
        ushort port;

        if (!ushort.TryParse(portNumber.text, out port))
        {
            Debug.LogError("The supplied port number is not within the allowed range 0-" + ushort.MaxValue);
            return;
        }

        NetWorker client;

        if (useTCP)
        {
            client = new TCPClient();
            Debug.Log($"Connecting to: {ipAddress.text.Trim()} port {port}");
            ((TCPClient)client).Connect(ipAddress.text.Trim(), (ushort)port);
        }
        else
        {
            client = new UDPClient();
            Debug.Log($"Connecting to: {ipAddress.text.Trim()} port {port}");
            if (natServerHost.Trim().Length == 0)
            {
                ((UDPClient)client).Connect(ipAddress.text.Trim(), (ushort)port);
            }
            else
            {
                ((UDPClient)client).Connect(ipAddress.text.Trim(), (ushort)port, natServerHost, natServerPort);
            }
        }

        Connected(client);
    }
Beispiel #2
0
    public void ConnectToMatchmaking()
    {
        if (_matchmaking)
        {
            return;
        }

        SetToggledButtons(false);
        _matchmaking = true;

        if (mgr == null && networkManager == null)
        {
            Debug.LogWarning("A network manager was not provided, generating a new one instead");
            networkManager = new GameObject("Network Manager");
            mgr            = networkManager.AddComponent <NetworkManager>();
        }
        else if (mgr == null)
        {
            mgr = Instantiate(networkManager).GetComponent <NetworkManager>();
        }

        mgr.MatchmakingServersFromMasterServer(masterServerHost, masterServerPort, myElo, (response) =>
        {
            _matchmaking = false;
            SetToggledButtons(true);
            Debug.LogFormat("Matching Server(s) count[{0}]", response.serverResponse.Count);

            //TODO: YOUR OWN MATCHMAKING EXTRA LOGIC HERE!
            // I just make it randomly pick a server... you can do whatever you please!
            if (response != null && response.serverResponse.Count > 0)
            {
                MasterServerResponse.Server server = response.serverResponse[Random.Range(0, response.serverResponse.Count)];
                //TCPClient client = new TCPClient();
                UDPClient client = new UDPClient();
                client.Connect(server.Address, server.Port);
                Connected(client);
            }
        });
    }
Beispiel #3
0
		/// <summary>
		/// Connect to the NAT hole punch server, this is called from a client machine
		/// </summary>
		/// <param name="host">The host address of the server the client is trying to connect to</param>
		/// <param name="port">The port number of the server the client is trying to connect to</param>
		/// <param name="clientPort">The port number that the client is listening on</param>
		/// <param name="natServer">The NAT server host address to connect to</param>
		/// <param name="natPort">The NAT server port number to connect to</param>
		public void Connect(string host, ushort port, ushort clientPort, string natServer, ushort natPort = DEFAULT_NAT_SERVER_PORT)
		{
			// Don't allow multiple NAT server connection requests at once
			if (Client != null)
				return;

			// Connect to the NAT server
			Client = new UDPClient();
			Client.Connect(natServer, natPort, pendCreates: true);

            Debug.Log("Connecting to nat server");

            NetWorker.BaseNetworkEvent accepted = (NetWorker sender) =>
			{
				// Send the data to the nat server with the host address and port that this client
				// is trying to connect to so that it can punch a hole in the network for this client
				JSONNode sendJson = JSONNode.Parse("{}");
				sendJson.Add("host", new JSONData(host));
				sendJson.Add("port", new JSONData(port));
				sendJson.Add("clientPort", new JSONData(clientPort));

				// Send the message to the NAT server
				Text connect = Text.CreateFromString(Client.Time.Timestep, sendJson.ToString(), false, Receivers.Server, MessageGroupIds.NAT_SERVER_CONNECT, false);
				Client.Send(connect, true);

                Debug.Log("Connected to NAT server and sent info for NAT punching");

                Client.messageConfirmed += (player, packet) => 
                {
                    if (packet.uniqueId == connect.UniqueId)
                    {
                        Client.Disconnect(false);
                        Debug.Log("Disconnecting from NAT server");
                    }
                };
			};

			Client.serverAccepted += accepted;
		}
        public virtual void StartAsClient(Scene pScene, NetworkSceneManagerSetting pSettings)
        {
            _settings = pSettings;
            SceneManager.MoveGameObjectToScene(gameObject, pScene);
            Disconnect();
            InitializeDefaults();
            NetWorker client;

            if (_settings.UseTCP)
            {
                client = new TCPClient();
                ((TCPClient)client).Connect(_settings.ClientAddress.Ip, _settings.ClientAddress.Port);
            }
            else
            {
                client = new UDPClient();
                if (_settings.ClientNATAddress == null || _settings.ClientNATAddress.Ip == null || _settings.ClientNATAddress.Ip.Trim().Length == 0)
                {
                    ((UDPClient)client).Connect(_settings.ClientAddress.Ip, _settings.ClientAddress.Port);
                }
                else
                {
                    ((UDPClient)client).Connect(_settings.ClientAddress.Ip, _settings.ClientAddress.Port, _settings.ClientNATAddress.Ip, _settings.ClientNATAddress.Port);
                }
            }

            if (!client.IsBound)
            {
                RaiseNetworkSceneFailedToBind(this, gameObject.scene);
                return;
            }

            UnregisterEventsClient();
            _networker = client;
            RegisterEventsClient();
            SceneReady(gameObject.scene);
            SceneManager.MoveGameObjectToScene(gameObject, gameObject.scene);
            RaiseNetworkSceneStart(this, gameObject.scene);
        }
    private void Connect()
    {
        portNumber = "15937";
        if (connectUsingMatchmaking)
        {
            ConnectToMatchmaking();
            return;
        }
        ushort port;

        if (!ushort.TryParse(portNumber, out port))
        {
            Debug.LogError("The supplied port number is not within the allowed range 0-" + ushort.MaxValue);
            return;
        }

        NetWorker client;

        if (useTCP)
        {
            client = new TCPClient();
            ((TCPClient)client).Connect(ipAddress, (ushort)port);
        }
        else
        {
            client = new UDPClient();
            if (natServerHost.Trim().Length == 0)
            {
                ((UDPClient)client).Connect(ipAddress, (ushort)port);
            }
            else
            {
                ((UDPClient)client).Connect(ipAddress, (ushort)port, natServerHost, natServerPort);
            }
        }

        Connected(client);
    }
Beispiel #6
0
    public void Connect(string ip)
    {
        NetWorker client;

        if (useTCP)
        {
            client = new TCPClient();
            ((TCPClient)client).Connect(ip, ServerInfo.SERVER_PORT);
        }
        else
        {
            client = new UDPClient();
            if (natServerHost.Trim().Length == 0)
            {
                ((UDPClient)client).Connect(ip, ServerInfo.SERVER_PORT);
            }
            else
            {
                ((UDPClient)client).Connect(ip, ServerInfo.SERVER_PORT, natServerHost, natServerPort);
            }
        }
        Connected(client);
    }
Beispiel #7
0
        private void button_login_Click(object sender, EventArgs e)
        {
            UDPClient udpClient = KevRegister.Get <UDPClient>(ClientItemsPrimaryKey.Socket_UDPClient, () =>
            {
                udpClient = new UDPClient();
                udpClient.ServerIPPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 7788);
                udpClient.Start();
                return(udpClient);
            });

            KevSocketModel ksModel = new KevSocketModel()
            {
                DeviceId    = KevRegister.Get(UDPPrimaryKey.Client_ThisDeviceId, -1),
                MessageId   = IdGenerator.NextId(),
                MessageType = MessageType.Login,
                NetworkType = NetworkType.Request
            };

            if (!udpClient.SendMessage(ksModel))
            {
                MessageBox.Show("连接服务器失败,请稍后尝试");
            }
        }
Beispiel #8
0
    public void Connect()
    {
        if (m_ConnectUsingMatchmaking)
        {
            ConnectToMatchmaking();
            return;
        }
        ushort port;

        if (!ushort.TryParse(m_PortNumber.text, out port))
        {
            Debug.LogError("The supplied port number is not within the allowed range 0-" + ushort.MaxValue);
            return;
        }

        NetWorker client;

        if (m_UseTCP)
        {
            client = new TCPClient();
            ((TCPClient)client).Connect(m_IPAddress.text, (ushort)port);
        }
        else
        {
            client = new UDPClient();
            if (m_NATServerHost.Trim().Length == 0)
            {
                ((UDPClient)client).Connect(m_IPAddress.text, (ushort)port);
            }
            else
            {
                ((UDPClient)client).Connect(m_IPAddress.text, (ushort)port, m_NATServerHost, NATServerPort);
            }
        }

        Connected(client);
    }
Beispiel #9
0
    public void Connect()
    {
        if (connectUsingMatchmaking)
        {
            ConnectToMatchmaking();
            return;
        }
        int port = ushort.Parse(portNumber.text);

        if (port < 0 || port > ushort.MaxValue)
        {
            Debug.LogError("The supplied port number is not within the allowed range 0-" + ushort.MaxValue);
            return;
        }

        NetWorker client;

        if (useTCP)
        {
            client = new TCPClient();
            ((TCPClient)client).Connect(ipAddress.text, (ushort)port);
        }
        else
        {
            client = new UDPClient();
            if (natServerHost.Trim().Length == 0)
            {
                ((UDPClient)client).Connect(ipAddress.text, (ushort)port);
            }
            else
            {
                ((UDPClient)client).Connect(ipAddress.text, (ushort)port, natServerHost, natServerPort);
            }
        }

        Connected(client);
    }
Beispiel #10
0
        public void Connect2ClientsTest()
        {
            var client1 = new UDPClient();
            var client2 = new UDPClient();

            Console.WriteLine("Using port number: " + currentPort);

            client1.Connect("127.0.0.1", currentPort);
            Assert.IsTrue(client1.IsBound);
            WaitFor(() => { return(client1.IsConnected); });

            client2.Connect("127.0.0.1", currentPort);
            Assert.IsTrue(client2.IsBound);
            WaitFor(() => { return(client2.IsConnected); });

            client1.Disconnect(false);
            client2.Disconnect(false);

            WaitFor(() => { return(!client1.IsConnected); });
            Assert.IsFalse(client1.IsBound);

            WaitFor(() => { return(!client2.IsConnected); });
            Assert.IsFalse(client2.IsBound);
        }
Beispiel #11
0
 public void Terminate()
 {
     if (!m_terminate)
     {
         m_terminate = true;
         if (null != m_loginClient)
         {
             m_loginClient.Close();
             m_loginClient = null;
         }
         if (null != m_gateClient)
         {
             m_gateClient.Close();
             m_gateClient = null;
         }
         if (null != m_crossClient)
         {
             m_crossClient.Close();
             m_crossClient = null;
         }
         m_thread.Join();
         m_thread = null;
     }
 }
Beispiel #12
0
        static void Main(string[] args)
        {
            var s = new Base.MessageData();

            s.desc = "12313";
            Console.WriteLine(s.ToString());


            var udpType = 0;
            var get     = Console.ReadKey();

            Console.WriteLine();
            if (get.Key == ConsoleKey.Q)
            {
                UDPClient.Init();
                UDPClient.GetRoomList();
                udpType = 0;
            }
            else if (get.Key == ConsoleKey.W)
            {
                UDPServer.Init();
                udpType = 1;
            }
            while (true)
            {
                string str = Console.ReadLine();
                if (udpType == 0)
                {
                    UDPClient.SendMsg(str);
                }
                else
                {
                    UDPServer.SendMsg(str);
                }
            }
        }
Beispiel #13
0
    public void StartAsClient(ECSNetworkManagerSetting pSettings)
    {
        _settings = pSettings;
        Disconnect();
        InitializeDefaults();
        NetWorker client;

        if (_settings.UseTCP)
        {
            client = new TCPClient();
            ((TCPClient)client).Connect(_settings.ClientAddress.Host, _settings.ClientAddress.Port);
        }
        else
        {
            client = new UDPClient();
            if (_settings.ClientNATAddress == null || _settings.ClientNATAddress.Host == null || _settings.ClientNATAddress.Host.Trim().Length == 0)
            {
                ((UDPClient)client).Connect(_settings.ClientAddress.Host, _settings.ClientAddress.Port);
            }
            else
            {
                ((UDPClient)client).Connect(_settings.ClientAddress.Host, _settings.ClientAddress.Port, _settings.ClientNATAddress.Host, _settings.ClientNATAddress.Port);
            }
        }

        if (!client.IsBound)
        {
            RaiseFailedToBind(this);
            return;
        }

        UnregisterEventsClient();
        _networker = client;
        RegisterEventsClient();
        RaiseStart(this);
    }
Beispiel #14
0
 private bool UDPClient_dataSend_EventDataSend(byte[] data)
 {
     return(UDPClient.SendData(data));
 }
Beispiel #15
0
 public void Connect()
 {
     client = new UDPClient();
     client.Connect(ip, port);
     Connected(client);
 }
Beispiel #16
0
 /// <summary>
 /// Start the VOIP sending client
 /// </summary>
 /// <param name="hostAddress">The address for the VOIP to connect to</param>
 /// <param name="port">Port of the VOIP</param>
 public void StartClient(string hostAddress = "127.0.0.1", ushort port = 15959)
 {
     Socket = new UDPClient();
     Setup(hostAddress, port);
 }
Beispiel #17
0
        void generateMapAndPlayer(Hashtable mapInfo, PlayerSpawnDir spawnDir)
        {
            // get map information from the hash table
            string mapString = (string)mapInfo["map"];

            rows             = (int)mapInfo["row"];
            columns          = (int)mapInfo["column"];
            currentStageHash = (string)mapInfo["hash"];

            int HPStatus, APStatus;

            if (player != null)
            {
                HPStatus = player.m_HP;
                APStatus = player.m_AP;
            }
            else
            {
                HPStatus = (int)mapInfo["hp"];
                APStatus = (int)mapInfo["ap"];
            }

            string[] arrayMap = mapString.Split(',');

            // get item information from the hash table
            int[] itemCounts = new int[(int)(itemID.END + 1)];
            int[] itemValues = new int[(int)(itemID.END + 1)];
            for (int i = 0; i <= (int)(itemID.END); i++)
            {
                if (mapInfo.ContainsKey(i.ToString()))
                {
                    Hashtable itemTable = (Hashtable)mapInfo[i.ToString()];
                    itemCounts[i] = (int)itemTable["items"];
                    itemValues[i] = (int)itemTable["value"];
                }
                else
                {
                    itemCounts[i] = 0;
                }
            }

            // find the gates
            int northGate = -111, southGate = -111, eastGate = -111, westGate = -111;

            for (int i = 0; i < columns; i++)
            {
                if (arrayMap[i] == "N")
                {
                    northGate = i;
                    break;
                }
            }
            for (int i = 0; i < columns; i++)
            {
                if (arrayMap[columns * (rows - 1) + i] == "S")
                {
                    southGate = i;
                    break;
                }
            }
            for (int i = 0; i < rows; i++)
            {
                if (arrayMap[columns - 1 + columns * (rows - 1 - i)] == "E")
                {
                    eastGate = i;
                    break;
                }
            }
            for (int i = 0; i < rows; i++)
            {
                if (arrayMap[columns * (rows - 1 - i)] == "W")
                {
                    westGate = i;
                    break;
                }
            }

            // floor generation
            for (int x = -2; x < columns + 2; x++)
            {
                for (int y = -3; y < rows + 3; y++)
                {
                    int tileIndex = 0;
                    if (x <= 0 || y <= 0 || x >= columns - 1 || y >= rows - 1)
                    {
                        tileIndex = 9;
                    }
                    else if (x == 1)
                    {
                        if (y == 1)
                        {
                            tileIndex = 6;
                        }
                        else if (y == rows - 2)
                        {
                            tileIndex = 0;
                        }
                        else
                        {
                            tileIndex = 3;
                        }
                    }
                    else if (x == columns - 2)
                    {
                        if (y == 1)
                        {
                            tileIndex = 8;
                        }
                        else if (y == rows - 2)
                        {
                            tileIndex = 2;
                        }
                        else
                        {
                            tileIndex = 5;
                        }
                    }
                    else
                    {
                        if (y == 1)
                        {
                            tileIndex = 7;
                        }
                        else if (y == rows - 2)
                        {
                            tileIndex = 1;
                        }
                        else
                        {
                            tileIndex = 4;
                        }
                    }

                    instantiateAndAdd(floorTiles[tileIndex], x, y, holders[(int)(holderID.FLOOR)]);
                }
            }

            // cliff generation
            List <Vector3> rockTilePositions = new List <Vector3>();
            List <Vector3> rockPositions = new List <Vector3>();

            // cliff, SW side of the map
            instantiateAndAdd(cliffTiles[3], -1, -1, holders[(int)(holderID.CLIFF)]);
            for (int y = -3; y <= -2; y++)
            {
                for (int x = -2; x <= 0; x++)
                {
                    rockTilePositions.Add(new Vector3(x, y, 0));
                }
            }
            for (int y = -1; y <= 0; y++)
            {
                rockTilePositions.Add(new Vector3(-2, y, 0));
            }

            // cliff, SE side of the map
            instantiateAndAdd(cliffTiles[15], columns, -1, holders[(int)(holderID.CLIFF)]);
            for (int y = -3; y <= -2; y++)
            {
                for (int x = columns - 1; x <= columns + 1; x++)
                {
                    rockTilePositions.Add(new Vector3(x, y, 0));
                }
            }
            for (int y = -1; y <= 0; y++)
            {
                rockTilePositions.Add(new Vector3((columns + 1), y, 0));
            }

            // cliff, NW side of the map
            instantiateAndAdd(cliffTiles[7], -1, rows + 1, holders[(int)(holderID.CLIFF)]);
            for (int x = -2; x <= 0; x++)
            {
                rockTilePositions.Add(new Vector3(x, rows + 2, 0));
            }
            for (int y = rows - 1; y <= rows + 1; y++)
            {
                rockTilePositions.Add(new Vector3(-2, y, 0));
            }

            // cliff, NE side of the map
            instantiateAndAdd(cliffTiles[11], columns, rows + 1, holders[(int)(holderID.CLIFF)]);
            for (int x = columns - 1; x <= columns + 1; x++)
            {
                rockTilePositions.Add(new Vector3(x, rows + 2, 0));
            }
            for (int y = rows - 1; y <= rows + 1; y++)
            {
                rockTilePositions.Add(new Vector3((columns + 1), y, 0));
            }

            // cliff, south side
            for (int x = 1; x < columns - 1; x++)
            {
                if (x == southGate - 2)
                {
                    instantiateAndAdd(cliffTiles[2], x, -1, holders[(int)(holderID.CLIFF)]);
                    for (int y = -3; y <= -2; y++)
                    {
                        instantiateAndAdd(cliffTiles[4 + Random.Range(0, 2)], x, y, holders[(int)(holderID.CLIFF)]);
                    }
                }
                else if (x == southGate + 2)
                {
                    instantiateAndAdd(cliffTiles[14], x, -1, holders[(int)(holderID.CLIFF)]);
                    for (int y = -3; y <= -2; y++)
                    {
                        instantiateAndAdd(cliffTiles[12 + Random.Range(0, 2)], x, y, holders[(int)(holderID.CLIFF)]);
                    }
                }
                else if (Mathf.Abs(x - southGate) >= 3)
                {
                    instantiateAndAdd(cliffTiles[Random.Range(0, 2)], x, -1, holders[(int)(holderID.CLIFF)]);
                    for (int y = -3; y <= -2; y++)
                    {
                        rockTilePositions.Add(new Vector3(x, y, 0));
                    }
                }
            }

            // cliff, north side
            for (int x = 1; x < columns - 1; x++)
            {
                if (x == northGate - 2)
                {
                    instantiateAndAdd(cliffTiles[6], x, rows + 1, holders[(int)(holderID.CLIFF)]);
                    instantiateAndAdd(cliffTiles[4 + Random.Range(0, 2)], x, rows + 2, holders[(int)(holderID.CLIFF)]);
                }
                else if (x == northGate + 2)
                {
                    instantiateAndAdd(cliffTiles[10], x, rows + 1, holders[(int)(holderID.CLIFF)]);
                    instantiateAndAdd(cliffTiles[12 + Random.Range(0, 2)], x, rows + 2, holders[(int)(holderID.CLIFF)]);
                }
                else if (Mathf.Abs(x - northGate) >= 3)
                {
                    instantiateAndAdd(cliffTiles[8 + Random.Range(0, 2)], x, rows + 1, holders[(int)(holderID.CLIFF)]);
                    rockTilePositions.Add(new Vector3(x, rows + 2, 0));
                }
            }

            // cliff, west side
            for (int y = 1; y <= rows - 1; y++)
            {
                if (y == westGate + 3)
                {
                    instantiateAndAdd(cliffTiles[6], -1, y, holders[(int)(holderID.CLIFF)]);
                    instantiateAndAdd(cliffTiles[8 + Random.Range(0, 2)], -2, y, holders[(int)(holderID.CLIFF)]);
                }
                else if (y == westGate - 1)
                {
                    instantiateAndAdd(cliffTiles[2], -1, y, holders[(int)(holderID.CLIFF)]);
                    instantiateAndAdd(cliffTiles[Random.Range(0, 2)], -2, y, holders[(int)(holderID.CLIFF)]);
                }
                else if (Mathf.Abs(y - (westGate + 1)) >= 3)
                {
                    instantiateAndAdd(cliffTiles[4 + Random.Range(0, 2)], -1, y, holders[(int)(holderID.CLIFF)]);
                    rockTilePositions.Add(new Vector3(-2, y, 0));
                }
            }

            // cliff, east side
            for (int y = 1; y <= rows - 1; y++)
            {
                if (y == eastGate + 3)
                {
                    instantiateAndAdd(cliffTiles[10], columns, y, holders[(int)(holderID.CLIFF)]);
                    instantiateAndAdd(cliffTiles[8 + Random.Range(0, 2)], columns + 1, y, holders[(int)(holderID.CLIFF)]);
                }
                else if (y == eastGate - 1)
                {
                    instantiateAndAdd(cliffTiles[14], columns, y, holders[(int)(holderID.CLIFF)]);
                    instantiateAndAdd(cliffTiles[Random.Range(0, 2)], columns + 1, y, holders[(int)(holderID.CLIFF)]);
                }
                else if (Mathf.Abs(y - (eastGate + 1)) >= 3)
                {
                    instantiateAndAdd(cliffTiles[12 + Random.Range(0, 2)], columns, y, holders[(int)(holderID.CLIFF)]);
                    rockTilePositions.Add(new Vector3(columns + 1, y, 0));
                }
            }

            // random generation of rock tiles
            foreach (Vector3 pos in rockTilePositions)
            {
                instantiateAndAdd(
                    rockFloorTiles[Random.Range(0, rockFloorTiles.Length)],
                    Mathf.FloorToInt(pos.x),
                    Mathf.FloorToInt(pos.y),
                    holders[(int)(holderID.CLIFF)]
                    );
            }

            // box colliders for the borders
            for (int x = 0; x < columns; x++)
            {
                for (int y = 0; y < rows; y++)
                {
                    if (arrayMap[x + (rows - 1 - y) * columns] == "#")
                    {
                        Transform border = new GameObject("collider").transform;
                        border.SetParent(holders[(int)(holderID.BOARD_COLLIDER)]);
                        border.Translate(x, y, 0);
                        border.gameObject.layer = LayerMask.NameToLayer("Object");

                        border.gameObject.AddComponent <BoxCollider2D>();
                    }
                }
            }
            if (northGate >= 1 && northGate < columns - 1)
            {
                for (int x = northGate - 1; x <= northGate + 1; x += 2)
                {
                    Transform border = new GameObject("collider").transform;
                    border.SetParent(holders[(int)(holderID.BOARD_COLLIDER)]);
                    border.Translate(x, rows + 1f, 0);
                    border.localScale      += new Vector3(0, 2.0f, 0);
                    border.gameObject.layer = LayerMask.NameToLayer("Object");

                    border.gameObject.AddComponent <BoxCollider2D>();
                }
            }
            if (southGate >= 1 && southGate < columns - 1)
            {
                for (int x = southGate - 1; x <= southGate + 1; x += 2)
                {
                    Transform border = new GameObject("collider").transform;
                    border.SetParent(holders[(int)(holderID.BOARD_COLLIDER)]);
                    border.Translate(x, -2f, 0);
                    border.localScale      += new Vector3(0, 2.0f, 0);
                    border.gameObject.layer = LayerMask.NameToLayer("Object");

                    border.gameObject.AddComponent <BoxCollider2D>();
                }
            }
            if (eastGate >= 1 && eastGate < rows - 1)
            {
                for (int y = eastGate - 1; y <= eastGate + 1; y += 2)
                {
                    Transform border = new GameObject("collider").transform;
                    border.SetParent(holders[(int)(holderID.BOARD_COLLIDER)]);
                    border.Translate(columns + 0.5f, y, 0);
                    border.localScale      += new Vector3(1.0f, 0, 0);
                    border.gameObject.layer = LayerMask.NameToLayer("Object");

                    border.gameObject.AddComponent <BoxCollider2D>();
                }
            }
            if (westGate >= 1 && westGate < rows - 1)
            {
                for (int y = westGate - 1; y <= westGate + 1; y += 2)
                {
                    Transform border = new GameObject("collider").transform;
                    border.SetParent(holders[(int)(holderID.BOARD_COLLIDER)]);
                    border.Translate(-1.5f, y, 0);
                    border.localScale      += new Vector3(1.0f, 0, 0);
                    border.gameObject.layer = LayerMask.NameToLayer("Object");

                    border.gameObject.AddComponent <BoxCollider2D>();
                }
            }

            // block generation
            for (int y = rows - 1; y >= 0; y--)
            {
                for (int x = 0; x < columns; x++)
                {
                    if (arrayMap[x + (rows - 1 - y) * columns] == "b")
                    {
                        instantiateAndAdd(blockTiles, x, y, 0, holders[(int)(holderID.BLOCK)]);
                    }
                }
            }

            // item generation
            for (int y = rows - 1; y >= 0; y--)
            {
                for (int x = 0; x < columns; x++)
                {
                    for (int itemIdx = (int)(itemID.START); itemIdx <= (int)(itemID.END); itemIdx++)
                    {
                        if (arrayMap[x + (rows - 1 - y) * columns] == itemIdx.ToString() &&
                            itemCounts[itemIdx] > 0)
                        {
                            switch ((itemID)itemIdx)
                            {
                            case itemID.POTION1:
                                Potion potion1 = ObjectFactory.createPotion(x, y, itemValues[itemIdx], (int)(itemID.POTION1));
                                potion1.transform.SetParent(holders[(int)(holderID.POTION)]);
                                break;

                            case itemID.POTION2:
                                Potion potion2 = ObjectFactory.createPotion(x, y, itemValues[itemIdx], (int)(itemID.POTION2));
                                potion2.transform.SetParent(holders[(int)(holderID.POTION)]);
                                break;

                            case itemID.WEAPON:
                                Weapon weapon = ObjectFactory.createWeapon(x, y, itemValues[itemIdx], (int)(itemID.WEAPON));
                                weapon.transform.SetParent(holders[(int)(holderID.WEAPON)]);
                                break;
                            }
                        }
                    }
                }
            }

            // player generation
            int playerX = 0;
            int playerY = 0;

            switch (spawnDir)
            {
            case PlayerSpawnDir.SPAWN_EAST:
                playerX = columns - 2;
                playerY = eastGate;
                break;

            case PlayerSpawnDir.SPAWN_NORTH:
                playerX = northGate;
                playerY = rows - 2;
                break;

            case PlayerSpawnDir.SPAWN_WEST:
                playerX = 1;
                playerY = westGate;
                break;

            case PlayerSpawnDir.SPAWN_SOUTH:
                playerX = southGate;
                playerY = 1;
                break;

            case PlayerSpawnDir.SPAWN_NONE:
                bool playerPlaced  = false;
                bool hasEmptySpace = false;
                for (int y = rows - 1; y >= 0; y--)
                {
                    for (int x = 0; x < columns; x++)
                    {
                        if (arrayMap[x + (rows - 1 - y) * columns] == "u")
                        {
                            if (!playerPlaced)
                            {
                                playerPlaced = true;
                                playerX      = x;
                                playerY      = y;
                            }
                        }
                        else if (arrayMap[x + (rows - 1 - y) * columns] == "f")
                        {
                            hasEmptySpace = true;
                        }
                    }
                }
                while (!playerPlaced && hasEmptySpace)
                {
                    playerX = Random.Range(1, columns - 1);
                    playerY = Random.Range(1, columns - 1);
                    if (arrayMap[playerX + (rows - 1 - playerY) * columns] == "f")
                    {
                        playerPlaced = true;
                    }
                }
                break;
            }
            if (player == null)
            {
                player = ObjectFactory.createPlayer(playerX, playerY, HPStatus, APStatus);
                player.transform.SetParent(holders[(int)(holderID.PLAYER)]);
            }
            else
            {
                player.Initialize(playerX, playerY, HPStatus, APStatus);
            }

            // get peer's ip addresses who are in this area!
            peerIPList.Clear();
            ArrayList listIPs = (ArrayList)mapInfo["ips"];

            foreach (string ip in listIPs)
            {
                if (ip != getMyIP())
                {
                    peerIPList.Add(ip);
                }
            }

            // peer player initialization
            peerUDPClients.Clear();
            foreach (string ip in peerIPList)
            {
                GameObject peer       = new GameObject("peer UDP client");
                UDPClient  peerClient = peer.AddComponent <UDPClient>();
                peerClient.InitiateSocket(ip, 12346);
                peerUDPClients.Add(peer);

                Hashtable data = new Hashtable();
                data.Add("action", "myinfo");
                data.Add("hash", currentStageHash);
                data.Add("username", SystemInfo.deviceUniqueIdentifier);
                data.Add("ip", getMyIP());
                data.Add("xpos", playerX);
                data.Add("ypos", playerY);
                peerClient.sendJSONObject(data);
            }
        }
Beispiel #18
0
 void Start()
 {
     client = new UDPClient(port, OnReceive, OnError);
 }
Beispiel #19
0
        public AuthServer()
        {
            _packetLogger = new PacketLogger();
            _logger       = new Logger()
            {
                WriteToConsole = true
            };
            _logger.Load(Path.Combine("logs", string.Format("auth_{0}.log", DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss"))));
            AppDomain.CurrentDomain.UnhandledException += (s, e) =>
            {
                Error(s, new ExceptionEventArgs((Exception)e.ExceptionObject));
                Environment.Exit(0);
            };

            _packetLogger.Load("auth_packets.log");
            _logger.Info("Loaded Packet Logger");

            Stopwatch sw = Stopwatch.StartNew();

            AuthConfig.Load();
            sw.Stop();
            _logger.Info("Loaded Auth Configuration in {0} ms", sw.Elapsed.TotalMilliseconds);

            _logger.Info("Starting up server connections...");

            _server = new TcpServer(IPAddress.Parse(AuthConfig.Instance.IP), AuthConfig.Instance.Port);
            _server.PacketReceived += HandlePacket;
            _server.Error          += Error;

            //
            // Initalize a list of ports
            //

            ushort[] ports = { 38915, 38917 };

            for (uint i = 0; ports.Length > i; i++)
            {
                // Handle NAT tests before starting...
                switch (i)
                {
                case 0:
                    _natServer = new UDPClient(ports[0]);
                    _natServer.PacketReceived += HandleNATTest;
                    _natServer.Error          += Error;
                    _logger.InfoAuth("NAT Test successful at Port {0}", ports[0]);
                    break;

                case 1:
                    _natServer2 = new UDPClient(ports[1]);
                    _natServer2.PacketReceived += HandleNATTest2;
                    _natServer2.Error          += Error;
                    _logger.InfoAuth("NAT Test successful at Port {0}", ports[1]);
                    break;

                default:
                    break;
                }
            }

            // Bind to pipe/tcp/http settings in configuration
            var isMono = Type.GetType("Mono.Runtime") != null;

            switch (AuthConfig.Instance.Remote.Binding)
            {
            case "pipe":
                if (isMono)
                {
                    _logger.Error("pipe is not supported in mono, use http!");
                    Environment.Exit(1);
                    return;
                }
                _remoteServer = new RemoteServer(this, ERemoteBinding.Pipe, string.Format("localhost/AuthServer/{0}/", SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
                break;

            case "tcp":
                if (isMono)
                {
                    _logger.Error("tcp is not supported in mono, use http!");
                    Environment.Exit(1);
                    return;
                }
                _remoteServer = new RemoteServer(this, ERemoteBinding.Pipe, string.Format("{0}:{1}/AuthServer/{2}/", AuthConfig.Instance.Remote.Server, AuthConfig.Instance.Remote.Port, SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
                break;

            case "http":
                _remoteServer = new RemoteServer(this, ERemoteBinding.Http, string.Format("{0}:{1}/AuthServer/{2}/", AuthConfig.Instance.Remote.Server, AuthConfig.Instance.Remote.Port, SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
                break;

            default:
                _logger.Error("Invalid remote binding '{0}'", AuthConfig.Instance.Remote.Binding);
                Environment.Exit(1);
                return;
            }
            _remoteServer.AddServiceEndpoint(typeof(IAuthRemote), "IAuthRemote");
        }
Beispiel #20
0
        public AuthServer()
        {
            _packetLogger = new PacketLogger();
            _logger = new Logger() { WriteToConsole = true };
            _logger.Load(Path.Combine("logs", string.Format("auth_{0}.log", DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss"))));
            AppDomain.CurrentDomain.UnhandledException += (s, e) =>
            {
                Error(s, new ExceptionEventArgs((Exception)e.ExceptionObject));
                Environment.Exit(0);
            };

            _packetLogger.Load("auth_packets.log");
            _logger.Info("Loaded Packet Logger");

            Stopwatch sw = Stopwatch.StartNew();
            AuthConfig.Load();
            sw.Stop();
            _logger.Info("Loaded Auth Configuration in {0} ms", sw.Elapsed.TotalMilliseconds);

            _logger.Info("Starting up server connections...");

            _server = new TcpServer(IPAddress.Parse(AuthConfig.Instance.IP), AuthConfig.Instance.Port);
            _server.PacketReceived += HandlePacket;
            _server.Error += Error;

            //
            // Initalize a list of ports
            //

            ushort[] ports = { 38915, 38917 };

            for (uint i = 0; ports.Length > i; i++ )
            {
                // Handle NAT tests before starting...
                switch (i)
                {
                    case 0:
                        _natServer = new UDPClient(ports[0]);
                        _natServer.PacketReceived += HandleNATTest;
                        _natServer.Error += Error;
                        _logger.InfoAuth("NAT Test successful at Port {0}", ports[0]);
                        break;
                    case 1:
                        _natServer2 = new UDPClient(ports[1]);
                        _natServer2.PacketReceived += HandleNATTest2;
                        _natServer2.Error += Error;
                        _logger.InfoAuth("NAT Test successful at Port {0}", ports[1]);
                        break;
                    default:
                        break;
                }
            }

            // Bind to pipe/tcp/http settings in configuration
            var isMono = Type.GetType("Mono.Runtime") != null;
            switch (AuthConfig.Instance.Remote.Binding)
            {
                case "pipe":
                    if (isMono)
                    {
                        _logger.Error("pipe is not supported in mono, use http!");
                        Environment.Exit(1);
                        return;
                    }
                    _remoteServer = new RemoteServer(this, ERemoteBinding.Pipe, string.Format("localhost/AuthServer/{0}/", SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
                    break;

                case "tcp":
                    if (isMono)
                    {
                        _logger.Error("tcp is not supported in mono, use http!");
                        Environment.Exit(1);
                        return;
                    }
                    _remoteServer = new RemoteServer(this, ERemoteBinding.Pipe, string.Format("{0}:{1}/AuthServer/{2}/", AuthConfig.Instance.Remote.Server, AuthConfig.Instance.Remote.Port, SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
                    break;

                case "http":
                    _remoteServer = new RemoteServer(this, ERemoteBinding.Http, string.Format("{0}:{1}/AuthServer/{2}/", AuthConfig.Instance.Remote.Server, AuthConfig.Instance.Remote.Port, SHA256.ComputeHash(AuthConfig.Instance.Remote.Password)));
                    break;

                default:
                    _logger.Error("Invalid remote binding '{0}'", AuthConfig.Instance.Remote.Binding);
                    Environment.Exit(1);
                    return;
            }
            _remoteServer.AddServiceEndpoint(typeof(IAuthRemote), "IAuthRemote");
        }
Beispiel #21
0
 public void SendToClient(UDPClient client, byte[] data)
 {
     Debug.Log("Sent: " + Encoding.UTF8.GetString(data));
     serverClient.Send(data, data.GetLength(0), client.endPoint);
 }
Beispiel #22
0
 //don't use on main thread
 public void ReadInput()
 {
     SendToClient(Connectedclient, UDPClient.StringToBytes(Console.ReadLine()));
     serverClient.BeginReceive(new AsyncCallback(receive), null);
 }
Beispiel #23
0
 public UdpClientHelper()
 {
     udpClient = new UDPClient();
 }
Beispiel #24
0
    private static void Main()
    {
        UDPClient sendObj = new UDPClient();

        sendObj.init();
    }
Beispiel #25
0
 public override void init(MsgConsumer consumer)
 {
     for (int i = 0; i < serverCount;i++ )
     {
         udpServers[i] = new UDPServer(local[i], this);
     }
     for (int i=0; i< clientCount;i++)
     {
         udpClients[i] = new UDPClient(remote[i]);
     }
     if (clientCount > 1)
     {
         deliveryThreads = new SplitThread[clientCount];
         for (int i=0; i < clientCount; i++)
         {
             deliveryThreads[i] = new SplitThread(i, udpClients[i], msgID);
         }
     }
     base.init(consumer);
 }
Beispiel #26
0
 public static void RegisterEvent(OutgoingGameEvent gameEvent)
 {
     byte[] message = gameEvent.GetSerialized();
     UDPClient.GetInstance().SendMessage(message, message.Length);
 }
 void initUDP()
 {
     udpClient = new UDPClient(true);
     udpClient.Initiate(ConnectionData.selectedIP, ConnectionData.portOutUDP);
 }
Beispiel #28
0
 private void Start()
 {
     localIP = UDPClient.GetLocalIPAddress();
 }
Beispiel #29
0
 // initialization method
 public void Initialize(int posX, int posY, int HPStatus, int APStatus)
 {
     m_posX = posX;
     m_posY = posY;
     m_HP = HPStatus;
     m_AP = APStatus;
     boxCollider = GetComponent<BoxCollider2D>();
     if (boardManager == null)
     {
         boardManager = GameObject.Find("BoardManager").GetComponent<BoardManager>();
     }
     if (client == null)
     {
         client = boardManager.GetComponent<UDPClient>();
     }
     transform.position = new Vector3(posX, posY, 0);
 }
Beispiel #30
0
        //private ObservableCollection<RssItem> listViewCollection;
        public MainWindow()
        {
            using (MemoryStream memory = new MemoryStream())
            {
                Properties.Resources.icon.Save(memory);
                memory.Position = 0;
                BitmapImage bitmapImage = new BitmapImage();
                bitmapImage.BeginInit();
                bitmapImage.StreamSource = memory;
                bitmapImage.CacheOption  = BitmapCacheOption.OnLoad;
                bitmapImage.EndInit();
                Icon = bitmapImage;
            }

            string fullPath = AppDomain.CurrentDomain.BaseDirectory;

            InitializeComponent();

            CBServis = new CB.DailyInfoSoapClient();
            try
            {
                System.Data.DataSet Curs = CBServis.GetCursOnDate(System.DateTime.Now);
                TextUS.Content  = Curs.Tables[0].Rows[9].ItemArray[2].ToString();
                TextEVR.Content = Curs.Tables[0].Rows[10].ItemArray[2].ToString();
            }
            catch (Exception)
            {
                TextUS.Content  = "Не доступно";
                TextEVR.Content = TextUS.Content;
            }



            ipDispatcher = "";

            rssChanels = this.LoadChannelsFromFile("RssChannels.bin");
            Logger.Write("загружены из файла rss каналы");
            this.UpdateChannels();
            //listViewCollection = new ObservableCollection<RssItem>(rssChanels[0].Articles);
            lvArticles.ItemsSource = rssChanels[0].Articles;


            // аля неудачная попытка сделать красивый интерфейс
            // create buttons for articles categories
            //for (int i = 0; i < rssChanels.Count; i++)
            //{
            //    var btnCateg = new Button() { Name = "btnCat" + i, Content = rssChanels[i].Category };
            //    btnCateg.Click += RssCateg_Click;
            //    btnCateg.Uid = i.ToString();
            //    btnCateg.Style = this.FindResource("channelBtn") as Style;
            //    CategoryWrap.Children.Add(btnCateg);
            //}

            foreach (RssChannel channel in rssChanels)
            {
                cmbCategoryList.Items.Add(channel.Category);
            }
            cmbCategoryList.SelectedIndex = 0;
            broadCast            = new UDPClient();
            broadCast.onMessage += this.UDP_Receive;
            broadCast.Start();
            Logger.Write("запущен поток на прослушку UDP");
        }
Beispiel #31
0
 public SplitThread(int index, UDPClient udpClient, int baseMsgID)
 {
     this.msgID = baseMsgID;
     this.index = index;
     this.udpClient = udpClient;
     innerThread = new Thread(new ThreadStart(distribute));
     innerThread.Start();
     Thread.Sleep(5);
 }
Beispiel #32
0
 public void PostAwake()
 {
     UDPClient.cs = this;
 }
Beispiel #33
0
        public void Refresh()
        {
            // Clear out all the currently listed servers
            for (int i = content.childCount - 1; i >= 0; --i)
            {
                Destroy(content.GetChild(i).gameObject);
            }

            // The Master Server communicates over TCP
            client = new TCPMasterClient();

            // Once this client has been accepted by the master server it should sent it's get request
            client.serverAccepted += (sender) =>
            {
                try
                {
                    // Create the get request with the desired filters
                    JSONNode  sendData = JSONNode.Parse("{}");
                    JSONClass getData  = new JSONClass();
                    getData.Add("id", gameId);
                    getData.Add("type", gameType);
                    getData.Add("mode", gameMode);

                    sendData.Add("get", getData);

                    // Send the request to the server
                    client.Send(Frame.Text.CreateFromString(client.Time.Timestep, sendData.ToString(), true, Receivers.Server, MessageGroupIds.MASTER_SERVER_GET, true));
                }
                catch
                {
                    // If anything fails, then this client needs to be disconnected
                    client.Disconnect(true);
                    client = null;
                }
            };

            // An event that is raised when the server responds with hosts
            client.textMessageReceived += (player, frame, sender) =>
            {
                try
                {
                    // Get the list of hosts to iterate through from the frame payload
                    JSONNode data = JSONNode.Parse(frame.ToString());
                    if (data["hosts"] != null)
                    {
                        MasterServerResponse response = new MasterServerResponse(data["hosts"].AsArray);

                        if (response != null && response.serverResponse.Count > 0)
                        {
                            // Go through all of the available hosts and add them to the server browser
                            foreach (MasterServerResponse.Server server in response.serverResponse)
                            {
                                string protocol = server.Protocol;
                                string address  = server.Address;
                                ushort port     = server.Port;
                                string name     = server.Name;

                                // name, address, port, comment, type, mode, players, maxPlayers, protocol
                                CreateServerOption(name, () =>
                                {
                                    // Determine which protocol should be used when this client connects
                                    NetWorker socket = null;

                                    if (protocol == "udp")
                                    {
                                        socket = new UDPClient();
                                        ((UDPClient)socket).Connect(address, port, natServerHost, natServerPort);
                                    }
                                    else if (protocol == "tcp")
                                    {
                                        socket = new TCPClient();
                                        ((TCPClient)socket).Connect(address, port);
                                    }
#if !UNITY_IOS && !UNITY_ANDROID
                                    else if (protocol == "web")
                                    {
                                        socket = new TCPClientWebsockets();
                                        ((TCPClientWebsockets)socket).Connect(address, port);
                                    }
#endif
                                    if (socket == null)
                                    {
                                        throw new Exception("No socket of type " + protocol + " could be established");
                                    }

                                    Connected(socket);
                                });
                            }
                        }
                    }
                }
                finally
                {
                    if (client != null)
                    {
                        // If we succeed or fail the client needs to disconnect from the Master Server
                        client.Disconnect(true);
                        client = null;
                    }
                }
            };

            client.Connect(masterServerHost, (ushort)masterServerPort);
        }
Beispiel #34
0
    void Start()
    {
        Instance = this;
        try
        {
            GC = GameObject.FindGameObjectWithTag("GameController").GetComponent <GameController>();
        } catch (Exception)
        {
            throw;
        }
        GC.CurrentGpsPosition = Config.DebugGpsPosition;

        // tryToLogin("Lukas", "1234567");

        //TODO: MAKE SURE THAT THE GAME DOESN'T CRASH IF SERVER CONNECTION CAN'T BE ESTABLISHED!


        // Helper.ServerRequest login = new Helper.ServerRequest() {request = Helper.ServerRequestType.LogIn};
        // StartCoroutine(SendRequest<Helper.LoginCredentials, Helper.Player>(login, new Helper.LoginCredentials(){name = "Lukas", password = "******"},true));

        // Helper.ServerRequest newplayer = new Helper.ServerRequest() {request = Helper.ServerRequestType.NewPlayer};
        // StartCoroutine(SendRequest<Helper.LoginCredentials, Helper.Player>(newplayer, new Helper.LoginCredentials(){name = "Lars", password = "******"},true));

        // Helper.ServerRequest updateplayer = new Helper.ServerRequest() {request = Helper.ServerRequestType.UpdatePlayer};
        // StartCoroutine(SendRequest<Helper.Player, string>(updateplayer, new Helper.Player("Lars","1234567",2) {xp = 100},true));

        // Helper.ServerRequest sendPos = new Helper.ServerRequest() {request = Helper.ServerRequestType.SendPosition};
        // Debug.Log(JsonUtility.ToJson(new Helper.PlayerLocation(){name = "Lars", id = 2, timestamp = DateTime.Now.ToString(), position = new Vector2(48.05f, 8.2f)}));
        // StartCoroutine(SendRequest<Helper.PlayerLocation, string>(sendPos, new Helper.PlayerLocation(){name = "Lars", id = 2, timestamp = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss"), position = new Vector2(48.05f, 8.2f)},true));
        // StartCoroutine(SendRequest<Helper.PlayerLocation, string>(sendPos, new Helper.PlayerLocation(){name = "Lukas", id = 0, timestamp = DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss"), position = new Vector2(48.0501f, 8.202f)},true));

        // Helper.ServerRequest getPos = new Helper.ServerRequest() {request = Helper.ServerRequestType.RecievePositions};
        // StartCoroutine(SendRequest<Vector2,List<Helper.PlayerLocation>>(getPos, new Vector2(48.05f, 8.2f), true));


        /*
         * Helper.PointOfAction poa = new Helper.PointOfAction() {name = "Furtwangen", attack = Helper.Attacks.None, position = new Vector2(GC.CurrentGpsPosition.Latitude, GC.CurrentGpsPosition.Longitude), power = 0};
         *
         * // print (Cube.position);
         * byte[] data = new byte[1024];
         * IPEndPoint ipep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9050);
         *
         * Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
         *
         * // string welcome = "Hello, what's up?";
         * Debug.Log(poa);
         * Helper.ServerRequest sr = new Helper.ServerRequest() {request = Helper.ServerRequestType.SendPosition};
         * data = Encoding.ASCII.GetBytes(JsonUtility.ToJson(sr) +";"+JsonUtility.ToJson(poa));
         * Debug.Log(data);
         * server.SendTo(data, data.Length, SocketFlags.None, ipep);
         *
         * IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
         * EndPoint tmpRemote = (EndPoint)sender;
         *
         * data = new byte[1024];
         * int recv = server.ReceiveFrom(data, ref tmpRemote);
         *
         * Debug.Log (String.Format("Message received from {0}:", tmpRemote.ToString()));
         * Debug.Log (Encoding.ASCII.GetString(data, 0, recv));
         * Debug.Log (JsonUtility.FromJson<Helper.ServerRequest>(Encoding.ASCII.GetString(data, 0, recv)));
         *
         * // server.SendTo(Encoding.ASCII.GetBytes(Cube.position.ToString()), tmpRemote);
         *
         *
         * Console.WriteLine("Stopping client");
         * server.Close();
         */
    }