std::vector<std::vector<cv::Point> >
LibVision::findCandidates(std::vector<std::vector<cv::Point> > contours,
uint vertexCount) {
static std::vector<cv::Point> approxCurve;
std::vector<std::vector<cv::Point> > candidates;
for (int i = 0; i < contours.size(); i++) {
if (vertexCount == 1000) {
// Circles
cv::approxPolyDP(contours[i], approxCurve, 3, true);
if (approxCurve.size() > 8) {
candidates.push_back(approxCurve);
}
} else {
// Others
cv::approxPolyDP(contours[i], approxCurve,
cv::arcLength(cv::Mat(contours[i]), true) * 0.02, true);
if (approxCurve.size() == vertexCount &&
cv::isContourConvex(approxCurve)) {
if (verifyDistance(approxCurve[0], approxCurve[2])) {
candidates.push_back(approxCurve);
}
}
}
approxCurve.clear();
}
return candidates;
}
//////////////////////////////////////////////////////////////////////////////
// 슬레이어 오브젝트
//////////////////////////////////////////////////////////////////////////////
void JabbingVein::execute (Slayer* pSlayer, ObjectID_t TargetObjectID, SkillSlot* pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY __BEGIN_DEBUG
//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
|| !canAttack(pSlayer, pTargetCreature )
|| pTargetCreature->isNPC())
{
executeSkillFailException(pSlayer, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
GCAttackArmsOK1 _GCAttackArmsOK1;
GCAttackArmsOK2 _GCAttackArmsOK2;
GCAttackArmsOK3 _GCAttackArmsOK3;
GCAttackArmsOK4 _GCAttackArmsOK4;
GCAttackArmsOK5 _GCAttackArmsOK5;
// 들고 있는 무기가 없거나, 총 계열 무기가 아니라면 기술을 쓸 수 없다.
// 총 계열 무기 중에서도 SG나 SR은 JabbingVein를 쓸 수가 없다.
// SG, SR 도 이제 쓸 수 있다.
// 2003. 1. 14 by bezz
Item* pWeapon = pSlayer->getWearItem(Slayer::WEAR_RIGHTHAND);
if (pWeapon == NULL || isArmsWeapon(pWeapon) == false )
// pWeapon->getItemClass() == Item::ITEM_CLASS_SG ||
// pWeapon->getItemClass() == Item::ITEM_CLASS_SR)
{
executeSkillFailException(pSlayer, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
bool bIncreaseExp = pSlayer->isRealWearingEx(Slayer::WEAR_RIGHTHAND);
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
SkillDomainType_t DomainType = pSkillInfo->getDomainType();
SkillLevel_t SkillLevel = pSkillSlot->getExpLevel();
SkillInput input(pSlayer, pSkillSlot);
SkillOutput output;
if (pTargetCreature->isPC() )
{
input.TargetType = SkillInput::TARGET_PC;
}
else
{
input.TargetType = SkillInput::TARGET_MONSTER;
}
computeOutput(input, output);
// 페널티 값을 계산한다.
int ToHitPenalty = getPercentValue(pSlayer->getToHit(), output.ToHit);
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pSlayer, pTargetCreature, pWeapon->getRange());
bool bBulletCheck = (getRemainBullet(pWeapon) > 0) ? true : false;
bool bHitRoll = HitRoll::isSuccess(pSlayer, pTargetCreature, ToHitPenalty);
bool bPK = verifyPK(pSlayer, pTargetCreature);
// 총알 숫자는 무조건 떨어뜨린다.
Bullet_t RemainBullet = 0;
if (bBulletCheck)
{
// 총알 숫자를 떨어뜨리고, 저장하고, 남은 총알 숫자를 받아온다.
decreaseBullet(pWeapon);
// 한발쓸때마다 저장할 필요 없다. by sigi. 2002.5.9
//pWeapon->save(pSlayer->getName(), STORAGE_GEAR, 0, Slayer::WEAR_RIGHTHAND, 0);
RemainBullet = getRemainBullet(pWeapon);
}
if (bManaCheck && bTimeCheck && bRangeCheck && bBulletCheck && bHitRoll && bPK)
{
//cout << pSlayer->getName().c_str() << " Attack OK" << endl;
decreaseMana(pSlayer, RequiredMP, _GCAttackArmsOK1);
_GCAttackArmsOK5.setSkillSuccess(true);
_GCAttackArmsOK1.setSkillSuccess(true);
bool bCriticalHit = false;
// 데미지를 계산하고, quickfire 페널티를 가한다.
// output.Damage가 음수이기 때문에, %값을 구해 더하면 결국 빼는 것이 된다.
int Damage = computeDamage(pSlayer, pTargetCreature, SkillLevel/5, bCriticalHit);
Damage += getPercentValue(Damage, output.Damage);
Damage = max(0, Damage);
//cout << "JabbingVeinDamage:" << Damage << endl;
// 데미지를 세팅한다.
setDamage(pTargetCreature, Damage, pSlayer, SkillType, &_GCAttackArmsOK2, &_GCAttackArmsOK1);
computeAlignmentChange(pTargetCreature, Damage, pSlayer, &_GCAttackArmsOK2, &_GCAttackArmsOK1);
bool bAffect = true;
if (pTargetCreature->isMonster())
{
Monster* pMonster = dynamic_cast<Monster*>(pTargetCreature);
if (pMonster->isMaster() ) bAffect = false;
}
if (bAffect && !pTargetCreature->isFlag(Effect::EFFECT_CLASS_JABBING_VEIN) && rand()%100 < output.Range )
{
EffectJabbingVein* pEffect = new EffectJabbingVein(pTargetCreature);
pEffect->setDeadline(output.Duration);
pTargetCreature->addEffect(pEffect);
pTargetCreature->setFlag(pEffect->getEffectClass());
GCAddEffect gcAddEffect;
gcAddEffect.setObjectID(pTargetCreature->getObjectID());
gcAddEffect.setEffectID(pEffect->getSendEffectClass());
gcAddEffect.setDuration(output.Duration);
pZone->broadcastPacket(pTargetCreature->getX(), pTargetCreature->getY(), &gcAddEffect);
}
// 크리티컬 히트라면 상대방을 뒤로 물러나게 한다.
if (bCriticalHit)
{
knockbackCreature(pZone, pTargetCreature, pSlayer->getX(), pSlayer->getY());
}
if(!pTargetCreature->isSlayer() )
{
if (bIncreaseExp)
{
shareAttrExp(pSlayer, Damage , 1, 8, 1, _GCAttackArmsOK1);
increaseDomainExp(pSlayer, DomainType, pSkillInfo->getPoint(), _GCAttackArmsOK1, pTargetCreature->getLevel());
increaseSkillExp(pSlayer, DomainType, pSkillSlot, pSkillInfo, _GCAttackArmsOK1);
}
increaseAlignment(pSlayer, pTargetCreature, _GCAttackArmsOK1);
}
//}
if (pTargetCreature->isPC())
{
Player* pTargetPlayer = pTargetCreature->getPlayer();
if (pTargetPlayer != NULL)
{
_GCAttackArmsOK2.setObjectID(getSkillType());
_GCAttackArmsOK2.setObjectID(pSlayer->getObjectID());
pTargetPlayer->sendPacket(&_GCAttackArmsOK2);
}
}
else if (pTargetCreature->isMonster())
{
Monster* pMonster = dynamic_cast<Monster*>(pTargetCreature);
pMonster->addEnemy(pSlayer);
}
// 공격자와 상대의 아이템 내구성 떨어트림.
decreaseDurability(pSlayer, pTargetCreature, NULL, &_GCAttackArmsOK1, &_GCAttackArmsOK2);
ZoneCoord_t targetX = pTargetCreature->getX();
ZoneCoord_t targetY = pTargetCreature->getY();
ZoneCoord_t myX = pSlayer->getX();
ZoneCoord_t myY = pSlayer->getY();
_GCAttackArmsOK1.setSkillType(getSkillType());
_GCAttackArmsOK1.setObjectID(TargetObjectID);
_GCAttackArmsOK1.setBulletNum(RemainBullet);
_GCAttackArmsOK3.setSkillType(getSkillType());
_GCAttackArmsOK3.setObjectID(pSlayer->getObjectID());
_GCAttackArmsOK3.setTargetXY (targetX, targetY);
_GCAttackArmsOK4.setSkillType(getSkillType());
_GCAttackArmsOK4.setTargetObjectID (TargetObjectID);
_GCAttackArmsOK5.setSkillType(getSkillType());
_GCAttackArmsOK5.setObjectID(pSlayer->getObjectID());
_GCAttackArmsOK5.setTargetObjectID (TargetObjectID);
pPlayer->sendPacket(&_GCAttackArmsOK1);
list<Creature *> cList;
cList.push_back(pTargetCreature);
cList.push_back(pSlayer);
cList = pZone->broadcastSkillPacket(myX, myY, targetX, targetY, &_GCAttackArmsOK5, cList);
pZone->broadcastPacket(myX, myY, &_GCAttackArmsOK3, cList);
pZone->broadcastPacket(targetX, targetY, &_GCAttackArmsOK4, cList);
pSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormalWithGun(pSlayer, getSkillType(), pTargetCreature, RemainBullet);
//cout << pSlayer->getName().c_str() << " Fail : "
// << (int)bManaCheck << (int)bTimeCheck << (int)bRangeCheck
// << (int)bBulletCheck << (int)bHitRoll << (int)bPK << endl;
}
}
catch (Throwable &t)
{
executeSkillFailException(pSlayer, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_DEBUG __END_CATCH
}
//////////////////////////////////////////////////////////////////////
//
// Visible::execute()
//
//////////////////////////////////////////////////////////////////////
void Visible::execute(Slayer * pSlayer, ZoneCoord_t X, ZoneCoord_t Y, SkillSlot * pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pSlayer != NULL);
Assert(pSkillSlot != NULL);
try
{
// Player를 받아온다.
Player * pPlayer = pSlayer->getPlayer();
// Zone을 받아온다.
Zone * pZone = pSlayer->getZone();
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo * pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
// 기술의 레벨을 받아온다.
//SkillLevel_t SkillLevel = pSkillSlot->getExpLevel();
//SkillDomainType_t DomainType = pSkillInfo->getDomainType();
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pSlayer, X, Y, pSkillInfo->getRange());
bool bHit = false;
// 기술성공률 검증.
if (bManaCheck && bTimeCheck && bRangeCheck)
{
SkillInput input(pSlayer, pSkillSlot);
SkillOutput output;
computeOutput(input, output);
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
Coord_t myX = pSlayer->getX(), myY = pSlayer->getY();
Dir_t dir = calcDirection(myX, myY, X, Y);
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;
if (!rect.ptInRect(tileX, tileY)) continue;
Tile& tile = pZone->getTile(tileX, tileY);
Creature * 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)
}
decreaseMana(pSlayer, RequiredMP, _GCSkillToTileOK1);
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 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(
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 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 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 Liberty::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
{
Player* pPlayer = pOusters->getPlayer();
Zone* pZone = pOusters->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
Item* pWeapon = pOusters->getWearItem(Ousters::WEAR_RIGHTHAND);
if (pWeapon == NULL || pWeapon->getItemClass() != Item::ITEM_CLASS_OUSTERS_WRISTLET || !pOusters->isRealWearingEx(Ousters::WEAR_RIGHTHAND))
{
executeSkillFailException(pOusters, pOustersSkillSlot->getSkillType());
return;
}
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL
|| !pTargetCreature->isOusters())
{
executeSkillFailException(pOusters, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
return;
}
Ousters* pTargetOusters = dynamic_cast<Ousters*>(pTargetCreature);
GCSkillToObjectOK1 _GCSkillToObjectOK1;
GCSkillToObjectOK2 _GCSkillToObjectOK2;
GCSkillToObjectOK5 _GCSkillToObjectOK5;
SkillType_t SkillType = pOustersSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
int RequiredMP = (int)pSkillInfo->getConsumeMP() + pOustersSkillSlot->getExpLevel()/3;
bool bManaCheck = hasEnoughMana(pOusters, RequiredMP);
bool bTimeCheck = verifyRunTime(pOustersSkillSlot);
bool bRangeCheck = verifyDistance(pOusters, pTargetCreature, pSkillInfo->getRange()) && canHit(pOusters, pTargetCreature, SkillType, pOustersSkillSlot->getExpLevel());
bool bHitRoll = HitRoll::isSuccessMagic(pOusters, pSkillInfo, pOustersSkillSlot);
bool bSatisfyRequire = pOusters->satisfySkillRequire(pSkillInfo);
bool bHPCheck = pTargetOusters->isFlag(Effect::EFFECT_CLASS_PARALYZE);
int Ratio = 0;
EffectParalyze* pEffect = dynamic_cast<EffectParalyze*>(pTargetOusters->findEffect(Effect::EFFECT_CLASS_PARALYZE ));
if (pEffect != NULL )
{
if (pOustersSkillSlot->getExpLevel() <= 15 )
{
Ratio = (int)((pOusters->getLevel() + (pOustersSkillSlot->getExpLevel() * 8.0 / 3.0 ) ) - pEffect->getLevel());
}
else
{
Ratio = (int)((pOusters->getLevel() + 20 + (pOustersSkillSlot->getExpLevel() * 4.0 / 3.0 ) ) - pEffect->getLevel());
if (pOustersSkillSlot->getExpLevel() == 30 ) Ratio = (int)(Ratio * 1.1);
}
}
bool bHitRoll2 = (rand()%100) < Ratio;
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bHitRoll2 && bSatisfyRequire && bHPCheck)
{
// 마나를 줄인다.
decreaseMana(pOusters, RequiredMP, _GCSkillToObjectOK1);
// 이펙트의 효과와 지속시간을 계산한다.
SkillInput input(pOusters, pOustersSkillSlot);
SkillOutput output;
input.TargetType = SkillInput::TARGET_OTHER;
computeOutput(input, output);
pEffect->setDeadline(0);
// 패킷을 준비해서 보낸다.
_GCSkillToObjectOK1.setSkillType(SkillType);
_GCSkillToObjectOK1.setCEffectID(CEffectID);
_GCSkillToObjectOK1.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK2.setObjectID(pOusters->getObjectID());
_GCSkillToObjectOK2.setSkillType(SkillType);
_GCSkillToObjectOK5.setObjectID(pOusters->getObjectID());
_GCSkillToObjectOK5.setSkillType(SkillType);
_GCSkillToObjectOK5.setTargetObjectID (TargetObjectID);
// Send Packet
pPlayer->sendPacket(&_GCSkillToObjectOK1);
if (pOusters != pTargetCreature && pTargetCreature->isPC())
{
Player* pTargetPlayer = pTargetCreature->getPlayer();
Assert(pTargetPlayer != NULL);
pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
}
list<Creature*> cList;
cList.push_back(pOusters);
cList.push_back(pTargetCreature);
pZone->broadcastPacket(pOusters->getX(), pOusters->getY(), &_GCSkillToObjectOK5 , cList);
pOustersSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pOusters, getSkillType(), pTargetCreature);
}
}
catch (Throwable & t)
{
executeSkillFailException(pOusters, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
void Flare::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);
// NPC이거나, 슬레이어에게는 Flare를 쓸 수가 없다.
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL
|| pTargetCreature->isNPC() || pTargetCreature->isSlayer())
{
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();
SkillLevel_t SkillLevel = pSkillSlot->getExpLevel();
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pSlayer, pTargetCreature, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessFlare(pTargetCreature, SkillLevel) && canAttack(pSlayer, pTargetCreature);
bool bEffected = pTargetCreature->isFlag(Effect::EFFECT_CLASS_FLARE);
//if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && !bEffected)
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && !bEffected && pTargetCreature->getCompetence() == 3)
{
decreaseMana(pSlayer, RequiredMP, _GCSkillToObjectOK1);
// 지속 시간을 계산한다.
SkillInput input(pSlayer, pSkillSlot);
SkillOutput output;
computeOutput(input, output);
// 이펙트 클래스를 만들어 붙인다.
EffectFlare* pEffect = new EffectFlare(pTargetCreature);
//pEffect->setOldSight(13);
pEffect->setOldSight(pTargetCreature->getSight());
// 제거할때 level체크하기 위햇서.by sigi. 2002.6.21
pEffect->setLevel(pSkillInfo->getLevel());
pEffect->setDeadline(output.Duration);
pTargetCreature->setFlag(Effect::EFFECT_CLASS_FLARE);
pTargetCreature->addEffect(pEffect);
// 이펙트를 적용시킨다.
pEffect->affect(pTargetCreature);
// 경험치를 올린다.
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 targetX = pTargetCreature->getX();
ZoneCoord_t targetY = pTargetCreature->getY();
ZoneCoord_t myX = pSlayer->getX();
ZoneCoord_t myY = pSlayer->getY();
_GCSkillToObjectOK1.setSkillType(SkillType);
_GCSkillToObjectOK1.setCEffectID(CEffectID);
_GCSkillToObjectOK1.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK1.setDuration(0);
_GCSkillToObjectOK2.setObjectID(pSlayer->getObjectID());
_GCSkillToObjectOK2.setSkillType(SkillType);
_GCSkillToObjectOK2.addShortData(MODIFY_VISION, FLARE_SIGHT);
_GCSkillToObjectOK2.setDuration(0);
_GCSkillToObjectOK3.setObjectID(pSlayer->getObjectID());
_GCSkillToObjectOK3.setSkillType(SkillType);
_GCSkillToObjectOK3.setTargetXY (targetX, targetY);
_GCSkillToObjectOK4.setSkillType(SkillType);
_GCSkillToObjectOK4.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK4.setDuration(0);
_GCSkillToObjectOK5.setObjectID(pSlayer->getObjectID());
_GCSkillToObjectOK5.setSkillType(SkillType);
_GCSkillToObjectOK5.setTargetObjectID (TargetObjectID);
_GCSkillToObjectOK5.setDuration(0);
list<Creature *> cList;
cList.push_back(pTargetCreature);
cList.push_back(pSlayer);
cList = pZone->broadcastSkillPacket(myX, myY, targetX, targetY, &_GCSkillToObjectOK5, cList);
pZone->broadcastPacket(myX, myY, &_GCSkillToObjectOK3, cList);
pZone->broadcastPacket(targetX, targetY, &_GCSkillToObjectOK4, cList);
pPlayer->sendPacket(&_GCSkillToObjectOK1);
if (pTargetCreature->isPC())
{
Player* pTargetPlayer = pTargetCreature->getPlayer();
Assert(pTargetPlayer != NULL);
pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
}
else
{
Monster* pMonster = dynamic_cast<Monster*>(pTargetCreature);
pMonster->addEnemy(pSlayer);
}
GCAddEffect gcAddEffect;
gcAddEffect.setObjectID(TargetObjectID);
gcAddEffect.setEffectID(Effect::EFFECT_CLASS_FLARE);
gcAddEffect.setDuration(output.Duration);
pZone->broadcastPacket(targetX, targetY, &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
}
//////////////////////////////////////////////////////////////////////////////
// 슬레이어 타일 핸들러
//////////////////////////////////////////////////////////////////////////////
void MagicElusion::execute(Slayer* pSlayer, ZoneCoord_t X, ZoneCoord_t Y, SkillSlot* pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pSlayer != NULL);
Assert(pSkillSlot != NULL);
try
{
Player* pPlayer = pSlayer->getPlayer();
Zone* pZone = pSlayer->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
ZoneCoord_t myX = pSlayer->getX();
ZoneCoord_t myY = pSlayer->getY();
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pSlayer, X, Y, pSkillInfo->getRange()) && checkZoneLevelToUseSkill(pSlayer);
bool bHitRoll = HitRoll::isSuccessMagicElusion(pSlayer);
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
if (rect.ptInRect(X, Y)) bTileCheck = true;
// 이펙트의 지속시간을 계산한다.
SkillInput input(pSlayer, pSkillSlot);
SkillOutput output;
computeOutput(input, output);
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bTileCheck)
{
decreaseMana(pSlayer, RequiredMP, _GCSkillToTileOK1);
Range_t Range = 2;
int oX, oY;
list<Creature*> cList; // denier list
ObjectRegistry & objectregister = pZone->getObjectRegistry();
// 일단 이미 sanctuary가 있는지 검색한다.
for(oY = -1; oY <= 1; oY++)
for(oX = -1; oX <= 1; oX++)
{
int tileX = X+oX;
int tileY = Y+oY;
if (rect.ptInRect(tileX, tileY))
{
Tile& tile = pZone->getTile(tileX, tileY);
if (tile.canAddEffect())
{
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_MAGIC_ELUSION);
// 이미 있다면
// 기술 실패다.
if (pOldEffect != NULL)
{
executeSkillFailNormal(pSlayer, getSkillType(), NULL);
return;
}
}
else
{
executeSkillFailNormal(pSlayer, getSkillType(), NULL);
return;
}
}
}
for(oY = -1; oY <= 1; oY++)
for(oX = -1; oX <= 1; oX++)
{
int tileX = X+oX;
int tileY = Y+oY;
if (rect.ptInRect(tileX, tileY))
{
Tile& tile = pZone->getTile(tileX, tileY);
// 이펙트 클래스를 생성한다.
EffectMagicElusion* pEffect = new EffectMagicElusion(pZone , tileX, tileY);
pEffect->setDeadline(output.Duration);
// Tile에 붙이는 Effect는 ObjectID를 등록받아야 한다.
objectregister.registerObject(pEffect);
pZone->addEffect(pEffect);
tile.addEffect(pEffect);
if (oX==0 && oY==0)
{
pEffect->setBroadcastingEffect(true);
GCAddEffectToTile gcAddEffectToTile;
gcAddEffectToTile.setEffectID(pEffect->getEffectClass());
gcAddEffectToTile.setObjectID(pEffect->getObjectID());
gcAddEffectToTile.setXY(X, Y);
gcAddEffectToTile.setDuration(output.Duration);
pZone->broadcastPacket(X, Y, &gcAddEffectToTile, pSlayer);
}
else
{
// 가운데 이펙트가 아니면 브로드캐스팅해주지 않는다.
pEffect->setBroadcastingEffect(false);
}
const list<Object*>& oList = tile.getObjectList();
for(list<Object*>::const_iterator itr = oList.begin(); itr != oList.end(); itr++)
{
Object* pTarget = *itr;
if (pTarget->getObjectClass() == Object::OBJECT_CLASS_CREATURE )
{
Creature* pCreature = dynamic_cast<Creature*>(pTarget);
Assert(pCreature != NULL);
if (pCreature->isVampire() )
{
Vampire* pVampire = dynamic_cast<Vampire*>(pCreature);
Assert(pVampire != NULL);
GCModifyInformation gcMI;
::setDamage(pVampire, output.Damage, pSlayer, pSkillSlot->getSkillType(), &gcMI);
pVampire->getPlayer()->sendPacket(&gcMI);
cList.push_back(pCreature);
}
else if (pCreature->isMonster() )
{
::setDamage(pCreature, output.Damage, pSlayer, pSkillSlot->getSkillType());
}
}
}
}
}
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setDuration(output.Duration);
_GCSkillToTileOK1.setRange(Range);
_GCSkillToTileOK2.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setDuration(output.Duration);
_GCSkillToTileOK2.setRange(Range);
_GCSkillToTileOK3.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setRange(Range);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK5.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setRange(Range);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK6.setOrgXY(myX, myY);
_GCSkillToTileOK6.setSkillType(SkillType);
_GCSkillToTileOK6.setX(X);
_GCSkillToTileOK6.setY(Y);
_GCSkillToTileOK6.setDuration(output.Duration);
_GCSkillToTileOK6.setRange(Range);
for(list<Creature*>::const_iterator itr = cList.begin(); itr != cList.end(); itr++)
{
Creature* pTargetCreature = *itr;
if (canSee(pTargetCreature, pSlayer)) pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK2);
else pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK6);
}
pPlayer->sendPacket(&_GCSkillToTileOK1);
cList.push_back(pSlayer);
list<Creature*> watcherList = pZone->getWatcherList(myX, myY, pSlayer);
// watcherList에서 cList에 속하지 않고, caster(pSlayer)를 볼 수 없는 경우는
// OK4를 보내고.. cList에 추가한다.
for(list<Creature*>::const_iterator itr = watcherList.begin(); itr != watcherList.end(); itr++)
{
bool bBelong = false;
for(list<Creature*>::const_iterator tItr = cList.begin(); tItr != cList.end(); tItr++)
if (*itr == *tItr)
bBelong = true;
Creature* pWatcher = (*itr);
if (bBelong == false && canSee(pWatcher, pSlayer) == false)
{
//Assert(pWatcher->isPC()); // 당연 PC다.. Zone::getWatcherList는 PC만 return한다
if (pWatcher->isPC())
{
pWatcher->getPlayer()->sendPacket(&_GCSkillToTileOK4);
cList.push_back(*itr);
}
}
}
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList, false);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
}
else
{
executeSkillFailNormal(pSlayer, getSkillType(), NULL);
}
if (bTimeCheck ) pSkillSlot->setRunTime(output.Delay);
}
catch (Throwable & t)
{
executeSkillFailException(pSlayer, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 슬레이어 타일 핸들러 - AR이나 SMG를 들고 있을 경우
//////////////////////////////////////////////////////////////////////////////
void MoleShot::ARSMGexecute(Slayer* pSlayer, ZoneCoord_t X, ZoneCoord_t Y, SkillSlot* pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " SGexecute Begin" << endl;
Assert(pSlayer != NULL);
Assert(pSkillSlot != NULL);
try
{
Player* pPlayer = pSlayer->getPlayer();
Zone* pZone = pSlayer->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(getSkillType());
SkillDomainType_t DomainType = pSkillInfo->getDomainType();
Level_t SkillLevel = pSkillSlot->getExpLevel();
Item* pWeapon = pSlayer->getWearItem(Slayer::WEAR_RIGHTHAND);
Assert(pWeapon != NULL);
bool bIncreaseExp = pSlayer->isRealWearingEx(Slayer::WEAR_RIGHTHAND);
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pSlayer, X, Y, pWeapon->getRange());
bool bBulletCheck = (getRemainBullet(pWeapon) > 0) ? true : false;
// 총알 숫자는 무조건 떨어뜨린다.
Bullet_t RemainBullet = 0;
if (bBulletCheck)
{
decreaseBullet(pWeapon);
// 한발쓸때마다 저장할 필요 없다. by sigi. 2002.5.9
// pWeapon->save(pSlayer->getName(), STORAGE_GEAR, 0, Slayer::WEAR_RIGHTHAND, 0);
RemainBullet = getRemainBullet(pWeapon);
}
// 데미지, 투힛 보너스, 좌표와 방향을 구한다.
int ToHitBonus = 0;
int DamageBonus = 0;
int ToHitPenalty = 0;
int DamagePenalty = 0;
ZoneCoord_t myX = pSlayer->getX();
ZoneCoord_t myY = pSlayer->getY();
Dir_t dir = calcDirection(myX, myY, X, Y);
bool bHit = false; // 한번이라도 맞았는가를 저장하기 위한 변수
Damage_t Damage = 0; // 마지막으로 입힌 데미지를 저장하기 위한 변수
// AR이나 SMG일 경우에는 2부터 시작해서 4까지의 splash 데미지를 입힌다.
int Splash = 1 + pSkillSlot->getExpLevel()/30 + 1;
if (bManaCheck && bTimeCheck && bRangeCheck && bBulletCheck)
{
decreaseMana(pSlayer, RequiredMP, _GCSkillToTileOK1);
SkillInput input(pSlayer, pSkillSlot);
SkillOutput output;
computeOutput(input, output);
// 음수 값이 돌아온다.
ToHitPenalty = getPercentValue(pSlayer->getToHit(), output.ToHit);
list<Creature*> cList;
list<Creature*> creatureList;
getSplashVictims(pZone, X, Y, Creature::CREATURE_CLASS_MAX, creatureList, Splash);
Level_t maxEnemyLevel = 0;
uint EnemyNum = 0;
list<Creature*>::iterator itr = creatureList.begin();
for (; itr != creatureList.end(); itr++)
{
Creature* pTargetCreature = (*itr);
Assert(pTargetCreature != NULL);
ToHitBonus = computeArmsWeaponToHitBonus(pWeapon, myX, myY, pTargetCreature->getX(), pTargetCreature->getY());
DamageBonus = computeArmsWeaponDamageBonus(pWeapon, myX, myY, pTargetCreature->getX(), pTargetCreature->getY());
bool bInvokerCheck = (pTargetCreature->getObjectID() == pSlayer->getObjectID()) ? true : false;
bool bRaceCheck = pTargetCreature->isSlayer() || pTargetCreature->isNPC();
bool bHitRoll = HitRoll::isSuccess(pSlayer, pTargetCreature, ToHitPenalty + ToHitBonus);
bool bPK = verifyPK(pSlayer, pTargetCreature);
bool bZoneLevelCheck = checkZoneLevelToHitTarget(pTargetCreature);
if (pTargetCreature->isFlag(Effect::EFFECT_CLASS_NO_DAMAGE )
|| pTargetCreature->isFlag(Effect::EFFECT_CLASS_COMA )
)
{
bHitRoll = false;
}
if (!bInvokerCheck && !bRaceCheck && bHitRoll && bPK && bZoneLevelCheck)
{
bool bCriticalHit = false;
// 데미지를 계산해서 페널티를 가한다.
// 보너스는 멀티샷 페널티 때문에 음수가 될 수도 있다.
Damage = computeDamage(pSlayer, pTargetCreature, SkillLevel/5, bCriticalHit);
DamagePenalty = getPercentValue(Damage, output.Damage);
Damage = max(0, Damage + DamagePenalty + DamageBonus);
// 메인 타겟을 제외하고는, 스플래시 데미지를 입는데,
// 스플래시 데미지는 일반 데미지의 50%다.
if (pTargetCreature->getX() != X || pTargetCreature->getY() != Y)
{
Damage = Damage/2;
}
// 소드웨이브와는 달리 크로스 카운터 체크는 하지 않는다.
ObjectID_t targetObjectID = pTargetCreature->getObjectID();
cList.push_back(pTargetCreature);
_GCSkillToTileOK1.addCListElement(targetObjectID);
_GCSkillToTileOK2.addCListElement(targetObjectID);
_GCSkillToTileOK5.addCListElement(targetObjectID);
setDamage(pTargetCreature, Damage, pSlayer, getSkillType(), NULL, &_GCSkillToTileOK1);
computeAlignmentChange(pTargetCreature, Damage, pSlayer, NULL, &_GCSkillToTileOK1);
// 크리티컬 히트라면 상대방을 뒤로 물러나게 한다.
if (bCriticalHit)
{
knockbackCreature(pZone, pTargetCreature, pSlayer->getX(), pSlayer->getY());
}
// 슬레이어가 아닐 경우에만 맞춘 걸로 간주한다.
if (!pTargetCreature->isSlayer())
{
bHit = true;
if (maxEnemyLevel < pTargetCreature->getLevel() ) maxEnemyLevel = pTargetCreature->getLevel();
EnemyNum++;
}
}
}
if (bHit)
{
if (bIncreaseExp)
{
increaseDomainExp(pSlayer, DomainType , pSkillInfo->getPoint(), _GCSkillToTileOK1, maxEnemyLevel, EnemyNum);
shareAttrExp(pSlayer, Damage , 1, 8, 1, _GCSkillToTileOK1);
}
increaseSkillExp(pSlayer, DomainType, pSkillSlot, pSkillInfo, _GCSkillToTileOK1);
}
_GCSkillToTileOK1.addShortData(MODIFY_BULLET, RemainBullet);
decreaseDurability(pSlayer, NULL, pSkillInfo, &_GCSkillToTileOK1, NULL);
_GCSkillToTileOK1.setSkillType(getSkillType());
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setRange(dir);
_GCSkillToTileOK1.setDuration(0);
_GCSkillToTileOK2.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK2.setSkillType(getSkillType());
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setRange(dir);
_GCSkillToTileOK2.setDuration(0);
_GCSkillToTileOK3.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK3.setSkillType(getSkillType());
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK4.setSkillType(getSkillType());
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setDuration(0);
_GCSkillToTileOK4.setRange(dir);
_GCSkillToTileOK5.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK5.setSkillType(getSkillType());
_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_t targetHP = 0;
if (pTargetCreature->isSlayer())
{
targetHP = (dynamic_cast<Slayer*>(pTargetCreature))->getHP();
}
else if (pTargetCreature->isVampire())
{
targetHP = (dynamic_cast<Vampire*>(pTargetCreature))->getHP();
}
_GCSkillToTileOK2.addShortData(MODIFY_CURRENT_HP, targetHP);
// 아이템의 내구력을 떨어뜨린다.
decreaseDurability(NULL, pTargetCreature, pSkillInfo, NULL, &_GCSkillToTileOK2);
// 패킷을 보내준다.
Player* pPlayer = pTargetCreature->getPlayer();
Assert(pPlayer != NULL);
pPlayer->sendPacket(&_GCSkillToTileOK2);
}
else if (pTargetCreature->isMonster())
{
// 당근 적으로 인식한다.
Monster* pMonster = dynamic_cast<Monster*>(pTargetCreature);
pMonster->addEnemy(pSlayer);
}
}
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
{
executeSkillFailNormalWithGun(pSlayer, getSkillType(), NULL, RemainBullet);
}
}
catch (Throwable & t)
{
executeSkillFailException(pSlayer, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " SGexecute End" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 슬레이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void Restore::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* pFromCreature = pZone->getCreature(TargetObjectID);
// 뱀파이어만 건드릴 수가 있다.
// NoSuch제거. by sigi. 2002.5.2
if (pFromCreature==NULL
|| !pFromCreature->isVampire())
{
executeSkillFailException(pSlayer, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
GCSkillToObjectOK1 _GCSkillToObjectOK1; // 스킬 쓴 넘에게...
GCMorph1 _GCMorph1; // 변신 당사자에게..
GCMorphSlayer2 _GCMorphSlayer2; // 변신 구경꾼들에게..
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
bool bRangeCheck = verifyDistance(pSlayer, pFromCreature, pSkillInfo->getRange());
bool bHitRoll = true;
if (bRangeCheck && bHitRoll)
{
dropRelicToZone(pFromCreature);
dropFlagToZone(pFromCreature);
//////////////////////////////////////////////////////////////////////
// 각종 존 레벨 정보를 삭제해야 한다.
//////////////////////////////////////////////////////////////////////
// 파티 초대 중이라면 정보를 삭제해 준다.
PartyInviteInfoManager* pPIIM = pZone->getPartyInviteInfoManager();
Assert(pPIIM != NULL);
pPIIM->cancelInvite(pFromCreature);
// 파티 관련 정보를 삭제해 준다.
int PartyID = pFromCreature->getPartyID();
if (PartyID != 0)
{
// 먼저 로컬에서 삭제하고...
LocalPartyManager* pLPM = pZone->getLocalPartyManager();
Assert(pLPM != NULL);
pLPM->deletePartyMember(PartyID, pFromCreature);
// 글로벌에서도 삭제해 준다.
deleteAllPartyInfo(pFromCreature);
}
// 트레이드 중이었다면 트레이드 관련 정보를 삭제해준다.
TradeManager* pTM = pZone->getTradeManager();
Assert(pTM != NULL);
pTM->cancelTrade(pFromCreature);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
Slayer* pNewSlayer = new Slayer;
Vampire* pVampire = dynamic_cast<Vampire*>(pFromCreature);
// DB에서 혹시 남아있을 지 모르는 흡혈 정보를 삭제해준다.
Statement* pStmt = NULL;
BEGIN_DB
{
pStmt = g_pDatabaseManager->getConnection("DARKEDEN")->createStatement();
StringStream sql;
sql << "DELETE FROM EffectBloodDrain WHERE OwnerID = '" + pFromCreature->getName() + "'";
pStmt->executeQuery(sql.toString());
SAFE_DELETE(pStmt);
}
END_DB(pStmt)
pNewSlayer->setName(pFromCreature->getName());
// 크리쳐 안의 플레이어 포인터와 플레이어 안의 크리쳐 포인터를 갱신한다.
Player* pFromPlayer = pFromCreature->getPlayer();
pNewSlayer->setPlayer(pFromPlayer);
GamePlayer* pFromGamePlayer = dynamic_cast<GamePlayer*>(pFromPlayer);
pFromGamePlayer->setCreature(pNewSlayer);
// load하면 load한 zone에서 objectID를 받으므로 다시 설정한다. by sigi. 2002.6.4
pNewSlayer->load();
pNewSlayer->setZone(pZone);
pNewSlayer->setObjectID(pFromCreature->getObjectID());
//pZone->getObjectRegistry().registerObject(pNewSlayer);
pNewSlayer->setMoveMode(Creature::MOVE_MODE_WALKING);
ZoneCoord_t x = pFromCreature->getX();
ZoneCoord_t y = pFromCreature->getY();
Dir_t dir = pFromCreature->getDir();
Tile& tile = pZone->getTile(x, y);
// 곧 pFromCreature 즉, 원래의 뱀파이어 객체는 지워질 것이므로,
// PCFinder에 들어가 있는 값은 쓰레기 값이 될 것이다.
// 그러므로 뱀파이어 포인터를 지워주고, 새로운 슬레이어 포인터를 더한다.
g_pPCFinder->deleteCreature(pFromCreature->getName());
g_pPCFinder->addCreature(pNewSlayer);
// 길드 현재 접속 멤버 리스트에서 삭제한다.
if (pVampire->getGuildID() != 0 )
{
Guild* pGuild = g_pGuildManager->getGuild(pVampire->getGuildID());
if (pGuild != NULL )
{
pGuild->deleteCurrentMember(pVampire->getName());
GSGuildMemberLogOn gsGuildMemberLogOn;
gsGuildMemberLogOn.setGuildID(pGuild->getID());
gsGuildMemberLogOn.setName(pVampire->getName());
gsGuildMemberLogOn.setLogOn(false);
g_pSharedServerManager->sendPacket(&gsGuildMemberLogOn);
Statement* pStmt = NULL;
// 디비에 업데이트 한다.
BEGIN_DB
{
pStmt = g_pDatabaseManager->getConnection("DARKEDEN")->createStatement();
pStmt->executeQuery("UPDATE GuildMember SET LogOn = 0 WHERE Name = '%s'", pVampire->getName().c_str());
}
END_DB(pStmt)
}
else
filelog("GuildMissing.log", "[NoSuchGuild] GuildID : %d, Name : %s\n", (int)pVampire->getGuildID(), pVampire->getName().c_str());
}
//////////////////////////////////////////////////////////////////////////////
// 슬레이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void Restore::execute(Slayer* pSlayer, ObjectID_t TargetObjectID, SkillSlot* pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
//cout << "Restore2 Start" << endl;
Assert(pSlayer != NULL);
Assert(pSkillSlot != NULL);
try
{
Player* pPlayer = pSlayer->getPlayer();
Zone* pZone = pSlayer->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
Creature* pFromCreature = pZone->getCreature(TargetObjectID);
// 뱀파이어만 건드릴 수가 있다.
// NoSuch제거. by sigi. 2002.5.2
if (pFromCreature==NULL
|| !pFromCreature->isVampire())
{
executeSkillFailException(pSlayer, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
GCSkillToObjectOK1 _GCSkillToObjectOK1; // 스킬 쓴 넘에게...
GCMorph1 _GCMorph1; // 변신 당사자에게..
GCMorphSlayer2 _GCMorphSlayer2; // 변신 구경꾼들에게..
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
bool bRangeCheck = verifyDistance(pSlayer, pFromCreature, pSkillInfo->getRange());
bool bHitRoll = true;
if (bRangeCheck && bHitRoll)
{
//////////////////////////////////////////////////////////////////////
// 각종 존 레벨 정보를 삭제해야 한다.
//////////////////////////////////////////////////////////////////////
// 파티 초대 중이라면 정보를 삭제해 준다.
PartyInviteInfoManager* pPIIM = pZone->getPartyInviteInfoManager();
Assert(pPIIM != NULL);
pPIIM->cancelInvite(pFromCreature);
// 파티 관련 정보를 삭제해 준다.
int PartyID = pFromCreature->getPartyID();
if (PartyID != 0)
{
// 먼저 로컬에서 삭제하고...
LocalPartyManager* pLPM = pZone->getLocalPartyManager();
Assert(pLPM != NULL);
pLPM->deletePartyMember(PartyID, pFromCreature);
// 글로벌에서도 삭제해 준다.
deleteAllPartyInfo(pFromCreature);
}
// 트레이드 중이었다면 트레이드 관련 정보를 삭제해준다.
TradeManager* pTM = pZone->getTradeManager();
Assert(pTM != NULL);
pTM->cancelTrade(pFromCreature);
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////
Slayer* pNewSlayer = new Slayer;
Vampire* pVampire = dynamic_cast<Vampire*>(pFromCreature);
// DB에서 혹시 남아있을 지 모르는 흡혈 정보를 삭제해준다.
Statement* pStmt = NULL;
BEGIN_DB
{
pStmt = g_pDatabaseManager->getConnection("DARKEDEN")->createStatement();
StringStream sql;
sql << "DELETE FROM EffectBloodDrain WHERE OwnerID = '" + pFromCreature->getName() + "'";
pStmt->executeQuery(sql.toString());
SAFE_DELETE(pStmt);
}
END_DB(pStmt)
pNewSlayer->setName(pFromCreature->getName());
// 크리쳐 안의 플레이어 포인터와 플레이어 안의 크리쳐 포인터를 갱신한다.
Player* pFromPlayer = pFromCreature->getPlayer();
pNewSlayer->setPlayer(pFromPlayer);
GamePlayer* pFromGamePlayer = dynamic_cast<GamePlayer*>(pFromPlayer);
pFromGamePlayer->setCreature(pNewSlayer);
pNewSlayer->setZone(pZone);
pNewSlayer->load();
pNewSlayer->setObjectID(pFromCreature->getObjectID());
pNewSlayer->setMoveMode(Creature::MOVE_MODE_WALKING);
ZoneCoord_t x = pFromCreature->getX();
ZoneCoord_t y = pFromCreature->getY();
Dir_t dir = pFromCreature->getDir();
Tile& tile = pZone->getTile(x, y);
// 곧 pFromCreature 즉, 원래의 뱀파이어 객체는 지워질 것이므로,
// PCFinder에 들어가 있는 값은 쓰레기 값이 될 것이다.
// 그러므로 뱀파이어 포인터를 지워주고, 새로운 슬레이어 포인터를 더한다.
g_pPCFinder->deleteCreature(pFromCreature->getName());
g_pPCFinder->addCreature(pNewSlayer);
// 길드 현재 접속 멤버 리스트에서 삭제한다.
if (pVampire->getGuildID() != 0 )
g_pGuildManager->getGuild(pVampire->getGuildID() )->deleteCurrentMember(pVampire->getName());
// 인벤토리 교체.
Inventory* pInventory = pVampire->getInventory();
pNewSlayer->setInventory(pInventory);
pVampire->setInventory(NULL);
// 보관함 교체
pNewSlayer->deleteStash();
pNewSlayer->setStash(pVampire->getStash());
pNewSlayer->setStashNum(pVampire->getStashNum());
pNewSlayer->setStashStatus(false);
pVampire->setStash(NULL);
/*
// 가비지 교체
while (true)
{
Item* pGarbage = pVampire->popItemFromGarbage();
// 더 이상 없다면 브레이크...
if (pGarbage == NULL) break;
pNewSlayer->addItemToGarbage(pGarbage);
}
*/
// 플래그 셋 교체
pNewSlayer->deleteFlagSet();
pNewSlayer->setFlagSet(pVampire->getFlagSet());
pVampire->setFlagSet(NULL);
Item* pItem = NULL;
_TPOINT point;
// 입고 있는 아이템들을 인벤토리 또는 바닥으로 옮긴다.
for(int part = 0; part < (int)Vampire::VAMPIRE_WEAR_MAX; part++)
{
pItem = pVampire->getWearItem((Vampire::WearPart)part);
if (pItem != NULL)
{
// 먼저 기어에서 삭제하고...
pVampire->deleteWearItem((Vampire::WearPart)part);
// 인벤토리에 자리가 있으면 인벤토리에 더하고...
if (pInventory->getEmptySlot(pItem, point))
{
pInventory->addItem(point.x, point.y, pItem);
pItem->save(pNewSlayer->getName(), STORAGE_INVENTORY, 0, point.x, point.y);
}
// 자리가 없으면 바닥에 떨어뜨린다.
else
{
ZoneCoord_t ZoneX = pVampire->getX();
ZoneCoord_t ZoneY = pVampire->getY();
TPOINT pt;
pt = pZone->addItem(pItem, ZoneX , ZoneY);
if (pt.x != -1)
{
pItem->save("", STORAGE_ZONE, pZone->getZoneID(), pt.x, pt.y);
}
else
{
pItem->destroy();
SAFE_DELETE(pItem);
}
}
}
}
pItem = pVampire->getExtraInventorySlotItem();
if (pItem != NULL)
{
pVampire->deleteItemFromExtraInventorySlot();
// 인벤토리에 자리가 있으면 인벤토리에 더하고...
if (pInventory->getEmptySlot(pItem, point))
{
pInventory->addItem(point.x, point.y, pItem);
pItem->save(pNewSlayer->getName(), STORAGE_INVENTORY, 0, point.x, point.y);
}
// 자리가 없으면 바닥에 떨어뜨린다.
else
{
TPOINT pt;
ZoneCoord_t ZoneX = pVampire->getX();
ZoneCoord_t ZoneY = pVampire->getY();
pt = pZone->addItem(pItem, ZoneX , ZoneY);
if (pt.x != -1)
{
pItem->save("", STORAGE_ZONE, pZone->getZoneID(), pt.x, pt.y);
}
else
{
pItem->destroy();
SAFE_DELETE(pItem);
}
}
}
// 뱀파이어 가지고 있던 돈을 슬레이어로 옮겨준다.
pNewSlayer->setGoldEx(pVampire->getGold());
// 스킬 정보를 전송한다.
pNewSlayer->sendSlayerSkillInfo();
_GCMorph1.setPCInfo2(pNewSlayer->getSlayerInfo2());
_GCMorph1.setInventoryInfo(pNewSlayer->getInventoryInfo());
_GCMorph1.setGearInfo(pNewSlayer->getGearInfo());
_GCMorph1.setExtraInfo(pNewSlayer->getExtraInfo());
_GCMorphSlayer2.setSlayerInfo(pNewSlayer->getSlayerInfo3());
pFromPlayer->sendPacket(&_GCMorph1);
//pFromGamePlayer->deleteEvent(Event::EVENT_CLASS_REGENERATION);
pZone->broadcastPacket(x, y, &_GCMorphSlayer2, pNewSlayer);
// 타일 및 존에서 기존 뱀파이어를 삭제하고, 새로운 슬레이어를 더한다.
tile.deleteCreature(pFromCreature->getObjectID());
pZone->deletePC(pFromCreature);
TPOINT pt = findSuitablePosition(pZone, x, y, Creature::MOVE_MODE_WALKING);
Tile& newtile = pZone->getTile(pt.x, pt.y);
newtile.addCreature(pNewSlayer);
pNewSlayer->setXYDir(pt.x, pt.y, dir);
pZone->addPC(pNewSlayer);
pNewSlayer->tinysave("Race='SLAYER'");
SAFE_DELETE(pFromCreature);
// 시야 update..
pZone->updateHiddenScan(pNewSlayer);
_GCSkillToObjectOK1.setSkillType(SkillType);
_GCSkillToObjectOK1.setCEffectID(CEffectID);
_GCSkillToObjectOK1.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK1.setDuration(0);
pPlayer->sendPacket(&_GCSkillToObjectOK1);
pSkillSlot->setRunTime(0);
EffectRestore* pEffectRestore = new EffectRestore(pNewSlayer);
pEffectRestore->setDeadline(60*60*24*7*10); // 7일
pNewSlayer->addEffect(pEffectRestore);
pNewSlayer->setFlag(Effect::EFFECT_CLASS_RESTORE);
pEffectRestore->create(pNewSlayer->getName());
}
else
{
executeSkillFailNormal(pSlayer, getSkillType(), pFromCreature);
}
}
//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void WildWolf::execute(Vampire* pVampire, ObjectID_t TargetObjectID, VampireSkillSlot* pVampireSkillSlot, CEffectID_t CEffectID)
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);
if (pTargetCreature==NULL )
{
Item* pTargetItem = pZone->getItem(TargetObjectID);
if (pTargetItem == NULL || pTargetItem->getItemClass() != Item::ITEM_CLASS_CORPSE )
{
executeSkillFailException(pVampire, getSkillType());
return;
}
eatCorpse(pVampire, pTargetItem, pVampireSkillSlot);
return;
}
// NPC는 공격할 수가 없다.
// NoSuch제거. by sigi. 2002.5.2
if (!canAttack(pVampire, pTargetCreature )
|| pTargetCreature->isNPC() )
{
executeSkillFailException(pVampire, getSkillType());
return;
}
if (pTargetCreature->isFlag(Effect::EFFECT_CLASS_COMA ) )
{
eatComaCreature(pVampire, pTargetCreature);
return;
}
GCSkillToObjectOK1 _GCSkillToObjectOK1;
GCSkillToObjectOK2 _GCSkillToObjectOK2;
GCSkillToObjectOK5 _GCSkillToObjectOK5;
SkillType_t SkillType = pVampireSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
Range_t Range = pSkillInfo->getRange();
int RequiredMP = decreaseConsumeMP(pVampire, pSkillInfo);
bool bManaCheck = hasEnoughMana(pVampire, RequiredMP);
bool bTimeCheck = verifyRunTime(pVampireSkillSlot);
bool bRangeCheck = verifyDistance(pVampire, pTargetCreature, Range);
bool bHitRoll = HitRoll::isSuccess(pVampire, pTargetCreature);
bool bCanHit = canHit(pVampire, pTargetCreature, getSkillType());
bool bPK = verifyPK(pVampire, pTargetCreature);
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bCanHit && bPK)
{
SkillInput input(pVampire);
SkillOutput output;
computeOutput(input, output);
Damage_t Damage = output.Damage;
bool bCriticalHit = false;
Damage += computeDamage(pVampire, pTargetCreature, 0, bCriticalHit);
// 마나를 깍는다.
decreaseMana(pVampire, RequiredMP, _GCSkillToObjectOK1);
EffectSetAfire* pEffect = new EffectSetAfire(pTargetCreature);
pEffect->setDamage(Damage);
pEffect->setTick(3);
pEffect->setNextTime(3);
pEffect->setTimes(3);
pEffect->setCasterOID(pVampire->getObjectID());
pTargetCreature->addEffect(pEffect);
increaseAlignment(pVampire, pTargetCreature, _GCSkillToObjectOK1);
// 패킷을 보낸다.
_GCSkillToObjectOK1.setSkillType(getSkillType());
_GCSkillToObjectOK1.setCEffectID(CEffectID);
_GCSkillToObjectOK1.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK1.setDuration(0);
_GCSkillToObjectOK2.setObjectID(pVampire->getObjectID());
_GCSkillToObjectOK2.setSkillType(getSkillType());
_GCSkillToObjectOK2.setDuration(0);
_GCSkillToObjectOK5.setObjectID(pVampire->getObjectID());
_GCSkillToObjectOK5.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK5.setSkillType(getSkillType());
pPlayer->sendPacket(&_GCSkillToObjectOK1);
Player* pTargetPlayer = NULL;
if (pTargetCreature->isPC())
{
pTargetPlayer = pTargetCreature->getPlayer();
Assert(pTargetPlayer != NULL);
pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
}
else
{
Monster* pMonster = dynamic_cast<Monster*>(pTargetCreature);
pMonster->addEnemy(pVampire);
}
list<Creature*> cList;
cList.push_back(pVampire);
cList.push_back(pTargetCreature);
cList = pZone->broadcastSkillPacket(pVampire->getX(), pVampire->getY(),
pTargetCreature->getX(), pTargetCreature->getY(), &_GCSkillToObjectOK5, cList);
pVampireSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pVampire, getSkillType(), pTargetCreature);
}
}
catch(Throwable & t)
{
executeSkillFailException(pVampire, getSkillType());
}
__END_CATCH
}
void GroundBless::execute(Ousters* pOusters, ObjectID_t TargetObjectID, OustersSkillSlot* pSkillSlot, CEffectID_t CEffectID) throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << "begin " << endl;
Assert(pOusters != NULL);
Assert(pSkillSlot != NULL);
try
{
Player* pPlayer = pOusters->getPlayer();
Zone* pZone = pOusters->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
Item* pWeapon = pOusters->getWearItem(Ousters::WEAR_RIGHTHAND);
if (pWeapon == NULL || pWeapon->getItemClass() != Item::ITEM_CLASS_OUSTERS_WRISTLET || !pOusters->isRealWearingEx(Ousters::WEAR_RIGHTHAND))
{
executeSkillFailException(pOusters, pSkillSlot->getSkillType());
return;
}
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NPC는 공격할 수 없다.
// 저주 면역. by sigi. 2002.9.13
// NoSuch제거. by sigi. 2002.5.2
if (pTargetCreature==NULL
|| !pTargetCreature->isOusters()
)
{
executeSkillFailException(pOusters, 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);
SkillInput input(pOusters, pSkillSlot);
SkillOutput output;
computeOutput(input, output);
int RequiredMP = (int)pSkillInfo->getConsumeMP() + pSkillSlot->getExpLevel()/2;
bool bManaCheck = hasEnoughMana(pOusters, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pOusters, pTargetCreature, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessMagic(pOusters, pSkillInfo, pSkillSlot);
bool bEffected = pTargetCreature->isFlag(Effect::EFFECT_CLASS_GROUND_BLESS);
bool bSatisfyRequire = pOusters->satisfySkillRequire(pSkillInfo);
ZoneCoord_t targetX = pTargetCreature->getX();
ZoneCoord_t targetY = pTargetCreature->getY();
ZoneCoord_t myX = pOusters->getX();
ZoneCoord_t myY = pOusters->getY();
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && !bEffected && bSatisfyRequire)
{
decreaseMana(pOusters, RequiredMP, _GCSkillToObjectOK1);
bool bCanSeeCaster = canSee(pTargetCreature, pOusters);
// 이펙트 오브젝트를 생성해 붙인다.
EffectGroundBless* pEffect = new EffectGroundBless(pTargetCreature);
pEffect->setDeadline(output.Duration);
pEffect->setBonus(output.Damage);
pTargetCreature->addEffect(pEffect);
pTargetCreature->setFlag(Effect::EFFECT_CLASS_GROUND_BLESS);
Ousters* pTargetOusters = dynamic_cast<Ousters*>(pTargetCreature);
if (pTargetOusters != NULL ) pTargetOusters->initAllStatAndSend();
_GCSkillToObjectOK1.setSkillType(SkillType);
_GCSkillToObjectOK1.setCEffectID(CEffectID);
_GCSkillToObjectOK1.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK1.setDuration(output.Duration);
_GCSkillToObjectOK2.setObjectID(pOusters->getObjectID());
_GCSkillToObjectOK2.setSkillType(SkillType);
_GCSkillToObjectOK2.setDuration(output.Duration);
_GCSkillToObjectOK3.setObjectID(pOusters->getObjectID());
_GCSkillToObjectOK3.setSkillType(SkillType);
_GCSkillToObjectOK3.setTargetXY (targetX, targetY);
_GCSkillToObjectOK4.setSkillType(SkillType);
_GCSkillToObjectOK4.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK4.setDuration(output.Duration);
_GCSkillToObjectOK5.setObjectID(pOusters->getObjectID());
_GCSkillToObjectOK5.setSkillType(SkillType);
_GCSkillToObjectOK5.setTargetObjectID (TargetObjectID);
_GCSkillToObjectOK5.setDuration(output.Duration);
_GCSkillToObjectOK6.setXY(myX, myY);
_GCSkillToObjectOK6.setSkillType(SkillType);
_GCSkillToObjectOK6.setDuration(output.Duration);
list<Creature *> cList;
cList.push_back(pTargetCreature);
cList.push_back(pOusters);
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);
Player* pTargetPlayer = pTargetCreature->getPlayer();
if (pTargetPlayer != NULL )
{
if (bCanSeeCaster) pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
else pTargetPlayer->sendPacket(&_GCSkillToObjectOK6);
}
GCAddEffect gcAddEffect;
gcAddEffect.setObjectID(TargetObjectID);
gcAddEffect.setEffectID(Effect::EFFECT_CLASS_GROUND_BLESS);
gcAddEffect.setDuration(output.Duration);
pZone->broadcastPacket(targetX, targetY, &gcAddEffect);
pSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pOusters, getSkillType(), pTargetCreature);
}
}
catch (Throwable & t)
{
executeSkillFailException(pOusters, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 아우스터즈 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void ChargingAttack::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
{
Player* pPlayer = pOusters->getPlayer();
Zone* pZone = pOusters->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
Creature* pTargetCreature = pZone->getCreature(TargetObjectID);
//Assert(pTargetCreature != NULL);
// NoSuch제거. by sigi. 2002.5.2
// NPC는 공격할 수가 없다.
if (pTargetCreature==NULL
|| pTargetCreature->isNPC())
{
executeSkillFailException(pOusters, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
// 무장하고 있는 무기가 널이거나, 검이 아니라면 기술을 사용할 수 없다.
Item* pItem = pOusters->getWearItem(Ousters::WEAR_RIGHTHAND);
if (pItem == NULL)
{
executeSkillFailException(pOusters, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
GCSkillToObjectOK1 _GCSkillToObjectOK1;
GCSkillToObjectOK2 _GCSkillToObjectOK2;
SkillType_t SkillType = pOustersSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
SkillLevel_t SkillLevel = pOustersSkillSlot->getExpLevel();
SkillInput input(pOusters, pOustersSkillSlot);
SkillOutput output;
computeOutput(input, output);
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pOusters, RequiredMP);
bool bTimeCheck = verifyRunTime(pOustersSkillSlot);
bool bRangeCheck = verifyDistance(pOusters, pTargetCreature, output.Range);
bool bHitRoll = HitRoll::isSuccess(pOusters, pTargetCreature, SkillLevel/2);
bool bCanHit = canHit(pOusters, pTargetCreature, SkillType) && canAttack(pOusters, pTargetCreature);
bool bPK = verifyPK(pOusters, pTargetCreature);
bool bEffected = pOusters->hasRelicItem()
|| pOusters->isFlag(Effect::EFFECT_CLASS_HAS_FLAG)
|| pOusters->isFlag(Effect::EFFECT_CLASS_HAS_SWEEPER);
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bCanHit && bPK && !bEffected )
{
// 빠르게 PC를 움직여준다.
if (pZone->moveFastPC(pOusters, pOusters->getX(), pOusters->getY(), pTargetCreature->getX(), pTargetCreature->getY(), getSkillType()))
{
decreaseMana(pOusters, RequiredMP, _GCSkillToObjectOK1);
bool bCriticalHit = false;
// 데미지를 준다.
Damage_t Damage = computeDamage(pOusters, pTargetCreature, 0, bCriticalHit) + output.Damage;
setDamage(pTargetCreature, Damage, pOusters, SkillType, &_GCSkillToObjectOK2, &_GCSkillToObjectOK1);
computeAlignmentChange(pTargetCreature, Damage, pOusters, &_GCSkillToObjectOK2, &_GCSkillToObjectOK1);
decreaseDurability(pOusters, pTargetCreature, pSkillInfo, &_GCSkillToObjectOK1, &_GCSkillToObjectOK2);
// 크리티컬 히트라면 상대방을 뒤로 물러나게 한다.
if (bCriticalHit)
{
knockbackCreature(pZone, pTargetCreature, pOusters->getX(), pOusters->getY());
}
if (pTargetCreature->isDead())
{
int exp = computeCreatureExp(pTargetCreature, 100, pOusters);
shareOustersExp(pOusters, exp, _GCSkillToObjectOK1);
}
// 패킷을 준비하고 보낸다.
_GCSkillToObjectOK1.setSkillType(SkillType);
_GCSkillToObjectOK1.setCEffectID(CEffectID);
_GCSkillToObjectOK1.setTargetObjectID(TargetObjectID);
_GCSkillToObjectOK1.setDuration(0);
pPlayer->sendPacket(&_GCSkillToObjectOK1);
_GCSkillToObjectOK2.setObjectID(pOusters->getObjectID());
_GCSkillToObjectOK2.setSkillType(SkillType);
_GCSkillToObjectOK2.setDuration(0);
if (pTargetCreature->isPC())
{
Player* pTargetPlayer = pTargetCreature->getPlayer();
Assert(pTargetPlayer != NULL);
pTargetPlayer->sendPacket(&_GCSkillToObjectOK2);
}
else
{
Monster * pMonster = dynamic_cast<Monster*>(pTargetCreature);
pMonster->addEnemy(pOusters);
}
pOustersSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pOusters, getSkillType(), pTargetCreature);
}
}
else
{
executeSkillFailNormal(pOusters, getSkillType(), pTargetCreature);
}
}
catch (Throwable & t)
{
executeSkillFailException(pOusters, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////
//
// ThunderFlash::execute()
//
//////////////////////////////////////////////////////////////////////
void ThunderFlash::execute(Slayer* pSlayer, ZoneCoord_t X, ZoneCoord_t Y, SkillSlot* pSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " begin" << endl;
Assert(pSlayer != NULL);
Assert(pSkillSlot != NULL);
try
{
Player* pPlayer = pSlayer->getPlayer();
Zone* pZone = pSlayer->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
// 무장하고 있는 무기가 널이거나, SWORD가 아니라면 사용할 수 없다.
Item* pItem = pSlayer->getWearItem(Slayer::WEAR_RIGHTHAND);
if (pItem == NULL || pItem->getItemClass() != Item::ITEM_CLASS_SWORD)
{
executeSkillFailException(pSlayer, getSkillType());
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end" << endl;
return;
}
bool bIncreaseExp = pSlayer->isRealWearingEx(Slayer::WEAR_RIGHTHAND);
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK5 _GCSkillToTileOK5;
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
SkillDomainType_t DomainType = pSkillInfo->getDomainType();
SkillLevel_t SkillLevel = pSkillSlot->getExpLevel();
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pSlayer, X, Y, pSkillInfo->getRange());
// 마나가 있어야 하고, 시간과 거리 체크에 성공하고,
if (bManaCheck && bTimeCheck && bRangeCheck)
{
// MP를 떨어뜨린다.
decreaseMana(pSlayer, RequiredMP, _GCSkillToTileOK1);
// 좌표와 방향을 구한다.
ZoneCoord_t myX = pSlayer->getX();
ZoneCoord_t myY = pSlayer->getY();
Dir_t dir = calcDirection(myX, myY, X, Y);
SkillInput input(pSlayer, pSkillSlot);
SkillOutput output;
computeOutput(input, output);
Damage_t SkillDamage = output.Damage;
Damage_t Damage = 0;
bool bHit = false;
Level_t maxEnemyLevel = 0;
uint EnemyNum = 0;
VSRect rect(1, 1, pZone->getWidth()-2, pZone->getHeight()-2);
list<Creature*> cList;
for (int count=0; count<4; count++)
{
int tileX = X + m_pThunderFlashMask[count].x;
int tileY = Y + m_pThunderFlashMask[count].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);
}
list<Creature*>::iterator itr = targetList.begin();
for(; itr != targetList.end(); itr++)
{
Creature* pTargetCreature = (*itr);
Assert(pTargetCreature != NULL);
bool bMoveModeCheck = (pTargetCreature->getMoveMode() == Creature::MOVE_MODE_WALKING) ? true : false;
bool bHitRoll = HitRoll::isSuccess(pSlayer, pTargetCreature, SkillLevel/2);
//bool bCanHit = canHit(pSlayer, pTargetCreature, SkillType);
bool bCanHit = true;
bool bPK = verifyPK(pSlayer, pTargetCreature);
bool bRaceCheck = pTargetCreature->isSlayer() || pTargetCreature->isNPC();
bool bZoneLevelCheck = checkZoneLevelToHitTarget(pTargetCreature);
if (bMoveModeCheck && bHitRoll && bCanHit && bPK && !bRaceCheck && bZoneLevelCheck)
{
CheckCrossCounter(pSlayer, pTargetCreature, Damage, pSkillInfo->getRange());
bool bCriticalHit = false;
Damage = computeDamage(pSlayer, pTargetCreature, SkillLevel/5, bCriticalHit) + SkillDamage;
ObjectID_t targetObjectID = pTargetCreature->getObjectID();
cList.push_back(pTargetCreature);
_GCSkillToTileOK1.addCListElement(targetObjectID);
_GCSkillToTileOK2.addCListElement(targetObjectID);
_GCSkillToTileOK5.addCListElement(targetObjectID);
// 일단 맞는 놈이 받을 패킷은 널 상태로 한 채로, 데미지를 준다.
setDamage(pTargetCreature, Damage, pSlayer, SkillType, NULL, &_GCSkillToTileOK1);
computeAlignmentChange(pTargetCreature, Damage, pSlayer, NULL, &_GCSkillToTileOK1);
increaseAlignment(pSlayer, pTargetCreature, _GCSkillToTileOK1);
// 크리티컬 히트라면 상대방을 뒤로 물러나게 한다.
if (bCriticalHit)
{
knockbackCreature(pZone, pTargetCreature, pSlayer->getX(), pSlayer->getY());
}
// 슬레이어가 아닐 경우에만 맞은 것으로 간주한다.
if (!pTargetCreature->isSlayer())
{
bHit = true;
if (maxEnemyLevel < pTargetCreature->getLevel() ) maxEnemyLevel = pTargetCreature->getLevel();
EnemyNum++;
}
}
} //for (; itr != objectList.end(); itr++)
} // if (rect.ptInRect(tileX, tileY) && ...
} // for (int count=0; count<3; count++)
if (bHit)
{
if (bIncreaseExp)
{
shareAttrExp(pSlayer, Damage , 8, 1, 1, _GCSkillToTileOK1);
increaseDomainExp(pSlayer, DomainType, pSkillInfo->getPoint(), _GCSkillToTileOK1, maxEnemyLevel, EnemyNum);
increaseSkillExp(pSlayer, DomainType, pSkillSlot, pSkillInfo, _GCSkillToTileOK1);
}
}
// 공격자 아이템 내구성 떨어트림.
decreaseDurability(pSlayer, NULL, pSkillInfo, &_GCSkillToTileOK1, NULL);
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setRange(dir);
_GCSkillToTileOK1.setDuration(0);
_GCSkillToTileOK2.setObjectID(pSlayer->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setRange(dir);
_GCSkillToTileOK2.setDuration(0);
_GCSkillToTileOK5.setObjectID(pSlayer->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);
_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(pSlayer);
}
}
cList.push_back(pSlayer);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK5 , cList);
// set Next Run Time
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 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 RefusalEther::execute(Ousters* pOusters, ZoneCoord_t X, ZoneCoord_t Y, OustersSkillSlot* pOustersSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pOusters != NULL);
Assert(pOustersSkillSlot != NULL);
BYTE Grade = 0;
if (pOustersSkillSlot->getExpLevel() < 15 ) Grade = 0;
else if (pOustersSkillSlot->getExpLevel() < 30 ) Grade = 1;
else Grade = 2;
try
{
Player* pPlayer = pOusters->getPlayer();
Zone* pZone = pOusters->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
Item* pWeapon = pOusters->getWearItem(Ousters::WEAR_RIGHTHAND);
if (pWeapon == NULL || pWeapon->getItemClass() != Item::ITEM_CLASS_OUSTERS_WRISTLET || !pOusters->isRealWearingEx(Ousters::WEAR_RIGHTHAND))
{
executeSkillFailException(pOusters, pOustersSkillSlot->getSkillType(), Grade);
return;
}
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = pOustersSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
ZoneCoord_t myX = pOusters->getX();
ZoneCoord_t myY = pOusters->getY();
// 이펙트의 지속시간을 계산한다.
SkillInput input(pOusters, pOustersSkillSlot);
SkillOutput output;
computeOutput(input, output);
int RequiredMP = (int)pSkillInfo->getConsumeMP() + pOustersSkillSlot->getExpLevel()/3;
bool bManaCheck = hasEnoughMana(pOusters, RequiredMP);
bool bTimeCheck = verifyRunTime(pOustersSkillSlot);
bool bRangeCheck = verifyDistance(pOusters, X, Y, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessMagic(pOusters, pSkillInfo, pOustersSkillSlot);
bool bSatisfyRequire = pOusters->satisfySkillRequire(pSkillInfo);
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
if (rect.ptInRect(X, Y)) bTileCheck = true;
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bTileCheck && bSatisfyRequire)
{
decreaseMana(pOusters, RequiredMP, _GCSkillToTileOK1);
list<Creature*> cList;
for (int ox = X-output.Range; ox <= X+output.Range; ++ox )
for (int oy = Y-output.Range; oy <= Y+output.Range; ++oy )
{
if (!rect.ptInRect(ox,oy) ) continue;
Tile& rTile = pZone->getTile(ox,oy);
EffectDarkness* pEffect = dynamic_cast<EffectDarkness*>(rTile.getEffect(Effect::EFFECT_CLASS_DARKNESS));
int ratio = 0;
if (pEffect != NULL )
{
if (input.SkillLevel <= 15 )
{
ratio = (int)(pOusters->getLevel() + (input.SkillLevel * 8.0 / 3.0 ) - pEffect->getLevel());
}
else
{
ratio = (int)(pOusters->getLevel() + 20 + (input.SkillLevel * 4.0 / 3.0 ) - pEffect->getLevel());
if (input.SkillLevel == 30 ) ratio = (int)(ratio * 1.1);
}
ratio = max(20, ratio);
}
else
{
continue;
}
bool bHitRoll2 = (rand()%100) < ratio;
if (bHitRoll2)
{
pZone->deleteEffect(pEffect->getObjectID());
Creature* pTargetCreature = NULL;
if (rTile.hasCreature(Creature::MOVE_MODE_WALKING))
pTargetCreature = rTile.getCreature(Creature::MOVE_MODE_WALKING);
GCDeleteEffectFromTile gcDeleteEffectFromTile;
gcDeleteEffectFromTile.setXY(ox, oy);
gcDeleteEffectFromTile.setObjectID(pEffect->getObjectID());
gcDeleteEffectFromTile.setEffectID(Effect::EFFECT_CLASS_DARKNESS);
pZone->broadcastPacket(ox, oy, &gcDeleteEffectFromTile);
if (pTargetCreature != NULL && pTargetCreature->isPC() && pTargetCreature->getObjectID() != pOusters->getObjectID() )
cList.push_back(pTargetCreature);
}
}
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setDuration(output.Duration);
_GCSkillToTileOK1.setRange(0);
_GCSkillToTileOK1.setGrade(Grade);
_GCSkillToTileOK2.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setDuration(output.Duration);
_GCSkillToTileOK2.setRange(0);
//_GCSkillToTileOK2.addShortData(MODIFY_VISION, ICE_FIELD_SIGHT);
_GCSkillToTileOK2.setGrade(Grade);
_GCSkillToTileOK3.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK3.setGrade(Grade);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setRange(0);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK4.setGrade(Grade);
_GCSkillToTileOK5.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setRange(0);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK5.setGrade(Grade);
_GCSkillToTileOK6.setOrgXY(myX, myY);
_GCSkillToTileOK6.setSkillType(SkillType);
_GCSkillToTileOK6.setX(X);
_GCSkillToTileOK6.setY(Y);
_GCSkillToTileOK6.setDuration(output.Duration);
_GCSkillToTileOK6.setRange(0);
//_GCSkillToTileOK6.addShortData(MODIFY_VISION, ICE_FIELD_SIGHT);
_GCSkillToTileOK6.setGrade(Grade);
pPlayer->sendPacket(&_GCSkillToTileOK1);
list<Creature*>::iterator itr = cList.begin();
list<Creature*>::iterator endItr = cList.end();
for (; itr != endItr ; ++itr )
{
if ((*itr)->isPC() )
{
(*itr)->getPlayer()->sendPacket(&_GCSkillToTileOK2);
}
}
cList.push_back(pOusters);
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList, false);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
pOustersSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pOusters, getSkillType(), NULL, Grade);
}
}
catch (Throwable & t)
{
executeSkillFailException(pOusters, getSkillType(), Grade);
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__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
}
//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 타일 핸들러
//////////////////////////////////////////////////////////////////////////////
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
}
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 TurnUndead::execute(Slayer * pSlayer, 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);
Player* pPlayer = pSlayer->getPlayer();
Assert(pPlayer != NULL);
GCSkillToSelfOK1 _GCSkillToSelfOK1;
GCSkillToSelfOK2 _GCSkillToSelfOK2;
SkillType_t SkillType = pSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
SkillDomainType_t DomainType = pSkillInfo->getDomainType();
ZoneCoord_t X = pSlayer->getX();
ZoneCoord_t Y = pSlayer->getY();
int RequiredMP = (int)pSkillInfo->getConsumeMP();
bool bManaCheck = hasEnoughMana(pSlayer, RequiredMP);
bool bTimeCheck = verifyRunTime(pSkillSlot);
bool bRangeCheck = verifyDistance(pSlayer, X, Y, pSkillInfo->getRange()) && checkZoneLevelToUseSkill(pSlayer);
bool bHitRoll = HitRoll::isSuccessMagic(pSlayer, pSkillInfo, pSkillSlot);
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll)
{
decreaseMana(pSlayer, RequiredMP, _GCSkillToSelfOK1);
// calculate damage and duration time
SkillInput input(pSlayer, pSkillSlot);
SkillOutput output;
computeOutput(input, output);
bool bHit = false;
Level_t maxEnemyLevel = 0;
uint EnemyNum = 0;
int oX, oY;
for(oX = -2; oX <= 2; oX++)
for(oY = -2; oY <= 2; oY++)
{
int tileX = X+oX;
int tileY = Y+oY;
if (oX == 0 && oY == 0 ) continue;
if (!rect.ptInRect(tileX, tileY)) continue;
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(checkZoneLevelToHitTarget(pTargetCreature ) && !pTargetCreature->isSlayer()
&& !pTargetCreature->isFlag(Effect::EFFECT_CLASS_COMA)
&& canAttack(pSlayer, pTargetCreature )
)
{
if(pTargetCreature->isVampire() || pTargetCreature->isOusters())
{
Player* pTargetPlayer = pTargetCreature->getPlayer();
bHit = true;
// 데미지를 적용시킨다.
GCModifyInformation gcMI;
::setDamage(pTargetCreature, output.Damage, pSlayer, pSkillSlot->getSkillType(), &gcMI);
// HP 가 변했다고 당사자에게 보낸다.
pTargetPlayer->sendPacket(&gcMI);
GCSkillToObjectOK2 gcSkillToObjectOK2;
gcSkillToObjectOK2.setObjectID(1); // 의미 없다.
gcSkillToObjectOK2.setSkillType(SKILL_ATTACK_MELEE);
gcSkillToObjectOK2.setDuration(0);
}
else if(pTargetCreature->isMonster())
{
Monster* pMonster = dynamic_cast<Monster*>(pTargetCreature);
bHit = true;
::setDamage(pMonster, output.Damage, pSlayer, pSkillSlot->getSkillType());
pMonster->addEnemy(pSlayer);
}
else
{
continue;
}
if (maxEnemyLevel < pTargetCreature->getLevel() ) maxEnemyLevel = pTargetCreature->getLevel();
EnemyNum++;
GCSkillToObjectOK4 gcSkillToObjectOK4;
gcSkillToObjectOK4.setTargetObjectID(pTargetCreature->getObjectID());
gcSkillToObjectOK4.setSkillType(SKILL_ATTACK_MELEE);
gcSkillToObjectOK4.setDuration(0);
pZone->broadcastPacket(pTargetCreature->getX(), pTargetCreature->getY(), &gcSkillToObjectOK4);
// 성향을 올린다.
increaseAlignment(pSlayer, pTargetCreature, _GCSkillToSelfOK1);
}
}
}
if(bHit)
{
//cout << "Skill Succesfully Attacked(" << output.Damage << ")" << endl;
shareAttrExp(pSlayer, output.Damage, 1, 1, 8, _GCSkillToSelfOK1);
increaseDomainExp(pSlayer, DomainType, pSkillInfo->getPoint(), _GCSkillToSelfOK1, maxEnemyLevel, EnemyNum);
increaseSkillExp(pSlayer, DomainType, pSkillSlot, pSkillInfo, _GCSkillToSelfOK1);
}
// 패킷을 만들어 보낸다.
_GCSkillToSelfOK1.setSkillType(SkillType);
_GCSkillToSelfOK1.setCEffectID(CEffectID);
_GCSkillToSelfOK1.setDuration(0);
_GCSkillToSelfOK2.setObjectID(pSlayer->getObjectID());
_GCSkillToSelfOK2.setSkillType(SkillType);
_GCSkillToSelfOK2.setDuration(0);
// 기술을 사용한 사람에게 packet 전달
pPlayer->sendPacket(&_GCSkillToSelfOK1);
pZone->broadcastPacket(X, Y, &_GCSkillToSelfOK2, pSlayer);
// 기술 delay setting
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 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 BloodyWall::execute(Vampire* pVampire, ZoneCoord_t X, ZoneCoord_t Y, VampireSkillSlot* pVampireSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pVampire != NULL);
Assert(pVampireSkillSlot != NULL);
try
{
Player* pPlayer = pVampire->getPlayer();
Zone* pZone = pVampire->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = pVampireSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
ZoneCoord_t myX = pVampire->getX();
ZoneCoord_t myY = pVampire->getY();
// Knowledge of Blood 가 있다면 hit bonus 10
int HitBonus = 0;
if (pVampire->hasRankBonus(RankBonus::RANK_BONUS_KNOWLEDGE_OF_BLOOD ) )
{
RankBonus* pRankBonus = pVampire->getRankBonus(RankBonus::RANK_BONUS_KNOWLEDGE_OF_BLOOD);
Assert(pRankBonus != NULL);
HitBonus = pRankBonus->getPoint();
}
int RequiredMP = decreaseConsumeMP(pVampire, pSkillInfo);
bool bManaCheck = hasEnoughMana(pVampire, RequiredMP);
bool bTimeCheck = verifyRunTime(pVampireSkillSlot);
bool bRangeCheck = verifyDistance(pVampire, X, Y, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessMagic(pVampire, pSkillInfo, pVampireSkillSlot, HitBonus);
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
if (rect.ptInRect(X, Y)) bTileCheck = true;
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bTileCheck)
{
decreaseMana(pVampire, RequiredMP, _GCSkillToTileOK1);
// 이펙트의 지속시간을 계산한다.
SkillInput input(pVampire);
SkillOutput output;
computeOutput(input, output);
Dir_t Dir = getDirectionToPosition(myX, myY, X, Y);
list<Creature*> cList; // denier list
for (int i=0; i<5; i++)
{
POINT& pt = m_BloodyWallMask[Dir][i];
int tileX = X+pt.x;
int tileY = Y+pt.y;
if (rect.ptInRect(tileX, tileY))
{
Tile& tile = pZone->getTile(tileX, tileY);
if (tile.getEffect(Effect::EFFECT_CLASS_TRYING_POSITION )!=NULL ) continue;
// 현재 타일에다 이펙트를 추가할 수 있다면...
if (tile.canAddEffect())
{
// 같은 effect가 있으면 지운다.
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_BLOODY_WALL);
if (pOldEffect != NULL)
{
ObjectID_t effectID = pOldEffect->getObjectID();
pZone->deleteEffect(effectID);// fix me
}
// 이펙트 클래스를 생성한다.
EffectBloodyWall* pEffect = new EffectBloodyWall(pZone , tileX, tileY);
pEffect->setCasterName(pVampire->getName());
pEffect->setCasterID(pVampire->getObjectID());
pEffect->setClan(Creature::CREATURE_CLASS_VAMPIRE, pVampire->getClanType());
pEffect->setDamage(output.Damage);
pEffect->setDeadline(output.Duration);
pEffect->setLevel(pVampire->getINT());
pEffect->setNextTime(0);
pEffect->setTick(output.Tick);
// Tile에 붙이는 Effect는 ObjectID를 등록받아야 한다.
ObjectRegistry & objectregister = pZone->getObjectRegistry();
objectregister.registerObject(pEffect);
pZone->addEffect(pEffect);
tile.addEffect(pEffect);
const list<Object*>& oList = tile.getObjectList();
for(list<Object*>::const_iterator itr = oList.begin(); itr != oList.end(); itr++)
{
Object* pTarget = *itr;
Creature* pTargetCreature = NULL;
if (pTarget->getObjectClass() == Object::OBJECT_CLASS_CREATURE
&& ((pTargetCreature = dynamic_cast<Creature*>(pTarget))->isSlayer() || pTargetCreature->isOusters() )
&& !checkZoneLevelToHitTarget(pTargetCreature )
)
{
cList.push_back(pTargetCreature);
_GCSkillToTileOK2.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK4.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK5.addCListElement(pTargetCreature->getObjectID());
pEffect->affect(pTargetCreature);
}
// pEffect->affect(pTarget);
}
}
}
}
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setDuration(output.Duration);
_GCSkillToTileOK1.setRange(Dir);
_GCSkillToTileOK2.setObjectID(pVampire->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setDuration(output.Duration);
_GCSkillToTileOK2.setRange(Dir);
//_GCSkillToTileOK2.addShortData(MODIFY_VISION, BLOODY_WALL_SIGHT);
_GCSkillToTileOK3.setObjectID(pVampire->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setRange(Dir);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK5.setObjectID(pVampire->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setRange(Dir);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK6.setOrgXY(myX, myY);
_GCSkillToTileOK6.setSkillType(SkillType);
_GCSkillToTileOK6.setX(X);
_GCSkillToTileOK6.setY(Y);
_GCSkillToTileOK6.setDuration(output.Duration);
_GCSkillToTileOK6.setRange(Dir);
//_GCSkillToTileOK6.addShortData(MODIFY_VISION, BLOODY_WALL_SIGHT);
for(list<Creature*>::const_iterator itr = cList.begin(); itr != cList.end(); itr++)
{
Creature* pTargetCreature = *itr;
if (canSee(pTargetCreature, pVampire)) pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK2);
else pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK6);
}
pPlayer->sendPacket(&_GCSkillToTileOK1);
cList.push_back(pVampire);
list<Creature*> watcherList = pZone->getWatcherList(myX, myY, pVampire);
// watcherList에서 cList에 속하지 않고, caster(pVampire)를 볼 수 없는 경우는
// OK4를 보내고.. cList에 추가한다.
for(list<Creature*>::const_iterator itr = watcherList.begin(); itr != watcherList.end(); itr++)
{
bool bBelong = false;
for(list<Creature*>::const_iterator tItr = cList.begin(); tItr != cList.end(); tItr++)
if (*itr == *tItr)
bBelong = true;
Creature* pWatcher = (*itr);
if (bBelong == false && canSee(pWatcher, pVampire) == false)
{
//Assert(pWatcher->isPC()); // 당연 PC다.. Zone::getWatcherList는 PC만 return한다
if (!pWatcher->isPC())
{
//cout << "BloodyWall : 왓처 리스트가 PC가 아닙니다." << endl;
GCSkillFailed1 _GCSkillFailed1;
_GCSkillFailed1.setSkillType(getSkillType());
pVampire->getPlayer()->sendPacket(&_GCSkillFailed1);
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
pWatcher->getPlayer()->sendPacket(&_GCSkillToTileOK4);
cList.push_back(*itr);
}
}
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList, false);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
pVampireSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pVampire, getSkillType(), NULL);
}
}
catch (Throwable & t)
{
executeSkillFailException(pVampire, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
bool BloodDrain::executeMonster(Monster* pMonster, Creature* pEnemy)
throw(Error)
{
__BEGIN_TRY
bool isMaster = pMonster->isMaster()
#ifdef __UNDERWORLD__
|| pMonster->isUnderworld() || pMonster->getMonsterType() == 599
#endif
;
// 죽었으면 흡혈 못하고..
// 마스터는 아무나 다 빤다 - -;
// 대상이 죽었으면 못 빤다.
if (pMonster->isDead()
|| pMonster->isFlag(Effect::EFFECT_CLASS_COMA)
|| !pMonster->isEnemyToAttack(pEnemy) && !isMaster
|| pEnemy->isDead() || pEnemy->isFlag(Effect::EFFECT_CLASS_COMA))
{
return false;
}
Zone* pZone = pMonster->getZone();
Assert(pZone != NULL);
GCBloodDrainOK1 _GCBloodDrainOK1;
GCBloodDrainOK2 _GCBloodDrainOK2;
GCBloodDrainOK3 _GCBloodDrainOK3;
// 마스터는 체력 100% 라도 문다.
int HPMultiplier = (isMaster? 1 : 3); // 현재 HP가 1/1, 1/3
bool bHitRoll = HitRoll::isSuccessBloodDrain(pMonster, pEnemy, HPMultiplier);
bool bCanHit = canHit(pMonster, pEnemy, SKILL_BLOOD_DRAIN);
// 마스터는 거리에 관계없이 문다~
bool bRangeCheck = isMaster || verifyDistance(pMonster, pEnemy, 1);
// 흡혈 면역 상태. by sigi. 2002.9.13
bool bEffected = pEnemy->isFlag(Effect::EFFECT_CLASS_IMMUNE_TO_BLOOD_DRAIN);
if (bHitRoll && bCanHit && bRangeCheck && !bEffected)
{
if (pEnemy->isSlayer())
{
// Set EffectBloodDrain
// 마스터면 안건다.
if (!isMaster)
{
EffectBloodDrain* pEffectBloodDrain = new EffectBloodDrain(pEnemy);
pEffectBloodDrain->setLevel(pMonster->getLevel());
pEffectBloodDrain->setDeadline(BLOODDRAIN_DURATION); // 게임시간으로 3일 정도
pEnemy->addEffect(pEffectBloodDrain);
pEffectBloodDrain->create(pEnemy->getName());
_GCBloodDrainOK2.addShortData(MODIFY_EFFECT_STAT, Effect::EFFECT_CLASS_BLOOD_DRAIN);
pEnemy->setFlag(Effect::EFFECT_CLASS_BLOOD_DRAIN);
Slayer* pTargetSlayer = dynamic_cast<Slayer*>(pEnemy);
SLAYER_RECORD prev;
pTargetSlayer->getSlayerRecord(prev);
pTargetSlayer->initAllStat();
pTargetSlayer->sendRealWearingInfo();
pTargetSlayer->addModifyInfo(prev, _GCBloodDrainOK2);
}
// 로그를 남긴다.
//log(LOG_BLOODDRAINED, pEnemy->getName(), "게임 내의 몬스터");
}
// 아우스터즈의 경우엔..... -_-; 제한시간 없는 이펙트를 생성한다. 엄밀히 말해 제한시간이 없는 건 아니지만..
// else if (pEnemy->isOusters() && !isMaster )
// {
// EffectBloodDrain* pEffectBloodDrain = new EffectBloodDrain(pEnemy);
// pEffectBloodDrain->setLevel(pMonster->getLevel());
// pEnemy->addEffect(pEffectBloodDrain);
// pEffectBloodDrain->create(pEnemy->getName());
// _GCBloodDrainOK2.addShortData(MODIFY_EFFECT_STAT, Effect::EFFECT_CLASS_BLOOD_DRAIN);
//
// pEnemy->setFlag(Effect::EFFECT_CLASS_BLOOD_DRAIN);
//
// Sight_t oldSight = pEnemy->getSight();
// Sight_t newSight = pEnemy->getEffectedSight();
//
// if (oldSight != newSight )
// {
// pEnemy->setSight(newSight);
// pZone->updateScan(pEnemy, oldSight, pEnemy->getSight());
// _GCBloodDrainOK2.addShortData(MODIFY_VISION, pEnemy->getSight());
//
// GCChangeDarkLight gcChangeDarkLight;
// gcChangeDarkLight.setDarkLevel(15);
// gcChangeDarkLight.setLightLevel(newSight);
// pEnemy->getPlayer()->sendPacket(&gcChangeDarkLight);
// }
// }
_GCBloodDrainOK3.setObjectID(pMonster->getObjectID());
_GCBloodDrainOK3.setTargetObjectID (pEnemy->getObjectID());
// 타겟이 뭐든 플래그는 건다.
// 마스터면 안건다.
if (!isMaster)
{
pEnemy->setFlag(Effect::EFFECT_CLASS_BLOOD_DRAIN);
}
if (pEnemy != NULL && pEnemy->isPC())
{
Player* pTargetPlayer = pEnemy->getPlayer();
if (pTargetPlayer != NULL)
{
_GCBloodDrainOK2.setObjectID(pMonster->getObjectID());
if (!isMaster)
{
// _GCBloodDrainOK2.addLongData(MODIFY_DURATION, BLOODDRAIN_DURATION);
}
pTargetPlayer->sendPacket(&_GCBloodDrainOK2);
}
}
// target
int targetLevel = 0;
int targetMaxHP = 0;
if (pEnemy->isSlayer())
{
Slayer* pTargetSlayer = dynamic_cast<Slayer*>(pEnemy);
targetLevel = pTargetSlayer->getHighestSkillDomainLevel();
targetMaxHP = pTargetSlayer->getHP(ATTR_MAX);
}
else if (pEnemy->isVampire())
{
Vampire* pTargetVampire = dynamic_cast<Vampire*>(pEnemy);
targetLevel = pTargetVampire->getLevel();
targetMaxHP = pTargetVampire->getHP(ATTR_MAX);
}
else if (pEnemy->isOusters())
{
Ousters* pTargetOusters = dynamic_cast<Ousters*>(pEnemy);
targetLevel = pTargetOusters->getLevel();
targetMaxHP = pTargetOusters->getHP(ATTR_MAX);
}
else if (pEnemy->isMonster())
{
Monster* pEnemyMonster = dynamic_cast<Monster*>(pEnemy);
// 흡혈당하는 몬스터한테 딜레이 걸어준다.
Timeval DelayTurn;
DelayTurn.tv_sec = 4;
DelayTurn.tv_usec = 500000;
pEnemyMonster->addAccuDelay(DelayTurn);
if ((pMonster->isMaster()
#ifdef __UNDERWORLD__
|| pMonster->isUnderworld() || pMonster->getMonsterType() == 599
#endif
)
&& pMonster->getClanType()==pEnemyMonster->getClanType())
{
// 같은 clan의 마스터이면 피 상납이라고 볼 수 있을까 -_-;
}
else
{
pEnemyMonster->addEnemy(pMonster);
}
targetLevel = pEnemyMonster->getLevel();
targetMaxHP = pEnemyMonster->getHP(ATTR_MAX);
}
// 자신이나 상대방 중.. HP가 많은 쪽의 15~25%
HP_t maxHP = max((int)pMonster->getHP(ATTR_MAX), targetMaxHP);
HP_t drainHP = maxHP*(rand()%11+15)/100; // 15~25%
// 한번에 1000이상 안 찬다.
if (pMonster->getMonsterType() >= 717 )
drainHP = min((int)drainHP, 2000);
else
drainHP = min((int)drainHP, 1000);
// 몬스터의 HP를 올려준다.
HP_t CurrentHP = pMonster->getHP();
HP_t MaxHP = pMonster->getHP(ATTR_MAX);
HP_t NewHP = min((int)MaxHP , (int)CurrentHP + (int)drainHP);
// 뱀파이어의 HP를 세팅한다.
pMonster->setHP(NewHP);
GCStatusCurrentHP gcStatusCurrentHP;
gcStatusCurrentHP.setObjectID(pMonster->getObjectID());
gcStatusCurrentHP.setCurrentHP(NewHP);
pZone->broadcastPacket(pMonster->getX(), pMonster->getY(), &gcStatusCurrentHP);
// 흡혈 당한 애의 HP를 줄인다.
// 대상이 내 레벨보다 높다면.. MaxHP의 10~15% damage
// by sigi. 2002.9.14
int drainDamage = 0;
int myLevel = pMonster->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, pEnemy, drainDamage);
EffectDecreaseHP* pEffect = new EffectDecreaseHP(pEnemy);
pEffect->setPoint(drainDamage);
pEffect->setDeadline(20); // 2초 후
pEffect->setUserObjectID(pMonster->getObjectID());
pEnemy->addEffect(pEffect);
pEnemy->setFlag(Effect::EFFECT_CLASS_DECREASE_HP);
}
// 흡혈 모습 보이게..
list<Creature *> cList;
cList.push_back(pEnemy);
cList.push_back(pMonster);
pZone->broadcastPacket(pMonster->getX(), pMonster->getY(), &_GCBloodDrainOK3 , cList);
// 흡혈 성공
return true;
}
__END_CATCH
return false;
}
//////////////////////////////////////////////////////////////////////////////
// 몬스터 셀프 핸들러
//////////////////////////////////////////////////////////////////////////////
void BloodyWall::execute(Monster* pMonster, ZoneCoord_t X, ZoneCoord_t Y)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pMonster != NULL);
try
{
Zone* pZone = pMonster->getZone();
Assert(pZone != NULL);
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = SKILL_BLOODY_WALL;
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
ZoneCoord_t myX = pMonster->getX();
ZoneCoord_t myY = pMonster->getY();
// 마스터는 무조건~~
bool bRangeCheck = pMonster->isMaster()
#ifdef __UNDERWORLD__
|| pMonster->isUnderworld() || pMonster->getMonsterType() == 599
#endif
|| verifyDistance(pMonster, X, Y, pSkillInfo->getRange());
bool bHitRoll = pMonster->isMaster()
#ifdef __UNDERWORLD__
|| pMonster->isUnderworld() || pMonster->getMonsterType() == 599
#endif
|| HitRoll::isSuccessMagic(pMonster, pSkillInfo);
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
if (rect.ptInRect(X, Y)) bTileCheck = true;
if (bRangeCheck && bHitRoll && bTileCheck)
{
// 이펙트의 지속시간을 계산한다.
SkillInput input(pMonster);
SkillOutput output;
computeOutput(input, output);
//Range_t Range = 3;
Dir_t Dir = getDirectionToPosition(myX, myY, X, Y);
list<Creature*> cList; // denier list
for (int i=0; i<5; i++)
{
POINT& pt = m_BloodyWallMask[Dir][i];
int tileX = X+pt.x;
int tileY = Y+pt.y;
if (rect.ptInRect(tileX, tileY))
{
Tile& tile = pZone->getTile(tileX, tileY);
// 현재 타일에다 이펙트를 추가할 수 있다면...
if (tile.canAddEffect())
{
// 같은 effect가 있으면 지운다.
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_BLOODY_WALL);
if (pOldEffect != NULL)
{
ObjectID_t effectID = pOldEffect->getObjectID();
pZone->deleteEffect(effectID);// fix me
}
// 이펙트 클래스를 생성한다.
EffectBloodyWall* pEffect = new EffectBloodyWall(pZone , tileX, tileY);
pEffect->setCasterName(pMonster->getName());
pEffect->setCasterID(pMonster->getObjectID());
pEffect->setClan(Creature::CREATURE_CLASS_MONSTER, pMonster->getClanType());
pEffect->setDamage(output.Damage);
pEffect->setDeadline(output.Duration);
pEffect->setLevel(pMonster->getINT());
pEffect->setNextTime(0);
pEffect->setTick(output.Tick);
// Tile에 붙이는 Effect는 ObjectID를 등록받아야 한다.
ObjectRegistry & objectregister = pZone->getObjectRegistry();
objectregister.registerObject(pEffect);
pZone->addEffect(pEffect);
tile.addEffect(pEffect);
GCAddEffectToTile gcAE;
gcAE.setObjectID(pEffect->getObjectID());
gcAE.setEffectID(pEffect->getSendEffectClass());
gcAE.setDuration(output.Duration);
gcAE.setXY(tileX, tileY);
pZone->broadcastPacket(tileX, tileY, &gcAE);
const list<Object*>& oList = tile.getObjectList();
for(list<Object*>::const_iterator itr = oList.begin(); itr != oList.end(); itr++)
{
Object* pTarget = *itr;
Creature* pTargetCreature = NULL;
if (pTarget->getObjectClass() == Object::OBJECT_CLASS_CREATURE
&& ((pTargetCreature = dynamic_cast<Creature*>(pTarget))->isSlayer() || pTargetCreature->isOusters() )
)
{
cList.push_back(pTargetCreature);
_GCSkillToTileOK2.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK4.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK5.addCListElement(pTargetCreature->getObjectID());
pEffect->affect(pTargetCreature);
}
//pEffect->affectObject(pTarget, false);
}
}
}
}
_GCSkillToTileOK2.setObjectID(pMonster->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setDuration(output.Duration);
_GCSkillToTileOK2.setRange(Dir);
//_GCSkillToTileOK2.addShortData(MODIFY_VISION, BLOODY_WALL_SIGHT);
_GCSkillToTileOK3.setObjectID(pMonster->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setRange(Dir);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK5.setObjectID(pMonster->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setRange(Dir);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK6.setOrgXY(myX, myY);
_GCSkillToTileOK6.setSkillType(SkillType);
_GCSkillToTileOK6.setX(X);
_GCSkillToTileOK6.setY(Y);
_GCSkillToTileOK6.setDuration(output.Duration);
_GCSkillToTileOK6.setRange(Dir);
//_GCSkillToTileOK6.addShortData(MODIFY_VISION, BLOODY_WALL_SIGHT);
for(list<Creature*>::const_iterator itr = cList.begin(); itr != cList.end(); itr++)
{
Creature* pTargetCreature = *itr;
if (canSee(pTargetCreature, pMonster)) pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK2);
else pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK6);
}
cList.push_back(pMonster);
list<Creature*> watcherList = pZone->getWatcherList(myX, myY, pMonster);
// watcherList에서 cList에 속하지 않고, caster(pMonster)를 볼 수 없는 경우는
// OK4를 보내고.. cList에 추가한다.
for(list<Creature*>::const_iterator itr = watcherList.begin(); itr != watcherList.end(); itr++)
{
bool bBelong = false;
for(list<Creature*>::const_iterator tItr = cList.begin(); tItr != cList.end(); tItr++)
if (*itr == *tItr)
bBelong = true;
Creature* pWatcher = (*itr);
if (bBelong == false && canSee(pWatcher, pMonster) == false)
{
//Assert(pWatcher->isPC()); // 당연 PC다.. Zone::getWatcherList는 PC만 return한다
if (!pWatcher->isPC())
{
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
return;
}
pWatcher->getPlayer()->sendPacket(&_GCSkillToTileOK4);
cList.push_back(*itr);
}
}
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList, false);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
}
else
{
executeSkillFailNormal(pMonster, getSkillType(), NULL);
}
}
catch (Throwable & t)
{
executeSkillFailException(pMonster, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 뱀파이어 타일 핸들러
//////////////////////////////////////////////////////////////////////////////
void IceField::execute(Ousters* pOusters, ZoneCoord_t X, ZoneCoord_t Y, OustersSkillSlot* pOustersSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin" << endl;
Assert(pOusters != NULL);
Assert(pOustersSkillSlot != NULL);
try
{
Player* pPlayer = pOusters->getPlayer();
Zone* pZone = pOusters->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
Item* pWeapon = pOusters->getWearItem(Ousters::WEAR_RIGHTHAND);
if (pWeapon == NULL || pWeapon->getItemClass() != Item::ITEM_CLASS_OUSTERS_WRISTLET || !pOusters->isRealWearingEx(Ousters::WEAR_RIGHTHAND))
{
executeSkillFailException(pOusters, pOustersSkillSlot->getSkillType());
return;
}
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = pOustersSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
ZoneCoord_t myX = pOusters->getX();
ZoneCoord_t myY = pOusters->getY();
// 이펙트의 지속시간을 계산한다.
SkillInput input(pOusters, pOustersSkillSlot);
SkillOutput output;
computeOutput(input, output);
int RequiredMP = (int)pSkillInfo->getConsumeMP() + pOustersSkillSlot->getExpLevel();
bool bManaCheck = hasEnoughMana(pOusters, RequiredMP);
bool bTimeCheck = verifyRunTime(pOustersSkillSlot);
bool bRangeCheck = verifyDistance(pOusters, X, Y, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessMagic(pOusters, pSkillInfo, pOustersSkillSlot);
bool bSatisfyRequire = pOusters->satisfySkillRequire(pSkillInfo);
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
if (rect.ptInRect(X, Y)) bTileCheck = true;
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bTileCheck && bSatisfyRequire)
{
decreaseMana(pOusters, RequiredMP, _GCSkillToTileOK1);
int grade = 0;
if (input.SkillLevel <= 10 ) grade = 0;
else if (input.SkillLevel <= 20 ) grade = 1;
else if (input.SkillLevel < 30 ) grade = 2;
else grade = 3;
list<Creature*> cList; // denier list
for (int i=0; i<m_MaskNum[grade]; i++)
{
POINT& pt = m_IceFieldMask[grade][i];
int tileX = X+pt.x;
int tileY = Y+pt.y;
if (rect.ptInRect(tileX, tileY))
{
Tile& tile = pZone->getTile(tileX, tileY);
if (tile.getEffect(Effect::EFFECT_CLASS_TRYING_POSITION) ) continue;
// 현재 타일에다 이펙트를 추가할 수 있다면...
if (tile.canAddEffect())
{
// 같은 effect가 있으면 지운다.
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_ICE_FIELD);
if (pOldEffect != NULL)
{
ObjectID_t effectID = pOldEffect->getObjectID();
pZone->deleteEffect(effectID);// fix me
}
// 이펙트 클래스를 생성한다.
EffectIceField* pEffect = new EffectIceField(pZone , tileX, tileY);
pEffect->setCasterName(pOusters->getName());
pEffect->setCasterID(pOusters->getObjectID());
pEffect->setDeadline(output.Duration);
pEffect->setDuration(output.Range);
pEffect->setNextTime(0);
pEffect->setTick(output.Tick);
// Tile에 붙이는 Effect는 ObjectID를 등록받아야 한다.
ObjectRegistry & objectregister = pZone->getObjectRegistry();
objectregister.registerObject(pEffect);
pZone->addEffect(pEffect);
tile.addEffect(pEffect);
const list<Object*>& oList = tile.getObjectList();
for(list<Object*>::const_iterator itr = oList.begin(); itr != oList.end(); itr++)
{
Object* pTarget = *itr;
Creature* pTargetCreature = NULL;
if (pTarget->getObjectClass() == Object::OBJECT_CLASS_CREATURE
&& ((pTargetCreature = dynamic_cast<Creature*>(pTarget))->isSlayer() || pTargetCreature->isVampire() )
&& !checkZoneLevelToHitTarget(pTargetCreature )
)
{
cList.push_back(pTargetCreature);
_GCSkillToTileOK2.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK4.addCListElement(pTargetCreature->getObjectID());
_GCSkillToTileOK5.addCListElement(pTargetCreature->getObjectID());
pEffect->affect(pTargetCreature);
}
// pEffect->affect(pTarget);
}
}
}
}
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setDuration(output.Duration);
_GCSkillToTileOK1.setRange(grade);
_GCSkillToTileOK2.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK2.setSkillType(SkillType);
_GCSkillToTileOK2.setX(X);
_GCSkillToTileOK2.setY(Y);
_GCSkillToTileOK2.setDuration(output.Duration);
_GCSkillToTileOK2.setRange(grade);
//_GCSkillToTileOK2.addShortData(MODIFY_VISION, ICE_FIELD_SIGHT);
_GCSkillToTileOK3.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setRange(grade);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK5.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setRange(grade);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK6.setOrgXY(myX, myY);
_GCSkillToTileOK6.setSkillType(SkillType);
_GCSkillToTileOK6.setX(X);
_GCSkillToTileOK6.setY(Y);
_GCSkillToTileOK6.setDuration(output.Duration);
_GCSkillToTileOK6.setRange(grade);
//_GCSkillToTileOK6.addShortData(MODIFY_VISION, ICE_FIELD_SIGHT);
for(list<Creature*>::const_iterator itr = cList.begin(); itr != cList.end(); itr++)
{
Creature* pTargetCreature = *itr;
if (canSee(pTargetCreature, pOusters)) pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK2);
else pTargetCreature->getPlayer()->sendPacket(&_GCSkillToTileOK6);
}
pPlayer->sendPacket(&_GCSkillToTileOK1);
cList.push_back(pOusters);
list<Creature*> watcherList = pZone->getWatcherList(myX, myY, pOusters);
// watcherList에서 cList에 속하지 않고, caster(pOusters)를 볼 수 없는 경우는
// OK4를 보내고.. cList에 추가한다.
for(list<Creature*>::const_iterator itr = watcherList.begin(); itr != watcherList.end(); itr++)
{
bool bBelong = false;
for(list<Creature*>::const_iterator tItr = cList.begin(); tItr != cList.end(); tItr++)
if (*itr == *tItr)
bBelong = true;
Creature* pWatcher = (*itr);
if (bBelong == false && canSee(pWatcher, pOusters) == false)
{
//Assert(pWatcher->isPC()); // 당연 PC다.. Zone::getWatcherList는 PC만 return한다
if (!pWatcher->isPC())
{
//cout << "IceField : 왓처 리스트가 PC가 아닙니다." << endl;
// GCSkillFailed1 _GCSkillFailed1;
// _GCSkillFailed1.setSkillType(getSkillType());
// pOusters->getPlayer()->sendPacket(&_GCSkillFailed1);
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
// return;
continue;
}
pWatcher->getPlayer()->sendPacket(&_GCSkillToTileOK4);
cList.push_back(*itr);
}
}
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList, false);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
pOustersSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pOusters, getSkillType(), NULL);
}
}
catch (Throwable & t)
{
executeSkillFailException(pOusters, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 아우스터즈 타일 핸들러
//////////////////////////////////////////////////////////////////////////////
void SummonGroundElemental::execute(Ousters* pOusters, ZoneCoord_t X, ZoneCoord_t Y, OustersSkillSlot* pOustersSkillSlot, CEffectID_t CEffectID)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << "begin " << endl;
Assert(pOusters != NULL);
Assert(pOustersSkillSlot != NULL);
BYTE Grade = 0;
if (pOustersSkillSlot->getExpLevel() < 15 ) Grade = 0;
else if (pOustersSkillSlot->getExpLevel() < 30 ) Grade = 1;
else Grade = 2;
try
{
Player* pPlayer = pOusters->getPlayer();
Zone* pZone = pOusters->getZone();
Assert(pPlayer != NULL);
Assert(pZone != NULL);
Item* pWeapon = pOusters->getWearItem(Ousters::WEAR_RIGHTHAND);
if (pWeapon == NULL || pWeapon->getItemClass() != Item::ITEM_CLASS_OUSTERS_WRISTLET || !pOusters->isRealWearingEx(Ousters::WEAR_RIGHTHAND))
{
executeSkillFailException(pOusters, pOustersSkillSlot->getSkillType(), Grade);
return;
}
GCSkillToTileOK1 _GCSkillToTileOK1;
GCSkillToTileOK2 _GCSkillToTileOK2;
GCSkillToTileOK3 _GCSkillToTileOK3;
GCSkillToTileOK4 _GCSkillToTileOK4;
GCSkillToTileOK5 _GCSkillToTileOK5;
GCSkillToTileOK6 _GCSkillToTileOK6;
SkillType_t SkillType = pOustersSkillSlot->getSkillType();
SkillInfo* pSkillInfo = g_pSkillInfoManager->getSkillInfo(SkillType);
// 데미지와 지속 시간을 계산한다.
SkillInput input(pOusters, pOustersSkillSlot);
SkillOutput output;
computeOutput(input, output);
int RequiredMP = (int)pSkillInfo->getConsumeMP() + pOustersSkillSlot->getExpLevel()/3;
bool bManaCheck = hasEnoughMana(pOusters, RequiredMP);
bool bTimeCheck = verifyRunTime(pOustersSkillSlot);
bool bRangeCheck = verifyDistance(pOusters, X, Y, pSkillInfo->getRange());
bool bHitRoll = HitRoll::isSuccessMagic(pOusters, pSkillInfo, pOustersSkillSlot);
bool bSatisfyRequire = pOusters->satisfySkillRequire(pSkillInfo);
bool bTileCheck = false;
VSRect rect(0, 0, pZone->getWidth()-1, pZone->getHeight()-1);
// if (rect.ptInRect(X, Y))
// {
// Tile& tile = pZone->getTile(X, Y);
// if (tile.canAddEffect()) bTileCheck = true;
// }
TPOINT pt = findSuitablePosition(pZone, X, Y, Creature::MOVE_MODE_WALKING);
if (pt.x == -1 )
{
bTileCheck = false;
}
else
{
bTileCheck = true;
for (int oX = pt.x - 2 ; oX <= pt.x + 2 ; ++oX )
for (int oY = pt.y - 2 ; oY <= pt.y + 2 ; ++oY )
{
if (!rect.ptInRect(oX, oY ) ) continue;
if (pZone->getTile(oX, oY).getEffect(Effect::EFFECT_CLASS_GROUND_ELEMENTAL_AURA ) != NULL )
{
bTileCheck = false;
break;
}
}
}
if (bManaCheck && bTimeCheck && bRangeCheck && bHitRoll && bTileCheck && bSatisfyRequire)
{
decreaseMana(pOusters, RequiredMP, _GCSkillToTileOK1);
int oX, oY;
/*
HP = 200 + (S_level * 10)
Defense = 50 + (S_level * 2)
Protection = 20 + (S_level * 2)
Poison Resistance = 70%
Acid Resistance = 60%
Curse Resistance = 100%
Blood Resistance = 50%
Regen = 1 HP per 1 sec
*/
Monster* pGroundElemental = new Monster(GROUND_ELEMENTAL_TYPE);
pGroundElemental->setName("대지 정령");
pGroundElemental->setHP(1000 + input.SkillLevel * 100);
pGroundElemental->setHP(1000 + input.SkillLevel * 100, ATTR_MAX);
pGroundElemental->setDefense(0);
pGroundElemental->setProtection(0);
pGroundElemental->setResist(MAGIC_DOMAIN_POISON, 0);
pGroundElemental->setResist(MAGIC_DOMAIN_ACID, 0);
pGroundElemental->setResist(MAGIC_DOMAIN_CURSE, 0);
pGroundElemental->setResist(MAGIC_DOMAIN_BLOOD, 0);
pGroundElemental->setFlag(Effect::EFFECT_CLASS_IMMUNE_TO_CURSE);
pGroundElemental->removeFlag(Effect::EFFECT_CLASS_HIDE);
pGroundElemental->setMoveMode(Creature::MOVE_MODE_WALKING);
// 무뇌정령
pGroundElemental->setBrain(NULL);
pZone->addCreature(pGroundElemental, X, Y, 2);
X = pGroundElemental->getX();
Y = pGroundElemental->getY();
//cout << pGroundElemental->toString() << " 을 " << X << ", " << Y << " 에 불러냈습니다." << endl;
EffectGroundElemental* pCreatureEffect = new EffectGroundElemental(pGroundElemental);
pCreatureEffect->setDeadline(output.Duration);
pGroundElemental->setFlag(pCreatureEffect->getEffectClass());
pGroundElemental->addEffect(pCreatureEffect);
GCAddEffect gcAddEffect;
gcAddEffect.setObjectID(pGroundElemental->getObjectID());
gcAddEffect.setEffectID(pCreatureEffect->getSendEffectClass());
pZone->broadcastPacket(X, Y, &gcAddEffect);
// addSimpleCreatureEffect(pGroundElemental, Effect::EFFECT_CLASS_GROUND_ELEMENTAL_CENTER);
// for (int i = 0; i < m_MaskIndex[Grade]; ++i )
for (oX = X - 2 ; oX <= X + 2 ; ++oX )
for (oY = Y - 2 ; oY <= Y + 2 ; ++oY )
{
// oX = m_ElementalMask[Grade][i].x;
// oY = m_ElementalMask[Grade][i].y;
if (!rect.ptInRect(oX, oY)) continue;
if (oX == X && oY == Y ) continue;
Tile& tile = pZone->getTile(oX, oY);
if (!tile.canAddEffect()) continue;
if (tile.getEffect(Effect::EFFECT_CLASS_TRYING_POSITION) ) continue;
// 같은 이펙트가 이미 존재한다면 삭제한다.
Effect* pOldEffect = tile.getEffect(Effect::EFFECT_CLASS_GROUND_ELEMENTAL_AURA);
if (pOldEffect != NULL)
{
ObjectID_t effectID = pOldEffect->getObjectID();
pZone->deleteEffect(effectID);
}
// 이펙트 오브젝트를 생성한다.
EffectSummonGroundElemental* pEffect = new EffectSummonGroundElemental(pZone, oX, oY);
pEffect->setDeadline(output.Duration);
// 타일에 붙은 이펙트는 OID를 받아야 한다.
ObjectRegistry & objectregister = pZone->getObjectRegistry();
objectregister.registerObject(pEffect);
// 존 및 타일에다가 이펙트를 추가한다.
pZone->addEffect(pEffect);
tile.addEffect(pEffect);
GCAddEffectToTile gcAddEffect;
gcAddEffect.setXY(oX, oY);
gcAddEffect.setEffectID(pEffect->getSendEffectClass());
gcAddEffect.setObjectID(pEffect->getObjectID());
gcAddEffect.setDuration(output.Duration);
pZone->broadcastPacket(oX, oY, &gcAddEffect);
}
ZoneCoord_t myX = pOusters->getX();
ZoneCoord_t myY = pOusters->getY();
_GCSkillToTileOK1.setSkillType(SkillType);
_GCSkillToTileOK1.setCEffectID(CEffectID);
_GCSkillToTileOK1.setX(X);
_GCSkillToTileOK1.setY(Y);
_GCSkillToTileOK1.setDuration(output.Duration);
_GCSkillToTileOK1.setGrade(Grade);
_GCSkillToTileOK3.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK3.setSkillType(SkillType);
_GCSkillToTileOK3.setX(X);
_GCSkillToTileOK3.setY(Y);
_GCSkillToTileOK3.setGrade(Grade);
_GCSkillToTileOK4.setSkillType(SkillType);
_GCSkillToTileOK4.setX(X);
_GCSkillToTileOK4.setY(Y);
_GCSkillToTileOK4.setDuration(output.Duration);
_GCSkillToTileOK4.setGrade(Grade);
_GCSkillToTileOK5.setObjectID(pOusters->getObjectID());
_GCSkillToTileOK5.setSkillType(SkillType);
_GCSkillToTileOK5.setX(X);
_GCSkillToTileOK5.setY(Y);
_GCSkillToTileOK5.setDuration(output.Duration);
_GCSkillToTileOK5.setGrade(Grade);
pPlayer->sendPacket(&_GCSkillToTileOK1);
list<Creature*> cList;
cList.push_back(pOusters);
cList = pZone->broadcastSkillPacket(myX, myY, X, Y, &_GCSkillToTileOK5, cList);
pZone->broadcastPacket(myX, myY, &_GCSkillToTileOK3 , cList);
pZone->broadcastPacket(X, Y, &_GCSkillToTileOK4 , cList);
pOustersSkillSlot->setRunTime(output.Delay);
}
else
{
executeSkillFailNormal(pOusters, getSkillType(), NULL, Grade);
}
}
catch (Throwable & t)
{
executeSkillFailException(pOusters, getSkillType(), Grade);
//cout << t.toString() << endl;
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
