// 참가 구성원 작성 윈도우 오픈...
void CGuildCombat1to1Mng::SendMemberLineUpOpenWnd( CUser* pUser )
{
if( m_nState != GC1TO1_OPEN )
{
pUser->AddDefinedText( TID_GAME_GUILDCOMBAT1TO1_NOLINEUP );
return;
}
int nIndex = GetTenderGuildIndexByUser( pUser );
if( nIndex == NULL_ID )
{
pUser->AddDefinedText( TID_GAME_GUILDCOMBAT1TO1_CANNOT_MAKEUP );
return;
}
// 길드마스터 또는 킹핀급만 가능
if( !IsGuildMaster( pUser ) )
{
CGuild* pGuild = pUser->GetGuild();
if( pGuild )
{
CGuildMember* pGuildMember = pGuild->GetMember( pUser->m_idPlayer );
if( pGuildMember->m_nMemberLv != GUD_KINGPIN )
{
pUser->AddDefinedText( TID_GAME_GUILDCOMBAT1TO1_NOLINEUPAUTH );
return;
}
}
}
pUser->AddGC1to1MemberLineUpOpenWnd( m_vecTenderGuild[nIndex].vecMemberId );
}
//----------------------------------------------------------------------------
void CGuildMemberModule::sendMessageToGuildMembers( const std::string & msg, const TVectorParamCheck & params )const
{
MODULE_AST( _GuildMemberCore );
CGuild * guild = MODULE_CAST<CGuild*>( _GuildMemberCore->getGuild() );
MODULE_AST( guild );
guild->sendMessageToGuildMembers( msg,params );
}
bool CGuildMemberModule::isGuildProxy()
{
CGuild * guild = EGS_PD_CAST<CGuild*>( _GuildMemberCore->getGuild() );
EGS_PD_AST( guild );
return guild->isProxy();
}
void CGuildWarManager::SuggestEndDeny( void* pMsg )
{
MSG_DWORD* pmsg = (MSG_DWORD*)pMsg;
CPlayer* pPlayer = (CPlayer*)g_pUserTable->FindUser( pmsg->dwObjectID );
if( pPlayer == NULL ) return;
DWORD dwGuildIdx1 = pPlayer->GetGuildIdx();
DWORD dwGuildIdx2 = pmsg->dwData;
if( dwGuildIdx1 == 0 || dwGuildIdx2 == 0 ) return;
if( pPlayer->GetGuildMemberRank() != GUILD_MASTER ) return;
CGuild* pGuild = GUILDMGR->GetGuild( dwGuildIdx2 );
if( pGuild == NULL ) return;
pPlayer = (CPlayer*)g_pUserTable->FindUser( pGuild->GetMasterIdx() );
if( pPlayer )
{
MSG_DWORD Msg;
Msg.Category = MP_GUILD_WAR;
Msg.Protocol = MP_GUILD_WAR_SUGGESTEND_DENY;
Msg.dwData = dwGuildIdx1;
pPlayer->SendMsg( (MSGBASE*)&Msg, sizeof(Msg) );
}
else
{
MSG_DWORD2 Notify;
Notify.Category = MP_GUILD_WAR;
Notify.Protocol = MP_GUILD_WAR_SUGGESTEND_DENY_NOTIFY_TOMAP;
Notify.dwData1 = pGuild->GetMasterIdx();
Notify.dwData2 = dwGuildIdx1;
g_Network.Send2AgentServer( (char*)&Notify, sizeof(Notify) );
}
}
//----------------------------------------------------------------------------
void CBuildingPhysicalGuild::dumpBuilding(NLMISC::CLog & log) const
{
log.displayNL("<BUILDING_DUMP> CBuildingPhysicalGuild");
log.displayNL("Name: %s, alias: %s", _Name.c_str(), CPrimitivesParser::aliasToString( _Alias ).c_str());
for (uint i = 0; i < _UsersInside.size(); i++)
{
const TDataSetRow rowId = _UsersInside[i];
CCharacter * c = PlayerManager.getChar( rowId );
if ( !c )
{
log.displayNL("\tError: cannot find character with row id: %s", rowId.toString().c_str());
continue;
}
const string charName = c->getName().toUtf8();
const string charEId = c->getId().toString();
CMirrorPropValueRO<TYPE_CELL> mirrorCell(TheDataset, rowId, DSPropertyCELL);
const sint32 cell = mirrorCell;
IRoomInstance * room = CBuildingManager::getInstance()->getRoomInstanceFromCell( cell );
if ( !room )
{
log.displayNL("\tError: character %s %s is in cell %d but no room was found", charName.c_str(), charEId.c_str(), cell);
continue;
}
CRoomInstanceGuild * guildRoom = dynamic_cast<CRoomInstanceGuild *>(room);
if ( !guildRoom )
{
log.displayNL("\tError: character %s %s is in cell %d but room is not a guild room but a %s",
charName.c_str(), charEId.c_str(), cell, room->getRoomDescription().c_str()
);
continue;
}
const uint32 guildId = c->getGuildId();
string guildName;
CGuild * guild = CGuildManager::getInstance()->getGuildFromId( guildId );
if (guild)
guildName = guild->getName().toUtf8();
log.displayNL("\tCharacter %s %s [guild name='%s' id=%u] is in cell %d, room desc: %s",
charName.c_str(), charEId.c_str(), guildName.c_str(), guildId, cell, room->getRoomDescription().c_str()
);
}
for (uint i = 0; i < _Guilds.size(); i++)
{
const uint32 guildId = _Guilds[i];
string guildName;
CGuild * guild = CGuildManager::getInstance()->getGuildFromId( guildId );
if (guild)
guildName = guild->getName().toUtf8();
log.displayNL("\t> Guild registered in building at index %u: %s", i, guildName.c_str());
}
}
// 길드마스터 인가?
BOOL CGuildCombat1to1Mng::IsGuildMaster( CUser* pUser )
{
CGuild* pGuild = pUser->GetGuild();
if( pGuild && pGuild->IsMaster( pUser->m_idPlayer ) )
return TRUE;
return FALSE;
}
//----------------------------------------------------------------------------
void CGuildMemberModule::onParentDestructionHandler()
{
MODULE_AST( _GuildMemberCore );
CGuild* guild = EGS_PD_CAST<CGuild*>(_GuildMemberCore->getGuild());
EGS_PD_AST( guild );
_GuildMemberCore->removeReferencingModule(this);
// once the guild member module is removed the member can be set offline
guild->setMemberOffline( _GuildMemberCore );
}
//----------------------------------------------------------------------------
void CGuildMemberModule::setMOTD(const std::string& motd)
{
MODULE_AST( _GuildMemberCore );
CGuild * guild = EGS_PD_CAST<CGuild*>( _GuildMemberCore->getGuild() );
EGS_PD_AST( guild );
CGuildCharProxy proxy;
getProxy(proxy);
guild->setMOTD(motd, proxy.getId());
}
// 입찰 취소
void CGuildCombat1to1Mng::SetCancelTenderGuild( CUser* pUser )
{
if( m_nState != GC1TO1_CLOSE )
{
pUser->AddDiagText( prj.GetText( TID_GAME_GUILDCOMBAT1TO1_NOTENDER ) );
return;
}
// 길드마스터만 입찰 취소 가능
if( !IsGuildMaster( pUser ) )
{
pUser->AddDefinedText( TID_GAME_GUILDCOMBAT1TO1_NOTMASTER );
return;
}
CGuild* pGuild = pUser->GetGuild();
if( pGuild )
{
for( vector<__GC1TO1TENDER>::iterator it=m_vecTenderGuild.begin(); it!=m_vecTenderGuild.end(); it++ )
{
if( (*it).ulGuildId == pGuild->GetGuildId() )
{
int nReturnGold = (int)( (*it).nPenya * ( (float)m_nCancelReturnRate / 100 ) );
//인벤 꽉 찼을때 예외처리 해야함..
int nTotal = pUser->GetGold() + nReturnGold;
if( nReturnGold > 0 && nTotal < 0 ) // overflow
{
pUser->AddDefinedText( TID_GAME_LACKSPACE );
return;
}
pUser->AddGold( nReturnGold );
g_dpDBClient.SendGC1to1Tender( 'U', (*it).ulGuildId, (*it).nPenya, 'C' );
m_vecTenderGuild.erase( it );
CString strTemp;
strTemp.Format( prj.GetText( TID_GAME_GUILDCOMBAT1TO1_CANCELTENDER ), nReturnGold );
pUser->AddDiagText( strTemp );
// 로그 남김(아이템로그)
LogItemInfo aLogItem;
aLogItem.Action = "9";
aLogItem.SendName = pUser->GetName();
aLogItem.RecvName = "GUILDCOMBAT1TO1_CANCELRETURN";
aLogItem.WorldId = pUser->GetWorld()->GetID();
//aLogItem.ItemName = "SEED";
_stprintf( aLogItem.szItemName, "%d", II_GOLD_SEED1 );
aLogItem.Gold = pUser->GetGold() - nReturnGold;
aLogItem.Gold2 = pUser->GetGold();
aLogItem.Gold_1 = nReturnGold;
g_DPSrvr.OnLogItem( aLogItem );
break;
}
}
}
}
// BUILDING_NPC
void CObject::RegenNPC()
{
if (!m_pProto)
return;
if (!m_pProto->dwNPCVnum)
return;
if (!m_pkLand)
return;
DWORD dwGuildID = m_pkLand->GetOwner();
CGuild* pGuild = CGuildManager::instance().FindGuild(dwGuildID);
if (!pGuild)
return;
int x = m_pProto->lNPCX;
int y = m_pProto->lNPCY;
int newX, newY;
float rot = m_data.zRot * 2.0f * M_PI / 360.0f;
newX = (int)(( x * cosf(rot)) + ( y * sinf(rot)));
newY = (int)(( y * cosf(rot)) - ( x * sinf(rot)));
m_chNPC = CHARACTER_MANAGER::instance().SpawnMob(m_pProto->dwNPCVnum,
GetMapIndex(),
GetX() + newX,
GetY() + newY,
GetZ(),
false,
(int)m_data.zRot);
if (!m_chNPC)
{
sys_err("Cannot create guild npc");
return;
}
m_chNPC->SetGuild(pGuild);
// 힘의 신전일 경우 길드 레벨을 길마에게 저장해놓는다
if ( m_pProto->dwVnum == 14061 || m_pProto->dwVnum == 14062 || m_pProto->dwVnum == 14063 )
{
quest::PC* pPC = quest::CQuestManager::instance().GetPC(pGuild->GetMasterPID());
if ( pPC != NULL )
{
pPC->SetFlag("alter_of_power.build_level", pGuild->GetLevel());
}
}
}
//----------------------------------------------------------------------------
void COutpostGuildDBUpdater::updateOutpostGuildDBOUTPOST_PROPERTIES()
{
CGuild* owner = CGuildManager::getInstance()->getGuildFromId(_Outpost->_OwnerGuildId);
CGuild* attacker = CGuildManager::getInstance()->getGuildFromId(_Outpost->_AttackerGuildId);
// uint32 const OWNED = (_Side == OUTPOSTENUMS::OutpostOwner)?1:0;
// uint32 const SHEET = _Outpost->_Sheet.asInt();
// uint32 const LEVEL = _Outpost->getStaticForm()?_Outpost->getStaticForm()->Level:0;
ucstring const GUILD_NAME = owner?owner->getName():ucstring();
uint64 const GUILD_ICON = owner?owner->getIcon():0;
// uint32 const TRIBE = _Outpost->isBelongingToAGuild()?0:1;
ucstring const GUILD_NAME_ATT = attacker?attacker->getName():ucstring();
// uint32 const STATUS = _Outpost->computeStatusForClient();
// uint32 const DISPLAY_CRASH = _Outpost->_CrashHappened?1:0;
uint32 const WARCOST = _Outpost->_Form->ChallengeCost;
uint32 const ROUND_LVL_THRESHOLD = _Outpost->_CurrentOutpostLevel;
uint32 const ROUND_LVL_MAX_ATT = _Outpost->_FightData._MaxAttackLevel;
uint32 const ROUND_LVL_MAX_DEF = _Outpost->_FightData._MaxDefenseLevel;
uint32 const ROUND_LVL_CUR = _Outpost->_FightData._CurrentCombatLevel;
uint32 const ROUND_ID_CUR = _Outpost->_FightData._CurrentCombatRound;
uint32 const ROUND_ID_MAX = _Outpost->computeRoundCount();
uint32 const TIME_RANGE_DEF_WANTED = _Outpost->_DefenseHour;
uint32 const TIME_RANGE_DEF = _Outpost->computeTimeRangeDefForClient();
uint32 const TIME_RANGE_ATT = _Outpost->computeTimeRangeAttForClient();
uint32 const TIME_RANGE_LENGTH = _Outpost->computeTimeRangeLengthForClient();
uint32 const SQUAD_CAPITAL = (_Side == OUTPOSTENUMS::OutpostOwner) ? _Outpost->_OwnerExpenseLimit : _Outpost->_AttackerExpenseLimit;
setOWNED(_Side == OUTPOSTENUMS::OutpostOwner);
setSHEET(_Outpost->_Sheet);
setLEVEL(_Outpost->getStaticForm()?_Outpost->getStaticForm()->Level:0);
setGUILD__NAME(GUILD_NAME);
setGUILD__ICON(GUILD_ICON);
setGUILD__TRIBE(!_Outpost->isBelongingToAGuild());
setGUILD__NAME_ATT(GUILD_NAME_ATT);
setSTATUS(_Outpost->computeStatusForClient());
setDISPLAY_CRASH(_Outpost->_CrashHappened);
setWARCOST(WARCOST);
setROUND_LVL_THRESHOLD(uint8(ROUND_LVL_THRESHOLD));
setROUND_LVL_MAX_ATT(uint8(ROUND_LVL_MAX_ATT));
setROUND_LVL_MAX_DEF(uint8(ROUND_LVL_MAX_DEF));
setROUND_LVL_CUR(uint8(ROUND_LVL_CUR));
setROUND_ID_CUR(uint8(ROUND_ID_CUR));
setROUND_ID_MAX(uint8(ROUND_ID_MAX));
setTIME_RANGE_DEF_WANTED(uint8(TIME_RANGE_DEF_WANTED));
setTIME_RANGE_DEF(TIME_RANGE_DEF);
setTIME_RANGE_ATT(TIME_RANGE_ATT);
setTIME_RANGE_LENGTH(TIME_RANGE_LENGTH);
setSQUAD_CAPITAL(SQUAD_CAPITAL);
}
void CGuildWarManager::SurrenderNotifyToMap( void* pMsg )
{
const MSG_GUILD_WAR_RESULT* pmsg = ( MSG_GUILD_WAR_RESULT* )pMsg;
const DWORD winnnerGuildIndex = pmsg->mWinner.mGuildIndex;
const DWORD loserGuildIndex = pmsg->mLoser.mGuildIndex;
MSG_DWORD4 message;
{
message.Category = MP_GUILD_WAR;
message.Protocol = MP_GUILD_WAR_SURRENDER;
}
// 승리 길드에게 메시지 전달
{
CGuild* guild = GUILDMGR->GetGuild( winnnerGuildIndex );
if( guild )
{
const MSG_GUILD_WAR_RESULT::Data& data = pmsg->mWinner;
message.dwData1 = 1; // 1 = win
message.dwData2 = loserGuildIndex;
message.dwData3 = data.mScoreValue;
message.dwData4 = DWORD( data.mScoreVariation );
guild->SendMsgToAll( &message, sizeof( message ) );
}
}
// 패배 길드에게 전달
{
CGuild* guild = GUILDMGR->GetGuild( loserGuildIndex );
if( guild )
{
const MSG_GUILD_WAR_RESULT::Data& data = pmsg->mLoser;
message.dwData1 = 0; // 0 = surrender,
message.dwData2 = winnnerGuildIndex;
message.dwData3 = data.mScoreValue;
message.dwData4 = DWORD( data.mScoreVariation );
guild->SendMsgToAll( &message, sizeof( message ) );
}
}
UnregistGuildWar( winnnerGuildIndex, loserGuildIndex );
// PenaltyForEndNotifyToMap( 1, loserGuildIndex );
UpdateGuildWarRecord( FALSE, 0, loserGuildIndex );
UpdateGuildWarRecord( FALSE, 1, winnnerGuildIndex );
}
void CGuildList::Reset(void)
{
for(CGuild *i = this->Unk0; i; i = this->Unk0)
{
this->Unk0 = i->nextguild();
i->DeleteAllChild();
if(i)
delete i;
}
this->Unk4 = 0;
}
// 입찰 길드(m_vecTenderGuild)의 인덱스 값
int CGuildCombat1to1Mng::GetTenderGuildIndexByUser( CUser* pUser )
{
CGuild* pGuild = pUser->GetGuild();
if( pGuild )
{
for( int i=0; i<(int)( m_vecTenderGuild.size() ); i++ )
{
if( pGuild->GetGuildId() == m_vecTenderGuild[i].ulGuildId )
return i;
}
}
return NULL_ID;
}
CGuildMember *CGuildList::findmember(int a2)
{
CGuildMember *v4; // [sp+14h] [bp-4h]@1
v4 = 0;
for(CGuild *i = this->Unk0; i; i = i->nextguild())
{
v4 = i->findmember(a2, 1);
if(v4)
return v4;
}
return v4;
}
//----------------------------------------------------------------------------
void CGuildMemberModule::kickMember( uint16 index,uint8 session )const
{
MODULE_AST( _GuildMemberCore );
CGuild * guild = EGS_PD_CAST<CGuild*>( _GuildMemberCore->getGuild() );
EGS_PD_AST( guild );
CGuildCharProxy proxy;
getProxy(proxy);
proxy.cancelAFK();
if ( guild->getMembersSession() != session )
{
proxy.sendSystemMessage( "GUILD_BAD_SESSION" );
return;
}
if ( _GuildMemberCore->getMemberIndex() == index )
{
nlwarning("<GUILD>%s tries to kick himself",proxy.getId().toString().c_str());
return;
}
CGuildMember * member = guild->getMemberByIndex( index );
if ( member == NULL )
{
nlwarning("<GUILD>%s set invalid member idx %u as leader",proxy.getId().toString().c_str(),index );
return;
}
EGSPD::CGuildGrade::TGuildGrade targetGrade = member->getGrade();
if ( !canAffectGrade( targetGrade ) )
{
proxy.sendSystemMessage("GUILD_INSUFFICIENT_GRADE");
return;
}
// if the user is online reset its guild id
CGuildMemberModule * module = NULL;
if ( member->getReferencingModule( module ) )
{
module->clearOnlineGuildProperties();
}
// send system message
SM_STATIC_PARAMS_2(params,STRING_MANAGER::player,STRING_MANAGER::string_id);
params[0].setEIdAIAlias( proxy.getId(), CAIAliasTranslator::getInstance()->getAIAlias(proxy.getId()) );
params[1].StringId = CEntityIdTranslator::getInstance()->getEntityNameStringId(member->getIngameEId());
sendMessageToGuildMembers("GUILD_KICK_MEMBER",params);
guild->deleteMember( member );
}
//----------------------------------------------------------------------------
void CGuildMemberModule::quitGuild()
{
MODULE_AST( _GuildMemberCore );
CGuild * guild = EGS_PD_CAST<CGuild*>( _GuildMemberCore->getGuild() );
EGS_PD_AST( guild );
SM_STATIC_PARAMS_1( params,STRING_MANAGER::player );
params[0].setEIdAIAlias( _GuildMemberCore->getIngameEId(), CAIAliasTranslator::getInstance()->getAIAlias(_GuildMemberCore->getIngameEId()) );
CFameManager::getInstance().clearPlayerGuild( _GuildMemberCore->getIngameEId() );
CGuildCharProxy proxy;
getProxy(proxy);
proxy.cancelAFK();
clearOnlineGuildProperties();
guild->deleteMember( _GuildMemberCore );
if ( guild->getMembersBegin() == guild->getMembersEnd() )
{
CGuildManager::getInstance()->deleteGuild(guild->getId());
proxy.sendSystemMessage("GUILD_DESTROYED");
}
else
{
guild->sendMessageToGuildMembers("GUILD_QUIT", params);
SM_STATIC_PARAMS_1(params, STRING_MANAGER::string_id);
params[0].StringId = guild->getNameId();
proxy.sendSystemMessage("GUILD_YOU_QUIT", params);
}
}
void CGuildWarManager::SuggestEnd( void* pMsg )
{
// 편의상 종전을 요청한 측을 아군, 요청받은 측을 적군이라 칭하자
const MSG_DWORD3* pmsg = (MSG_DWORD3*)pMsg;
CGuild* friendlyGuild = GUILDMGR->GetGuildFromMasterIdx( pmsg->dwData1 );
CGuild* enemyGuild = GUILDMGR->GetGuildFromMasterIdx( pmsg->dwData2 );
if( ! friendlyGuild ||
! enemyGuild ||
! IsGuildWar( friendlyGuild->GetIdx(), enemyGuild->GetIdx() ) )
{
return;
}
// 동맹인데 마스터 길드가 아닐 경우 해킹 또는 클라이언트 검사 실패
{
CGuildUnion* friendlyAlliance = GUILDUNIONMGR->GetUnion( friendlyGuild->GetUnionIndex() );
CGuildUnion* enemyAlliance = GUILDUNIONMGR->GetUnion( enemyGuild->GetUnionIndex() );
if( ( friendlyAlliance && friendlyAlliance->GetMasterGuild() != friendlyGuild ) ||
( enemyAlliance && enemyAlliance->GetMasterGuild() != enemyGuild ) )
{
return;
}
}
// 요청 측에 대기하라고 알린다
{
CObject* friendlyPlayer = g_pUserTable->FindUser( pmsg->dwData1 );
if( friendlyPlayer )
{
MSG_BYTE message;
message.Category = MP_GUILD_WAR;
message.Protocol = MP_GUILD_WAR_WAIT;
message.bData = MP_GUILD_WAR_SUGGESTEND;
friendlyPlayer->SendMsg( &message, sizeof( message ) );
}
}
// 제안 받은 측에 메시지 보내자
{
CObject* enemyPlayer = g_pUserTable->FindUser( pmsg->dwData2 );
if( enemyPlayer )
{
MSG_DWORD message;
message.Category = MP_GUILD_WAR;
message.Protocol = MP_GUILD_WAR_SUGGESTEND;
message.dwData = friendlyGuild->GetIdx();
enemyPlayer->SendMsg( &message, sizeof( message ) );
}
}
}
//----------------------------------------------------------------------------
void COutpostManager::doOutpostGuildDBUpdates()
{
for (uint i = 0; i < _OutpostsWaitingGuildDBUpdate.size(); i++)
{
TAIAlias outpostAlias = _OutpostsWaitingGuildDBUpdate[i].first;
COutpostGuildDBUpdater::TDBPropSet dbPropSet = _OutpostsWaitingGuildDBUpdate[i].second;
CHashMap<uint, NLMISC::CSmartPtr<COutpost> >::iterator it = _OutpostsByAlias.find(outpostAlias);
if (it == _OutpostsByAlias.end())
continue;
NLMISC::CSmartPtr<COutpost> & outpost = (*it).second;
// check data consistency
if (outpost->isBelongingToAGuild() && outpost->getOwnerGuild() == outpost->getAttackerGuild())
{
nlwarning("Owner and attacker are the same guild (%u) for the outpost '%s'",
outpost->getOwnerGuild(),
outpost->getName().c_str()
);
DEBUG_STOP;
}
CGuild * ownerGuild = CGuildManager::getInstance()->getGuildFromId(outpost->getOwnerGuild());
if (ownerGuild != NULL)
{
COutpostGuildDBUpdaterPtr dbUpdater = ownerGuild->getOutpostGuildDBUpdater(outpost);
if (dbUpdater != NULL)
dbUpdater->updateOutpostGuildDB(dbPropSet);
}
CGuild * attackerGuild = CGuildManager::getInstance()->getGuildFromId(outpost->getAttackerGuild());
if (attackerGuild != NULL)
{
COutpostGuildDBUpdaterPtr dbUpdater = attackerGuild->getOutpostGuildDBUpdater(outpost);
if (dbUpdater != NULL)
dbUpdater->updateOutpostGuildDB(dbPropSet);
}
}
_OutpostsWaitingGuildDBUpdate.clear();
}
void _test_func( std::vector< string >& arg )
{
BOOL bAuthority = FALSE;
CGuild* pGuild = g_pPlayer->GetGuild( );
if( pGuild )
bAuthority = pGuild->IsAuthority( g_pPlayer->m_idPlayer, PF_GUILDHOUSE_UPKEEP );
if( !bAuthority ) //유지비 권한이 없으면
{
g_WndMng.PutString( GETTEXT( TID_GAME_GUILDHOUSE_TAX_LEVEL ) );
return;
}
if( !g_WndMng.m_pWndUpkeep )
{
g_WndMng.m_pWndUpkeep = new CWndGHUpkeep;
g_WndMng.m_pWndUpkeep->Initialize(&g_WndMng, APP_CONFIRM_BUY_);
}
}
void FBuildLuaGuildWarList::operator() (DWORD g1, DWORD g2)
{
CGuild* g = CGuildManager::instance().FindGuild(g1);
if (!g)
return;
if (g->GetGuildWarType(g2) == GUILD_WAR_TYPE_FIELD)
return;
if (g->GetGuildWarState(g2) != GUILD_WAR_ON_WAR)
return;
lua_newtable(L);
lua_pushnumber(L, g1);
lua_rawseti(L, -2, 1);
lua_pushnumber(L, g2);
lua_rawseti(L, -2, 2);
lua_rawseti(L, -2, m_count++);
}
//----------------------------------------------------------------------------
void CBuildingPhysicalGuild::getClientDescription(uint16 roomIdx, uint16 ownerIndex, CCharacter * user, uint64 & icon, uint32 & textId )const
{
#ifdef NL_DEBUG
nlassert(user);
#endif
CMirrorPropValueRO<TYPE_CELL> mirrorValue( TheDataset, user->getEntityRowId(), DSPropertyCELL );
const sint32 cell = mirrorValue;
// if user is inside a building, icons and texts are found the same way as standard building
if ( CBuildingManager::getInstance()->isRoomCell(cell) )
{
icon = UINT64_CONSTANT(0x8000000000000000) + _Template->Rooms[roomIdx].Icon;
textId = CZoneManager::getInstance().sendPlaceName( user->getEntityRowId(), _Template->Rooms[roomIdx].PhraseId );
}
// otherwise, display the guild icon and guild name
else
{
if ( ownerIndex >= _Guilds.size() )
{
nlwarning("<BUILDING>%s ask for guild room %u count is %u, in building '%s'",ownerIndex, _Guilds.size(), user->getId().toString().c_str(),_Name.c_str());
textId = 0;
icon = 0;
return;
}
CGuild * guild = CGuildManager::getInstance()->getGuildFromId( _Guilds[ownerIndex] );
if ( !guild )
{
nlwarning("<BUILDING>%s ask for guild %u. This guild is invalid",user->getId().toString().c_str(), _Guilds[ownerIndex] );
textId = 0;
icon = 0;
return;
}
icon = guild->getIcon();
static TVectorParamCheck params(1);
params[0].Type = STRING_MANAGER::string_id;
params[0].StringId = guild->getNameId();
textId = STRING_MANAGER::sendStringToClient( user->getEntityRowId(),"GUILD_ROOM",params );
}
}
void CObject::ApplySpecialEffect()
{
if (m_pProto)
{
// ADD_SUPPLY_BUILDING
if (m_pProto->dwVnum == BUILDING_INCREASE_GUILD_MEMBER_COUNT_SMALL ||
m_pProto->dwVnum == BUILDING_INCREASE_GUILD_MEMBER_COUNT_MEDIUM ||
m_pProto->dwVnum == BUILDING_INCREASE_GUILD_MEMBER_COUNT_LARGE)
{
CLand* pLand = GetLand();
DWORD guild_id = 0;
if (pLand)
guild_id = pLand->GetOwner();
CGuild* pGuild = CGuildManager::instance().FindGuild(guild_id);
if (pGuild)
{
switch (m_pProto->dwVnum)
{
case BUILDING_INCREASE_GUILD_MEMBER_COUNT_SMALL:
pGuild->SetMemberCountBonus(6);
break;
case BUILDING_INCREASE_GUILD_MEMBER_COUNT_MEDIUM:
pGuild->SetMemberCountBonus(12);
break;
case BUILDING_INCREASE_GUILD_MEMBER_COUNT_LARGE:
pGuild->SetMemberCountBonus(18);
break;
}
if (map_allow_find(pLand->GetMapIndex()))
{
pGuild->BroadcastMemberCountBonus();
}
}
}
// END_OF_ADD_SUPPLY_BUILDING
}
}
void CGuildWarManager::DeclareAccept( void* pMsg )
{
/*
071009 웅주
요구사항: 연합<->길드, 길드<->길드, 연합<->연합 간의 전투가 가능해야한다.
처리개요: 예를 들어 A길드와 B연합이 전쟁을 한다고 하자. 각각의 길드와 연합을 모두 다른 자료구조 A, B에 넣는다.
길드는 B에 있는 길드 전체를 적으로 등록한다. 연합은 A에 있는 길드 전체를 적으로 등록한다.
이런 식으로 기존 프로세스를 이용하여 연합전을 쉽게 처리할 수 있다.
주의: 다양한 테스트 케이스를 고려하여 시험해봐야한다.
*/
MSG_DWORD2* pmsg = ( MSG_DWORD2* )pMsg;
CPlayer* friendlyGuildMaster = ( CPlayer* )g_pUserTable->FindUser( pmsg->dwObjectID );
if( ! friendlyGuildMaster )
{
return;
}
const DWORD friendlyGuildIndex = friendlyGuildMaster->GetGuildIdx();
const DWORD enemyGuildIndex = pmsg->dwData1;
CGuild* friendlyGuild = GUILDMGR->GetGuildFromMasterIdx( pmsg->dwObjectID );
CGuild* enemyGuild = GUILDMGR->GetGuild( enemyGuildIndex );
if( ( ! friendlyGuild || ! enemyGuild ) ||
IsGuildWar( friendlyGuildIndex, enemyGuildIndex ) )
{
return;
}
Alliance friendlyAlliance;
Alliance enemyAlliance;
const DWORD money = pmsg->dwData2;
// 071008 웅주, 길드가 연합이라면 마스터인지 검사한 후 아군을 등록한다.
{
{
CGuildUnion* alliance = GUILDUNIONMGR->GetUnion( friendlyGuild->GetUnionIndex() );
if( alliance )
{
if( alliance->GetMasterGuild() != friendlyGuild )
{
// 처리 불필요. 이미 선전포고 요청할 때 검사했음
return;
}
AddGuildToGroup( alliance, friendlyAlliance );
}
// 위의 루프에서 모든 동맹 내 길드의 선포금을 0으로 선포한다. 동맹 마스터 길드만 선포금이 지정되어야 하므로 마지막에 지정한다
friendlyAlliance[ friendlyGuild ] = money;
}
{
CGuildUnion* alliance = GUILDUNIONMGR->GetUnion( enemyGuild->GetUnionIndex() );
if( alliance )
{
if( alliance->GetMasterGuild() != enemyGuild )
{
// 처리 불필요. 이미 선전포고 요청할 때 검사했음
return;
}
AddGuildToGroup( alliance, enemyAlliance );
}
// 위의 루프에서 모든 동맹 내 길드의 선포금을 0으로 선포한다. 동맹 마스터 길드만 선포금이 지정되어야 하므로 마지막에 지정한다
enemyAlliance[ enemyGuild ] = money;
}
}
{
CPlayer* enemyGuildMaster = ( CPlayer* )g_pUserTable->FindUser( enemyGuild->GetMasterIdx() );
SendMoneyMsg( friendlyGuildMaster, enemyGuildMaster, money, MP_GUILD_WAR_REMOVEMONEY );
}
AddEnemyToFriendly( friendlyAlliance, enemyAlliance );
AddEnemyToFriendly( enemyAlliance, friendlyAlliance );
}
// 참가자 구성
void CGuildCombat1to1Mng::SetMemberLineUp( CUser* pUser, vector<u_long>& vecMemberId )
{
if( m_nState != GC1TO1_OPEN ) // 참가자 구성 시간이 아니다.
{
pUser->AddDefinedText( TID_GAME_GUILDCOMBAT1TO1_NOLINEUP );
return;
}
int nIndex = GetTenderGuildIndexByUser( pUser );
if( nIndex == NULL_ID ) // 입찰되지 않았거나 순위에서 밀린 길드
{
pUser->AddDefinedText( TID_GAME_GUILDCOMBAT1TO1_CANNOT_MAKEUP );
return;
}
if( (int)( vecMemberId.size() ) < m_nMinJoinPlayer ) // 최소 참가자 수보다 적다.
{
pUser->AddDefinedText( TID_GAME_GUILDCOMBAT1TO1_LOWMINPLAYER, "%d", m_nMinJoinPlayer );
return;
}
if( (int)( vecMemberId.size() ) > m_nMaxJoinPlayer )
{
pUser->AddDefinedText( TID_GAME_GUILDCOMBAT1TO1_OVERMAXPLAYER, "%d", m_nMaxJoinPlayer );
return;
}
// 길드마스터 또는 킹핀급만 가능
CGuild* pGuild = pUser->GetGuild();
if( pGuild )
{
CGuildMember* pGuildMember = pGuild->GetMember( pUser->m_idPlayer );
if( pGuildMember )
{
if( pGuildMember->m_nMemberLv != GUD_MASTER && pGuildMember->m_nMemberLv != GUD_KINGPIN )
{
pUser->AddDefinedText( TID_GAME_GUILDCOMBAT1TO1_NOLINEUPAUTH );
return;
}
}
}
BOOL bMasterOrKingpin = FALSE;
// 최소 참가 레벨 검사
for( int i=0; i<(int)( vecMemberId.size() ); i++ )
{
CUser* pUserTemp = (CUser*)prj.GetUserByID( vecMemberId[i] );
if( IsValidObj( pUserTemp ) && pUserTemp->GetLevel() < m_nMinJoinPlayerLevel )
{
pUser->AddDefinedText( TID_GAME_GUILDCOMBAT1TO1_LIMIT_LEVEL_NOTICE );
return;
}
if( IsValidObj( pUserTemp ) && !bMasterOrKingpin )
{
CGuildMember* pGuildMember = pGuild->GetMember( pUserTemp->m_idPlayer );
if( pGuildMember )
if( pGuildMember->m_nMemberLv == GUD_MASTER || pGuildMember->m_nMemberLv == GUD_KINGPIN )
bMasterOrKingpin = TRUE;
}
}
if( !bMasterOrKingpin )
{
pUser->AddDefinedText( TID_GAME_GUILDCOMBAT1TO1_HAVENOT_MASTER );
return;
}
m_vecTenderGuild[nIndex].vecMemberId.clear();
m_vecTenderGuild[nIndex].vecMemberId = vecMemberId;
pUser->AddDefinedText( TID_GAME_GUILDCOMBAT1TO1_LINEUPCOMPLETE );
g_dpDBClient.SendGC1to1LineUp( m_vecTenderGuild[nIndex].ulGuildId, vecMemberId );
}
void CGuildWarManager::Declare( void* pMsg )
{
MSG_DWORD3* pmsg = (MSG_DWORD3*)pMsg;
CGuild* pGuild1 = GUILDMGR->GetGuildFromMasterIdx( pmsg->dwData1 );
CGuild* pGuild2 = GUILDMGR->GetGuildFromMasterIdx( pmsg->dwData2 );
if( pGuild1 == NULL || pGuild2 == NULL ) return;
// 주의! 길드전 테스트를 위해 멤버 수를 검사하지 않도록 함
if( pGuild1->GetMemberNum() < 5 )
{
SendDeclareNackMsg( pmsg->dwData1, 2 );
return;
}
else if( pGuild2->GetMemberNum() < 5 )
{
SendDeclareNackMsg( pmsg->dwData1, 3 );
return;
}
else if( IsGuildWar( pGuild1->GetInfo().GuildIdx, pGuild2->GetInfo().GuildIdx ) )
{
return;
}
// 071009 웅주, 길드1이 연합에 속하나 마스터 길드가 아닌 경우, 클라이언트 검사가 실패했거나 해킹임
{
CGuildUnion* guildUnion = GUILDUNIONMGR->GetUnion( pGuild1->GetUnionIndex() );
if( guildUnion && guildUnion->GetMasterGuild() != pGuild1 )
{
return;
}
}
CPlayer* guild1Master = (CPlayer*)g_pUserTable->FindUser( pmsg->dwData1 );
CPlayer* guild2Master = (CPlayer*)g_pUserTable->FindUser( pmsg->dwData2 );
// 071009 웅주, 길드2가 연합에 속하나 마스터 길드가 아닌 경우 길드1에게 알려준다
{
CGuildUnion* guildUnion = GUILDUNIONMGR->GetUnion( pGuild2->GetUnionIndex() );
if( guildUnion && guildUnion->GetMasterGuild() != pGuild2 )
{
CGuild* masterGuild = guildUnion->GetMasterGuild();
MSG_NAME message;
message.Category = MP_GUILD_WAR;
message.Protocol = MP_GUILD_WAR_DECLARE_NACK_BY_UNION;
SafeStrCpy( message.Name, masterGuild->GetGuildName(), sizeof( message.Name ) );
guild1Master->SendMsg( &message, sizeof( message ) );
return;
}
}
//int rt = CanGuildWar( pGuild2->GetIdx(), pGuild1->GetIdx() );
//if( rt != 0 )
//{
// SendDeclareNackMsg( pmsg->dwData1, rt );
// return;
//}
const DWORD money = pmsg->dwData3;
if( guild1Master )
{
if( money > guild1Master->GetMoney() )
{
SendDeclareNackMsg( pmsg->dwData1, 98 );
return;
}
MSG_BYTE message;
message.Category = MP_GUILD_WAR;
message.Protocol = MP_GUILD_WAR_WAIT;
message.bData = MP_GUILD_WAR_DECLARE;
guild1Master->SendMsg( &message, sizeof( message ) );
}
if( guild2Master )
{
MSG_GUILD_LIST message;
message.Category = MP_GUILD_WAR;
message.Protocol = MP_GUILD_WAR_DECLARE;
message.mSize = 1;
MSG_GUILD_LIST::Data& dest = message.mData[ 0 ];
const GUILDINFO& source = pGuild1->GetInfo();
// 제대로 복사되나 테스트할 것
memcpy( &dest, &source, sizeof( source ) );
dest.MarkName = money;
CGuildUnion* alliance = GUILDUNIONMGR->GetUnion( source.UnionIdx );
if( alliance )
{
SafeStrCpy( dest.mUnionName, alliance->GetName(), sizeof( dest.mUnionName ) );
}
else
{
dest.mUnionName[ 0 ] = 0;
}
guild2Master->SendMsg( &message, message.GetSize() );
}
}
void CWndGuildBank::OnInitialUpdate()
{
CWndNeuz::OnInitialUpdate();
// 여기에 코딩하세요
#if __VER >= 11 // __SYS_POCKET
if(GetWndBase( APP_BAG_EX )) GetWndBase( APP_BAG_EX )->Destroy();
#endif
if( g_WndMng.m_pWndTrade || g_WndMng.m_pWndShop || g_WndMng.m_pWndBank || g_WndMng.GetWndVendorBase() )
{
Destroy();
return;
}
CWndStatic* pCost = (CWndStatic*) GetDlgItem( WIDC_GUILDBANK_NUM );
pCost->AddWndStyle(WSS_MONEY);
CWndTabCtrl* pTabCtrl = reinterpret_cast<CWndTabCtrl*>(GetDlgItem(WIDC_TABCTRL1));
m_wndItemCtrl.Create( WLVS_ICON, CRect( 0, 0, 250, 250 ), pTabCtrl, 11 );
m_wndItemCtrl.InitItem( &g_pPlayer->GetGuild()->m_GuildBank, APP_GUILD_BANK );
WTCITEM tabTabItem;
tabTabItem.mask = WTCIF_TEXT | WTCIF_PARAM;
tabTabItem.pszText = prj.GetText(TID_GAME_ITEM);//"아이템";
tabTabItem.pWndBase = &m_wndItemCtrl;
pTabCtrl->InsertItem( 0, &tabTabItem );
LPWNDCTRL lpWndCtrl = GetWndCtrl( WIDC_CUSTOM1 );
m_wndGold.Create( "g", WBS_NODRAWFRAME, lpWndCtrl->rect, this, WIDC_CUSTOM1 );
m_wndGold.AddWndStyle( WBS_NODRAWFRAME );
CGuild *pGuild = g_pPlayer->GetGuild();
if( pGuild )
{
if( pGuild->IsMaster( g_pPlayer->m_idPlayer ) == FALSE ) // 길마가 아니면
{
CWndButton* pWndButt = (CWndButton*)GetDlgItem(WIDC_BUTTON2); // 망토제작 버튼을 disable 시킨다.
pWndButt->EnableWindow( FALSE );
}
}
#ifdef __GLDISABLE
CWndButton* pWndButt = (CWndButton*)GetDlgItem(WIDC_BUTTON1);
pWndButt->EnableWindow( FALSE );
#endif
CWndInventory* pWndInventory = (CWndInventory*)GetWndBase( APP_INVENTORY );
CRect rectInventory = pWndInventory->GetWindowRect( TRUE );
CPoint ptInventory = rectInventory.TopLeft();
CPoint ptMove;
CRect rect = GetWindowRect( TRUE );
if( ptInventory.x > rect.Width() / 2 )
ptMove = ptInventory - CPoint( rect.Width(), 0 );
else
ptMove = ptInventory + CPoint( rectInventory.Width(), 0 );
Move( ptMove );
if( pGuild )
{
CWndButton* pWndButt = (CWndButton*)GetDlgItem(WIDC_BUTTON3);
#if __VER >= 8 // __GUILDCOMBAT_85
pWndButt->EnableWindow(FALSE);
pWndButt->SetVisible(FALSE);
#else // __VER >= 8
if( g_GuildCombatMng.m_uWinGuildId == pGuild->GetGuildId() )
pWndButt->EnableWindow(TRUE);
else
pWndButt->EnableWindow(FALSE);
#endif // __VER >= 8
}
#if __VER >= 11 // __GUILD_BANK_LOG
CWndButton* pWndButtLog = (CWndButton*)GetDlgItem(WIDC_LOG);
pWndButtLog->EnableWindow(TRUE);
pWndButtLog->SetVisible(TRUE);
#else //__GUILD_BANK_LOG
//CWndButton* pWndButtLog = (CWndButton*)GetDlgItem(WIDC_LOG);
//pWndButtLog->EnableWindow(FALSE);
//pWndButtLog->SetVisible(FALSE);
#endif //__GUILD_BANK_LOG
}
BOOL CWndGuildBank::OnChildNotify( UINT message, UINT nID, LRESULT* pLResult )
{
if( WIN_DBLCLK == message )
return FALSE;
LPSHORTCUT lpShortcut = reinterpret_cast<LPSHORTCUT>(pLResult);
if( lpShortcut == NULL )
return FALSE;
if( lpShortcut->m_pFromWnd == NULL )
return FALSE;
CWndBase* pWndFrame = lpShortcut->m_pFromWnd->GetFrameWnd();
if( pWndFrame == NULL )
return FALSE;
if( pWndFrame->GetWndId() == APP_INVENTORY )
{
switch (message)
{
case WIN_ITEMDROP:
{
if( nID == 11 ) // item
{
BOOL bForbid = TRUE;
SAFE_DELETE( g_WndMng.m_pWndTradeGold );
if( lpShortcut->m_dwData != 0 )
{
CWndItemCtrl* pWndItemCtrl = (CWndItemCtrl*)lpShortcut->m_pFromWnd;
UINT SelectCount = pWndItemCtrl->GetSelectedCount();
if( SelectCount != 1)
{
//g_WndMng.PutString( "장착 되어 있는것은 넣을수 없습니다", NULL, 0xffffff00 );
g_WndMng.PutString( prj.GetText(TID_GAME_EQUIPPUT), NULL, prj.GetTextColor( TID_GAME_EQUIPPUT ) );
}
else
{
for( int i = 0; i < (int)( SelectCount ); i++ )
{
int nItem = pWndItemCtrl->GetSelectedItem( i );
pWndItemCtrl->GetItem( nItem );
}
CItemElem* itemElem = (CItemElem*)lpShortcut->m_dwData;
if( itemElem->IsCharged() )
{
g_WndMng.PutString( prj.GetText( TID_GAME_NOTTRADE ), NULL, prj.GetTextColor( TID_GAME_NOTTRADE ) );
return FALSE;
}
if( itemElem->m_nItemNum > 1 )
{
g_WndMng.m_pWndTradeGold = new CWndTradeGold;
memcpy( &g_WndMng.m_pWndTradeGold->m_Shortcut, pLResult, sizeof(SHORTCUT) );
g_WndMng.m_pWndTradeGold->m_dwGold = itemElem->m_nItemNum;
g_WndMng.m_pWndTradeGold->m_nIdWndTo = APP_GUILD_BANK;
g_WndMng.m_pWndTradeGold->m_pWndBase = this;
g_WndMng.m_pWndTradeGold->Initialize( NULL, APP_TRADE_GOLD );
g_WndMng.m_pWndTradeGold->MoveParentCenter();
CWndStatic* pStatic = (CWndStatic *)g_WndMng.m_pWndTradeGold->GetDlgItem( WIDC_STATIC );
CWndStatic* pStaticCount = (CWndStatic *)g_WndMng.m_pWndTradeGold->GetDlgItem( WIDC_CONTROL1 );
CString strMain = prj.GetText(TID_GAME_MOVECOUNT);//"몇개를 이동하시겠습니까?";
CString strCount = prj.GetText(TID_GAME_NUMCOUNT);// " 갯수 : ";
pStatic->m_strTitle = strMain;
pStaticCount->m_strTitle = strCount;
}
else
{
g_DPlay.SendPutItemGuildBank( (BYTE)( lpShortcut->m_dwId ), 1, 1 );
}
}
}
}
}
break;
case WIN_DBLCLK:
{
}
break;
case WNM_CLICKED:
{
switch( nID )
{
case WTBID_CLOSE: // 종료
{
g_DPlay.SendCloseGuildBankWnd();
}
break;
}
}
break;
}
} else
{
switch( nID )
{
case WTBID_CLOSE:
{
g_DPlay.SendCloseGuildBankWnd();
}
break;
case WIDC_BUTTON1: // 길드 지원(공헌)
SAFE_DELETE(m_pwndGuildMerit);
// TID_GAME_GUILDNOTHINGNAME
{
CGuild *pGuild = g_pPlayer->GetGuild();
if( pGuild )
{
if( pGuild->m_szGuild[0] == '\0' )
{
// "길드명칭이 없어 길드에 지원을 할 수 없습니다. 길드마스터는 길드명칭을 정해주세요."
g_WndMng.OpenMessageBox( prj.GetText( TID_GAME_GUILDNOTHINGNAME ), MB_OK, this );
}
else
{
m_pwndGuildMerit = new CWndGuildMerit;
m_pwndGuildMerit->Initialize( this );
}
}
}
break;
case WIDC_BUTTON2: // 망토제작.
{
CGuild *pGuild = g_pPlayer->GetGuild();
if( pGuild )
{
if( pGuild->m_nLevel < 4 ) // 4레벨 이하는 망토못만듬.
{
g_WndMng.OpenMessageBox( prj.GetText( TID_GAME_GUILDNOTLEVEL ), MB_OK, this );
break;
}
g_DPlay.SendCreateGuildCloak();
}
}
break;
#if __VER < 8 // #ifndef __GUILDCOMBAT_85
case WIDC_BUTTON3:
{
CGuild *pGuild = g_pPlayer->GetGuild();
// 길드가 존재하고 우승한 길드이면서...그길드의 맴버이면...망토 생성가능
if( pGuild && g_GuildCombatMng.m_uWinGuildId == pGuild->GetGuildId() && pGuild->IsMember( g_pPlayer->m_idPlayer ) )
{
CWndGuildBankMessageBox* pBox = new CWndGuildBankMessageBox;
g_WndMng.OpenCustomBox( "", pBox );
CString str;
str.Format( prj.GetText( TID_GAME_GUILDCOMBAT_MAKE_CLOAK ) ); //"수정요망!! 용망토를 생성하시겠습니까? 1,000페냐의 제작 수수료가 부과됩니다." );
pBox->SetValue( str );
}
}
break;
#endif // __VER < 8
#if __VER >= 11 // __GUILD_BANK_LOG
case WIDC_LOG:
{
CGuild* pGuild = g_pPlayer->GetGuild();
CGuildMember* pGuildMemberl;
pGuildMemberl = pGuild->GetMember( g_pPlayer->m_idPlayer );
if( pGuildMemberl && (pGuildMemberl->m_nMemberLv == GUD_MASTER || pGuildMemberl->m_nMemberLv == GUD_KINGPIN) )
{
CWndGuildBankLog* pwndbanklog = (CWndGuildBankLog*)GetWndBase(APP_GUILD_BANK_LOG);
if(pwndbanklog == NULL)
{
g_WndMng.m_pWndGuildBankLog = new CWndGuildBankLog();
g_WndMng.m_pWndGuildBankLog->Initialize(this);
}
else
SAFE_DELETE(g_WndMng.m_pWndGuildBankLog);
}
else
g_WndMng.PutString( prj.GetText( TID_GAME_CANNT_USE_GLOG ), NULL, prj.GetTextColor( TID_GAME_CANNT_USE_GLOG ) );
}
break;
#endif //__GUILD_BANK_LOG
}
}
return CWndNeuz::OnChildNotify( message, nID, pLResult );
}
void CGuildList::Remove(CGuild *a2)
{
CGuild *i; // [sp+14h] [bp-4h]@1
for(i = this->Unk0; i; i = this->Unk0)
{
if(i == a2)
break;
i->nextguild();
}
if(i)
{
if(i->prevguild())
i->prevguild()->nextguild(i->nextguild());
if(i->nextguild())
i->nextguild()->prevguild(i->prevguild());
if(i == this->Unk0)
this->Unk0 = i->nextguild();
i->prevguild(0);
i->nextguild(0);
--this->Unk4;
if(i)
delete i;
}
}
CGuild *CGuildList::findguild(int a2)
{
for(CGuild *i = this->Unk0; i; i = i->nextguild())
{
if(i->index() == a2)
return i;
if(i->leftchild())
{
if(i->leftchild()->index() == a2)
return i->leftchild();
if(i->leftchild()->leftchild())
{
if(i->leftchild()->leftchild()->index() == a2)
return i->leftchild()->leftchild();
}
if(i->leftchild()->rightchild())
{
if(i->leftchild()->rightchild()->index() == a2)
return i->leftchild()->rightchild();
}
}
if(i->rightchild())
{
if(i->rightchild()->index() == a2)
return i->rightchild();
if(i->rightchild()->leftchild())
{
if(i->rightchild()->leftchild()->index() == a2)
return i->rightchild()->leftchild();
}
if(i->rightchild()->rightchild())
{
if(i->rightchild()->rightchild()->index() == a2)
return i->rightchild()->rightchild();
}
}
}
return 0;
}
