public void NetworkManagerConnectionSendTest()
        {
            // arrange
            string         sendMessage = "My Message";
            NetworkManager host        = new NetworkManager(5000);

            host.DataFormat = DataFormat.TextMessages;
            string receivedResult = string.Empty;

            host.NetworkMessageEvent += delegate(object sender, NetworkMessageEventArgs args)
            {
                receivedResult = args.Message;
            };

            // act
            bool resultStart = host.Start();
            NetworkManagerState  resultState = host.State;
            NetworkManagerClient client      = new NetworkManagerClient();
            string connectResult             = client.Connect(5000);

            client.Send(Encoding.UTF8.GetBytes(sendMessage));

            // assert
            Assert.IsTrue(resultStart, "Start result must be 'True'");
            Assert.IsTrue(resultState == NetworkManagerState.Running, "The state must be 'Running'");
            Assert.IsTrue(connectResult == "Success", "The connect methode must return 'Success'");
            Assert.IsTrue(receivedResult == sendMessage, "Received message must the same of sended message.");
        }
        public void NetworkManagerProtocolErrorTest()
        {
            // arrange
            // SensorValueRawDataModel
            string         sendMessage = NetworkProtocol.CreateMessage("Das ist kein Json objekt");
            NetworkManager host        = new NetworkManager(5000);

            host.DataFormat = DataFormat.JsonObject;
            string receivedResult = string.Empty;

            host.NetworkMessageEvent += delegate(object sender, NetworkMessageEventArgs args)
            {
                receivedResult = args.Message;
            };
            NetworkManagerClient client = new NetworkManagerClient();

            // act
            bool resultStart = host.Start();
            NetworkManagerState resultState = host.State;
            string connectResult            = client.Connect(5000);

            client.Send(Encoding.UTF8.GetBytes(sendMessage));

            // assert
            Assert.IsTrue(resultStart, "Start result must be 'True'");
            Assert.IsTrue(resultState == NetworkManagerState.Running, "The state must be 'Running'");
            Assert.IsTrue(connectResult == "Success", "The connect methode must return 'Success'");
            Assert.IsTrue(receivedResult == "ERROR", "The result of received message must be 'ERROR'");
        }
Example #3
0
        public void Setup()
        {
            server = new NetworkManagerServer();
            client = new NetworkManagerClient("127.0.0.1");

            compareLogic = new CompareLogic();
        }
Example #4
0
 public static void StaticInit(System.Net.IPEndPoint inServerAddress, string inName)
 {
     if (sInstance == null)
     {
         sInstance = new NetworkManagerClient();
     }
     sInstance.Init(inServerAddress, inName);
 }
    void Start()
    {
        if (client == null)
            client = FindObjectOfType<NetworkManagerClient>();
        cardTypeManager = GetComponent<CardTypeManager>();

        DontDestroyOnLoad(gameObject);
    }
        public async Task NetworkManagerProtocolTest()
        {
            // arrange
            // SensorValueRawDataModel
            string         sendMessage = NetworkProtocol.CreateMessage("{\"UID\":123,\"IsValid\":true,\"TimeStamp\":\"0001-01-01T00:00:00\",\"SensorType\":1,\"RawValue\":1234}");
            NetworkManager host        = new NetworkManager(5000);

            host.DataFormat = DataFormat.JsonObject;
            string resultReceived = string.Empty;

            host.NetworkMessageEvent += delegate(object sender, NetworkMessageEventArgs args)
            {
                resultReceived = args.Message;
            };
            string resultShutdown = string.Empty;

            host.NetworkMessageShutdownEvent += delegate(object sender, NetworkMessageEventArgs args)
            {
                resultShutdown = args.Message;
                throw new Exception(resultShutdown);
            };
            Stopwatch sw = new Stopwatch();

            sw.Start();
            StringBuilder sbStateMessages = new StringBuilder();

            host.NetworkLogEvent += delegate(string stateMessage)
            {
                sbStateMessages.AppendLine($"{stateMessage}, Time: {sw.ElapsedMilliseconds}ms");
            };

            NetworkManagerClient client = new NetworkManagerClient();

            // act

            bool resultStart = host.Start();
            NetworkManagerState resultState = host.State;
            string connectResult            = client.Connect(5000);

            client.Send(Encoding.UTF8.GetBytes(sendMessage));

            await Task.Delay(1000);

            // assert
            sw.Stop();
            Assert.IsTrue(resultStart, "Start result must be 'True': " + sbStateMessages.ToString());
            Assert.IsTrue(resultState == NetworkManagerState.Running, "The state must be 'Running'");
            Assert.IsTrue(connectResult == "Success", "The connect methode must return 'Success'");
            Assert.IsTrue(resultReceived == sendMessage, "Received message must the same of sended message.");
        }
Example #7
0
    // Use this for initialization
    void Start()
    {
        core.GameObjectRegistry.sInstance.RegisterCreationFunction((uint)core.GameObjectClassId.kActor, CActor.StaticCreate);
        core.GameObjectRegistry.sInstance.RegisterCreationFunction((uint)core.GameObjectClassId.kProp, CProp.StaticCreate);
        core.GameObjectRegistry.sInstance.RegisterCreationFunction((uint)core.GameObjectClassId.kProjectile, CProjectile.StaticCreate);
        core.GameObjectRegistry.sInstance.RegisterCreationFunction((uint)core.GameObjectClassId.kBomb, CBomb.StaticCreate);

        core.Engine.sInstance.IsClient = true;
        core.Engine.sInstance.IsServer = false;

        System.Net.IPEndPoint addr = null;
        if (server_addr != null)
        {
            addr = CreateIPEndPoint(server_addr);
        }
        else
        {
            addr = new System.Net.IPEndPoint(System.Net.IPAddress.Parse(server_ip_address), server_port);
        }

        NetworkManagerClient.StaticInit(addr, user_id);
    }
Example #8
0
        static void Main(string[] args)
        {
            Console.Write("s for Server, c for client: ");
            string optionRead = Console.ReadLine();

            switch (optionRead)
            {
            case "s":
            {
                NetworkManager host = new NetworkManager(1200, 10, true);

                host.NetworkLogEvent             += Host_NetworkLogEvent;
                host.NetworkMessageEvent         += Host_NetworkMessageEvent;
                host.NetworkMessageShutdownEvent += Host_NetworkMessageShutdownEvent;

                if (host.Start())
                {
                    Console.WriteLine("host was startet");
                    bool isGoingToStop = false;
                    while (host.State == NetworkManagerState.Running || host.State == NetworkManagerState.Waiting)
                    {
                        if (!isGoingToStop)
                        {
                            Console.WriteLine("s to stop host.");
                            string setToStop = Console.ReadLine();
                            if (setToStop == "s")
                            {
                                host.Stop();
                                isGoingToStop = true;
                            }
                            Task.Delay(2000);
                        }
                        else
                        {
                            Console.Write(".");
                            Task.Delay(1000);
                        }
                    }
                }
                else
                {
                    Console.WriteLine("host has not startet");
                }

                break;
            }

            case "c":
            {
                NetworkManagerClient client = new NetworkManagerClient();

                client.NetworkMessage += Client_NetworkMessage;

                Console.WriteLine("Wait for connect");
                string connectResult = client.Connect(1200);

                Console.Write("Connect Result: ");
                Console.WriteLine(connectResult);

                while (client.IsConnected)
                {
                    Console.Write("Enter a message for send: ");
                    string message = Console.ReadLine();
                    client.Send(Encoding.UTF8.GetBytes(message));

                    Console.Write("s to stop, nothing to enter next message: ");
                    string clientOption = Console.ReadLine();
                    if (clientOption == "s")
                    {
                        break;
                    }

                    Task.Delay(500);
                }

                Console.WriteLine("---------------------------");
                break;
            }

            default:
                Console.WriteLine("Invalid Option. Application stop and end");
                break;
            }

            Console.WriteLine("hit enter for stop application");
            string str = Console.ReadLine();
        }
Example #9
0
        public async Task <bool> JoinBattle(string sServer_addr, int WorldId, string session_id, bool is_debug_user = false, string debug_user_name = "", byte debug_user_team = 0, int debug_player_id = 0)
        {
            Debug.Log($"try connect battle server {sServer_addr}, {WorldId}, {session_id}");
            try
            {
                if (m_bIs_start)
                {
                    Debug.LogWarning($"alread started");
                    return(false);
                }

                System.Net.IPEndPoint addr = core.NetworkHelper.CreateIPEndPoint(sServer_addr);

                if (addr == null)
                {
                    return(false);
                }

                NetworkManagerClient.StaticInit();
                NetworkManagerClient.sInstance.Init(addr, session_id, (byte)WorldId);
                NetworkManagerClient.sInstance.SetDebugUser(is_debug_user, debug_user_name, debug_user_team, debug_player_id);
                OnUpdateIngame = UpdateIngame;

                m_kCts = new CancellationTokenSource();

                while (NetworkManagerClient.sInstance.tryConnectCount <= 5)
                {
                    await Task.Delay(1000, m_kCts.Token);

                    if (NetworkManagerClient.sInstance.State == NetworkManagerClient.NetworkClientState.Welcomed)
                    {
                        m_bIs_start = true;

                        return(true);
                    }
                }

                // udp 통신은 가능하나 타임아웃이라면 tcp를 시도해볼 것 없이 실패
                if (NetworkManagerClient.sInstance.IsUdpOk == false)
                {
                    Debug.Log("change TCP");
                    // tcp 연결 시도
                    NetworkManagerClient.sInstance.IsTcp = true;

                    // 3초간 응답 없으면 연결 실패
                    await Task.Delay(3000, m_kCts.Token);
                }


                // 서버 접속 제한 시간 초과로 인해 접속 실패...
                if (NetworkManagerClient.sInstance.State != NetworkManagerClient.NetworkClientState.Welcomed)
                {
                    NetworkManagerClient.sInstance.IsTrySend = false;
                    Debug.Log("start play failed");
                    return(false);
                }

                m_bIs_start = true;

                return(true);
            }
            catch (TaskCanceledException ex)
            {
                if (NetworkManagerClient.sInstance.State != NetworkManagerClient.NetworkClientState.Welcomed)
                {
                    NetworkManagerClient.sInstance.IsTrySend = false;
                    Debug.Log("start play failed");
                    OnUpdateIngame = null;
                    return(false);
                }

                return(true);
            }
            catch (Exception ex)
            {
                Debug.LogError(ex.ToString());
            }
            OnUpdateIngame = null;
            return(false);
        }
 void Start()
 {
     client = FindObjectOfType<NetworkManagerClient>();
 }