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 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 EffectDecreaseHP::unaffect(Creature* pCreature)
throw(Error)
{
__BEGIN_TRY
__BEGIN_DEBUG
Assert(pCreature != NULL);
Zone* pZone = pCreature->getZone();
Assert(pZone != NULL);
pCreature->removeFlag(Effect::EFFECT_CLASS_DECREASE_HP);
Damage_t decreaseHP = m_Point;
if (!(pZone->getZoneLevel() & COMPLETE_SAFE_ZONE)
&& !pCreature->isDead()
&& !pCreature->isFlag(Effect::EFFECT_CLASS_COMA)
// 무적상태 체크. by sigi. 2002.9.5
&& canAttack(NULL, pCreature )
)
{
if (pCreature->isSlayer())
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pCreature);
HP_t CurrentHP = pSlayer->getHP(ATTR_CURRENT);
if (CurrentHP > 0)
{
HP_t RemainHP = max(0, CurrentHP -(int)decreaseHP);
pSlayer->setHP(RemainHP, ATTR_CURRENT);
GCModifyInformation gcMI;
gcMI.addShortData(MODIFY_CURRENT_HP, RemainHP);
pSlayer->getPlayer()->sendPacket(&gcMI);
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pSlayer->getObjectID());
pkt.setCurrentHP(RemainHP);
pZone->broadcastPacket(pSlayer->getX(), pSlayer->getY(), &pkt);
}
}
else if (pCreature->isVampire())
{
Vampire* pVampire = dynamic_cast<Vampire*>(pCreature);
HP_t CurrentHP = pVampire->getHP(ATTR_CURRENT);
if (CurrentHP > 0)
{
HP_t RemainHP = max(0, CurrentHP -(int)decreaseHP);
pVampire->setHP(RemainHP, ATTR_CURRENT);
GCModifyInformation gcMI;
gcMI.addShortData(MODIFY_CURRENT_HP, RemainHP);
pVampire->getPlayer()->sendPacket(&gcMI);
// 공격(흡혈) 당하는 경우에는 공격자의 성향이 바뀜 by sigi. 2002.12.27
Creature* pAttacker = pZone->getCreature(m_UserObjectID);
if (pAttacker!=NULL && pAttacker->isVampire())
{
Vampire* pAttackVampire = dynamic_cast<Vampire*>(pAttacker);
GCModifyInformation gcAttackerMI;
computeAlignmentChange(pVampire, decreaseHP, pAttackVampire, NULL, &gcAttackerMI);
// 뭔가 변한 정보가 있다면 보내준다.
if (gcAttackerMI.getShortCount()+gcAttackerMI.getLongCount() > 0)
{
pAttackVampire->getPlayer()->sendPacket(&gcAttackerMI);
}
}
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pVampire->getObjectID());
pkt.setCurrentHP(RemainHP);
pZone->broadcastPacket(pVampire->getX(), pVampire->getY(), &pkt);
}
}
else if (pCreature->isOusters())
{
Ousters* pOusters = dynamic_cast<Ousters*>(pCreature);
HP_t CurrentHP = pOusters->getHP(ATTR_CURRENT);
if (CurrentHP > 0)
{
HP_t RemainHP = max(0, CurrentHP -(int)decreaseHP);
pOusters->setHP(RemainHP, ATTR_CURRENT);
GCModifyInformation gcMI;
gcMI.addShortData(MODIFY_CURRENT_HP, RemainHP);
pOusters->getPlayer()->sendPacket(&gcMI);
// 공격(흡혈) 당하는 경우에는 공격자의 성향이 바뀜 by sigi. 2002.12.27
Creature* pAttacker = pZone->getCreature(m_UserObjectID);
if (pAttacker!=NULL && pAttacker->isOusters())
{
Ousters* pAttackOusters = dynamic_cast<Ousters*>(pAttacker);
GCModifyInformation gcAttackerMI;
computeAlignmentChange(pOusters, decreaseHP, pAttackOusters, NULL, &gcAttackerMI);
// 뭔가 변한 정보가 있다면 보내준다.
if (gcAttackerMI.getShortCount()+gcAttackerMI.getLongCount() > 0)
{
pAttackOusters->getPlayer()->sendPacket(&gcAttackerMI);
}
}
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pOusters->getObjectID());
pkt.setCurrentHP(RemainHP);
pZone->broadcastPacket(pOusters->getX(), pOusters->getY(), &pkt);
}
}
else if (pCreature->isMonster())
{
Monster* pMonster = dynamic_cast<Monster*>(pCreature);
HP_t CurrentHP = pMonster->getHP(ATTR_CURRENT);
if (CurrentHP > 0)
{
HP_t RemainHP = max(0, CurrentHP -(int)decreaseHP);
pMonster->setHP(RemainHP, ATTR_CURRENT);
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pMonster->getObjectID());
pkt.setCurrentHP(RemainHP);
pZone->broadcastPacket(pMonster->getX(), pMonster->getY(), &pkt);
if (RemainHP == 0 )
{
Creature* pAttacker = pZone->getCreature(m_UserObjectID);
if (pAttacker != NULL && pAttacker->isVampire() )
{
Vampire* pAttackVampire = dynamic_cast<Vampire*>(pAttacker);
GCModifyInformation gcMI;
increaseAlignment(pAttackVampire, pCreature, gcMI);
if (gcMI.getShortCount() > 0 || gcMI.getLongCount() > 0 )
pAttackVampire->getPlayer()->sendPacket(&gcMI);
}
}
}
}
// m_CasterName이 pCreature를 죽인 경우의 KillCount 처리
// by sigi. 2002.9.9
if (pCreature->isDead())
{
Creature* pAttacker = pZone->getCreature(m_UserObjectID);
if (pAttacker!=NULL)
{
if (pAttacker->isVampire())
{
Vampire* pVampire = dynamic_cast<Vampire*>(pAttacker);
// 죽일때 경험치를 준다.
GCModifyInformation mi;
int exp = computeCreatureExp(pCreature, KILL_EXP);
shareVampExp(pVampire, exp, mi);
if (pCreature->isMonster() )
{
increaseFame(pVampire, decreaseHP);
mi.addLongData(MODIFY_FAME, pVampire->getFame());
}
pAttacker->getPlayer()->sendPacket(&mi);
}
else if (pAttacker->isOusters() )
{
Ousters* pOusters = dynamic_cast<Ousters*>(pAttacker);
GCModifyInformation mi;
int exp = computeCreatureExp(pCreature, 100);
shareOustersExp(pOusters, exp, mi);
if (pCreature->isMonster() )
{
increaseFame(pOusters, decreaseHP);
mi.addLongData(MODIFY_FAME, pOusters->getFame());
}
}
affectKillCount(pAttacker, pCreature);
}
}
}
__END_DEBUG
__END_CATCH
}
void EffectBloodyWallBlocked::affect()
throw(Error)
{
__BEGIN_TRY
//cout << "EffectBloodyWallBlocked" << "affect BEGIN" << endl;
Assert(m_pZone != NULL);
// 현재 이펙트가 붙어있는 타일을 받아온다.
Tile& tile = m_pZone->getTile(m_X, m_Y);
HP_t CurrentHP = 0;
HP_t RemainHP = 0;
// 타일 안에 존재하는 오브젝트들을 검색한다.
const list<Object*>& oList = tile.getObjectList();
list<Object*>::const_iterator itr = oList.begin();
for (; itr != oList.end(); itr++)
{
Assert(*itr != NULL);
Object* pObject = *itr;
Assert(pObject != NULL);
if (pObject->getObjectClass() == Object::OBJECT_CLASS_CREATURE)
{
Creature* pCreature = dynamic_cast<Creature*>(pObject);
Assert(pCreature != NULL);
// 무적상태 체크. by sigi. 2002.9.5
// 산 면역. by sigi. 2002.9.13
if (!canAttack(NULL, pCreature )
|| pCreature->isFlag(Effect::EFFECT_CLASS_IMMUNE_TO_BLOOD_DRAIN)
|| pCreature->isFlag(Effect::EFFECT_CLASS_COMA)
|| pCreature->isDead())
{
continue;
}
int AcidDamage = computeMagicDamage(pCreature, m_Damage, SKILL_BLOODY_WALL);
if (pCreature->getMoveMode() != Creature::MOVE_MODE_FLYING)
{
if (pCreature->isSlayer())
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pCreature);
CurrentHP = pSlayer->getHP(ATTR_CURRENT);
RemainHP = max(0, CurrentHP -(int)AcidDamage);
pSlayer->setHP(RemainHP, ATTR_CURRENT);
GCModifyInformation gcMI;
gcMI.addShortData(MODIFY_CURRENT_HP, pSlayer->getHP(ATTR_CURRENT));
Player* pPlayer = pSlayer->getPlayer();
Assert(pPlayer != NULL);
pPlayer->sendPacket(&gcMI);
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pSlayer->getObjectID());
pkt.setCurrentHP(RemainHP);
m_pZone->broadcastPacket(pSlayer->getX(), pSlayer->getY(), &pkt);
}
/* else if (pCreature->isVampire())
{
Vampire* pVampire = dynamic_cast<Vampire*>(pCreature);
CurrentHP = pVampire->getHP(ATTR_CURRENT);
RemainHP = max(0, CurrentHP -(int)AcidDamage);
pVampire->setHP(RemainHP, ATTR_CURRENT);
GCModifyInformation gcMI;
gcMI.addShortData(MODIFY_CURRENT_HP, pVampire->getHP(ATTR_CURRENT));
Player* pPlayer = pVampire->getPlayer();
Assert(pPlayer != NULL);
pPlayer->sendPacket(&gcMI);
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pVampire->getObjectID());
pkt.setCurrentHP(RemainHP);
m_pZone->broadcastPacket(pVampire->getX(), pVampire->getY(), &pkt);
}
*/
else if (pCreature->isOusters())
{
Ousters* pOusters = dynamic_cast<Ousters*>(pCreature);
CurrentHP = pOusters->getHP(ATTR_CURRENT);
RemainHP = max(0, CurrentHP -(int)AcidDamage);
pOusters->setHP(RemainHP, ATTR_CURRENT);
GCModifyInformation gcMI;
gcMI.addShortData(MODIFY_CURRENT_HP, pOusters->getHP(ATTR_CURRENT));
Player* pPlayer = pOusters->getPlayer();
Assert(pPlayer != NULL);
pPlayer->sendPacket(&gcMI);
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pOusters->getObjectID());
pkt.setCurrentHP(RemainHP);
m_pZone->broadcastPacket(pOusters->getX(), pOusters->getY(), &pkt);
}
else if (pCreature->isMonster())
{
Monster* pMonster = dynamic_cast<Monster*>(pCreature);
CurrentHP = pMonster->getHP(ATTR_CURRENT);
RemainHP = max(0, CurrentHP -(int)AcidDamage);
pMonster->setHP(RemainHP, ATTR_CURRENT);
if(m_CasterName != "" ) {
// 시전자의 데미지를 추가해 준다.
// 맞는 놈이 몬스터이고, 공격자가 사람이라면,
// 데미지에 따라서 변하는 우선권 테이블을 갱신해 주어야 한다.
pMonster->addPrecedence(m_CasterName, m_PartyID, AcidDamage);
pMonster->setLastHitCreatureClass(Creature::CREATURE_CLASS_VAMPIRE);
}
// 변한 HP를 브로드캐스팅해준다.
GCStatusCurrentHP pkt;
pkt.setObjectID(pMonster->getObjectID());
pkt.setCurrentHP(RemainHP);
m_pZone->broadcastPacket(pMonster->getX(), pMonster->getY(), &pkt);
}
// m_CasterName이 pCreature를 죽인 경우의 KillCount 처리
// by sigi. 2002.8.31
if (pCreature->isDead())
{
Creature* pAttacker = m_pZone->getCreature(m_CasterName);
if (pAttacker!=NULL)
{
affectKillCount(pAttacker, pCreature);
}
}
}
}
}
// 한번만..
//setNextTime(m_Tick);
//cout << "EffectBloodyWallBlocked" << "affect END" << endl;
__END_CATCH
}
void ActionHeal::execute (Creature * pCreature1 , Creature * pCreature2)
throw(Error)
{
__BEGIN_TRY
Assert(pCreature1 != NULL);
Assert(pCreature2 != NULL);
Assert(pCreature1->isNPC());
Assert(pCreature2->isPC());
Player* pPlayer = pCreature2->getPlayer();
Zone* pZone = pCreature2->getZone();
Assert(pPlayer != NULL);
// 일단 클라이언트를 위해서 OK 패킷을 함 날린다.
GCNPCResponse okpkt;
okpkt.setCode(NPC_RESPONSE_HEAL);
pPlayer->sendPacket(&okpkt);
// 죽었거나 코마 걸려있으면 안 치료해준다.
if (pCreature2->isDead() || pCreature2->isFlag(Effect::EFFECT_CLASS_COMA ) )
{
return;
}
// 슬레이어라면...
if (pCreature2->isSlayer())
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pCreature2);
EffectManager* pEffectManager = pSlayer->getEffectManager();
GCModifyInformation modifyPkt;
GCRemoveEffect removePkt;
GCStatusCurrentHP hpPkt;
// 먼저 HP랑 MP를 풀로 채워준다.
if (pSlayer->getHP(ATTR_CURRENT) < pSlayer->getHP(ATTR_MAX))
{
pSlayer->setHP(pSlayer->getHP(ATTR_MAX), ATTR_CURRENT);
modifyPkt.addShortData(MODIFY_CURRENT_HP, pSlayer->getHP(ATTR_CURRENT));
hpPkt.setObjectID(pSlayer->getObjectID());
hpPkt.setCurrentHP(pSlayer->getHP(ATTR_CURRENT));
}
if (pSlayer->getMP(ATTR_CURRENT) < pSlayer->getMP(ATTR_MAX))
{
pSlayer->setMP(pSlayer->getMP(ATTR_MAX), ATTR_CURRENT);
modifyPkt.addShortData(MODIFY_CURRENT_MP, pSlayer->getMP(ATTR_CURRENT));
}
// 흡혈 이펙트를 삭제한다.
Effect* pBloodDrainEffect = pEffectManager->findEffect(Effect::EFFECT_CLASS_BLOOD_DRAIN);
if (pBloodDrainEffect != NULL)
{
// DB에서 삭제하고, 이펙트 매니저에서 삭제한다.
pBloodDrainEffect->destroy(pSlayer->getName());
pEffectManager->deleteEffect(pSlayer, Effect::EFFECT_CLASS_BLOOD_DRAIN);
// 흡혈 아르바이트를 방지하기 위한 후유증 이펙트를 붙여준다.
if (pSlayer->isFlag(Effect::EFFECT_CLASS_AFTERMATH))
{
Effect* pEffect = pEffectManager->findEffect(Effect::EFFECT_CLASS_AFTERMATH);
EffectAftermath* pEffectAftermath = dynamic_cast<EffectAftermath*>(pEffect);
pEffectAftermath->setDeadline(5*600); // 5분 동안 지속된다.
}
else
{
EffectAftermath* pEffectAftermath = new EffectAftermath(pSlayer);
pEffectAftermath->setDeadline(5*600); // 5분 동안 지속된다.
pEffectManager->addEffect(pEffectAftermath);
pSlayer->setFlag(Effect::EFFECT_CLASS_AFTERMATH);
pEffectAftermath->create(pSlayer->getName());
}
// 패킷에다 정보를 더한다.
removePkt.addEffectList((EffectID_t)Effect::EFFECT_CLASS_BLOOD_DRAIN);
// 흡혈을 치료하면 능력치가 변화하게 된다.
SLAYER_RECORD prev;
pSlayer->getSlayerRecord(prev);
pSlayer->initAllStat();
pSlayer->sendModifyInfo(prev);
pSlayer->sendRealWearingInfo();
}
// 독 이펙트를 삭제한다.
Effect* pEffectPoison = pEffectManager->findEffect(Effect::EFFECT_CLASS_POISON);
if (pEffectPoison != NULL)
{
// 이펙트 매니저에서 삭제한다.
pEffectManager->deleteEffect(pSlayer, Effect::EFFECT_CLASS_POISON);
// 패킷에다 정보를 더한다.
removePkt.addEffectList((EffectID_t)Effect::EFFECT_CLASS_POISON);
}
// 다크블루 포이즌 이펙트를 삭제한다.
Effect* pEffectDarkBluePoison = pEffectManager->findEffect(Effect::EFFECT_CLASS_DARKBLUE_POISON);
if (pEffectDarkBluePoison != NULL)
{
// 이펙트 매니저에서 삭제한다.
pEffectManager->deleteEffect(pSlayer, Effect::EFFECT_CLASS_DARKBLUE_POISON);
// 패킷에다 정보를 더한다.
removePkt.addEffectList((EffectID_t)Effect::EFFECT_CLASS_DARKBLUE_POISON);
}
// 패킷 날려준다.
removePkt.setObjectID(pSlayer->getObjectID());
pPlayer->sendPacket(&modifyPkt);
pZone->broadcastPacket(pSlayer->getX(), pSlayer->getY(), &removePkt);
pZone->broadcastPacket(pSlayer->getX(), pSlayer->getY(), &hpPkt, pSlayer);
//log(LOG_HEAL, pSlayer->getName(), "");
}
else if (pCreature2->isVampire())
{
Vampire* pVampire = dynamic_cast<Vampire*>(pCreature2);
//EffectManager* pEffectManager = pVampire->getEffectManager();
GCModifyInformation modifyPkt;
GCRemoveEffect removePkt;
GCStatusCurrentHP hpPkt;
// HP 채워주고...
if (pVampire->getHP(ATTR_CURRENT) < pVampire->getHP(ATTR_MAX))
{
pVampire->setHP(pVampire->getHP(ATTR_MAX), ATTR_CURRENT);
modifyPkt.addShortData(MODIFY_CURRENT_HP, pVampire->getHP(ATTR_CURRENT));
hpPkt.setObjectID(pVampire->getObjectID());
hpPkt.setCurrentHP(pVampire->getHP(ATTR_CURRENT));
}
// 패킷 날려준다.
removePkt.setObjectID(pVampire->getObjectID());
pPlayer->sendPacket(&modifyPkt);
pZone->broadcastPacket(pVampire->getX(), pVampire->getY(), &removePkt);
pZone->broadcastPacket(pVampire->getX(), pVampire->getY(), &hpPkt, pVampire);
//log(LOG_HEAL, pVampire->getName(), "");
}
else if (pCreature2->isOusters())
{
Ousters* pOusters = dynamic_cast<Ousters*>(pCreature2);
EffectManager* pEffectManager = pOusters->getEffectManager();
GCModifyInformation modifyPkt;
GCRemoveEffect removePkt;
GCStatusCurrentHP hpPkt;
// 먼저 HP랑 MP를 풀로 채워준다.
if (pOusters->getHP(ATTR_CURRENT) < pOusters->getHP(ATTR_MAX) || pOusters->getSilverDamage() != 0 )
{
Silver_t prev = pOusters->getSilverDamage();
if (prev != 0 )
{
pOusters->setSilverDamage(0);
modifyPkt.addShortData(MODIFY_SILVER_DAMAGE, pOusters->getSilverDamage());
}
pOusters->setHP(pOusters->getHP(ATTR_MAX), ATTR_CURRENT);
modifyPkt.addShortData(MODIFY_CURRENT_HP, pOusters->getHP(ATTR_CURRENT));
hpPkt.setObjectID(pOusters->getObjectID());
hpPkt.setCurrentHP(pOusters->getHP(ATTR_CURRENT));
}
if (pOusters->getMP(ATTR_CURRENT) < pOusters->getMP(ATTR_MAX))
{
pOusters->setMP(pOusters->getMP(ATTR_MAX), ATTR_CURRENT);
modifyPkt.addShortData(MODIFY_CURRENT_MP, pOusters->getMP(ATTR_CURRENT));
}
// 독 이펙트를 삭제한다.
Effect* pEffectPoison = pEffectManager->findEffect(Effect::EFFECT_CLASS_POISON);
if (pEffectPoison != NULL)
{
// 이펙트 매니저에서 삭제한다.
pEffectManager->deleteEffect(pOusters, Effect::EFFECT_CLASS_POISON);
// 패킷에다 정보를 더한다.
removePkt.addEffectList((EffectID_t)Effect::EFFECT_CLASS_POISON);
}
// 다크블루 포이즌 이펙트를 삭제한다.
Effect* pEffectDarkBluePoison = pEffectManager->findEffect(Effect::EFFECT_CLASS_DARKBLUE_POISON);
if (pEffectDarkBluePoison != NULL)
{
// 이펙트 매니저에서 삭제한다.
pEffectManager->deleteEffect(pOusters, Effect::EFFECT_CLASS_DARKBLUE_POISON);
// 패킷에다 정보를 더한다.
removePkt.addEffectList((EffectID_t)Effect::EFFECT_CLASS_DARKBLUE_POISON);
}
// 흡혈 이펙트를 삭제한다.
Effect* pBloodDrainEffect = pEffectManager->findEffect(Effect::EFFECT_CLASS_BLOOD_DRAIN);
if (pBloodDrainEffect != NULL)
{
pBloodDrainEffect->setDeadline(0);
// 흡혈 아르바이트를 방지하기 위한 후유증 이펙트를 붙여준다.
if (pOusters->isFlag(Effect::EFFECT_CLASS_AFTERMATH))
{
Effect* pEffect = pEffectManager->findEffect(Effect::EFFECT_CLASS_AFTERMATH);
EffectAftermath* pEffectAftermath = dynamic_cast<EffectAftermath*>(pEffect);
pEffectAftermath->setDeadline(5*600); // 5분 동안 지속된다.
}
else
{
EffectAftermath* pEffectAftermath = new EffectAftermath(pOusters);
pEffectAftermath->setDeadline(5*600); // 5분 동안 지속된다.
pEffectManager->addEffect(pEffectAftermath);
pOusters->setFlag(Effect::EFFECT_CLASS_AFTERMATH);
pEffectAftermath->create(pOusters->getName());
}
// 패킷에다 정보를 더한다.
removePkt.addEffectList((EffectID_t)Effect::EFFECT_CLASS_BLOOD_DRAIN);
}
// 패킷 날려준다.
removePkt.setObjectID(pOusters->getObjectID());
pPlayer->sendPacket(&modifyPkt);
pZone->broadcastPacket(pOusters->getX(), pOusters->getY(), &removePkt);
pZone->broadcastPacket(pOusters->getX(), pOusters->getY(), &hpPkt, pOusters);
//log(LOG_HEAL, pOusters->getName(), "");
}
__END_CATCH
}
void EventResurrect::activate ()
throw(Error)
{
__BEGIN_TRY
__BEGIN_DEBUG
Assert(m_pGamePlayer != NULL);
Creature * pDeadPC = m_pGamePlayer->getCreature();
Assert(pDeadPC != NULL);
// 하이드한 상태에서 죽었다면, 하이드를 풀어준다.
pDeadPC->removeFlag(Effect::EFFECT_CLASS_HIDE);
// 무브모드를 바꿔준다.
if (pDeadPC->isVampire() && pDeadPC->isFlag(Effect::EFFECT_CLASS_TRANSFORM_TO_BAT))
{
pDeadPC->setMoveMode(Creature::MOVE_MODE_FLYING);
}
else
{
pDeadPC->setMoveMode(Creature::MOVE_MODE_WALKING);
}
// HP를 채워준다.
if (pDeadPC->isSlayer())
{
Slayer* pSlayer = dynamic_cast<Slayer*>(pDeadPC);
pSlayer->setHP(pSlayer->getHP(ATTR_MAX), ATTR_CURRENT);
}
else if (pDeadPC->isVampire())
{
Vampire* pVampire = dynamic_cast<Vampire*>(pDeadPC);
pVampire->setHP(pVampire->getHP(ATTR_MAX), ATTR_CURRENT);
}
else if (pDeadPC->isOusters())
{
Ousters* pOusters = dynamic_cast<Ousters*>(pDeadPC);
pOusters->setHP(pOusters->getHP(ATTR_MAX), ATTR_CURRENT);
}
// 새 zone을 설정하지 않는다. by sigi. 2002.5.11
Zone* pOldZone = pDeadPC->getZone();
Assert(pOldZone != NULL);
try
{
// 존그룹의 ZPM에서 플레이어를 삭제한다.
pOldZone->getZoneGroup()->getZonePlayerManager()->deletePlayer(m_pGamePlayer->getSocket()->getSOCKET());
// 여기서 설정해줘야지만 Save 이벤트가 IPM에서 동작하지 않는다.
m_pGamePlayer->setPlayerStatus(GPS_WAITING_FOR_CG_READY);
// IPM으로 플레이어를 옮긴다.
//g_pIncomingPlayerManager->pushPlayer(m_pGamePlayer);
pOldZone->getZoneGroup()->getZonePlayerManager()->pushOutPlayer(m_pGamePlayer);
}
catch (NoSuchElementException& t)
{
filelog("eventRessurect.txt", "%s-%s", t.toString().c_str(), pDeadPC->getName().c_str());
cerr << "EventResurrect::activate() : NoSuchElementException" << endl;
//throw Error("존에 플레이어가 존재하지 않습니다.");
// 어떻게 없어졌겠지.. -_-;
// 무시하고.. 그냥 진행한다.
// by sigi. 2002.11.25
}
// 죽었을 당시 killCreature에서 존을 셋팅 하기 때문에 그냥 할당 받으면 된다.
// 이거는 ZonePlayerManager의 heartbeat에서 처리한다.
// 주석처리 by sigi. 2002.5.14
//pDeadPC->registerObject();
/*
// GCUpdateInfo 패킷을 만들어둔다.
GCUpdateInfo gcUpdateInfo;
makeGCUpdateInfo(&gcUpdateInfo, pDeadPC);
m_pGamePlayer->sendPacket(&gcUpdateInfo);
*/
__END_DEBUG
__END_CATCH
}
