public override void OnEndGame(EndGameMessage msg)
    {
        base.OnEndGame(msg);

        var scene = GameObject.Find("GameScene").GetComponent <GameScene>();

        scene.OpenPopup <PopupOneButton>("PopupOneButton", popup =>
        {
            if (msg.winnerPlayerIndex == playerInfo.netId)
            {
                popup.gameObject.GetComponent <SortingGroup>().sortingLayerName = "HandCards";
                popup.gameObject.GetComponent <SortingGroup>().sortingOrder     = 2500;
                popup.text.text = "You win!";
            }
            else
            {
                popup.gameObject.GetComponent <SortingGroup>().sortingLayerName = "BoardCards";
                popup.gameObject.GetComponent <SortingGroup>().sortingOrder     = 2500;
                popup.text.text = "You lose!";
            }
            popup.buttonText.text = "Exit";
            popup.button.onClickEvent.AddListener(() =>
            {
                if (NetworkingUtils.GetLocalPlayer().isServer)
                {
                    NetworkManager.singleton.StopHost();
                }
                else
                {
                    NetworkManager.singleton.StopClient();
                }
            });
        });
    }
示例#2
0
    /// <summary>
    /// Callback for when the exit game button is pressed.
    /// </summary>
    public void OnExitGameButtonPressed()
    {
        OpenPopup <PopupTwoButtons>("PopupTwoButtons", popup =>
        {
            popup.text.text        = "ゲームを終了しますか?";
            popup.buttonText.text  = "はい";
            popup.button2Text.text = "いいえ";


            popup.button.onClickEvent.AddListener(() =>
            {
                if (NetworkingUtils.GetLocalPlayer().isServer)
                {
                    GameNetworkManager.Instance.StopHost();
                }
                else
                {
                    GameNetworkManager.Instance.StopClient();
                }

                //追記

                SceneManager.LoadScene("Home");
            });


            popup.button2.onClickEvent.AddListener(() => { popup.Close(); });
        });
    }
    void Start()
    {
        Valve.Sockets.Library.Initialize();

        Instance = this;

        NetworkingUtils utils = new NetworkingUtils();

        utils.SetDebugCallback(DebugType.Everything, DebugMessageCallback);
    }
        // Called when player connects to server
        private void ConnectionCallback()
        {
            this.debugWriter.WriteLine("Successfully connected to server");
            isConnected = true;

            debugCallbackDelegate = (type, message) => {
                if (this.debugWriter != null)
                {
                    this.debugWriter.WriteLine("Valve Debug - Type: {0}, Message: {1}", type, message);
                }
            };

            NetworkingUtils utils = new NetworkingUtils();

            utils.SetDebugCallback(DebugType.Important, debugCallbackDelegate);

            Main.utilityMenu.chat = "";
            Main.utilityMenu.previousMessageCount = 0;

            unsafe {
#if DEBUG
                // From data I saw a typical example of udp packets over the internet would be 0.3% loss, 25% reorder
                // For testing I'll use 25% reorder, 30ms delay on reorder, 150ms ping, and 0.2% loss

                // Re-order 25% of packets and add 30ms delay on reordered packets
                //float reorderPercent = 25f;
                //int reorderTime = 30;
                //utils.SetConfiguratioValue(ConfigurationValue.FakePacketReorderSend, ConfigurationScope.Global, IntPtr.Zero, ConfigurationDataType.Float, new IntPtr(&reorderPercent));
                //utils.SetConfiguratioValue(ConfigurationValue.FakePacketReorderTime, ConfigurationScope.Global, IntPtr.Zero, ConfigurationDataType.Int32, new IntPtr(&reorderTime));

                //// Fake 150ms ping
                //int pingTime = 150;
                //utils.SetConfiguratioValue(ConfigurationValue.FakePacketLagSend, ConfigurationScope.Global, IntPtr.Zero, ConfigurationDataType.Int32, new IntPtr(&pingTime));

                //// Simulate 0.2% packet loss
                //float lossPercent = 0.2f;
                //utils.SetConfiguratioValue(ConfigurationValue.FakePacketLossSend, ConfigurationScope.Global, IntPtr.Zero, ConfigurationDataType.Float, new IntPtr(&lossPercent));
#endif

                int sendRateMin    = 0;
                int sendRateMax    = 209715200;
                int sendBufferSize = 10485760;
                utils.SetConfigurationValue(ConfigurationValue.SendRateMin, ConfigurationScope.Global, IntPtr.Zero, ConfigurationDataType.Int32, new IntPtr(&sendRateMin));
                utils.SetConfigurationValue(ConfigurationValue.SendRateMax, ConfigurationScope.Global, IntPtr.Zero, ConfigurationDataType.Int32, new IntPtr(&sendRateMax));
                utils.SetConfigurationValue(ConfigurationValue.SendBufferSize, ConfigurationScope.Global, IntPtr.Zero, ConfigurationDataType.Int32, new IntPtr(&sendBufferSize));
            }
        }
    public void SubmitText()
    {
        var localPlayer = NetworkingUtils.GetHumanLocalPlayer();

        if (localPlayer != null)
        {
            var msg = new SendChatTextMessage();
            msg.senderNetId = localPlayer.netId;
            msg.text        = inputField.text;
            if (msg.text.Length > maxChatMessageLength)
            {
                msg.text = msg.text.Substring(0, maxChatMessageLength);
            }
            NetworkManager.singleton.client.Send(NetworkProtocol.SendChatTextMessage, msg);
            inputField.text = string.Empty;
            inputField.ActivateInputField();
        }
    }
    public void SendText(NetworkInstanceId senderNetId, string text)
    {
        var go = Instantiate(textLinePrefab) as GameObject;

        go.transform.SetParent(scrollViewContent.transform, false);
        go.GetComponent <TextMeshProUGUI>().text = text;
        scrollView.velocity = new Vector2(0.0f, 1000.0f);
        var localPlayer = NetworkingUtils.GetHumanLocalPlayer();

        if (senderNetId == localPlayer.netId)
        {
            go.GetComponent <TextMeshProUGUI>().color = playerTextColor;
        }
        else
        {
            go.GetComponent <TextMeshProUGUI>().color = opponentTextColor;
        }
    }
    void  Start()
    {
        Library.Initialize();

        ushort port = 8080;

        this.client = new NetworkingSockets();
        Address address = new Address();

        address.SetAddress("::1", port);

        this.connection = client.Connect(ref address);

        this.status = (info, context) => {
            switch (info.connectionInfo.state)
            {
            case ConnectionState.None:
                break;

            case ConnectionState.Connected:
                Debug.Log("Client connected to server - ID: " + connection);
                break;

            case ConnectionState.ClosedByPeer:
                client.CloseConnection(connection);
                Debug.Log("Client disconnected from server");
                break;

            case ConnectionState.ProblemDetectedLocally:
                client.CloseConnection(connection);
                Debug.Log("Client unable to connect");
                break;
            }
        };

        DebugCallback debug = (type, message) => {
            Debug.Log("Debug - Type: " + type + ", Message: " + message);
        };

        NetworkingUtils utils = new NetworkingUtils();

        utils.SetDebugCallback(DebugType.Everything, debug);
    }
示例#8
0
    /// <summary>
    /// Callback for when the end turn button is pressed.
    /// </summary>
    public void OnEndTurnButtonPressed()
    {
        var localPlayer = NetworkingUtils.GetLocalPlayer() as DemoHumanPlayer;

        if (localPlayer != null)
        {
            //var maxHandSize = GameManager.Instance.Config.properties.maxHandSize;

            /*if (localPlayer.HandSize > maxHandSize)
             * {
             *  var diff = localPlayer.HandSize - maxHandSize;
             *  if (diff == 1)
             *      WindowUtils.OpenAlertDialog("You need to discard " + diff + " card from your hand.");
             *  else
             *      WindowUtils.OpenAlertDialog("You need to discard " + diff + " cards from your hand.");
             * }*/
            localPlayer.StopTurn();
        }
    }
示例#9
0
    void StartServer()
    {
        Debug.Log("Starting server...");

        utils = new NetworkingUtils();
        utils.SetDebugCallback(DebugType.Message, debug);

        status = OnServerStatusUpdate;
        utils.SetStatusCallback(status);

        server = new NetworkingSockets();

        Address address = new Address();

        address.SetAddress("::0", port);

        listenSocket = server.CreateListenSocket(ref address);

        //connectedPollGroup = server.CreatePollGroup();
    }
示例#10
0
 /// <summary>
 /// Callback for when the exit game button is pressed.
 /// </summary>
 public void OnExitGameButtonPressed()
 {
     OpenPopup <PopupTwoButtons>("PopupTwoButtons", popup =>
     {
         popup.text.text        = "Do you want to leave this game?";
         popup.buttonText.text  = "Yes";
         popup.button2Text.text = "No";
         popup.button.onClickEvent.AddListener(() =>
         {
             if (NetworkingUtils.GetLocalPlayer().isServer)
             {
                 GameNetworkManager.Instance.StopHost();
             }
             else
             {
                 GameNetworkManager.Instance.StopClient();
             }
         });
         popup.button2.onClickEvent.AddListener(() => { popup.Close(); });
     });
 }
示例#11
0
    protected virtual void OnMoveCard(NetworkMessage netMsg)
    {
        var msg = netMsg.ReadMessage <MoveCardMessage>();

        if (msg != null)
        {
            // Only the current player can summon cards.
            if (netMsg.conn.connectionId != server.gameState.currentPlayer.connectionId)
            {
                return;
            }

            var player          = server.gameState.players.Find(x => x.netId == msg.playerNetId);
            var originZone      = player.zones[msg.originZoneId];
            var destinationZone = player.zones[msg.destinationZoneId];

            var card = originZone.cards.Find(x => x.instanceId == msg.cardInstanceId);
            if (card != null)
            {
                var gameConfig  = GameManager.Instance.config;
                var libraryCard = gameConfig.GetCard(card.cardId);
                var cost        = libraryCard.costs.Find(x => x is PayResourceCost);
                if (cost != null)
                {
                    var payResourceCost = cost as PayResourceCost;
                    player.stats[payResourceCost.statId].baseValue -= payResourceCost.value;
                }

                var cardMovedMsg = new CardMovedMessage();
                cardMovedMsg.playerNetId       = msg.playerNetId;
                cardMovedMsg.card              = NetworkingUtils.GetNetCard(card);
                cardMovedMsg.originZoneId      = originZone.zoneId;
                cardMovedMsg.destinationZoneId = destinationZone.zoneId;
                cardMovedMsg.targetInfo        = msg.targetInfo;
                server.SafeSendToClient(server.gameState.currentOpponent, NetworkProtocol.CardMoved, cardMovedMsg);

                server.effectSolver.MoveCard(player.netId, card, originZone.name, destinationZone.name, new List <int>(msg.targetInfo));
            }
        }
    }
示例#12
0
    public void ConnectToServer(string username, OnConnect onConnect, OnDisconnect onDisconnect, OnReject onReject)
    {
        this.onConnect    = onConnect;
        this.onDisconnect = onDisconnect;
        this.onReject     = onReject;

        utils = new NetworkingUtils();
        utils.SetDebugCallback(DebugType.Message, debug);

        Reset();

        client = new NetworkingSockets();

        Address address = new Address();

        address.SetAddress(serverIP, serverport);

        status = OnClientStatusUpdate;
        utils.SetStatusCallback(status);

        connection = client.Connect(ref address);
    }
示例#13
0
    public override void OnEndGame(EndGameMessage msg)
    {
        base.OnEndGame(msg);

        var scene = GameObject.Find("GameScene").GetComponent <GameScene>();

        scene.OpenPopup <PopupOneButton>("PopupOneButton", popup =>
        {
            if (msg.winnerPlayerIndex == playerInfo.netId)
            {
                popup.text.text = "人生の勝利者";
            }
            else
            {
                popup.text.text = "負け犬";
            }
            popup.buttonText.text = "閉じる";
            popup.button.onClickEvent.AddListener(() =>
            {
                if (NetworkingUtils.GetLocalPlayer().isServer)
                {
                    NetworkManager.singleton.StopHost();
                }
                else
                {
                    NetworkManager.singleton.StopClient();
                }

                //追記
                SceneManager.LoadScene("Home");
            }



                                                  );
        });
    }
示例#14
0
 /// <summary>
 /// Called when the game starts.
 /// </summary>
 /// <param name="msg">Start game message.</param>
 public override void OnStartGame(StartGameMessage msg)
 {
     base.OnStartGame(msg);
     humanPlayer = NetworkingUtils.GetHumanLocalPlayer();
 }
        public void Execute(Entity entity, int index, ref NetworkClientConnection clientConnection)
        {
            if (!serverEndPoint.IsValid)
            {
                // TODO: disconnect if the server is not running on the end point
                commandBuffer.DestroyEntity(index, entity);
            }
            else
            {
                DataStreamReader  stream;
                NetworkEvent.Type command;
                while ((command = driver.PopEventForConnection(clientConnection.connection, out stream)) != NetworkEvent.Type.Empty)
                {
                    if (command == NetworkEvent.Type.Connect)
                    {
                        int    lengthOfMsg    = sizeof(int); // in bytes, one int, just for the command type, not including the length integer itself
                        byte[] lengthAsBytes  = BitConverter.GetBytes(lengthOfMsg);
                        byte[] cmdTypeAsBytes = BitConverter.GetBytes(CommandType.SpawnNewPlayer);

                        if (BitConverter.IsLittleEndian)
                        {
                            Array.Reverse(lengthAsBytes);
                            Array.Reverse(cmdTypeAsBytes);
                        }
                        byte[] result = NetworkingUtils.CombineBytes(lengthAsBytes, cmdTypeAsBytes);

                        DataStreamWriter data = new DataStreamWriter(sizeof(byte) * result.Length, Allocator.Temp);
                        data.Write(result);
                        Debug.Log("size of result " + sizeof(byte) * result.Length);
                        Debug.Log("Sending confirmation of connection to server");
                        driver.Send(NetworkPipeline.Null, clientConnection.connection, data);
                    }
                    else if (command == NetworkEvent.Type.Data)
                    {
                        /*
                         * Structure of a message to be sent over the server
                         * [size of message, not including this part, sizeof(int)][command type sizeof(int)][other data]
                         */
                        DataStreamReader.Context readerCtx = default(DataStreamReader.Context);
                        byte[] lengthOfDataAsBytes         = stream.ReadBytesAsArray(ref readerCtx, sizeof(int));
                        if (BitConverter.IsLittleEndian)
                        {
                            Array.Reverse(lengthOfDataAsBytes);
                        }
                        int lengthOfData = BitConverter.ToInt32(lengthOfDataAsBytes, 0);

                        byte[] dataRead = stream.ReadBytesAsArray(ref readerCtx, lengthOfData);


                        byte[] cmdTypeRead = new byte[sizeof(int)];
                        Buffer.BlockCopy(dataRead, 0, cmdTypeRead, 0, sizeof(int));
                        if (BitConverter.IsLittleEndian)
                        {
                            Array.Reverse(cmdTypeRead);
                        }
                        int commandType = BitConverter.ToInt32(cmdTypeRead, 0);
                        if (commandType == CommandType.SpawnNewPlayer)
                        {
                            byte[] idAsBytes = new byte[sizeof(int)];
                            Buffer.BlockCopy(dataRead, sizeof(int), idAsBytes, 0, sizeof(int));
                            if (BitConverter.IsLittleEndian)
                            {
                                Array.Reverse(idAsBytes);
                            }
                            int id = BitConverter.ToInt32(idAsBytes, 0);
                            Debug.Log("player id from server " + id);

                            commandBuffer.SetComponent(index, entity, new NetworkClientConnection
                            {
                                networkId = id
                            });
                        }
                    }
                    else if (command == NetworkEvent.Type.Disconnect)
                    {
                        commandBuffer.DestroyEntity(index, entity);
                    }
                }
            }
        }
        public void Execute(Entity entity, int index, ref NetworkServerConnection serverConnection)
        {
            DataStreamReader stream;

            NetworkEvent.Type command;
            while ((command = driver.PopEventForConnection(serverConnection.connection, out stream)) != NetworkEvent.Type.Empty)
            {
                if (command == NetworkEvent.Type.Data)
                {
                    /*
                     * Structure of a message to be sent over the server
                     * [size of message, not including this part, sizeof(int)][command type sizeof(int)][other data]
                     */
                    Debug.Log("data command on server");
                    DataStreamReader.Context readerCtx = default(DataStreamReader.Context);
                    byte[] lengthOfDataAsBytes         = stream.ReadBytesAsArray(ref readerCtx, sizeof(int));
                    if (BitConverter.IsLittleEndian)
                    {
                        Array.Reverse(lengthOfDataAsBytes);
                    }
                    int lengthOfData = BitConverter.ToInt32(lengthOfDataAsBytes, 0);

                    byte[] dataRead = stream.ReadBytesAsArray(ref readerCtx, lengthOfData);


                    byte[] cmdTypeRead = new byte[sizeof(int)];
                    Buffer.BlockCopy(dataRead, 0, cmdTypeRead, 0, sizeof(int));
                    if (BitConverter.IsLittleEndian)
                    {
                        Array.Reverse(cmdTypeRead);
                    }
                    int commandType = BitConverter.ToInt32(cmdTypeRead, 0);

                    Debug.Log("command type received " + commandType);
                    if (commandType == CommandType.SpawnNewPlayer)
                    {
                        int    networkId      = id[0];
                        byte[] cmdTypeAsBytes = BitConverter.GetBytes(CommandType.SpawnNewPlayer);
                        byte[] idAsBytes      = BitConverter.GetBytes(networkId);
                        if (BitConverter.IsLittleEndian)
                        {
                            Array.Reverse(cmdTypeAsBytes);
                            Array.Reverse(idAsBytes);
                        }

                        byte[] result        = NetworkingUtils.CombineBytes(cmdTypeAsBytes, idAsBytes);
                        int    lengthOfMsg   = result.Length * sizeof(byte); // in bytes, one int, just for the command type and the id
                        byte[] lengthAsBytes = BitConverter.GetBytes(lengthOfMsg);
                        if (BitConverter.IsLittleEndian)
                        {
                            Array.Reverse(lengthAsBytes);
                        }
                        result = NetworkingUtils.CombineBytes(lengthAsBytes, result);
                        DataStreamWriter data = new DataStreamWriter(sizeof(byte) * result.Length, Allocator.Temp);
                        data.Write(result);

                        id[0] += 1;

                        driver.Send(NetworkPipeline.Null, serverConnection.connection, data);

                        commandBuffer.SetComponent(index, entity, new NetworkServerConnection
                        {
                            networkId = networkId
                        });
                    }
                }
                else if (command == NetworkEvent.Type.Disconnect)
                {
                    commandBuffer.DestroyEntity(index, entity);
                }
            }
        }
示例#17
0
        public static void ServerLoop()
        {
            Library.Initialize();

            server = new NetworkingSockets();
            Address address = new Address();

            NetworkingUtils utils = new NetworkingUtils();

            utils.SetDebugCallback(DebugType.Important, (type, message) => {
                Console.WriteLine("Valve Debug - Type: {0}, Message: {1}", type, message);
            });

            unsafe {
                int sendRateMin    = 5 * 1024 * 1024;
                int sendRateMax    = MAX_UPLOAD;
                int sendBufferSize = MAX_BUFFER;
                utils.SetConfigurationValue(ConfigurationValue.SendRateMin, ConfigurationScope.Global, IntPtr.Zero, ConfigurationDataType.Int32, new IntPtr(&sendRateMin));
                utils.SetConfigurationValue(ConfigurationValue.SendRateMax, ConfigurationScope.Global, IntPtr.Zero, ConfigurationDataType.Int32, new IntPtr(&sendRateMax));
                utils.SetConfigurationValue(ConfigurationValue.SendBufferSize, ConfigurationScope.Global, IntPtr.Zero, ConfigurationDataType.Int32, new IntPtr(&sendBufferSize));
            }

            address.SetAddress("::0", port);

            uint listenSocket = server.CreateListenSocket(ref address);
            uint pollGroup    = server.CreatePollGroup();

            Console.WriteLine($"Server {SERVER_NAME} started Listening on port {port} for maximum of {MAX_PLAYERS} players\nEnforcing maps is {ENFORCE_MAPS}");

            StartAnnouncing();

            StatusCallback status = (ref StatusInfo info, IntPtr context) => {
                switch (info.connectionInfo.state)
                {
                case ConnectionState.None:
                    break;

                case ConnectionState.Connecting:
                    server.AcceptConnection(info.connection);
                    server.SetConnectionPollGroup(pollGroup, info.connection);
                    break;

                case ConnectionState.Connected:
                    Console.WriteLine("Client connected - IP: " + info.connectionInfo.address.GetIP());

                    bool openSlot = false;

                    for (byte i = 0; i < MAX_PLAYERS; i++)
                    {
                        if (players[i] == null)
                        {
                            players[i] = new Player(i, info.connection, info.connectionInfo.address);

                            byte[] versionNumber  = ASCIIEncoding.ASCII.GetBytes(VERSION_NUMBER);
                            byte[] versionMessage = new byte[versionNumber.Length + 1];

                            versionMessage[0] = (byte)OpCode.VersionNumber;
                            Array.Copy(versionNumber, 0, versionMessage, 1, versionNumber.Length);
                            server.SendMessageToConnection(players[i].connection, versionMessage, SendFlags.Reliable | SendFlags.NoNagle);

                            if (ENFORCE_MAPS)
                            {
                                server.SendMessageToConnection(players[i].connection, mapListBytes, SendFlags.Reliable);
                                server.SendMessageToConnection(players[i].connection, GetCurrentMapHashMessage(), SendFlags.Reliable);
                            }

                            foreach (Player player in players)
                            {
                                if (player != null && player != players[i])
                                {
                                    server.SendMessageToConnection(players[i].connection, new byte[] { (byte)OpCode.Connect, player.playerID }, SendFlags.Reliable);
                                    server.SendMessageToConnection(player.connection, new byte[] { (byte)OpCode.Connect, i }, SendFlags.Reliable);

                                    if (player.usernameMessage != null)
                                    {
                                        server.SendMessageToConnection(players[i].connection, player.usernameMessage, SendFlags.Reliable);
                                    }
                                    if (player.allGearUploaded)
                                    {
                                        foreach (KeyValuePair <string, byte[]> value in player.gear)
                                        {
                                            server.SendMessageToConnection(players[i].connection, value.Value, SendFlags.Reliable);
                                        }
                                    }
                                }
                            }

                            server.FlushMessagesOnConnection(players[i].connection);

                            openSlot = true;
                            break;
                        }
                    }

                    if (!openSlot)
                    {
                        server.CloseConnection(info.connection);
                    }
                    break;

                case ConnectionState.ClosedByPeer:
                    RemovePlayer(info.connection);
                    break;
                }
            };

#if VALVESOCKETS_SPAN
            MessageCallback messageCallback = (in NetworkingMessage netMessage) => {
                byte[] messageData = new byte[netMessage.length];
                netMessage.CopyTo(messageData);

                Player sendingPlayer = null;
                foreach (Player player in players)
                {
                    if (player != null && player.connection == netMessage.connection)
                    {
                        sendingPlayer = player;
                        break;
                    }
                }

                if (sendingPlayer != null)
                {
                    ProcessMessage(messageData, sendingPlayer.playerID, server);
                }
            };
#else
            const int maxMessages = 256;

            NetworkingMessage[] netMessages = new NetworkingMessage[maxMessages];
#endif
            while (RUNNING)
            {
                server.DispatchCallback(status);

#if VALVESOCKETS_SPAN
                server.ReceiveMessagesOnPollGroup(pollGroup, messageCallback, 256);
#else
                int netMessagesCount = server.ReceiveMessagesOnConnection(listenSocket, netMessages, maxMessages);

                if (netMessagesCount > 0)
                {
                    for (int i = 0; i < netMessagesCount; i++)
                    {
                        ref NetworkingMessage netMessage = ref netMessages[i];

                        byte[] messageData = new byte[netMessage.length];
                        netMessage.CopyTo(messageData);

                        Player sendingPlayer = null;
                        foreach (Player player in players)
                        {
                            if (player != null && player.connection == netMessage.connection)
                            {
                                sendingPlayer = player;
                                break;
                            }
                        }

                        //Console.WriteLine("Recieved packet from connection {0}, sending player null: {1}", netMessage.connection, sendingPlayer == null);

                        if (sendingPlayer != null)
                        {
                            ProcessMessage(messageData, sendingPlayer.playerID, server);
                        }

                        netMessage.Destroy();
                    }
                }
#endif

                mapVotes.Clear();
                total_players = 0;
                foreach (Player player in players)
                {
                    if (player != null)
                    {
                        total_players++;

                        if (player.timeoutWatch.ElapsedMilliseconds > 15000)
                        {
                            Console.WriteLine($"{player.playerID} has been timed out for not responding for 15 seconds");

                            RemovePlayer(player.connection, player.playerID, true);
                        }

                        if (!mapVotes.ContainsKey(player.currentVote))
                        {
                            mapVotes.Add(player.currentVote, 1);
                        }
                        else
                        {
                            mapVotes[player.currentVote]++;
                        }
                    }
                }

                // Handle map voting and map enforcement
                if (ENFORCE_MAPS)
                {
                    if (total_players == 0)
                    {
                        currentMapHash = "1";
                    }

                    bool startNewTimer = false;
                    if (mapVotes.ContainsKey("current"))
                    {
                        if (mapVotes["current"] < (int)Math.Ceiling((float)total_players / 2))
                        {
                            if (!mapVoteTimer.IsRunning)
                            {
                                startNewTimer = true;
                            }
                        }
                    }
                    else if (!mapVoteTimer.IsRunning && total_players > 0)
                    {
                        startNewTimer = true;
                    }

                    if (startNewTimer)
                    {
                        mapVoteTimer.Restart();

                        byte[] mapVoteMsg = new byte[] { (byte)OpCode.MapVote, 0, 0 };

                        foreach (Player player in players)
                        {
                            if (player != null)
                            {
                                server.SendMessageToConnection(player.connection, mapVoteMsg, SendFlags.Reliable);
                            }
                        }
                    }

                    if (mapVoteTimer.IsRunning && mapVoteTimer.ElapsedMilliseconds > 30000 && total_players > 0)
                    {
                        mapVoteTimer.Stop();

                        Tuple <string, int> mostVoted = null;

                        foreach (var item in mapVotes)
                        {
                            if (!item.Key.Equals("current"))
                            {
                                if (mostVoted == null || mostVoted.Item2 < item.Value)
                                {
                                    mostVoted = Tuple.Create <string, int>(item.Key, item.Value);
                                }
                            }
                        }

                        currentMapHash = mostVoted.Item1;

                        byte[] newMapMessage = GetCurrentMapHashMessage();

                        foreach (Player player in players)
                        {
                            if (player != null)
                            {
                                server.SendMessageToConnection(player.connection, newMapMessage, SendFlags.Reliable);

                                player.currentVote = "current";
                            }
                        }
                    }
                    else if (total_players == 0)
                    {
                        mapVoteTimer.Stop();
                    }
                }
            }
示例#18
0
        public void ServerLoop()
        {
            Library.Initialize();

            server = new NetworkingSockets();
            Address address = new Address();

            //Console.WriteLine($"Gameplay port: {Server.port}, File Server Port: {(ushort)(Server.port + 1)}");

            address.SetAddress("::0", (ushort)(Server.port + 1));

            listenSocket = server.CreateListenSocket(ref address);
            pollGroup    = server.CreatePollGroup();

            NetworkingUtils utils = new NetworkingUtils();

            unsafe {
                int sendRateMin = 512000;
                int sendRateMax = Server.FILE_MAX_UPLOAD;
                utils.SetConfigurationValue(ConfigurationValue.SendRateMin, ConfigurationScope.ListenSocket, new IntPtr(listenSocket), ConfigurationDataType.Int32, new IntPtr(&sendRateMin));
                utils.SetConfigurationValue(ConfigurationValue.SendRateMax, ConfigurationScope.ListenSocket, new IntPtr(listenSocket), ConfigurationDataType.Int32, new IntPtr(&sendRateMax));
            }
            StatusCallback status = StatusCallbackFunction;

            MessageCallback messageCallback = (in NetworkingMessage netMessage) => {
                byte[] message = new byte[netMessage.length];
                netMessage.CopyTo(message);

                if ((OpCode)message[0] == OpCode.Connect)
                {
                    uint originalConnection = BitConverter.ToUInt32(message, 1);

                    Player newPlayer = null;
                    foreach (Player player in mainServer.players)
                    {
                        if (player != null && player.connection == originalConnection)
                        {
                            player.fileConnection = netMessage.connection;
                            newPlayer             = player;
                            break;
                        }
                    }

                    if (newPlayer == null)
                    {
                        //Console.WriteLine("Connection on file server doesn't exist on gameplay server");

                        server.CloseConnection(netMessage.connection);
                    }
                    else
                    {
                        foreach (Player player in mainServer.players)
                        {
                            if (player != null && player.playerID != newPlayer.playerID && player.completedGearStream)
                            {
                                player.SendGear(newPlayer.fileConnection, server);
                            }
                        }

                        foreach (Plugin plugin in mainServer.loadedPlugins)
                        {
                            if (plugin.hash != "" && plugin.dependencyFile != "")
                            {
                                byte[] hashBytes   = ASCIIEncoding.ASCII.GetBytes(plugin.hash);
                                byte[] hashMessage = new byte[hashBytes.Length + 2];

                                hashMessage[0] = (byte)OpCode.PluginHash;
                                hashMessage[1] = plugin.pluginID;
                                Array.Copy(hashBytes, 0, hashMessage, 2, hashBytes.Length);

                                server.SendMessageToConnection(newPlayer.fileConnection, hashMessage, SendFlags.Reliable);
                            }
                        }
                    }
                }
                else if ((OpCode)message[0] == OpCode.StillAlive)
                {
                    server.SendMessageToConnection(netMessage.connection, message, SendFlags.Unreliable | SendFlags.NoNagle);
                }
                else
                {
                    foreach (Player player in mainServer.players)
                    {
                        if (player != null && player.fileConnection == netMessage.connection)
                        {
                            mainServer.ProcessMessage(message, player.playerID, mainServer.server);
                        }
                    }
                }
            };

            Stopwatch fileServerLoopTime = new Stopwatch();

            while (mainServer.RUNNING)
            {
                fileServerLoopTime.Restart();
                server.DispatchCallback(status);

                server.ReceiveMessagesOnPollGroup(pollGroup, messageCallback, 256);
                SpinWait.SpinUntil(() => fileServerLoopTime.Elapsed.TotalMilliseconds >= 1, 1);
            }
        }
示例#19
0
        public void ServerLoop()
        {
            Library.Initialize();

            server = new NetworkingSockets();
            Address address = new Address();

            //Console.WriteLine($"Gameplay port: {Server.port}, File Server Port: {(ushort)(Server.port + 1)}");

            address.SetAddress("::0", (ushort)(Server.port + 1));

            listenSocket = server.CreateListenSocket(ref address);
            pollGroup    = server.CreatePollGroup();

            NetworkingUtils utils = new NetworkingUtils();

            unsafe {
                int sendRateMin = 512000;
                int sendRateMax = Server.FILE_MAX_UPLOAD;
                utils.SetConfigurationValue(ConfigurationValue.SendRateMin, ConfigurationScope.ListenSocket, new IntPtr(listenSocket), ConfigurationDataType.Int32, new IntPtr(&sendRateMin));
                utils.SetConfigurationValue(ConfigurationValue.SendRateMax, ConfigurationScope.ListenSocket, new IntPtr(listenSocket), ConfigurationDataType.Int32, new IntPtr(&sendRateMax));
            }
            StatusCallback status = StatusCallbackFunction;

            MessageCallback messageCallback = (in NetworkingMessage netMessage) => {
                byte[] message = new byte[netMessage.length];
                netMessage.CopyTo(message);

                if ((OpCode)message[0] == OpCode.Connect)
                {
                    uint originalConnection = BitConverter.ToUInt32(message, 1);

                    Player newPlayer = null;
                    foreach (Player player in mainServer.players)
                    {
                        if (player != null && player.connection == originalConnection)
                        {
                            player.fileConnection = netMessage.connection;
                            newPlayer             = player;
                            break;
                        }
                    }

                    if (newPlayer == null)
                    {
                        //Console.WriteLine("Connection on file server doesn't exist on gameplay server");

                        server.CloseConnection(netMessage.connection);
                    }
                    else
                    {
                        foreach (Player player in mainServer.players)
                        {
                            if (player != null && player.playerID != newPlayer.playerID && player.completedGearStream)
                            {
                                player.SendGear(newPlayer.fileConnection, server);
                            }
                        }
                    }
                }
                else if ((OpCode)message[0] == OpCode.StillAlive)
                {
                    server.SendMessageToConnection(netMessage.connection, message, SendFlags.Unreliable | SendFlags.NoNagle);
                }
                else
                {
                    foreach (Player player in mainServer.players)
                    {
                        if (player != null && player.fileConnection == netMessage.connection)
                        {
                            mainServer.ProcessMessage(message, player.playerID, mainServer.server);
                        }
                    }
                }
            };

            while (mainServer.RUNNING)
            {
                server.DispatchCallback(status);

                server.ReceiveMessagesOnPollGroup(pollGroup, messageCallback, 256);
            }
        }