//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void DestructionSpear::execute(Ousters* pOusters, ObjectID_t TargetObjectID, OustersSkillSlot* pOustersSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
Assert(pOusters != NULL);
Assert(pOustersSkillSlot != NULL);
try
{
Zone* pZone = pOusters->getZone();
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL)
{
executeSkillFailException(pOusters, getSkillType());
return;
}
execute(pOusters, pTargetCreature->getX(), pTargetCreature->getY(), pOustersSkillSlot, CEffectID);
}
catch (Throwable & t)
{
executeSkillFailException(pOusters, getSkillType());
//cout << t.toString() << endl;
}
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 슬레이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void MoleShot::execute(Slayer* pSlayer, ObjectID_t TargetObjectID, SkillSlot* pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pSlayer != NULL);
Assert(pSkillSlot != NULL);
try
{
Zone* pZone = pSlayer->getZone();
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL)
{
executeSkillFailException(pSlayer, getSkillType());
return;
}
// 아이템이 없거나, 총 계열의 무기가 아니거나, SR이라면
// 이 기술을 사용할 수 없다.
Item* pItem = pSlayer->getWearItem(Slayer::WEAR_RIGHTHAND);
if (pItem == NULL
|| !isArmsWeapon(pItem))
// SR도 사용 가능하게 수정. by sigi. 2002.12.3
// || pItem->getItemClass() == Item::ITEM_CLASS_SR)
{
executeSkillFailException(pSlayer, getSkillType());
return;
}
Item::ItemClass IClass = pItem->getItemClass();
if (IClass == Item::ITEM_CLASS_SG)
{
SGexecute(pSlayer, pTargetCreature->getX(), pTargetCreature->getY(), pSkillSlot, CEffectID);
}
else if (IClass == Item::ITEM_CLASS_AR
|| IClass == Item::ITEM_CLASS_SMG
// SR도 사용 가능하게 수정. by sigi. 2002.12.3
|| IClass == Item::ITEM_CLASS_SR)
{
ARSMGexecute(pSlayer, pTargetCreature->getX(), pTargetCreature->getY(), pSkillSlot, CEffectID);
}
}
catch (Throwable & t)
{
executeSkillFailException(pSlayer, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
void EffectBlazeWalk::affect(Creature* pCreature)
throw(Error)
{
__BEGIN_TRY
Assert(pCreature != NULL);
Zone* pZone = pCreature->getZone();
Assert(pZone != NULL);
Creature* pAttacker = pZone->getCreature(m_UserObjectID);
if (pAttacker == NULL )
{
setDeadline(0);
return;
}
if (!(pZone->getZoneLevel() & COMPLETE_SAFE_ZONE)
&& !pCreature->isDead()
&& !pCreature->isFlag(Effect::EFFECT_CLASS_COMA )
// 무적상태 체크. by sigi. 2002.9.5
&& canAttack(pAttacker, pCreature )
)
{
GCModifyInformation gcMI, gcAttackerMI;
setDamage(pCreature, m_Point, pAttacker, m_SkillType, &gcMI, &gcAttackerMI);
if (pAttacker->isPC() ) computeAlignmentChange(pCreature, m_Point, pAttacker, &gcMI, &gcAttackerMI);
if (pCreature->isPC() ) pCreature->getPlayer()->sendPacket(&gcMI);
if (pAttacker->isSlayer() && !pCreature->isSlayer() )
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pAttacker);
if (pSlayer != NULL )
{
GCModifyInformation gcMI;
shareAttrExp(pSlayer, m_Point, 8, 1, 1, gcAttackerMI);
}
}
if (pAttacker->isPC() ) pAttacker->getPlayer()->sendPacket(&gcAttackerMI);
if (pCreature->isDead() ) setDeadline(0);
}
m_AttackNum--;
if (m_AttackNum > 0 )
{
setNextTime(5);
}
else setDeadline(0);
//cout << "EffectBlazeWalk " << "begin" << endl;
//cout << "EffectBlazeWalk " << "end" << endl;
__END_CATCH
}
void EffectDivineGuidance::affect(Creature* pCreature)
throw(Error)
{
__BEGIN_TRY
//cout << "EffectDivineGuidance " << "begin" << endl;
//cout << "EffectDivineGuidance " << "end" << endl;
Assert(pCreature != NULL);
Zone* pZone = pCreature->getZone();
Assert(pZone != NULL);
Creature* pAttacker = pZone->getCreature(m_UserObjectID);
if (!(pZone->getZoneLevel() & COMPLETE_SAFE_ZONE)
&& !pCreature->isDead()
&& !pCreature->isFlag(Effect::EFFECT_CLASS_COMA)
// 무적상태 체크. by sigi. 2002.9.5
&& canAttack(pAttacker, pCreature )
)
{
GCModifyInformation gcMI, gcAttackerMI;
setDamage(pCreature, m_Point, pAttacker, SKILL_DIVINE_GUIDANCE, &gcMI, &gcAttackerMI);
if (pCreature->isPC() ) pCreature->getPlayer()->sendPacket(&gcMI);
if (pAttacker!=NULL)
{
computeAlignmentChange(pCreature, m_Point, pAttacker, &gcMI, &gcAttackerMI);
if (pAttacker->isPC() )
{
if (pAttacker->isSlayer() && !pCreature->isSlayer() )
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pAttacker);
if (pSlayer != NULL )
{
GCModifyInformation gcMI;
shareAttrExp(pSlayer, m_Point, 1, 1, 8, gcAttackerMI);
}
}
if (pAttacker->isPC() ) pAttacker->getPlayer()->sendPacket(&gcAttackerMI);
}
}
}
setNextTime(m_Tick);
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 아우스터즈 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void SummonGroundElemental::execute(Ousters* pOusters, ObjectID_t TargetObjectID, 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() <= 10 ) Grade = 0;
else if (pOustersSkillSlot->getExpLevel() <= 20 ) Grade = 1;
else if (pOustersSkillSlot->getExpLevel() < 30 ) Grade = 2;
else Grade = 3;
try
{
Zone* pZone = pOusters->getZone();
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NPC는 공격할 수가 없다.
if (pTargetCreature==NULL // NoSuch제거 때문에.. by sigi. 2002.5.2
|| pTargetCreature->isNPC())
{
executeSkillFailException(pOusters, getSkillType(), Grade);
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
return;
}
execute(pOusters, pTargetCreature->getX(), pTargetCreature->getY(), pOustersSkillSlot, CEffectID);
}
catch (Throwable & t)
{
executeSkillFailException(pOusters, getSkillType(), Grade);
//cout << t.toString() << endl;
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 슬레이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void SwordRay::execute(Slayer* pSlayer, ObjectID_t TargetObjectID, SkillSlot* pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << "begin " << endl;
// Slayer Object Assertion
Assert(pSlayer != NULL);
Assert(pSkillSlot != NULL);
try
{
Zone* pZone = pSlayer->getZone();
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL
|| !canAttack(pSlayer, pTargetCreature )
|| pTargetCreature->isNPC())
{
executeSkillFailException(pSlayer, getSkillType());
return;
}
execute(pSlayer, pTargetCreature->getX(), pTargetCreature->getY(), pSkillSlot, CEffectID);
}
catch (Throwable & t)
{
executeSkillFailException(pSlayer, getSkillType());
//cout << t.toString() << endl;
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void RefusalEther::execute(Ousters* pOusters, ObjectID_t TargetObjectID, 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
{
Zone* pZone = pOusters->getZone();
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL)
{
executeSkillFailException(pOusters, getSkillType(), Grade);
return;
}
execute(pOusters, pTargetCreature->getX(), pTargetCreature->getY(), pOustersSkillSlot, CEffectID);
}
catch (Throwable & t)
{
executeSkillFailException(pOusters, getSkillType(), Grade);
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
void SwordOfThor::execute(Slayer* pSlayer, ObjectID_t targetObjectID, SkillSlot* pSkillSlot, CEffectID_t CEffectID) throw(Error)
{
__BEGIN_TRY
Zone* pZone = pSlayer->getZone();
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(targetObjectID);
//Assert(pTargetCreature != NULL);
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL)
{
executeSkillFailException(pSlayer, getSkillType());
return;
}
execute(pSlayer, pTargetCreature->getX(), pTargetCreature->getY(), pSkillSlot, CEffectID);
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void MeteorStrike::execute(Vampire* pVampire, ObjectID_t TargetObjectID, VampireSkillSlot* pVampireSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << "begin " << endl;
Assert(pVampire != NULL);
Assert(pVampireSkillSlot != NULL);
try
{
Zone* pZone = pVampire->getZone();
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NPC는 공격할 수가 없다.
if (pTargetCreature==NULL // NoSuch제거 때문에.. by sigi. 2002.5.2
|| !canAttack(pVampire, pTargetCreature )
|| pTargetCreature->isNPC())
{
executeSkillFailException(pVampire, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
return;
}
execute(pVampire, pTargetCreature->getX(), pTargetCreature->getY(), pVampireSkillSlot, CEffectID);
}
catch (Throwable & t)
{
executeSkillFailException(pVampire, getSkillType());
//cout << t.toString() << endl;
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 슬레이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void ThunderStorm::execute(Slayer * pSlayer, ObjectID_t TargetObjectID, SkillSlot * pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
Zone* pZone = pSlayer->getZone();
Assert(pZone!=NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
if (pTargetCreature!=NULL)
{
execute(pSlayer, pTargetCreature->getX(), pTargetCreature->getY(), pSkillSlot, CEffectID);
}
else
{
executeSkillFailException(pSlayer, getSkillType());
}
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void IceField::execute(Ousters* pOusters, ObjectID_t TargetObjectID, OustersSkillSlot* pOustersSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pOusters != NULL);
Assert(pOustersSkillSlot != NULL);
try
{
Zone* pZone = pOusters->getZone();
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL
|| !canAttack(pOusters, pTargetCreature )
)
{
executeSkillFailException(pOusters, getSkillType());
return;
}
execute(pOusters, pTargetCreature->getX(), pTargetCreature->getY(), pOustersSkillSlot, CEffectID);
}
catch (Throwable & t)
{
executeSkillFailException(pOusters, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 슬레이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void ThunderFlash::execute(Slayer* pSlayer, ObjectID_t TargetObjectID, SkillSlot* pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " begin(slayerobject)" << endl;
Assert(pSlayer != NULL);
Assert(pSkillSlot != NULL);
try
{
Zone* pZone = pSlayer->getZone();
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL)
{
executeSkillFailException(pSlayer, getSkillType());
return;
}
execute(pSlayer, pTargetCreature->getX(), pTargetCreature->getY(), pSkillSlot, CEffectID);
}
catch (Throwable & t)
{
executeSkillFailException(pSlayer, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end(slayerobject)" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void Darkness::execute(Vampire* pVampire, ObjectID_t TargetObjectID, VampireSkillSlot* pVampireSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pVampire != NULL);
Assert(pVampireSkillSlot != NULL);
try
{
Zone* pZone = pVampire->getZone();
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL)
{
executeSkillFailException(pVampire, getSkillType());
return;
}
execute(pVampire, pTargetCreature->getX(), pTargetCreature->getY(), pVampireSkillSlot, CEffectID);
}
catch (Throwable & t)
{
executeSkillFailException(pVampire, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////
//
// Visible::execute()
//
//////////////////////////////////////////////////////////////////////
void Visible::execute(Slayer * pSlayer, ObjectID_t TargetObjectID, SkillSlot * pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pSlayer != NULL);
Assert(pSkillSlot != NULL);
try
{
// Player를 받아온다.
Player * pPlayer = pSlayer->getPlayer();
// Zone을 받아온다.
Zone * pZone = pSlayer->getZone();
Creature * pTargetCreature = NULL;
if (pSlayer->getObjectID() == TargetObjectID) pTargetCreature = pSlayer;
else pTargetCreature = pZone->getCreature(TargetObjectID);
SkillType_t SkillType = pSkillSlot->getSkillType();
//Assert (pTargetCreature != NULL);
if (pTargetCreature == NULL || pTargetCreature->isNPC())
{
executeSkillFailException(pSlayer, SkillType);
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
SkillInfo * pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
// 기술의 레벨을 받아온다.
//SkillLevel_t SkillLevel = pSkillSlot->getExpLevel();
//SkillDomainType_t DomainType = pSkillInfo->getDomainType();
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pSlayer, pTargetCreature, pSkillInfo->getRange());
bool bHit = false;
// 기술성공률 검증.
if (bManaCheck && bTimeCheck && bRangeCheck)
{
Coord_t myX = pSlayer->getX(), myY = pSlayer->getY();
Coord_t X = pTargetCreature->getX(), Y = pTargetCreature->getY();
Dir_t dir = calcDirection(myX, myY, X, Y);
SkillInput input(pSlayer, pSkillSlot);
SkillOutput output;
computeOutput(input, output);
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
decreaseMana(pSlayer, RequiredMP, _GCSkillToTileOK1);
// by sigi. 2002.11.12
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
list<Creature*> cList;
int oX, oY;
for(oX = -2; oX <= 2; oX++)
for(oY = -2; oY <= 2; oY++)
{
int tileX = X+oX;
int tileY = Y+oY;
// by sigi. 2002.11.12
if (!rect.ptInRect(tileX, tileY)) continue;
Tile& tile = pZone->getTile(tileX, tileY);
pTargetCreature = NULL;
if(tile.hasCreature(Creature::MOVE_MODE_WALKING)) pTargetCreature = tile.getCreature(Creature::MOVE_MODE_WALKING);
if(pTargetCreature != NULL)
{
if(pTargetCreature->isPC())
{
bool bHitRoll = HitRoll::isSuccessMagic(pSlayer, pSkillInfo, pSkillSlot);
bool bEffected = pTargetCreature->isFlag(Effect::EFFECT_CLASS_INVISIBILITY);
if(bHitRoll && bEffected ) {
// 주위에 GCAddXXX를 보내고, effect manager에서 effect를 삭제하고, GCRemoveEffect를 보낸다.
addVisibleCreature(pZone, pTargetCreature, true);
_GCSkillToTileOK2.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setRange(dir);
_GCSkillToTileOK2.setDuration(0);
Player * pTargetPlayer = pTargetCreature->getPlayer();
Assert(pTargetPlayer != NULL);
pTargetPlayer->sendPacket(&_GCSkillToTileOK2);
cList.push_back(pTargetCreature);
bHit = true;
}
}
} // if(pTargetCreature!= NULL)
}
SkillDomainType_t DomainType = pSkillInfo->getDomainType();
// EXP UP!
Exp_t Point = pSkillInfo->getPoint();
if(bHit ) {
shareAttrExp(pSlayer, Point, 1, 1, 8, _GCSkillToTileOK1);
increaseDomainExp(pSlayer, DomainType, pSkillInfo->getPoint(), _GCSkillToTileOK1);
increaseSkillExp(pSlayer, DomainType, pSkillSlot, pSkillInfo, _GCSkillToTileOK1);
}
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setRange(dir);
_GCSkillToTileOK1.setDuration(0);
_GCSkillToTileOK3.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setDuration(0);
_GCSkillToTileOK4.setRange(dir);
_GCSkillToTileOK5.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setRange(dir);
_GCSkillToTileOK5.setDuration(0);
// Send Packet
pPlayer->sendPacket(&_GCSkillToTileOK1);
cList.push_back(pSlayer);
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList);
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 BloodDrain::execute(Vampire* pVampire, ObjectID_t TargetObjectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin(vampire)" << endl;
Assert(pVampire != NULL);
try
{
Player* pPlayer = pVampire->getPlayer();
Zone* pZone = pVampire->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NPC는 공격할 수가 없다.
// 면역 상태. by sigi. 2002.9.13
// 무적상태 체크. by sigi.2002.9.5
// 죽은 애는 피 빨 수 없다. by Sequoia.2003. 3. 20
if (pTargetCreature==NULL // NoSuch 제거. by sigi. 2002.5.2
|| pTargetCreature->isNPC()
|| pTargetCreature->isFlag(Effect::EFFECT_CLASS_IMMUNE_TO_BLOOD_DRAIN)
|| !canAttack(pVampire, pTargetCreature )
|| pTargetCreature->isFlag(Effect::EFFECT_CLASS_COMA)
|| pTargetCreature->isDead()
)
{
executeSkillFailException(pVampire, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End(vampire)" << endl;
return;
}
GCBloodDrainOK1 _GCBloodDrainOK1;
GCBloodDrainOK2 _GCBloodDrainOK2;
GCBloodDrainOK3 _GCBloodDrainOK3;
Timeval CurrentTime;
getCurrentTime(CurrentTime);
bool bHitRoll = HitRoll::isSuccessBloodDrain(pVampire, pTargetCreature);
bool bCanHit = canHit(pVampire, pTargetCreature, SKILL_BLOOD_DRAIN);
bool bTimeCheck = CurrentTime.tv_sec > 1 ? true : false;
bool bRangeCheck = verifyDistance(pVampire, pTargetCreature, 2);
bool bPK = verifyPK(pVampire, pTargetCreature);
if (bHitRoll && bCanHit && bTimeCheck && bRangeCheck && bPK)
{
// 슬레이어일 경우에만 이펙트 오브젝트를 생성한다.
if (pTargetCreature->isSlayer())
{
EffectBloodDrain* pEffectBloodDrain = new EffectBloodDrain(pTargetCreature);
pEffectBloodDrain->setLevel(pVampire->getLevel());
pEffectBloodDrain->setDeadline(BLOODDRAIN_DURATION); // 3일??
pTargetCreature->addEffect(pEffectBloodDrain);
pEffectBloodDrain->create(pTargetCreature->getName());
_GCBloodDrainOK2.addShortData(MODIFY_EFFECT_STAT, Effect::EFFECT_CLASS_BLOOD_DRAIN);
// 타겟이 뭐든 플래그는 건다.
pTargetCreature->setFlag(Effect::EFFECT_CLASS_BLOOD_DRAIN);
Slayer* pTargetSlayer = dynamic_cast<Slayer*>(pTargetCreature);
SLAYER_RECORD prev;
pTargetSlayer->getSlayerRecord(prev);
pTargetSlayer->initAllStat();
pTargetSlayer->sendRealWearingInfo();
pTargetSlayer->addModifyInfo(prev, _GCBloodDrainOK2);
// 로그를 남긴다.
//log(LOG_BLOODDRAINED, pTargetCreature->getName(), pVampire->getName());
}
// 아우스터즈의 경우엔..... -_-; 제한시간 없는 이펙트를 생성한다. 엄밀히 말해 제한시간이 없는 건 아니지만..
// else if (pTargetCreature->isOusters() )
// {
// EffectBloodDrain* pEffectBloodDrain = new EffectBloodDrain(pTargetCreature);
// pEffectBloodDrain->setLevel(pVampire->getLevel());
// pTargetCreature->addEffect(pEffectBloodDrain);
// pEffectBloodDrain->create(pTargetCreature->getName());
// _GCBloodDrainOK2.addShortData(MODIFY_EFFECT_STAT, Effect::EFFECT_CLASS_BLOOD_DRAIN);
//
// // 타겟이 뭐든 플래그는 건다.
// pTargetCreature->setFlag(Effect::EFFECT_CLASS_BLOOD_DRAIN);
//
// Sight_t oldSight = pTargetCreature->getSight();
// Sight_t newSight = pTargetCreature->getEffectedSight();
//
// if (oldSight != newSight )
// {
// pTargetCreature->setSight(newSight);
// pZone->updateScan(pTargetCreature, oldSight, pTargetCreature->getSight());
// _GCBloodDrainOK2.addShortData(MODIFY_VISION, pTargetCreature->getSight());
//
// GCChangeDarkLight gcChangeDarkLight;
// gcChangeDarkLight.setDarkLevel(15);
// gcChangeDarkLight.setLightLevel(newSight);
// pTargetCreature->getPlayer()->sendPacket(&gcChangeDarkLight);
// }
// }
// 타겟이 뭐든 플래그는 건다.
pTargetCreature->setFlag(Effect::EFFECT_CLASS_BLOOD_DRAIN);
// 올릴 경험치량을 계산한다.
Exp_t Exp = computeCreatureExp(pTargetCreature, BLOODDRAIN_EXP);
int targetLevel = 0;
int targetMaxHP = 0;
// 페임을 올려준다.
if (pTargetCreature->isSlayer())
{
//increaseFame(pVampire, Exp);
Slayer* pTargetSlayer = dynamic_cast<Slayer*>(pTargetCreature);
targetLevel = pTargetSlayer->getHighestSkillDomainLevel();
targetMaxHP = pTargetSlayer->getHP(ATTR_MAX);
}
else if (pTargetCreature->isVampire())
{
//increaseFame(pVampire, Exp);
Vampire* pTargetVampire = dynamic_cast<Vampire*>(pTargetCreature);
targetLevel = pTargetVampire->getLevel();
targetMaxHP = pTargetVampire->getHP(ATTR_MAX);
}
else if (pTargetCreature->isOusters())
{
//increaseFame(pOusters, Exp);
Ousters* pTargetOusters = dynamic_cast<Ousters*>(pTargetCreature);
targetLevel = pTargetOusters->getLevel();
targetMaxHP = pTargetOusters->getHP(ATTR_MAX);
}
else if (pTargetCreature->isMonster())
{
Monster* pMonster = dynamic_cast<Monster*>(pTargetCreature);
Timeval NextTurn = pMonster->getNextTurn();
Timeval DelayTurn;
DelayTurn.tv_sec = 4;
DelayTurn.tv_usec = 500000;
pMonster->addAccuDelay(DelayTurn);
pMonster->addEnemy(pVampire);
targetLevel = pMonster->getLevel();
targetMaxHP = pMonster->getHP(ATTR_MAX);
}
shareVampExp(pVampire, Exp, _GCBloodDrainOK1);
// 흡혈을 하게 되면 흡혈한 사람의 체력이 올라간다.
// Mephisto이펙트가 걸려있으면 HP는 안 올라간다.
if (!pVampire->isFlag(Effect::EFFECT_CLASS_MEPHISTO))
{
HP_t HealPoint = (Exp==0? computeBloodDrainHealPoint(pTargetCreature, BLOODDRAIN_EXP) : Exp);
HP_t CurrentHP = pVampire->getHP();
HP_t MaxHP = pVampire->getHP(ATTR_MAX);
HP_t NewHP = min((int)MaxHP , (int)CurrentHP + (int)HealPoint);
// 은 데미지 관련 처리를 해 준다.
Silver_t newSilverDamage = max(0, (int)pVampire->getSilverDamage()-(int)HealPoint);
pVampire->saveSilverDamage(newSilverDamage);
_GCBloodDrainOK1.addShortData(MODIFY_SILVER_DAMAGE, newSilverDamage);
// 뱀파이어의 HP를 세팅한다.
pVampire->setHP(NewHP);
GCStatusCurrentHP gcStatusCurrentHP;
gcStatusCurrentHP.setObjectID(pVampire->getObjectID());
gcStatusCurrentHP.setCurrentHP(NewHP);
pZone->broadcastPacket(pVampire->getX(), pVampire->getY(), &gcStatusCurrentHP, pVampire);
_GCBloodDrainOK1.addShortData(MODIFY_CURRENT_HP, NewHP);
}
// 흡혈을 당한 애는 HP가 줄어든다.
// 대상이 내 레벨보다 높다면.. MaxHP의 10~15% damage
// by sigi. 2002.9.14
int drainDamage = 0;
int myLevel = pVampire->getLevel();
if (targetLevel > myLevel)
{
drainDamage = targetMaxHP * (rand()%6+10) / 100;
}
else
{
// 레벨 5차이마다 1%씩 더~
int damagePercent = min(30, (rand()%6+10+(myLevel-targetLevel)));
drainDamage = targetMaxHP * damagePercent / 100;
}
if (drainDamage > 0)
{
//decreaseHP(pZone, pTargetCreature, drainDamage, pVampire->getObjectID());
EffectDecreaseHP* pEffect = new EffectDecreaseHP(pTargetCreature);
pEffect->setPoint(drainDamage);
pEffect->setDeadline(20); // 2초 후
pEffect->setUserObjectID(pVampire->getObjectID());
pTargetCreature->addEffect(pEffect);
pTargetCreature->setFlag(Effect::EFFECT_CLASS_DECREASE_HP);
}
pVampire->getGQuestManager()->blooddrain();
// 흡혈시에도 성향 바뀜
// by sigi. 2002.12.16
// EffectDecreaseHP에서 HP가 닳아서 0이 되어야하는 경우가 있어서
// EffectDecreaseHP::unaffect()로 옮긴다.
//computeAlignmentChange(pTargetCreature, drainDamage, pVampire, NULL, &_GCBloodDrainOK1);
_GCBloodDrainOK1.setObjectID(TargetObjectID);
_GCBloodDrainOK3.setObjectID(pVampire->getObjectID());
_GCBloodDrainOK3.setTargetObjectID (TargetObjectID);
pPlayer->sendPacket(&_GCBloodDrainOK1);
if (pTargetCreature != NULL && pTargetCreature->isPC())
{
Player* pTargetPlayer = pTargetCreature->getPlayer();
if (pTargetPlayer != NULL)
{
_GCBloodDrainOK2.setObjectID(pVampire->getObjectID());
// _GCBloodDrainOK2.addLongData(MODIFY_DURATION, BLOODDRAIN_DURATION);
pTargetPlayer->sendPacket(&_GCBloodDrainOK2);
}
}
list<Creature *> cList;
cList.push_back(pTargetCreature);
cList.push_back(pVampire);
pZone->broadcastPacket(pVampire->getX(), pVampire->getY(), &_GCBloodDrainOK3 , cList);
}
else
{
executeSkillFailNormal(pVampire, getSkillType(), pTargetCreature);
}
}
catch (Throwable & t)
{
executeSkillFailException(pVampire, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End(vampire)" << endl;
__END_CATCH
}
void CGShopRequestSellHandler::executeOpSwapAdvancementItem(CGShopRequestSell* pPacket, Player* pPlayer)
throw(ProtocolException, Error)
{
__BEGIN_TRY
#ifdef __GAME_SERVER__
ObjectID_t NPCID = pPacket->getObjectID();
ObjectID_t ITEMOID = pPacket->getItemObjectID();
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Creature* pCreature = pGamePlayer->getCreature();
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature);
if (!pPC->isAdvanced() )
{
return sendFailPacket(pPacket, pPlayer);
}
Zone* pZone = pPC->getZone();
if (pZone == NULL) return sendFailPacket(pPacket, pPlayer);
Creature* pNPCBase = pZone->getCreature(NPCID);
if (pNPCBase == NULL || !pNPCBase->isNPC()) return sendFailPacket(pPacket, pPlayer);
NPC* pNPC = dynamic_cast<NPC*>(pNPCBase);
Inventory* pInventory = pPC->getInventory();
Item* pItem = pInventory->getItemWithObjectID(ITEMOID);
if (pItem == NULL || pItem->isTimeLimitItem() )
{
return sendFailPacket(pPacket, pPlayer);
}
Item::ItemClass iClass = Item::ITEM_CLASS_MAX;
ItemType_t iType = 0;
Grade_t iGrade = 0;
FlagSetType fType = FLAGSET_MAX;
ItemInfo* pItemInfo = g_pItemInfoManager->getItemInfo(pItem->getItemClass(), pItem->getItemType());
Assert(pItemInfo!=NULL);
switch (pItem->getItemClass() )
{
case Item::ITEM_CLASS_SWORD:
case Item::ITEM_CLASS_BLADE:
case Item::ITEM_CLASS_AR:
case Item::ITEM_CLASS_SR:
case Item::ITEM_CLASS_SG:
case Item::ITEM_CLASS_SMG:
{
switch (pItem->getItemType() )
{
case 9:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 2;
break;
}
case 11:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 4;
break;
}
case 12:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 6;
break;
}
case 13:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 8;
break;
}
default:
break;
}
if (iClass == Item::ITEM_CLASS_SG ) iClass = Item::ITEM_CLASS_SR;
if (iClass == Item::ITEM_CLASS_SMG ) iClass = Item::ITEM_CLASS_AR;
break;
}
case Item::ITEM_CLASS_CROSS:
case Item::ITEM_CLASS_MACE:
{
switch (pItem->getItemType() )
{
case 7:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 2;
break;
}
case 9:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 4;
break;
}
case 10:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 6;
break;
}
case 11:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 8;
break;
}
default:
break;
}
break;
}
case Item::ITEM_CLASS_COAT:
case Item::ITEM_CLASS_TROUSER:
{
switch (pItem->getItemType() )
{
case 14:
case 15:
{
iClass = pItem->getItemClass();
iType = 24 + (pItem->getItemType()%2);
iGrade = 2;
break;
}
case 18:
case 19:
case 20:
case 21:
case 22:
case 23:
{
iClass = pItem->getItemClass();
iType = 24 + (pItem->getItemType()%2);
iGrade = 4 + (((pItem->getItemType()-18)/2)*2);
break;
}
default:
break;
}
break;
}
case Item::ITEM_CLASS_VAMPIRE_WEAPON:
{
switch (pItem->getItemType() )
{
case 14:
{
iClass = pItem->getItemClass();
iType = 19;
iGrade = 2;
break;
}
case 16:
{
iClass = pItem->getItemClass();
iType = 19;
iGrade = 4;
break;
}
case 17:
{
iClass = pItem->getItemClass();
iType = 19;
iGrade = 6;
break;
}
case 18:
{
iClass = pItem->getItemClass();
iType = 19;
iGrade = 8;
break;
}
default:
break;
}
break;
}
case Item::ITEM_CLASS_VAMPIRE_COAT:
{
switch (pItem->getItemType() )
{
case 10:
case 11:
{
iClass = pItem->getItemClass();
iType = 20 + (pItem->getItemType()%2);
iGrade = 2;
break;
}
case 14:
case 15:
case 16:
case 17:
case 18:
case 19:
{
iClass = pItem->getItemClass();
iType = 20 + (pItem->getItemType()%2);
iGrade = 4 + (((pItem->getItemType()-14)/2)*2);
break;
}
default:
break;
}
break;
}
case Item::ITEM_CLASS_OUSTERS_CHAKRAM:
{
switch (pItem->getItemType() )
{
case 9:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 2;
break;
}
case 10:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 4;
break;
}
case 11:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 6;
break;
}
case 13:
{
iClass = pItem->getItemClass();
iType = 14;
iGrade = 8;
break;
}
default:
break;
}
break;
}
case Item::ITEM_CLASS_OUSTERS_WRISTLET:
{
switch (pItem->getItemType() )
{
case 9:
case 30:
case 31:
case 39:
{
iClass = pItem->getItemClass();
iType = 42;
iGrade = pItemInfo->getItemLevel() * 2 - 16;
break;
}
case 19:
case 32:
case 33:
case 40:
{
iClass = pItem->getItemClass();
iType = 43;
iGrade = pItemInfo->getItemLevel() * 2 - 16;
break;
}
case 29:
case 34:
case 35:
case 41:
{
iClass = pItem->getItemClass();
iType = 44;
iGrade = pItemInfo->getItemLevel() * 2 - 16;
break;
}
default:
break;
}
break;
}
case Item::ITEM_CLASS_OUSTERS_COAT:
case Item::ITEM_CLASS_OUSTERS_BOOTS:
{
switch (pItem->getItemType() )
{
case 7:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 2;
break;
}
case 8:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 4;
break;
}
case 9:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 6;
break;
}
case 11:
{
iClass = pItem->getItemClass();
iType = 12;
iGrade = 8;
break;
}
default:
break;
}
break;
}
default:
break;
}
switch (iClass )
{
case Item::ITEM_CLASS_SWORD:
case Item::ITEM_CLASS_BLADE:
case Item::ITEM_CLASS_AR:
case Item::ITEM_CLASS_SR:
case Item::ITEM_CLASS_CROSS:
case Item::ITEM_CLASS_MACE:
case Item::ITEM_CLASS_VAMPIRE_WEAPON:
case Item::ITEM_CLASS_OUSTERS_CHAKRAM:
case Item::ITEM_CLASS_OUSTERS_WRISTLET:
fType = FLAGSET_SWAP_WEAPON;
break;
case Item::ITEM_CLASS_COAT:
case Item::ITEM_CLASS_VAMPIRE_COAT:
case Item::ITEM_CLASS_OUSTERS_COAT:
fType = FLAGSET_SWAP_COAT;
break;
case Item::ITEM_CLASS_TROUSER:
case Item::ITEM_CLASS_OUSTERS_BOOTS:
fType = FLAGSET_SWAP_TROUSER;
break;
default:
break;
}
if (iClass == Item::ITEM_CLASS_MAX || fType == FLAGSET_MAX )
{
sendFailPacket(pPacket, pPlayer);
return;
}
FlagSet* pFlagSet = pPC->getFlagSet();
if (pFlagSet->isOn(fType) )
{
sendFailPacket(pPacket, pPlayer);
return;
}
Item* pNewItem = g_pItemFactoryManager->createItem(iClass, iType, pItem->getOptionTypeList());
if (pNewItem == NULL )
{
sendFailPacket(pPacket, pPlayer);
return;
}
pNewItem->setGrade(iGrade);
_TPOINT tp;
if (!pInventory->getEmptySlot(pNewItem, tp) )
{
SAFE_DELETE(pNewItem);
sendFailPacket(pPacket, pPlayer);
return;
}
filelog("ItemSwap.log", "[%s:%s] %s <-> %s",
pGamePlayer->getID().c_str(), pPC->getName().c_str(), pItem->toString().c_str(), pNewItem->toString().c_str());
pNewItem->setTraceItem(bTraceLog(pNewItem ));
pInventory->deleteItem(ITEMOID);
pItem->whenPCLost(pPC);
if (!pItem->destroy())
{
filelog("shopDBBug.txt", "NoSuchItemInDB-destroy: %s", pItem->toString().c_str());
throw DisconnectException("아이템 지울려는데 DB에 없다.");
}
pZone->registerObject(pNewItem);
GCShopSellOK okpkt;
okpkt.setObjectID(NPCID);
okpkt.setShopVersion(-1);
okpkt.setItemObjectID(ITEMOID);
okpkt.setPrice(0);
pGamePlayer->sendPacket(&okpkt);
// 삭제할 아이템의 ItemTrace Log 를 남겨야 한다면 남긴다
if (pItem != NULL && pItem->isTraceItem() )
{
remainTraceLog(pItem, pCreature->getName() , pNPC->getName(), ITEM_LOG_DELETE, DETAIL_SHOPSELL);
}
// 인벤토리에 추가
Assert(pInventory->addItem(pNewItem, tp ));
// DB 에 생성
pNewItem->create(pPC->getName(), STORAGE_INVENTORY, 0, tp.x, tp.y);
// 교환해줄 아이템의 ItemTrace Log 를 남겨야 한다면 남긴다
if (pNewItem->isTraceItem() )
{
remainTraceLog(pNewItem, pNPC->getName() , pCreature->getName(), ITEM_LOG_CREATE, DETAIL_SHOPBUY);
}
pFlagSet->turnOn(fType);
pFlagSet->save(pPC->getName());
GCCreateItem gcCI;
makeGCCreateItem(&gcCI, pNewItem, tp.x, tp.y);
pGamePlayer->sendPacket(&gcCI);
#endif
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
//
// 해골 한꺼번에 팔기를 실행한다.
//
//////////////////////////////////////////////////////////////////////////////
void CGShopRequestSellHandler::executeOpAllSkull (CGShopRequestSell* pPacket , Player* pPlayer)
throw(ProtocolException , Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
ObjectID_t NPCID = pPacket->getObjectID();
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Creature* pCreature = pGamePlayer->getCreature();
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature);
Zone* pZone = pPC->getZone();
if (pZone == NULL) return sendFailPacket(pPacket, pPlayer);
Creature* pNPCBase = NULL;
/*
try
{
pNPCBase = pZone->getCreature(NPCID);
}
catch (NoSuchElementException & nsee)
{
pNPCBase = NULL;
}
*/
// NoSuch제거. by sigi. 2002.5.2
pNPCBase = pZone->getCreature(NPCID);
if (pNPCBase == NULL || !pNPCBase->isNPC()) return sendFailPacket(pPacket, pPlayer);
NPC* pNPC = dynamic_cast<NPC*>(pNPCBase);
Inventory* pInventory = pPC->getInventory();
// by sigi. 2002.9.4
//Gold_t playerMoney = pPC->getGold();
Price_t itemPrice = 0;
Item* pItem = NULL;
for (uint y=0; y<pInventory->getHeight(); y++)
{
for (uint x=0; x<pInventory->getWidth(); x++)
{
pItem = pInventory->getItem(x, y);
// 아이템이 존재하고, 해골이라면...
if (pItem != NULL && pItem->getItemClass() == Item::ITEM_CLASS_SKULL)
{
// 아이템 가격을 계산해서 플레이어의 돈에다 더한다.
//itemPrice = g_pPriceManager->getPrice(pItem, pNPC->getMarketCondBuy(), SHOP_RACK_NORMAL, pPC) * pItem->getNum();
//playerMoney += itemPrice;
// by sigi. 2002.9.4
itemPrice += g_pPriceManager->getPrice(pItem, pNPC->getMarketCondBuy(), SHOP_RACK_NORMAL, pPC) * pItem->getNum();
// 인벤토리 및 DB에서 아이템을 삭제한다.
pInventory->deleteItem(x, y);
pItem->destroy();
SAFE_DELETE(pItem);
}
}
}
itemPrice = itemPrice * (g_pVariableManager->getHeadPriceBonus() / 100);
// 플레이어에게 물건값을 지불한다.
//pPC->setGoldEx(playerMoney);
// by sigi. 2002.9.4
pPC->increaseGoldEx(itemPrice);
// 물건을 산 플레이어에게 GCShopSellOK를...보낸다.
GCShopSellOK okpkt;
okpkt.setObjectID(NPCID);
okpkt.setShopVersion(pNPC->getShopVersion(SHOP_RACK_NORMAL));
okpkt.setItemObjectID(0);
okpkt.setPrice(pPC->getGold());
pPlayer->sendPacket(&okpkt);
#endif
__END_DEBUG_EX __END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
//
// 모터 사이클을 처리한다.
//
//////////////////////////////////////////////////////////////////////////////
void CGShopRequestSellHandler::executeMotorcycle (CGShopRequestSell* pPacket , Player* pPlayer)
throw(ProtocolException , Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
// 패킷 정보를 뽑아낸다.
ObjectID_t NPCID = pPacket->getObjectID();
ObjectID_t ITEMOID = pPacket->getItemObjectID();
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Creature* pCreature = pGamePlayer->getCreature();
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature);
Zone* pZone = pPC->getZone();
if (pZone == NULL) return sendFailPacket(pPacket, pPlayer);
Creature* pNPCBase = NULL;
/*
try
{
pNPCBase = pZone->getCreature(NPCID);
}
catch (NoSuchElementException & nsee)
{
pNPCBase = NULL;
}
*/
// NoSuch제거. by sigi. 2002.5.2
pNPCBase = pZone->getCreature(NPCID);
if (pNPCBase == NULL || !pNPCBase->isNPC()) return sendFailPacket(pPacket, pPlayer);
NPC* pNPC = dynamic_cast<NPC*>(pNPCBase);
int CenterX = pNPC->getX();
int CenterY = pNPC->getY();
// 플레이어가 팔려고 하는 아이템을 가지고 있는지 검사
Inventory* pInventory = pPC->getInventory();
Gold_t playerMoney = pPC->getGold();
Item* pItem = pInventory->getItemWithObjectID(ITEMOID);
if (pItem == NULL) return sendFailPacket(pPacket, pPlayer);
// 주위 일정 범위를 검색해서, 모터 사이클이 있는지 확인한다.
try
{
for (int zx=CenterX-5; zx<=CenterX+5; zx++)
{
for (int zy=CenterY-5; zy<=CenterY+5; zy++)
{
// 바운드를 넘어가지 않는가를 체크
if (!isValidZoneCoord(pZone, zx, zy)) continue;
Tile & tile = pZone->getTile(zx, zy);
if (tile.hasItem())
{
Item* pItemOnTile = tile.getItem();
if (pItemOnTile == NULL) continue;
// 만일 아이템이 타일 위에 있을 경우, 모터 사이클인지 확인한다.
if (pItemOnTile->getItemClass() == Item::ITEM_CLASS_MOTORCYCLE)
{
DWORD targetID = dynamic_cast<Key*>(pItem)->getTarget();
ItemID_t motorcycleID = pItemOnTile->getItemID();
if (targetID == motorcycleID)
{
// 모터사이클을 DB에서 삭제한다.
pItemOnTile->destroy();
// 플레이어의 인벤토리에서 열쇠를 제거한다.
pInventory->deleteItem(ITEMOID);
pItem->destroy();
SAFE_DELETE(pItem);
// 열쇠 값이 아니라, 오토바이 값을 줘야 한다.
Price_t itemPrice = g_pPriceManager->getPrice(pItemOnTile, pNPC->getMarketCondBuy(), SHOP_RACK_NORMAL, pPC);
// 플레이어의 돈을 늘린다.
//pPC->setGoldEx(playerMoney+itemPrice);
// by sigi. 2002.9.4
pPC->increaseGoldEx(itemPrice);
// 물건을 판 플레이어에게 GCShopSellOK를...보낸다.
GCShopSellOK okpkt;
okpkt.setObjectID(NPCID);
if (!pItemOnTile->getOptionTypeList().empty()) okpkt.setShopVersion(pNPC->getShopVersion(SHOP_RACK_SPECIAL));
else okpkt.setShopVersion(pNPC->getShopVersion(SHOP_RACK_NORMAL));
okpkt.setItemObjectID(ITEMOID);
okpkt.setPrice(playerMoney+itemPrice);
pPlayer->sendPacket(&okpkt);
// 뻑킹 센터에서 박스를 삭제해 준다.
if (g_pParkingCenter->hasMotorcycleBox(motorcycleID))
g_pParkingCenter->deleteMotorcycleBox(motorcycleID);
// NPC에게 자리가 충분하다면 플레이어가 판 아이템을 보관한다.
// 단 스페셜 아이템만을 보관한다. 노말 아이템은 그냥 버림.
//if (pItemOnTile->getOptionType() != 0)
//{
// index = pNPC->getFirstEmptySlot(SHOP_RACK_SPECIAL);
// if (index < SHOP_RACK_INDEX_MAX)
// {
// pNPC->insertShopItem(SHOP_RACK_SPECIAL, index, pItemOnTile);
// // 스페셜 아이템을 NPC가 진열장에 추가했으므로, 상점 버전이 올라간다.
// pNPC->increaseShopVersion(SHOP_RACK_SPECIAL);
// }
//}
//else
//{
// SAFE_DELETE(pItemOnTile);
//}
// 모터 사이클을 찾았으므로, 할 일이 끝났다.
return;
}
}
}
} // end of for (ZoneCoord_t zy=CenterY-5; zy<=CenterY+5; zy++)
} // end of for (ZoneCoord_t zx=CenterX-5; zx<=CenterX+5; zx++)
}
catch (Throwable & t)
{
filelog("shopbug_packet.log", "%s", t.toString().c_str());
}
// FOR 루프를 다 돌고, 이까지 왔다는 것은 근처에 오토바이가 없다는 말이당...
// 그러므로 모터 사이클 팔기가 실패했다는 것을 알린다.
GCShopSellFail failpkt;
failpkt.setObjectID(NPCID);
pPlayer->sendPacket(&failpkt);
#endif
__END_DEBUG_EX __END_CATCH
}
void EffectDecreaseHP::unaffect(Creature* pCreature)
throw(Error)
{
__BEGIN_TRY
__BEGIN_DEBUG
Assert(pCreature != NULL);
Zone* pZone = pCreature->getZone();
Assert(pZone != NULL);
pCreature->removeFlag(Effect::EFFECT_CLASS_DECREASE_HP);
Damage_t decreaseHP = m_Point;
if (!(pZone->getZoneLevel() & COMPLETE_SAFE_ZONE)
&& !pCreature->isDead()
&& !pCreature->isFlag(Effect::EFFECT_CLASS_COMA)
// 무적상태 체크. by sigi. 2002.9.5
&& canAttack(NULL, pCreature )
)
{
if (pCreature->isSlayer())
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pCreature);
HP_t CurrentHP = pSlayer->getHP(ATTR_CURRENT);
if (CurrentHP > 0)
{
HP_t RemainHP = max(0, CurrentHP -(int)decreaseHP);
pSlayer->setHP(RemainHP, ATTR_CURRENT);
GCModifyInformation gcMI;
gcMI.addShortData(MODIFY_CURRENT_HP, RemainHP);
pSlayer->getPlayer()->sendPacket(&gcMI);
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pSlayer->getObjectID());
pkt.setCurrentHP(RemainHP);
pZone->broadcastPacket(pSlayer->getX(), pSlayer->getY(), &pkt);
}
}
else if (pCreature->isVampire())
{
Vampire* pVampire = dynamic_cast<Vampire*>(pCreature);
HP_t CurrentHP = pVampire->getHP(ATTR_CURRENT);
if (CurrentHP > 0)
{
HP_t RemainHP = max(0, CurrentHP -(int)decreaseHP);
pVampire->setHP(RemainHP, ATTR_CURRENT);
GCModifyInformation gcMI;
gcMI.addShortData(MODIFY_CURRENT_HP, RemainHP);
pVampire->getPlayer()->sendPacket(&gcMI);
// 공격(흡혈) 당하는 경우에는 공격자의 성향이 바뀜 by sigi. 2002.12.27
Creature* pAttacker = pZone->getCreature(m_UserObjectID);
if (pAttacker!=NULL && pAttacker->isVampire())
{
Vampire* pAttackVampire = dynamic_cast<Vampire*>(pAttacker);
GCModifyInformation gcAttackerMI;
computeAlignmentChange(pVampire, decreaseHP, pAttackVampire, NULL, &gcAttackerMI);
// 뭔가 변한 정보가 있다면 보내준다.
if (gcAttackerMI.getShortCount()+gcAttackerMI.getLongCount() > 0)
{
pAttackVampire->getPlayer()->sendPacket(&gcAttackerMI);
}
}
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pVampire->getObjectID());
pkt.setCurrentHP(RemainHP);
pZone->broadcastPacket(pVampire->getX(), pVampire->getY(), &pkt);
}
}
else if (pCreature->isOusters())
{
Ousters* pOusters = dynamic_cast<Ousters*>(pCreature);
HP_t CurrentHP = pOusters->getHP(ATTR_CURRENT);
if (CurrentHP > 0)
{
HP_t RemainHP = max(0, CurrentHP -(int)decreaseHP);
pOusters->setHP(RemainHP, ATTR_CURRENT);
GCModifyInformation gcMI;
gcMI.addShortData(MODIFY_CURRENT_HP, RemainHP);
pOusters->getPlayer()->sendPacket(&gcMI);
// 공격(흡혈) 당하는 경우에는 공격자의 성향이 바뀜 by sigi. 2002.12.27
Creature* pAttacker = pZone->getCreature(m_UserObjectID);
if (pAttacker!=NULL && pAttacker->isOusters())
{
Ousters* pAttackOusters = dynamic_cast<Ousters*>(pAttacker);
GCModifyInformation gcAttackerMI;
computeAlignmentChange(pOusters, decreaseHP, pAttackOusters, NULL, &gcAttackerMI);
// 뭔가 변한 정보가 있다면 보내준다.
if (gcAttackerMI.getShortCount()+gcAttackerMI.getLongCount() > 0)
{
pAttackOusters->getPlayer()->sendPacket(&gcAttackerMI);
}
}
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pOusters->getObjectID());
pkt.setCurrentHP(RemainHP);
pZone->broadcastPacket(pOusters->getX(), pOusters->getY(), &pkt);
}
}
else if (pCreature->isMonster())
{
Monster* pMonster = dynamic_cast<Monster*>(pCreature);
HP_t CurrentHP = pMonster->getHP(ATTR_CURRENT);
if (CurrentHP > 0)
{
HP_t RemainHP = max(0, CurrentHP -(int)decreaseHP);
pMonster->setHP(RemainHP, ATTR_CURRENT);
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pMonster->getObjectID());
pkt.setCurrentHP(RemainHP);
pZone->broadcastPacket(pMonster->getX(), pMonster->getY(), &pkt);
if (RemainHP == 0 )
{
Creature* pAttacker = pZone->getCreature(m_UserObjectID);
if (pAttacker != NULL && pAttacker->isVampire() )
{
Vampire* pAttackVampire = dynamic_cast<Vampire*>(pAttacker);
GCModifyInformation gcMI;
increaseAlignment(pAttackVampire, pCreature, gcMI);
if (gcMI.getShortCount() > 0 || gcMI.getLongCount() > 0 )
pAttackVampire->getPlayer()->sendPacket(&gcMI);
}
}
}
}
// m_CasterName이 pCreature를 죽인 경우의 KillCount 처리
// by sigi. 2002.9.9
if (pCreature->isDead())
{
Creature* pAttacker = pZone->getCreature(m_UserObjectID);
if (pAttacker!=NULL)
{
if (pAttacker->isVampire())
{
Vampire* pVampire = dynamic_cast<Vampire*>(pAttacker);
// 죽일때 경험치를 준다.
GCModifyInformation mi;
int exp = computeCreatureExp(pCreature, KILL_EXP);
shareVampExp(pVampire, exp, mi);
if (pCreature->isMonster() )
{
increaseFame(pVampire, decreaseHP);
mi.addLongData(MODIFY_FAME, pVampire->getFame());
}
pAttacker->getPlayer()->sendPacket(&mi);
}
else if (pAttacker->isOusters() )
{
Ousters* pOusters = dynamic_cast<Ousters*>(pAttacker);
GCModifyInformation mi;
int exp = computeCreatureExp(pCreature, 100);
shareOustersExp(pOusters, exp, mi);
if (pCreature->isMonster() )
{
increaseFame(pOusters, decreaseHP);
mi.addLongData(MODIFY_FAME, pOusters->getFame());
}
}
affectKillCount(pAttacker, pCreature);
}
}
}
__END_DEBUG
__END_CATCH
}
void SimpleMissileSkill::execute(
Ousters* pOusters, ObjectID_t TargetObjectID, OustersSkillSlot* pOustersSkillSlot,
const SIMPLE_SKILL_INPUT& param, SIMPLE_SKILL_OUTPUT& result,
CEffectID_t CEffectID, int HitBonus)
throw(Error)
{
__BEGIN_TRY
Assert(pOusters != NULL);
Assert(pOustersSkillSlot != NULL);
try
{
Player* pPlayer = pOusters->getPlayer();
Zone* pZone = pOusters->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
// NPC는 공격할 수가 없다.
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL
|| !canAttack(pOusters, pTargetCreature )
|| pTargetCreature->isNPC()
)
{
executeSkillFailException(pOusters, param.SkillType, param.Grade);
return;
}
result.pTargetCreature = pTargetCreature;
GCSkillToObjectOK1 _GCSkillToObjectOK1;
GCSkillToObjectOK2 _GCSkillToObjectOK2;
GCSkillToObjectOK3 _GCSkillToObjectOK3;
GCSkillToObjectOK4 _GCSkillToObjectOK4;
GCSkillToObjectOK5 _GCSkillToObjectOK5;
GCSkillToObjectOK6 _GCSkillToObjectOK6;
if (param.ItemClass != Item::ITEM_CLASS_MAX)
{
Item* pItem = pOusters->getWearItem(Ousters::WEAR_RIGHTHAND);
if (pItem == NULL || pItem->getItemClass() != param.ItemClass || !pOusters->isRealWearingEx(Ousters::WEAR_RIGHTHAND))
{
executeSkillFailException(pOusters, param.SkillType, param.Grade);
return;
}
}
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(param.SkillType);
bool bCriticalHit = false;
Damage_t Damage = 0;
if (param.bAdd)
{
// 파라미터로 전달된 데미지 값이 더해지는 데미지라면,
// 일반 데미지를 계산 후, 데미지를 더해야 한다.
// 파라미터로 전달된 데미지 값이 직접적으로 쓰이는 데미지라면,
// 이 부분까지 들어오지 않으므로, 밑의 부분까지 0으로 전달된다.
Damage += computeDamage(pOusters, pTargetCreature, 0, bCriticalHit);
}
if (param.bMagicDamage)
{
// 만일 스킬 데미지가 마법 데미지라면, 마법 데미지 계산 함수를 이용해 계산을 해준다.
// Damage += computeMagicDamage(pTargetCreature, param.SkillDamage, param.SkillType, true);
Damage += computeOustersMagicDamage(pOusters, pTargetCreature, param.SkillDamage, param.SkillType);
}
else
{
Damage += param.SkillDamage;
}
computeCriticalBonus(pOusters, param.SkillType, Damage, bCriticalHit);
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pOusters, RequiredMP);
bool bTimeCheck = verifyRunTime(pOustersSkillSlot);
bool bRangeCheck = verifyDistance(pOusters, pTargetCreature, pSkillInfo->getRange());
bool bHitRoll = false;
bool bCanHit = canHit(pOusters, pTargetCreature, param.SkillType);
bool bPK = verifyPK(pOusters, pTargetCreature);
bool bSatisfyRequire = pOusters->satisfySkillRequire(pSkillInfo);
if (param.bMagicHitRoll)
{
bHitRoll = HitRoll::isSuccessMagic(pOusters, pSkillInfo, pOustersSkillSlot, HitBonus);
}
else
{
bHitRoll = HitRoll::isSuccess(pOusters, pTargetCreature);
}
ZoneCoord_t X = pOusters->getX();
ZoneCoord_t Y = pOusters->getY();
ZoneCoord_t targetX = pTargetCreature->getX();
ZoneCoord_t targetY = pTargetCreature->getY();
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bCanHit && bPK && bSatisfyRequire )
{
decreaseMana(pOusters, RequiredMP, _GCSkillToObjectOK1);
bool bCanSeeCaster = canSee(pTargetCreature, pOusters);
if (bCanSeeCaster)
{
setDamage(pTargetCreature, Damage, pOusters, param.SkillType, &_GCSkillToObjectOK2, &_GCSkillToObjectOK1);
computeAlignmentChange(pTargetCreature, Damage, pOusters, &_GCSkillToObjectOK2, &_GCSkillToObjectOK1);
decreaseDurability(pOusters, pTargetCreature, pSkillInfo, &_GCSkillToObjectOK1, &_GCSkillToObjectOK2);
}
else
{
setDamage(pTargetCreature, Damage, pOusters, param.SkillType, &_GCSkillToObjectOK6, &_GCSkillToObjectOK1);
computeAlignmentChange(pTargetCreature, Damage, pOusters, &_GCSkillToObjectOK6, &_GCSkillToObjectOK1);
decreaseDurability(pOusters, pTargetCreature, pSkillInfo, &_GCSkillToObjectOK1, &_GCSkillToObjectOK6);
}
if (pTargetCreature->isDead())
{
int exp = computeCreatureExp(pTargetCreature, 100, pOusters);
shareOustersExp(pOusters, exp, _GCSkillToObjectOK1);
}
increaseAlignment(pOusters, pTargetCreature, _GCSkillToObjectOK1);
_GCSkillToObjectOK1.setSkillType(param.SkillType);
_GCSkillToObjectOK1.setCEffectID(CEffectID);
_GCSkillToObjectOK1.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK1.setDuration(0);
_GCSkillToObjectOK1.setGrade(param.Grade);
_GCSkillToObjectOK2.setObjectID(pOusters->getObjectID());
_GCSkillToObjectOK2.setSkillType(param.SkillType);
_GCSkillToObjectOK2.setDuration(0);
_GCSkillToObjectOK2.setGrade(param.Grade);
_GCSkillToObjectOK3.setObjectID(pOusters->getObjectID());
_GCSkillToObjectOK3.setSkillType(param.SkillType);
_GCSkillToObjectOK3.setTargetXY(targetX, targetY);
_GCSkillToObjectOK3.setGrade(param.Grade);
_GCSkillToObjectOK4.setSkillType(param.SkillType);
_GCSkillToObjectOK4.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK4.setGrade(param.Grade);
_GCSkillToObjectOK5.setObjectID(pOusters->getObjectID());
_GCSkillToObjectOK5.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK5.setSkillType(param.SkillType);
_GCSkillToObjectOK5.setGrade(param.Grade);
_GCSkillToObjectOK6.setXY(X, Y);
_GCSkillToObjectOK6.setSkillType(param.SkillType);
_GCSkillToObjectOK6.setDuration(0);
_GCSkillToObjectOK6.setGrade(param.Grade);
pPlayer->sendPacket(&_GCSkillToObjectOK1);
Player* pTargetPlayer = NULL;
if (pTargetCreature->isPC())
{
pTargetPlayer = pTargetCreature->getPlayer();
Assert(pTargetPlayer != NULL);
if (bCanSeeCaster) pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
else pTargetPlayer->sendPacket(&_GCSkillToObjectOK6);
}
else
{
Monster* pMonster = dynamic_cast<Monster*>(pTargetCreature);
pMonster->addEnemy(pOusters);
}
list<Creature*> cList;
cList.push_back(pOusters);
cList.push_back(pTargetCreature);
cList = pZone->broadcastSkillPacket(X, Y, targetX, targetY, &_GCSkillToObjectOK5, cList);
pZone->broadcastPacket(X, Y, &_GCSkillToObjectOK3 , cList);
pZone->broadcastPacket(targetX, targetY, &_GCSkillToObjectOK4 , cList);
pOustersSkillSlot->setRunTime(param.Delay);
result.bSuccess = true;
}
else
{
executeSkillFailNormal(pOusters, param.SkillType, pTargetCreature, param.Grade);
}
}
catch (Throwable & t)
{
executeSkillFailException(pOusters, param.SkillType, param.Grade);
}
__END_CATCH
}
void SimpleMissileSkill::execute(
Slayer* pSlayer, ObjectID_t TargetObjectID, SkillSlot* pSkillSlot,
const SIMPLE_SKILL_INPUT& param, SIMPLE_SKILL_OUTPUT& result,
CEffectID_t CEffectID)
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);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NPC는 공격할 수가 없다.
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL
|| !canAttack(pSlayer, pTargetCreature )
|| pTargetCreature->isNPC())
{
executeSkillFailException(pSlayer, param.SkillType);
return;
}
result.pTargetCreature = pTargetCreature;
GCSkillToObjectOK1 _GCSkillToObjectOK1;
GCSkillToObjectOK2 _GCSkillToObjectOK2;
GCSkillToObjectOK3 _GCSkillToObjectOK3;
GCSkillToObjectOK4 _GCSkillToObjectOK4;
GCSkillToObjectOK5 _GCSkillToObjectOK5;
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(param.SkillType);
SkillDomainType_t DomainType = pSkillInfo->getDomainType();
SkillLevel_t SkillLevel = pSkillSlot->getExpLevel();
bool bCriticalHit = false;
Damage_t Damage = 0;
if (param.bAdd)
{
// 파라미터로 전달된 데미지 값이 더해지는 데미지라면,
// 일반 데미지를 계산 후, 데미지를 더해야 한다.
// 파라미터로 전달된 데미지 값이 직접적으로 쓰이는 데미지라면,
// 이 부분까지 들어오지 않으므로, 밑의 부분까지 0으로 전달된다.
Damage += computeDamage(pSlayer, pTargetCreature, SkillLevel/5, bCriticalHit);
}
if (param.bMagicDamage)
{
// 만일 스킬 데미지가 마법 데미지라면, 마법 데미지 계산 함수를 이용해 계산을 해준다.
Damage += computeMagicDamage(pTargetCreature, param.SkillDamage, param.SkillType);
}
else
{
Damage += param.SkillDamage;
}
ZoneCoord_t myX = pSlayer->getX();
ZoneCoord_t myY = pSlayer->getY();
ZoneCoord_t targetX = pTargetCreature->getX();
ZoneCoord_t targetY = pTargetCreature->getY();
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pSlayer, pTargetCreature, pSkillInfo->getRange());
bool bHitRoll = false;
bool bPK = verifyPK(pSlayer, pTargetCreature);
if (param.bMagicHitRoll)
{
bHitRoll = HitRoll::isSuccessMagic(pSlayer, pSkillInfo, pSkillSlot);
}
else
{
bHitRoll = HitRoll::isSuccess(pSlayer, pTargetCreature, SkillLevel/2);
}
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bPK)
{
decreaseMana(pSlayer, RequiredMP, _GCSkillToObjectOK1);
// 데미지를 가하고, 내구도를 떨어뜨린다.
setDamage(pTargetCreature, Damage, pSlayer, param.SkillType, &_GCSkillToObjectOK2, &_GCSkillToObjectOK1);
computeAlignmentChange(pTargetCreature, Damage, pSlayer, &_GCSkillToObjectOK2, &_GCSkillToObjectOK1);
decreaseDurability(pSlayer, pTargetCreature, NULL, &_GCSkillToObjectOK1, &_GCSkillToObjectOK2);
// 타겟이 슬레이어가 아닌 경우에만 경험치를 올려준다.
if (!pTargetCreature->isSlayer())
{
shareAttrExp(pSlayer, Damage , param.STRMultiplier, param.DEXMultiplier, param.INTMultiplier, _GCSkillToObjectOK1);
increaseDomainExp(pSlayer, DomainType, pSkillInfo->getPoint(), _GCSkillToObjectOK1, pTargetCreature->getLevel());
increaseSkillExp(pSlayer, DomainType, pSkillSlot, pSkillInfo, _GCSkillToObjectOK1);
increaseAlignment(pSlayer, pTargetCreature, _GCSkillToObjectOK1);
}
_GCSkillToObjectOK1.setSkillType(param.SkillType);
_GCSkillToObjectOK1.setCEffectID(CEffectID);
_GCSkillToObjectOK1.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK1.setDuration(0);
_GCSkillToObjectOK2.setObjectID(pSlayer->getObjectID());
_GCSkillToObjectOK2.setSkillType(param.SkillType);
_GCSkillToObjectOK2.setDuration(0);
_GCSkillToObjectOK3.setObjectID(pSlayer->getObjectID());
_GCSkillToObjectOK3.setSkillType(param.SkillType);
_GCSkillToObjectOK3.setTargetXY(targetX, targetY);
_GCSkillToObjectOK4.setSkillType(param.SkillType);
_GCSkillToObjectOK4.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK5.setObjectID(pSlayer->getObjectID());
_GCSkillToObjectOK5.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK5.setSkillType(param.SkillType);
_GCSkillToObjectOK5.setDuration(0);
// Send Packet
pPlayer->sendPacket(&_GCSkillToObjectOK1);
if (pTargetCreature->isPC())
{
Player* pTargetPlayer = pTargetCreature->getPlayer();
Assert(pTargetPlayer != NULL);
pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
}
else if (pTargetCreature->isMonster())
{
Monster* pMonster = dynamic_cast<Monster*>(pTargetCreature);
pMonster->addEnemy(pSlayer);
}
list<Creature*> cList;
cList.push_back(pSlayer);
cList.push_back(pTargetCreature);
cList = pZone->broadcastSkillPacket(myX, myY, targetX, targetY, &_GCSkillToObjectOK5, cList);
pZone->broadcastPacket(myX, myY, &_GCSkillToObjectOK3 , cList);
pZone->broadcastPacket(targetX, targetY, &_GCSkillToObjectOK4 , cList);
pSkillSlot->setRunTime(param.Delay);
result.bSuccess = true;
}
else
{
executeSkillFailNormal(pSlayer, param.SkillType, pTargetCreature);
}
}
catch (Throwable & t)
{
executeSkillFailException(pSlayer, param.SkillType);
}
__END_CATCH
}
void SimpleMissileSkill::execute(
Vampire* pVampire, ObjectID_t TargetObjectID, VampireSkillSlot* pVampireSkillSlot,
const SIMPLE_SKILL_INPUT& param, SIMPLE_SKILL_OUTPUT& result,
CEffectID_t CEffectID, int HitBonus)
throw(Error)
{
__BEGIN_TRY
Assert(pVampire != NULL);
Assert(pVampireSkillSlot != NULL);
try
{
Player* pPlayer = pVampire->getPlayer();
Zone* pZone = pVampire->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NPC는 공격할 수가 없다.
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL
|| !canAttack(pVampire, pTargetCreature )
|| pTargetCreature->isNPC())
{
executeSkillFailException(pVampire, param.SkillType);
return;
}
result.pTargetCreature = pTargetCreature;
GCSkillToObjectOK1 _GCSkillToObjectOK1;
GCSkillToObjectOK2 _GCSkillToObjectOK2;
GCSkillToObjectOK3 _GCSkillToObjectOK3;
GCSkillToObjectOK4 _GCSkillToObjectOK4;
GCSkillToObjectOK5 _GCSkillToObjectOK5;
GCSkillToObjectOK6 _GCSkillToObjectOK6;
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(param.SkillType);
bool bCriticalHit = false;
Damage_t Damage = 0;
if (param.bAdd)
{
// 파라미터로 전달된 데미지 값이 더해지는 데미지라면,
// 일반 데미지를 계산 후, 데미지를 더해야 한다.
// 파라미터로 전달된 데미지 값이 직접적으로 쓰이는 데미지라면,
// 이 부분까지 들어오지 않으므로, 밑의 부분까지 0으로 전달된다.
Damage += computeDamage(pVampire, pTargetCreature, 0, bCriticalHit);
}
if (param.bMagicDamage)
{
// 만일 스킬 데미지가 마법 데미지라면, 마법 데미지 계산 함수를 이용해 계산을 해준다.
Damage += computeMagicDamage(pTargetCreature, param.SkillDamage, param.SkillType, true, pVampire);
}
else
{
Damage += param.SkillDamage;
}
int RequiredMP = decreaseConsumeMP(pVampire, pSkillInfo);
bool bManaCheck = hasEnoughMana(pVampire, RequiredMP);
bool bTimeCheck = verifyRunTime(pVampireSkillSlot);
bool bRangeCheck = verifyDistance(pVampire, pTargetCreature, pSkillInfo->getRange());
bool bHitRoll = false;
bool bCanHit = canHit(pVampire, pTargetCreature, param.SkillType);
bool bPK = verifyPK(pVampire, pTargetCreature);
if (param.bMagicHitRoll)
{
bHitRoll = HitRoll::isSuccessMagic(pVampire, pSkillInfo, pVampireSkillSlot, HitBonus);
}
else
{
bHitRoll = HitRoll::isSuccess(pVampire, pTargetCreature);
}
ZoneCoord_t vampX = pVampire->getX();
ZoneCoord_t vampY = pVampire->getY();
ZoneCoord_t targetX = pTargetCreature->getX();
ZoneCoord_t targetY = pTargetCreature->getY();
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bCanHit && bPK)
{
decreaseMana(pVampire, RequiredMP, _GCSkillToObjectOK1);
bool bCanSeeCaster = canSee(pTargetCreature, pVampire);
// 데미지를 가하고, 아이템 내구도를 떨어뜨린다.
if (bCanSeeCaster)
{
setDamage(pTargetCreature, Damage, pVampire, param.SkillType, &_GCSkillToObjectOK2, &_GCSkillToObjectOK1);
computeAlignmentChange(pTargetCreature, Damage, pVampire, &_GCSkillToObjectOK2, &_GCSkillToObjectOK1);
decreaseDurability(pVampire, pTargetCreature, pSkillInfo, &_GCSkillToObjectOK1, &_GCSkillToObjectOK2);
}
else
{
setDamage(pTargetCreature, Damage, pVampire, param.SkillType, &_GCSkillToObjectOK6, &_GCSkillToObjectOK1);
computeAlignmentChange(pTargetCreature, Damage, pVampire, &_GCSkillToObjectOK6, &_GCSkillToObjectOK1);
decreaseDurability(pVampire, pTargetCreature, pSkillInfo, &_GCSkillToObjectOK1, &_GCSkillToObjectOK6);
}
// 상대가 죽었다면 경험치를 좀 올려준다.
if (pTargetCreature->isDead())
{
int exp = computeCreatureExp(pTargetCreature, KILL_EXP);
shareVampExp(pVampire, exp, _GCSkillToObjectOK1);
}
increaseAlignment(pVampire, pTargetCreature, _GCSkillToObjectOK1);
_GCSkillToObjectOK1.setSkillType(param.SkillType);
_GCSkillToObjectOK1.setCEffectID(CEffectID);
_GCSkillToObjectOK1.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK1.setDuration(0);
_GCSkillToObjectOK2.setObjectID(pVampire->getObjectID());
_GCSkillToObjectOK2.setSkillType(param.SkillType);
_GCSkillToObjectOK2.setDuration(0);
_GCSkillToObjectOK3.setObjectID(pVampire->getObjectID());
_GCSkillToObjectOK3.setSkillType(param.SkillType);
_GCSkillToObjectOK3.setTargetXY(targetX, targetY);
_GCSkillToObjectOK4.setSkillType(param.SkillType);
_GCSkillToObjectOK4.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK5.setObjectID(pVampire->getObjectID());
_GCSkillToObjectOK5.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK5.setSkillType(param.SkillType);
_GCSkillToObjectOK6.setXY(vampX, vampY);
_GCSkillToObjectOK6.setSkillType(param.SkillType);
_GCSkillToObjectOK6.setDuration(0);
pPlayer->sendPacket(&_GCSkillToObjectOK1);
Player* pTargetPlayer = NULL;
if (pTargetCreature->isPC())
{
pTargetPlayer = pTargetCreature->getPlayer();
Assert(pTargetPlayer != NULL);
if (bCanSeeCaster) pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
else pTargetPlayer->sendPacket(&_GCSkillToObjectOK6);
}
else
{
Monster* pMonster = dynamic_cast<Monster*>(pTargetCreature);
pMonster->addEnemy(pVampire);
}
list<Creature*> cList;
cList.push_back(pVampire);
cList.push_back(pTargetCreature);
cList = pZone->broadcastSkillPacket(vampX, vampY, targetX, targetY, &_GCSkillToObjectOK5, cList);
pZone->broadcastPacket(vampX, vampY, &_GCSkillToObjectOK3 , cList);
pZone->broadcastPacket(targetX, targetY, &_GCSkillToObjectOK4 , cList);
pVampireSkillSlot->setRunTime(param.Delay);
result.bSuccess = true;
}
else
{
executeSkillFailNormal(pVampire, param.SkillType, pTargetCreature);
}
}
catch (Throwable & t)
{
executeSkillFailException(pVampire, param.SkillType);
}
__END_CATCH
}
void CGTradeAddItemHandler::execute (CGTradeAddItem* pPacket , Player* pPlayer)
throw(ProtocolException , Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
Assert(pPacket != NULL);
Assert(pPlayer != NULL);
ObjectID_t TargetOID = pPacket->getTargetObjectID();
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Creature* pPC = pGamePlayer->getCreature();
Assert(pPC != NULL);
Zone* pZone = pPC->getZone();
Assert(pZone != NULL);
TradeManager* pTradeManager = pZone->getTradeManager();
Assert(pTradeManager != NULL);
// 교환을 원하는 상대방을 존에서 찾아본다.
Creature* pTargetPC = NULL;
/*
try
{
pTargetPC = pZone->getCreature(TargetOID);
}
catch (NoSuchElementException)
{
pTargetPC = NULL;
}
*/
// NoSuch제거. by sigi. 2002.5.2
pTargetPC = pZone->getCreature(TargetOID);
// 교환 상대가 없다면 에러다.
if (pTargetPC == NULL)
{
pTradeManager->cancelTrade(pPC);
executeError(pPacket, pPlayer, GC_TRADE_ERROR_CODE_TARGET_NOT_EXIST);
return;
}
// 교환 상대가 사람이 아니거나, 같은 종족이 아니라면 에러다.
if (!pTargetPC->isPC() || !isSameRace(pTargetPC, pPC))
{
pTradeManager->cancelTrade(pPC);
executeError(pPacket, pPlayer, GC_TRADE_ERROR_CODE_RACE_DIFFER);
return;
}
// 둘 다 안전 지대에 있는지 체크를 한다.
if (!isInSafeZone(pPC) || !isInSafeZone(pTargetPC))
{
pTradeManager->cancelTrade(pPC);
executeError(pPacket, pPlayer, GC_TRADE_ERROR_CODE_NOT_SAFE);
return;
}
// 오토바이를 타고 있다면 에러다.
if (pPC->isSlayer() && pTargetPC->isSlayer())
{
Slayer* pSlayer1 = dynamic_cast<Slayer*>(pPC);
Slayer* pSlayer2 = dynamic_cast<Slayer*>(pTargetPC);
if (pSlayer1->hasRideMotorcycle() || pSlayer2->hasRideMotorcycle())
{
pTradeManager->cancelTrade(pPC);
executeError(pPacket, pPlayer, GC_TRADE_ERROR_CODE_MOTORCYCLE);
return;
}
}
if (pPC->isOusters() && pTargetPC->isOusters())
{
Ousters* pOusters1 = dynamic_cast<Ousters*>(pPC);
Ousters* pOusters2 = dynamic_cast<Ousters*>(pTargetPC);
if (pOusters1->isFlag(Effect::EFFECT_CLASS_SUMMON_SYLPH)
|| pOusters2->isFlag(Effect::EFFECT_CLASS_SUMMON_SYLPH) )
{
pTradeManager->cancelTrade(pPC);
executeError(pPacket, pPlayer, GC_TRADE_ERROR_CODE_MOTORCYCLE);
return;
}
}
// 둘이서 교환을 하고 있는 상태가 아니라면 에러다.
if (!pTradeManager->isTrading(pPC, pTargetPC))
{
pTradeManager->cancelTrade(pPC);
executeError(pPacket, pPlayer, GC_TRADE_ERROR_CODE_NOT_TRADING);
return;
}
if (pPC->isSlayer()) executeSlayer(pPacket, pPlayer);
else if (pPC->isVampire()) executeVampire(pPacket, pPlayer);
else if (pPC->isOusters()) executeOusters(pPacket, pPlayer);
else throw ProtocolException("CGTradeAddItemHandler::execute() : 알 수 없는 플레이어 크리쳐");
#endif
__END_DEBUG_EX __END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void Transfusion::execute(Vampire* pVampire, ObjectID_t TargetObjectID, VampireSkillSlot* pVampireSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << "begin " << endl;
Assert(pVampire != NULL);
Assert(pVampireSkillSlot != NULL);
//cout << "Transfusion" << endl;
try
{
Zone* pZone = pVampire->getZone();
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NPC는 공격할 수가 없다.
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL
|| pTargetCreature->isNPC()
// HIDE 인 놈은 되살려내면 이상하게 된다. 일단 막아놓음.
// 2003. 1. 17. DEW
|| pTargetCreature->isFlag(Effect::EFFECT_CLASS_HIDE)
|| (g_pConfig->hasKey("Hardcore") && g_pConfig->getPropertyInt("Hardcore")!=0 && pTargetCreature->isDead() ) )
{
executeSkillFailException(pVampire, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
return;
}
ZoneCoord_t X = pTargetCreature->getX();
ZoneCoord_t Y = pTargetCreature->getY();
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = pVampireSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
// 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();
}
// 15%를 사용
int CurrentHP = pVampire->getHP(ATTR_CURRENT);
#ifdef __CHINA_SERVER__
int RequiredMP = CurrentHP*15/100; //decreaseConsumeMP(pVampire, pSkillInfo);
int RecoverHP = CurrentHP*17/100;
#else
int RequiredMP = CurrentHP*12/100; //decreaseConsumeMP(pVampire, pSkillInfo);
int RecoverHP = CurrentHP*12/100;
#endif
//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 bHPCheck = false;
Range_t Range = 1;
// 상대방의 HP가 Full이 아니고
// 자신의 HP가 30이상
if (pVampire->getHP(ATTR_CURRENT) >= 30)
{
if (pTargetCreature->isVampire())
{
Vampire* pTargetVampire = dynamic_cast<Vampire*>(pTargetCreature);
// 현재HP+SilverDamage < MaxHP 여야 한다.
if (pTargetVampire->getHP(ATTR_CURRENT) + pTargetVampire->getSilverDamage()
< pTargetVampire->getHP(ATTR_MAX))
bHPCheck = true;
}
/*
// 아직 이건 필요없다.
else if (pTargetCreature->isMonster())
{
Monster* pMonster = dynamic_cast<Monster*>(pTargetCreature);
if (pMonster->getHP(ATTR_MAX) < pMonster->getHP(ATTR_MAX_HP))
bHPCHeck = true;
}
*/
}
if (bTimeCheck && bRangeCheck && bHitRoll && bHPCheck)
{
//cout << "Transfusion Success" << endl;
decreaseMana(pVampire, RequiredMP, _GCSkillToTileOK1);
// 데미지와 지속 시간을 계산한다.
SkillInput input(pVampire);
SkillOutput output;
computeOutput(input, output);
// TargetCreature의 HP를 채운다
if (pTargetCreature->isVampire())
{
Vampire* pTargetVampire = dynamic_cast<Vampire*>(pTargetCreature);
HP_t maxHP = pTargetVampire->getHP(ATTR_MAX);
HP_t currentHP = pTargetVampire->getHP(ATTR_CURRENT);
HP_t newHP = min((int)maxHP, currentHP + RecoverHP);
pTargetVampire->setHP(newHP);
// HP가 30%가 되면(33% -_-;) 살아나게 된다.
if (pTargetCreature->isFlag(Effect::EFFECT_CLASS_COMA))
{
//cout << "Target has EFFECT_COMA" << endl;
if (newHP*3 >= maxHP)
{
//cout << "Target HP is over 1/3" << endl;
EffectComa* pEffectComa = (EffectComa*)(pTargetCreature->findEffect(Effect::EFFECT_CLASS_COMA));
Assert(pEffectComa != NULL);
if (pEffectComa->canResurrect())
{
//cout << "Can Resurrect!" << endl;
// 타겟의 이펙트 매니저에서 코마 이펙트를 삭제한다.
pTargetCreature->deleteEffect(Effect::EFFECT_CLASS_COMA);
pTargetCreature->removeFlag(Effect::EFFECT_CLASS_COMA);
// 코마 이펙트가 날아갔다고 알려준다.
GCRemoveEffect gcRemoveEffect;
gcRemoveEffect.setObjectID(pTargetCreature->getObjectID());
gcRemoveEffect.addEffectList((EffectID_t)Effect::EFFECT_CLASS_COMA);
pZone->broadcastPacket(pTargetCreature->getX(), pTargetCreature->getY(), &gcRemoveEffect);
// 이펙트 정보를 다시 보내준다. by sigi. 2002.11.14
pTargetCreature->getEffectManager()->sendEffectInfo(pTargetCreature, pZone, pTargetCreature->getX(), pTargetCreature->getY());
// EffectKillAftermath 를 붙인다.
if (pTargetCreature->isFlag(Effect::EFFECT_CLASS_KILL_AFTERMATH))
{
Effect *pEffect = pTargetCreature->findEffect(Effect::EFFECT_CLASS_KILL_AFTERMATH);
EffectKillAftermath* pEffectKillAftermath = dynamic_cast<EffectKillAftermath*>(pEffect);
pEffectKillAftermath->setDeadline(5*600);
}
else
{
EffectKillAftermath* pEffectKillAftermath = new EffectKillAftermath(pTargetCreature);
pEffectKillAftermath->setDeadline(5*600);
pTargetCreature->addEffect(pEffectKillAftermath);
pTargetCreature->setFlag(Effect::EFFECT_CLASS_KILL_AFTERMATH);
pEffectKillAftermath->create(pTargetCreature->getName());
}
}
}
}
// 주위에 체력이 채워졌다는 사실을 알린다.
GCStatusCurrentHP gcStatusCurrentHP;
gcStatusCurrentHP.setObjectID(pTargetVampire->getObjectID());
gcStatusCurrentHP.setCurrentHP(pTargetVampire->getHP(ATTR_CURRENT));
pZone->broadcastPacket(X, Y, &gcStatusCurrentHP);
// 자신의 에너지가 줄어든것도 보여주자
gcStatusCurrentHP.setObjectID(pVampire->getObjectID());
gcStatusCurrentHP.setCurrentHP(pVampire->getHP(ATTR_CURRENT));
pZone->broadcastPacket(pVampire->getX(), pVampire->getY(), &gcStatusCurrentHP);
}
ZoneCoord_t myX = pVampire->getX();
ZoneCoord_t myY = pVampire->getY();
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setDuration(output.Duration);
_GCSkillToTileOK1.setRange(Range);
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setObjectID(pVampire->getObjectID());
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setDuration(output.Duration);
_GCSkillToTileOK2.setRange(Range);
_GCSkillToTileOK3.setObjectID(pVampire->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK4.setRange(Range);
_GCSkillToTileOK5.setObjectID(pVampire->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK5.setRange(Range);
Player* pPlayer = pVampire->getPlayer();
Assert(pPlayer != NULL);
pPlayer->sendPacket(&_GCSkillToTileOK1);
list<Creature*> cList;
cList.push_back(pVampire);
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
pVampireSkillSlot->setRunTime(output.Delay);
}
else
{
//cout << "Transfusion Failed" << endl;
executeSkillFailNormal(pVampire, getSkillType(), NULL);
}
}
catch (Throwable & t)
{
//cout << "Transfusion Failed2" << endl;
executeSkillFailException(pVampire, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
void CGTradeMoneyHandler::executeOusters (CGTradeMoney* pPacket , Player* pPlayer)
throw(ProtocolException , Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
// 상위 함수에서 검사를 했기 때문에,
// 여기서는 포인터가 널인지를 검사하지 않는다.
ObjectID_t TargetOID = pPacket->getTargetObjectID();
Gold_t Amount = pPacket->getAmount();
BYTE Code = pPacket->getCode();
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Creature* pPC = pGamePlayer->getCreature();
Zone* pZone = pPC->getZone();
Creature* pTargetPC = pZone->getCreature(TargetOID);
// NoSuch제거. by sigi. 2002.5.2
if (pTargetPC==NULL) return;
Ousters* pSender = dynamic_cast<Ousters*>(pPC);
Ousters* pReceiver = dynamic_cast<Ousters*>(pTargetPC);
Player* pTargetPlayer = pTargetPC->getPlayer();
Gold_t finalAmount = Amount;
Gold_t margin = 0;
GCTradeMoney gcTradeMoney;
GCTradeVerify gcTradeVerify;
TradeManager* pTradeManager = pZone->getTradeManager();
Assert(pTradeManager != NULL);
// 교환 상태가 맞는지 체크를 해봐야한다.
TradeInfo* pInfo1 = pTradeManager->getTradeInfo(pSender->getName());
TradeInfo* pInfo2 = pTradeManager->getTradeInfo(pReceiver->getName());
// 인벤토리에서 돈을 덜어, 교환창에다 더한다.
if (Code == CG_TRADE_MONEY_INCREASE)
{
// 교환창에다 더할 액수보다 많은 돈을 가지고 있어야 한다.
if (pSender->getGold() >= Amount)
{
// 돈을 받는 쪽이 맥스를 초과하게 된다면, 일부만 넣어줘야 한다.
// 현재 교환 예정인 돈도 더해서 계산. by sigi. 2003.1.8
Gold_t receiverGold = pReceiver->getGold() + pInfo1->getGold();
if (receiverGold + Amount > MAX_MONEY)
{
margin = receiverGold + Amount - MAX_MONEY;
finalAmount = finalAmount - margin;
}
// 인벤토리에서 돈을 빼고, 교환창에다 더한다.
pSender->setGold(pSender->getGold() - finalAmount);
pInfo1->setGold(pInfo1->getGold() + finalAmount);
// 현재 OK를 누른 상태라면, 클라이언트에게 인증 패킷을 보내줘야 한다.
if (pInfo1->getStatus() == TRADE_FINISH)
{
// 인증 패킷을 날려준다.
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_MONEY_INCREASE);
pPlayer->sendPacket(&gcTradeVerify);
}
// 아이템을 더하거나 뺄 경우, 상태를 변환해줘야 한다.
pInfo1->setStatus(TRADE_TRADING);
pInfo2->setStatus(TRADE_TRADING);
// 돈을 올린 당사자에게 실제로 인벤토리에서
// 빠진 금액이 얼마인지 보내준다.
gcTradeMoney.setTargetObjectID(TargetOID);
gcTradeMoney.setCode(GC_TRADE_MONEY_INCREASE_RESULT);
gcTradeMoney.setAmount(finalAmount);
pPlayer->sendPacket(&gcTradeMoney);
// 상대방에게 바뀐 정보를 보내준다.
gcTradeMoney.setTargetObjectID(pSender->getObjectID());
gcTradeMoney.setCode(GC_TRADE_MONEY_INCREASE);
gcTradeMoney.setAmount(finalAmount);
pTargetPlayer->sendPacket(&gcTradeMoney);
}
else
{
pTradeManager->cancelTrade(pPC);
executeError(pPacket, pPlayer, GC_TRADE_ERROR_CODE_INCREASE_MONEY);
return;
}
}
// 교환창에서 돈을 덜어, 인벤토리에다가 더한다.
else if (Code == CG_TRADE_MONEY_DECREASE)
{
// 인벤토리에다 더할 액수보다 교환창에 있는 돈이 많아야 한다.
if (pInfo1->getGold() >= Amount)
{
// 돈이 맥스를 초과하게 된다면, 일부만 뺄 수 있다.
Gold_t senderGold = pSender->getGold() + pInfo2->getGold();
if (senderGold + Amount > MAX_MONEY)
{
margin = senderGold + Amount - MAX_MONEY;
finalAmount = finalAmount - margin;
}
// 인벤토리에다가 돈을 더하고, 교환창에서 돈을 뺀다.
pSender->setGold(pSender->getGold() + finalAmount);
pInfo1->setGold(pInfo1->getGold() - finalAmount);
// 현재 OK를 누른 상태라면, 클라이언트에게 인증 패킷을 보내줘야 한다.
if (pInfo1->getStatus() == TRADE_FINISH)
{
// 인증 패킷을 날려준다.
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_MONEY_DECREASE);
pPlayer->sendPacket(&gcTradeVerify);
}
// 아이템을 더하거나 뺄 경우, 상태를 변환해줘야 한다.
pInfo1->setStatus(TRADE_TRADING);
pInfo2->setStatus(TRADE_TRADING);
// 돈을 올린 당사자에게 실제로 인벤토리에다
// 더한 금액이 얼마인지 보내준다.
gcTradeMoney.setTargetObjectID(TargetOID);
gcTradeMoney.setCode(GC_TRADE_MONEY_DECREASE_RESULT);
gcTradeMoney.setAmount(finalAmount);
pPlayer->sendPacket(&gcTradeMoney);
// 상대방에게 바뀐 정보를 보내준다.
gcTradeMoney.setTargetObjectID(pSender->getObjectID());
gcTradeMoney.setCode(GC_TRADE_MONEY_DECREASE);
gcTradeMoney.setAmount(finalAmount);
pTargetPlayer->sendPacket(&gcTradeMoney);
}
else
{
pTradeManager->cancelTrade(pPC);
executeError(pPacket, pPlayer, GC_TRADE_ERROR_CODE_DECREASE_MONEY);
return;
}
}
#endif
__END_DEBUG_EX __END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
//
// 일반 아이템을 처리한다.
//
//////////////////////////////////////////////////////////////////////////////
void CGShopRequestSellHandler::executeNormal (CGShopRequestSell* pPacket , Player* pPlayer)
throw(ProtocolException , Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
ObjectID_t NPCID = pPacket->getObjectID();
ObjectID_t ITEMOID = pPacket->getItemObjectID();
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Creature* pCreature = pGamePlayer->getCreature();
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pCreature);
BYTE index = 0;
bool bSpecialItem = false;
Zone* pZone = pPC->getZone();
if (pZone == NULL) return sendFailPacket(pPacket, pPlayer);
Creature* pNPCBase = NULL;
/*
try
{
pNPCBase = pZone->getCreature(NPCID);
}
catch (NoSuchElementException & nsee)
{
pNPCBase = NULL;
}
*/
// NoSuch제거. by sigi. 2002.5.2
pNPCBase = pZone->getCreature(NPCID);
if (pNPCBase == NULL || !pNPCBase->isNPC()) return sendFailPacket(pPacket, pPlayer);
NPC* pNPC = dynamic_cast<NPC*>(pNPCBase);
// 플레이어가 팔려고 하는 아이템을 가지고 있는지 검사
Inventory* pInventory = pPC->getInventory();
//Gold_t playerMoney = pPC->getGold();
Item* pItem = pInventory->getItemWithObjectID(ITEMOID);
ItemNum_t itemNumber = pItem->getNum();
Price_t itemPrice = g_pPriceManager->getPrice(pItem, pNPC->getMarketCondBuy(), SHOP_RACK_NORMAL, pPC) * itemNumber;
// 플레이어의 인벤토리에 아이템을 제거한다.
pInventory->deleteItem(ITEMOID);
pItem->whenPCLost(pPC);
if (!pItem->destroy()) {
filelog("shopDBBug.txt", "NoSuchItemInDB-destroy: %s", pItem->toString().c_str());
throw DisconnectException("아이템 지울려는데 DB에 없다.");
}
// 만약 벨트라면 안에 있는 포션을 삭제해준다.
// DB에서 지우는 것은 Belt::destroy()를 부르는 것만으로 포션까지 삭제된다.
if (pItem->getItemClass() == Item::ITEM_CLASS_BELT) {
Inventory* pBeltInventory = dynamic_cast<Belt*>(pItem)->getInventory();
for (int y=0; y<pBeltInventory->getHeight(); y++) {
for (int x=0; x<pBeltInventory->getWidth(); x++) {
Item* pBeltItem = pBeltInventory->getItem(x, y);
if (pBeltItem != NULL) {
pBeltInventory->deleteItem(x, y);
SAFE_DELETE(pBeltItem);
}
}
}
}
// Skull 일 경우 Variable Manager 에서 머리값 배수 값으로 가격을 새로 계산한다
if (pItem->getItemClass() == Item::ITEM_CLASS_SKULL)
itemPrice = itemPrice * (g_pVariableManager->getHeadPriceBonus() / 100);
// ItemTrace Log 를 남겨야 한다면 남긴다
if (pItem != NULL && pItem->isTraceItem() )
remainTraceLog(pItem, pCreature->getName() , pNPC->getName(), ITEM_LOG_DELETE, DETAIL_SHOPSELL);
// 플레이어에게 물건값을 지불한다.
// pPC->setGoldEx(playerMoney+itemPrice);
// by sigi. 2002.9.4
pPC->increaseGoldEx(itemPrice);
// 플레이어가 물건 팔 때 처리할 것들을 처리한다.
pPC->sellItem(pItem);
if (pItem->getItemClass() == Item::ITEM_CLASS_MOON_CARD && pItem->getItemType() == 4)
addOlympicStat(pPC, 4, (uint)(itemNumber));
bool bClearDefaultOptionTypes = false;
if (pItem->getItemClass() == Item::ITEM_CLASS_EVENT_ITEM && pItem->getItemType() >= 32 && pItem->getItemType() <= 36)
bClearDefaultOptionTypes = true;
// NPC에게 자리가 충분하다면 플레이어가 판 아이템을 보관한다.
// 운영자 명령어로 만든 아이템은 바로 없앤다.
// 단 스페셜 아이템만을 보관한다. 노말 아이템은 그냥 버림.
// 퀘스트 아이템은 보관하지 않고 버린다.
if (pNPC->getShopType()==SHOPTYPE_NORMAL &&
pItem->getCreateType()!=Item::CREATE_TYPE_CREATE &&
!pItem->getOptionTypeList().empty() &&
!pItem->isTimeLimitItem()) {
bSpecialItem = true;
index = pNPC->getFirstEmptySlot(SHOP_RACK_SPECIAL);
if (index < SHOP_RACK_INDEX_MAX) {
// 아이템을 추가한다.
pNPC->insertShopItem(SHOP_RACK_SPECIAL, index, pItem);
// 스페셜 아이템을 NPC가 진열장에 추가했으므로, 상점 버전이 올라간다.
pNPC->increaseShopVersion(SHOP_RACK_SPECIAL);
////////////////////////////////////////////////////////////////////////////
// 근처의 플레이어들에게는 GCShopBought를...
////////////////////////////////////////////////////////////////////////////
int CenterX = pNPC->getX();
int CenterY = pNPC->getY();
Creature* pNearCreature = NULL;
Player* pNearPlayer = NULL;
GCShopBought boughtpkt;
boughtpkt.setObjectID(NPCID);
if (!pItem->getOptionTypeList().empty()) {
boughtpkt.setShopVersion(pNPC->getShopVersion(SHOP_RACK_SPECIAL));
boughtpkt.setShopType(SHOP_RACK_SPECIAL);
} else {
boughtpkt.setShopVersion(pNPC->getShopVersion(SHOP_RACK_NORMAL));
boughtpkt.setShopType(SHOP_RACK_NORMAL);
}
boughtpkt.setShopIndex(index);
boughtpkt.setItemObjectID(ITEMOID);
boughtpkt.setItemClass(pItem->getItemClass());
boughtpkt.setItemType(pItem->getItemType());
boughtpkt.setOptionType(pItem->getOptionTypeList());
boughtpkt.setDurability(pItem->getDurability());
boughtpkt.setSilver(pItem->getSilver());
boughtpkt.setGrade(pItem->getGrade());
boughtpkt.setEnchantLevel(pItem->getEnchantLevel());
//pZone->broadcastPacket(pNPC->getX(), pNPC->getY(), &boughtpkt, pPC);
try
{
for (int zx=CenterX-5; zx<=CenterX+5; zx++)
{
for (int zy=CenterY-5; zy<=CenterY+5; zy++)
{
// 바운드를 넘어가지 않는가를 체크
if (!isValidZoneCoord(pZone, zx, zy)) continue;
Tile & tile = pZone->getTile(zx, zy);
// 걸어다니는 크리쳐를 검색
if (tile.hasCreature(Creature::MOVE_MODE_WALKING))
{
pNearCreature = tile.getCreature(Creature::MOVE_MODE_WALKING);
if (pNearCreature == NULL) continue;
// 방금 물건을 판 플레이어라면 생략
if (pNearCreature->getObjectID() == pPC->getObjectID()) continue;
// 만약 플레이어라면 패킷을 보내준다.
if (pNearCreature->isPC())
{
pNearPlayer = pNearCreature->getPlayer();
if (pNearPlayer == NULL) continue;
pNearPlayer->sendPacket(&boughtpkt);
}
}
// 날아다니는 크리쳐를 검색
if (tile.hasCreature(Creature::MOVE_MODE_FLYING))
{
pNearCreature = tile.getCreature(Creature::MOVE_MODE_FLYING);
if (pNearCreature == NULL) continue;
// 방금 물건을 판 플레이어라면 생략
if (pNearCreature->getObjectID() == pPC->getObjectID()) continue;
// 만약 플레이어라면 패킷을 보내준다.
if (pNearCreature->isPC())
{
pNearPlayer = pNearCreature->getPlayer();
if (pNearPlayer == NULL) continue;
pNearPlayer->sendPacket(&boughtpkt);
}
}
} // end of for (ZoneCoord_t zy=CenterY-5; zy<=CenterY+5; zy++)
} // end of for (ZoneCoord_t zx=CenterX-5; zx<=CenterX+5; zx++)
}
catch (Throwable & t)
{
filelog("shopbug_packet.log", "%s", t.toString().c_str());
}
} // if (index < SHOP_RACK_INDEX_MAX)
else
{
SAFE_DELETE(pItem);
}
} // if (pItem->getOptionType() != 0)
else
{
bSpecialItem = false;
SAFE_DELETE(pItem);
}
// 물건을 산 플레이어에게 GCShopSellOK를...보낸다.
GCShopSellOK okpkt;
okpkt.setObjectID(NPCID);
if (bSpecialItem) okpkt.setShopVersion(pNPC->getShopVersion(SHOP_RACK_SPECIAL));
else okpkt.setShopVersion(pNPC->getShopVersion(SHOP_RACK_NORMAL));
okpkt.setItemObjectID(ITEMOID);
//okpkt.setPrice(playerMoney+itemPrice);
// playerMoney + itemPrice 가 MAX_MONEY를 넘어갈 수 있다.
// 2003.1.8 by bezz
okpkt.setPrice(pPC->getGold());
pPlayer->sendPacket(&okpkt);
if (bClearDefaultOptionTypes )
{
pPC->clearDefaultOptionTypes();
pPC->initAllStatAndSend();
if (pPC->isSlayer() )
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pPC);
Assert(pSlayer != NULL);
pSlayer->sendRealWearingInfo();
}
else if (pPC->isVampire() )
{
Vampire* pVampire = dynamic_cast<Vampire*>(pPC);
Assert(pVampire != NULL);
pVampire->sendRealWearingInfo();
}
else if (pPC->isOusters() )
{
Ousters* pOusters = dynamic_cast<Ousters*>(pPC);
Assert(pOusters != NULL);
pOusters->sendRealWearingInfo();
}
}
#endif
__END_DEBUG_EX __END_CATCH
}
void EffectPlasmaRocketLauncher::affect(Creature* pCreature)
throw(Error)
{
__BEGIN_TRY
__BEGIN_DEBUG
Assert(pCreature != NULL);
Zone* pZone = pCreature->getZone();
Assert(pZone != NULL);
Creature* pAttacker = pZone->getCreature(m_UserObjectID);
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
int cX = pCreature->getX();
int cY = pCreature->getY();
for(int x = -1; x <= 1; x++)
{
for(int y= -1; y <= 1; y++)
{
int X = cX + x;
int Y = cY + y;
if(!rect.ptInRect(X, Y)) continue;
Tile& tile = pZone->getTile(X, Y);
const list<Object*>& oList = tile.getObjectList();
list<Object*>::const_iterator itr = oList.begin();
for(; itr != oList.end(); itr++)
{
Assert(*itr != NULL);
Object* pObject = *itr;
Assert(pObject != NULL);
if(pObject->getObjectClass() == Object::OBJECT_CLASS_CREATURE)
{
Creature* pCreature2 = dynamic_cast<Creature*>(pObject);
Assert(pCreature2 != NULL);
if (pCreature2 != pCreature && pCreature2->isSlayer() ) continue;
if (!(pZone->getZoneLevel() & COMPLETE_SAFE_ZONE)
&& !pCreature2->isDead()
&& !pCreature2->isFlag(Effect::EFFECT_CLASS_COMA)
// 무적상태 체크. by sigi. 2002.9.5
&& canAttack(pAttacker, pCreature2 )
)
{
GCModifyInformation gcMI, gcAttackerMI;
setDamage(pCreature2, m_Point, pAttacker, SKILL_PLASMA_ROCKET_LAUNCHER, &gcMI, &gcAttackerMI);
if (pCreature2->isPC() ) pCreature2->getPlayer()->sendPacket(&gcMI);
if (pAttacker!=NULL)
{
computeAlignmentChange(pCreature2, m_Point, pAttacker, &gcMI, &gcAttackerMI);
if (pAttacker->isPC() )
{
if (pAttacker->isSlayer() && !pCreature2->isSlayer() )
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pAttacker);
if (pSlayer != NULL )
{
GCModifyInformation gcMI;
shareAttrExp(pSlayer, m_Point, 1, 8, 1, gcAttackerMI);
}
}
if (pAttacker->isPC() ) pAttacker->getPlayer()->sendPacket(&gcAttackerMI);
}
}
}
}
}
}
}
setDeadline(0);
__END_DEBUG
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 슬레이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void RemoveCurse::execute(Slayer* pSlayer, ObjectID_t TargetObjectID, 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);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// 슬레이어 외에는 치료할 수 없다.
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL
|| pTargetCreature->isSlayer() == false)
{
executeSkillFailException(pSlayer, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
GCSkillToObjectOK1 _GCSkillToObjectOK1;
GCSkillToObjectOK2 _GCSkillToObjectOK2;
GCSkillToObjectOK3 _GCSkillToObjectOK3;
GCSkillToObjectOK4 _GCSkillToObjectOK4;
GCSkillToObjectOK5 _GCSkillToObjectOK5;
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
SkillDomainType_t DomainType = pSkillInfo->getDomainType();
// by sigi. 2002.12.3
SkillLevel_t SkillLevel = pSlayer->getINT()/2; //pSkillSlot->getExpLevel();
bool bDoom = false;
bool bParalyze = false;
bool bSeduction = false;
// by sigi. 2002.12.3
//bool bHallucination = false;
bool bDeath = false;
bool bEffected = false; // 아무 저주나 걸려 있으면 켠다.
EffectDoom* pEffectDoom = NULL;
EffectParalyze* pEffectParalyze = NULL;
EffectSeduction* pEffectSeduction = NULL;
// by sigi. 2002.12.3
//EffectHallucination* pEffectHallucination = NULL;
EffectDeath* pEffectDeath = NULL;
if (pTargetCreature->isEffect(Effect::EFFECT_CLASS_DOOM))
{
pEffectDoom = (EffectDoom*)pTargetCreature->findEffect(Effect::EFFECT_CLASS_DOOM);
Assert(pEffectDoom != NULL);
bDoom = HitRoll::isSuccessRemoveCurse(45, SkillLevel, 20, pEffectDoom->getLevel()/4);
bEffected = true;
}
if (pTargetCreature->isEffect(Effect::EFFECT_CLASS_PARALYZE))
{
pEffectParalyze = (EffectParalyze*)pTargetCreature->findEffect(Effect::EFFECT_CLASS_PARALYZE);
Assert(pEffectParalyze != NULL);
bParalyze = HitRoll::isSuccessRemoveCurse(45, SkillLevel, 10, pEffectParalyze->getLevel()/4);
bEffected = true;
}
if (pTargetCreature->isEffect(Effect::EFFECT_CLASS_SEDUCTION))
{
pEffectSeduction = (EffectSeduction*)pTargetCreature->findEffect(Effect::EFFECT_CLASS_SEDUCTION);
Assert(pEffectSeduction != NULL);
bSeduction = HitRoll::isSuccessRemoveCurse(45, SkillLevel, 30, pEffectSeduction->getLevel()/4);
bEffected = true;
}
// by sigi. 2002.12.3
// if (pTargetCreature->isEffect(Effect::EFFECT_CLASS_HALLUCINATION))
// {
// pEffectHallucination = (EffectHallucination*)pTargetCreature->findEffect(Effect::EFFECT_CLASS_HALLUCINATION);
//// Assert(pEffectHallucination != NULL);
//
// bHallucination = HitRoll::isSuccessRemoveCurse(45, SkillLevel, 40, pEffectHallucination->getLevel()/4);
// bEffected = true;
// }
if (pTargetCreature->isEffect(Effect::EFFECT_CLASS_DEATH))
{
pEffectDeath = (EffectDeath*)pTargetCreature->findEffect(Effect::EFFECT_CLASS_DEATH);
Assert(pEffectDeath != NULL);
bDeath = HitRoll::isSuccessRemoveCurse(45, SkillLevel, 50, pEffectDeath->getLevel()/4);
bEffected = true;
}
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pSlayer, pTargetCreature, pSkillInfo->getRange());
// 마나가 있고, 시간이 됐고, 거리가 적당하며,
// 저주가 하나라도 걸려있어야 한다.
if (bManaCheck && bTimeCheck && bRangeCheck && bEffected)
{
decreaseMana(pSlayer, RequiredMP, _GCSkillToObjectOK1);
SkillInput input(pSlayer, pSkillSlot);
SkillOutput output;
computeOutput(input, output);
// 각각의 저주를 삭제하고,
// 패킷에다 이펙트 삭제하라고 더한다.
GCRemoveEffect gcRemoveEffect;
gcRemoveEffect.setObjectID(pTargetCreature->getObjectID());
if (bDoom)
{
pEffectDoom->setDeadline(0);
pTargetCreature->removeFlag(Effect::EFFECT_CLASS_DOOM);
gcRemoveEffect.addEffectList(Effect::EFFECT_CLASS_DOOM);
}
if (bParalyze)
{
pEffectParalyze->setDeadline(0);
pTargetCreature->removeFlag(Effect::EFFECT_CLASS_PARALYZE);
gcRemoveEffect.addEffectList(Effect::EFFECT_CLASS_PARALYZE);
}
if (bSeduction)
{
pEffectSeduction->setDeadline(0);
pTargetCreature->removeFlag(Effect::EFFECT_CLASS_SEDUCTION);
gcRemoveEffect.addEffectList(Effect::EFFECT_CLASS_SEDUCTION);
}
// by sigi. 2002.12.3
// if (bHallucination)
// {
// pEffectHallucination->setDeadline(0);
// pTargetCreature->removeFlag(Effect::EFFECT_CLASS_HALLUCINATION);
// gcRemoveEffect.addEffectList(Effect::EFFECT_CLASS_HALLUCINATION);
// }
if (bDeath)
{
pEffectDeath->setDeadline(0);
pTargetCreature->removeFlag(Effect::EFFECT_CLASS_DEATH);
gcRemoveEffect.addEffectList(Effect::EFFECT_CLASS_DEATH);
}
// 경험치를 올린다.
SkillGrade Grade = g_pSkillInfoManager->getGradeByDomainLevel(pSlayer->getSkillDomainLevel(DomainType));
Exp_t ExpUp = 10*(Grade+1);
shareAttrExp(pSlayer, ExpUp, 1, 1, 8, _GCSkillToObjectOK1);
increaseDomainExp(pSlayer, DomainType, pSkillInfo->getPoint(), _GCSkillToObjectOK1);
increaseSkillExp(pSlayer, DomainType, pSkillSlot, pSkillInfo, _GCSkillToObjectOK1);
// 패킷을 만들어 보낸다.
ZoneCoord_t myX = pSlayer->getX();
ZoneCoord_t myY = pSlayer->getY();
ZoneCoord_t targetX = pTargetCreature->getX();
ZoneCoord_t targetY = pTargetCreature->getY();
_GCSkillToObjectOK1.setSkillType(SkillType);
_GCSkillToObjectOK1.setCEffectID(CEffectID);
_GCSkillToObjectOK1.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK1.setDuration(0);
_GCSkillToObjectOK2.setObjectID(pSlayer->getObjectID());
_GCSkillToObjectOK2.setSkillType(SkillType);
_GCSkillToObjectOK2.setDuration (0);
_GCSkillToObjectOK3.setObjectID(pSlayer->getObjectID());
_GCSkillToObjectOK3.setSkillType(SkillType);
_GCSkillToObjectOK3.setTargetXY(targetX, targetY);
_GCSkillToObjectOK4.setSkillType(SkillType);
_GCSkillToObjectOK4.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK5.setObjectID(pSlayer->getObjectID());
_GCSkillToObjectOK5.setSkillType(SkillType);
_GCSkillToObjectOK5.setTargetObjectID (TargetObjectID);
_GCSkillToObjectOK5.setDuration (0);
pPlayer->sendPacket(&_GCSkillToObjectOK1);
if (pTargetCreature->isPC())
{
Player* pTargetPlayer = pTargetCreature->getPlayer();
pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
}
pZone->broadcastPacket(targetX, targetY, &gcRemoveEffect);
list< Creature*> cList;
cList.push_back(pSlayer);
cList.push_back(pTargetCreature);
cList = pZone->broadcastSkillPacket(myX, myY, targetX, targetY, &_GCSkillToObjectOK5 , cList);
pZone->broadcastPacket(myX, myY, &_GCSkillToObjectOK3 , cList);
pZone->broadcastPacket(targetX, targetY, &_GCSkillToObjectOK4 , cList);
pSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pSlayer, getSkillType(), pTargetCreature);
}
}
catch(Throwable & t)
{
executeSkillFailException(pSlayer, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
void CGTradeAddItemHandler::executeOusters (CGTradeAddItem* pPacket , Player* pPlayer)
throw(ProtocolException , Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
// 상위 함수에서 에러를 검사했기 때문에,
// 여기서는 포인터가 널인지를 검사하지 않는다.
ObjectID_t TargetOID = pPacket->getTargetObjectID();
ObjectID_t ItemOID = pPacket->getItemObjectID();
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Creature* pPC = pGamePlayer->getCreature();
Zone* pZone = pPC->getZone();
PlayerCreature* pTargetPC = dynamic_cast<PlayerCreature*>(pZone->getCreature(TargetOID));
// NoSuch제거. by sigi. 2002.5.2
if (pTargetPC==NULL) return;
Ousters* pSender = dynamic_cast<Ousters*>(pPC);
TradeManager* pTradeManager = pZone->getTradeManager();
Assert(pTradeManager != NULL);
// 교환 대상에 추가할 아이템의 포인터를 얻어낸다.
CoordInven_t X, Y;
Inventory* pInventory = pSender->getInventory();
Item* pItem = pInventory->findItemOID(ItemOID, X, Y);
// 추가할 아이템이 없다면 당연히 더 이상 처리가 불가능
// Relic은 교환할 수 없다.
if (pItem == NULL
|| !canTrade(pItem )
|| pSender->getStore()->hasItem(pItem)
|| (pItem->getItemClass() == Item::ITEM_CLASS_SUB_INVENTORY && hasItemWithItemClass(pTargetPC, Item::ITEM_CLASS_SUB_INVENTORY ) )
)
{
pTradeManager->cancelTrade(pPC);
executeError(pPacket, pPlayer, GC_TRADE_ERROR_CODE_ADD_ITEM);
return;
}
//
//#ifdef __XMAS_EVENT_CODE__
// 녹색 선물 상자인 경우에는, 상대방에게 적색 선물 상자가 없는지 검사한 후,
// 인증 패킷을 보내줘야 한다.
if (pItem->getItemClass() == Item::ITEM_CLASS_EVENT_GIFT_BOX)
{
PlayerCreature* pReceiver = dynamic_cast<PlayerCreature*>(pTargetPC);
Item* pExtraSlotItem = pReceiver->getExtraInventorySlotItem();
if (pItem->getItemType() == 0)
{
Inventory* pTargetInventory = pReceiver->getInventory();
if (pTargetInventory->hasRedGiftBox())
{
// 적색 선물 상자를 가지고 있다면 더할 수 없다. 리턴시킨다.
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_FAIL);
pPlayer->sendPacket(&gcTradeVerify);
return;
}
else if (pExtraSlotItem != NULL)
{
if (pExtraSlotItem->getItemClass() == Item::ITEM_CLASS_EVENT_GIFT_BOX && pExtraSlotItem->getItemType() == 1)
{
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_FAIL);
pPlayer->sendPacket(&gcTradeVerify);
return;
}
}
else
{
// 적색 선물 상자를 가지고 있지 않다면, 걍 넘어간다.
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_OK);
pPlayer->sendPacket(&gcTradeVerify);
}
}
else if (pItem->getItemType() == 1)
{
// 적색 선물 상자는 교환 품목이 될 수 없다.
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_FAIL);
pPlayer->sendPacket(&gcTradeVerify);
return;
}
}
//#endif
//
TradeInfo* pInfo1 = pTradeManager->getTradeInfo(pSender->getName());
TradeInfo* pInfo2 = pTradeManager->getTradeInfo(pTargetPC->getName());
list<Item*> tradeList1 = pInfo1->getItemList();
if (pItem->getItemClass() == Item::ITEM_CLASS_EVENT_GIFT_BOX && pItem->getItemType() > 1 && pItem->getItemType() < 6)
{
for (list<Item*>::iterator itr = tradeList1.begin(); itr != tradeList1.end(); itr++)
{
Item* pTradeItem = (*itr);
if (pTradeItem->getItemClass() == Item::ITEM_CLASS_EVENT_GIFT_BOX && pTradeItem->getItemType() > 1 && pTradeItem->getItemType() < 6)
{
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_FAIL);
pPlayer->sendPacket(&gcTradeVerify);
return;
}
}
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_OK);
pPlayer->sendPacket(&gcTradeVerify);
}
else if (pItem->getItemClass() == Item::ITEM_CLASS_EVENT_GIFT_BOX && pItem->getItemType() >= 6)
{
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_OK);
pPlayer->sendPacket(&gcTradeVerify);
}
// TradeManager에 교환 대상으로서 아이템을 더한다.
//Assert(pInfo1->addItem(pItem));
pInfo1->addItem(pItem);
// 현재 OK를 누른 상태라면, 클라이언트에게 인증 패킷을 보내줘야 한다.
if (pInfo1->getStatus() == TRADE_FINISH)
{
//cout << "CGTradeRemoveItem [" << pSender->getName() << "]의 상태가 TRADE_FINISH이므로, 인증 패킷을 보내준다." << endl;
// 인증 패킷을 날려준다.
GCTradeVerify gcTradeVerify;
gcTradeVerify.setCode(GC_TRADE_VERIFY_CODE_ADD_ITEM_WHEN_ACCEPT);
pPlayer->sendPacket(&gcTradeVerify);
}
else
{
//cout << "CGTradeRemoveItem [" << pSender->getName() << "]의 상태가 TRADE_FINISH가 아니므로, 인증 패킷 날리지 않는다." << endl;
}
// 아이템을 더하거나 뺄 경우, 상태가 TRADE_FINISH라면
// TRADE_TRADING으로 바꿔줘야 한다.
pInfo1->setStatus(TRADE_TRADING);
pInfo2->setStatus(TRADE_TRADING);
// 상대방에게 날려줄 아이템 정보를 구성한다.
GCTradeAddItem gcTradeAddItem;
makeGCTradeAddItemPacket(&gcTradeAddItem, pSender->getObjectID(), pItem, X, Y);
// 상대방에게 교환할 아이템 정보를 날려준다.
Player* pTargetPlayer = pTargetPC->getPlayer();
pTargetPlayer->sendPacket(&gcTradeAddItem);
#endif
__END_DEBUG_EX __END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 슬레이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void ProtectionFromAcid::execute(Slayer* pSlayer, ObjectID_t TargetObjectID, 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);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL
|| !pTargetCreature->isSlayer()
)
{
executeSkillFailException(pSlayer, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
return;
}
GCSkillToObjectOK1 _GCSkillToObjectOK1;
GCSkillToObjectOK2 _GCSkillToObjectOK2;
GCSkillToObjectOK5 _GCSkillToObjectOK5;
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
SkillDomainType_t DomainType = pSkillInfo->getDomainType();
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pSlayer, pTargetCreature, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessMagic(pSlayer, pSkillInfo, pSkillSlot);
bool bEffected = pTargetCreature->isFlag(Effect::EFFECT_CLASS_PROTECTION_FROM_ACID);
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && !bEffected)
{
// 마나를 줄인다.
decreaseMana(pSlayer, RequiredMP, _GCSkillToObjectOK1);
// 경험치를 올려준다.
SkillGrade Grade = g_pSkillInfoManager->getGradeByDomainLevel(pSlayer->getSkillDomainLevel(DomainType));
Exp_t ExpUp = 10* (Grade + 1);
shareAttrExp(pSlayer, ExpUp, 1, 1, 8, _GCSkillToObjectOK1);
increaseDomainExp(pSlayer, DomainType, pSkillInfo->getPoint(), _GCSkillToObjectOK1);
increaseSkillExp(pSlayer, DomainType, pSkillSlot, pSkillInfo, _GCSkillToObjectOK1);
// 이펙트의 효과와 지속시간을 계산한다.
SkillInput input(pSlayer, pSkillSlot);
SkillOutput output;
input.TargetType = SkillInput::TARGET_OTHER;
computeOutput(input, output);
// 이펙트를 생성해서 붙인다.
EffectProtectionFromAcid* pEPFP = new EffectProtectionFromAcid (pTargetCreature);
Assert(pEPFP != NULL);
pEPFP->setDeadline(output.Duration);
pEPFP->setResist(output.Damage);
pTargetCreature->addEffect(pEPFP);
pTargetCreature->setFlag(Effect::EFFECT_CLASS_PROTECTION_FROM_ACID);
if (pTargetCreature->isSlayer())
{
Slayer* pTargetSlayer = dynamic_cast<Slayer*>(pTargetCreature);
SLAYER_RECORD prev;
pTargetSlayer->getSlayerRecord(prev);
pTargetSlayer->initAllStat();
pTargetSlayer->addModifyInfo(prev, _GCSkillToObjectOK1);
}
else
{
Assert(false);
}
// 패킷을 준비해서 보낸다.
_GCSkillToObjectOK1.setSkillType(SkillType);
_GCSkillToObjectOK1.setCEffectID(CEffectID);
_GCSkillToObjectOK1.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK1.setDuration(output.Duration);
_GCSkillToObjectOK2.setObjectID(pSlayer->getObjectID());
_GCSkillToObjectOK2.setSkillType(SkillType);
_GCSkillToObjectOK2.setDuration (output.Duration);
_GCSkillToObjectOK5.setObjectID(pSlayer->getObjectID());
_GCSkillToObjectOK5.setSkillType(SkillType);
_GCSkillToObjectOK5.setTargetObjectID (TargetObjectID);
_GCSkillToObjectOK5.setDuration (output.Duration);
// Send Packet
pPlayer->sendPacket(&_GCSkillToObjectOK1);
if (pSlayer != pTargetCreature && pTargetCreature->isPC())
{
Player* pTargetPlayer = pTargetCreature->getPlayer();
Assert(pTargetPlayer != NULL);
pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
}
list<Creature*> cList;
cList.push_back(pSlayer);
cList.push_back(pTargetCreature);
pZone->broadcastPacket(pSlayer->getX(), pSlayer->getY(), &_GCSkillToObjectOK5 , cList);
// 이펙트가 붙었다고 알려준다.
GCAddEffect gcAddEffect;
gcAddEffect.setObjectID(pTargetCreature->getObjectID());
gcAddEffect.setEffectID(Effect::EFFECT_CLASS_PROTECTION_FROM_ACID);
gcAddEffect.setDuration(output.Duration);
pZone->broadcastPacket(pTargetCreature->getX(), pTargetCreature->getY(), &gcAddEffect);
pSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pSlayer, getSkillType(), pTargetCreature);
}
}
catch (Throwable & t)
{
executeSkillFailException(pSlayer, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
