Exemple #1
0
        void HandleLoginRes(SFMessage message)
        {
            var loginResult = message.GetValue <Result>("Result");

            if (loginResult.IsFailed)
            {
                PrintStatus(1, "Login failed {0}", loginResult);

                if (mLoginFailedAction != null)
                {
                    mLoginFailedAction(this, 2);
                }

                CloseAllConnections();
                return;
            }

            NextState = eTesterState.GAME_LOGINING;

            m_LoginTicket       = message.GetValue <UInt64>("Ticket");
            m_AccountID         = message.GetValue <UInt64>("AccID");
            m_GameServerAddress = message.GetValue <NetAddress>("GameServerAddrIPV4");
            m_LoginEntityID     = message.GetValue <UInt64>("LoginEntityUID");

            PrintStatus(1, "Login Success!! {0}", m_LoginID);////loginResult);

            if (!string.IsNullOrEmpty(m_GameServerAddress.Address))
            {
                m_ConnectionGame = new SFConnection(m_MessageRouter);
                m_ConnectionGame.Connect(m_LoginTicket, m_GameServerAddress.Address, m_GameServerAddress.Port);
            }
        }
Exemple #2
0
        void HandleJoinGameServerRes(SFMessage message)
        {
            var joinResult = message.GetValue <Result>("Result");

            if (joinResult.IsFailed)
            {
                if (mGameJoinResAction != null)
                {
                    mGameJoinResAction(this, false);
                }

                NextState = eTesterState.GAMESVR_JOIN_FAILED;
                PrintStatus(1, "Join game server failed {0}", joinResult);
                CloseAllConnections();
                return;
            }
            else
            {
                if (mGameJoinResAction != null)
                {
                    mGameJoinResAction(this, true);
                }
            }

            NextState = eTesterState.COMPLTE;

            m_JoinedGameUID = message.GetValue <UInt64>("GameUID");
            if (m_JoinedGameUID != 0)
            {
                PrintStatus(1, "Already has JoinedGame!! = {0} ID = {1} And LeaveGameCMD!!", m_JoinedGameUID, m_LoginID);
                // Fixme
                //m_Game.LeaveGameCmd(0, m_JoinedGameUID, m_AccountID, m_LoginTicket);
            }
        }
Exemple #3
0
        public void RunConnect(NetAddress serverAddress,

                               System.Action <StressTest_LoginUser> OnLoginConnected,
                               System.Action <StressTest_LoginUser, SF.Net.SendMessageLogin> OnLoginDisConnected,
                               System.Action <StressTest_LoginUser, int> OnLoginFailed,

                               System.Action <StressTest_LoginUser> OnGameSvrConnected,
                               System.Action <StressTest_LoginUser, SF.Net.SendMessageGame> OnGameSvrDisConnected,
                               System.Action <StressTest_LoginUser> OnGameSvrFailedConnect,

                               System.Action <StressTest_LoginUser, bool> OnGameJoinAction)
        {
            mLoginConnectedAction    = OnLoginConnected;
            mLoginDisConnectedAction = OnLoginDisConnected;
            mLoginFailedAction       = OnLoginFailed;

            // Game Sever
            mGameSvrConnectedAction     = OnGameSvrConnected;
            mGameSvrDisConnectedAction  = OnGameSvrDisConnected;
            mGameSvrFailedConnectAction = OnGameSvrFailedConnect;

            mGameJoinResAction = OnGameJoinAction;

            NextState     = eTesterState.LOGINING;
            mCurDeltaTime = 0;

            m_ConnectionLogin = new SFConnection(m_MessageRouter);
            m_ConnectionLogin.Connect(0, serverAddress.Address, (int)serverAddress.Port);
        }
Exemple #4
0
        public void OnTimerTick(long TickMs)
        {
            if (mNextState != eTesterState.NONE)
            {
                if (mCurState != mNextState)
                {
                    mCurState = mNextState;
                }

                mNextState = eTesterState.NONE;
            }

            mCurDeltaTime += TickMs;

            SFConnection.Event conEvent;
            // Individual connection update loop
            if (m_ConnectionLogin != null)
            {
                var result = m_ConnectionLogin.DequeueEvent(out conEvent);
                while (result)
                {
                    HandleLoginConnectionEvent(conEvent);

                    if (m_ConnectionLogin == null)
                    {
                        return;
                    }

                    result = m_ConnectionLogin.DequeueEvent(out conEvent);
                }

                m_ConnectionLogin.UpdateMessageQueue();
            }

            if (m_ConnectionGame != null)
            {
                var result = m_ConnectionGame.DequeueEvent(out conEvent);
                while (result)
                {
                    HandleGameConnectionEvent(conEvent);
                    if (m_ConnectionGame == null)
                    {
                        return;
                    }

                    result = m_ConnectionGame.DequeueEvent(out conEvent);
                }

                m_ConnectionGame.UpdateMessageQueue();
                if (mCurState != eTesterState.NONE)// && m_ConnectionLogin.State != SFConnection.ConnectionState.DISCONNECTED)
                {
                    if (m_Game != null && mCurDeltaTime >= 10000)
                    {
                        m_Game.HeartBitC2SEvt();
                        mCurDeltaTime = 0;
                    }
                }
            }
        }
        public void OnTimerTick(long TickMs)
        {
            if (mNextState != eTesterState.NONE)
            {
                if (mCurState != mNextState)
                {
                    mCurState = mNextState;
                }

                mNextState = eTesterState.NONE;
            }
            SFConnection.Event conEvent;

            mHeartBitTime += TickMs;

            // Individual connection update loop
            if (m_ConnectionLogin != null)
            {
                var result = m_ConnectionLogin.DequeueEvent(out conEvent);
                while (result)
                {
                    HandleLoginConnectionEvent(conEvent);
                    if (m_ConnectionLogin == null)
                    {
                        return;
                    }

                    result = m_ConnectionLogin.DequeueEvent(out conEvent);
                }

                m_ConnectionLogin.UpdateMessageQueue();
            }


            if (m_ConnectionGame != null)
            {
                var result = m_ConnectionGame.DequeueEvent(out conEvent);
                while (result)
                {
                    HandleGameConnectionEvent(conEvent);
                    if (m_ConnectionGame == null)
                    {
                        return;
                    }

                    result = m_ConnectionGame.DequeueEvent(out conEvent);
                }
                m_ConnectionGame.UpdateMessageQueue();

                //if (mCurState != eTesterState.NONE && m_Game != null && m_ConnectionGame.State == SFConnection.ConnectionState.CONNECTED)
                //{
                //    if (mHeartBitTime >= 20)
                //    {
                //        this.m_Game.HeartBitC2SEvt();
                //        mHeartBitTime = 0;
                //    }
                //}
            }
        }
Exemple #6
0
        void HandleLeavePartyRes(SFMessage message)
        {
            PrintStatus(1, "HandleLeavePartyRes {0}", m_LoginID);

            m_PartyUID = 0;

            if (!IsPartyBoss)
            {
                NextState = eTesterState.PARTY_WAIT_INVITE;
            }
        }
        public void RunConnect(NetAddress serverAddress,

                               System.Action <StressTest_Matched_Chat> OnLoginConnected,
                               System.Action <StressTest_Matched_Chat, SF.Net.SendMessageLogin> OnLoginDisConnected,
                               System.Action <StressTest_Matched_Chat, int> OnLoginFailed,

                               System.Action <StressTest_Matched_Chat> OnGameSvrConnected,
                               System.Action <StressTest_Matched_Chat, SF.Net.SendMessageGame> OnGameSvrDisConnected,
                               System.Action <StressTest_Matched_Chat> OnGameSvrFailedConnect,

                               System.Action <StressTest_Matched_Chat, bool> OnGameJoinResAction,


                               System.Action <StressTest_Matched_Chat> OnPartyCreateAction,
                               System.Action <StressTest_Matched_Chat, bool> OnGamePartyJoinedAction,
                               System.Action <StressTest_Matched_Chat, bool> OnPartyChatSendResAction,
                               System.Action <StressTest_Matched_Chat, UInt64> OnPartyChatOneKBRecivedTen,
                               System.Action <StressTest_Matched_Chat, int, UInt64> OnPartyChatOneKBRecivedSingle)
        {
            mLoginConnectedAction    = OnLoginConnected;
            mLoginDisConnectedAction = OnLoginDisConnected;
            mLoginFailedAction       = OnLoginFailed;

            // Game Sever
            mGameSvrConnectedAction     = OnGameSvrConnected;
            mGameSvrDisConnectedAction  = OnGameSvrDisConnected;
            mGameSvrFailedConnectAction = OnGameSvrFailedConnect;

            //---
            mGameJoinResAction = OnGameJoinResAction;
            mPartyCreateAction = OnPartyCreateAction;


            mGamePartyJoinedAction    = OnGamePartyJoinedAction;
            mPartyChatSendResAction   = OnPartyChatSendResAction;
            mPartyChatOneKBRecivedTen = OnPartyChatOneKBRecivedTen;

            mPartyChatOneKBRecivedSingle = OnPartyChatOneKBRecivedSingle;

            mTotalRecvedPartyChatMessageCount = 0;

            m_PartyInfo = new PartyMatchedInfo(0);

            NextState         = eTesterState.LOGINING;
            m_ConnectionLogin = new SFConnection(m_MessageRouter);
            m_ConnectionLogin.Connect(0, serverAddress.Address, (int)serverAddress.Port);

            mHeartBitTime = 0;
        }
Exemple #8
0
        public void OnTimerTick(long TickMs)
        {
            if (mNextState != eTesterState.NONE)
            {
                if (mCurState != mNextState)
                {
                    mCurState = mNextState;
                }

                mNextState = eTesterState.NONE;
            }
            SFConnection.Event conEvent;

            // Individual connection update loop
            if (m_ConnectionLogin != null)
            {
                var result = m_ConnectionLogin.DequeueEvent(out conEvent);
                while (result)
                {
                    HandleLoginConnectionEvent(conEvent);
                    if (m_ConnectionLogin == null)
                    {
                        return;
                    }

                    result = m_ConnectionLogin.DequeueEvent(out conEvent);
                }

                m_ConnectionLogin.UpdateMessageQueue();
            }


            if (m_ConnectionGame != null)
            {
                var result = m_ConnectionGame.DequeueEvent(out conEvent);
                while (result)
                {
                    HandleGameConnectionEvent(conEvent);
                    if (m_ConnectionGame == null)
                    {
                        return;
                    }

                    result = m_ConnectionGame.DequeueEvent(out conEvent);
                }
                m_ConnectionGame.UpdateMessageQueue();
            }
        }
Exemple #9
0
        // matching successed
        //-- 매칭 요청 완료시..
        void HandleGameMatchedS2CEvt(SFMessage message)
        {
            if (m_Game == null)
            {
                return;
            }

            UInt64 GameInsID = message.GetValue <UInt64>("InsUID");

            PrintStatus(1, "GameMatchedS2CEvt !! InsUID = {0} and JoinGameCmd!! ID = {1} ", GameInsID, m_LoginID);
            //m_Game.JoinGameCmd(m_AccountID, m_LoginTicket, GameInsID);
            //variableBuilder.SetVariable("InsUID", parser.GetInsUID());
            //variableBuilder.SetVariable("TimeStamp", parser.GetTimeStamp());
            //variableBuilder.SetVariable("GameState", (int)parser.GetGameState());
            //variableBuilder.SetVariable("Day", parser.GetDay());
            //variableBuilder.SetVariable("MaxPlayer", parser.GetMaxPlayer());
            //variableBuilder.SetVariable("PlayerIndex", parser.GetPlayerIndex());
            //variableBuilder.SetVariable("PlayerCharacter", parser.GetPlayerCharacter());
            //variableBuilder.SetVariable("Role", (int)parser.GetRole());
            //variableBuilder.SetVariable("Dead", parser.GetDead());
            //variableBuilder.SetVariable("ChatHistoryData", (int)parser.GetChatHistoryData().size(), parser.GetChatHistoryData().data());
            //variableBuilder.SetVariable("GameLogData", (int)parser.GetGameLogData().size(), parser.GetGameLogData().data());
            //variableBuilder.SetVariable("Stamina", parser.GetStamina());
            //variableBuilder.SetVariable("TotalGem", parser.GetTotalGem());
            //variableBuilder.SetVariable("TotalGameMoney", parser.GetTotalGameMoney());
            UInt64 JoinedGameUID = message.GetValue <UInt64>("InsUID");

            if (m_JoinedGameUID == 0)
            {
                m_JoinedGameUID = JoinedGameUID;
                m_MatchedInfo   = new MatchedInfo(m_JoinedGameUID);

                if (mReqMatchResAction != null)
                {
                    mReqMatchResAction(this, true);
                }

                NextState = eTesterState.COMPLTE;
            }
            else if (JoinedGameUID == m_JoinedGameUID)
            {
                // Already has Joined!!
            }
        }
Exemple #10
0
        public void RunConnect(NetAddress serverAddress,

                               System.Action <StressTest_MatchingUser> OnLoginConnected,
                               System.Action <StressTest_MatchingUser, SF.Net.SendMessageLogin> OnLoginDisConnected,
                               System.Action <StressTest_MatchingUser, int> OnLoginFailed,

                               System.Action <StressTest_MatchingUser> OnGameSvrConnected,
                               System.Action <StressTest_MatchingUser, SF.Net.SendMessageGame> OnGameSvrDisConnected,
                               System.Action <StressTest_MatchingUser> OnGameSvrFailedConnect,
                               System.Action <StressTest_MatchingUser, bool> OnGameJoinAction,

                               System.Action <StressTest_MatchingUser> On4xMatchedAction,
                               System.Action <StressTest_MatchingUser> OnSendMatchAction,


                               System.Action <StressTest_MatchingUser, bool> OnReqMatchResAction,


                               System.Action <StressTest_MatchingUser> OnRecvChatDataAction)
        {
            mLoginConnectedAction    = OnLoginConnected;
            mLoginDisConnectedAction = OnLoginDisConnected;
            mLoginFailedAction       = OnLoginFailed;

            // Game Sever
            mGameSvrConnectedAction     = OnGameSvrConnected;
            mGameSvrDisConnectedAction  = OnGameSvrDisConnected;
            mGameSvrFailedConnectAction = OnGameSvrFailedConnect;

            mGameJoinResAction = OnGameJoinAction;

            m4xMatchedAction    = On4xMatchedAction;
            mSendReqMatchAction = OnSendMatchAction;
            mReqMatchResAction  = OnReqMatchResAction;

            mRecvChatDataAction = OnRecvChatDataAction;
            m_MatchedInfo       = new MatchedInfo(0);

            NextState     = eTesterState.LOGINING;
            mCurDeltaTime = 0;

            m_ConnectionLogin = new SFConnection(m_MessageRouter);
            m_ConnectionLogin.Connect(0, serverAddress.Address, (int)serverAddress.Port);
        }
        void HandleJoinGameServerRes(SFMessage message)
        {
            var joinResult = message.GetValue <Result>("Result");

            if (joinResult.IsFailed)
            {
                if (mGameJoinResAction != null)
                {
                    mGameJoinResAction(this, false);
                }

                PrintStatus(1, "Join game server failed {0}", joinResult);
                CloseAllConnections();
                return;
            }
            else
            {
                if (mGameJoinResAction != null)
                {
                    mGameJoinResAction(this, true);
                }
            }

            NextState = eTesterState.MATCHING;

            m_JoinedGameUID = message.GetValue <UInt64>("GameUID");
            if (m_JoinedGameUID == 0)
            {
                if (mSendReqMatchAction != null)
                {
                    mSendReqMatchAction(this);
                }
            }
            else
            {
                PrintStatus(1, "Already has JoinedGame!! = {0} ID = {1} And LeaveGameCMD!!", m_JoinedGameUID, m_LoginID);
                m_MatchedInfo = new MatchedInfo(m_JoinedGameUID);
                // Fixme
                //m_Game.LeaveGameCmd(0, m_JoinedGameUID, m_AccountID, m_LoginTicket);
            }
        }
        public void RunConnect(NetAddress serverAddress,
                               System.Action <StressTest_TenKBUser> OnLoginConnected,
                               System.Action <StressTest_TenKBUser, SF.Net.SendMessageLogin> OnLoginDisConnected,
                               System.Action <StressTest_TenKBUser> OnLoginFailedConnect,
                               System.Action <StressTest_TenKBUser, bool> OnLoginRes,
                               System.Action <StressTest_TenKBUser, bool> OnDataTestSendRes)
        {
            mLoginConnectedAction     = OnLoginConnected;
            mLoginDisConnectedAction  = OnLoginDisConnected;
            mLoginFailedConnectAction = OnLoginFailedConnect;

            mLoginResAction  = OnLoginRes;
            mDataTestSendRes = OnDataTestSendRes;

            mNextState        = eTesterState.LOGINING;
            mDataTestResCount = 0;
            mCurDeltaTime     = 0;

            m_ConnectionLogin = new SFConnection(m_MessageRouter);
            m_ConnectionLogin.Connect(0, serverAddress.Address, (int)serverAddress.Port);
        }
Exemple #13
0
        void HandlePartyChatMessageS2CEvt(SFMessage message)
        {
            //AccountID m_SenderID;
            //const char* m_SenderName;
            //const char* m_ChatMessage;
            //variableBuilder.SetVariable("SenderID", parser.GetSenderID());
            //variableBuilder.SetVariable("SenderName", parser.GetSenderName());
            //variableBuilder.SetVariable("ChatMessage", parser.GetChatMessage());
            mRecvedPartyChatMessageCount++;

            PartyChatMessageRecvInfo data = new PartyChatMessageRecvInfo();

            data.RecvTime     = DateTime.Now;
            data.RecvChatSize = message.GetValue <string>("ChatMessage").Length;
            data.ChatMsg      = message.GetValue <string>("ChatMessage");

            mRecvChatHistorys.Add(data);

            if (!IsPartyBoss)
            {
                PrintStatus(1, "Recivice 1KB  ID ={0} Time = {1} ", m_LoginID, data.RecvTime.ToString("hh/mm/ss.fff"));
            }

            if (mRecvedPartyChatMessageCount == StressTestWindowMatch10KB.SendChatRepeatCount)
            {
                NextState = eTesterState.COMPLTE;

                if (!IsPartyBoss)
                {
                    PrintStatus(1, "Recivice 1KB {0}... ID ={1}", StressTestWindowMatch10KB.SendChatRepeatCount, m_LoginID);
                }

                if (mPartyChatOneKBRecivedTen != null)
                {
                    mPartyChatOneKBRecivedTen(this);
                }
            }
        }
Exemple #14
0
        void HandleJoinGameServerRes(SFMessage message)
        {
            if (m_Game == null || m_ConnectionGame == null)
            {
                return;
            }

            if (m_ConnectionGame.State != SFConnection.ConnectionState.CONNECTED)
            {
                return;
            }

            var joinResult = message.GetValue <Result>("Result");

            if (joinResult.IsFailed)
            {
                if (mGameJoinResAction != null)
                {
                    mGameJoinResAction(this, false);
                }

                PrintStatus(1, "Join game server failed {0} ID = {1}", joinResult, m_LoginID);
                CloseAllConnections();
                return;
            }
            else
            {
                if (mGameJoinResAction != null)
                {
                    mGameJoinResAction(this, true);
                }
            }

            m_PartyUID = message.GetValue <UInt64>("PartyUID");

            if (m_PartyUID == 0)
            {
                if (IsPartyBoss)
                {
                    NextState = eTesterState.PARTY_MATCING;

                    if (m_Game.CreatePartyCmd(0) != 0)
                    {
                        return;
                    }

                    PrintStatus(1, "Create PartyCmd ID = {0}", m_LoginID);
                }
                else
                {
                    NextState = eTesterState.PARTY_WAIT_INVITE;
                }
            }
            else
            {
                NextState = eTesterState.PARTY_MATCING;

                // already has party
                m_PartyInfo = new PartyMatchedInfo(m_PartyUID);
                if (IsPartyBoss)
                {
                    PrintStatus(1, "Already has partyID = {0} ID = {1} IsBoss = {2} ", m_PartyUID, m_LoginID, IsPartyBoss);
                    if (mPartyCreateAction != null)
                    {
                        mPartyCreateAction(this);
                    }
                }
                else
                {
                    PrintStatus(1, "Already has PartyJoined!! = {0} ID = {1} And LeavePartyCmd!!", m_PartyUID, m_LoginID);
                    m_Game.LeavePartyCmd(0, m_PartyUID, m_AccountID);
                }
            }
        }
        void HandlePartyChatMessageS2CEvt(SFMessage message)
        {
            //AccountID m_SenderID;
            //const char* m_SenderName;
            //const char* m_ChatMessage;
            //variableBuilder.SetVariable("SenderID", parser.GetSenderID());
            //variableBuilder.SetVariable("SenderName", parser.GetSenderName());
            //variableBuilder.SetVariable("ChatMessage", parser.GetChatMessage());

            PartyChatMessageRecvInfo data = new PartyChatMessageRecvInfo();

            data.RecvTime     = DateTime.Now;
            data.RecvChatSize = message.GetValue <string>("ChatMessage").Length;
            data.ChatMsg      = message.GetValue <string>("ChatMessage");
            data.SenderID     = message.GetValue <UInt64>("SenderID");
            // data.SenderName  = message.GetValue<string>("SenderName");

            if (!mRecvChatHistorys.ContainsKey(data.SenderID))
            {
                mRecvChatHistorys.Add(data.SenderID, new List <PartyChatMessageRecvInfo>());
            }

            mRecvChatHistorys[data.SenderID].Add(data);
            int RecvedPartyChatMessageCount = mRecvChatHistorys[data.SenderID].Count;

            mTotalRecvedPartyChatMessageCount++;

            int ChatDataSize = StressTestWindowMatch10KB.ChatDataTestSize / 1024;


            if (StressTestWindowMatch10KB.bSingleSpeedCheck)
            {
                if (RecvedPartyChatMessageCount == StressTestWindowMatch10KB.SendChatRepeatCount)
                {
                    NextState = eTesterState.COMPLTE;
                }

                if (IsPutRecvChatLog)
                {
                    PrintStatus(1, "Recivice {3}KB {0}... ID ={1} [{4}] Sender ={2} RecvTime = {5}", StressTestWindowMatch10KB.SendChatRepeatCount, m_LoginID, data.SenderID,
                                10, m_AccountID, data.RecvTime.ToString("hh/mm/ss.fff"));
                }

                if (mPartyChatOneKBRecivedSingle != null)
                {
                    mPartyChatOneKBRecivedSingle(this, RecvedPartyChatMessageCount, data.SenderID);
                }
            }
            else
            {
                if (IsPutRecvChatLog)
                {
                    PrintStatus(1, "Recivice.[Me={0}][Sender={1} / {2} ] -({3}) {5}KB RecvTime = {4} ", m_AccountID, data.SenderID,
                                mRecvChatHistorys[data.SenderID].Count, mTotalRecvedPartyChatMessageCount, data.RecvTime.ToString("hh/mm/ss.fff"), ChatDataSize);
                }

                if (RecvedPartyChatMessageCount == StressTestWindowMatch10KB.SendChatRepeatCount)
                {
                    if (mTotalRecvedPartyChatMessageCount == StressTestWindowMatch10KB.SendChatRepeatCount * 4)// 40)
                    {
                        NextState = eTesterState.COMPLTE;
                    }

                    if (IsPutRecvChatLog)
                    {
                        PrintStatus(1, "Recivice {3}KB {0}... ID ={1} [{4}] Sender ={2}", StressTestWindowMatch10KB.SendChatRepeatCount, m_LoginID, data.SenderID, ChatDataSize, m_AccountID);
                    }

                    if (mPartyChatOneKBRecivedTen != null)
                    {
                        mPartyChatOneKBRecivedTen(this, data.SenderID);
                    }
                }
            }

            ////if(!IsPartyBoss)
            //PrintStatus(1, "Recivice 1KB  ID ={0} Sender = {1} Time = {2} ", m_LoginID, data.SenderID,
            //    data.RecvTime.ToString("hh/mm/ss.fff"));
            //if (mRecvedPartyChatMessageCount == StressTestWindowMatch10KB.SendChatRepeatCount)
            //{
            //    NextState = eTesterState.COMPLTE;
            //   // if (!IsPartyBoss)
            //    PrintStatus(1, "Recivice 1KB {0}... ID ={1}", StressTestWindowMatch10KB.SendChatRepeatCount,  m_LoginID);
            //    if(mPartyChatOneKBRecivedTen != null)
            //        mPartyChatOneKBRecivedTen(this);
            //}
        }