//////////////////////////////////////////////////////////////////////////////
// 몬스터 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void AcidBall::execute(Monster* pMonster, Creature* pEnemy)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin(monster)" << endl;
SkillInput input(pMonster);
SkillOutput output;
computeOutput(input, output);
SIMPLE_SKILL_INPUT param;
param.SkillType = getSkillType();
param.SkillDamage = output.Damage;
param.Delay = output.Delay;
param.ItemClass = Item::ITEM_CLASS_MAX;
param.STRMultiplier = 0;
param.DEXMultiplier = 0;
param.INTMultiplier = 0;
param.bMagicHitRoll = true;
param.bMagicDamage = true;
param.bAdd = false;
SIMPLE_SKILL_OUTPUT result;
// 마스터는 여러마리 공격한다.
if (0)//pMonster->isMaster())
{
int x = pMonster->getX();
int y = pMonster->getY();
int Splash = 3 + rand()%5; // 3~7 마리
int range = 2; // 5x5
list<Creature*> creatureList;
getSplashVictims(pMonster->getZone(), x, y, Creature::CREATURE_CLASS_MAX, creatureList, Splash, range);
list<Creature*>::iterator itr = creatureList.begin();
int i=0;
for (; itr != creatureList.end(); itr++)
{
Creature* pTargetCreature = (*itr);
Assert(pTargetCreature != NULL);
if (pMonster!=pTargetCreature)
{
//cout << "Master's AcidBall: " << i << endl;
i++;
g_SimpleMissileSkill.execute(pMonster, pTargetCreature, param, result);
}
}
}
else
{
g_SimpleMissileSkill.execute(pMonster, pEnemy, param, result);
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End(monster)" << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////////////
// 몬스터 오브젝트 핸들러
//////////////////////////////////////////////////////////////////////////////
void Paralyze::execute(Monster* pMonster, Creature* pEnemy)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << "begin " << endl;
Assert(pMonster != NULL);
Assert(pEnemy != NULL);
try
{
Zone* pZone = pMonster->getZone();
Assert(pZone != NULL);
if (pMonster->isFlag(Effect::EFFECT_CLASS_HIDE))
{
//cout << "Monster cannot use skill while hiding." << endl;
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End(monster)" << endl;
return;
}
if (pMonster->isFlag(Effect::EFFECT_CLASS_INVISIBILITY))
{
addVisibleCreature(pZone, pMonster, true);
}
if (pMonster->isMaster())
{
int x = pMonster->getX();
int y = pMonster->getY();
int Splash = 3 + rand()%5; // 3~7 마리
int range = 2; // 5x5
list<Creature*> creatureList;
getSplashVictims(pMonster->getZone(), x, y, Creature::CREATURE_CLASS_MAX, creatureList, Splash, range);
list<Creature*>::iterator itr = creatureList.begin();
for (; itr != creatureList.end(); itr++)
{
Creature* pTargetCreature = (*itr);
Assert(pTargetCreature != NULL);
if (pMonster!=pTargetCreature)
executeMonster(pZone, pMonster, pTargetCreature);
}
}
else
{
executeMonster(pZone, pMonster, pEnemy);
}
}
catch(Throwable & t)
{
executeSkillFailException(pMonster, getSkillType());
}
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " end " << endl;
__END_CATCH
}
//////////////////////////////////////////////////////////////////////
//
// BloodDrain::execute()
//
//////////////////////////////////////////////////////////////////////
void BloodDrain::execute(Monster* pMonster, Creature* pEnemy)
throw(Error)
{
__BEGIN_TRY
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " Begin(monster)" << endl;
Assert(pMonster != NULL);
Assert(pEnemy != NULL);
bool bSuccess = false;
try
{
Zone* pZone = pMonster->getZone();
Assert(pZone != NULL);
if (pMonster->isFlag(Effect::EFFECT_CLASS_HIDE))
{
//cout << "Monster cannot use skill while hiding." << endl;
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End(monster)" << endl;
return;
}
if (pMonster->isFlag(Effect::EFFECT_CLASS_INVISIBILITY))
{
addVisibleCreature(pZone, pMonster, true);
}
// 마스터 : 광역 흡혈 - -;
if (pMonster->isMaster()
#ifdef __UNDERWORLD__
|| pMonster->isUnderworld() || pMonster->getMonsterType() == 599
#endif
)
{
// cout << pMonster->getName() << "가 광역흡혈함" << endl;
int x = pMonster->getX();
int y = pMonster->getY();
int Splash = 3 + rand()%5; // 3~7 마리
int range = 5; // 11 x 11
list<Creature*> creatureList;
getSplashVictims(pMonster->getZone(), x, y, Creature::CREATURE_CLASS_MAX, creatureList, Splash, range);
list<Creature*>::iterator itr = creatureList.begin();
for (; itr != creatureList.end(); itr++)
{
Creature* pTargetCreature = (*itr);
Assert(pTargetCreature != NULL);
if (pMonster!=pTargetCreature)
{
//cout << "BloodDrain: " << pTargetCreature->getName().c_str() << endl;
executeMonster(pMonster, pTargetCreature);
}
}
}
// 일반 몹 : 한 마리
else
{
if (executeMonster(pMonster, pEnemy))
{
bSuccess = true;
}
else
{
executeSkillFailNormal(pMonster, getSkillType(), pEnemy);
}
}
}
catch (Throwable & t)
{
executeSkillFailException(pMonster, getSkillType());
}
// 성공이든 실패든 몬스터에게 딜레이는 걸어준다.
Timeval NextTurn = pMonster->getNextTurn();
Timeval DelayTurn;
DelayTurn.tv_sec = (bSuccess? 4 : 1); // 성공과 실패의 delay를 다르게 한다. by sigi. 2002.9.14
DelayTurn.tv_usec = 500000;
pMonster->addAccuDelay(DelayTurn);
//cout << "TID[" << Thread::self() << "]" << getSkillHandlerName() << " End(monster)" << 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
}
