491 lines
14 KiB
C++
491 lines
14 KiB
C++
#include "stdafx.h"
|
|
|
|
#ifdef _NA_008012_20150204_SUN_RANKING_SYSTEM
|
|
|
|
#include <iostream>
|
|
#include "SunRanking.h"
|
|
#include "SunRankingManager.h"
|
|
#include "SunRankingPlayer.h"
|
|
#include "SunRankingParser.h"
|
|
#include "SunRankingGradeManager.h"
|
|
#include "GameBattleResult.h"
|
|
#include "Player.h"
|
|
#include "ServerOptionParserEx.h"
|
|
|
|
SunRankingManager::SunRankingManager()
|
|
{
|
|
Initialize();
|
|
};
|
|
|
|
SunRankingManager::~SunRankingManager()
|
|
{
|
|
Release();
|
|
};
|
|
|
|
void SunRankingManager::Initialize()
|
|
{
|
|
for (eSUN_RANKING_TYPE type = eSUN_RANKING_TYPE_START; type < eSUN_RANKING_TYPE_END; ++type)
|
|
{
|
|
if (m_sun_rankings.find(type) != m_sun_rankings.end())
|
|
{
|
|
continue;
|
|
}
|
|
|
|
m_sun_rankings.insert(std::make_pair(type, new SunRanking()));
|
|
}
|
|
}
|
|
|
|
void SunRankingManager::Release()
|
|
{
|
|
{ // Release SunRankings
|
|
SunRankings::iterator cur_iter = m_sun_rankings.begin();
|
|
SunRankings::iterator end_iter = m_sun_rankings.end();
|
|
for ( ; cur_iter != end_iter; ++cur_iter)
|
|
{
|
|
if (cur_iter->second == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
SAFE_DELETE(cur_iter->second);
|
|
}
|
|
m_sun_rankings.clear();
|
|
}
|
|
|
|
{ // Release SunRankingPlayers
|
|
SunRankingPlayers::iterator cur_iter = m_sun_ranking_players.begin();
|
|
SunRankingPlayers::iterator end_iter = m_sun_ranking_players.end();
|
|
for ( ; cur_iter != end_iter; ++cur_iter)
|
|
{
|
|
if (cur_iter->second == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
destroy(cur_iter->second);
|
|
}
|
|
m_sun_ranking_players.clear();
|
|
}
|
|
}
|
|
|
|
SunRanking* SunRankingManager::_GetSunRanking( eSUN_RANKING_TYPE rank_type )
|
|
{
|
|
SunRankings::const_iterator cur_iter = m_sun_rankings.find(rank_type);
|
|
SunRankings::const_iterator end_iter = m_sun_rankings.end();
|
|
if (cur_iter == end_iter)
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "|[%s]| Invalid rank type (%d)",
|
|
__FUNCTION__, rank_type);
|
|
return NULL;
|
|
}
|
|
|
|
return cur_iter->second;
|
|
}
|
|
|
|
void SunRankingManager::SetGuildGuid( CHARGUID char_guid, GUILDGUID guild_guid )
|
|
{
|
|
if (SunRankingGradeManager::Instance()->GetState() != eSUN_RANKING_STATE_RUN)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SunRankings::iterator cur_iter = m_sun_rankings.begin();
|
|
SunRankings::iterator end_iter = m_sun_rankings.end();
|
|
for ( ; cur_iter != end_iter; ++cur_iter)
|
|
{
|
|
SunRanking* sun_ranking = cur_iter->second;
|
|
if (sun_ranking == NULL)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
sun_ranking->SetGuildGuid(char_guid, guild_guid);
|
|
}
|
|
|
|
SunRankingPlayer* sun_ranking_player = GetSunRankingPlayer(char_guid);
|
|
if (sun_ranking_player == NULL)
|
|
{
|
|
return;
|
|
}
|
|
sun_ranking_player->SetGuildGuid(guild_guid);
|
|
|
|
MSG_DG_SUN_RANKING_UPDATE_CMD msg;
|
|
sun_ranking_player->GetSunRankingPlayerInfo(msg.info);
|
|
g_pGameServer->SendToServer(GAME_DBPROXY, &msg, sizeof(msg));
|
|
}
|
|
|
|
#ifdef _NA_008679_20160202_REWORK_BATTLEGROUND
|
|
VOID SunRankingManager::ProcessBattleGround( const BattleRecorder::Record& record,
|
|
const eBATTLEGROUND_RESULT& result_code, Player* player )
|
|
{
|
|
if (SunRankingGradeManager::Instance()->GetState() != eSUN_RANKING_STATE_RUN)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (CreateSunRankingPlayer(player->GetSunRankingPlayerInfo()) == false)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SunRankingPlayer* sun_ranking_player = GetSunRankingPlayer(player->GetCharGuid());
|
|
if (sun_ranking_player == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (result_code == eBG_RESULT_ABUSE) {
|
|
return;
|
|
}
|
|
|
|
bool is_updated = false;
|
|
|
|
//ų Ä«¿îÆ®
|
|
is_updated = _UpdateSunRanking(sun_ranking_player, eSUN_RANKING_TYPE_BATTLEGROUND_KILL_COUNT,
|
|
record.player_kill_count) || is_updated;
|
|
//½Â¸®
|
|
if (result_code == eBG_RESULT_WIN)
|
|
{
|
|
SCORE* score =
|
|
sun_ranking_player->GetSunRankingScore(eSUN_RANKING_TYPE_BATTLEGROUND_WIN_COUNT);
|
|
is_updated = _UpdateSunRanking(sun_ranking_player, eSUN_RANKING_TYPE_BATTLEGROUND_WIN_COUNT,
|
|
(*score) + 1) || is_updated;
|
|
}
|
|
|
|
if (is_updated == true)
|
|
{
|
|
MSG_DG_SUN_RANKING_UPDATE_CMD msg;
|
|
sun_ranking_player->GetSunRankingPlayerInfo(msg.info);
|
|
g_pGameServer->SendToServer(GAME_DBPROXY, &msg, sizeof(msg));
|
|
}
|
|
}
|
|
#endif //_NA_008679_20160202_REWORK_BATTLEGROUND
|
|
|
|
void SunRankingManager::ProcessBattleZone( const BattleRecorder::Record& record, Player* player )
|
|
{
|
|
if (SunRankingGradeManager::Instance()->GetState() != eSUN_RANKING_STATE_RUN)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (CreateSunRankingPlayer(player->GetSunRankingPlayerInfo()) == false)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SunRankingPlayer* sun_ranking_player = GetSunRankingPlayer(player->GetCharGuid());
|
|
if (sun_ranking_player == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool is_updated = false;
|
|
is_updated = _UpdateSunRanking(sun_ranking_player, eSUN_RANKING_TYPE_STRONG_ONE_SHOT,
|
|
record.max_damage_to_enemy) || is_updated;
|
|
is_updated = _UpdateSunRanking(sun_ranking_player, eSUN_RANKING_TYPE_BEST_ATTACKER,
|
|
record.total_damage_to_enemy) || is_updated;
|
|
is_updated = _UpdateSunRanking(sun_ranking_player, eSUN_RANKING_TYPE_MASTER_OF_HEAL,
|
|
record.total_heal_to_party) || is_updated;
|
|
|
|
if (is_updated == true)
|
|
{
|
|
_UpdateSunRanking(sun_ranking_player, eSUN_RANKING_TYPE_BEST_OF_BEST, sun_ranking_player->GetBestOfBestScore());
|
|
|
|
MSG_DG_SUN_RANKING_UPDATE_CMD msg;
|
|
sun_ranking_player->GetSunRankingPlayerInfo(msg.info);
|
|
g_pGameServer->SendToServer(GAME_DBPROXY, &msg, sizeof(msg));
|
|
}
|
|
}
|
|
|
|
void SunRankingManager::ProcessDisconnect( Player* player )
|
|
{
|
|
if (SunRankingGradeManager::Instance()->GetState() != eSUN_RANKING_STATE_RUN)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (CreateSunRankingPlayer(player->GetSunRankingPlayerInfo()) == false)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SunRankingPlayer* sun_ranking_player = GetSunRankingPlayer(player->GetCharGuid());
|
|
if (sun_ranking_player == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool is_updated = false;
|
|
is_updated = _UpdateSunRanking(sun_ranking_player, eSUN_RANKING_TYPE_LEVEL_KING,
|
|
player->GetExp()) || is_updated;
|
|
|
|
int total_equipment_score = 0;
|
|
if (player->GetTotalEquipmentScore(total_equipment_score) == true)
|
|
{
|
|
is_updated = _UpdateSunRanking(sun_ranking_player, eSUN_RANKING_TYPE_LEGEND_EQUIP,
|
|
total_equipment_score) || is_updated;
|
|
}
|
|
|
|
if (is_updated == true)
|
|
{
|
|
_UpdateSunRanking(sun_ranking_player, eSUN_RANKING_TYPE_BEST_OF_BEST, sun_ranking_player->GetBestOfBestScore());
|
|
|
|
MSG_DG_SUN_RANKING_UPDATE_CMD msg;
|
|
sun_ranking_player->GetSunRankingPlayerInfo(msg.info);
|
|
g_pGameServer->SendToServer(GAME_DBPROXY, &msg, sizeof(msg));
|
|
}
|
|
}
|
|
|
|
void SunRankingManager::ProcessPvp( CHARGUID char_guid, SCORE score )
|
|
{
|
|
if (SunRankingGradeManager::Instance()->GetState() != eSUN_RANKING_STATE_RUN)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SunRankingPlayer* sun_ranking_player = GetSunRankingPlayer(char_guid);
|
|
if (sun_ranking_player == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SCORE* cur_pvp_count = sun_ranking_player->GetSunRankingScore(eSUN_RANKING_TYPE_ELETE_WARRIOR);
|
|
if (cur_pvp_count == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool is_updated = false;
|
|
is_updated = _UpdateSunRanking(sun_ranking_player, eSUN_RANKING_TYPE_ELETE_WARRIOR,
|
|
*cur_pvp_count + score) || is_updated;
|
|
|
|
if (is_updated == true)
|
|
{
|
|
_UpdateSunRanking(sun_ranking_player, eSUN_RANKING_TYPE_BEST_OF_BEST, sun_ranking_player->GetBestOfBestScore());
|
|
|
|
MSG_DG_SUN_RANKING_UPDATE_CMD msg;
|
|
sun_ranking_player->GetSunRankingPlayerInfo(msg.info);
|
|
g_pGameServer->SendToServer(GAME_DBPROXY, &msg, sizeof(msg));
|
|
}
|
|
}
|
|
|
|
bool SunRankingManager::CreateSunRankingPlayer( SunRankingPlayerInfo& info )
|
|
{
|
|
SunRankingPlayers::iterator find_iter = m_sun_ranking_players.find(info.char_guid);
|
|
if (find_iter != m_sun_ranking_players.end())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
SunRankingPlayer* sun_ranking_player = construct();
|
|
if (m_sun_ranking_players.insert(std::make_pair(info.char_guid, sun_ranking_player)).second == false)
|
|
{
|
|
destroy(sun_ranking_player);
|
|
SUNLOG(eCRITICAL_LOG, "|[%s]| insert failed(%d)", __FUNCTION__, info.char_guid);
|
|
return false;
|
|
}
|
|
|
|
sun_ranking_player->Initialize(info);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool SunRankingManager::_UpdateSunRanking( SunRankingPlayer* sun_ranking_player, eSUN_RANKING_TYPE ranking_type, SCORE score )
|
|
{
|
|
if (sun_ranking_player == NULL)
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "|[%s]| Player is null(rank type : %d)",
|
|
__FUNCTION__, ranking_type);
|
|
return false;
|
|
}
|
|
|
|
SCORE* current_score = sun_ranking_player->GetSunRankingScore(ranking_type);
|
|
if (current_score == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (*current_score == score)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (eSUN_RANKING_TYPE_LEGEND_EQUIP != ranking_type
|
|
&& eSUN_RANKING_TYPE_BEST_OF_BEST != ranking_type)
|
|
{
|
|
if (score <= 0 || *current_score >= score)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
SunRanking* sun_ranking = _GetSunRanking(ranking_type);
|
|
if (sun_ranking == NULL)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if(sun_ranking->UpdateScore(sun_ranking_player->GetCharGuid(), sun_ranking_player->GetGuildGuid(), score) == true)
|
|
{
|
|
*current_score = score;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
SunRankingPlayer* SunRankingManager::GetSunRankingPlayer( CHARGUID char_guid )
|
|
{
|
|
SunRankingPlayers::iterator find_iter = m_sun_ranking_players.find(char_guid);
|
|
if (find_iter == m_sun_ranking_players.end())
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "|[%s]| can't find sunrankingplayer(%d)",
|
|
__FUNCTION__, char_guid);
|
|
return NULL;
|
|
}
|
|
|
|
return find_iter->second;
|
|
}
|
|
|
|
void SunRankingManager::UpdateFromSunRankingPlayer( SunRankingPlayerInfo& info )
|
|
{
|
|
if (CreateSunRankingPlayer(info) == false)
|
|
{
|
|
return;
|
|
}
|
|
|
|
SunRankingPlayer* sun_ranking_player = GetSunRankingPlayer(info.char_guid);
|
|
if (sun_ranking_player == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
for (eSUN_RANKING_TYPE type = eSUN_RANKING_TYPE_START; type < eSUN_RANKING_TYPE_END; ++type)
|
|
{
|
|
_UpdateSunRanking(sun_ranking_player, type, info.score[type]);
|
|
}
|
|
|
|
sun_ranking_player->SetGuildGuid(info.guild_guid);
|
|
}
|
|
|
|
RC::eSUN_RANKING_RESULT SunRankingManager::GetSunRankingInfos( MSG_CG_ETC_SUN_RANKING_ACK& msg, eSUN_RANKING_TYPE ranking_type, CHARGUID char_guid, int rank_count, bool is_guild_ranking, GUILDGUID guild_guid )
|
|
{
|
|
if (SunRankingGradeManager::Instance()->GetState() != eSUN_RANKING_STATE_RUN)
|
|
{
|
|
return RC::RC_SUN_RANKING_SETTLE;
|
|
}
|
|
|
|
SunRanking* sun_ranking = _GetSunRanking(ranking_type);
|
|
if (sun_ranking == NULL)
|
|
{
|
|
return RC::RC_SUN_RANKING_INVALID_RANKING_TYPE;
|
|
}
|
|
|
|
msg.my_score = sun_ranking->GetScore(char_guid);
|
|
|
|
RANKINGINFOS infos;
|
|
if (is_guild_ranking == true)
|
|
{
|
|
sun_ranking->GetGuildRanking(guild_guid, rank_count, infos);
|
|
msg.my_ranking = sun_ranking->GetGuildRanking(msg.my_score, guild_guid);
|
|
}
|
|
else
|
|
{
|
|
sun_ranking->GetRanking(rank_count, infos);
|
|
msg.my_ranking = sun_ranking->GetRanking(msg.my_score);
|
|
}
|
|
|
|
RANKINGINFOS::iterator cur_iter = infos.begin();
|
|
RANKINGINFOS::iterator end_iter = infos.end();
|
|
int count = 0;
|
|
for (; cur_iter != end_iter; ++cur_iter, ++count)
|
|
{
|
|
if (MSG_CG_ETC_SUN_RANKING_ACK::MAX_INFO_COUNT <= count)
|
|
{
|
|
break;
|
|
}
|
|
const SunRankingInfo* const temp = *cur_iter;
|
|
|
|
SunRankingInfoForClient& temp_info = msg.infos[count];
|
|
|
|
SunRankingPlayer* ranking_player = GetSunRankingPlayer(temp->char_guid);
|
|
if (ranking_player != NULL)
|
|
{
|
|
temp_info.class_code = ranking_player->GetCharClass();
|
|
temp_info.char_name;
|
|
strncpy(temp_info.char_name, ranking_player->GetCharName(), MAX_CHARNAME_LENGTH);
|
|
temp_info.score = temp->score;
|
|
}
|
|
}
|
|
|
|
return RC::RC_SUN_RANKING_SUCCESS;
|
|
}
|
|
|
|
void SunRankingManager::GetTopRankerEquipmentScore(SCORE& score, CHARGUID& char_guid)
|
|
{
|
|
score = 0;
|
|
char_guid = 0;
|
|
SunRanking* sun_ranking_bob = _GetSunRanking(eSUN_RANKING_TYPE_BEST_OF_BEST);
|
|
if (sun_ranking_bob == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
RANKINGINFOS infos;
|
|
sun_ranking_bob->GetRanking(1, infos);
|
|
if (infos.empty() == true)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const SunRankingInfo* const temp = *infos.begin();
|
|
if (infos.size() <= 0 || infos.begin() == infos.end())
|
|
{
|
|
return;
|
|
}
|
|
|
|
char_guid = temp->char_guid;
|
|
|
|
SunRanking* sun_ranking_equip = _GetSunRanking(eSUN_RANKING_TYPE_LEGEND_EQUIP);
|
|
if (sun_ranking_equip == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
score = sun_ranking_equip->GetScore(temp->char_guid);
|
|
}
|
|
|
|
RC::eSUN_RANKING_RESULT SunRankingManager::GetRanking( eSUN_RANKING_TYPE ranking_type, CHARGUID char_guid, int& rank )
|
|
{
|
|
SunRanking* sun_ranking = _GetSunRanking(ranking_type);
|
|
if (sun_ranking == NULL)
|
|
{
|
|
return RC::RC_SUN_RANKING_INVALID_RANKING_TYPE;
|
|
}
|
|
|
|
SCORE my_score = sun_ranking->GetScore(char_guid);
|
|
|
|
rank = sun_ranking->GetRanking(my_score);
|
|
|
|
return RC::RC_SUN_RANKING_SUCCESS;
|
|
}
|
|
|
|
void SunRankingManager::Display()
|
|
{
|
|
static const int MAX_RANKING_STATE_STR = 64;
|
|
|
|
SUNLOG(eCRITICAL_LOG, "[SunRanking] - SunRanking Count : %d", m_sun_rankings.size());
|
|
|
|
for (eSUN_RANKING_TYPE type = eSUN_RANKING_TYPE_START; type < eSUN_RANKING_TYPE_END; ++type)
|
|
{
|
|
SunRanking* sun_ranking = _GetSunRanking(type);
|
|
if (sun_ranking == NULL)
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "[SunRanking] - Rank Type(%d) is null", type);
|
|
}
|
|
else
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "[SunRanking] - Rank Type(%d) Count(%d)", type, sun_ranking->GetSize());
|
|
}
|
|
}
|
|
|
|
SUNLOG(eCRITICAL_LOG, "[SunRanking] - SunRankingPlayer Count : %d", m_sun_ranking_players.size());
|
|
}
|
|
|
|
#endif // _NA_008012_20150204_SUN_RANKING_SYSTEM
|