//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void Death::execute(Vampire* pVampire, ObjectID_t TargetObjectID, VampireSkillSlot* pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << "begin " << endl;
Assert(pVampire != NULL);
Assert(pSkillSlot != 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
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL
|| pTargetCreature->isFlag(Effect::EFFECT_CLASS_IMMUNE_TO_CURSE)
|| !canAttack(pVampire, pTargetCreature )
|| pTargetCreature->isNPC())
{
executeSkillFailException(pVampire, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
return;
}
GCSkillToObjectOK1 _GCSkillToObjectOK1;
GCSkillToObjectOK2 _GCSkillToObjectOK2;
GCSkillToObjectOK3 _GCSkillToObjectOK3;
GCSkillToObjectOK4 _GCSkillToObjectOK4;
GCSkillToObjectOK5 _GCSkillToObjectOK5;
GCSkillToObjectOK6 _GCSkillToObjectOK6;
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
// Knowledge of Curse 가 있다면 hit bonus 10
int HitBonus = 0;
if (pVampire->hasRankBonus(RankBonus::RANK_BONUS_KNOWLEDGE_OF_CURSE ) )
{
RankBonus* pRankBonus = pVampire->getRankBonus(RankBonus::RANK_BONUS_KNOWLEDGE_OF_CURSE);
Assert(pRankBonus != NULL);
HitBonus = pRankBonus->getPoint();
}
int RequiredMP = decreaseConsumeMP(pVampire, pSkillInfo);
bool bManaCheck = hasEnoughMana(pVampire, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pVampire, pTargetCreature, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessVampireCurse(pSkillInfo->getLevel(), pTargetCreature->getResist(MAGIC_DOMAIN_CURSE));
bool bHitRoll2 = HitRoll::isSuccessMagic(pVampire, pSkillInfo, pSkillSlot, HitBonus);
bool bCanHit = canHit(pVampire, pTargetCreature, SkillType);
bool bEffected = pTargetCreature->isFlag(Effect::EFFECT_CLASS_DEATH);
bool bPK = verifyPK(pVampire, pTargetCreature);
ZoneCoord_t targetX = pTargetCreature->getX();
ZoneCoord_t targetY = pTargetCreature->getY();
ZoneCoord_t myX = pVampire->getX();
ZoneCoord_t myY = pVampire->getY();
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bHitRoll2 && bCanHit && !bEffected && bPK)
{
decreaseMana(pVampire, RequiredMP, _GCSkillToObjectOK1);
bool bCanSeeCaster = canSee(pTargetCreature, pVampire);
SkillInput input(pVampire);
SkillOutput output;
computeOutput(input, output);
// pTargetCreature가 저주마법을 반사하는 경우
if (CheckReflection(pVampire, pTargetCreature, getSkillType()))
{
pTargetCreature = (Creature*)pVampire;
TargetObjectID = pVampire->getObjectID();
}
Resist_t resist = pTargetCreature->getResist(MAGIC_DOMAIN_CURSE);
if ((resist*10/3) > output.Duration ) output.Duration=0;
else output.Duration -= resist*10/3;
if (output.Duration < 20 ) output.Duration = 20;
// 이펙트 오브젝트를 생성해 붙인다.
EffectDeath* pEffect = new EffectDeath(pTargetCreature);
pEffect->setDeadline(output.Duration);
pEffect->setLevel(pSkillInfo->getLevel()/2);
pEffect->setResistPenalty(output.Damage);
pTargetCreature->addEffect(pEffect);
pTargetCreature->setFlag(Effect::EFFECT_CLASS_DEATH);
// 능력치를 계산해서 보내준다.
if (pTargetCreature->isSlayer())
{
Slayer* pTargetSlayer = dynamic_cast<Slayer*>(pTargetCreature);
if (bCanSeeCaster)
{
SLAYER_RECORD prev;
pTargetSlayer->getSlayerRecord(prev);
pTargetSlayer->initAllStat();
pTargetSlayer->addModifyInfo(prev, _GCSkillToObjectOK2);
}
else
{
SLAYER_RECORD prev;
pTargetSlayer->getSlayerRecord(prev);
pTargetSlayer->initAllStat();
pTargetSlayer->addModifyInfo(prev, _GCSkillToObjectOK6);
}
}
else if (pTargetCreature->isVampire())
{
Vampire* pTargetVampire = dynamic_cast<Vampire*>(pTargetCreature);
VAMPIRE_RECORD prev;
pTargetVampire->getVampireRecord(prev);
pTargetVampire->initAllStat();
if (bCanSeeCaster)
{
pTargetVampire->addModifyInfo(prev, _GCSkillToObjectOK2);
}
else
{
pTargetVampire->addModifyInfo(prev, _GCSkillToObjectOK6);
}
}
else if (pTargetCreature->isOusters())
{
Ousters* pTargetOusters = dynamic_cast<Ousters*>(pTargetCreature);
OUSTERS_RECORD prev;
pTargetOusters->getOustersRecord(prev);
pTargetOusters->initAllStat();
if (bCanSeeCaster)
{
pTargetOusters->addModifyInfo(prev, _GCSkillToObjectOK2);
}
else
{
pTargetOusters->addModifyInfo(prev, _GCSkillToObjectOK6);
}
}
else if (pTargetCreature->isMonster())
{
Monster* pTargetMonster = dynamic_cast<Monster*>(pTargetCreature);
pTargetMonster->initAllStat();
}
else Assert(false);
_GCSkillToObjectOK1.setSkillType(SkillType);
_GCSkillToObjectOK1.setCEffectID(CEffectID);
_GCSkillToObjectOK1.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK1.setDuration(output.Duration);
_GCSkillToObjectOK2.setObjectID(pVampire->getObjectID());
_GCSkillToObjectOK2.setSkillType(SkillType);
_GCSkillToObjectOK2.setDuration(output.Duration);
_GCSkillToObjectOK3.setObjectID(pVampire->getObjectID());
_GCSkillToObjectOK3.setSkillType(SkillType);
_GCSkillToObjectOK3.setTargetXY (targetX, targetY);
_GCSkillToObjectOK4.setSkillType(SkillType);
_GCSkillToObjectOK4.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK4.setDuration(output.Duration);
_GCSkillToObjectOK5.setObjectID(pVampire->getObjectID());
_GCSkillToObjectOK5.setSkillType(SkillType);
_GCSkillToObjectOK5.setTargetObjectID (TargetObjectID);
_GCSkillToObjectOK5.setDuration(output.Duration);
_GCSkillToObjectOK6.setXY(myX, myY);
_GCSkillToObjectOK6.setSkillType(SkillType);
_GCSkillToObjectOK6.setDuration(output.Duration);
if (bCanSeeCaster) // 10은 땜빵 수치다.
{
computeAlignmentChange(pTargetCreature, 10, pVampire, &_GCSkillToObjectOK2, &_GCSkillToObjectOK1);
}
else // 10은 땜빵 수치다.
{
computeAlignmentChange(pTargetCreature, 10, pVampire, &_GCSkillToObjectOK6, &_GCSkillToObjectOK1);
}
list<Creature *> cList;
cList.push_back(pTargetCreature);
cList.push_back(pVampire);
cList = pZone->broadcastSkillPacket(myX, myY, targetX, targetY, &_GCSkillToObjectOK5, cList);
pZone->broadcastPacket(myX, myY, &_GCSkillToObjectOK3, cList);
pZone->broadcastPacket(targetX, targetY, &_GCSkillToObjectOK4, cList);
// Send Packet
pPlayer->sendPacket(&_GCSkillToObjectOK1);
if (pTargetCreature->isPC())
{
Player* pTargetPlayer = pTargetCreature->getPlayer();
if (pTargetPlayer == NULL)
{
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
return;
}
if (bCanSeeCaster) pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
else pTargetPlayer->sendPacket(&_GCSkillToObjectOK6);
}
else if (pTargetCreature->isMonster())
{
Monster* pTargetMonster = dynamic_cast<Monster*>(pTargetCreature);
pTargetMonster->addEnemy(pVampire);
}
GCAddEffect gcAddEffect;
gcAddEffect.setObjectID(TargetObjectID);
gcAddEffect.setEffectID(Effect::EFFECT_CLASS_DEATH);
gcAddEffect.setDuration(output.Duration);
pZone->broadcastPacket(targetX, targetY, &gcAddEffect);
//cout << pTargetCreature->getName() << "에게 Death를 " << output.Duration << " duration 동안 건다." << endl;
pSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pVampire, getSkillType(), pTargetCreature);
}
}
catch (Throwable & t)
{
executeSkillFailException(pVampire, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
void CGDownSkillHandler::execute (CGDownSkill* pPacket , Player* pPlayer)
throw(ProtocolException, Error)
{
__BEGIN_TRY __BEGIN_DEBUG_EX
#ifdef __GAME_SERVER__
Assert(pPacket != NULL);
Assert(pPlayer != NULL);
GamePlayer* pGamePlayer = dynamic_cast<GamePlayer*>(pPlayer);
Assert(pGamePlayer != NULL);
PlayerCreature* pPC = dynamic_cast<PlayerCreature*>(pGamePlayer->getCreature());
Assert(pPC != NULL);
SkillType_t targetSkillType = pPacket->getSkillType();
GCDownSkillFailed failpkt;
failpkt.setSkillType(targetSkillType);
if (!pPC->isOusters() )
{
failpkt.setDesc(NOT_OUSTERS);
pPlayer->sendPacket(&failpkt);
return;
}
Ousters* pOusters = dynamic_cast<Ousters*>(pPC);
Assert(pOusters != NULL);
OustersSkillSlot* pTargetSkillSlot = pOusters->getSkill(targetSkillType);
if (pTargetSkillSlot == NULL )
{
failpkt.setDesc(HAVE_NOT_SKILL);
pPlayer->sendPacket(&failpkt);
return;
}
SkillInfo* pTargetSkillInfo = NULL;
try
{
pTargetSkillInfo = g_pSkillInfoManager->getSkillInfo(targetSkillType);
}
catch(Exception& e)
{
failpkt.setDesc(INVALID_SKILL);
pPlayer->sendPacket(&failpkt);
return;
}
if (pTargetSkillSlot->getExpLevel() <= 1 )
{
if (!pTargetSkillInfo->canDelete() )
{
failpkt.setDesc(TOO_LOW);
pPlayer->sendPacket(&failpkt);
return;
}
list<SkillType_t>& rRequiredSkills = pTargetSkillInfo->getRequiredSkills();
list<SkillType_t>::iterator itr = rRequiredSkills.begin();
for (; itr != rRequiredSkills.end(); ++itr )
{
if (pOusters->hasSkill(*itr) != NULL )
{
bool canDrop = false;
SkillInfo* pFollowingSkillInfo = g_pSkillInfoManager->getSkillInfo(*itr);
list<SkillType_t>& rRequireSkills = pFollowingSkillInfo->getRequireSkills();
list<SkillType_t>::iterator itr2 = rRequireSkills.begin();
for (; itr2 != rRequireSkills.end(); ++itr2 )
{
if ((*itr2) != targetSkillType && pOusters->hasSkill(*itr2) != NULL )
{
SkillInfo* pAlternativeSkillInfo = g_pSkillInfoManager->getSkillInfo(*itr2);
if (getSkillMapID((ElementalDomain)pAlternativeSkillInfo->getElementalDomain()) == getSkillMapID((ElementalDomain)pTargetSkillInfo->getElementalDomain()) )
canDrop = true;
}
}
if (!canDrop )
{
failpkt.setDesc(CANNOT_DROP_SKILL);
pPlayer->sendPacket(&failpkt);
return;
}
}
}
}
/* if (pTargetSkillSlot->getExpLevel() >= 30 )
{
failpkt.setDesc(TOO_HIGH);
pPlayer->sendPacket(&failpkt);
return;
}*/
Assert(pTargetSkillInfo != NULL);
int backPoint = pTargetSkillInfo->getLevelUpPoint();
Price_t downPrice = (int)(backPoint * pow(pOusters->getLevel(),1.3) * 200);
if (pTargetSkillSlot->getExpLevel() <= 1 )
{
downPrice *= 5;
if (downPrice == 0 ) downPrice = 1000000;
}
if (pOusters->getGold() < downPrice )
{
failpkt.setDesc(NOT_ENOUGH_MONEY);
pPlayer->sendPacket(&failpkt);
return;
}
pOusters->decreaseGoldEx(downPrice);
pTargetSkillSlot->setExpLevel(pTargetSkillSlot->getExpLevel() - 1);
pTargetSkillSlot->save();
if (pTargetSkillSlot->getExpLevel() <= 0 )
{
pTargetSkillSlot->destroy(pOusters->getName());
backPoint = pTargetSkillInfo->getSkillPoint();
pOusters->removeSkill(targetSkillType);
}
pOusters->setSkillBonus(pOusters->getSkillBonus() + backPoint);
char query[50];
sprintf(query, "SkillBonus=%d", pOusters->getSkillBonus());
pOusters->tinysave(query);
GCDownSkillOK okpkt;
okpkt.setSkillType(targetSkillType);
pPlayer->sendPacket(&okpkt);
GCModifyInformation gcMI;
gcMI.addLongData(MODIFY_GOLD, pOusters->getGold());
gcMI.addShortData(MODIFY_SKILL_BONUS_POINT, pOusters->getSkillBonus());
switch (targetSkillType )
{
case SKILL_HIDE_SIGHT:
{
OUSTERS_RECORD prev;
pOusters->getOustersRecord(prev);
pOusters->initAllStat();
pOusters->sendRealWearingInfo();
pOusters->addModifyInfo(prev, gcMI);
}
break;
default :
break;
}
pPlayer->sendPacket(&gcMI);
#endif // __GAME_SERVER__
__END_DEBUG_EX __END_CATCH
}
