Example #1
0
        // called when answer recieved
        public void answer()
        {
            string message = Helpers.getMessage(1, _clientStream);

            if (message == Protocol.CREATE_ROOM_SUCCESS)
            {
                // if room created
                _waitWin.setStream(_clientStream);
                _waitWin.initAdmin(int.Parse(_playerNo), int.Parse(_questionNo), int.Parse(_time));
                _waitWin.initNames(usernameLabel.Text, _roomName);
                _waitWin.initName(_username);
                _waitWin.Visible = true;
            }
            else
            {
                // if there was an error
                errorLabel.Visible = true;
                errorLabel.Text    = FAIL;
            }
        }
Example #2
0
        // function for thread which will listen to server
        private void ServerThreadListener()
        {
            bool   run     = true;
            string message = "";

            // establish communication
            try
            {
                IPEndPoint serverEndPoint = new IPEndPoint(IPAddress.Parse(_ip), _port);
                _client.Connect(serverEndPoint);
                _clientStream = _client.GetStream();

                while (run)
                {
                    // wait for message
                    byte[] bufferIn  = new byte[PROTOCOL_SIZE];
                    int    bytesRead = _clientStream.Read(bufferIn, 0, PROTOCOL_SIZE);

                    // set the message field to be the message we got
                    message = new ASCIIEncoding().GetString(bufferIn);

                    switch (message)
                    {
                    case Protocol.SIGN_IN_RECIEVED:
                        Invoke((MethodInvoker) delegate { signInAnswer(); });
                        break;

                    case Protocol.SIGN_UP_RECIEVED:
                        Invoke((MethodInvoker) delegate { Sign_up_Win.signUpAnswer(); });
                        break;

                    case Protocol.BEST_SCORE_ANS:
                        Invoke((MethodInvoker) delegate { bestScoresAnswer(); });
                        break;

                    case Protocol.STATUS_RECIEVED:
                        Invoke((MethodInvoker) delegate { myStatusAnswer(); });
                        break;

                    case Protocol.CREATE_ROOM_RECIEVED:
                        Invoke((MethodInvoker) delegate { _isWaiting = true; CreateWin.answer(); });
                        break;

                    case Protocol.GET_ROOMS_RECIEVED:
                        Invoke((MethodInvoker) delegate { JoinWin.roomsAnswer(); });
                        break;

                    case Protocol.GET_ROOM_USERS_RECIEVED:
                        Invoke((MethodInvoker) delegate {
                            waitWin.setStream(_clientStream);
                            if (_isWaiting)
                            {
                                waitWin.usersAnswer();
                            }
                            else
                            {
                                JoinWin.usersAnswer();
                            }
                        });
                        break;

                    case Protocol.JOIN_ROOM_RECIEVED:
                        Invoke((MethodInvoker) delegate { JoinWin.joinAnswer(); });
                        break;

                    case Protocol.LEAVE_ROOM_RECIEVED:
                        Invoke((MethodInvoker) delegate { _isWaiting = false; waitWin.leaveRoomAnswer(); });
                        break;

                    case Protocol.CLOSE_ROOM_RECIEVED:
                        Invoke((MethodInvoker) delegate { _isWaiting = false; waitWin.closeRoomAnswer(); });
                        break;

                    case Protocol.STRAT_GAME_RECIEVED:
                        Invoke((MethodInvoker) delegate { GameWin.NextQuestion(); });
                        break;

                    case Protocol.USER_CHOICE_RECIEVED:
                        Invoke((MethodInvoker) delegate { GameWin.ChekingAnswer(); });
                        break;

                    case Protocol.GAME_END_RECIEVED:
                        Invoke((MethodInvoker) delegate { GameWin.EndGame(); });
                        break;

                    default:
                        throw new Exception(UNEXPECTED_INPUT);
                    }
                }
            }
            catch (Exception e)
            {
                // if the error did not occur because of closing
                if (!_close)
                {
                    Invoke((MethodInvoker) delegate { MessageBox.Show(CONNECTION_ERROR); });
                    Invoke((MethodInvoker) delegate { this.Close(); });
                }
            }
        }