//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 타일 핸들러
//////////////////////////////////////////////////////////////////////////////
void IceField::execute(Ousters* pOusters, ZoneCoord_t X, ZoneCoord_t Y, OustersSkillSlot* pOustersSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pOusters != NULL);
Assert(pOustersSkillSlot != NULL);
try
{
Player* pPlayer = pOusters->getPlayer();
Zone* pZone = pOusters->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
Item* pWeapon = pOusters->getWearItem(Ousters::WEAR_RIGHTHAND);
if (pWeapon == NULL || pWeapon->getItemClass() != Item::ITEM_CLASS_OUSTERS_WRISTLET || !pOusters->isRealWearingEx(Ousters::WEAR_RIGHTHAND))
{
executeSkillFailException(pOusters, pOustersSkillSlot->getSkillType());
return;
}
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = pOustersSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
ZoneCoord_t myX = pOusters->getX();
ZoneCoord_t myY = pOusters->getY();
// 이펙트의 지속시간을 계산한다.
SkillInput input(pOusters, pOustersSkillSlot);
SkillOutput output;
computeOutput(input, output);
int RequiredMP = (int)pSkillInfo->getConsumeMP() + pOustersSkillSlot->getExpLevel();
bool bManaCheck = hasEnoughMana(pOusters, RequiredMP);
bool bTimeCheck = verifyRunTime(pOustersSkillSlot);
bool bRangeCheck = verifyDistance(pOusters, X, Y, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessMagic(pOusters, pSkillInfo, pOustersSkillSlot);
bool bSatisfyRequire = pOusters->satisfySkillRequire(pSkillInfo);
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
if (rect.ptInRect(X, Y)) bTileCheck = true;
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bTileCheck && bSatisfyRequire)
{
decreaseMana(pOusters, RequiredMP, _GCSkillToTileOK1);
int grade = 0;
if (input.SkillLevel <= 10 ) grade = 0;
else if (input.SkillLevel <= 20 ) grade = 1;
else if (input.SkillLevel < 30 ) grade = 2;
else grade = 3;
list<Creature*> cList; // denier list
for (int i=0; i<m_MaskNum[grade]; i++)
{
POINT& pt = m_IceFieldMask[grade][i];
int tileX = X+pt.x;
int tileY = Y+pt.y;
if (rect.ptInRect(tileX, tileY))
{
Tile& tile = pZone->getTile(tileX, tileY);
if (tile.getEffect(Effect::EFFECT_CLASS_TRYING_POSITION) ) continue;
// 현재 타일에다 이펙트를 추가할 수 있다면...
if (tile.canAddEffect())
{
// 같은 effect가 있으면 지운다.
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_ICE_FIELD);
if (pOldEffect != NULL)
{
ObjectID_t effectID = pOldEffect->getObjectID();
pZone->deleteEffect(effectID);// fix me
}
// 이펙트 클래스를 생성한다.
EffectIceField* pEffect = new EffectIceField(pZone , tileX, tileY);
pEffect->setCasterName(pOusters->getName());
pEffect->setCasterID(pOusters->getObjectID());
pEffect->setDeadline(output.Duration);
pEffect->setDuration(output.Range);
pEffect->setNextTime(0);
pEffect->setTick(output.Tick);
// Tile에 붙이는 Effect는 ObjectID를 등록받아야 한다.
ObjectRegistry & objectregister = pZone->getObjectRegistry();
objectregister.registerObject(pEffect);
pZone->addEffect(pEffect);
tile.addEffect(pEffect);
const list<Object*>& oList = tile.getObjectList();
for(list<Object*>::const_iterator itr = oList.begin(); itr != oList.end(); itr++)
{
Object* pTarget = *itr;
Creature* pTargetCreature = NULL;
if (pTarget->getObjectClass() == Object::OBJECT_CLASS_CREATURE
&& ((pTargetCreature = dynamic_cast<Creature*>(pTarget))->isSlayer() || pTargetCreature->isVampire() )
&& !checkZoneLevelToHitTarget(pTargetCreature )
)
{
cList.push_back(pTargetCreature);
_GCSkillToTileOK2.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK4.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK5.addCListElement(pTargetCreature->getObjectID());
pEffect->affect(pTargetCreature);
}
// pEffect->affect(pTarget);
}
}
}
}
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setDuration(output.Duration);
_GCSkillToTileOK1.setRange(grade);
_GCSkillToTileOK2.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setDuration(output.Duration);
_GCSkillToTileOK2.setRange(grade);
//_GCSkillToTileOK2.addShortData(MODIFY_VISION, ICE_FIELD_SIGHT);
_GCSkillToTileOK3.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setRange(grade);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK5.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setRange(grade);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK6.setOrgXY(myX, myY);
_GCSkillToTileOK6.setSkillType(SkillType);
_GCSkillToTileOK6.setX(X);
_GCSkillToTileOK6.setY(Y);
_GCSkillToTileOK6.setDuration(output.Duration);
_GCSkillToTileOK6.setRange(grade);
//_GCSkillToTileOK6.addShortData(MODIFY_VISION, ICE_FIELD_SIGHT);
for(list<Creature*>::const_iterator itr = cList.begin(); itr != cList.end(); itr++)
{
Creature* pTargetCreature = *itr;
if (canSee(pTargetCreature, pOusters)) pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK2);
else pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK6);
}
pPlayer->sendPacket(&_GCSkillToTileOK1);
cList.push_back(pOusters);
list<Creature*> watcherList = pZone->getWatcherList(myX, myY, pOusters);
// watcherList에서 cList에 속하지 않고, caster(pOusters)를 볼 수 없는 경우는
// OK4를 보내고.. cList에 추가한다.
for(list<Creature*>::const_iterator itr = watcherList.begin(); itr != watcherList.end(); itr++)
{
bool bBelong = false;
for(list<Creature*>::const_iterator tItr = cList.begin(); tItr != cList.end(); tItr++)
if (*itr == *tItr)
bBelong = true;
Creature* pWatcher = (*itr);
if (bBelong == false && canSee(pWatcher, pOusters) == false)
{
//Assert(pWatcher->isPC()); // 당연 PC다.. Zone::getWatcherList는 PC만 return한다
if (!pWatcher->isPC())
{
//cout << "IceField : 왓처 리스트가 PC가 아닙니다." << endl;
// GCSkillFailed1 _GCSkillFailed1;
// _GCSkillFailed1.setSkillType(getSkillType());
// pOusters->getPlayer()->sendPacket(&_GCSkillFailed1);
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
// return;
continue;
}
pWatcher->getPlayer()->sendPacket(&_GCSkillToTileOK4);
cList.push_back(*itr);
}
}
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList, false);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
pOustersSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pOusters, getSkillType(), NULL);
}
}
catch (Throwable & t)
{
executeSkillFailException(pOusters, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 몬스터 셀프 핸들러
//////////////////////////////////////////////////////////////////////////////
void BloodyWall::execute(Monster* pMonster, ZoneCoord_t X, ZoneCoord_t Y)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pMonster != NULL);
try
{
Zone* pZone = pMonster->getZone();
Assert(pZone != NULL);
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = SKILL_BLOODY_WALL;
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
ZoneCoord_t myX = pMonster->getX();
ZoneCoord_t myY = pMonster->getY();
// 마스터는 무조건~~
bool bRangeCheck = pMonster->isMaster()
#ifdef __UNDERWORLD__
|| pMonster->isUnderworld() || pMonster->getMonsterType() == 599
#endif
|| verifyDistance(pMonster, X, Y, pSkillInfo->getRange());
bool bHitRoll = pMonster->isMaster()
#ifdef __UNDERWORLD__
|| pMonster->isUnderworld() || pMonster->getMonsterType() == 599
#endif
|| HitRoll::isSuccessMagic(pMonster, pSkillInfo);
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
if (rect.ptInRect(X, Y)) bTileCheck = true;
if (bRangeCheck && bHitRoll && bTileCheck)
{
// 이펙트의 지속시간을 계산한다.
SkillInput input(pMonster);
SkillOutput output;
computeOutput(input, output);
//Range_t Range = 3;
Dir_t Dir = getDirectionToPosition(myX, myY, X, Y);
list<Creature*> cList; // denier list
for (int i=0; i<5; i++)
{
POINT& pt = m_BloodyWallMask[Dir][i];
int tileX = X+pt.x;
int tileY = Y+pt.y;
if (rect.ptInRect(tileX, tileY))
{
Tile& tile = pZone->getTile(tileX, tileY);
// 현재 타일에다 이펙트를 추가할 수 있다면...
if (tile.canAddEffect())
{
// 같은 effect가 있으면 지운다.
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_BLOODY_WALL);
if (pOldEffect != NULL)
{
ObjectID_t effectID = pOldEffect->getObjectID();
pZone->deleteEffect(effectID);// fix me
}
// 이펙트 클래스를 생성한다.
EffectBloodyWall* pEffect = new EffectBloodyWall(pZone , tileX, tileY);
pEffect->setCasterName(pMonster->getName());
pEffect->setCasterID(pMonster->getObjectID());
pEffect->setClan(Creature::CREATURE_CLASS_MONSTER, pMonster->getClanType());
pEffect->setDamage(output.Damage);
pEffect->setDeadline(output.Duration);
pEffect->setLevel(pMonster->getINT());
pEffect->setNextTime(0);
pEffect->setTick(output.Tick);
// Tile에 붙이는 Effect는 ObjectID를 등록받아야 한다.
ObjectRegistry & objectregister = pZone->getObjectRegistry();
objectregister.registerObject(pEffect);
pZone->addEffect(pEffect);
tile.addEffect(pEffect);
GCAddEffectToTile gcAE;
gcAE.setObjectID(pEffect->getObjectID());
gcAE.setEffectID(pEffect->getSendEffectClass());
gcAE.setDuration(output.Duration);
gcAE.setXY(tileX, tileY);
pZone->broadcastPacket(tileX, tileY, &gcAE);
const list<Object*>& oList = tile.getObjectList();
for(list<Object*>::const_iterator itr = oList.begin(); itr != oList.end(); itr++)
{
Object* pTarget = *itr;
Creature* pTargetCreature = NULL;
if (pTarget->getObjectClass() == Object::OBJECT_CLASS_CREATURE
&& ((pTargetCreature = dynamic_cast<Creature*>(pTarget))->isSlayer() || pTargetCreature->isOusters() )
)
{
cList.push_back(pTargetCreature);
_GCSkillToTileOK2.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK4.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK5.addCListElement(pTargetCreature->getObjectID());
pEffect->affect(pTargetCreature);
}
//pEffect->affectObject(pTarget, false);
}
}
}
}
_GCSkillToTileOK2.setObjectID(pMonster->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setDuration(output.Duration);
_GCSkillToTileOK2.setRange(Dir);
//_GCSkillToTileOK2.addShortData(MODIFY_VISION, BLOODY_WALL_SIGHT);
_GCSkillToTileOK3.setObjectID(pMonster->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setRange(Dir);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK5.setObjectID(pMonster->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setRange(Dir);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK6.setOrgXY(myX, myY);
_GCSkillToTileOK6.setSkillType(SkillType);
_GCSkillToTileOK6.setX(X);
_GCSkillToTileOK6.setY(Y);
_GCSkillToTileOK6.setDuration(output.Duration);
_GCSkillToTileOK6.setRange(Dir);
//_GCSkillToTileOK6.addShortData(MODIFY_VISION, BLOODY_WALL_SIGHT);
for(list<Creature*>::const_iterator itr = cList.begin(); itr != cList.end(); itr++)
{
Creature* pTargetCreature = *itr;
if (canSee(pTargetCreature, pMonster)) pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK2);
else pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK6);
}
cList.push_back(pMonster);
list<Creature*> watcherList = pZone->getWatcherList(myX, myY, pMonster);
// watcherList에서 cList에 속하지 않고, caster(pMonster)를 볼 수 없는 경우는
// OK4를 보내고.. cList에 추가한다.
for(list<Creature*>::const_iterator itr = watcherList.begin(); itr != watcherList.end(); itr++)
{
bool bBelong = false;
for(list<Creature*>::const_iterator tItr = cList.begin(); tItr != cList.end(); tItr++)
if (*itr == *tItr)
bBelong = true;
Creature* pWatcher = (*itr);
if (bBelong == false && canSee(pWatcher, pMonster) == false)
{
//Assert(pWatcher->isPC()); // 당연 PC다.. Zone::getWatcherList는 PC만 return한다
if (!pWatcher->isPC())
{
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
pWatcher->getPlayer()->sendPacket(&_GCSkillToTileOK4);
cList.push_back(*itr);
}
}
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList, false);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
}
else
{
executeSkillFailNormal(pMonster, getSkillType(), NULL);
}
}
catch (Throwable & t)
{
executeSkillFailException(pMonster, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
////////////////////////////////////////////////////////////////////////////////
// 액션을 실행한다.
////////////////////////////////////////////////////////////////////////////////
void ActionTradeGiftBox::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);
Player* pPlayer = pPC->getPlayer();
Assert(pPlayer != NULL);
Inventory* pInventory = pPC->getInventory();
Assert(pInventory != NULL);
Zone* pZone = pPC->getZone();
Assert(pZone != NULL);
FlagSet* pFlagSet = pPC->getFlagSet();
Item::ItemClass ItemClass;
ItemType_t ItemType;
OptionType_t OptionType;
Item* pItem;
Item* pGiftBoxItem;
// 이미 선물을 교환해 갔다면
if (pFlagSet->isOn(FLAGSET_TRADE_GIFT_BOX_2002_12 ) )
{
GCNPCResponse response;
response.setCode(NPC_RESPONSE_TRADE_GIFT_BOX_ALREADY_TRADE);
pPlayer->sendPacket(&response);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
return;
}
// 빨간 선물 상자가 있는지 확인한다.
CoordInven_t X,Y;
pGiftBoxItem = pInventory->findItem(Item::ITEM_CLASS_EVENT_GIFT_BOX, 1, X, Y);
if (pGiftBoxItem == NULL )
{
GCNPCResponse response;
response.setCode(NPC_RESPONSE_TRADE_GIFT_BOX_NO_ITEM);
pPlayer->sendPacket(&response);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
return;
}
LuaSelectItem* pLuaSelectItem = NULL;
string luaFileName;
if (pPC->isSlayer() )
{
// 루아에 슬레이어 능력치의 합을 set한다.
Slayer* pSlayer = dynamic_cast<Slayer*>(pPC);
Assert(pSlayer != NULL);
Attr_t sum = pSlayer->getSTR(ATTR_BASIC )
+ pSlayer->getDEX(ATTR_BASIC )
+ pSlayer->getINT(ATTR_BASIC);
m_pLuaSlayerItem->setSum(sum);
pLuaSelectItem = m_pLuaSlayerItem;
luaFileName = m_SlayerFilename;
}
else if (pPC->isVampire() )
{
// 루아에 뱀파이어의 레벨을 set한다.
Vampire* pVampire = dynamic_cast<Vampire*>(pPC);
Assert(pVampire != NULL);
int level = pVampire->getLevel();
m_pLuaVampireItem->setLevel(level);
pLuaSelectItem = m_pLuaVampireItem;
luaFileName = m_VampireFilename;
}
//--------------------------------------------------------
// 속도 체크를 위해서 1000번 돌려보는 코드
// 결과는.. 0.07초 정도 나왔다. 감덩~ -_-;
/*
Timeval beforeTime;
getCurrentTime(beforeTime);
for (int i=0; i<1000; i++)
{
// 루아의 계산 결과를 받아 아이템을 생성한다.
pLuaSelectItem->prepare();
int result = pLuaSelectItem->executeFile(luaFileName);
LuaState::logError(result);
pLuaSelectItem->clear();
}
Timeval afterTime;
getCurrentTime(afterTime);
cout << "luaExecute time before : " << beforeTime.tv_sec << "." << beforeTime.tv_usec << endl;
cout << "luaExecute time after : " << afterTime.tv_sec << "." << afterTime.tv_usec << endl;
*/
//--------------------------------------------------------
// 루아의 계산 결과를 받아 아이템을 생성한다.
pLuaSelectItem->prepare();
int result = pLuaSelectItem->executeFile(luaFileName);
LuaState::logError(result);
ItemClass = pLuaSelectItem->getItemClass();
ItemType = pLuaSelectItem->getItemType();
OptionType = pLuaSelectItem->getOptionType();
pLuaSelectItem->clear();
if(ItemClass >= Item::ITEM_CLASS_MAX )
//|| ItemType >= ITEM_TYPE_MAX || ItemType < 0
// || OptionType == 0)
{
filelog("XMasEventError.txt", "[ ItemInfo Error ] : ItemClass = %d , ItemType = %d , OptionType = %d", ItemClass, ItemType, OptionType);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
return;
}
// 클라이언트에 선물상자를 지우도록 한다.
GCDeleteInventoryItem gcDeleteInventoryItem;
gcDeleteInventoryItem.setObjectID(pGiftBoxItem->getObjectID());
pPlayer->sendPacket(&gcDeleteInventoryItem);
// 선물상자를 지운다.
pInventory->deleteItem(X, Y);
// ItemTraceLog 를 남긴다
if (pGiftBoxItem != NULL && pGiftBoxItem->isTraceItem() )
{
remainTraceLog(pGiftBoxItem, pCreature2->getName(), pCreature1->getName(), ITEM_LOG_DELETE, DETAIL_EVENTNPC);
}
pGiftBoxItem->destroy();
SAFE_DELETE(pGiftBoxItem);
// 선물(Item)을 만든다.
list<OptionType_t> optionTypeList;
if (OptionType != 0 )
optionTypeList.push_back(OptionType);
pItem = g_pItemFactoryManager->createItem(ItemClass, ItemType, optionTypeList);
Assert(pItem != NULL);
// 선물을 인벤토리에 추가한다.
pZone->getObjectRegistry().registerObject(pItem);
pInventory->addItem(X, Y, pItem);
pItem->create(pPC->getName(), STORAGE_INVENTORY, 0, X, Y);
// ItemTraceLog 를 남긴다
if (pItem != NULL && pItem->isTraceItem() )
{
remainTraceLog(pItem, pCreature1->getName(), pCreature2->getName(), ITEM_LOG_CREATE, DETAIL_EVENTNPC);
}
// 클라이언트에 선물이 추가되었음을 알린다.
GCCreateItem gcCreateItem;
makeGCCreateItem(&gcCreateItem, pItem, X, Y);
pPlayer->sendPacket(&gcCreateItem);
// Flag을 켠다.
pFlagSet->turnOn(FLAGSET_TRADE_GIFT_BOX_2002_12);
// Flag을 저장한다.
pFlagSet->save(pPC->getName());
// 아이템 교환이 이루어 졌다고 클라이언트에 알린다.
GCNPCResponse response;
response.setCode(NPC_RESPONSE_TRADE_GIFT_BOX_OK);
pPlayer->sendPacket(&response);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
__END_CATCH
}
void InstallMine::execute(Slayer* pSlayer, ObjectID_t, CoordInven_t X, CoordInven_t Y, CoordInven_t TargetX, CoordInven_t TargetY, SkillSlot* pSkillSlot)
throw(Error)
{
__BEGIN_TRY
Assert(pSlayer != NULL);
Assert(pSkillSlot != NULL);
try
{
Player* pPlayer = pSlayer->getPlayer();
Zone* pZone = pSlayer->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
GCSkillToInventoryOK1 _GCSkillToInventoryOK1;
// GCSkillToTileOK1 _GCSkillToTileOK1;
// GCSkillToTileOK5 _GCSkillToTileOK5;
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo * pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
SkillLevel_t SkillLevel = pSkillSlot->getExpLevel();
// 명중률.
//ToHit_t ToHit = pSlayer->getToHit();
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = checkZoneLevelToUseSkill(pSlayer);
ZoneCoord_t slayerX = pSlayer->getX(), slayerY = pSlayer->getY();
bool bInstallAction = false;
Mine* pMine = NULL;
Inventory * pInventory = pSlayer->getInventory();
Assert(pInventory != NULL);
if(bManaCheck && bTimeCheck &&bRangeCheck ) {
// mine을 찾는다.
Item* pItem = pInventory->getItem(X, Y);
if(pItem != NULL && pItem->getItemClass() == Item::ITEM_CLASS_MINE)
{
bInstallAction = true;
pMine = dynamic_cast<Mine*>(pItem);
}
}
// 기술의 성패를 따진다.
if (bInstallAction )
{
//Range_t Range = 1;
GCSkillToInventoryOK1 _GCSkillToInventoryOK1;
// GCSkillToInventoryOK5 _GCSkillToInventoryOK5;
ItemInfo* pItemInfo = g_pItemInfoManager->getItemInfo(Item::ITEM_CLASS_MINE, pMine->getItemType());
Damage_t MinDamage = pItemInfo->getMinDamage();
Damage_t MaxDamage = pItemInfo->getMaxDamage();
Damage_t RealDamage = MinDamage + (max (0, ((int)MaxDamage * (int)SkillLevel / 100 ) - MinDamage ));
Mine * pInstallMine = new Mine();
ObjectRegistry& OR = pZone->getObjectRegistry();
OR.registerObject(pInstallMine);
Assert(pInstallMine != NULL);
pInstallMine->setItemType(pMine->getItemType());
pInstallMine->setDir(TargetX);
pInstallMine->setDamage(RealDamage);
pInstallMine->setInstallerName(pSlayer->getName());
pInstallMine->setInstallerPartyID(pSlayer->getPartyID());
pInstallMine->setFlag(Effect::EFFECT_CLASS_INSTALL);
// 아이템 사라지는게 3분인거 때문에 지뢰도 사라졌는데..
// 10분으로 고정. by sigi. 2002.11.3
TPOINT pt = pZone->addItem(pInstallMine, slayerX, slayerY, true, 6000);
// EXP up
Exp_t Point = pSkillInfo->getPoint();
shareAttrExp(pSlayer, 100, 1, 8, 1, _GCSkillToInventoryOK1);
increaseDomainExp(pSlayer, SKILL_DOMAIN_GUN, Point, _GCSkillToInventoryOK1);
increaseSkillExp(pSlayer, SKILL_DOMAIN_GUN, pSkillSlot, pSkillInfo, _GCSkillToInventoryOK1);
decreaseMana(pSlayer, RequiredMP, _GCSkillToInventoryOK1);
decreaseItemNum(pMine, pInventory, pSlayer->getName(), STORAGE_INVENTORY, 0, X, Y);
_GCSkillToInventoryOK1.setObjectID(pInstallMine->getObjectID());
_GCSkillToInventoryOK1.setSkillType(SkillType);
_GCSkillToInventoryOK1.setCEffectID(0);
_GCSkillToInventoryOK1.setX(X);
_GCSkillToInventoryOK1.setY(Y);
_GCSkillToInventoryOK1.setDuration(0);
/*
_GCSkillToInventoryOK5.setObjectID(pSlayer->getObjectID());
_GCSkillToInventoryOK5.setSkillType(SkillType);
_GCSkillToInventoryOK5.setX(X);
_GCSkillToInventoryOK5.setY(Y);
_GCSkillToInventoryOK5.setRange(Range);
_GCSkillToInventoryOK5.setDuration(0);
*/
pPlayer->sendPacket(&_GCSkillToInventoryOK1);
// mine을 볼 수 없게 된 자들에게는 삭제
addInstalledMine(pZone, pInstallMine, pt.x, pt.y);
// pZone->broadcastPacket(slayerX, slayerY, &_GCSkillToInventoryOK5, pSlayer);
// cout << "Run Skill : " << (int)SkillType << endl;
// Set NextTime
pSkillSlot->setRunTime();
}
else
{
GCSkillFailed1 _GCSkillFailed1;
GCSkillFailed2 _GCSkillFailed2;
executeSkillFailException(pSlayer, getSkillType());
}
}
catch(Throwable & t)
{
executeSkillFailException(pSlayer, getSkillType());
}
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 타일 핸들러
//////////////////////////////////////////////////////////////////////////////
void BloodyWall::execute(Vampire* pVampire, ZoneCoord_t X, ZoneCoord_t Y, VampireSkillSlot* pVampireSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pVampire != NULL);
Assert(pVampireSkillSlot != NULL);
try
{
Player* pPlayer = pVampire->getPlayer();
Zone* pZone = pVampire->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = pVampireSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
ZoneCoord_t myX = pVampire->getX();
ZoneCoord_t myY = pVampire->getY();
// Knowledge of Blood 가 있다면 hit bonus 10
int HitBonus = 0;
if (pVampire->hasRankBonus(RankBonus::RANK_BONUS_KNOWLEDGE_OF_BLOOD ) )
{
RankBonus* pRankBonus = pVampire->getRankBonus(RankBonus::RANK_BONUS_KNOWLEDGE_OF_BLOOD);
Assert(pRankBonus != NULL);
HitBonus = pRankBonus->getPoint();
}
int RequiredMP = decreaseConsumeMP(pVampire, pSkillInfo);
bool bManaCheck = hasEnoughMana(pVampire, RequiredMP);
bool bTimeCheck = verifyRunTime(pVampireSkillSlot);
bool bRangeCheck = verifyDistance(pVampire, X, Y, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessMagic(pVampire, pSkillInfo, pVampireSkillSlot, HitBonus);
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
if (rect.ptInRect(X, Y)) bTileCheck = true;
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bTileCheck)
{
decreaseMana(pVampire, RequiredMP, _GCSkillToTileOK1);
// 이펙트의 지속시간을 계산한다.
SkillInput input(pVampire);
SkillOutput output;
computeOutput(input, output);
Dir_t Dir = getDirectionToPosition(myX, myY, X, Y);
list<Creature*> cList; // denier list
for (int i=0; i<5; i++)
{
POINT& pt = m_BloodyWallMask[Dir][i];
int tileX = X+pt.x;
int tileY = Y+pt.y;
if (rect.ptInRect(tileX, tileY))
{
Tile& tile = pZone->getTile(tileX, tileY);
if (tile.getEffect(Effect::EFFECT_CLASS_TRYING_POSITION )!=NULL ) continue;
// 현재 타일에다 이펙트를 추가할 수 있다면...
if (tile.canAddEffect())
{
// 같은 effect가 있으면 지운다.
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_BLOODY_WALL);
if (pOldEffect != NULL)
{
ObjectID_t effectID = pOldEffect->getObjectID();
pZone->deleteEffect(effectID);// fix me
}
// 이펙트 클래스를 생성한다.
EffectBloodyWall* pEffect = new EffectBloodyWall(pZone , tileX, tileY);
pEffect->setCasterName(pVampire->getName());
pEffect->setCasterID(pVampire->getObjectID());
pEffect->setClan(Creature::CREATURE_CLASS_VAMPIRE, pVampire->getClanType());
pEffect->setDamage(output.Damage);
pEffect->setDeadline(output.Duration);
pEffect->setLevel(pVampire->getINT());
pEffect->setNextTime(0);
pEffect->setTick(output.Tick);
// Tile에 붙이는 Effect는 ObjectID를 등록받아야 한다.
ObjectRegistry & objectregister = pZone->getObjectRegistry();
objectregister.registerObject(pEffect);
pZone->addEffect(pEffect);
tile.addEffect(pEffect);
const list<Object*>& oList = tile.getObjectList();
for(list<Object*>::const_iterator itr = oList.begin(); itr != oList.end(); itr++)
{
Object* pTarget = *itr;
Creature* pTargetCreature = NULL;
if (pTarget->getObjectClass() == Object::OBJECT_CLASS_CREATURE
&& ((pTargetCreature = dynamic_cast<Creature*>(pTarget))->isSlayer() || pTargetCreature->isOusters() )
&& !checkZoneLevelToHitTarget(pTargetCreature )
)
{
cList.push_back(pTargetCreature);
_GCSkillToTileOK2.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK4.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK5.addCListElement(pTargetCreature->getObjectID());
pEffect->affect(pTargetCreature);
}
// pEffect->affect(pTarget);
}
}
}
}
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setDuration(output.Duration);
_GCSkillToTileOK1.setRange(Dir);
_GCSkillToTileOK2.setObjectID(pVampire->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setDuration(output.Duration);
_GCSkillToTileOK2.setRange(Dir);
//_GCSkillToTileOK2.addShortData(MODIFY_VISION, BLOODY_WALL_SIGHT);
_GCSkillToTileOK3.setObjectID(pVampire->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setRange(Dir);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK5.setObjectID(pVampire->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setRange(Dir);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK6.setOrgXY(myX, myY);
_GCSkillToTileOK6.setSkillType(SkillType);
_GCSkillToTileOK6.setX(X);
_GCSkillToTileOK6.setY(Y);
_GCSkillToTileOK6.setDuration(output.Duration);
_GCSkillToTileOK6.setRange(Dir);
//_GCSkillToTileOK6.addShortData(MODIFY_VISION, BLOODY_WALL_SIGHT);
for(list<Creature*>::const_iterator itr = cList.begin(); itr != cList.end(); itr++)
{
Creature* pTargetCreature = *itr;
if (canSee(pTargetCreature, pVampire)) pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK2);
else pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK6);
}
pPlayer->sendPacket(&_GCSkillToTileOK1);
cList.push_back(pVampire);
list<Creature*> watcherList = pZone->getWatcherList(myX, myY, pVampire);
// watcherList에서 cList에 속하지 않고, caster(pVampire)를 볼 수 없는 경우는
// OK4를 보내고.. cList에 추가한다.
for(list<Creature*>::const_iterator itr = watcherList.begin(); itr != watcherList.end(); itr++)
{
bool bBelong = false;
for(list<Creature*>::const_iterator tItr = cList.begin(); tItr != cList.end(); tItr++)
if (*itr == *tItr)
bBelong = true;
Creature* pWatcher = (*itr);
if (bBelong == false && canSee(pWatcher, pVampire) == false)
{
//Assert(pWatcher->isPC()); // 당연 PC다.. Zone::getWatcherList는 PC만 return한다
if (!pWatcher->isPC())
{
//cout << "BloodyWall : 왓처 리스트가 PC가 아닙니다." << endl;
GCSkillFailed1 _GCSkillFailed1;
_GCSkillFailed1.setSkillType(getSkillType());
pVampire->getPlayer()->sendPacket(&_GCSkillFailed1);
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
pWatcher->getPlayer()->sendPacket(&_GCSkillToTileOK4);
cList.push_back(*itr);
}
}
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList, false);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
pVampireSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pVampire, getSkillType(), NULL);
}
}
catch (Throwable & t)
{
executeSkillFailException(pVampire, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 슬레이어 타일 핸들러
//////////////////////////////////////////////////////////////////////////////
void MagicElusion::execute(Slayer* pSlayer, ZoneCoord_t X, ZoneCoord_t Y, SkillSlot* pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pSlayer != NULL);
Assert(pSkillSlot != NULL);
try
{
Player* pPlayer = pSlayer->getPlayer();
Zone* pZone = pSlayer->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
ZoneCoord_t myX = pSlayer->getX();
ZoneCoord_t myY = pSlayer->getY();
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pSlayer, X, Y, pSkillInfo->getRange()) && checkZoneLevelToUseSkill(pSlayer);
bool bHitRoll = HitRoll::isSuccessMagicElusion(pSlayer);
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
if (rect.ptInRect(X, Y)) bTileCheck = true;
// 이펙트의 지속시간을 계산한다.
SkillInput input(pSlayer, pSkillSlot);
SkillOutput output;
computeOutput(input, output);
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bTileCheck)
{
decreaseMana(pSlayer, RequiredMP, _GCSkillToTileOK1);
Range_t Range = 2;
int oX, oY;
list<Creature*> cList; // denier list
ObjectRegistry & objectregister = pZone->getObjectRegistry();
// 일단 이미 sanctuary가 있는지 검색한다.
for(oY = -1; oY <= 1; oY++)
for(oX = -1; oX <= 1; oX++)
{
int tileX = X+oX;
int tileY = Y+oY;
if (rect.ptInRect(tileX, tileY))
{
Tile& tile = pZone->getTile(tileX, tileY);
if (tile.canAddEffect())
{
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_MAGIC_ELUSION);
// 이미 있다면
// 기술 실패다.
if (pOldEffect != NULL)
{
executeSkillFailNormal(pSlayer, getSkillType(), NULL);
return;
}
}
else
{
executeSkillFailNormal(pSlayer, getSkillType(), NULL);
return;
}
}
}
for(oY = -1; oY <= 1; oY++)
for(oX = -1; oX <= 1; oX++)
{
int tileX = X+oX;
int tileY = Y+oY;
if (rect.ptInRect(tileX, tileY))
{
Tile& tile = pZone->getTile(tileX, tileY);
// 이펙트 클래스를 생성한다.
EffectMagicElusion* pEffect = new EffectMagicElusion(pZone , tileX, tileY);
pEffect->setDeadline(output.Duration);
// Tile에 붙이는 Effect는 ObjectID를 등록받아야 한다.
objectregister.registerObject(pEffect);
pZone->addEffect(pEffect);
tile.addEffect(pEffect);
if (oX==0 && oY==0)
{
pEffect->setBroadcastingEffect(true);
GCAddEffectToTile gcAddEffectToTile;
gcAddEffectToTile.setEffectID(pEffect->getEffectClass());
gcAddEffectToTile.setObjectID(pEffect->getObjectID());
gcAddEffectToTile.setXY(X, Y);
gcAddEffectToTile.setDuration(output.Duration);
pZone->broadcastPacket(X, Y, &gcAddEffectToTile, pSlayer);
}
else
{
// 가운데 이펙트가 아니면 브로드캐스팅해주지 않는다.
pEffect->setBroadcastingEffect(false);
}
const list<Object*>& oList = tile.getObjectList();
for(list<Object*>::const_iterator itr = oList.begin(); itr != oList.end(); itr++)
{
Object* pTarget = *itr;
if (pTarget->getObjectClass() == Object::OBJECT_CLASS_CREATURE )
{
Creature* pCreature = dynamic_cast<Creature*>(pTarget);
Assert(pCreature != NULL);
if (pCreature->isVampire() )
{
Vampire* pVampire = dynamic_cast<Vampire*>(pCreature);
Assert(pVampire != NULL);
GCModifyInformation gcMI;
::setDamage(pVampire, output.Damage, pSlayer, pSkillSlot->getSkillType(), &gcMI);
pVampire->getPlayer()->sendPacket(&gcMI);
cList.push_back(pCreature);
}
else if (pCreature->isMonster() )
{
::setDamage(pCreature, output.Damage, pSlayer, pSkillSlot->getSkillType());
}
}
}
}
}
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setDuration(output.Duration);
_GCSkillToTileOK1.setRange(Range);
_GCSkillToTileOK2.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setDuration(output.Duration);
_GCSkillToTileOK2.setRange(Range);
_GCSkillToTileOK3.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setRange(Range);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK5.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setRange(Range);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK6.setOrgXY(myX, myY);
_GCSkillToTileOK6.setSkillType(SkillType);
_GCSkillToTileOK6.setX(X);
_GCSkillToTileOK6.setY(Y);
_GCSkillToTileOK6.setDuration(output.Duration);
_GCSkillToTileOK6.setRange(Range);
for(list<Creature*>::const_iterator itr = cList.begin(); itr != cList.end(); itr++)
{
Creature* pTargetCreature = *itr;
if (canSee(pTargetCreature, pSlayer)) pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK2);
else pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK6);
}
pPlayer->sendPacket(&_GCSkillToTileOK1);
cList.push_back(pSlayer);
list<Creature*> watcherList = pZone->getWatcherList(myX, myY, pSlayer);
// watcherList에서 cList에 속하지 않고, caster(pSlayer)를 볼 수 없는 경우는
// OK4를 보내고.. cList에 추가한다.
for(list<Creature*>::const_iterator itr = watcherList.begin(); itr != watcherList.end(); itr++)
{
bool bBelong = false;
for(list<Creature*>::const_iterator tItr = cList.begin(); tItr != cList.end(); tItr++)
if (*itr == *tItr)
bBelong = true;
Creature* pWatcher = (*itr);
if (bBelong == false && canSee(pWatcher, pSlayer) == false)
{
//Assert(pWatcher->isPC()); // 당연 PC다.. Zone::getWatcherList는 PC만 return한다
if (pWatcher->isPC())
{
pWatcher->getPlayer()->sendPacket(&_GCSkillToTileOK4);
cList.push_back(*itr);
}
}
}
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList, false);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
}
else
{
executeSkillFailNormal(pSlayer, getSkillType(), NULL);
}
if (bTimeCheck ) pSkillSlot->setRunTime(output.Delay);
}
catch (Throwable & t)
{
executeSkillFailException(pSlayer, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
void CGAddMouseToInventoryHandler::execute(CGAddMouseToInventory* pPacket , Player* pPlayer)
throw(ProtocolException, Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
Assert(pPacket != NULL);
Assert(pPlayer != NULL);
try {
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Assert(pGamePlayer != NULL);
Creature* pCreature = pGamePlayer->getCreature();
Assert(pCreature != NULL);
Assert(pCreature->isPC());
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature);
Assert(pPC != NULL);
Zone* pZone = pPC->getZone();
Assert(pZone != NULL);
Inventory* pInventory = pPC->getInventory();
Assert(pInventory != NULL);
Item* pItem = pPC->getExtraInventorySlot()->getItem();
bool Success = false;
if (pItem == NULL) {
GCCannotAdd _GCCannotAdd;
_GCCannotAdd.setObjectID(pPacket->getObjectID());
pPlayer->sendPacket(&_GCCannotAdd);
return;
}
int invenID = 0;
/* Commenting the SubInventory stuff, since it's not supported by the client we use
SubInventory* pInventoryItem = NULL;
int invenID = 0;
if (pPacket->getInventoryItemObjectID() != 0 )
{
// cout << "서브 인벤토리에 넣기 : " << pPacket->getInventoryItemObjectID() << endl;
CoordInven_t X, Y;
pInventoryItem = dynamic_cast<SubInventory*>(pInventory->findItemOID(pPacket->getInventoryItemObjectID(), X, Y ));
TradeManager* pTradeManager = pZone->getTradeManager();
Assert(pTradeManager != NULL);
if (pInventoryItem == NULL || pItem->getItemClass() == Item::ITEM_CLASS_SUB_INVENTORY || pTradeManager->hasTradeInfo(pPC->getName()) )
{
// cout << "근데 서브 인벤토리가 없다." <<endl;
GCCannotAdd _GCCannotAdd;
_GCCannotAdd.setObjectID(pPacket->getObjectID());
pPlayer->sendPacket(&_GCCannotAdd);
return;
}
pInventory = pInventoryItem->getInventory();
invenID = pInventoryItem->getItemID();
}
*/
//Item::ItemClass itemClass = pItem->getItemClass();
//ItemType_t itemType = pItem->getItemType();
ObjectID_t itemObjectID = pItem->getObjectID();
CoordInven_t InvenX = pPacket->getInvenX();
CoordInven_t InvenY = pPacket->getInvenY();
if (InvenX >= pInventory->getWidth() || InvenY >= pInventory->getHeight() || itemObjectID != pPacket->getObjectID() ||
!pInventory->canAdding(InvenX, InvenY, pItem)) {
GCCannotAdd _GCCannotAdd;
_GCCannotAdd.setObjectID(pPacket->getObjectID());
pPlayer->sendPacket(&_GCCannotAdd);
return;
}
TPOINT pt;
pt.x = 99;
pt.y = 99;
// 넣을려는 Inventory Slot의 Item을 받아온다.
Item* pPrevItem = pInventory->searchItem(InvenX, InvenY , pItem, pt);
// 그 장소에 아이템이 있다면
if (pPrevItem != NULL) {
bool bisSame = true;
// 아이템 클래스가 같을때 숫자를 올려 주고 마우스에 있는 것은 없앤다.
if (canStack(pItem, pPrevItem)) {
int MaxStack = ItemMaxStack[pItem->getItemClass()];
VolumeWidth_t ItemWidth = pItem->getVolumeWidth();
VolumeHeight_t ItemHeight = pItem->getVolumeHeight();
VolumeWidth_t InvenWidth = pInventory->getWidth();
VolumeWidth_t InvenHeight= pInventory->getHeight();
if ((InvenX + ItemWidth <= InvenWidth) && (InvenY + ItemHeight <= InvenHeight)) {
for (int x = InvenX; x < (InvenX + ItemWidth); x++) {
for (int y = InvenY; y < (InvenY + ItemHeight); y++) {
if (pInventory->hasItem(x, y)) {
if(pInventory->getItem(x,y) != pPrevItem ) {
bisSame = false;
break;
}
} else {
bisSame = false;
break;
}
}
}
}
// 들어갈 아이템과 들어있는 아이템의 좌표가 꼭 일치 한다면?
if(bisSame) {
// 숫자가 9개를 넘으면 9개 될때까지만 Add 하고 나머지는 마우스에 달아둔다.
if (pItem->getNum() + pPrevItem->getNum() > MaxStack) {
ItemNum_t CurrentNum = pPrevItem->getNum();
ItemNum_t AddNum = pItem->getNum();
ItemNum_t NewNum = AddNum + CurrentNum - MaxStack;
pPrevItem->setNum(MaxStack);
pItem->setNum(NewNum);
pInventory->increaseNum(MaxStack - CurrentNum);
pInventory->increaseWeight(pItem->getWeight()* (MaxStack - CurrentNum));
//pPrevItem->save(pPC->getName(), STORAGE_INVENTORY, 0, InvenX, InvenY);
// item저장 최적화. by sigi. 2002.5.13
char pField[80];
sprintf(pField, "Num=%d, Storage=%d, StorageID=%d, X=%d, Y=%d", MaxStack, STORAGE_INVENTORY, invenID, InvenX, InvenY);
pPrevItem->tinysave(pField);
//pItem->save(pPC->getName(), STORAGE_EXTRASLOT, 0, 0, 0);
// item저장 최적화. by sigi. 2002.5.13
sprintf(pField, "Num=%d, Storage=%d", NewNum, STORAGE_EXTRASLOT);
pItem->tinysave(pField);
Success = true;
} else {
pPC->deleteItemFromExtraInventorySlot();
pPrevItem->setNum(pPrevItem->getNum() + pItem->getNum());
pInventory->increaseNum(pItem->getNum());
pInventory->increaseWeight(pItem->getWeight()* pItem->getNum());
//pPrevItem->save(pPC->getName(), STORAGE_INVENTORY, 0, InvenX, InvenY);
// item저장 최적화. by sigi. 2002.5.13
char pField[80];
sprintf(pField, "Num=%d, Storage=%d, StorageID=%u, X=%d, Y=%d", pPrevItem->getNum(), STORAGE_INVENTORY, invenID, InvenX, InvenY);
pPrevItem->tinysave(pField);
pItem->destroy();
SAFE_DELETE(pItem);
Success = true;
}
if (g_pVariableManager->getVariable(NETMARBLE_CARD_EVENT) != 0 && pPrevItem->getItemClass() == Item::ITEM_CLASS_MOON_CARD && pPrevItem->getItemType() == 2 && pPrevItem->getNum() == 99) {
GCNoticeEvent gcNE;
gcNE.setCode(NOTICE_EVENT_NETMARBLE_CARD_FULL);
pGamePlayer->sendPacket(&gcNE);
//cout << "gcNE sent" << endl;
}
if (pPrevItem->getItemClass() == Item::ITEM_CLASS_LUCKY_BAG
&& pPrevItem->getItemType() == 3
&& pPrevItem->getNum() == 50 ) {
GCDeleteInventoryItem gcDI;
gcDI.setObjectID(pPrevItem->getObjectID());
pGamePlayer->sendPacket(&gcDI);
pInventory->deleteItem(pPrevItem->getObjectID());
pPrevItem->destroy();
SAFE_DELETE(pPrevItem);
Item* pNewItem = g_pItemFactoryManager->createItem(Item::ITEM_CLASS_EVENT_ITEM, 28, list<OptionType_t>());
pZone->registerObject(pNewItem);
if (!pInventory->addItem(pt.x, pt.y, pNewItem) )
return;
pNewItem->create(pPC->getName(), STORAGE_INVENTORY, 0, pt.x, pt.y);
if (pNewItem != NULL ) {
GCCreateItem gcCI;
makeGCCreateItem(&gcCI, pNewItem, pt.x, pt.y);
pGamePlayer->sendPacket(&gcCI);
}
}
} else {
pInventory->deleteItem(pPrevItem->getObjectID());
pPC->deleteItemFromExtraInventorySlot();
pPC->addItemToExtraInventorySlot(pPrevItem);
pInventory->addItem(InvenX , InvenY , pItem);
//pPrevItem->save(pPC->getName(), STORAGE_EXTRASLOT, 0, 0, 0);
// item저장 최적화. by sigi. 2002.5.13
char pField[80];
sprintf(pField, "Storage=%d", STORAGE_EXTRASLOT);
pPrevItem->tinysave(pField);
//pItem->save(pPC->getName(), STORAGE_INVENTORY, 0, InvenX, InvenY);
// item저장 최적화. by sigi. 2002.5.13
sprintf(pField, "Storage=%d, StorageID=%u, X=%d, Y=%d", STORAGE_INVENTORY, invenID, InvenX, InvenY);
pItem->tinysave(pField);
Success = true;
}
}
else {// 아이템 클래스가 다르거나, 쌓이는 아이템이 아니라면.
pInventory->deleteItem(pPrevItem->getObjectID());
pPC->deleteItemFromExtraInventorySlot();
pPC->addItemToExtraInventorySlot(pPrevItem);
pInventory->addItem(InvenX , InvenY , pItem);
//pPrevItem->save(pPC->getName(), STORAGE_EXTRASLOT, 0, 0, 0);
// item저장 최적화. by sigi. 2002.5.13
char pField[80];
sprintf(pField, "Storage=%d", STORAGE_EXTRASLOT);
pPrevItem->tinysave(pField);
//pItem->save(pPC->getName(), STORAGE_INVENTORY, 0, InvenX, InvenY);
// item저장 최적화. by sigi. 2002.5.13
sprintf(pField, "Storage=%d, StorageID=%u, X=%d, Y=%d", STORAGE_INVENTORY, invenID, InvenX, InvenY);
pItem->tinysave(pField);
Success = true;
}
} else { // 그 장소에 아이템이 없다면.
//cout << "prevItem is NULL" << endl;
// Inventory에 특정 아이템을 넣는다.
pInventory->addItem(InvenX , InvenY , pItem);
// 넣기에 성공하면 마우스에 달려있는 아이템을 없앤다.
pPC->deleteItemFromExtraInventorySlot();
//pItem->save(pPC->getName(), STORAGE_INVENTORY, 0, InvenX, InvenY);
// item저장 최적화. by sigi. 2002.5.13
char pField[80];
sprintf(pField, "Storage=%d, StorageID=%u, X=%d, Y=%d", STORAGE_INVENTORY, invenID, InvenX, InvenY);
pItem->tinysave(pField);
Success = true;
}
if (Success) {
TradeManager* pTradeManager = pZone->getTradeManager();
TradeInfo* pInfo = pTradeManager->getTradeInfo(pCreature->getName());
if (pInfo != NULL && pInfo->getStatus() == TRADE_FINISH) {
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_MOUSE_TO_INVENTORY_OK);
pPlayer->sendPacket(&gcTradeVerify);
}
// 트리 조각일 경우
if (pItem != NULL && pItem->getItemClass() == Item::ITEM_CLASS_EVENT_TREE) {
ItemType_t itemtype = pItem->getItemType();
// 크리스마스 트리 조각이면
if (itemtype <= 11) {
// 크리스마스 트리 조각이 맞춰지는지 본다.
TPOINT pt = checkEventPuzzle(pPC, InvenX, InvenY, 0);
if (pt.x != -1 && pt.y != -1 )
{
// 맞춰진 트리 조각을 지운다.
deleteInventoryItem(pInventory, pt.x, pt.y, pt.x + 2, pt.y + 3);
// 트리를 생성한다.
list<OptionType_t> optionType;
Item* pTreeItem = g_pItemFactoryManager->createItem(Item::ITEM_CLASS_EVENT_TREE, 12, optionType);
pZone->getObjectRegistry().registerObject(pTreeItem);
pInventory->addItem(pt.x, pt.y, pTreeItem);
pTreeItem->create(pPC->getName(), STORAGE_INVENTORY, invenID, pt.x, pt.y);
// 클라이언트에 트리가 만들어졌다는 걸 알린다.
GCCreateItem gcCreateItem;
makeGCCreateItem(&gcCreateItem, pTreeItem, pt.x, pt.y);
pGamePlayer->sendPacket(&gcCreateItem);
}
}
// 크리스마스 트리 조각이면
else if (itemtype > 12 && itemtype <= 24) {
// 크리스마스 트리 조각이 맞춰지는지 본다.
TPOINT pt = checkEventPuzzle(pPC, InvenX, InvenY, 13);
if (pt.x != -1 && pt.y != -1) {
// 맞춰진 트리 조각을 지운다.
deleteInventoryItem(pInventory, pt.x, pt.y, pt.x + 2, pt.y + 3);
// 트리를 생성한다.
list<OptionType_t> optionType;
Item* pTreeItem = g_pItemFactoryManager->createItem(Item::ITEM_CLASS_EVENT_TREE, 25, optionType);
pTreeItem->setQuestItem();
pZone->getObjectRegistry().registerObject(pTreeItem);
pInventory->addItem(pt.x, pt.y, pTreeItem);
pTreeItem->create(pPC->getName(), STORAGE_INVENTORY, invenID, pt.x, pt.y);
// 클라이언트에 트리가 만들어졌다는 걸 알린다.
GCCreateItem gcCreateItem;
makeGCCreateItem(&gcCreateItem, pTreeItem, pt.x, pt.y);
pGamePlayer->sendPacket(&gcCreateItem);
}
}
// 크리스마스 트리 조각이면
else if (itemtype > 28 && itemtype <= 40) {
// 크리스마스 트리 조각이 맞춰지는지 본다.
TPOINT pt = checkEventPuzzle(pPC, InvenX, InvenY, 29);
if (pt.x != -1 && pt.y != -1) {
// 맞춰진 트리 조각을 지운다.
deleteInventoryItem(pInventory, pt.x, pt.y, pt.x + 2, pt.y + 3);
// 트리를 생성한다.
list<OptionType_t> optionType;
Item* pTreeItem = g_pItemFactoryManager->createItem(Item::ITEM_CLASS_EVENT_TREE, 41, optionType);
pTreeItem->setQuestItem();
pZone->getObjectRegistry().registerObject(pTreeItem);
pInventory->addItem(pt.x, pt.y, pTreeItem);
pTreeItem->create(pPC->getName(), STORAGE_INVENTORY, invenID, pt.x, pt.y);
// 클라이언트에 트리가 만들어졌다는 걸 알린다.
GCCreateItem gcCreateItem;
makeGCCreateItem(&gcCreateItem, pTreeItem, pt.x, pt.y);
pGamePlayer->sendPacket(&gcCreateItem);
}
}
}
} else {
//cout << "cannot add" << endl;
GCCannotAdd _GCCannotAdd;
_GCCannotAdd.setObjectID(pPacket->getObjectID());
pPlayer->sendPacket(&_GCCannotAdd);
}
} catch (Throwable & t) {}
#endif // __GAME_SERVER__
__END_DEBUG_EX __END_CATCH
}
void CGAddInventoryToMouseHandler::execute(CGAddInventoryToMouse* pPacket , Player* pPlayer)
throw(ProtocolException, Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#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);
Zone* pZone = pPC->getZone();
Assert(pZone != NULL);
if (pPC->getStore()->isOpen() )
{
GCCannotAdd _GCCannotAdd;
_GCCannotAdd.setObjectID(pPacket->getObjectID());
pPlayer->sendPacket(&_GCCannotAdd);
return;
}
CoordInven_t InvenX = pPacket->getX();
CoordInven_t InvenY = pPacket->getY();
ObjectID_t ItemOID = pPacket->getObjectID();
Inventory* pInventory = pPC->getInventory();
Assert(pInventory != NULL);
int invenID = 0;
/* Commenting the SubInventory stuff, since it's not supported by the client we use
SubInventory* pInventoryItem = NULL;
int invenID = 0;
if (pPacket->getInventoryItemObjectID() != 0 )
{
CoordInven_t X, Y;
pInventoryItem = dynamic_cast<SubInventory*>(pInventory->findItemOID(pPacket->getInventoryItemObjectID(), X, Y ));
if (pInventoryItem == NULL )
{
GCCannotAdd _GCCannotAdd;
_GCCannotAdd.setObjectID(pPacket->getObjectID());
pPlayer->sendPacket(&_GCCannotAdd);
return;
}
pInventory = pInventoryItem->getInventory();
invenID = pInventoryItem->getItemID();
}
*/
// 인벤토리 좌표를 넘어가면 곤란하다...
if (InvenX >= pInventory->getWidth() || InvenY >= pInventory->getHeight())
{
GCCannotAdd _GCCannotAdd;
_GCCannotAdd.setObjectID(pPacket->getObjectID());
pPlayer->sendPacket(&_GCCannotAdd);
return;
}
Item* pItem = pInventory->getItem(InvenX, InvenY);
Item* pExtraSlotItem = pPC->getExtraInventorySlotItem();
if (pPC->getStore()->hasItem(pItem ) )
{
GCCannotAdd _GCCannotAdd;
_GCCannotAdd.setObjectID(pPacket->getObjectID());
pPlayer->sendPacket(&_GCCannotAdd);
return;
}
// 더하고자 하는 아이템이 없거나, 이미 마우스에 뭔가가 붙어있다면
// 들 수 없다.
if (pItem == NULL || pExtraSlotItem != NULL)
{
GCCannotAdd _GCCannotAdd;
_GCCannotAdd.setObjectID(pPacket->getObjectID());
pPlayer->sendPacket(&_GCCannotAdd);
return;
}
// 일반적인 아이템 마우스 더하기 루틴
if (ItemOID != 0)
{
// OID가 일치하지 않으면 곤란하다...
if (pItem->getObjectID() != ItemOID)
{
GCCannotAdd _GCCannotAdd;
_GCCannotAdd.setObjectID(pPacket->getObjectID());
pPlayer->sendPacket(&_GCCannotAdd);
return;
}
pInventory->deleteItem(pItem->getObjectID());
pPC->addItemToExtraInventorySlot(pItem);
//pItem->save(pPC->getName(), STORAGE_EXTRASLOT, 0, 0, 0);
// item저장 최적화. by sigi. 2002.5.13
char pField[80];
sprintf(pField, "Storage=%d, StorageID=0", STORAGE_EXTRASLOT);
pItem->tinysave(pField);
TradeManager* pTradeManager = pZone->getTradeManager();
TradeInfo* pInfo = pTradeManager->getTradeInfo(pCreature->getName());
if (pInfo != NULL && pInfo->getStatus() == TRADE_FINISH)
{
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_INVENTORY_TO_MOUSE_OK);
pPlayer->sendPacket(&gcTradeVerify);
}
}
// 겹치는 아이템 분리하기 루틴
else
{
// 겹치는 아이템이 아니거나, 현재 숫자가 2 미만이라면 분리할 수 없다.
if (!isStackable(pItem) || pItem->getNum() < 2
|| (pItem->getItemClass() == Item::ITEM_CLASS_MOON_CARD && pItem->getItemType() == 2 && pItem->getNum() == 99)
|| pPC->getStore()->hasItem(pItem)
)
{
GCCannotAdd _GCCannotAdd;
_GCCannotAdd.setObjectID(pPacket->getObjectID());
pPlayer->sendPacket(&_GCCannotAdd);
return;
}
// 기존의 아이템을 바탕으로 같은 아이템을 생성한다.
Item::ItemClass IClass = pItem->getItemClass();
ItemType_t IType = pItem->getItemType();
const list<OptionType_t>& OType = pItem->getOptionTypeList();
Item* pNewItem = g_pItemFactoryManager->createItem(IClass, IType, OType);
Assert(pNewItem != NULL);
// 마우스에다 더할 아이템은 기존의 OID를 가져가고,
// 인벤토리에 남을 아이템은 새로운 OID를 받아야 한다.
Zone* pZone = pPC->getZone();
Assert(pZone != NULL);
ObjectRegistry& OR = pZone->getObjectRegistry();
OR.registerObject(pNewItem);
// 인벤토리에 남아있는 아이템의 숫자는 원래 숫자에서 1을 뺀 숫자가 된다.
// 기존의 아이템은 마우스로 옮겨졌으므로, 숫자가 1이 된다.
// 인벤토리에서 마우스로 옮겨진 아이템을 삭제하고,
// 새로 생성된 아이템을 더한다.
pInventory->deleteItem(pItem->getObjectID());
pPC->addItemToExtraInventorySlot(pItem);
int NewNum = pItem->getNum() - 1;
pNewItem->setNum(NewNum);
pItem->setNum(1);
pInventory->addItem(InvenX, InvenY, pNewItem);
// 달라진 위치 정보를 세이브한다...
//pItem->save(pPC->getName(), STORAGE_EXTRASLOT, 0, 0, 0);
// item저장 최적화. by sigi. 2002.5.13
char pField[80];
sprintf(pField, "Num=%d, Storage=%d, StorageID=0", 1, STORAGE_EXTRASLOT);
pItem->tinysave(pField);
pNewItem->create(pPC->getName(), STORAGE_INVENTORY, invenID, InvenX, InvenY);
//pNewItem->setNum(NewNum); // 위에서 했는데 또 하네. -_-;
//pNewItem->save(pPC->getName(), STORAGE_INVENTORY, 0, InvenX, InvenY);
// item저장 최적화. by sigi. 2002.5.13
sprintf(pField, "Num=%d, Storage=%d, StorageID=%u", NewNum, STORAGE_INVENTORY, invenID);
pNewItem->tinysave(pField);
// 클라이언트에게는 GCCreateItem 패킷을 이용해
// 인벤토리에 새로이(?) 생성된 아이템에 대한 정보를 보내준다.
GCCreateItem gcCreateItem;
gcCreateItem.setObjectID(pNewItem->getObjectID());
gcCreateItem.setItemClass((BYTE)pNewItem->getItemClass());
gcCreateItem.setItemType(pNewItem->getItemType());
gcCreateItem.setOptionType(pNewItem->getOptionTypeList());
gcCreateItem.setDurability(pNewItem->getDurability());
gcCreateItem.setSilver(pNewItem->getSilver());
gcCreateItem.setEnchantLevel(pNewItem->getEnchantLevel());
gcCreateItem.setItemNum(pNewItem->getNum());
gcCreateItem.setInvenX(InvenX);
gcCreateItem.setInvenY(InvenY);
pPlayer->sendPacket(&gcCreateItem);
}
#endif // __GAME_SERVER__
__END_DEBUG_EX __END_CATCH
}
Item* CastleShrineInfoManager::addShrineToZone(ShrineInfo& shrineInfo, ItemType_t itemType )
throw(Error)
{
__BEGIN_TRY
// 성단을 넣을 존을 가져온다.
Zone* pZone = getZoneByZoneID(shrineInfo.getZoneID());
Assert(pZone != NULL);
MonsterCorpse* pShrine = new MonsterCorpse(shrineInfo.getMonsterType(), shrineInfo.getName(), 2);
Assert(pShrine != NULL);
pShrine->setShrine(true);
pShrine->setZone(pZone);
pZone->getObjectRegistry().registerObject(pShrine);
shrineInfo.setObjectID(pShrine->getObjectID());
Item* pItem = NULL;
/* if (shrineInfo.getShrineType() == ShrineInfo::SHRINE_GUARD )
{
pShrine->setFlag(Effect::EFFECT_CLASS_SHRINE_GUARD);
EffectShrineGuard* pEffect = new EffectShrineGuard(pShrine);
pEffect->setShrineID(itemType);
pEffect->setTick(60 * 10);
pShrine->getEffectManager().addEffect(pEffect);
}
else if (shrineInfo.getShrineType() == ShrineInfo::SHRINE_HOLY )
{
pShrine->setFlag(Effect::EFFECT_CLASS_SHRINE_HOLY);
EffectShrineHoly* pEffect = new EffectShrineHoly(pShrine);
pEffect->setShrineID(itemType);
pEffect->setTick(60 * 10);
pShrine->getEffectManager().addEffect(pEffect);
}*/
TPOINT tp = pZone->addItem(pShrine, shrineInfo.getX(), shrineInfo.getY(), true);
Assert(tp.x != -1);
// 성의 상징을 추가할 필요가 있다면 추가한다.
if (shrineInfo.getShrineType() == ShrineInfo::SHRINE_GUARD )
{
//if (AddBible[ itemType ] )
{
list<OptionType_t> optionNULL;
pItem = g_pItemFactoryManager->createItem(Item::ITEM_CLASS_CASTLE_SYMBOL, itemType, optionNULL);
Assert(pItem != NULL);
char strZoneID[10];
sprintf(strZoneID, "%d", (int)pZone->getZoneID());
pZone->registerObject(pItem);
pItem->create(strZoneID, STORAGE_CORPSE, pShrine->getObjectID(), 0, 0);
pShrine->addTreasure(pItem);
}
// 수호성단이라는걸 표시해둔다.
pShrine->setFlag(Effect::EFFECT_CLASS_CASTLE_SHRINE_GUARD);
// 모든 수호성단에 Shield Effect 붙인다
pShrine->setFlag(Effect::EFFECT_CLASS_SHRINE_SHIELD);
EffectShrineShield* pEffect = new EffectShrineShield(pShrine);
pEffect->setShrineID(itemType);
pEffect->setTick(60 * 10);
pShrine->getEffectManager().addEffect(pEffect);
}
else
{
// 성지성단이라는걸 표시해둔다.
pShrine->setFlag(Effect::EFFECT_CLASS_CASTLE_SHRINE_HOLY);
}
// 성단 좌표를 새로 세팅한다.
shrineInfo.setX(tp.x);
shrineInfo.setY(tp.y);
return pItem;
__END_CATCH
}
////////////////////////////////////////////////////////////////////////////////
// 액션을 실행한다.
////////////////////////////////////////////////////////////////////////////////
void ActionGiveAccountEventItem::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);
Player* pPlayer = pPC->getPlayer();
Assert(pPlayer != NULL);
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Assert(pGamePlayer != NULL);
Inventory* pInventory = pPC->getInventory();
Assert(pInventory != NULL);
Zone* pZone = pPC->getZone();
Assert(pZone != NULL);
Item::ItemClass ItemClass;
ItemType_t ItemType;
OptionType_t OptionType;
OptionType_t OptionType2;
Item* pItem;
// 이벤트가 진행중이지 않은 경우
if (!g_pVariableManager->isActiveGiveEventItem())
{
GCNPCResponse response;
response.setCode(NPC_RESPONSE_GIVE_EVENT_ITEM_FAIL_NOW);
pPlayer->sendPacket(&response);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
return;
}
// 이미 받았는지 체크한다.
if (pGamePlayer->getSpecialEventCount() & m_SpecialEventFlag)
{
GCNPCResponse response;
response.setCode(NPC_RESPONSE_GIVE_EVENT_ITEM_FAIL);
pPlayer->sendPacket(&response);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
return;
}
// 유료 사용자 여부를 체크한다.
if (!PaySystem::isPayPlayingPeriodPersonal(pGamePlayer->getID() ) )
{
GCNPCResponse response;
response.setCode(NPC_RESPONSE_GIVE_PREMIUM_USER_ONLY);
pPlayer->sendPacket(&response);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
return;
}
LuaSelectItem* pLuaSelectItem = NULL;
string luaFileName;
if (pPC->isSlayer() )
{
// 루아에 슬레이어 능력치의 합을 set한다.
Slayer* pSlayer = dynamic_cast<Slayer*>(pPC);
Assert(pSlayer != NULL);
Attr_t sum = pSlayer->getSTR(ATTR_BASIC )
+ pSlayer->getDEX(ATTR_BASIC )
+ pSlayer->getINT(ATTR_BASIC);
m_pLuaSlayerItem->setSum(sum);
pLuaSelectItem = m_pLuaSlayerItem;
luaFileName = m_SlayerFilename;
}
else if (pPC->isVampire() )
{
// 루아에 뱀파이어의 레벨을 set한다.
Vampire* pVampire = dynamic_cast<Vampire*>(pPC);
Assert(pVampire != NULL);
int level = pVampire->getLevel();
m_pLuaVampireItem->setLevel(level);
pLuaSelectItem = m_pLuaVampireItem;
luaFileName = m_VampireFilename;
}
// 루아의 계산 결과를 받아 아이템을 생성한다.
pLuaSelectItem->prepare();
int result = pLuaSelectItem->executeFile(luaFileName);
LuaState::logError(result);
ItemClass = pLuaSelectItem->getItemClass();
ItemType = pLuaSelectItem->getItemType();
OptionType = pLuaSelectItem->getOptionType();
OptionType2 = pLuaSelectItem->getOptionType2();
pLuaSelectItem->clear();
if(ItemClass >= Item::ITEM_CLASS_MAX )
{
filelog("AccountEventItemError.txt", "[ ItemInfo Error ] : ItemClass = %d , ItemType = %d , OptionType = %d", ItemClass, ItemType, OptionType);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
return;
}
// 선물(Item)을 만든다.
list<OptionType_t> optionTypeList;
if (OptionType != 0 ) optionTypeList.push_back(OptionType);
if (OptionType2 != 0 ) optionTypeList.push_back(OptionType2);
pItem = g_pItemFactoryManager->createItem(ItemClass, ItemType, optionTypeList);
Assert(pItem != NULL);
// 인벤토리에 아이템을 넣을 빈 자리를 받아온다.
TPOINT p;
if (!pInventory->getEmptySlot(pItem, p))
{
SAFE_DELETE(pItem);
GCNPCResponse response;
response.setCode(NPC_RESPONSE_NO_EMPTY_SLOT);
pGamePlayer->sendPacket(&response);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
return;
}
// 선물을 인벤토리에 추가한다.
pZone->getObjectRegistry().registerObject(pItem);
pInventory->addItem(p.x, p.y, pItem);
pItem->create(pPC->getName(), STORAGE_INVENTORY, 0, p.x, p.y);
// ItemTraceLog 를 남긴다
if (pItem != NULL && pItem->isTraceItem() )
{
remainTraceLog(pItem, pCreature1->getName(), pCreature2->getName(), ITEM_LOG_CREATE, DETAIL_EVENTNPC);
remainTraceLogNew(pItem, pCreature2->getName(), ITL_GET, ITLD_EVENTNPC, pCreature1->getZone()->getZoneID(), pCreature1->getX(), pCreature1->getY());
}
// 클라이언트에 선물이 추가되었음을 알린다.
GCCreateItem gcCreateItem;
makeGCCreateItem(&gcCreateItem, pItem, p.x, p.y);
pPlayer->sendPacket(&gcCreateItem);
// 선물을 받았다고 Flag 를 켠다.
pGamePlayer->setSpecialEventCount(pGamePlayer->getSpecialEventCount() | m_SpecialEventFlag);
// Flag 를 저장한다.
pGamePlayer->saveSpecialEventCount();
// 보상을 받았다고 클라이언트에 보낸다.
GCNPCResponse response;
response.setCode(NPC_RESPONSE_GIVE_EVENT_ITEM_OK);
pPlayer->sendPacket(&response);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 아우스터즈 타일 핸들러
//////////////////////////////////////////////////////////////////////////////
void SummonGroundElemental::execute(Ousters* pOusters, ZoneCoord_t X, ZoneCoord_t Y, OustersSkillSlot* pOustersSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << "begin " << endl;
Assert(pOusters != NULL);
Assert(pOustersSkillSlot != NULL);
BYTE Grade = 0;
if (pOustersSkillSlot->getExpLevel() < 15 ) Grade = 0;
else if (pOustersSkillSlot->getExpLevel() < 30 ) Grade = 1;
else Grade = 2;
try
{
Player* pPlayer = pOusters->getPlayer();
Zone* pZone = pOusters->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
Item* pWeapon = pOusters->getWearItem(Ousters::WEAR_RIGHTHAND);
if (pWeapon == NULL || pWeapon->getItemClass() != Item::ITEM_CLASS_OUSTERS_WRISTLET || !pOusters->isRealWearingEx(Ousters::WEAR_RIGHTHAND))
{
executeSkillFailException(pOusters, pOustersSkillSlot->getSkillType(), Grade);
return;
}
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = pOustersSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
// 데미지와 지속 시간을 계산한다.
SkillInput input(pOusters, pOustersSkillSlot);
SkillOutput output;
computeOutput(input, output);
int RequiredMP = (int)pSkillInfo->getConsumeMP() + pOustersSkillSlot->getExpLevel()/3;
bool bManaCheck = hasEnoughMana(pOusters, RequiredMP);
bool bTimeCheck = verifyRunTime(pOustersSkillSlot);
bool bRangeCheck = verifyDistance(pOusters, X, Y, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessMagic(pOusters, pSkillInfo, pOustersSkillSlot);
bool bSatisfyRequire = pOusters->satisfySkillRequire(pSkillInfo);
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
// if (rect.ptInRect(X, Y))
// {
// Tile& tile = pZone->getTile(X, Y);
// if (tile.canAddEffect()) bTileCheck = true;
// }
TPOINT pt = findSuitablePosition(pZone, X, Y, Creature::MOVE_MODE_WALKING);
if (pt.x == -1 )
{
bTileCheck = false;
}
else
{
bTileCheck = true;
for (int oX = pt.x - 2 ; oX <= pt.x + 2 ; ++oX )
for (int oY = pt.y - 2 ; oY <= pt.y + 2 ; ++oY )
{
if (!rect.ptInRect(oX, oY ) ) continue;
if (pZone->getTile(oX, oY).getEffect(Effect::EFFECT_CLASS_GROUND_ELEMENTAL_AURA ) != NULL )
{
bTileCheck = false;
break;
}
}
}
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bTileCheck && bSatisfyRequire)
{
decreaseMana(pOusters, RequiredMP, _GCSkillToTileOK1);
int oX, oY;
/*
HP = 200 + (S_level * 10)
Defense = 50 + (S_level * 2)
Protection = 20 + (S_level * 2)
Poison Resistance = 70%
Acid Resistance = 60%
Curse Resistance = 100%
Blood Resistance = 50%
Regen = 1 HP per 1 sec
*/
Monster* pGroundElemental = new Monster(GROUND_ELEMENTAL_TYPE);
pGroundElemental->setName("대지 정령");
pGroundElemental->setHP(1000 + input.SkillLevel * 100);
pGroundElemental->setHP(1000 + input.SkillLevel * 100, ATTR_MAX);
pGroundElemental->setDefense(0);
pGroundElemental->setProtection(0);
pGroundElemental->setResist(MAGIC_DOMAIN_POISON, 0);
pGroundElemental->setResist(MAGIC_DOMAIN_ACID, 0);
pGroundElemental->setResist(MAGIC_DOMAIN_CURSE, 0);
pGroundElemental->setResist(MAGIC_DOMAIN_BLOOD, 0);
pGroundElemental->setFlag(Effect::EFFECT_CLASS_IMMUNE_TO_CURSE);
pGroundElemental->removeFlag(Effect::EFFECT_CLASS_HIDE);
pGroundElemental->setMoveMode(Creature::MOVE_MODE_WALKING);
// 무뇌정령
pGroundElemental->setBrain(NULL);
pZone->addCreature(pGroundElemental, X, Y, 2);
X = pGroundElemental->getX();
Y = pGroundElemental->getY();
//cout << pGroundElemental->toString() << " 을 " << X << ", " << Y << " 에 불러냈습니다." << endl;
EffectGroundElemental* pCreatureEffect = new EffectGroundElemental(pGroundElemental);
pCreatureEffect->setDeadline(output.Duration);
pGroundElemental->setFlag(pCreatureEffect->getEffectClass());
pGroundElemental->addEffect(pCreatureEffect);
GCAddEffect gcAddEffect;
gcAddEffect.setObjectID(pGroundElemental->getObjectID());
gcAddEffect.setEffectID(pCreatureEffect->getSendEffectClass());
pZone->broadcastPacket(X, Y, &gcAddEffect);
// addSimpleCreatureEffect(pGroundElemental, Effect::EFFECT_CLASS_GROUND_ELEMENTAL_CENTER);
// for (int i = 0; i < m_MaskIndex[Grade]; ++i )
for (oX = X - 2 ; oX <= X + 2 ; ++oX )
for (oY = Y - 2 ; oY <= Y + 2 ; ++oY )
{
// oX = m_ElementalMask[Grade][i].x;
// oY = m_ElementalMask[Grade][i].y;
if (!rect.ptInRect(oX, oY)) continue;
if (oX == X && oY == Y ) continue;
Tile& tile = pZone->getTile(oX, oY);
if (!tile.canAddEffect()) continue;
if (tile.getEffect(Effect::EFFECT_CLASS_TRYING_POSITION) ) continue;
// 같은 이펙트가 이미 존재한다면 삭제한다.
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_GROUND_ELEMENTAL_AURA);
if (pOldEffect != NULL)
{
ObjectID_t effectID = pOldEffect->getObjectID();
pZone->deleteEffect(effectID);
}
// 이펙트 오브젝트를 생성한다.
EffectSummonGroundElemental* pEffect = new EffectSummonGroundElemental(pZone, oX, oY);
pEffect->setDeadline(output.Duration);
// 타일에 붙은 이펙트는 OID를 받아야 한다.
ObjectRegistry & objectregister = pZone->getObjectRegistry();
objectregister.registerObject(pEffect);
// 존 및 타일에다가 이펙트를 추가한다.
pZone->addEffect(pEffect);
tile.addEffect(pEffect);
GCAddEffectToTile gcAddEffect;
gcAddEffect.setXY(oX, oY);
gcAddEffect.setEffectID(pEffect->getSendEffectClass());
gcAddEffect.setObjectID(pEffect->getObjectID());
gcAddEffect.setDuration(output.Duration);
pZone->broadcastPacket(oX, oY, &gcAddEffect);
}
ZoneCoord_t myX = pOusters->getX();
ZoneCoord_t myY = pOusters->getY();
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setDuration(output.Duration);
_GCSkillToTileOK1.setGrade(Grade);
_GCSkillToTileOK3.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK3.setGrade(Grade);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK4.setGrade(Grade);
_GCSkillToTileOK5.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK5.setGrade(Grade);
pPlayer->sendPacket(&_GCSkillToTileOK1);
list<Creature*> cList;
cList.push_back(pOusters);
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
pOustersSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pOusters, getSkillType(), NULL, Grade);
}
}
catch (Throwable & t)
{
executeSkillFailException(pOusters, getSkillType(), Grade);
//cout << t.toString() << endl;
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
////////////////////////////////////////////////////////////////////////////////
// 액션을 실행한다.
////////////////////////////////////////////////////////////////////////////////
void ActionGiveEventItem::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);
Player* pPlayer = pPC->getPlayer();
Assert(pPlayer != NULL);
Inventory* pInventory = pPC->getInventory();
Assert(pInventory != NULL);
Zone* pZone = pPC->getZone();
Assert(pZone != NULL);
FlagSet* pFlagSet = pPC->getFlagSet();
Item::ItemClass ItemClass;
ItemType_t ItemType;
OptionType_t OptionType;
OptionType_t OptionType2;
Item* pItem;
// 이벤트 진행 기간이 아닌 경우
if (!g_pVariableManager->isActiveGiveEventItem())
{
GCNPCResponse response;
response.setCode(NPC_RESPONSE_GIVE_EVENT_ITEM_FAIL_NOW);
pPlayer->sendPacket(&response);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
return;
}
// 이 값과 관련해서
// 캐릭터 생성시에 FlagSet을 바꿔줘야한다. (default ON 으로)
// 이미 선물을 교환해 갔다면
if (pFlagSet->isOn(m_FlagSetType ) )
{
GCNPCResponse response;
response.setCode(NPC_RESPONSE_GIVE_EVENT_ITEM_FAIL);
pPlayer->sendPacket(&response);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
return;
}
LuaSelectItem* pLuaSelectItem = NULL;
string luaFileName;
if (pPC->isSlayer() )
{
// 루아에 슬레이어 능력치의 합을 set한다.
Slayer* pSlayer = dynamic_cast<Slayer*>(pPC);
Assert(pSlayer != NULL);
Attr_t sum = pSlayer->getSTR(ATTR_BASIC )
+ pSlayer->getDEX(ATTR_BASIC )
+ pSlayer->getINT(ATTR_BASIC);
m_pLuaSlayerItem->setSum(sum);
pLuaSelectItem = m_pLuaSlayerItem;
luaFileName = m_SlayerFilename;
}
else if (pPC->isVampire() )
{
// 루아에 뱀파이어의 레벨을 set한다.
Vampire* pVampire = dynamic_cast<Vampire*>(pPC);
Assert(pVampire != NULL);
int level = pVampire->getLevel();
m_pLuaVampireItem->setLevel(level);
pLuaSelectItem = m_pLuaVampireItem;
luaFileName = m_VampireFilename;
}
//--------------------------------------------------------
// 속도 체크를 위해서 1000번 돌려보는 코드
// 결과는.. 0.07초 정도 나왔다. 감덩~ -_-;
/*
Timeval beforeTime;
getCurrentTime(beforeTime);
for (int i=0; i<1000; i++)
{
// 루아의 계산 결과를 받아 아이템을 생성한다.
pLuaSelectItem->prepare();
int result = pLuaSelectItem->executeFile(luaFileName);
LuaState::logError(result);
pLuaSelectItem->clear();
}
Timeval afterTime;
getCurrentTime(afterTime);
cout << "luaExecute time before : " << beforeTime.tv_sec << "." << beforeTime.tv_usec << endl;
cout << "luaExecute time after : " << afterTime.tv_sec << "." << afterTime.tv_usec << endl;
*/
//--------------------------------------------------------
// 루아의 계산 결과를 받아 아이템을 생성한다.
pLuaSelectItem->prepare();
int result = pLuaSelectItem->executeFile(luaFileName);
LuaState::logError(result);
ItemClass = pLuaSelectItem->getItemClass();
ItemType = pLuaSelectItem->getItemType();
OptionType = pLuaSelectItem->getOptionType();
OptionType2 = pLuaSelectItem->getOptionType2();
pLuaSelectItem->clear();
if(ItemClass >= Item::ITEM_CLASS_MAX )
//|| ItemType >= ITEM_TYPE_MAX || ItemType < 0
// || OptionType == 0)
{
filelog("GiveEventItemError.txt", "[ ItemInfo Error ] : ItemClass = %d , ItemType = %d , OptionType = %d", ItemClass, ItemType, OptionType);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
return;
}
// 선물(Item)을 만든다.
list<OptionType_t> optionTypeList;
if (OptionType != 0 ) optionTypeList.push_back(OptionType);
if (OptionType2 != 0 ) optionTypeList.push_back(OptionType2);
pItem = g_pItemFactoryManager->createItem(ItemClass, ItemType, optionTypeList);
Assert(pItem != NULL);
_TPOINT pt;
if (!pInventory->getEmptySlot(pItem, pt))
{
SAFE_DELETE(pItem);
GCNPCResponse response;
response.setCode(NPC_RESPONSE_NO_EMPTY_SLOT);
pPlayer->sendPacket(&response);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
return;
}
CoordInven_t X = pt.x;
CoordInven_t Y = pt.y;
// 선물을 인벤토리에 추가한다.
pZone->getObjectRegistry().registerObject(pItem);
pInventory->addItem(X, Y, pItem);
pItem->create(pPC->getName(), STORAGE_INVENTORY, 0, X, Y);
// ItemTraceLog 를 남긴다
if (pItem != NULL && pItem->isTraceItem() )
{
remainTraceLog(pItem, pCreature1->getName(), pCreature2->getName(), ITEM_LOG_CREATE, DETAIL_EVENTNPC);
remainTraceLogNew(pItem, pCreature2->getName(), ITL_GET, ITLD_EVENTNPC, pCreature1->getZone()->getZoneID(), pCreature1->getX(), pCreature1->getY());
}
// 클라이언트에 선물이 추가되었음을 알린다.
GCCreateItem gcCreateItem;
makeGCCreateItem(&gcCreateItem, pItem, X, Y);
pPlayer->sendPacket(&gcCreateItem);
// Flag을 켠다.
pFlagSet->turnOn(m_FlagSetType);
// Flag을 저장한다.
pFlagSet->save(pPC->getName());
// 아이템 교환이 이루어 졌다고 클라이언트에 알린다.
GCNPCResponse response;
response.setCode(NPC_RESPONSE_GIVE_EVENT_ITEM_OK);
pPlayer->sendPacket(&response);
GCNPCResponse quit;
quit.setCode(NPC_RESPONSE_QUIT_DIALOGUE);
pPlayer->sendPacket(&quit);
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 아우스터즈 타일 핸들러
//////////////////////////////////////////////////////////////////////////////
void Prominence::execute(Ousters* pOusters, ZoneCoord_t X, ZoneCoord_t Y, OustersSkillSlot* pOustersSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << "begin " << endl;
Assert(pOusters != NULL);
Assert(pOustersSkillSlot != NULL);
BYTE Grade = 0;
if (pOustersSkillSlot->getExpLevel() < 15 ) Grade = 0;
else if (pOustersSkillSlot->getExpLevel() < 30 ) Grade = 1;
else Grade = 2;
try
{
Player* pPlayer = pOusters->getPlayer();
Zone* pZone = pOusters->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
Item* pWeapon = pOusters->getWearItem(Ousters::WEAR_RIGHTHAND);
if (pWeapon == NULL || pWeapon->getItemClass() != Item::ITEM_CLASS_OUSTERS_WRISTLET || !pOusters->isRealWearingEx(Ousters::WEAR_RIGHTHAND))
{
executeSkillFailException(pOusters, pOustersSkillSlot->getSkillType(), Grade);
return;
}
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = pOustersSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
// 데미지와 지속 시간을 계산한다.
SkillInput input(pOusters, pOustersSkillSlot);
SkillOutput output;
computeOutput(input, output);
int RequiredMP = (int)pSkillInfo->getConsumeMP() + pOustersSkillSlot->getExpLevel()/3;
bool bManaCheck = hasEnoughMana(pOusters, RequiredMP);
bool bTimeCheck = verifyRunTime(pOustersSkillSlot);
bool bRangeCheck = verifyDistance(pOusters, X, Y, output.Range);
bool bHitRoll = HitRoll::isSuccessMagic(pOusters, pSkillInfo, pOustersSkillSlot);
bool bSatisfyRequire = pOusters->satisfySkillRequire(pSkillInfo);
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
if (rect.ptInRect(X, Y))
{
Tile& tile = pZone->getTile(X, Y);
if (tile.canAddEffect()) bTileCheck = true;
}
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bTileCheck && bSatisfyRequire)
{
decreaseMana(pOusters, RequiredMP, _GCSkillToTileOK1);
int oX, oY;
for (oX = X - 1 ; oX <= X + 1 ; ++oX )
for (oY = Y - 1 ; oY <= Y + 1 ; ++oY )
{
if (!rect.ptInRect(oX, oY)) continue;
Tile& tile = pZone->getTile(oX, oY);
if (!tile.canAddEffect()) continue;
// 머시 그라운드 있음 추가 못한당.
if (tile.getEffect(Effect::EFFECT_CLASS_MERCY_GROUND) != NULL ) continue;
if (tile.getEffect(Effect::EFFECT_CLASS_TRYING_POSITION) ) continue;
// 같은 이펙트가 이미 존재한다면 삭제한다.
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_PROMINENCE);
if (pOldEffect != NULL)
{
ObjectID_t effectID = pOldEffect->getObjectID();
pZone->deleteEffect(effectID);
}
checkMine(pZone, oX, oY);
// 이펙트 오브젝트를 생성한다.
EffectProminence* pEffect = new EffectProminence(pZone, oX, oY);
pEffect->setUserObjectID(pOusters->getObjectID());
pEffect->setDeadline(output.Duration);
pEffect->setNextTime(0);
pEffect->setTick(output.Tick);
pEffect->setDamage(output.Damage);
pEffect->setLevel(pOustersSkillSlot->getExpLevel());
if (Grade > 0 )
{
if (Grade == 1 ) pEffect->setSendEffectClass(Effect::EFFECT_CLASS_PROMINENCE_2);
else pEffect->setSendEffectClass(Effect::EFFECT_CLASS_PROMINENCE_3);
}
// 타일에 붙은 이펙트는 OID를 받아야 한다.
ObjectRegistry & objectregister = pZone->getObjectRegistry();
objectregister.registerObject(pEffect);
// 존 및 타일에다가 이펙트를 추가한다.
pZone->addEffect(pEffect);
tile.addEffect(pEffect);
GCAddEffectToTile gcAddEffect;
gcAddEffect.setXY(oX, oY);
gcAddEffect.setEffectID(pEffect->getSendEffectClass());
gcAddEffect.setObjectID(pEffect->getObjectID());
gcAddEffect.setDuration(output.Duration);
pZone->broadcastPacket(oX, oY, &gcAddEffect, pOusters);
}
ZoneCoord_t myX = pOusters->getX();
ZoneCoord_t myY = pOusters->getY();
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setDuration(output.Duration);
_GCSkillToTileOK1.setGrade(Grade);
_GCSkillToTileOK3.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK3.setGrade(Grade);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK4.setGrade(Grade);
_GCSkillToTileOK5.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK5.setGrade(Grade);
pPlayer->sendPacket(&_GCSkillToTileOK1);
list<Creature*> cList;
cList.push_back(pOusters);
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
pOustersSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pOusters, getSkillType(), NULL, Grade);
}
}
catch (Throwable & t)
{
executeSkillFailException(pOusters, getSkillType(), Grade);
//cout << t.toString() << endl;
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 슬레이어 타일 핸들러
//////////////////////////////////////////////////////////////////////////////
void Sanctuary::execute(Slayer* pSlayer, ZoneCoord_t X, ZoneCoord_t Y, SkillSlot* pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pSlayer != NULL);
Assert(pSkillSlot != NULL);
try
{
Player* pPlayer = pSlayer->getPlayer();
Zone* pZone = pSlayer->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
ZoneCoord_t myX = pSlayer->getX();
ZoneCoord_t myY = pSlayer->getY();
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pSlayer, X, Y, pSkillInfo->getRange()) && checkZoneLevelToUseSkill(pSlayer);
bool bHitRoll = HitRoll::isSuccessMagic(pSlayer, pSkillInfo, pSkillSlot);
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
if (rect.ptInRect(X, Y)) bTileCheck = true;
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bTileCheck)
{
// 이펙트의 지속시간을 계산한다.
SkillInput input(pSlayer, pSkillSlot);
SkillOutput output;
computeOutput(input, output);
Range_t Range = 3;
int oX, oY;
list<Creature*> cList; // denier list
ObjectRegistry & objectregister = pZone->getObjectRegistry();
// 일단 이미 sanctuary가 있는지 검색한다.
for(oY = -1; oY <= 1; oY++)
for(oX = -1; oX <= 1; oX++)
{
int tileX = X+oX;
int tileY = Y+oY;
if (rect.ptInRect(tileX, tileY))
{
Tile& tile = pZone->getTile(tileX, tileY);
if (tile.canAddEffect())
{
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_SANCTUARY);
// 이미 있다면
// 기술 실패다.
if (pOldEffect != NULL)
{
executeSkillFailNormal(pSlayer, getSkillType(), NULL);
return;
}
}
else
{
executeSkillFailNormal(pSlayer, getSkillType(), NULL);
return;
}
}
}
// 실패하면 마나가 줄면 안 되므로 여기서 줄여준다.
decreaseMana(pSlayer, RequiredMP, _GCSkillToTileOK1);
for(oY = -1; oY <= 1; oY++)
for(oX = -1; oX <= 1; oX++)
{
int tileX = X+oX;
int tileY = Y+oY;
if (rect.ptInRect(tileX, tileY))
{
Tile& tile = pZone->getTile(tileX, tileY);
// 현재 타일에다 이펙트를 추가할 수 있다면...
//if (tile.canAddEffect()) // 위에서 체크했다.
{
// 같은 effect가 있으면 지운다.
// 위에서 체크했다.
/*
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_SANCTUARY);
if (pOldEffect != NULL)
{
ObjectID_t effectID = pOldEffect->getObjectID();
pZone->deleteEffect(effectID);// fix me
}
*/
// 이펙트 클래스를 생성한다.
EffectSanctuary* pEffect = new EffectSanctuary(pZone , tileX, tileY, X, Y);
pEffect->setDeadline(output.Duration);
pEffect->setLevel(pSlayer->getINT());
pEffect->setDuration(output.Duration);
pEffect->setStartTime();
// Tile에 붙이는 Effect는 ObjectID를 등록받아야 한다.
objectregister.registerObject(pEffect);
pZone->addEffect(pEffect);
tile.addEffect(pEffect);
if (oX==0 && oY==0)
{
GCAddEffectToTile gcAddEffectToTile;
gcAddEffectToTile.setEffectID(pEffect->getEffectClass());
gcAddEffectToTile.setObjectID(pEffect->getObjectID());
gcAddEffectToTile.setXY(X, Y);
gcAddEffectToTile.setDuration(output.Duration);
pZone->broadcastPacket(X, Y, &gcAddEffectToTile, pSlayer);
}
const list<Object*>& oList = tile.getObjectList();
for(list<Object*>::const_iterator itr = oList.begin(); itr != oList.end(); itr++)
{
Object* pTarget = *itr;
//Creature* pTargetCreature = NULL;
//if (pTarget->getObjectClass() == Object::OBJECT_CLASS_CREATURE)
{
// pTargetCreature = dynamic_cast<Creature*>(pTarget);
// 이펙트 클래스를 생성한다.
/*
EffectSanctuary* pEffect = new EffectSanctuary(pZone , tileX, tileY, X, Y);
pEffect->setDeadline(output.Duration);
pEffect->setLevel(pSlayer->getINT());
pEffect->setDuration(output.Duration);
pEffect->setStartTime();
// 캐릭터에 붙는다. 못 움직이게 할려고..
objectregister.registerObject(pEffect);
pTargetCreature->getEffectManager()->addEffect(pEffect);
pZone->addEffect(pEffect);
*/
}
/*
&& (pTargetCreature = dynamic_cast<Creature*>(pTarget))->isSlayer())
{
cList.push_back(pTargetCreature);
_GCSkillToTileOK2.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK4.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK5.addCListElement(pTargetCreature->getObjectID());
}
*/
pEffect->affectObject(pTarget, false);
}
}
}
}
// client에서는 effect생성되는 시간이 있어서
// 타이밍 맞출려면.. 시간을 좀 빼줘야 한다. -_-;
output.Duration -= 20; // 2초 뺀다.
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setDuration(output.Duration);
_GCSkillToTileOK1.setRange(Range);
_GCSkillToTileOK2.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setDuration(output.Duration);
_GCSkillToTileOK2.setRange(Range);
//_GCSkillToTileOK2.addShortData(MODIFY_VISION, SANCTUARY_SIGHT);
_GCSkillToTileOK3.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setRange(Range);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK5.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setRange(Range);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK6.setOrgXY(myX, myY);
_GCSkillToTileOK6.setSkillType(SkillType);
_GCSkillToTileOK6.setX(X);
_GCSkillToTileOK6.setY(Y);
_GCSkillToTileOK6.setDuration(output.Duration);
_GCSkillToTileOK6.setRange(Range);
//_GCSkillToTileOK6.addShortData(MODIFY_VISION, SANCTUARY_SIGHT);
// EXP UP!
SkillDomainType_t DomainType = pSkillInfo->getDomainType();
SkillGrade Grade = g_pSkillInfoManager->getGradeByDomainLevel(pSlayer->getSkillDomainLevel(DomainType));
Exp_t ExpUp = 10* (Grade + 1);
shareAttrExp(pSlayer, ExpUp, 1, 1, 8, _GCSkillToTileOK1);
increaseDomainExp(pSlayer, DomainType, pSkillInfo->getPoint(), _GCSkillToTileOK1);
increaseSkillExp(pSlayer, DomainType, pSkillSlot, pSkillInfo, _GCSkillToTileOK1);
for(list<Creature*>::const_iterator itr = cList.begin(); itr != cList.end(); itr++)
{
Creature* pTargetCreature = *itr;
if (canSee(pTargetCreature, pSlayer)) pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK2);
else pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK6);
}
pPlayer->sendPacket(&_GCSkillToTileOK1);
cList.push_back(pSlayer);
list<Creature*> watcherList = pZone->getWatcherList(myX, myY, pSlayer);
// watcherList에서 cList에 속하지 않고, caster(pSlayer)를 볼 수 없는 경우는
// OK4를 보내고.. cList에 추가한다.
for(list<Creature*>::const_iterator itr = watcherList.begin(); itr != watcherList.end(); itr++)
{
bool bBelong = false;
for(list<Creature*>::const_iterator tItr = cList.begin(); tItr != cList.end(); tItr++)
if (*itr == *tItr)
bBelong = true;
Creature* pWatcher = (*itr);
if (bBelong == false && canSee(pWatcher, pSlayer) == false)
{
//Assert(pWatcher->isPC()); // 당연 PC다.. Zone::getWatcherList는 PC만 return한다
if (!pWatcher->isPC())
{
//cout << "Sanctuary : 왓처 리스트가 PC가 아닙니다." << endl;
GCSkillFailed1 _GCSkillFailed1;
_GCSkillFailed1.setSkillType(getSkillType());
pSlayer->getPlayer()->sendPacket(&_GCSkillFailed1);
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
pWatcher->getPlayer()->sendPacket(&_GCSkillToTileOK4);
cList.push_back(*itr);
}
}
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList, false);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
pSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pSlayer, getSkillType(), NULL);
}
}
catch (Throwable & t)
{
executeSkillFailException(pSlayer, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 타일 핸들러
//////////////////////////////////////////////////////////////////////////////
void Darkness::execute(Vampire* pVampire, ZoneCoord_t X, ZoneCoord_t Y, VampireSkillSlot* pVampireSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pVampire != NULL);
Assert(pVampireSkillSlot != NULL);
try
{
Player* pPlayer = pVampire->getPlayer();
Zone* pZone = pVampire->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = pVampireSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
ZoneCoord_t myX = pVampire->getX();
ZoneCoord_t myY = pVampire->getY();
// Knowledge of Innate 가 있다면 hit bonus 10
int HitBonus = 0;
if (pVampire->hasRankBonus(RankBonus::RANK_BONUS_KNOWLEDGE_OF_INNATE ) )
{
RankBonus* pRankBonus = pVampire->getRankBonus(RankBonus::RANK_BONUS_KNOWLEDGE_OF_INNATE);
Assert(pRankBonus != NULL);
HitBonus = pRankBonus->getPoint();
}
int RequiredMP = decreaseConsumeMP(pVampire, pSkillInfo);
bool bManaCheck = hasEnoughMana(pVampire, RequiredMP);
bool bTimeCheck = verifyRunTime(pVampireSkillSlot);
bool bRangeCheck = verifyDistance(pVampire, X, Y, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessMagic(pVampire, pSkillInfo, pVampireSkillSlot, HitBonus);
bool bSlayerSafeZone = pZone->getZoneLevel(X, Y ) & SLAYER_SAFE_ZONE;
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
if (rect.ptInRect(X, Y)) bTileCheck = true;
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bTileCheck && !bSlayerSafeZone)
{
decreaseMana(pVampire, RequiredMP, _GCSkillToTileOK1);
// 이펙트의 지속시간을 계산한다.
SkillInput input(pVampire);
SkillOutput output;
computeOutput(input, output);
// Wisdom of Darkness 이 있다면 지속시간 30% 증가
if (pVampire->hasRankBonus(RankBonus::RANK_BONUS_WISDOM_OF_DARKNESS ) )
{
RankBonus* pRankBonus = pVampire->getRankBonus(RankBonus::RANK_BONUS_WISDOM_OF_DARKNESS);
Assert(pRankBonus != NULL);
output.Duration += getPercentValue(output.Duration, pRankBonus->getPoint());
}
Range_t Range = 3;
int oX, oY;
list<Creature*> cList; // denier list
int edge = 1;
// Wide Darkness 이 있다면 범위가 5*5 로 수정. skill type 을 수정한다.
if (pVampire->hasRankBonus(RankBonus::RANK_BONUS_WIDE_DARKNESS ) )
{
RankBonus* pRankBonus = pVampire->getRankBonus(RankBonus::RANK_BONUS_WIDE_DARKNESS);
Assert(pRankBonus != NULL);
Range = pRankBonus->getPoint();
edge = (pRankBonus->getPoint() - 1 ) / 2;
SkillType = SKILL_DARKNESS_WIDE;
}
// map<int, uint> canAddMap;
for(oY = -edge; oY <= edge; oY++)
for(oX = -edge; oX <= edge; oX++)
{
int tileX = X+oX;
int tileY = Y+oY;
if (rect.ptInRect(tileX, tileY))
{
Tile& tile = pZone->getTile(tileX, tileY);
// if (canAddMap[normalizeCoord_DARKNESS(oX, oY, edge )] == 1 ) continue;
if (tile.hasItem() )
{
Item* pItem = tile.getItem();
if (pItem != NULL && pItem->getItemClass() == Item::ITEM_CLASS_CORPSE && pItem->getItemType() == MONSTER_CORPSE )
{
MonsterCorpse* pMonsterCorpse = dynamic_cast<MonsterCorpse*>(pItem);
if (g_pFlagManager->isFlagPole(pMonsterCorpse ) )
{
// canAddMap[normalizeCoord_DARKNESS(oX+1, oY, edge )] = 1;
// canAddMap[normalizeCoord_DARKNESS(oX+1, oY+1, edge )] = 1;
// canAddMap[normalizeCoord_DARKNESS(oX, oY+1, edge )] = 1;
continue;
}
}
}
if (tile.getEffect(Effect::EFFECT_CLASS_TRYING_POSITION ) != NULL ) continue;
// 현재 타일에다 이펙트를 추가할 수 있다면...
if (tile.canAddEffect())
{
// 머시 그라운드 있음 추가 못한당.
if (tile.getEffect(Effect::EFFECT_CLASS_MERCY_GROUND) != NULL ) continue;
if (tile.getEffect(Effect::EFFECT_CLASS_DARKNESS_FORBIDDEN) != NULL ) continue;
// 같은 effect가 있으면 지운다.
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_DARKNESS);
if (pOldEffect != NULL)
{
ObjectID_t effectID = pOldEffect->getObjectID();
pZone->deleteEffect(effectID);// fix me
}
// 이펙트 클래스를 생성한다.
EffectDarkness* pEffect = new EffectDarkness(pZone , tileX, tileY);
pEffect->setDeadline(output.Duration);
pEffect->setLevel(pVampire->getINT());
pEffect->setDuration(output.Duration);
pEffect->setStartTime();
// Tile에 붙이는 Effect는 ObjectID를 등록받아야 한다.
ObjectRegistry & objectregister = pZone->getObjectRegistry();
objectregister.registerObject(pEffect);
pZone->addEffect(pEffect);
tile.addEffect(pEffect);
const list<Object*>& oList = tile.getObjectList();
for(list<Object*>::const_iterator itr = oList.begin(); itr != oList.end(); itr++)
{
Object* pTarget = *itr;
Creature* pTargetCreature = NULL;
if (pTarget->getObjectClass() == Object::OBJECT_CLASS_CREATURE
&& ((pTargetCreature = dynamic_cast<Creature*>(pTarget))->isSlayer() || pTargetCreature->isOusters() )
)
{
cList.push_back(pTargetCreature);
_GCSkillToTileOK2.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK4.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK5.addCListElement(pTargetCreature->getObjectID());
}
pEffect->affectObject(pTarget, false);
}
}
}
}
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setDuration(output.Duration);
_GCSkillToTileOK1.setRange(Range);
_GCSkillToTileOK2.setObjectID(pVampire->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setDuration(output.Duration);
_GCSkillToTileOK2.setRange(Range);
//_GCSkillToTileOK2.addShortData(MODIFY_VISION, DARKNESS_SIGHT);
_GCSkillToTileOK3.setObjectID(pVampire->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setRange(Range);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK5.setObjectID(pVampire->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setRange(Range);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK6.setOrgXY(myX, myY);
_GCSkillToTileOK6.setSkillType(SkillType);
_GCSkillToTileOK6.setX(X);
_GCSkillToTileOK6.setY(Y);
_GCSkillToTileOK6.setDuration(output.Duration);
_GCSkillToTileOK6.setRange(Range);
//_GCSkillToTileOK6.addShortData(MODIFY_VISION, DARKNESS_SIGHT);
for(list<Creature*>::const_iterator itr = cList.begin(); itr != cList.end(); itr++)
{
Creature* pTargetCreature = *itr;
if (canSee(pTargetCreature, pVampire)) pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK2);
else pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK6);
}
pPlayer->sendPacket(&_GCSkillToTileOK1);
cList.push_back(pVampire);
list<Creature*> watcherList = pZone->getWatcherList(myX, myY, pVampire);
// watcherList에서 cList에 속하지 않고, caster(pVampire)를 볼 수 없는 경우는
// OK4를 보내고.. cList에 추가한다.
for(list<Creature*>::const_iterator itr = watcherList.begin(); itr != watcherList.end(); itr++)
{
bool bBelong = false;
for(list<Creature*>::const_iterator tItr = cList.begin(); tItr != cList.end(); tItr++)
if (*itr == *tItr)
bBelong = true;
Creature* pWatcher = (*itr);
if (bBelong == false && canSee(pWatcher, pVampire) == false)
{
//Assert(pWatcher->isPC()); // 당연 PC다.. Zone::getWatcherList는 PC만 return한다
if (!pWatcher->isPC())
{
//cout << "Darkness : 왓처 리스트가 PC가 아닙니다." << endl;
GCSkillFailed1 _GCSkillFailed1;
_GCSkillFailed1.setSkillType(getSkillType());
pVampire->getPlayer()->sendPacket(&_GCSkillFailed1);
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
pWatcher->getPlayer()->sendPacket(&_GCSkillToTileOK4);
cList.push_back(*itr);
}
}
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList, false);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
pVampireSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pVampire, getSkillType(), NULL);
}
}
catch (Throwable & t)
{
executeSkillFailException(pVampire, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 몬스터 셀프 핸들러
//////////////////////////////////////////////////////////////////////////////
void Darkness::execute(Monster* pMonster, ZoneCoord_t X, ZoneCoord_t Y)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pMonster != NULL);
try
{
Zone* pZone = pMonster->getZone();
Assert(pZone != NULL);
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = SKILL_DARKNESS;
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
ZoneCoord_t myX = pMonster->getX();
ZoneCoord_t myY = pMonster->getY();
bool bRangeCheck = verifyDistance(pMonster, X, Y, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessMagic(pMonster, pSkillInfo);
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
if (rect.ptInRect(X, Y)) bTileCheck = true;
if (bRangeCheck && bHitRoll && bTileCheck)
{
// 이펙트의 지속시간을 계산한다.
SkillInput input(pMonster);
SkillOutput output;
computeOutput(input, output);
Range_t Range = 3;
int oX, oY;
list<Creature*> cList; // denier list
for(oY = -1; oY <= 1; oY++)
for(oX = -1; oX <= 1; oX++)
{
int tileX = X+oX;
int tileY = Y+oY;
if (rect.ptInRect(tileX, tileY))
{
Tile& tile = pZone->getTile(tileX, tileY);
if (tile.hasItem() )
{
Item* pItem = tile.getItem();
if (pItem != NULL && pItem->getItemClass() == Item::ITEM_CLASS_CORPSE && pItem->getItemType() == MONSTER_CORPSE )
{
MonsterCorpse* pMonsterCorpse = dynamic_cast<MonsterCorpse*>(pItem);
if (g_pFlagManager->isFlagPole(pMonsterCorpse ) ) continue;
}
}
// 현재 타일에다 이펙트를 추가할 수 있다면...
if (tile.canAddEffect())
{
// 머시 그라운드 있음 추가 못한당.
if (tile.getEffect(Effect::EFFECT_CLASS_MERCY_GROUND) != NULL ) continue;
// 같은 effect가 있으면 지운다.
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_DARKNESS);
if (pOldEffect != NULL)
{
ObjectID_t effectID = pOldEffect->getObjectID();
pZone->deleteEffect(effectID);// fix me
}
// 이펙트 클래스를 생성한다.
EffectDarkness* pEffect = new EffectDarkness(pZone , tileX, tileY);
pEffect->setDeadline(output.Duration);
pEffect->setLevel(pMonster->getINT());
pEffect->setDuration(output.Duration);
pEffect->setStartTime();
// Tile에 붙이는 Effect는 ObjectID를 등록받아야 한다.
ObjectRegistry & objectregister = pZone->getObjectRegistry();
objectregister.registerObject(pEffect);
pZone->addEffect(pEffect);
tile.addEffect(pEffect);
const list<Object*>& oList = tile.getObjectList();
for(list<Object*>::const_iterator itr = oList.begin(); itr != oList.end(); itr++)
{
Object* pTarget = *itr;
Creature* pTargetCreature = NULL;
if (pTarget->getObjectClass() == Object::OBJECT_CLASS_CREATURE
&& ((pTargetCreature = dynamic_cast<Creature*>(pTarget))->isSlayer() || pTargetCreature->isOusters() )
)
{
cList.push_back(pTargetCreature);
_GCSkillToTileOK2.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK4.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK5.addCListElement(pTargetCreature->getObjectID());
}
pEffect->affectObject(pTarget, false);
}
}
}
}
_GCSkillToTileOK2.setObjectID(pMonster->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setDuration(output.Duration);
_GCSkillToTileOK2.setRange(Range);
//_GCSkillToTileOK2.addShortData(MODIFY_VISION, DARKNESS_SIGHT);
_GCSkillToTileOK3.setObjectID(pMonster->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setRange(Range);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK5.setObjectID(pMonster->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setRange(Range);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK6.setOrgXY(myX, myY);
_GCSkillToTileOK6.setSkillType(SkillType);
_GCSkillToTileOK6.setX(X);
_GCSkillToTileOK6.setY(Y);
_GCSkillToTileOK6.setDuration(output.Duration);
_GCSkillToTileOK6.setRange(Range);
//_GCSkillToTileOK6.addShortData(MODIFY_VISION, DARKNESS_SIGHT);
for(list<Creature*>::const_iterator itr = cList.begin(); itr != cList.end(); itr++)
{
Creature* pTargetCreature = *itr;
if (canSee(pTargetCreature, pMonster)) pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK2);
else pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK6);
}
cList.push_back(pMonster);
list<Creature*> watcherList = pZone->getWatcherList(myX, myY, pMonster);
// watcherList에서 cList에 속하지 않고, caster(pMonster)를 볼 수 없는 경우는
// OK4를 보내고.. cList에 추가한다.
for(list<Creature*>::const_iterator itr = watcherList.begin(); itr != watcherList.end(); itr++)
{
bool bBelong = false;
for(list<Creature*>::const_iterator tItr = cList.begin(); tItr != cList.end(); tItr++)
if (*itr == *tItr)
bBelong = true;
Creature* pWatcher = (*itr);
if (bBelong == false && canSee(pWatcher, pMonster) == false)
{
//Assert(pWatcher->isPC()); // 당연 PC다.. Zone::getWatcherList는 PC만 return한다
if (!pWatcher->isPC())
{
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
pWatcher->getPlayer()->sendPacket(&_GCSkillToTileOK4);
cList.push_back(*itr);
}
}
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList, false);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
}
else
{
executeSkillFailNormal(pMonster, getSkillType(), NULL);
}
}
catch (Throwable & t)
{
executeSkillFailException(pMonster, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
