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(
Monster* pMonster, Creature* pEnemy,
const SIMPLE_SKILL_INPUT& param, SIMPLE_SKILL_OUTPUT& result,
CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
Assert(pMonster != NULL);
Assert(pEnemy != NULL);
try
{
Zone* pZone = pMonster->getZone();
Assert(pZone != NULL);
if (pMonster->isFlag(Effect::EFFECT_CLASS_HIDE))
{
return;
}
if (pMonster->isFlag(Effect::EFFECT_CLASS_INVISIBILITY))
{
addVisibleCreature(pZone, pMonster, true);
}
result.pTargetCreature = pEnemy;
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(pMonster, pEnemy, 0, bCriticalHit);
}
if (param.bMagicDamage)
{
// 만일 스킬 데미지가 마법 데미지라면, 마법 데미지 계산 함수를 이용해 계산을 해준다.
Damage += computeMagicDamage(pEnemy, param.SkillDamage, param.SkillType);
}
else
{
Damage += param.SkillDamage;
}
bool bRangeCheck = verifyDistance(pMonster, pEnemy, pSkillInfo->getRange());
bool bHitRoll = false;
bool bCanHit = canHit(pMonster, pEnemy, param.SkillType);
if (param.bMagicHitRoll)
{
bHitRoll = HitRoll::isSuccessMagic(pMonster, pSkillInfo);
}
else
{
bHitRoll = HitRoll::isSuccess(pMonster, pEnemy);
}
Coord_t vampX = pMonster->getX();
Coord_t vampY = pMonster->getY();
Coord_t targetX = pEnemy->getX();
Coord_t targetY = pEnemy->getY();
// 공격성공률 검증.
if (bRangeCheck && bHitRoll && bCanHit)
{
bool bCanSeeCaster = canSee(pEnemy, pMonster);
// 데미지를 가하고, 아이템 내구도를 떨어뜨린다.
if (bCanSeeCaster)
{
setDamage(pEnemy, Damage, pMonster, param.SkillType, &_GCSkillToObjectOK2);
decreaseDurability(pMonster, pEnemy, pSkillInfo, NULL, &_GCSkillToObjectOK2);
}
else
{
setDamage(pEnemy, Damage, pMonster, param.SkillType, &_GCSkillToObjectOK6);
decreaseDurability(pMonster, pEnemy, pSkillInfo, NULL, &_GCSkillToObjectOK6);
}
_GCSkillToObjectOK2.setObjectID(pMonster->getObjectID());
_GCSkillToObjectOK2.setSkillType(param.SkillType);
_GCSkillToObjectOK2.setDuration(0);
_GCSkillToObjectOK2.setObjectID(pMonster->getObjectID());
_GCSkillToObjectOK3.setObjectID(pMonster->getObjectID());
_GCSkillToObjectOK3.setSkillType(param.SkillType);
_GCSkillToObjectOK3.setTargetXY(targetX, targetY);
_GCSkillToObjectOK4.setSkillType(param.SkillType);
_GCSkillToObjectOK4.setTargetObjectID(pEnemy->getObjectID());
_GCSkillToObjectOK5.setObjectID(pMonster->getObjectID());
_GCSkillToObjectOK5.setTargetObjectID(pEnemy->getObjectID());
_GCSkillToObjectOK5.setSkillType(param.SkillType);
_GCSkillToObjectOK5.setDuration(0);
_GCSkillToObjectOK6.setXY(vampX, vampY);
_GCSkillToObjectOK6.setSkillType(param.SkillType);
_GCSkillToObjectOK6.setDuration(0);
_GCSkillToObjectOK6.setXY(vampX, vampY);
if (pEnemy->isPC())
{
Player* pTargetPlayer = pEnemy->getPlayer();
Assert(pTargetPlayer != NULL);
if (bCanSeeCaster) pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
else pTargetPlayer->sendPacket(&_GCSkillToObjectOK6);
}
else if (pEnemy->isMonster())
{
Monster* pTargetMonster = dynamic_cast<Monster*>(pEnemy);
pTargetMonster->addEnemy(pMonster);
}
list<Creature*> cList;
cList.push_back(pMonster);
cList.push_back(pEnemy);
cList = pZone->broadcastSkillPacket(vampX, vampY, targetX, targetY, &_GCSkillToObjectOK5, cList);
pZone->broadcastPacket(vampX, vampY, &_GCSkillToObjectOK3 , cList);
pZone->broadcastPacket(targetX, targetY, &_GCSkillToObjectOK4 , cList);
result.bSuccess = true;
}
else
{
executeSkillFailNormal(pMonster, param.SkillType, pEnemy);
}
}
catch (Throwable & t)
{
executeSkillFailException(pMonster, param.SkillType);
}
__END_CATCH
}
void EffectGreenStalker::affect(Creature* pCreature)
throw(Error)
{
__BEGIN_TRY
//cout << "EffectGreenStalker " << "affect BEGIN" << endl;
Assert(pCreature != NULL);
Zone* pZone = pCreature->getZone();
Assert(pZone != NULL);
// 기술 사용자를 가져온다.
// !! 이미 존을 나갔을 수 있으므로 NULL 이 될 수 있다.
// by bezz. 2003.1.4
Creature* pCastCreature = pZone->getCreature(m_UserObjectID);
if (pCastCreature == NULL )
{
setNextTime(m_Tick);
return;
}
int PoisonDamage = computeMagicDamage(pCreature, m_Damage, SKILL_GREEN_STALKER, m_bVampire, pCastCreature);
// 무적상태 체크. by sigi. 2002.9.5
if (canAttack(pCastCreature, pCreature )
&& !pCreature->isFlag(Effect::EFFECT_CLASS_COMA)
)
{
// 슬레이어일 경우에만 독 데미지가 존재한다.
if (pCreature->isSlayer())
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pCreature);
Assert(pSlayer != NULL);
GCModifyInformation gcMI;
::setDamage(pSlayer, PoisonDamage, pCastCreature, SKILL_GREEN_STALKER, &gcMI);
Player* pPlayer = pCreature->getPlayer();
Assert(pPlayer != NULL);
pPlayer->sendPacket(&gcMI);
}
else if (pCreature->isVampire())
{
Vampire* pVampire = dynamic_cast<Vampire*>(pCreature);
Assert(pVampire != NULL);
GCModifyInformation gcMI;
::setDamage(pVampire, PoisonDamage, pCastCreature, SKILL_GREEN_STALKER, &gcMI);
Player* pPlayer = pCreature->getPlayer();
Assert(pPlayer != NULL);
pPlayer->sendPacket(&gcMI);
}
else if (pCreature->isOusters())
{
Ousters* pOusters = dynamic_cast<Ousters*>(pCreature);
Assert(pOusters != NULL);
GCModifyInformation gcMI;
::setDamage(pOusters, PoisonDamage, pCastCreature, SKILL_GREEN_STALKER, &gcMI);
Player* pPlayer = pCreature->getPlayer();
Assert(pPlayer != NULL);
pPlayer->sendPacket(&gcMI);
}
else if (pCreature->isMonster())
{
Monster* pMonster = dynamic_cast<Monster*>(pCreature);
Assert(pMonster != NULL);
::setDamage(pMonster, PoisonDamage, pCastCreature, SKILL_GREEN_STALKER);
}
// m_CasterName이 pCreature를 죽인 경우의 KillCount 처리
// by sigi. 2002.9.9
/* if (pCreature->isDead())
{
Creature* pAttacker = pZone->getCreature(m_UserObjectID);
if (pAttacker!=NULL)
{
affectKillCount(pAttacker, pCreature);
}
}*/
}
setNextTime(m_Tick);
//cout << "EffectGreenStalker " << "affect END" << endl;
__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 BloodyBreaker::execute(Vampire* pVampire, ZoneCoord_t X, ZoneCoord_t Y, VampireSkillSlot* pVampireSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << "begin " << endl;
SkillType_t SkillType = getSkillType();
// Knowledge of Blood 가 있다면 hit bonus 10
int HitBonus = 0;
if (pVampire->hasRankBonus(RankBonus::RANK_BONUS_KNOWLEDGE_OF_BLOOD ) )
{
RankBonus* pRankBonus = pVampire->getRankBonus(RankBonus::RANK_BONUS_KNOWLEDGE_OF_BLOOD);
Assert(pRankBonus != NULL);
HitBonus = pRankBonus->getPoint();
}
try
{
SkillInput input(pVampire);
SkillOutput output;
computeOutput(input, output);
Dir_t Dir = getDirectionToPosition(pVampire->getX(), pVampire->getY(), X, Y);
// 강제로 knockback시킬 확률
// bool bForceKnockback = rand()%100 < output.ToHit;
Player* pPlayer = pVampire->getPlayer();
Zone* pZone = pVampire->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
VSRect rect(1, 1, pZone->getWidth()-2, pZone->getHeight()-2);
if (!rect.ptInRect(X, Y ))
{
executeSkillFailException(pVampire, SkillType);
return;
}
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
// GCSkillToTileOK3 _GCSkillToTileOK3;
// GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
// GCSkillToTileOK6 _GCSkillToTileOK6;
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
int RequiredMP = decreaseConsumeMP(pVampire, pSkillInfo);
bool bManaCheck = hasEnoughMana(pVampire, RequiredMP);
bool bTimeCheck = verifyRunTime(pVampireSkillSlot);
bool bRangeCheck = verifyDistance(pVampire, X, Y, pSkillInfo->getRange());
if (bManaCheck && bTimeCheck && bRangeCheck )
{
// 마나를 떨어뜨린다.
decreaseMana(pVampire, RequiredMP, _GCSkillToTileOK1);
// 좌표와 방향을 구한다.
ZoneCoord_t myX = pVampire->getX();
ZoneCoord_t myY = pVampire->getY();
Dir_t dir = calcDirection(myX, myY, X, Y);
list<Creature*> cList;
// knockback 때문에 recursive 하게 데미지를 먹는 경우가 있다.
// 그래서 제일 먼쪽에 있는 마스크부터 체크한다.
for (int i = 21; i >= 0; i-- )
{
int tileX = myX + m_pBloodyBreakerMask[Dir][i].x;
int tileY = myY + m_pBloodyBreakerMask[Dir][i].y;
// 현재 타일이 존 내부이고, 안전지대가 아니라면 맞을 가능성이 있다.
if (rect.ptInRect(tileX, tileY))
{
// 타일을 받아온다.
Tile& tile = pZone->getTile(tileX, tileY);
list<Creature*> targetList;
if (tile.hasCreature(Creature::MOVE_MODE_WALKING))
{
Creature* pCreature = tile.getCreature(Creature::MOVE_MODE_WALKING);
targetList.push_back(pCreature);
}
if (tile.hasCreature(Creature::MOVE_MODE_FLYING))
{
Creature* pCreature = tile.getCreature(Creature::MOVE_MODE_FLYING);
targetList.push_back(pCreature);
}
if (tile.hasCreature(Creature::MOVE_MODE_BURROWING))
{
Creature* pCreature = tile.getCreature(Creature::MOVE_MODE_BURROWING);
targetList.push_back(pCreature);
}
list<Creature*>::iterator itr = targetList.begin();
for(; itr != targetList.end(); itr++)
{
Creature* pTargetCreature = (*itr);
Assert(pTargetCreature != NULL);
if (!canAttack(pVampire, pTargetCreature )
|| pTargetCreature->isFlag(Effect::EFFECT_CLASS_COMA) )
{
continue;
}
if (pTargetCreature != pVampire)
{
bool bPK = verifyPK(pVampire, pTargetCreature);
bool bRaceCheck = pTargetCreature->isSlayer() || pTargetCreature->isMonster() || pTargetCreature->isOusters();
bool bZoneLevelCheck = checkZoneLevelToHitTarget(pTargetCreature);
bool bHitRoll = false;//HitRoll::isSuccessMagic(pVampire, pSkillInfo, pVampireSkillSlot, HitBonus);
int EnemyLevel = 0;
if (pTargetCreature->isSlayer() )
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pTargetCreature);
EnemyLevel = pSlayer->getHighestSkillDomainLevel();
}
else if (pTargetCreature->isOusters() )
{
Ousters* pOusters = dynamic_cast<Ousters*>(pTargetCreature);
EnemyLevel = pOusters->getLevel();
}
else if (pTargetCreature->isMonster() )
{
Monster* pMonster = dynamic_cast<Monster*>(pTargetCreature);
EnemyLevel = pMonster->getLevel();
}
// min : 20, max : 100
int hitRatio = max(20, 50 + pVampire->getLevel() - EnemyLevel + HitBonus);
bHitRoll = (rand()%100) < hitRatio;
if (bPK && bRaceCheck && bZoneLevelCheck && bHitRoll)
{
Damage_t Damage = 0;
bool bForceKnockback = rand() & 1;
Damage += computeMagicDamage(pTargetCreature, output.Damage, SkillType, true, pVampire);
ObjectID_t targetObjectID = pTargetCreature->getObjectID();
cList.push_back(pTargetCreature);
_GCSkillToTileOK1.addCListElement(targetObjectID);
_GCSkillToTileOK2.addCListElement(targetObjectID);
_GCSkillToTileOK5.addCListElement(targetObjectID);
// 일단 맞는 놈이 받을 패킷은 널 상태로 한 채로, 데미지를 준다.
setDamage(pTargetCreature, Damage, pVampire, SkillType, NULL, &_GCSkillToTileOK1);
computeAlignmentChange(pTargetCreature, Damage, pVampire, NULL, &_GCSkillToTileOK1);
increaseAlignment(pVampire, pTargetCreature, _GCSkillToTileOK1);
// 크리티컬 히트라면 상대방을 뒤로 물러나게 한다.
if (bForceKnockback)
{
knockbackCreature(pZone, pTargetCreature, pVampire->getX(), pVampire->getY());
}
if (pTargetCreature->isDead())
{
int exp = computeCreatureExp(pTargetCreature, KILL_EXP);
shareVampExp(pVampire, exp, _GCSkillToTileOK1);
}
}
}
}
}
}
// 공격자의 아이템 내구성을 떨어뜨린다.
decreaseDurability(pVampire, NULL, pSkillInfo, &_GCSkillToTileOK1, NULL);
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(0);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setRange(dir);
_GCSkillToTileOK1.setDuration(0);
_GCSkillToTileOK2.setObjectID(pVampire->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setRange(dir);
_GCSkillToTileOK2.setDuration(0);
_GCSkillToTileOK5.setObjectID(pVampire->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setRange(dir);
_GCSkillToTileOK5.setDuration(0);
pPlayer->sendPacket(&_GCSkillToTileOK1);
// 이 기술에 의해 영향을 받는 놈들에게 패킷을 보내줘야 한다.
for (list<Creature*>::const_iterator itr = cList.begin(); itr != cList.end(); itr++)
{
Creature * pTargetCreature = *itr;
Assert(pTargetCreature != NULL);
if (pTargetCreature->isPC())
{
_GCSkillToTileOK2.clearList();
// HP의 변경사항을 패킷에다 기록한다.
HP_t targetHP = 0;
if (pTargetCreature->isSlayer())
{
targetHP = (dynamic_cast<Slayer*>(pTargetCreature))->getHP(ATTR_CURRENT);
}
else if (pTargetCreature->isVampire())
{
targetHP = (dynamic_cast<Vampire*>(pTargetCreature))->getHP(ATTR_CURRENT);
}
else if (pTargetCreature->isOusters())
{
targetHP = (dynamic_cast<Ousters*>(pTargetCreature))->getHP(ATTR_CURRENT);
}
_GCSkillToTileOK2.addShortData(MODIFY_CURRENT_HP, targetHP);
// 아이템의 내구력을 떨어뜨린다.
decreaseDurability(NULL, pTargetCreature, pSkillInfo, NULL, &_GCSkillToTileOK2);
// 패킷을 보내준다.
pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK2);
}
else if (pTargetCreature->isMonster())
{
// 당근 적으로 인식한다.
Monster* pMonster = dynamic_cast<Monster*>(pTargetCreature);
pMonster->addEnemy(pVampire);
}
}
cList.push_back(pVampire);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK5 , cList);
// set Next Run Time
pVampireSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pVampire, SkillType, NULL);
}
}
catch (Throwable & t)
{
executeSkillFailException(pVampire, SkillType);
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
bool EffectEnergyDrop::affectCreature(Creature* pTargetCreature, bool bAffectByMove)
throw(Error)
{
__BEGIN_TRY
//cout << "EffectEnergyDrop " << "affectCreature Begin " << endl;
Assert(pTargetCreature != NULL);
// 상대에게 이미 poison 이펙트가 걸려져 있는 경우에는 걸리지 않는다.
if (pTargetCreature->isFlag(Effect::EFFECT_CLASS_ENERGY_DROP_TO_CREATURE))
{
//cout << "EffectEnergyDrop " << "affectCreature End(Already Effected) " << endl;
return false;
}
// 안전지대 체크
// 2003.1.10 by bezz, Sequoia
if (!checkZoneLevelToHitTarget(pTargetCreature) )
{
return false;
}
Zone* pZone = pTargetCreature->getZone();
// 상대방에게 미칠 독 데미지를 계산한다.
int DropDamage = computeMagicDamage(pTargetCreature, m_Damage, SKILL_ENERGY_DROP);
//cout << "EffectEnergyDrop(Damage:" << DropDamage << ") Affected" << endl;
if (DropDamage > 0)
{
// 포이즌 이펙트를 생성해서, 타겟 크리쳐에 붙이고, 플래그를 켜준다.
// 현제는 EnergyDrop Effect를 지속적으로 운영하지 않는다. 다른 Effeect기술의
// 경우 시전자의 레벨이 올라갈수록 Duration이 증가하게 되고 이에 대한 Effect를 붙이게
// 되지만, --Drop, --Storm류의 기술은 일단 성공이 되면 해당 구역의 모든 사람이
// 기술을 당하게 되고, 각각 시간으로 데미지를 주는 것이 아니라 일정량의 데미지를
// 3등분해서 주게 된다. 몇번의 데미지를 주는 함수는 아직 개발되지 않은 단계라서
// Deadline과 tick을 사용해서 임의로 구현을 하였다.
// 1.6초 동안에 0.5초 간격으로 데미지를 주게 되면, 3번의 데미지를 줄 수 있게 된다.
// 여기서는 하드코딩이 되어 있는데, 이는 다른 방법으로 교체되어야 할 거 같다.
// EffectEnergyDrop Class에 member variable로
// m_Tick
// m_Count
// 를 두어서 이를 바탕으로 deadline을 계산해서 적용한다면 더욱 더 편할 것이다.
EffectEnergyDropToCreature* pEffectEnergyDropToCreature = new EffectEnergyDropToCreature(pTargetCreature);
// 우선권 시스템을 위하여 이름과 파티 아이디를 넣는다.
// pEffectEnergyDropToCreature->setCasterName(m_CasterName);
// pEffectEnergyDropToCreature->setPartyID(m_PartyID);
pEffectEnergyDropToCreature->setUserObjectID(m_UserObjectID);
pEffectEnergyDropToCreature->setLevel(m_Level);
pEffectEnergyDropToCreature->setPoint(DropDamage/3);
pEffectEnergyDropToCreature->setDeadline(16); // 이부분 바꿔야 한다.
pEffectEnergyDropToCreature->setTick(5); // 이부분도 바꿔야 한다.
pEffectEnergyDropToCreature->affect(pTargetCreature);
pTargetCreature->addEffect(pEffectEnergyDropToCreature);
pTargetCreature->setFlag(Effect::EFFECT_CLASS_ENERGY_DROP_TO_CREATURE);
// 이펙트가 붙었다고 주변에 알려준다.
GCAddEffect gcAddEffect;
gcAddEffect.setObjectID(pTargetCreature->getObjectID());
gcAddEffect.setEffectID(Effect::EFFECT_CLASS_ENERGY_DROP_TO_CREATURE);
gcAddEffect.setDuration(m_Duration);
pZone->broadcastPacket(pTargetCreature->getX(), pTargetCreature->getY(), &gcAddEffect);
}
//cout << "EffectEnergyDrop " << "affectCreature End " << endl;
return true;
__END_CATCH
}
void EffectBloodyWallBlocked::affect()
throw(Error)
{
__BEGIN_TRY
//cout << "EffectBloodyWallBlocked" << "affect BEGIN" << endl;
Assert(m_pZone != NULL);
// 현재 이펙트가 붙어있는 타일을 받아온다.
Tile& tile = m_pZone->getTile(m_X, m_Y);
HP_t CurrentHP = 0;
HP_t RemainHP = 0;
// 타일 안에 존재하는 오브젝트들을 검색한다.
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* pCreature = dynamic_cast<Creature*>(pObject);
Assert(pCreature != NULL);
// 무적상태 체크. by sigi. 2002.9.5
// 산 면역. by sigi. 2002.9.13
if (!canAttack(NULL, pCreature )
|| pCreature->isFlag(Effect::EFFECT_CLASS_IMMUNE_TO_BLOOD_DRAIN)
|| pCreature->isFlag(Effect::EFFECT_CLASS_COMA)
|| pCreature->isDead())
{
continue;
}
int AcidDamage = computeMagicDamage(pCreature, m_Damage, SKILL_BLOODY_WALL);
if (pCreature->getMoveMode() != Creature::MOVE_MODE_FLYING)
{
if (pCreature->isSlayer())
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pCreature);
CurrentHP = pSlayer->getHP(ATTR_CURRENT);
RemainHP = max(0, CurrentHP -(int)AcidDamage);
pSlayer->setHP(RemainHP, ATTR_CURRENT);
GCModifyInformation gcMI;
gcMI.addShortData(MODIFY_CURRENT_HP, pSlayer->getHP(ATTR_CURRENT));
Player* pPlayer = pSlayer->getPlayer();
Assert(pPlayer != NULL);
pPlayer->sendPacket(&gcMI);
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pSlayer->getObjectID());
pkt.setCurrentHP(RemainHP);
m_pZone->broadcastPacket(pSlayer->getX(), pSlayer->getY(), &pkt);
}
/* else if (pCreature->isVampire())
{
Vampire* pVampire = dynamic_cast<Vampire*>(pCreature);
CurrentHP = pVampire->getHP(ATTR_CURRENT);
RemainHP = max(0, CurrentHP -(int)AcidDamage);
pVampire->setHP(RemainHP, ATTR_CURRENT);
GCModifyInformation gcMI;
gcMI.addShortData(MODIFY_CURRENT_HP, pVampire->getHP(ATTR_CURRENT));
Player* pPlayer = pVampire->getPlayer();
Assert(pPlayer != NULL);
pPlayer->sendPacket(&gcMI);
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pVampire->getObjectID());
pkt.setCurrentHP(RemainHP);
m_pZone->broadcastPacket(pVampire->getX(), pVampire->getY(), &pkt);
}
*/
else if (pCreature->isOusters())
{
Ousters* pOusters = dynamic_cast<Ousters*>(pCreature);
CurrentHP = pOusters->getHP(ATTR_CURRENT);
RemainHP = max(0, CurrentHP -(int)AcidDamage);
pOusters->setHP(RemainHP, ATTR_CURRENT);
GCModifyInformation gcMI;
gcMI.addShortData(MODIFY_CURRENT_HP, pOusters->getHP(ATTR_CURRENT));
Player* pPlayer = pOusters->getPlayer();
Assert(pPlayer != NULL);
pPlayer->sendPacket(&gcMI);
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pOusters->getObjectID());
pkt.setCurrentHP(RemainHP);
m_pZone->broadcastPacket(pOusters->getX(), pOusters->getY(), &pkt);
}
else if (pCreature->isMonster())
{
Monster* pMonster = dynamic_cast<Monster*>(pCreature);
CurrentHP = pMonster->getHP(ATTR_CURRENT);
RemainHP = max(0, CurrentHP -(int)AcidDamage);
pMonster->setHP(RemainHP, ATTR_CURRENT);
if(m_CasterName != "" ) {
// 시전자의 데미지를 추가해 준다.
// 맞는 놈이 몬스터이고, 공격자가 사람이라면,
// 데미지에 따라서 변하는 우선권 테이블을 갱신해 주어야 한다.
pMonster->addPrecedence(m_CasterName, m_PartyID, AcidDamage);
pMonster->setLastHitCreatureClass(Creature::CREATURE_CLASS_VAMPIRE);
}
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pMonster->getObjectID());
pkt.setCurrentHP(RemainHP);
m_pZone->broadcastPacket(pMonster->getX(), pMonster->getY(), &pkt);
}
// m_CasterName이 pCreature를 죽인 경우의 KillCount 처리
// by sigi. 2002.8.31
if (pCreature->isDead())
{
Creature* pAttacker = m_pZone->getCreature(m_CasterName);
if (pAttacker!=NULL)
{
affectKillCount(pAttacker, pCreature);
}
}
}
}
}
// 한번만..
//setNextTime(m_Tick);
//cout << "EffectBloodyWallBlocked" << "affect END" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void DarkBluePoison::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
{
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, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
return;
}
GCSkillToObjectOK1 _GCSkillToObjectOK1;
GCSkillToObjectOK2 _GCSkillToObjectOK2;
GCSkillToObjectOK3 _GCSkillToObjectOK3;
GCSkillToObjectOK4 _GCSkillToObjectOK4;
GCSkillToObjectOK5 _GCSkillToObjectOK5;
GCSkillToObjectOK6 _GCSkillToObjectOK6;
SkillType_t SkillType = pVampireSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
// Knowledge of Poison 이 있다면 hit bonus 10
int HitBonus = 0;
if (pVampire->hasRankBonus(RankBonus::RANK_BONUS_KNOWLEDGE_OF_POISON ) )
{
RankBonus* pRankBonus = pVampire->getRankBonus(RankBonus::RANK_BONUS_KNOWLEDGE_OF_POISON);
Assert(pRankBonus != NULL);
HitBonus = pRankBonus->getPoint();
}
int RequiredMP = decreaseConsumeMP(pVampire, pSkillInfo);
bool bManaCheck = hasEnoughMana(pVampire, RequiredMP);
bool bTimeCheck = verifyRunTime(pVampireSkillSlot);
bool bRangeCheck = verifyDistance(pVampire, pTargetCreature, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessMagic(pVampire, pSkillInfo, pVampireSkillSlot, HitBonus);
bool bEffected = pTargetCreature->isFlag(Effect::EFFECT_CLASS_DARKBLUE_POISON);
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 && !bEffected)
{
decreaseMana(pVampire, RequiredMP, _GCSkillToObjectOK1);
bool bCanSeeCaster = canSee(pTargetCreature, pVampire);
SkillInput input(pVampire);
SkillOutput output;
computeOutput(input, output);
Damage_t Damage = computeMagicDamage(pTargetCreature, output.Damage, SkillType, true, pVampire);
// 아우스터즈는 절반의 시간만 받는다.
if (pTargetCreature->isOusters() ) output.Duration/=2;
// 이펙트 오브젝트를 생성해서 붙인다.
EffectDarkBluePoison* pEffectDarkBluePoison = new EffectDarkBluePoison(pTargetCreature);
pEffectDarkBluePoison->setDamage(Damage);
pEffectDarkBluePoison->setLevel(pSkillInfo->getLevel()/2);
pEffectDarkBluePoison->setDeadline(output.Duration);
pEffectDarkBluePoison->setTick(output.Tick);
pEffectDarkBluePoison->setNextTime(0);
pTargetCreature->addEffect(pEffectDarkBluePoison);
pTargetCreature->setFlag(Effect::EFFECT_CLASS_DARKBLUE_POISON);
// 이펙트가 붙었으니, 붙었다고 브로드캐스팅해준다.
GCAddEffect gcAddEffect;
gcAddEffect.setObjectID(pTargetCreature->getObjectID());
gcAddEffect.setEffectID(Effect::EFFECT_CLASS_DARKBLUE_POISON);
gcAddEffect.setDuration(output.Duration);
pZone->broadcastPacket(targetX, targetY, &gcAddEffect);
if (bCanSeeCaster)
{
decreaseDurability(pVampire, pTargetCreature, pSkillInfo, &_GCSkillToObjectOK1, &_GCSkillToObjectOK2);
}
else
{
decreaseDurability(pVampire, pTargetCreature, pSkillInfo, &_GCSkillToObjectOK1, &_GCSkillToObjectOK6);
}
_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);
_GCSkillToObjectOK5.setObjectID(pVampire->getObjectID());
_GCSkillToObjectOK5.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK5.setSkillType(SkillType);
_GCSkillToObjectOK5.setDuration(output.Duration);
_GCSkillToObjectOK6.setXY(vampX, vampY);
_GCSkillToObjectOK6.setSkillType(SkillType);
_GCSkillToObjectOK6.setDuration(output.Duration);
pPlayer->sendPacket(&_GCSkillToObjectOK1);
if (pTargetCreature->isPC())
{
Player* 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(output.Delay);
}
else
{
executeSkillFailNormal(pVampire, getSkillType(), pTargetCreature);
}
}
catch(Throwable & t)
{
executeSkillFailException(pVampire, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void DarkBluePoison::execute(Monster* pMonster, Creature* pEnemy)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << "begin " << endl;
Assert(pMonster != NULL);
Assert(pEnemy != NULL);
try
{
Zone* pZone = pMonster->getZone();
Assert(pZone != NULL);
GCSkillToObjectOK2 _GCSkillToObjectOK2;
GCSkillToObjectOK3 _GCSkillToObjectOK3;
GCSkillToObjectOK4 _GCSkillToObjectOK4;
GCSkillToObjectOK5 _GCSkillToObjectOK5;
GCSkillToObjectOK6 _GCSkillToObjectOK6;
SkillType_t SkillType = SKILL_DARKBLUE_POISON;
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
bool bRangeCheck = verifyDistance(pMonster, pEnemy, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessMagic(pMonster, pSkillInfo);
bool bEffected = pEnemy->isFlag(Effect::EFFECT_CLASS_DARKBLUE_POISON);
ZoneCoord_t vampX = pMonster->getX();
ZoneCoord_t vampY = pMonster->getY();
ZoneCoord_t targetX = pEnemy->getX();
ZoneCoord_t targetY = pEnemy->getY();
if (bRangeCheck && bHitRoll && !bEffected)
{
bool bCanSeeCaster = canSee(pEnemy, pMonster);
SkillInput input(pMonster);
SkillOutput output;
computeOutput(input, output);
Damage_t Damage = computeMagicDamage(pEnemy, output.Damage, SkillType);
// 이펙트 오브젝트를 생성해서 붙인다.
EffectDarkBluePoison* pEffectDarkBluePoison = new EffectDarkBluePoison(pEnemy);
pEffectDarkBluePoison->setDamage(Damage);
pEffectDarkBluePoison->setLevel(pSkillInfo->getLevel()/2);
pEffectDarkBluePoison->setDeadline(output.Duration);
pEffectDarkBluePoison->setTick(output.Tick);
pEffectDarkBluePoison->setNextTime(0);
pEnemy->addEffect(pEffectDarkBluePoison);
pEnemy->setFlag(Effect::EFFECT_CLASS_DARKBLUE_POISON);
// 이펙트가 붙었으니, 붙었다고 브로드캐스팅해준다.
GCAddEffect gcAddEffect;
gcAddEffect.setObjectID(pEnemy->getObjectID());
gcAddEffect.setEffectID(Effect::EFFECT_CLASS_DARKBLUE_POISON);
gcAddEffect.setDuration(output.Duration);
pZone->broadcastPacket(targetX, targetY, &gcAddEffect);
if (bCanSeeCaster)
{
decreaseDurability(pMonster, pEnemy, pSkillInfo, NULL, &_GCSkillToObjectOK2);
}
else
{
decreaseDurability(pMonster, pEnemy, pSkillInfo, NULL, &_GCSkillToObjectOK6);
}
_GCSkillToObjectOK2.setObjectID(pMonster->getObjectID());
_GCSkillToObjectOK2.setSkillType(SkillType);
_GCSkillToObjectOK2.setDuration(output.Duration);
_GCSkillToObjectOK3.setObjectID(pMonster->getObjectID());
_GCSkillToObjectOK3.setSkillType(SkillType);
_GCSkillToObjectOK3.setTargetXY(targetX, targetY);
_GCSkillToObjectOK4.setSkillType(SkillType);
_GCSkillToObjectOK4.setTargetObjectID(pEnemy->getObjectID());
_GCSkillToObjectOK5.setObjectID(pMonster->getObjectID());
_GCSkillToObjectOK5.setTargetObjectID(pEnemy->getObjectID());
_GCSkillToObjectOK5.setSkillType(SkillType);
_GCSkillToObjectOK5.setDuration(output.Duration);
_GCSkillToObjectOK6.setXY(vampX, vampY);
_GCSkillToObjectOK6.setSkillType(SkillType);
_GCSkillToObjectOK6.setDuration(output.Duration);
if (pEnemy->isPC())
{
Player* pTargetPlayer = pEnemy->getPlayer();
if (pTargetPlayer == NULL)
{
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
return;
}
if (bCanSeeCaster) pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
else pTargetPlayer->sendPacket(&_GCSkillToObjectOK6);
}
else
{
Monster* pTargetMonster = dynamic_cast<Monster*>(pEnemy);
pTargetMonster->addEnemy(pMonster);
}
list<Creature*> cList;
cList.push_back(pMonster);
cList.push_back(pEnemy);
cList = pZone->broadcastSkillPacket(vampX, vampY, targetX, targetY, &_GCSkillToObjectOK5, cList);
pZone->broadcastPacket(vampX, vampY, &_GCSkillToObjectOK3 , cList);
pZone->broadcastPacket(targetX, targetY, &_GCSkillToObjectOK4 , cList);
}
else
{
executeSkillFailNormal(pMonster, getSkillType(), pEnemy);
}
}
catch(Throwable & t)
{
executeSkillFailException(pMonster, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
