void CGSMSAddressListHandler::execute (CGSMSAddressList* pPacket , Player* pPlayer)
throw(ProtocolException, Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
Assert(pPacket != NULL);
Assert(pPlayer != NULL);
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Assert(pGamePlayer != NULL);
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pGamePlayer->getCreature());
Assert(pPC != NULL);
SMSAddressBook* pBook = pPC->getAddressBook();
if (pBook != NULL )
{
GCSMSAddressList* pPacket = pBook->getGCSMSAddressList();
if (pPacket != NULL ) pGamePlayer->sendPacket(pPacket);
}
#endif // __GAME_SERVER__
__END_DEBUG_EX __END_CATCH
}
void EffectIntimateGrail::unaffect(Creature* pCreature)
throw(Error)
{
__BEGIN_TRY
//cout << "EffectIntimateGrail" << "unaffect BEGIN" << endl;
Assert(pCreature != NULL);
pCreature->removeFlag(Effect::EFFECT_CLASS_INTIMATE_GRAIL);
if (pCreature->isPC() )
{
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature);
pPC->initAllStatAndSend();
}
// pSlayer->initAllStatAndSend();
Zone* pZone = pCreature->getZone();
Assert(pZone != NULL);
GCRemoveEffect gcRemoveEffect;
gcRemoveEffect.setObjectID(pCreature->getObjectID());
gcRemoveEffect.addEffectList(Effect::EFFECT_CLASS_INTIMATE_GRAIL);
pZone->broadcastPacket(pCreature->getX(), pCreature->getY(), &gcRemoveEffect);
//cout << "EffectIntimateGrail" << "unaffect END" << endl;
__END_CATCH
}
void CGFailQuestHandler::execute (CGFailQuest* pPacket , Player* pPlayer)
throw(Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
GamePlayer* pGP = dynamic_cast<GamePlayer*>(pPlayer);
Assert(pGP != NULL);
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pGP->getCreature());
pPC->getQuestManager()->adjustQuestStatus();
QuestMessage code;
if (pPacket->isFail() )
code = pPC->getQuestManager()->failQuest();
else
code = pPC->getQuestManager()->cancelQuest();
if (code == CANCEL_SUCCESS )
{
pPC->sendCurrentQuestInfo();
//cout << "Quest 시작 " << pPC->getName() << " " << pPacket->getQuestID() << endl;
}
else
{
//cout << "Quest 시작 실패 " << pPC->getName() << " " << (int)code << endl;
}
#endif // __GAME_SERVER__
__END_DEBUG_EX __END_CATCH
}
////////////////////////////////////////////////////////////////////////////////
// 액션을 실행한다.
////////////////////////////////////////////////////////////////////////////////
void ActionShowWarSchedule::execute (Creature * pCreature1 , Creature * pCreature2)
throw(Error)
{
__BEGIN_TRY
Assert(pCreature1 != NULL);
Assert(pCreature2 != NULL);
Assert(pCreature1->isNPC());
Assert(pCreature2->isPC());
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature2);
GCWarScheduleList gcWarScheduleList;
if (g_pVariableManager->isWarActive()
&& makeGCWarScheduleList(&gcWarScheduleList, m_ZoneID ) )
{
pPC->getPlayer()->sendPacket(&gcWarScheduleList);
}
else
{
GCNPCResponse gcNPCResponse;
gcNPCResponse.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPC->getPlayer()->sendPacket(&gcNPCResponse);
}
__END_CATCH
}
void ZonePacketHandler::handleUpdateTransformMessage(Message* pack) {
BaseClient* client = (BaseClient*) pack->getClient();
uint64 objid = pack->parseLong();
float x = pack->parseSignedShort() / 4.f;
float z = pack->parseSignedShort() / 4.f;
float y = pack->parseSignedShort() / 4.f;
uint32 counter = pack->parseInt();
SceneObject* scno = zone->getObject(objid);
if (scno != NULL) {
Locker _locker(scno);
scno->setPosition(x, z, y);
//scno->info("updating position");
_locker.release();
PlayerCreature* player = zone->getSelfPlayer();
Locker _playerLocker(player);
if (player->getFollowObject() == scno) {
player->updatePosition(x, z, y);
}
}
}
////////////////////////////////////////////////////////////////////////////////
// 액션을 실행한다.
////////////////////////////////////////////////////////////////////////////////
void ActionSelectBloodBible::execute (Creature * pCreature1 , Creature * pCreature2)
throw(Error)
{
__BEGIN_TRY
Assert(pCreature1 != NULL);
Assert(pCreature1->isNPC());
Assert(pCreature2 != NULL);
Assert(pCreature2->isPC());
NPC* pNPC = dynamic_cast<NPC*>(pCreature1);
Assert(pNPC != NULL);
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature2);
Assert(pPC != NULL);
Player* pPlayer = pCreature2->getPlayer();
Assert(pPlayer != NULL);
GCBloodBibleList gcPacket;
g_pBloodBibleBonusManager->getBloodBibleByRace(pPC->getRace(), back_inserter(gcPacket.getList()));
pPlayer->sendPacket(&gcPacket);
__END_CATCH
}
void CGModifyGuildMemberIntroHandler::execute (CGModifyGuildMemberIntro* pPacket , Player* pPlayer)
throw(Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
Assert(pPacket != NULL);
Assert(pPlayer != NULL);
SYSTEM_ASSERT(SYSTEM_GUILD);
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Assert(pGamePlayer != NULL);
Creature* pCreature = pGamePlayer->getCreature();
Assert(pCreature != NULL);
PlayerCreature* pPlayerCreature = dynamic_cast<PlayerCreature*>(pCreature);
Assert(pPlayerCreature != NULL);
// 길드를 가져온다.
Guild* pGuild = g_pGuildManager->getGuild(pPlayerCreature->getGuildID());
if (pGuild==NULL) return;
// 길드 멤버 정보를 가져온다.
GuildMember* pGuildMember = pGuild->getMember(pPlayerCreature->getName());
if (pGuildMember==NULL) return;
pGuildMember->saveIntro(pPacket->getGuildMemberIntro());
#endif // __GAME_SERVER__
__END_DEBUG_EX __END_CATCH
}
// Mysterious Item 가격
// itemClass와 pCreature의 능력치에 따라서 가격이 달라진다.
Price_t PriceManager::getMysteriousPrice(Item::ItemClass itemClass, Creature* pCreature) const
{
int multiplier = 1;
if (pCreature->isSlayer())
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pCreature);
Attr_t CSTR = pSlayer->getSTR(ATTR_BASIC);
Attr_t CDEX = pSlayer->getDEX(ATTR_BASIC);
Attr_t CINT = pSlayer->getINT(ATTR_BASIC);
Attr_t CSUM = CSTR + CDEX + CINT;
// 0~20 사이
multiplier = CSUM / 15;
}
else if (pCreature->isVampire())
{
Vampire* pVampire = dynamic_cast<Vampire*>(pCreature);
Level_t CLevel = pVampire->getLevel();
// 0~20 사이
multiplier = CLevel / 5;
}
else if (pCreature->isOusters())
{
Ousters* pOusters = dynamic_cast<Ousters*>(pCreature);
Level_t CLevel = pOusters->getLevel();
// 0~20 사이
multiplier = CLevel / 5;
}
// 1~20사이
multiplier = max(1, multiplier);
// 가격 평균을 알아온다.
InfoClassManager* pInfoClass = g_pItemInfoManager->getInfoManager(itemClass);
Assert(pInfoClass!=NULL);
// 가격 평균 * 능력치 비율?
int finalPrice = (int)pInfoClass->getAveragePrice() * multiplier;
// Blood Bible 보너스 적용
if (pCreature->isPC() )
{
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature);
int ratio = pPC->getGamblePriceRatio();
if (ratio != 0 )
{
// ratio 값은 마이너스 값이다.
finalPrice += getPercentValue(finalPrice, ratio);
}
}
return finalPrice;
}
void Zone::stopFollow() {
PlayerCreature* player = getSelfPlayer();
Locker _locker(player);
player->setFollow(NULL);
client->getClient()->info("stopped following", true);
}
void CGStashRequestBuyHandler::execute (CGStashRequestBuy* pPacket , Player* pPlayer)
throw(ProtocolException , Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
__BEGIN_DEBUG
#ifdef __GAME_SERVER__
Assert(pPacket != NULL);
Assert(pPlayer != NULL);
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Creature* pPC = pGamePlayer->getCreature();
PlayerCreature* pPlayerCreature = dynamic_cast<PlayerCreature*>(pPC);
BYTE curStashNum = pPlayerCreature->getStashNum();
// 가지고 있는 보관함이 맥스라면 리턴
if (curStashNum >= STASH_RACK_MAX)
{
GCNPCResponse failpkt;
failpkt.setCode(NPC_RESPONSE_STASH_SELL_FAIL_MAX);
pPlayer->sendPacket(&failpkt);
return;
}
Price_t price = g_pPriceManager->getStashPrice(curStashNum+1);
// 돈이 모자라도 실패쥐.
if (pPlayerCreature->getGold() < price)
{
GCNPCResponse failpkt;
failpkt.setCode(NPC_RESPONSE_STASH_SELL_FAIL_MONEY);
pPlayer->sendPacket(&failpkt);
return;
}
// 보관함 갯수를 한 칸 늘려주고...
pPlayerCreature->setStashNumEx(curStashNum+1);
// 돈을 줄인다.
//pPlayerCreature->setGoldEx(pPlayerCreature->getGold() - price);
// by sigi. 2002.9.4
pPlayerCreature->decreaseGoldEx(price);
// 마지막으로 OK 패킷을 날려준다.
GCNPCResponse okpkt;
okpkt.setCode(NPC_RESPONSE_STASH_SELL_OK);
pPlayer->sendPacket(&okpkt);
#endif
__END_DEBUG
__END_DEBUG_EX __END_CATCH
}
void CGSMSSendHandler::execute (CGSMSSend* pPacket , Player* pPlayer)
throw(ProtocolException , Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
Assert(pPacket != NULL);
Assert(pPlayer != NULL);
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Assert(pGamePlayer != NULL);
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pGamePlayer->getCreature());
Assert(pPC != NULL);
filelog("SMS.log", "[%s:%s] %s", pGamePlayer->getID().c_str(), pPC->getName().c_str(), pPacket->toString().c_str());
GCAddressListVerify gcVerify;
if (pPC->getSMSCharge() < pPacket->getNumbersList().size() )
{
filelog("SMS.log", "[%s:%s] Charge가 모자랍니다.", pGamePlayer->getID().c_str(), pPC->getName().c_str());
gcVerify.setCode(GCAddressListVerify::SMS_SEND_FAIL);
gcVerify.setParameter(GCAddressListVerify::SMS_SEND_FAIL_NOT_ENOUGH_CHARGE);
pGamePlayer->sendPacket(&gcVerify);
return;
}
pPC->setSMSCharge(pPC->getSMSCharge() - pPacket->getNumbersList().size());
char buffer[100];
sprintf(buffer, "SMSCharge=%u", pPC->getSMSCharge());
pPC->tinysave(buffer);
list<string>::const_iterator itr = pPacket->getNumbersList().begin();
list<string>::const_iterator endItr = pPacket->getNumbersList().end();
for (; itr != endItr ; ++itr )
{
if (SMSServiceThread::Instance().isValidNumber(*itr ) )
{
SMSMessage* pMsg = new SMSMessage(pPC->getName(), *itr, pPacket->getCallerNumber(), pPacket->getMessage());
SMSServiceThread::Instance().pushMessage(pMsg);
}
}
gcVerify.setCode(GCAddressListVerify::SMS_SEND_OK);
gcVerify.setParameter(pPC->getSMSCharge());
pGamePlayer->sendPacket(&gcVerify);
#endif
__END_DEBUG_EX __END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 플레이어가 팔려고 하는 아이템을 가지고 있는지 확인한 다음에,
// 일반 아이템과 모터 사이클 처리 부분으로 분기한다.
//////////////////////////////////////////////////////////////////////////////
void CGShopRequestSellHandler::execute (CGShopRequestSell* pPacket , Player* pPlayer)
throw(ProtocolException , Error) {
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
Assert(pPacket != NULL);
Assert(pPlayer != NULL);
ObjectID_t ITEMOID = pPacket->getItemObjectID();
BYTE OPCODE = pPacket->getOpCode();
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Creature* pCreature = pGamePlayer->getCreature();
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature);
if (OPCODE == SHOP_REQUEST_SELL_NORMAL) {
// 플레이어가 팔려고 하는 아이템을 가지고 있는지 검사
Inventory* pInventory = pPC->getInventory();
if (pInventory->hasItem(ITEMOID) == false)
throw ProtocolException("CGShopRequestSellHandler::execute() : No such item to sell!");
Item* pItem = pInventory->getItemWithObjectID(ITEMOID);
if (pItem == NULL || pPC->getStore()->hasItem(pItem))
return sendFailPacket(pPacket, pPlayer);
//ItemInfo* pItemInfo = g_pItemInfoManager->getItemInfo(pItem->getItemClass(), pItem->getItemType());
//Assert(pItemInfo!=NULL);
// 유니크 아이템은 못판다.
// 특정 아이템 클래스는 팔 수 없다. by sigi. 2002.8.29
// 선물 상자는 팔 수 있다. by bezz. 2002.12.13
// 커플링은 팔 수 없다. by Sequoia. 2003. 3. 3
// ItemUtil 안에 canSell 로 Extract 2003. 3. 3
if (!canSell(pItem))
return sendFailPacket(pPacket, pPlayer);
else if (pItem->getItemClass() == Item::ITEM_CLASS_KEY && pItem->getItemType() == 2)
executeMotorcycle(pPacket, pPlayer);
else
executeNormal(pPacket, pPlayer);
}
else if (OPCODE == SHOP_REQUEST_SELL_ALL_SKULL)
executeOpAllSkull(pPacket, pPlayer);
else if (OPCODE == SHOP_REQUEST_SWAP_ADVANCEMENT_ITEM)
executeOpSwapAdvancementItem(pPacket, pPlayer);
else
throw ProtocolException("CGShopRequestSellHandler::execute() : unknown op code");
#endif
__END_DEBUG_EX __END_CATCH
}
////////////////////////////////////////////////////////////////////////////////
// 액션을 실행한다.
////////////////////////////////////////////////////////////////////////////////
void ActionGiveItem::execute (Creature * pCreature1 , Creature * pCreature2)
throw(Error)
{
__BEGIN_TRY
Assert(pCreature2 != NULL);
Assert(pCreature2->isPC());
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature2);
Assert(pPC != NULL);
Player* pPlayer = pCreature2->getPlayer();
Assert(pPlayer != NULL);
list<OptionType_t> optionTypeList;
Item* pItem = g_pItemFactoryManager->createItem(m_ItemClass, m_ItemType, optionTypeList);
Assert(pItem != NULL);
_TPOINT pt;
Inventory* pInventory = pPC->getInventory();
Assert(pInventory != NULL);
if (!pInventory->getEmptySlot(pItem, pt))
{
// ConditionHasInvenSpace 컨디션과 반드시 함께 써야만 한다.
throw Error("ActionGiveItem: 제발 ConditionHasInvenSpace랑 같이 쓰자. 인벤토리에 자리없다.");
}
CoordInven_t X = pt.x;
CoordInven_t Y = pt.y;
pPC->getZone()->getObjectRegistry().registerObject(pItem);
pInventory->addItem(X, Y, pItem);
pItem->create(pPC->getName(), STORAGE_INVENTORY, 0, X, Y);
if (pItem != NULL && pItem->isTraceItem() )
{
remainTraceLog(pItem, "ActionGiveItem", pCreature2->getName(), ITEM_LOG_CREATE, DETAIL_EVENTNPC);
remainTraceLogNew(pItem, pCreature2->getName(), ITL_GET, ITLD_EVENTNPC , pCreature2->getZone()->getZoneID());
}
// 클라이언트에 선물이 추가되었음을 알린다.
GCCreateItem gcCreateItem;
makeGCCreateItem(&gcCreateItem, pItem, X, Y);
pPlayer->sendPacket(&gcCreateItem);
__END_CATCH
}
bool DynamicZoneGateOfAlter::openGateToAlter()
{
Assert(m_pZone != NULL);
// 퀘스트를 진행시킨다.
map<ObjectID_t, Creature*>::const_iterator itr = m_pZone->getPCManager()->getCreatures().begin();
map<ObjectID_t, Creature*>::const_iterator endItr = m_pZone->getPCManager()->getCreatures().end();
for (; itr != endItr; ++itr )
{
Assert(itr->second != NULL);
if (itr->second->isPC() )
{
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(itr->second);
Assert(pPC != NULL);
pPC->getGQuestManager()->clearDynamicZone(m_TemplateZoneID);
}
}
// 포탈 위치를 찾아서 그 위에다 EffectTilePortal 을 보낸다.
int tx = -1;
int ty = -1;
for (int x=0; x<m_pZone->getWidth(); x++)
{
for (int y=0; y<m_pZone->getHeight(); y++)
{
Tile& tile = m_pZone->getTile(x,y);
if (tile.hasPortal())
{
tx = x;
ty = y;
}
}
}
if (tx != -1 )
{
GCAddEffectToTile gcAddEffectToTile;
gcAddEffectToTile.setEffectID(Effect::EFFECT_CLASS_TILE_PORTAL);
gcAddEffectToTile.setDuration(999999);
gcAddEffectToTile.setXY(tx, ty);
m_pZone->broadcastPacket(&gcAddEffectToTile);
}
return true;
}
////////////////////////////////////////////////////////////////////////////////
// is satisfied?
////////////////////////////////////////////////////////////////////////////////
bool ConditionNotGuildMember::isSatisfied (Creature * pCreature1 , Creature * pCreature2, void* pParam) const
throw()
{
Assert(pCreature2 != NULL);
Assert(pCreature2->isPC());
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature2);
// 길드 이름을 가져와서 없으면 길드원이 아니다
if (pPC->getGuildName().size() == 0 )
return true;
return false;
}
void ObjectController::doEnqueueCommand(uint32 command, const UnicodeString& arguments) {
PlayerCreature* object = zone->getSelfPlayer();
Locker _locker(object);
BaseMessage* message = new ObjectControllerMessage(object->getObjectID(), 0x23, 0x116);
message->insertInt(object->getNewActionCount());
message->insertInt(command);
message->insertLong(0);
message->insertUnicode(arguments);
object->getClient()->sendMessage(message);
}
void Zone::follow(const String& name) {
SceneObject* object = objectManager->getObject(name);
if (object == NULL) {
client->getClient()->error(name + " not found");
return;
}
PlayerCreature* player = getSelfPlayer();
Locker _locker(player);
player->setFollow(object);
client->getClient()->info("started following " + name, true);
}
void ObjectController::doSayCommand(const UnicodeString& msg) {
PlayerCreature* object = zone->getSelfPlayer();
Locker _locker(object);
StringBuffer full;
full << "0 " << "0 " << "0 " << "0 " << "0 " << msg.toString();
BaseMessage* message = new ObjectControllerMessage(object->getObjectID(), 0x23, 0x116);
message->insertInt(object->getNewActionCount());
message->insertInt(String("spatialchatinternal").hashCode());
message->insertLong(0);
message->insertUnicode(full.toString());
object->getClient()->sendMessage(message);
}
////////////////////////////////////////////////////////////////////////////////
// 액션을 실행한다.
////////////////////////////////////////////////////////////////////////////////
void ActionGiveFinalLottoScript::execute (Creature * pCreature1 , Creature * pCreature2)
throw(Error)
{
__BEGIN_TRY
Assert(pCreature1 != NULL);
Assert(pCreature2 != NULL);
Assert(pCreature1->isNPC());
Assert(pCreature2->isPC());
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature2);
Assert(pPC != NULL);
GCNPCAsk gcNPCAsk;
gcNPCAsk.setObjectID(pCreature1->getObjectID());
gcNPCAsk.setNPCID(dynamic_cast<NPC*>(pCreature1)->getNPCID());
QuestID_t qID;
if (pPC->getQuestManager()->successEventQuest(4, qID ) )
{
ItemType_t fitItem = rand()%10;
if (pPC->getInventory()->findItem(Item::ITEM_CLASS_EVENT_ITEM, fitItem ) != NULL )
{
pPC->getQuestManager()->getEventQuestAdvanceManager()->advanced(EventQuestAdvanceManager::EVENT_QUEST_LEVEL_MAX-1);
gcNPCAsk.setScriptID(m_SuccessScriptID);
}
else
{
gcNPCAsk.setScriptID(m_FailScriptID);
}
list<Item*> iList;
pPC->getInventory()->clearQuestItem(iList);
list<Item*>::iterator itr = iList.begin();
list<Item*>::iterator endItr = iList.end();
for (; itr != endItr ; ++itr )
{
GCDeleteInventoryItem gcDII;
gcDII.setObjectID((*itr)->getObjectID());
pPC->getPlayer()->sendPacket(&gcDII);
(*itr)->destroy();
SAFE_DELETE(*itr);
}
iList.clear();
}
else
{
gcNPCAsk.setScriptID(m_CounterScriptID);
}
pPC->getPlayer()->sendPacket(&gcNPCAsk);
__END_CATCH
}
////////////////////////////////////////////////////////////////////////////////
// 액션을 실행한다.
////////////////////////////////////////////////////////////////////////////////
void ActionGiveQuestItem::execute (Creature * pCreature1 , Creature * pCreature2)
throw(Error)
{
__BEGIN_TRY
Assert(pCreature1 != NULL);
Assert(pCreature2 != NULL);
Assert(pCreature1->isNPC());
Assert(pCreature2->isPC());
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature2);
Assert(pPC != NULL);
TPOINT pt;
Item* pItem = pPC->getQuestItem();
if (pItem == NULL || !pPC->getInventory()->getEmptySlot(pItem, pt ) )
{
GCNPCAsk gcNPCAsk;
gcNPCAsk.setObjectID(pCreature1->getObjectID());
gcNPCAsk.setScriptID(m_CounterScriptID);
gcNPCAsk.setNPCID(dynamic_cast<NPC*>(pCreature1)->getNPCID());
pPC->getPlayer()->sendPacket(&gcNPCAsk);
return;
}
if (pPC->getInventory()->addItem(pItem, pt ) )
{
pPC->setQuestItem(NULL);
pPC->getZone()->registerObject(pItem);
pItem->create(pPC->getName(), STORAGE_INVENTORY, 0, pt.x, pt.y);
if (pItem->isUnique() || pItem->isTimeLimitItem() )
{
pPC->addTimeLimitItem(pItem, 43200);
}
GCCreateItem gcCreateItem;
makeGCCreateItem(&gcCreateItem, pItem, pt.x, pt.y);
pPC->getPlayer()->sendPacket(&gcCreateItem);
}
__END_CATCH
}
////////////////////////////////////////////////////////////////////////////////
// 액션을 실행한다.
////////////////////////////////////////////////////////////////////////////////
void ActionTurnOnFlag::execute (Creature * pCreature1 , Creature * pCreature2)
throw(Error)
{
__BEGIN_TRY
Assert(pCreature2 != NULL);
Assert(pCreature2->isPC());
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature2);
FlagSet* pFlagSet = pPC->getFlagSet();
if (pFlagSet->isOn(m_Index) == false)
{
pFlagSet->turnOn(m_Index);
pFlagSet->save(pCreature2->getName());
}
__END_CATCH
}
void DynamicZoneGateOfAlter::processEntering()
{
// 퀘스트 존에 들어왔음을 알린다.
map<ObjectID_t, Creature*>::const_iterator itr = m_pZone->getPCManager()->getCreatures().begin();
map<ObjectID_t, Creature*>::const_iterator endItr = m_pZone->getPCManager()->getCreatures().end();
for (; itr != endItr; ++itr )
{
Assert(itr->second != NULL);
if (itr->second->isPC() )
{
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(itr->second);
Assert(pPC != NULL);
pPC->getGQuestManager()->enterDynamicZone(m_TemplateZoneID);
}
}
}
void DynamicZoneSlayerMirrorOfAbyss::killPC()
{
Assert(m_pZone != NULL);
// PC 를 죽인다.
map<ObjectID_t, Creature*>::const_iterator itr = m_pZone->getPCManager()->getCreatures().begin();
map<ObjectID_t, Creature*>::const_iterator endItr = m_pZone->getPCManager()->getCreatures().end();
for (; itr != endItr; ++itr )
{
Assert(itr->second != NULL);
if (itr->second->isPC() )
{
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(itr->second);
Assert(pPC != NULL);
if (pPC->isSlayer() )
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pPC);
Assert(pSlayer != NULL);
pSlayer->setHP(0);
}
else if (pPC->isVampire() )
{
Vampire* pVampire = dynamic_cast<Vampire*>(pPC);
Assert(pVampire != NULL);
pVampire->setHP(0);
}
else if (pPC->isOusters() )
{
Ousters* pOusters = dynamic_cast<Ousters*>(pPC);
Assert(pOusters != NULL);
pOusters->setHP(0);
}
}
}
}
void CGSelectGuildMemberHandler::execute (CGSelectGuildMember* pPacket , Player* pPlayer)
throw(Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
Assert(pPacket != NULL);
Assert(pPlayer != NULL);
SYSTEM_ASSERT(SYSTEM_GUILD);
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Assert(pGamePlayer != NULL);
PlayerCreature* pPlayerCreature = dynamic_cast<PlayerCreature*>(pGamePlayer->getCreature());
Assert(pPlayerCreature != NULL);
// 선택한 길드를 가져온다.
Guild* pGuild = g_pGuildManager->getGuild(pPlayerCreature->getGuildID());
//try { Assert(pGuild != NULL); } catch (Throwable& ) { return; }
if (pGuild==NULL) return;
// 선택한 길드 멤버를 가져온다.
GuildMember* pGuildMember = pGuild->getMember(pPacket->getName());
//try { Assert(pGuildMember != NULL); } catch (Throwable& ) { return; }
if (pGuildMember==NULL) return;
GCShowGuildMemberInfo gcShowGuildMemberInfo;
gcShowGuildMemberInfo.setGuildID(pGuildMember->getGuildID());
gcShowGuildMemberInfo.setName(pGuildMember->getName());
gcShowGuildMemberInfo.setGuildMemberRank(pGuildMember->getRank());
gcShowGuildMemberInfo.setGuildMemberIntro(pGuildMember->getIntro());
pPlayer->sendPacket(&gcShowGuildMemberInfo);
#endif // __GAME_SERVER__
__END_DEBUG_EX __END_CATCH
}
void CGDeleteSMSAddressHandler::execute (CGDeleteSMSAddress* pPacket , Player* pPlayer)
throw(ProtocolException, Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
Assert(pPacket != NULL);
Assert(pPlayer != NULL);
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Assert(pGamePlayer != NULL);
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pGamePlayer->getCreature());
Assert(pPC != NULL);
GCAddressListVerify gcVerify;
SMSAddressBook* pBook = pPC->getAddressBook();
Assert(pBook != NULL);
int result = pBook->removeAddressElement(pPacket->getElementID());
if (result != 0 )
{
gcVerify.setCode(GCAddressListVerify::ADDRESS_LIST_DELETE_FAIL);
gcVerify.setParameter(result);
pGamePlayer->sendPacket(&gcVerify);
return;
}
gcVerify.setCode(GCAddressListVerify::ADDRESS_LIST_DELETE_OK);
gcVerify.setParameter(result);
pGamePlayer->sendPacket(&gcVerify);
#endif // __GAME_SERVER__
__END_DEBUG_EX __END_CATCH
}
bool DynamicZoneSlayerMirrorOfAbyss::openGateToOut()
{
Assert(m_pZone != NULL);
// 퀘스트를 진행시킨다.
map<ObjectID_t, Creature*>::const_iterator itr = m_pZone->getPCManager()->getCreatures().begin();
map<ObjectID_t, Creature*>::const_iterator endItr = m_pZone->getPCManager()->getCreatures().end();
for (; itr != endItr; ++itr )
{
Assert(itr->second != NULL);
if (itr->second->isPC() )
{
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(itr->second);
Assert(pPC != NULL);
pPC->getGQuestManager()->clearDynamicZone(m_TemplateZoneID);
}
}
return true;
}
void CGSelectWayPointHandler::executeEnterQuestZone(CGSelectWayPoint* pPacket , Player* pPlayer, int targetDynamicZoneType)
throw(Error)
{
__BEGIN_TRY
#ifdef __GAME_SERVER__
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Assert(pGamePlayer != NULL);
Creature* pCreature = pGamePlayer->getCreature();
Assert(pCreature != NULL);
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature);
Assert(pPC != NULL);
bool bQuestCondition = pPC->getGQuestManager()->canEnterDynamicZone(pPacket->getZoneID());
DynamicZoneGroup* pDynamicZoneGroup = g_pDynamicZoneManager->getDynamicZoneGroup(targetDynamicZoneType);
Assert(pDynamicZoneGroup != NULL);
bool bDynamicZoneAvailable = pDynamicZoneGroup->canEnter();
if (bQuestCondition && bDynamicZoneAvailable )
{
DynamicZone* pDynamicZone = pDynamicZoneGroup->getAvailableDynamicZone();
transportCreature(pPC, pDynamicZone->getZoneID(), 15, 15, true);
pPC->getGQuestManager()->enterDynamicZone(pPacket->getZoneID());
}
#endif
__END_CATCH
}
void CGTradeAddItemHandler::executeOusters (CGTradeAddItem* pPacket , Player* pPlayer)
throw(ProtocolException , Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
// 상위 함수에서 에러를 검사했기 때문에,
// 여기서는 포인터가 널인지를 검사하지 않는다.
ObjectID_t TargetOID = pPacket->getTargetObjectID();
ObjectID_t ItemOID = pPacket->getItemObjectID();
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Creature* pPC = pGamePlayer->getCreature();
Zone* pZone = pPC->getZone();
PlayerCreature* pTargetPC = dynamic_cast<PlayerCreature*>(pZone->getCreature(TargetOID));
// NoSuch제거. by sigi. 2002.5.2
if (pTargetPC==NULL) return;
Ousters* pSender = dynamic_cast<Ousters*>(pPC);
TradeManager* pTradeManager = pZone->getTradeManager();
Assert(pTradeManager != NULL);
// 교환 대상에 추가할 아이템의 포인터를 얻어낸다.
CoordInven_t X, Y;
Inventory* pInventory = pSender->getInventory();
Item* pItem = pInventory->findItemOID(ItemOID, X, Y);
// 추가할 아이템이 없다면 당연히 더 이상 처리가 불가능
// Relic은 교환할 수 없다.
if (pItem == NULL
|| !canTrade(pItem )
|| pSender->getStore()->hasItem(pItem)
|| (pItem->getItemClass() == Item::ITEM_CLASS_SUB_INVENTORY && hasItemWithItemClass(pTargetPC, Item::ITEM_CLASS_SUB_INVENTORY ) )
)
{
pTradeManager->cancelTrade(pPC);
executeError(pPacket, pPlayer, GC_TRADE_ERROR_CODE_ADD_ITEM);
return;
}
//
//#ifdef __XMAS_EVENT_CODE__
// 녹색 선물 상자인 경우에는, 상대방에게 적색 선물 상자가 없는지 검사한 후,
// 인증 패킷을 보내줘야 한다.
if (pItem->getItemClass() == Item::ITEM_CLASS_EVENT_GIFT_BOX)
{
PlayerCreature* pReceiver = dynamic_cast<PlayerCreature*>(pTargetPC);
Item* pExtraSlotItem = pReceiver->getExtraInventorySlotItem();
if (pItem->getItemType() == 0)
{
Inventory* pTargetInventory = pReceiver->getInventory();
if (pTargetInventory->hasRedGiftBox())
{
// 적색 선물 상자를 가지고 있다면 더할 수 없다. 리턴시킨다.
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_FAIL);
pPlayer->sendPacket(&gcTradeVerify);
return;
}
else if (pExtraSlotItem != NULL)
{
if (pExtraSlotItem->getItemClass() == Item::ITEM_CLASS_EVENT_GIFT_BOX && pExtraSlotItem->getItemType() == 1)
{
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_FAIL);
pPlayer->sendPacket(&gcTradeVerify);
return;
}
}
else
{
// 적색 선물 상자를 가지고 있지 않다면, 걍 넘어간다.
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_OK);
pPlayer->sendPacket(&gcTradeVerify);
}
}
else if (pItem->getItemType() == 1)
{
// 적색 선물 상자는 교환 품목이 될 수 없다.
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_FAIL);
pPlayer->sendPacket(&gcTradeVerify);
return;
}
}
//#endif
//
TradeInfo* pInfo1 = pTradeManager->getTradeInfo(pSender->getName());
TradeInfo* pInfo2 = pTradeManager->getTradeInfo(pTargetPC->getName());
list<Item*> tradeList1 = pInfo1->getItemList();
if (pItem->getItemClass() == Item::ITEM_CLASS_EVENT_GIFT_BOX && pItem->getItemType() > 1 && pItem->getItemType() < 6)
{
for (list<Item*>::iterator itr = tradeList1.begin(); itr != tradeList1.end(); itr++)
{
Item* pTradeItem = (*itr);
if (pTradeItem->getItemClass() == Item::ITEM_CLASS_EVENT_GIFT_BOX && pTradeItem->getItemType() > 1 && pTradeItem->getItemType() < 6)
{
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_FAIL);
pPlayer->sendPacket(&gcTradeVerify);
return;
}
}
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_OK);
pPlayer->sendPacket(&gcTradeVerify);
}
else if (pItem->getItemClass() == Item::ITEM_CLASS_EVENT_GIFT_BOX && pItem->getItemType() >= 6)
{
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_OK);
pPlayer->sendPacket(&gcTradeVerify);
}
// TradeManager에 교환 대상으로서 아이템을 더한다.
//Assert(pInfo1->addItem(pItem));
pInfo1->addItem(pItem);
// 현재 OK를 누른 상태라면, 클라이언트에게 인증 패킷을 보내줘야 한다.
if (pInfo1->getStatus() == TRADE_FINISH)
{
//cout << "CGTradeRemoveItem [" << pSender->getName() << "]의 상태가 TRADE_FINISH이므로, 인증 패킷을 보내준다." << endl;
// 인증 패킷을 날려준다.
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_WHEN_ACCEPT);
pPlayer->sendPacket(&gcTradeVerify);
}
else
{
//cout << "CGTradeRemoveItem [" << pSender->getName() << "]의 상태가 TRADE_FINISH가 아니므로, 인증 패킷 날리지 않는다." << endl;
}
// 아이템을 더하거나 뺄 경우, 상태가 TRADE_FINISH라면
// TRADE_TRADING으로 바꿔줘야 한다.
pInfo1->setStatus(TRADE_TRADING);
pInfo2->setStatus(TRADE_TRADING);
// 상대방에게 날려줄 아이템 정보를 구성한다.
GCTradeAddItem gcTradeAddItem;
makeGCTradeAddItemPacket(&gcTradeAddItem, pSender->getObjectID(), pItem, X, Y);
// 상대방에게 교환할 아이템 정보를 날려준다.
Player* pTargetPlayer = pTargetPC->getPlayer();
pTargetPlayer->sendPacket(&gcTradeAddItem);
#endif
__END_DEBUG_EX __END_CATCH
}
////////////////////////////////////////////////////////////////////////////////
// 액션을 실행한다.
////////////////////////////////////////////////////////////////////////////////
void ActionShowTaxBalance::execute (Creature * pCreature1 , Creature * pCreature2)
throw(Error)
{
__BEGIN_TRY
Assert(pCreature1 != NULL);
Assert(pCreature2 != NULL);
Assert(pCreature1->isNPC());
Assert(pCreature2->isPC());
bool bSuccess = true;
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature2);
Player* pPlayer = pPC->getPlayer();
Assert(pPlayer != NULL);
GuildID_t guildID = pPC->getGuildID();
GCNPCResponse deny;
Guild* pGuild = g_pGuildManager->getGuild(guildID);
if(bSuccess && pGuild == NULL )
{
// 길드가 없다.
bSuccess = false;
deny.setCode(NPC_RESPONSE_NO_GUILD);
}
if(bSuccess && pGuild->getMaster() != pPC->getName() )
{
// 길드 마스터가 아니다.
bSuccess = false;
deny.setCode(NPC_RESPONSE_NOT_GUILD_MASTER);
}
// 길드 마스터이다.
list<CastleInfo*> pCastleInfoList = g_pCastleInfoManager->getGuildCastleInfos(guildID);
if(bSuccess && pCastleInfoList.empty() )
{
// 길드가 소유한 성이 없다.
bSuccess = false;
deny.setCode(NPC_RESPONSE_HAS_NO_CASTLE);
}
list<CastleInfo*>::iterator itr = pCastleInfoList.begin();
CastleInfo* pCastleInfo = NULL;
for (; itr != pCastleInfoList.end() ; itr++ )
{
if ((*itr)->getZoneID() == pCreature1->getZoneID() )
{
pCastleInfo = (*itr);
break;
}
}
if(bSuccess && pCastleInfo == NULL)
{
bSuccess = false;
deny.setCode(NPC_RESPONSE_NOT_YOUR_CASTLE);
}
if (bSuccess )
{
GCNPCResponse response;
response.setCode(NPC_RESPONSE_SHOW_TAX_BALANCE);
response.setParameter((uint)pCastleInfo->getTaxBalance());
pPlayer->sendPacket(&response);
}
else
{
pPlayer->sendPacket(&deny);
}
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
__END_CATCH
}
void CGAddItemToCodeSheetHandler::execute (CGAddItemToCodeSheet* pPacket , Player* pPlayer)
throw(Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
Assert(pPacket != NULL);
Assert(pPlayer != NULL);
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Assert(pGamePlayer != NULL);
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pGamePlayer->getCreature());
Assert(pPC != NULL);
CoordInven_t x,y;
Item* pMouseItem = pPC->getExtraInventorySlotItem();
Item* pTargetItem = pPC->getInventory()->findItemOID(pPacket->getObjectID(), x, y);
GCCannotUse failpkt;
failpkt.setObjectID(pPacket->getObjectID());
if (pMouseItem == NULL || pTargetItem == NULL
|| pMouseItem->getItemClass() != Item::ITEM_CLASS_EVENT_ITEM
|| pTargetItem->getItemClass() != Item::ITEM_CLASS_CODE_SHEET
|| pMouseItem->getItemType() > 26 || pMouseItem->getItemType() < 22
|| pTargetItem->getItemType() != 0 )
{
pPlayer->sendPacket(&failpkt);
return;
}
GCUseOK okpkt;
uint StoneNum = pMouseItem->getItemType()-21;
Assert(StoneNum >= 1 && StoneNum <= 5);
x = pPacket->getX();
y = pPacket->getY();
vector<OptionType_t> OptionType(pTargetItem->getOptionTypeList().begin(), pTargetItem->getOptionTypeList().end());
if (OptionType.size() < 30 )
{
pPlayer->sendPacket(&failpkt);
return;
}
uint TargetStoneNum = getStoneNum(OptionType, x, y);
if (TargetStoneNum != 0xf || !canPutStone(OptionType, x, y, StoneNum ) )
{
pPlayer->sendPacket(&failpkt);
return;
}
setStoneNum(OptionType, x, y, StoneNum);
if (isComplete(OptionType ) )
{
pTargetItem->setItemType(1);
pTargetItem->tinysave("ItemType=1");
}
pTargetItem->setOptionType(list<OptionType_t>(OptionType.begin(), OptionType.end()));
string optionField;
setOptionTypeToField(pTargetItem->getOptionTypeList(), optionField);
char query[100];
sprintf(query, "OptionType = '%s'", optionField.c_str());
pTargetItem->tinysave(query);
pPC->deleteItemFromExtraInventorySlot();
pMouseItem->destroy();
SAFE_DELETE(pMouseItem);
pPlayer->sendPacket(&okpkt);
__END_DEBUG_EX __END_CATCH
}
