Fix logar na mesma conta Source MuLegend s16.1

Me pediram pra fixar alguns problemas dentro dessa source, então vou ir postando alguns fixs aqui.




Troque o seu AuthServer.cpp por esse

Código:

---

std::unordered_map<uint8, LoginHandler<AuthServer>> AuthServer::InitHandlers()
{
    std::unordered_map<uint8, LoginHandler<AuthServer>> handlers;


        handlers[HEADCODE_LOGIN_SERVER_CONNECT]                                        = { "ON_CONNECT", sizeof(GAMESERVER_CONNECT), &AuthServer::HandleHeadcodeOnConnect };
    handlers[HEADCODE_LOGIN_SERVER_ACCOUNT_LOGIN]                        = { "ACCOUNT_LOGIN", sizeof(ACCOUNT_LOGIN_RESULT), &AuthServer::PlayerLoginResult };
        handlers[HEADCODE_LOGIN_SERVER_ACCOUNT_SERVER_MOVE]                = { "ACCOUNT_SERVER_MOVE", sizeof(ACCOUNT_SERVER_MOVE_RESULT), &AuthServer::PlayerServerMoveResult };
        handlers[HEADCODE_LOGIN_SERVER_ACCOUNT_SERVER_AUTH]                = { "ACCOUNT_SERVER_AUTH", sizeof(ACCOUNT_SERVER_MOVE_AUTH_RESULT), &AuthServer::PlayerServerMoveAuthResult };
        handlers[HEADCODE_LOGIN_SERVER_ACCOUNT_KICK]                        = { "ACCOUNT_KICK", sizeof(ACCOUNT_KICK), &AuthServer::PlayerAccountKick };
        handlers[HEADCODE_LOGIN_SERVER_ACCOUNT_ONLINE]                        = { "ACCOUNT_ONLINE", sizeof(ACCOUNT_ONLINE), &AuthServer::PlayerAccountOnline };


        handlers[HEADCODE_LOGIN_SERVER_COMPLETE_BAN]                        = { "COMPLETE_BAN", sizeof(ACCOUNT_COMPLETE_BAN), &AuthServer::AccountCompleteBan };


        handlers[HEADCODE_LOGIN_SERVER_ACCOUNT_DUPLICATE] = { "ACCOUNT_DUPLICATE", sizeof(SL_ACCOUNT_DUPLICATE), &AuthServer::AccountDuplicate };
       
    return handlers;
}


std::unordered_map<uint8, LoginHandler<AuthServer>> const Handlers = AuthServer::InitHandlers();


AuthServer::AuthServer(): TCPClientMgr("AuthServer")
{
       
}


void AuthServerSocket::OnStart()
{
        sLog->outInfo("root", "CONNECTED AUTHSERVER");


        sAuthServer->IncreaseConnectCount(1);
        sAuthServer->SetStopped(false);


        sAuthServer->SendData();
}


void AuthServerSocket::OnStop()
{
        sLog->outInfo("root", "DISCONNECTED AUTHSERVER");


        sAuthServer->GetReconnectTime()->Start();
        sAuthServer->SetStopped(true);
}


void AuthServerSocket::ReadHandler()
{
        if ( this->IsStopped() )
                return;


        MessageBuffer& packet = GetReadBuffer();
    while ( packet.GetActiveSize() > 0 )
    {
                uint8 cmd = packet.GetReadPointer()[0];


        auto itr = Handlers.find(cmd);
        if (itr == Handlers.end())
        {
            packet.Reset();
            break;
        }


        uint16 size = itr->second.packetSize;


        if (packet.GetActiveSize() < size)
            break;


                CUSTOM_PACKET_HEAD * head = (CUSTOM_PACKET_HEAD*)packet.GetReadPointer();


                sAuthServer->AddPacket(new WorldPacket(cmd, packet.GetReadPointer(), head->size));       


                packet.ReadCompleted(head->size);
    }
}


void AuthServer::HandleHeadcodeOnConnect(uint8 * Packet)
{
        PlayerMap const& account_map = sObjectMgr->GetAllAccounts();
        for ( PlayerMap::const_iterator it = account_map.begin(); it != account_map.end(); ++it )
        {
                Player* pPlayer = it->second;


                if ( !pPlayer )
                        continue;


                if ( pPlayer->GetConnectStatus() == CONNECT_STATUS_LOGGED ||
                        pPlayer->GetConnectStatus() == CONNECT_STATUS_PLAYING )
                {
                        ACCOUNT_RECONNECT pMsg;
                        pMsg.h.server = sGameServer->GetServerCode();
                        pMsg.account_id = pPlayer->GetAccountData()->GetGUID();
                        pMsg.start_server = pPlayer->GetStartServer();
                        memcpy(pMsg.account, pPlayer->GetAccountData()->GetAccount(), MAX_ACCOUNT_LENGTH);
                        memcpy(pMsg.mac, pPlayer->GetAccountData()->GetMac(), MAX_ACCOUNT_MAC_LENGTH);
                        memcpy(pMsg.ip, pPlayer->GetAccountData()->GetIP(), MAX_ACCOUNT_IP_LENGTH);
                        pMsg.facebook_status = pPlayer->GetAccountData()->GetFacebookStatus();
                        pMsg.golden_channel = pPlayer->GetAccountData()->GetGoldenChannel();
                        pMsg.disk_serial = pPlayer->GetAccountData()->GetDiskSerial();
                        pMsg.authorized = pPlayer->IsAuthorizationEnabled();
                               
                        this->SendPacket(MAKE_PCT(pMsg));
                }
        }
}


void AuthServer::SendData()
{
        GAMESERVER_CONNECT pMsg(sGameServer->GetServerCode());
        pMsg.port = sGameServer->GetNetworkPort();
        memcpy(pMsg.ip, sGameServer->GetNetworkIP(), 16);
        pMsg.flag = sGameServer->GetFlag();
        pMsg.type = sGameServer->GetServerMode();
        this->SendPacket((uint8*)&pMsg, pMsg.h.get_size());
}


void AuthServer::SendPlayerPercent()
{
        GAMESERVER_USER_PERCENT pMsg(sObjectMgr->GetPlayerPercent(true), sGameServer->GetFlag(), sGameServer->GetServerMode());
        pMsg.h.server = sGameServer->GetServerCode();
        this->SendPacket((uint8*)&pMsg, pMsg.h.get_size());
}


void AuthServer::PlayerLoginRequest(Player* pPlayer, PlayerLoginStep step)
{
        if ( this->IsStopped() )
        {
                pPlayer->SetAutoLogin(false);
                pPlayer->CloseSocket();
                return;
        }


        switch ( step )
        {
        case PLAYER_LOGIN_STEP_ACCOUNT:
                {
                } break;


        case PLAYER_LOGIN_STEP_CHARACTER:
                {
                } break;


        case PLAYER_LOGIN_STEP_OK:


                {


               
                        ACCOUNT_LOGIN_REQUEST pMsg(pPlayer->GetEntry());


                        pMsg.h.server = sGameServer->GetServerCode();
                        pMsg.ms_time = pPlayer->GetMSTime();
                        memcpy(pMsg.account, pPlayer->GetAccountSafe(), MAX_ACCOUNT_LENGTH + 1);


                        if (sObjectMgr->AccountOnlineCheck(pMsg.account))
                        {
                                pPlayer->SetAutoLogin(false);
                                pPlayer->ResultClose(LOGIN_RESULT_ONLINE);
                                return;
                        }
                        memcpy(pMsg.password, pPlayer->GetPasswordSafe(), MAX_PASSWORD_LENGTH + 1);
                        memcpy(pMsg.ip, pPlayer->GetAccountData()->GetIP(), MAX_ACCOUNT_IP_LENGTH + 1);
                        memcpy(pMsg.mac, pPlayer->GetAccountData()->GetMac(), MAX_ACCOUNT_MAC_LENGTH + 1);
                        pMsg.disk_serial = pPlayer->GetAccountData()->GetDiskSerial();
                        pMsg.account_id = pPlayer->GetAutoLoginAccount();
                        pMsg.autologin = pPlayer->IsAutoLogin() ? 1 : 0;
                        this->SendPacket((uint8*)&pMsg, pMsg.h.size);
                } break;
        }
}
       
void AuthServer::PlayerLoginResult(uint8 * Packet)
{
        POINTER_PCT(ACCOUNT_LOGIN_RESULT, lpMsg, Packet, 0);


        if (lpMsg->h.server != sGameServer->GetServerCode())
        {
                return;
        }
       






        Player* pPlayer = sObjectMgr->FindPlayer(lpMsg->entry);




       


        if ( !pPlayer )
        {
                if ( lpMsg->result == LOGIN_RESULT_SUCCESS )
                {
                        this->PlayerLogout(lpMsg->account_id);
                }
                return;
        }


       




        if ( pPlayer->GetConnectStatus() != CONNECT_STATUS_CONNECTED )
        {
                if ( lpMsg->result == LOGIN_RESULT_SUCCESS )
                {
                        this->PlayerLogout(lpMsg->account_id);
                }
                return;
        }


        if ( pPlayer->GetMSTime() != lpMsg->ms_time ) // No permito que la cuenta loguee porque tienen diferente msec de inicio
        {
                if ( lpMsg->result == LOGIN_RESULT_SUCCESS )
                {
                        this->PlayerLogout(lpMsg->account_id);
                }
                return;
        }
       
        pPlayer->SetLoginSent(false);


        if ( lpMsg->result != LOGIN_RESULT_SUCCESS )
        {
                pPlayer->SetAutoLogin(false);
                pPlayer->LoginResult(lpMsg->result);
                return;
        }


        pPlayer->GetAccountData()->SetGUID(lpMsg->account_id);


        memcpy(pPlayer->GetAccountData()->secure_code, lpMsg->security_code, MAX_SECURE_CODE_LENGTH + 1);


        pPlayer->GetAccountData()->SetAccount(pPlayer->GetAccountSafe());
        pPlayer->GetAccountData()->SetFacebookStatus(lpMsg->facebook_status);
        pPlayer->GetAccountData()->SetGoldenChannel(lpMsg->golden_channel);


        if ( pPlayer->IsAutoLogin() )
        {
                pPlayer->GetAccountData()->SetAccount(lpMsg->account);
        }


        pPlayer->SetConnectStatus(CONNECT_STATUS_LOGGED);
        sObjectMgr->AddSessionAccount(pPlayer);


        pPlayer->LoginResult(LOGIN_RESULT_SUCCESS);


        pPlayer->UpdateAccountStatusType(0);
        pPlayer->SetAuthorizationEnabled(sGameServer->IsAuthorizationEnabled());


        sLog->outInfo(LOG_PLAYER, "[ LOGIN REQUEST ] Success %s", pPlayer->BuildLog().c_str());


        if ( pPlayer->IsAutoLogin() )
        {
                pPlayer->AutoLoginCharacterSelect();
        }


        //pPlayer->WhiteListRequest();
}


void AuthServer::PlayerLogout(uint32 account_id)
{
        QueryResult result = MuDatabase.PQuery("UPDATE account_data SET current_server=65535 WHERE account_id=%d", account_id);


        ACCOUNT_LOGOUT pMsg(account_id);
        pMsg.h.server = sGameServer->GetServerCode();
        this->SendPacket((uint8*)&pMsg, pMsg.h.size);
}


void AuthServer::PlayerServerMoveRequest(Player* pPlayer, uint16 server, uint16 world, int16 x, int16 y, bool channel)
{
        if ( !pPlayer )
                return;


        if (!pPlayer->IsAuthorizationEnabled()) {
                pPlayer->SendNotice(CUSTOM_MESSAGE_ID_RED, "You are not authorized for this action.");
                return;
        }


        if (pPlayer->IsDueling()) {
                pPlayer->SendNotice(CUSTOM_MESSAGE_ID_RED, "Don't move server is dueling");
                return;
        }


        if (sGameServer->IsChannelChangeNotUseHighPKEnabled()) {
                uint8 high_pk_level = sGameServer->GetChannelChangeNotUseHighPKLevel() + 3;


                if (high_pk_level == 3) {
                        high_pk_level = 4;
                }
                else if (high_pk_level > 6) {
                        high_pk_level = 6;
                }


                if (pPlayer->GetPKLevel() >= high_pk_level) {
                        pPlayer->SendNotice(CUSTOM_MESSAGE_ID_RED, "Don't move server is pk high");
                        return;
                }
        }


        if ( sGameServer->IsServerWarpTransactionCheck1() )
        {
                if ( pPlayer->GetInterfaceState()->GetID() != InterfaceData::None )
                {
                        sLog->outError(LOG_PLAYER, "[ SERVER MOVE REQUEST ] Active Interface %s // %s --- Server: %d [%d - %d/%d]", pPlayer->GetInterfaceState()->GetID().c_str(), pPlayer->BuildLog().c_str(),
                                server, world, x, y);


                        pPlayer->SendNotice(CUSTOM_MESSAGE_ID_RED, "Close interface before warp.");
                        return;
                }
        }


        if ( sGameServer->IsServerWarpTransactionCheck2() )
        {
                if ( pPlayer->GetTransaction() == TRANSACTION_TYPE_BEGIN )
                {
                        sLog->outError(LOG_PLAYER, "[ SERVER MOVE REQUEST ] Active Transaction // %s --- Server: %d [%d - %d/%d]", pPlayer->BuildLog().c_str(),
                                server, world, x, y);


                        pPlayer->SendNotice(CUSTOM_MESSAGE_ID_RED, "Wrong game interface. Close client and try again.");
                        return;
                }
        }


        if ( sGameServer->IsServerWarpTransactionCheck3() )
        {
                if ( pPlayer->GetPersonalStore()->IsBusy() )
                {
                        sLog->outError(LOG_PLAYER, "[ SERVER MOVE REQUEST ] Personal Store Open // %s --- Server: %d [%d - %d/%d]", pPlayer->BuildLog().c_str(),
                                server, world, x, y);


                        pPlayer->SendNotice(CUSTOM_MESSAGE_ID_RED, "Close Personal Store before warp.");
                        return;
                }
        }


        pPlayer->SaveCharacter();
        pPlayer->SetDestServer(server);
        pPlayer->SetDestWorld(world);
        pPlayer->SetDestX(x);
        pPlayer->SetDestY(y);


        ACCOUNT_SERVER_MOVE_REQUEST pMsg;
        pMsg.h.server = sGameServer->GetServerCode();
        memcpy(pMsg.data.account, pPlayer->GetAccountData()->GetAccount(), MAX_ACCOUNT_LENGTH + 1);
        pMsg.data.account_id = pPlayer->GetAccountData()->GetGUID();
        pMsg.data.cur_server = sGameServer->GetServerCode();
        pMsg.data.dest_server = pPlayer->GetDestServer();
        pMsg.data.dest_world = pPlayer->GetDestWorld();
        pMsg.data.dest_x = pPlayer->GetDestX();
        pMsg.data.dest_y = pPlayer->GetDestY();
        pMsg.channel_change = channel ? 1 : 0;


        sLog->outInfo(LOG_PLAYER, "[ SERVER MOVE REQUEST ] %s --- Server: %d [%d - %d/%d]", pPlayer->BuildLog().c_str(),
                server, world, x, y);


        this->SendPacket((uint8*)&pMsg, pMsg.h.size);
}


void AuthServer::PlayerServerMoveResult(uint8 * Packet)
{
        POINTER_PCT(ACCOUNT_SERVER_MOVE_RESULT, lpMsg, Packet, 0);


        if ( lpMsg->h.server != sGameServer->GetServerCode() )
        {
                return;
        }


        Player* pPlayer = sObjectMgr->FindPlayerByAccount(lpMsg->data.account_id);


        if ( !pPlayer || !pPlayer->IsPlaying() )
        {
                return;
        }


        if ( lpMsg->result == 0 )
        {
                pPlayer->SaveCharacter(1);
                pPlayer->SetDestAuth(0, lpMsg->auth[0]);
                pPlayer->SetDestAuth(1, lpMsg->auth[1]);
                pPlayer->SetDestAuth(2, lpMsg->auth[2]);
                pPlayer->SetDestAuth(3, lpMsg->auth[3]);
                pPlayer->SetDestServer(lpMsg->data.dest_server);
                pPlayer->SetDestPort(lpMsg->dest_port);
                pPlayer->SetDestIP(lpMsg->dest_ip);
                pPlayer->InitCloseSocketTime(CLOSE_SOCKET_TIME_SERVER_QUIT);
                pPlayer->SetServerQuit(true);
        }
        else
        {
                if ( pPlayer->IsServerMoveFromCharacterSelect() )
                {
                        pPlayer->SetWorldId(sGameServer->GetDefaultWorld());
                        pPlayer->SetX(sGameServer->GetDefaultX());
                        pPlayer->SetY(sGameServer->GetDefaultY());
                        pPlayer->SetTX(pPlayer->GetX());
                        pPlayer->SetTY(pPlayer->GetY());
                        pPlayer->GetACPathData()->Reset();


                        pPlayer->SendJoinInfo(0);
                        pPlayer->SetServerMove(false);
                        pPlayer->SetServerMoveFromCharacterSelect(false);
                        pPlayer->SendJoinInfo();


                        pPlayer->SendWeather();
                        pPlayer->RestoreEventAnimation();
                }
                else
                {
                        if ( lpMsg->result == 5 )
                        {
                                pPlayer->SendNotice(CUSTOM_MESSAGE_ID_RED, "Server is full.");
                        }
                        else
                        {
                                pPlayer->SendNotice(CUSTOM_MESSAGE_ID_RED, "This location is unavailable.");
                        }
                }


                sLog->outInfo(LOG_PLAYER, "[ SERVER MOVE ERROR %d ] %s --- Server: %d [%d - %d/%d]", lpMsg->result, pPlayer->BuildLog().c_str(),
                        pPlayer->GetDestServer(), pPlayer->GetDestWorld(), pPlayer->GetDestX(), pPlayer->GetDestY());
        }
}


void AuthServer::PlayerServerMoveAuth(Player* pPlayer, uint8 * Packet)
{
        POINTER_PCT(SERVER_CHANGE_AUTH, lpMsg, Packet, 0);


        if ( memcmp(lpMsg->version, sGameServer->GetGameServerVersions(), 5) )
        {
                sLog->outError(LOG_PLAYER, "[ SERVER MOVE AUTH ] %s Wrong Version [%d/%d/%d/%d/%d] / [%d/%d/%d/%d/%d]", pPlayer->BuildLog().c_str(),
                        lpMsg->version[0], lpMsg->version[1], lpMsg->version[2], lpMsg->version[3], lpMsg->version[4],
                        sGameServer->GetGameServerVersion(0), sGameServer->GetGameServerVersion(1), sGameServer->GetGameServerVersion(2),
                        sGameServer->GetGameServerVersion(3), sGameServer->GetGameServerVersion(4));


                this->PlayerServerMoveAuthResult(pPlayer, 6);
                pPlayer->CloseSocket();
                return;
        }


        char client_serial_tmp[17];
        memset(client_serial_tmp, 0, 17);
        memcpy(client_serial_tmp, lpMsg->serial, 16);
       
        if ( memcmp(client_serial_tmp, sGameServer->GetGameServerSerial(), 16) )
        {
                sLog->outError(LOG_PLAYER, "[ SERVER MOVE AUTH ] %s Wrong Serial [%s / %s]", pPlayer->BuildLog().c_str(),
                        client_serial_tmp, sGameServer->GetGameServerSerial());


                this->PlayerServerMoveAuthResult(pPlayer, 6);
                pPlayer->CloseSocket();
                return;
        }


        if ( pPlayer->GetConnectStatus() != CONNECT_STATUS_CONNECTED )
        {
                sLog->outError(LOG_PLAYER, "[ SERVER MOVE AUTH ] %s --- Not Connected", pPlayer->BuildLog().c_str());


                this->PlayerServerMoveAuthResult(pPlayer, 6);
                pPlayer->CloseSocket();
                return;
        }


        if ( pPlayer->IsLoginSent() )
                return;


        STRING_SAFE_COPY(account_temp, MAX_ACCOUNT_LENGTH + 1, lpMsg->account, MAX_ACCOUNT_LENGTH);
        Xor::Byte3(account_temp, MAX_ACCOUNT_LENGTH);
        STRING_SAFE(account, MAX_ACCOUNT_LENGTH + 1);
        strcpy(account, account_temp);


        StringToLower(account);


        pPlayer->SetLoginSent(true);
        pPlayer->SetServerMove(true);
        pPlayer->InitCloseSocketTime(CLOSE_SOCKET_TIME_CONNECT);
        pPlayer->GetAccountData()->IncreaseLoginAttempts(1);
        pPlayer->GetAccountData()->ResetAccount();
        pPlayer->GetAccountData()->SetAccount(account, MAX_ACCOUNT_LENGTH);
        pPlayer->GetAccountData()->SetAccountToLower();
        pPlayer->GetAccountData()->SetGameServerSerial((const char*)lpMsg->serial, 16);
        pPlayer->ResetName();
        pPlayer->SetName(lpMsg->name);


        sLog->outInfo(LOG_PLAYER, "[ SERVER MOVE AUTH ] %s --- Send Join Request [%s][%s]", pPlayer->BuildLog().c_str(), pPlayer->GetAccountData()->GetAccount(), pPlayer->GetName());


        ACCOUNT_SERVER_MOVE_AUTH pMsg;
        pMsg.h.server = sGameServer->GetServerCode();
        pMsg.index = pPlayer->GetEntry();
        memcpy(pMsg.account, account, MAX_ACCOUNT_LENGTH);
        memcpy(pMsg.name, lpMsg->name, MAX_CHARACTER_LENGTH);
        pMsg.auth[0] = lpMsg->auth[0];
        pMsg.auth[1] = lpMsg->auth[1];
        pMsg.auth[2] = lpMsg->auth[2];
        pMsg.auth[3] = lpMsg->auth[3];


        this->SendPacket((uint8*)&pMsg, pMsg.h.get_size());
}


void AuthServer::PlayerServerMoveAuthResult(Player* pPlayer, uint8 result)
{
        SERVER_CHANGE_AUTH_RESULT pMsg(result);
        pPlayer->SEND_PCT(pMsg);
}


void AuthServer::PlayerServerMoveAuthResult(uint8 * Packet)
{
        POINTER_PCT(ACCOUNT_SERVER_MOVE_AUTH_RESULT, lpMsg, Packet, 0);


        if ( lpMsg->h.server != sGameServer->GetServerCode() )
        {
                return;
        }


        Player* pPlayer = sObjectMgr->FindPlayer(lpMsg->index);


        if ( !pPlayer )
        {
                if ( lpMsg->result == 0 )
                {
                        this->PlayerLogout(lpMsg->account_id);
                }
                return;
        }


        if ( memcmp(pPlayer->GetAccountData()->GetAccount(), lpMsg->account, MAX_ACCOUNT_LENGTH) )
        {
                if ( lpMsg->result == 0 )
                {
                        this->PlayerLogout(lpMsg->account_id);
                }
                return;
        }


        if ( !pPlayer->IsServerMove() || !pPlayer->IsLoginSent() )
        {
                sLog->outError(LOG_PLAYER, "[ SERVER MOVE AUTH RESULT ] %s --- No request [%s][%s]",
                        pPlayer->BuildLog().c_str(), pPlayer->GetAccountData()->GetAccount(), pPlayer->GetName());


                pPlayer->CloseSocket();
                return;
        }


        if ( lpMsg->result )
        {
                sLog->outError(LOG_PLAYER, "[ SERVER MOVE AUTH RESULT ] %s --- Failed(%d) [%s][%s]",
                        pPlayer->BuildLog().c_str(), lpMsg->result, pPlayer->GetAccountData()->GetAccount(), pPlayer->GetName());


                this->PlayerServerMoveAuthResult(pPlayer, 0);
                pPlayer->CloseSocket();
                return;
        }


        pPlayer->GetAccountData()->SetGUID(lpMsg->account_id);
        memcpy(pPlayer->GetAccountData()->secure_code, lpMsg->security_code, MAX_SECURE_CODE_LENGTH + 1);
        pPlayer->GetAccountData()->SetFacebookStatus(lpMsg->facebook_status);
        pPlayer->GetAccountData()->SetGoldenChannel(lpMsg->golden_channel);
        pPlayer->GetAccountData()->SetMac(lpMsg->mac, MAX_ACCOUNT_MAC_LENGTH);
        pPlayer->GetAccountData()->SetDiskSerial(lpMsg->disk_serial);
        pPlayer->SetConnectStatus(CONNECT_STATUS_LOGGED);
        sObjectMgr->AddSessionAccount(pPlayer);


        pPlayer->SetDestWorld(lpMsg->world);
        pPlayer->SetDestX(lpMsg->x);
        pPlayer->SetDestY(lpMsg->y);
        pPlayer->SetStartServer(lpMsg->start_server);
        pPlayer->SetLoginSent(false);
        pPlayer->SetAuthorizationEnabled(true);


        this->PlayerServerMoveAuthResult(pPlayer, 1);


        if ( sGameServer->IsArkaWarEnabled() )
        {
                sArkaWar->SendPlayInfo(pPlayer);
                sArkaWar->SendState(pPlayer);
        }


        pPlayer->UpdateAccountStatusType(0);


        sLog->outInfo(LOG_PLAYER, "[ SERVER MOVE AUTH RESULT ] %s --- Joined Successfully [%s][%s]",
                        pPlayer->BuildLog().c_str(), pPlayer->GetAccountData()->GetAccount(), pPlayer->GetName());


        //pPlayer->WhiteListRequest();


        pPlayer->SendClearBuff();


        CHARACTER_SELECT_REQUEST pMsg;
        memcpy(pMsg.character_name, lpMsg->name, MAX_CHARACTER_LENGTH);
        pMsg.index = 0;


        pPlayer->CharacterSelect((uint8*)&pMsg, true);
}


void AuthServer::PlayerAccountKick(uint32 account_id)
{
        ACCOUNT_KICK pMsg(account_id);
        pMsg.h.server = sGameServer->GetServerCode();
        this->SendPacket(MAKE_PCT(pMsg));
}


void AuthServer::PlayerAccountKick(uint8 * Packet)
{
        POINTER_PCT(ACCOUNT_KICK, lpMsg, Packet, 0);


        Player* pPlayer = sObjectMgr->FindPlayerByAccount(lpMsg->account_id);


        if ( pPlayer )
        {
                KICK_PLAYER(pPlayer, "Administrator Account Kick");
                pPlayer->GetPersonalStore()->Clear();
                pPlayer->CloseSocket();
        }
}


void AuthServer::PlayerAccountOnline(uint8 * Packet)
{
        POINTER_PCT(ACCOUNT_ONLINE, lpMsg, Packet, 0);


        sObjectMgr->AccountOnlineCheck(lpMsg->account);
        sObjectMgr->PersonalStoreDisconnect(lpMsg->account);
}


void AuthServer::AccountCompleteBan(const char * ip, const char * mac, uint32 disk_serial, uint8 type)
{
        if ( !sGameServer->IsDupeCompleteBan() )
        {
                return;
        }


        ACCOUNT_COMPLETE_BAN pMsg;
        pMsg.h.server = sGameServer->GetServerCode();
        memcpy(pMsg.ip, ip, MAX_ACCOUNT_IP_LENGTH);
        memcpy(pMsg.mac, mac, MAX_ACCOUNT_MAC_LENGTH);
        pMsg.disk_serial = disk_serial;
        pMsg.type = type;
        this->SendPacket(MAKE_PCT(pMsg));
}


void AuthServer::AccountCompleteBan(uint8 * Packet)
{
        POINTER_PCT(ACCOUNT_COMPLETE_BAN, lpMsg, Packet, 0);


        PlayerSessionMap const& characters = sObjectMgr->GetAllCharacters();
        for ( PlayerSessionMap::const_iterator it = characters.begin(); it != characters.end(); ++it )
        {
                Player* pPlayer = it->second;


                if ( !pPlayer )
                {
                        continue;
                }


                if ( !memcmp(pPlayer->GetAccountData()->GetIP(), lpMsg->ip, MAX_ACCOUNT_IP_LENGTH) ||
                        !memcmp(pPlayer->GetAccountData()->GetMac(), lpMsg->mac, MAX_ACCOUNT_MAC_LENGTH) ||
                        pPlayer->GetAccountData()->GetDiskSerial() == lpMsg->disk_serial )
                {
                        KICK_PLAYER(pPlayer, std::string("Automatic BAN" + std::to_string(lpMsg->type)));
                }
        }
}


void AuthServer::AccountDuplicate(uint8 * Packet)
{
        POINTER_PCT(SL_ACCOUNT_DUPLICATE, lpMsg, Packet, 0);


        sObjectMgr->KickCharactersByAccount(lpMsg->account_id);
}


void AuthServer::AccountAuthorization(uint32 account_id, bool warning)
{
        SL_ACCOUNT_VALIDATE pMsg(account_id, warning);
        pMsg.h.server = sGameServer->GetServerCode();
        this->SendPacket(MAKE_PCT(pMsg));
}


void AuthServer::HandlePacketData(uint8 headcode, uint8 * packet)
{
    auto itr = Handlers.find(headcode);
    if (itr == Handlers.end())
        return;


        (*sAuthServer.*Handlers.at(headcode).handler)(packet);
}

---

thank you，Can you share the new wings and equipment fixes, as well as the time of the war?

Rooh, poderia fazer pra Source OgocX ? Obrigado !

Citação:

---

Originally Posted by beibei

thank you，Can you share the new wings and equipment fixes, as well as the time of the war?

---

I haven't worked on these fixes yet, could you give me more information?

The display of the wings character interface is different from the display of entering the game, and the game brings wings, and the other character has nothing to see

28 minutes:------- Atualizado -------
@Rooh What other bugs did you fix

23 Dias 8 Horas:------- Atualizado -------

pPlayer->ResultClose(LOGIN_RESULT_ONLINE); @Rooh , How to customize ResultClose