/*******************************************************************
*
* 暫定の座標結果を算出
*
*******************************************************************/
void ElevatorAlgorithm::InterimResults()
{
m_SearchCount++;//呼ばれたので進める
//反射の確認
CheckReflection();
//計算
m_NextArray.x += m_SearchCount * m_ReflectValue;
}
//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void Paralyze::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);
SkillType_t SkillType = pVampireSkillSlot->getSkillType();
// NPC는 공격할 수가 없다.
// 면역이거나. by sigi. 2002.9.13
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL
|| pTargetCreature->isFlag(Effect::EFFECT_CLASS_IMMUNE_TO_PARALYZE)
|| !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;
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();
}
Tile& rTile = pZone->getTile(pTargetCreature->getX(), pTargetCreature->getY());
int RequiredMP = decreaseConsumeMP(pVampire, pSkillInfo);
bool bManaCheck = hasEnoughMana(pVampire, RequiredMP);
bool bTimeCheck = verifyRunTime(pVampireSkillSlot);
bool bRangeCheck = verifyDistance(pVampire, pTargetCreature, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessVampireCurse(pSkillInfo->getLevel(), pTargetCreature->getResist(MAGIC_DOMAIN_CURSE));
bool bHitRoll2 = HitRoll::isSuccessMagic(pVampire, pSkillInfo, pVampireSkillSlot, HitBonus);
bool bCanHit = canHit(pVampire, pTargetCreature, SkillType);
bool bEffected = pTargetCreature->isFlag(Effect::EFFECT_CLASS_PARALYZE) || rTile.getEffect(Effect::EFFECT_CLASS_TRYING_POSITION)!=NULL;
bool bPK = verifyPK(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 && bHitRoll2 && bCanHit && !bEffected && bPK)
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bHitRoll2 && bCanHit && !bEffected && bPK && pTargetCreature->getCompetence() == 3)
{
decreaseMana(pVampire, RequiredMP, _GCSkillToObjectOK1);
bool bCanSeeCaster = canSee(pTargetCreature, pVampire);
SkillInput input(pVampire);
SkillOutput output;
computeOutput(input, output);
// Wisdom of Silence 이 있다면 지속시간 20% 증가
if (pVampire->hasRankBonus(RankBonus::RANK_BONUS_WISDOM_OF_SILENCE ) )
{
RankBonus* pRankBonus = pVampire->getRankBonus(RankBonus::RANK_BONUS_WISDOM_OF_SILENCE);
Assert(pRankBonus != NULL);
output.Duration += getPercentValue(output.Duration, pRankBonus->getPoint());
}
// pTargetCreature가 저주마법을 반사하는 경우
if (CheckReflection(pVampire, pTargetCreature, getSkillType()))
{
pTargetCreature = (Creature*)pVampire;
TargetObjectID = pVampire->getObjectID();
}
Resist_t resist = pTargetCreature->getResist(MAGIC_DOMAIN_CURSE);
if (resist > output.Duration ) resist = output.Duration;
output.Duration -= resist;
if (output.Duration < 20 ) output.Duration = 20;
// 이펙트 오브젝트를 생성해서 붙인다.
EffectParalyze* pEffectParalyze = new EffectParalyze(pTargetCreature);
pEffectParalyze->setLevel(pSkillInfo->getLevel()/2);
// pEffectParalyze->setDefensePenalty(output.Damage);
pEffectParalyze->setDeadline(output.Duration);
pTargetCreature->addEffect(pEffectParalyze);
pTargetCreature->setFlag(Effect::EFFECT_CLASS_PARALYZE);
if (pTargetCreature->isFlag(Effect::EFFECT_CLASS_BURNING_SOL_CHARGE_1 ) )
{
Effect* pEffect = pTargetCreature->findEffect(Effect::EFFECT_CLASS_BURNING_SOL_CHARGE_1);
if (pEffect != NULL ) pEffect->setDeadline(0);
}
// 저주에 걸리면 디펜스가 떨어진다.
// 디펜스 페널티가 없어짐. 2002.05.09 - by bezz
/* if (pTargetCreature->isSlayer())
{
Slayer* pTargetSlayer = dynamic_cast<Slayer*>(pTargetCreature);
SLAYER_RECORD prev;
pTargetSlayer->getSlayerRecord(prev);
pTargetSlayer->initAllStat();
pTargetSlayer->addModifyInfo(prev, _GCSkillToObjectOK2);
}
else if (pTargetCreature->isVampire())
{
Vampire* pTargetVampire = dynamic_cast<Vampire*>(pTargetCreature);
VAMPIRE_RECORD prev;
pTargetVampire->getVampireRecord(prev);
pTargetVampire->initAllStat();
pTargetVampire->addModifyInfo(prev, _GCSkillToObjectOK2);
}
else if (pTargetCreature->isMonster())
{
Monster* pTargetMonster = dynamic_cast<Monster*>(pTargetCreature);
pTargetMonster->initAllStat();
}
else Assert(false);
*/
// 이펙트가 붙었다는 것을 브로드캐스팅해준다.
GCAddEffect gcAddEffect;
gcAddEffect.setObjectID(pTargetCreature->getObjectID());
gcAddEffect.setEffectID(Effect::EFFECT_CLASS_PARALYZE);
gcAddEffect.setDuration(output.Duration);
pZone->broadcastPacket(targetX, targetY, &gcAddEffect);
_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);
if (bCanSeeCaster) // 10은 땜빵 수치다.
{
computeAlignmentChange(pTargetCreature, 10, pVampire, &_GCSkillToObjectOK2, &_GCSkillToObjectOK1);
}
else // 10은 땜빵 수치다.
{
computeAlignmentChange(pTargetCreature, 10, pVampire, &_GCSkillToObjectOK6, &_GCSkillToObjectOK1);
}
pPlayer->sendPacket(&_GCSkillToObjectOK1);
if (pTargetCreature->isPC())
{
Player* pTargetPlayer = pTargetCreature->getPlayer();
Assert(pTargetPlayer != NULL);
if (bCanSeeCaster) pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
else pTargetPlayer->sendPacket(&_GCSkillToObjectOK6);
}
else
{
Monster* pTargetMonster = dynamic_cast<Monster*>(pTargetCreature);
pTargetMonster->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 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 Hallucination::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는 공격할 수 없다.
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL
|| !canAttack(pVampire, pTargetCreature )
|| pTargetCreature->isFlag(Effect::EFFECT_CLASS_IMMUNE_TO_HALLUCINATION)
|| 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);
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::isSuccessHallucination(pVampire, pTargetCreature);
bool bCanHit = canHit(pVampire, pTargetCreature, SkillType);
bool bEffected = pTargetCreature->isFlag(Effect::EFFECT_CLASS_HALLUCINATION);
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();
}
// 이펙트 오브젝트를 생성해 붙인다.
EffectHallucination* pEffect = new EffectHallucination(pTargetCreature);
pEffect->setDeadline(output.Duration);
pEffect->setLevel(pSkillInfo->getLevel()/2);
pTargetCreature->addEffect(pEffect);
pTargetCreature->setFlag(Effect::EFFECT_CLASS_HALLUCINATION);
_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_HALLUCINATION);
gcAddEffect.setDuration(output.Duration);
pZone->broadcastPacket(targetX, targetY, &gcAddEffect);
pSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pVampire, getSkillType(), pTargetCreature);
}
}
catch (Throwable & t)
{
executeSkillFailException(pVampire, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
