816 lines
25 KiB
C++
816 lines
25 KiB
C++
#include "StdAfx.h"
|
|
|
|
#include "NewGameParty.h"
|
|
#include "NewGamePartyManager.h"
|
|
#include "Player.h"
|
|
#include "PlayerManager.h"
|
|
#include "GamePartyOperator.h"
|
|
#include "GameRoom.h"
|
|
#include ".\FriendInvitation\GFriendInvitationController.h" //친구 초대 이벤트
|
|
|
|
//_NA_20110630_BATTLE_ZONE_RENEWAL
|
|
#include "SlotManager.h"
|
|
#include "ItemManager.h"
|
|
#include "BattlezoneMissionTreeParser.h"
|
|
#include "MapInfoParser.h"
|
|
#include "MissionManager.h"
|
|
|
|
NewGamePartyManager::NewGamePartyManager()
|
|
{
|
|
}
|
|
|
|
|
|
NewGamePartyManager::~NewGamePartyManager()
|
|
{
|
|
}
|
|
|
|
RC::ePARTY_RESULT
|
|
NewGamePartyManager::CanRequestParty(DWORD request_member_key, DWORD recv_member_key)
|
|
{
|
|
PlayerManager* player_manager = PlayerManager::Instance();
|
|
|
|
Player* request_player = player_manager->FindPlayerByObjKey(request_member_key);
|
|
Player* recv_player = player_manager->FindPlayerByObjKey(recv_member_key);
|
|
if (request_player == NULL || recv_player == NULL)
|
|
{
|
|
return RC::RC_PARTY_PLAYER_NOTEXIST_TO_FIELD;
|
|
}
|
|
|
|
CHARGUID request_guild_guid = request_player->GetGuildGuid();
|
|
CHARGUID recv_guild_guid = recv_player->GetGuildGuid();
|
|
|
|
if (GuildSmallContentEntry::RelationSystem::GetRelationType(
|
|
request_guild_guid, recv_guild_guid) >= eGUILD_RELATION_BOTH_HOSTILITY)
|
|
{
|
|
return RC::RC_PARTY_CANNOT_INVITE_HOSTILITY;
|
|
}
|
|
|
|
if (IsExistHostilityMember(request_player->GetPartyState().GetPartyKey(), recv_guild_guid))
|
|
{
|
|
return RC::RC_PARTY_CANNOT_INVITE_HOSTILITY;
|
|
}
|
|
|
|
return RC::RC_PARTY_SUCCESS;
|
|
}
|
|
|
|
|
|
void
|
|
NewGamePartyManager::Initialize(DWORD partyPoolSize)
|
|
{
|
|
party_pool_router_.Register<NewGameParty>(ePARTY_FIELD);
|
|
party_pool_router_.Initialize(ePARTY_FIELD, partyPoolSize, partyPoolSize/4);
|
|
//_NA_20110630_BATTLE_ZONE_RENEWAL
|
|
party_pool_router_.Register<NewGameParty>(ePARTY_ROOM);
|
|
party_pool_router_.Initialize(ePARTY_ROOM, partyPoolSize, partyPoolSize/4);
|
|
|
|
//_NA_005026_20120527_CHAOS_ZONE_BATTLE_GROUND
|
|
party_pool_router_.Register<NewGameParty>(ePARTY_INSTANCE);
|
|
party_pool_router_.Initialize(ePARTY_INSTANCE, partyPoolSize, partyPoolSize/4);
|
|
m_UpdateTimer.SetTimer(300); //__NA001336_090514_PARTY_NAVI_SUPPORT__
|
|
}
|
|
|
|
void
|
|
NewGamePartyManager::DestroyAllParty()
|
|
{
|
|
GameMemberOperator<> Opr;
|
|
PARTY_MAP::iterator it = party_map_.begin(),
|
|
end = party_map_.end();
|
|
while(it != end)
|
|
{
|
|
Opr.Init(eGAMEPARTY_OPERATOR_INIT, 0);
|
|
NewGameParty* pNewGameParty = static_cast<NewGameParty*>(it->second);
|
|
pNewGameParty->For_eachMembers(Opr);
|
|
|
|
BaseParty* pBaseParty = it->second;
|
|
const ePARTY_TYPE party_type = pBaseParty->GetType();
|
|
pBaseParty->Release();
|
|
|
|
party_pool_router_.Free(party_type, pBaseParty);
|
|
|
|
party_map_.erase(it++);
|
|
}
|
|
}
|
|
|
|
void
|
|
NewGamePartyManager::CreateGameParty(WORD partyKey, DWORD masterKey,
|
|
eITEM_DISTRIBUTION_TYPE type, ePARTY_TYPE partyType)
|
|
{
|
|
BaseParty* pBaseParty = BasePartyManager::CreateParty(partyType, partyKey, masterKey);
|
|
|
|
if(!pBaseParty)
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "[CreateGameParty] Can't Create GameParty[%u]", partyKey);
|
|
return;
|
|
}
|
|
|
|
pBaseParty->SetDistributionType(type);
|
|
}
|
|
|
|
void
|
|
NewGamePartyManager::DestroyGameParty(WORD party_key)
|
|
{
|
|
BaseParty* base_party = FindEditableParty(party_key);
|
|
if (base_party == NULL)
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, __FUNCTION__" : Not found party : %u", party_key);
|
|
return;
|
|
}
|
|
|
|
static GameMemberOperator<> Opr;
|
|
Opr.Init(eGAMEPARTY_OPERATOR_INIT, 0);
|
|
base_party->For_eachMembers(Opr);
|
|
|
|
BasePartyManager::DestroyParty(party_key);
|
|
}
|
|
|
|
void
|
|
NewGamePartyManager::JoinGameParty(WORD party_key,
|
|
const _PARTY_MEMBER_INFO& join_member_info,
|
|
bool is_master)
|
|
{
|
|
RC::ePARTY_RESULT rcResult = BasePartyManager::JoinParty(party_key, join_member_info);
|
|
if(rcResult != RC::RC_PARTY_SUCCESS)
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, __FUNCTION__" : Fail join party : %u : %u", party_key, rcResult);
|
|
return;
|
|
}
|
|
|
|
Player* player = PlayerManager::Instance()->FindPlayerByObjKey(join_member_info.m_dwMemberKey);
|
|
if (player)
|
|
{
|
|
player->GetPartyState().JoinParty(0, party_key);
|
|
GFriendInvitationController::Instance()->OnParty_Join(party_key,
|
|
join_member_info.m_dwMemberKey);
|
|
}
|
|
}
|
|
|
|
void
|
|
NewGamePartyManager::LeaveGameParty(WORD party_key, DWORD member_key)
|
|
{
|
|
RC::ePARTY_RESULT result_code = BasePartyManager::LeaveParty(party_key, member_key);
|
|
if (result_code != RC::RC_PARTY_SUCCESS)
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, __FUNCTION__" : Fail leave party : %u : %u", party_key, result_code);
|
|
return;
|
|
}
|
|
|
|
Player* player = PlayerManager::Instance()->FindPlayerByObjKey(member_key);
|
|
if(player)
|
|
{
|
|
GFriendInvitationController::Instance()->OnParty_Leave(party_key, member_key);
|
|
player->GetPartyState().Init();
|
|
}
|
|
}
|
|
|
|
void
|
|
NewGamePartyManager::ChangeGameMaster(WORD partyKey, DWORD nextMasterKey)
|
|
{
|
|
RC::ePARTY_RESULT rcResult = BasePartyManager::ChangeMaster(partyKey, nextMasterKey);
|
|
if(rcResult != RC::RC_PARTY_SUCCESS)
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "[ChangeMaster] Fail ChangeMaster[%u]! ErrorCode[%u]",
|
|
partyKey, rcResult);
|
|
return;
|
|
}
|
|
|
|
//{__NA1335_090407_PORTAL_MISSION_ROOM_CONSTRAINTS__
|
|
Player* pPlayer = PlayerManager::Instance()->FindPlayerByObjKey(nextMasterKey);
|
|
GameZone* pGameZone = 0;
|
|
if(pPlayer == 0 || !(pGameZone = pPlayer->GetGameZonePtr()))
|
|
return;
|
|
eZONETYPE zoneType = pGameZone->GetZoneType();
|
|
if(zoneType == eZONETYPE_MISSION || zoneType == eZONETYPE_INSTANCE)
|
|
static_cast<GameRoom*>(pGameZone)->ChangeMaster(pPlayer->GetUserKey());
|
|
//}
|
|
}
|
|
|
|
void
|
|
NewGamePartyManager::ChangeItemDistributionType(WORD partyKey, eITEM_DISTRIBUTION_TYPE type)
|
|
{
|
|
BaseParty* pBaseParty = FindEditableParty(partyKey);
|
|
if(!pBaseParty)
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "[ChangeItemDistributionType] Can't Find GameParty[%u]", partyKey);
|
|
return;
|
|
}
|
|
|
|
if(type >= eITEM_DISTRIBUTION_MAX)
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, "[ChangeItemDistributionType] Invalid DistributionType[%u]", type);
|
|
return;
|
|
}
|
|
|
|
pBaseParty->SetDistributionType(type);
|
|
}
|
|
|
|
void
|
|
NewGamePartyManager::MemberLevelUp(WORD partyKey, DWORD memberKey)
|
|
{
|
|
NewGameParty* pNewGameParty = (NewGameParty*)FindEditableParty(partyKey);
|
|
if(!pNewGameParty)
|
|
{
|
|
if(partyKey)
|
|
SUNLOG(eCRITICAL_LOG, "[MemberLevelUp] Can't Find GameParty[%u]", partyKey);
|
|
return;
|
|
}
|
|
|
|
pNewGameParty->MemberLevelUp(memberKey);
|
|
}
|
|
|
|
void
|
|
NewGamePartyManager::GetAreaLivePartyInfo(WORD partyKey, ZONEKEY zoneKey,
|
|
const WzVector* pNpcPos, BYTE byRadius,
|
|
OUT WORD& totalNum, OUT LEVELTYPE& totalLevel)
|
|
{
|
|
NewGameParty* pNewGameParty = (NewGameParty*)FindEditableParty(partyKey);
|
|
if(pNewGameParty == 0)
|
|
return;
|
|
|
|
totalNum = 0;
|
|
totalLevel = 0;
|
|
|
|
if(pNpcPos == NULL || byRadius == 0)
|
|
return;
|
|
|
|
static GameMemberOperator<> Opr;
|
|
Opr.Init(eGAMEPARTY_OPERATOR_AREA_LIVE_PARTYINFO, 0);
|
|
Opr.SetAreaInfo(zoneKey, pNpcPos, byRadius);
|
|
pNewGameParty->For_eachMembers(Opr);
|
|
|
|
Opr.GetAreaInfo(totalNum, totalLevel);
|
|
}
|
|
|
|
void
|
|
NewGamePartyManager::AddExpToAllMember(WORD partyKey, EXPTYPE Exp)
|
|
{
|
|
NewGameParty* pNewGameParty = (NewGameParty*)FindEditableParty(partyKey);
|
|
if(!pNewGameParty) return;
|
|
|
|
static GameMemberOperator<> Opr;
|
|
Opr.Init(eGAMEPARTY_OPERATOR_ADD_EXP, 0);
|
|
Opr.SetExp(Exp);
|
|
|
|
pNewGameParty->For_eachMembers(Opr);
|
|
}
|
|
|
|
BOOL
|
|
NewGamePartyManager::IsMaster(Player* pPlayer)
|
|
{
|
|
NewGameParty* pNewGameParty = (NewGameParty*)FindEditableParty(pPlayer->GetPartyState().GetPartyKey());
|
|
if(!pNewGameParty)
|
|
return FALSE;
|
|
|
|
return pNewGameParty->GetMasterKey() == pPlayer->GetObjectKey() ? TRUE : FALSE;
|
|
}
|
|
|
|
Player*
|
|
NewGamePartyManager::FindMasterPlayer(WORD partyKey)
|
|
{
|
|
NewGameParty* pNewGameParty = (NewGameParty*)FindEditableParty(partyKey);
|
|
if(pNewGameParty == 0)
|
|
return NULL;
|
|
|
|
Player* pMaster = PlayerManager::Instance()->FindPlayerByObjKey(pNewGameParty->GetMasterKey());
|
|
|
|
return pMaster;
|
|
}
|
|
|
|
Player*
|
|
NewGamePartyManager::FindMemberPlayer(WORD partyKey, DWORD memberKey)
|
|
{
|
|
NewGameParty* pNewGameParty = (NewGameParty*)FindEditableParty(partyKey);
|
|
if(pNewGameParty == 0)
|
|
return NULL;
|
|
|
|
Player* pMember = PlayerManager::Instance()->FindPlayerByObjKey(memberKey);
|
|
|
|
return pMember;
|
|
}
|
|
|
|
BYTE
|
|
NewGamePartyManager::GetDistributionType(WORD partyKey)
|
|
{
|
|
NewGameParty* pNewGameParty = (NewGameParty*)FindEditableParty(partyKey);
|
|
if(pNewGameParty == 0)
|
|
return NULL;
|
|
|
|
return pNewGameParty->GetDistributionType();
|
|
}
|
|
|
|
BOOL
|
|
NewGamePartyManager::IsExistHostilityMember(WORD party_key, DWORD hostility_guild_guid)
|
|
{
|
|
NewGameParty* new_game_party = (NewGameParty*)FindEditableParty(party_key);
|
|
if (new_game_party == NULL)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
static GameMemberOperator<> Opr;
|
|
|
|
Opr.Init(eGAMEPARTY_OPERATOR_HOSTILITY_CHECK, 0);
|
|
Opr.SetHostilityGuildGuid(hostility_guild_guid);
|
|
|
|
new_game_party->For_eachMembers(Opr);
|
|
|
|
return Opr.IsExistHostilityMember();
|
|
}
|
|
|
|
DWORD
|
|
NewGamePartyManager::GetDistributionMemberKey(WORD party_key, DWORD defaultOwnerKey, eCHAR_TYPE classType)
|
|
{
|
|
NewGameParty* pNewGameParty = (NewGameParty*)FindEditableParty(party_key);
|
|
if(pNewGameParty == 0)
|
|
return defaultOwnerKey;
|
|
|
|
eITEM_DISTRIBUTION_TYPE type = (eITEM_DISTRIBUTION_TYPE)pNewGameParty->GetDistributionType();
|
|
switch(type)
|
|
{
|
|
case eITEM_DISTRIBUTION_DEFAULT: return defaultOwnerKey;
|
|
case eITEM_DISTRIBUTION_FIFO_PRIORITY: return pNewGameParty->GetFIFOMemberKey();
|
|
case eITEM_DISTRIBUTION_MASTER_PRIORITY: return pNewGameParty->GetMasterKey();
|
|
case eITEM_DISTRIBUTION_RANDOM: return pNewGameParty->GetRandomMemberKey();
|
|
case eITEM_DISTRIBUTION_CLASS_PRIORITY: return pNewGameParty->GetRandomMemberKey(classType);
|
|
#ifdef _NA_003033_20110831_DICECAST_ITEM_ROUTING
|
|
case eITEM_DISTRIBUTION_DICE_AND_FIFO: return pNewGameParty->GetFIFOMemberKey();
|
|
case eITEM_DISTRIBUTION_DICE_AND_DEFAULT: return defaultOwnerKey;
|
|
#endif //_NA_003033_20110831_DICECAST_ITEM_ROUTING
|
|
default:
|
|
SUNLOG(eCRITICAL_LOG, "[GetDistributionMemberKey] Invalid DistributionType[%u]", type);
|
|
}
|
|
|
|
return defaultOwnerKey;
|
|
}
|
|
|
|
DWORD
|
|
NewGamePartyManager::GetValidReferencePlayerKeyForReturn(WORD party_key)
|
|
{
|
|
NewGameParty* pGameParty = (NewGameParty*)FindEditableParty(party_key);
|
|
if(pGameParty == 0)
|
|
return FALSE;
|
|
|
|
static GameMemberOperator<> Opr;
|
|
Opr.Init(eGAMEPARTY_OPERATOR_VALID_PLAYER_INFO_FOR_PARTY_RETURN, 0);
|
|
pGameParty->For_eachMembers(Opr);
|
|
DWORD playerKey = Opr.GetFirstValidPlayerForPartyReturn();
|
|
return playerKey;
|
|
}
|
|
|
|
void
|
|
NewGamePartyManager::GetEnterRoomConditionInfoCollect(GameMemberEnterConditonOperator& oper,
|
|
Player* pRequester)
|
|
{
|
|
const WORD partyKey = pRequester->GetPartyState().GetPartyKey();
|
|
BaseParty* pParty = NULL;
|
|
if(partyKey && (pParty = FindEditableParty(partyKey)))
|
|
pParty->For_eachMembers(oper);
|
|
else
|
|
oper(pRequester, pRequester->GetObjectKey());
|
|
}
|
|
|
|
BOOL
|
|
NewGamePartyManager::SendPacketAllMember(WORD partyKey, MSG_BASE* pMsg, WORD wSize, DWORD exceptKey)
|
|
{
|
|
NewGameParty* pNewGameParty = (NewGameParty*)FindEditableParty(partyKey);
|
|
if(pNewGameParty == 0)
|
|
return FALSE;
|
|
|
|
static GameMemberOperator<> Opr;
|
|
Opr.Init(eGAMEPARTY_OPERATOR_SEND, exceptKey);
|
|
Opr.SetSendPacket(pMsg, wSize);
|
|
|
|
pNewGameParty->For_eachMembers(Opr);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void
|
|
NewGamePartyManager::Display()
|
|
{
|
|
DWORD dwMemberZeroCount = 0;
|
|
|
|
PARTY_MAP::iterator end(party_map_.end());
|
|
for(PARTY_MAP::iterator it = party_map_.begin(); it != end; ++it)
|
|
{
|
|
NewGameParty* pNewGameParty = (NewGameParty*)it->second;
|
|
|
|
if(!pNewGameParty->GetMemberNum())
|
|
++dwMemberZeroCount;
|
|
}
|
|
|
|
// 파티원이 0인 파티 수, 전체 파티 개수, 파티에 소속된 전체 멤버수
|
|
SUNLOG(eCRITICAL_LOG, "TotPartyNum[%d] MemberZeroPartyNum[%d]",
|
|
party_map_.size(), dwMemberZeroCount);
|
|
}
|
|
|
|
void
|
|
NewGamePartyManager::Update()
|
|
{
|
|
BOOLEAN isExpired = !!m_UpdateTimer.IsExpired();
|
|
if(isExpired == 0)
|
|
return;
|
|
|
|
FOREACH_CONTAINER(const PARTY_MAP::value_type& rParty, party_map_, PARTY_MAP)
|
|
{
|
|
NewGameParty* pGameParty = static_cast<NewGameParty*>(rParty.second);
|
|
pGameParty->Update();
|
|
}
|
|
}
|
|
|
|
//_NA_20110630_BATTLE_ZONE_RENEWAL
|
|
BYTE
|
|
NewGamePartyManager::GetMemberConditionForEnterRoom(CheckMemberConditionToEnterRoomOperator& oper,
|
|
WORD check_party_key)
|
|
{
|
|
BaseParty* base_party = NULL;
|
|
if (!check_party_key || !(base_party = FindEditableParty(check_party_key)))
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, __FUNCTION__" : Not found party : %d", check_party_key);
|
|
return 0;
|
|
}
|
|
|
|
base_party->For_eachMembers(oper);
|
|
|
|
return static_cast<BYTE>(base_party->GetMemberNum());
|
|
}
|
|
|
|
BYTE
|
|
NewGamePartyManager::GetMemberConditionForChangeOption(CheckMemberConditionToChangeOptionOperator& oper,
|
|
WORD change_party_key)
|
|
{
|
|
BaseParty* base_party = NULL;
|
|
if (!change_party_key || !(base_party = FindEditableParty(change_party_key)))
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, __FUNCTION__" : Not found party : %d", change_party_key);
|
|
return 0;
|
|
}
|
|
|
|
base_party->For_eachMembers(oper);
|
|
|
|
return static_cast<BYTE>(base_party->GetMemberNum());
|
|
}
|
|
|
|
bool
|
|
NewGamePartyManager::RemoveMissionItem(Player* master_player,
|
|
SLOTCODE item_code,
|
|
BYTE item_num)
|
|
{
|
|
if (item_code == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
ItemManager* item_manager = master_player->GetItemManager();
|
|
POSTYPE num = static_cast<POSTYPE>(item_num);
|
|
SCItemSlot deleted_item_slot;
|
|
MSG_CG_ITEM_LOSE_ACK ack_msg;
|
|
{
|
|
RC::eITEM_RESULT result_value = item_manager->DeleteAllKindOfItem( \
|
|
1, &item_code, &num, &(ack_msg.m_ItemInfo), &deleted_item_slot);
|
|
|
|
if (result_value != RC::RC_ITEM_SUCCESS)
|
|
{
|
|
SUNLOG(eCRITICAL_LOG,
|
|
__FUNCTION__" : Fail Delete item : %d",
|
|
master_player->GetCharGuid());
|
|
return false;
|
|
}
|
|
//배틀존 미션, 저탑, 이벤트 방 생성시 소모되는 아이템 로그
|
|
GAMELOG->LogItem(ITEM_USE, master_player, &deleted_item_slot, 0, item_num);
|
|
}
|
|
master_player->SendPacket(&ack_msg, ack_msg.GetSize());
|
|
return true;
|
|
}
|
|
|
|
RC::ePARTY_RESULT
|
|
NewGamePartyManager::SetMemberReadyState(Player* player, WORD party_key, bool ready_state)
|
|
{
|
|
MissionManager* mission_manager = player->GetMissionManager();
|
|
if (mission_manager->EnableWindowOpen() == true)
|
|
{
|
|
return RC::RC_PARTY_NOT_MISSION_REWARD;
|
|
}
|
|
|
|
NewGameParty* party = static_cast<NewGameParty*>(FindEditableParty(party_key));
|
|
if (party == NULL)
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, __FUNCTION__" : Not found party : %d", party_key);
|
|
return RC::RC_PARTY_NOT_EXIST_PARTY;
|
|
}
|
|
|
|
party->SetMemeberReadyState(player->GetObjectKey(), ready_state);
|
|
|
|
return RC::RC_PARTY_SUCCESS;
|
|
}
|
|
|
|
void
|
|
NewGamePartyManager::ResetMemberReadyState(WORD party_key)
|
|
{
|
|
NewGameParty* party = static_cast<NewGameParty*>(FindEditableParty(party_key));
|
|
if (party == NULL)
|
|
{
|
|
SUNLOG(eCRITICAL_LOG, __FUNCTION__" : Not found party : %d", party_key);
|
|
return;
|
|
}
|
|
|
|
party->ResetReadyStateAllMember();
|
|
return;
|
|
}
|
|
|
|
//gamelulu's note : 현재 상황에서의 RoomType별 모든 건을 다루다 보니 인자수가 많아진 상태이며
|
|
//앞으로 추가 될 수도 있는 인자가 존재할 가능성도 많다.
|
|
//각 RoomType별 객체에 방을 생성 할 수 있는지 조건 채크에 관한 로직을 추가하여 아래와 같은 함수
|
|
//생성을 막는 편이 좋을 것 같다. (2011.09.16)
|
|
RC::ePARTY_RESULT
|
|
NewGamePartyManager::CheckRoomTerms(Player* player, SLOTCODE item_code, BYTE item_num,
|
|
PartyZoneType party_room_type, MAPCODE map_code)
|
|
{
|
|
BattlezoneMissionTreeParser* const parser = BattlezoneMissionTreeParser::Instance();
|
|
|
|
//step 1 : 아이템이 필요한 미션인지 체크
|
|
if (parser->IsMissionOfRequireItem(map_code, party_room_type) == true)
|
|
{
|
|
//step 2 : 전달된 아이템이 해당 미션에 필요한 아이템인지 검사
|
|
if (parser->IsMissionItem(map_code, party_room_type, item_code) == false)
|
|
{
|
|
return RC::RC_PARTY_INVALID_ITEM;
|
|
}
|
|
|
|
//stemp 3 : 전달된 아이템을 유저가 소유하고 있는지 검사
|
|
#ifdef _NA_007734_20141027_ADD_ROOMKIND_SPECIALMISSION
|
|
RC::ePARTY_RESULT result_code = ExistPartyRoomItem(player, item_code, item_num, party_room_type);
|
|
#else
|
|
RC::ePARTY_RESULT result_code = ExistPartyRoomItem(player, item_code, item_num);
|
|
#endif //_NA_007734_20141027_ADD_ROOMKIND_SPECIALMISSION
|
|
if (result_code != RC::RC_PARTY_SUCCESS)
|
|
{
|
|
return result_code;
|
|
}
|
|
}
|
|
|
|
switch (parser->GetZoneType(map_code))
|
|
{
|
|
case eZONETYPE_INSTANCE:
|
|
{
|
|
const sMAPINFO* const map_info = MapInfoParser::Instance()->FindMapInfo(map_code);
|
|
if (map_info == NULL)
|
|
{
|
|
return RC::RC_PARTY_NOT_INCORRECT_MAPCODE;
|
|
}
|
|
|
|
const eZONE_RULESET& ruleset = map_info->Ruleset;
|
|
if (ruleset.rules & ruleset.ZONE_RULE_INDUN_CANT_EQUIP_WEAPON_AND_BLOCK)
|
|
{
|
|
const BASE_ITEMINFO* const equip_info =
|
|
player->GetEquipItemInfo(eEQUIPCONTAINER_WEAPON);
|
|
if (equip_info != NULL)
|
|
{
|
|
return RC::RC_PARTY_ROOM_NEED_UNEQUIP_WEAPON;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case eZONETYPE_MISSION:
|
|
{
|
|
MapInfoParser* const map_info_parser = MapInfoParser::Instance();
|
|
nsPartyRoomMission::EnterSynArg arg = { 0, };
|
|
arg.map_info_ = map_info_parser->FindMapInfo(map_code);
|
|
if (arg.map_info_ == NULL) {
|
|
return RC::RC_PARTY_NOT_INCORRECT_MAPCODE;
|
|
}
|
|
|
|
const bool is_free_pass = nsPartyRoomMission::IsFreePassLevel(player, &arg);
|
|
if (is_free_pass == false)
|
|
{
|
|
nsPartyRoomMission::QuestOrMissionResult result;
|
|
if (nsPartyRoomMission::IsMissionOrQuestPass(player, &arg, &result) == false)
|
|
{
|
|
if (result.quest_check_skip_ == false && result.is_quest_pass_ == false)
|
|
{
|
|
return RC::RC_PARTY_PREVIOUS_QUEST_CLEAR;
|
|
}
|
|
else if (result.mission_check_skip_ == false && result.is_mission_pass_ == false)
|
|
{
|
|
return RC::RC_PARTY_NEED_CLEAR_PRE_MISSION;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case eZONETYPE_PVP:
|
|
break;
|
|
|
|
case eZONETYPE_FIELD:
|
|
break;
|
|
|
|
default:
|
|
SUNLOG(eCRITICAL_LOG, __FUNCTION__" : Invalid party room type : %d", party_room_type);
|
|
return RC::RC_PARTY_INVALID_ROOMTYPE;
|
|
}
|
|
|
|
return RC::RC_PARTY_SUCCESS;
|
|
}
|
|
|
|
RC::ePARTY_RESULT
|
|
NewGamePartyManager::CheckJoinRoomTerms(Player* player, SLOTCODE item_code, BYTE item_num,
|
|
eZONETYPE party_room_type, MAPCODE map_code)
|
|
{
|
|
//타입별 추가 조건 검사
|
|
switch (party_room_type)
|
|
{
|
|
case eZONETYPE_INSTANCE:
|
|
break;
|
|
|
|
case eZONETYPE_MISSION:
|
|
{
|
|
MapInfoParser* const map_info_parser = MapInfoParser::Instance();
|
|
nsPartyRoomMission::EnterSynArg arg = { 0, };
|
|
arg.map_info_ = map_info_parser->FindMapInfo(map_code);
|
|
|
|
const bool is_free_pass = nsPartyRoomMission::IsFreePassLevel(player, &arg);
|
|
if (is_free_pass == false)
|
|
{
|
|
nsPartyRoomMission::QuestOrMissionResult result;
|
|
if (nsPartyRoomMission::IsMissionOrQuestPass(player, &arg, &result) == false)
|
|
{
|
|
if (result.quest_check_skip_ == false && result.is_quest_pass_ == false)
|
|
{
|
|
return RC::RC_PARTY_PREVIOUS_QUEST_CLEAR;
|
|
}
|
|
else if (result.mission_check_skip_ == false && result.is_mission_pass_ == false)
|
|
{
|
|
return RC::RC_PARTY_NEED_CLEAR_PRE_MISSION;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case eZONETYPE_PVP:
|
|
break;
|
|
|
|
case eZONETYPE_FIELD:
|
|
break;
|
|
|
|
default:
|
|
SUNLOG(eCRITICAL_LOG, __FUNCTION__" : Invalid party room type : %d", party_room_type);
|
|
return RC::RC_PARTY_INVALID_ROOMTYPE;
|
|
}
|
|
|
|
return RC::RC_PARTY_SUCCESS;
|
|
}
|
|
|
|
#ifdef _NA_007734_20141027_ADD_ROOMKIND_SPECIALMISSION
|
|
RC::ePARTY_RESULT
|
|
NewGamePartyManager::ExistPartyRoomItem(Player* player, SLOTCODE item_code, BYTE item_num,
|
|
PartyZoneType party_room_type /*= PartyOfMax*/)const
|
|
{
|
|
//아이템 구한다
|
|
BASE_ITEMINFO* item_info = ItemInfoParser::Instance()->GetItemInfo(item_code);
|
|
if (item_info == NULL)
|
|
{
|
|
return RC::RC_PARTY_INVALID_ITEM;
|
|
}
|
|
|
|
PartyState& party_state = player->GetPartyState();
|
|
const BaseParty* const party = FindParty(party_state.GetPartyKey());
|
|
|
|
if (party != NULL && party_room_type == PartyOfSpecialMission)
|
|
{
|
|
//모든 파티원들의 아이템을 검사
|
|
PlayerManager* player_manager = PlayerManager::Instance();
|
|
ItemManager* item_manager = NULL;
|
|
|
|
const BaseParty::MEMBER_MAP& member_map = party->GetMemberList();
|
|
BaseParty::MEMBER_MAP::const_iterator itr = member_map.begin();
|
|
for( ; itr != member_map.end(); ++itr)
|
|
{
|
|
Player* party_member = player_manager->FindPlayerByObjKey(itr->first);
|
|
if (party_member != NULL) {
|
|
item_manager = party_member->GetItemManager();
|
|
}
|
|
|
|
if (item_manager->ExistItem(SI_INVENTORY, item_code, item_num) < item_num)
|
|
{
|
|
return RC::RC_PARTY_NOT_EXIST_ITEM;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// 대상 플레이어의 아이템을 검사
|
|
ItemManager* item_manager = player->GetItemManager();
|
|
|
|
if (item_manager->ExistItem(SI_INVENTORY, item_code, item_num) < item_num)
|
|
{
|
|
return RC::RC_PARTY_NOT_EXIST_ITEM;
|
|
}
|
|
}
|
|
|
|
return RC::RC_PARTY_SUCCESS;
|
|
}
|
|
#else
|
|
RC::ePARTY_RESULT
|
|
NewGamePartyManager::ExistPartyRoomItem(Player* player, SLOTCODE item_code, BYTE item_num)const
|
|
{
|
|
ItemManager* item_manager = player->GetItemManager();
|
|
|
|
BASE_ITEMINFO* item_info = ItemInfoParser::Instance()->GetItemInfo(item_code);
|
|
if (item_info == NULL)
|
|
{
|
|
return RC::RC_PARTY_INVALID_ITEM;
|
|
}
|
|
|
|
if (item_manager->ExistItem(SI_INVENTORY, item_code, item_num) < item_num)
|
|
{
|
|
return RC::RC_PARTY_NOT_EXIST_ITEM;
|
|
}
|
|
|
|
return RC::RC_PARTY_SUCCESS;
|
|
}
|
|
#endif //_NA_007734_20141027_ADD_ROOMKIND_SPECIALMISSION
|
|
|
|
#ifdef _NA_003033_20110831_DICECAST_ITEM_ROUTING
|
|
DWORD NewGamePartyManager::GetDiceCastDistributionMember(Player* player,
|
|
WORD party_key, DicecastResultArray& result)
|
|
{
|
|
NewGameParty* party = static_cast<NewGameParty*>(FindEditableParty(party_key));
|
|
if (party == NULL)
|
|
return 0;
|
|
|
|
return party->GetDicecastResultKey(player, result);
|
|
}
|
|
#endif //_NA_003033_20110831_DICECAST_ITEM_ROUTING
|
|
|
|
|
|
#ifdef _NA_0_20111021_EDIT_HEIM_DROP_RATIO_BY_PARTY_USER_COUNT
|
|
int
|
|
NewGamePartyManager::FindNearPartyUserCount(Player* player)
|
|
{
|
|
int member_count = 1; // 자기 자신 포함.
|
|
|
|
WORD party_key = player->GetPartyState().GetPartyKey();
|
|
const BaseParty* pParty = FindParty(party_key);
|
|
if(!pParty)
|
|
return member_count;
|
|
|
|
DWORD number_of_party_members = pParty->GetMemberNum();
|
|
if(number_of_party_members < 1)
|
|
return member_count;
|
|
|
|
GameZone * game_zone = player->GetGameZonePtr();
|
|
if(!game_zone)
|
|
return member_count;
|
|
|
|
float near_radius = 0.0f;
|
|
if (game_zone->GetZoneType() == eZONETYPE_MISSION)
|
|
near_radius = 0.0f;
|
|
else
|
|
near_radius = 60.0f;
|
|
|
|
GameField* owner_field = player->GetField();
|
|
if (!owner_field)
|
|
return member_count;
|
|
|
|
|
|
// 조건에 맞는 멤버를 찾는다
|
|
BaseParty::MEMBER_MAP tempParty = pParty->GetMemberList();
|
|
for(BaseParty::MEMBER_MAP::iterator iter = tempParty.begin(); iter != tempParty.end(); ++iter)
|
|
{
|
|
const _PARTY_MEMBER_INFO& memberInfo = iter->second;
|
|
|
|
Player *pMember = PlayerManager::Instance()->FindPlayerByObjKey(memberInfo.m_dwMemberKey);
|
|
if(!pMember)
|
|
continue;
|
|
|
|
if(pMember->IsDead())
|
|
continue;
|
|
|
|
if (player == pMember)
|
|
continue;
|
|
|
|
GameZone *pZone = pMember->GetGameZonePtr();
|
|
if(!pZone)
|
|
continue;
|
|
|
|
GameField* member_field = pMember->GetField();
|
|
if(member_field == NULL)
|
|
continue;
|
|
|
|
if(owner_field->GetFieldCode() != member_field->GetFieldCode())
|
|
continue;
|
|
|
|
if (near_radius != 0.0f)
|
|
{
|
|
if(Math_VectorLength(*player->GetPosPtr(), *pMember->GetPosPtr()) > near_radius)
|
|
continue;
|
|
}
|
|
|
|
++member_count;
|
|
}
|
|
|
|
return member_count;
|
|
}
|
|
#endif //_NA_0_20111021_EDIT_HEIM_DROP_RATIO_BY_PARTY_USER_COUNT
|