Exemplo n.º 1
0
    private IEnumerator InterfaceRoutine(FlagInterface flag, TimeOutFlag timeOutFlag)
    {
        while (tcpClient != null)
        {
            yield return(new WaitForEndOfFrame());

            while (flag.gameInterfaceFlags.Count != 0)
            {
                var processed = flag.gameInterfaceFlags.Dequeue();
                switch (processed.interfaceMessage)
                {
                case InterfaceMessage.resetTimeout:
                    timeOutFlag.resetTimer = true;
                    break;

                case InterfaceMessage.raiseError:
                    ErrorScene.LoadError(processed.msg);
                    break;

                case InterfaceMessage.gameStart:
                    SceneManager.LoadScene("Game");
                    latestOpponentName = processed.msg;
                    break;

                case InterfaceMessage.enableQueueMenu:
                    MenuUX.GetSingleton().RevealQueue();
                    break;

                case InterfaceMessage.updateEnqueuedNumber:
                    MenuUX.GetSingleton().UpdateEnqueuedNumber((int)processed.val);
                    break;

                case InterfaceMessage.updateGameServerPos:
                    GameManager.GetSingleton().UpdateServerPos(processed.val);
                    break;

                case InterfaceMessage.updateGameOpponentPos:
                    GameManager.GetSingleton().UpdateOpponentPos(processed.val);
                    break;

                case InterfaceMessage.updateLocalPlayerPos:
                    GameManager.GetSingleton().UpdateLocalPlayerPos(processed.val);
                    break;
                }
            }
        }
    }
Exemplo n.º 2
0
    private static void ClientSideThreadPerpetualListen(FlagInterface flagInterface)
    {
        try
        {
            while (tcpClient != null)
            {
                string response = ReadFromServer();

                lock (_clientBoiBusy)
                {
                    response = response.Substring(0, response.Length - 1); //get rid of the \n
                    var    fields        = response.Split(' ');
                    float  valuePassed   = 0;
                    string messagePassed = "";
                    if (fields.Length == 3)
                    {
                        if (fields[2][0] == '~')
                        {
                            //this be string msg.
                            fields[2]     = fields[2].Remove(0, 1);
                            messagePassed = fields[2];
                        }
                        else
                        {
                            //this be float msg.
                            if (!float.TryParse(fields[2], out valuePassed))
                            {
                                Debug.LogError("Invalid response from server: " + response);
                                continue;
                            }
                        }
                    }
                    EnqueueNoTimeoutFlag(flagInterface);
                    string eval = fields[0] + " " + fields[1];
                    switch (eval)
                    {
                    case "MD INVALID":
                        EnqueueErrorFlag(flagInterface, "Server responded with " + response);
                        break;

                    case "MD NO-TIMEOUT":
                        WriteToServer("MD NO-TIMEOUT\n");
                        break;

                    case "MD QUEUE":
                        if (MenuUX.GetSingleton() != null)
                        {
                            EnqueueUpdateEnqueuedNumber(flagInterface, (int)valuePassed);
                        }
                        break;

                    case "MD GAME FDISCONNECT":
                        EnqueueErrorFlag(flagInterface, "Your opponent has lost connection to the server ;_;");
                        break;

                    case "MD GAME-INIT":
                        Debug.Log("Game shall be initalized with player: " + messagePassed);
                        EnqueueGameStartFlag(flagInterface, messagePassed);
                        break;

                    case "MD GAME-FAIL":
                        EnqueueErrorFlag(flagInterface, "You and your opponent were out of tolerable sync and both lost ;_;");
                        break;

                    case "MD GAME-INDIC":
                        EnqueueUpdateServerPos(flagInterface, valuePassed);
                        break;

                    case "MD GAME-OPP":
                        EnqueueUpdateOpponentPos(flagInterface, valuePassed);
                        break;

                    case "MD GAME-LOC":
                        EnqueueUpdateLocalPlayerPos(flagInterface, valuePassed);
                        break;

                    default:
                        EnqueueErrorFlag(flagInterface, "Unexpected response from server: " + response);
                        break;
                    }
                }
            }
        }
        catch (Exception e)
        {
            EnqueueErrorFlag(flagInterface, e.ToString());
        }
    }