//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::UpdateUnderwaterState( void )
{
if ( GetWaterLevel() == WL_Eyes )
{
if ( IsPlayerUnderwater() == false )
{
SetPlayerUnderwater( true );
}
return;
}
if ( IsPlayerUnderwater() )
{
SetPlayerUnderwater( false );
}
if ( GetWaterLevel() == 0 )
{
if ( GetFlags() & FL_INWATER )
{
#ifndef CLIENT_DLL
if ( m_iHealth > 0 && IsAlive() )
{
EmitSound( "Player.Wade" );
}
#endif
RemoveFlag( FL_INWATER );
}
}
else if ( !(GetFlags() & FL_INWATER) )
{
#ifndef CLIENT_DLL
// player enter water sound
if (GetWaterType() == CONTENTS_WATER)
{
EmitSound( "Player.Wade" );
}
#endif
AddFlag( FL_INWATER );
}
}
void Item::SetSoulboundTradeable(AllowedLooterSet* allowedLooters, Player* currentOwner, bool apply)
{
if (apply)
{
SetFlag(ITEM_FIELD_FLAGS, ITEM_FLAG_BOP_TRADEABLE);
allowedGUIDs = *allowedLooters;
}
else
{
RemoveFlag(ITEM_FIELD_FLAGS, ITEM_FLAG_BOP_TRADEABLE);
if (allowedGUIDs.empty())
return;
allowedGUIDs.clear();
SetState(ITEM_CHANGED, currentOwner);
PreparedStatement* stmt = CharDB.GetPreparedStatement(CHAR_DEL_ITEM_BOP_TRADE);
stmt->setUInt32(0, GetGUIDLow());
CharDB.Execute(stmt);
}
}
void CASW_Parasite::DoJumpFromEgg()
{
SetContextThink( NULL, gpGlobals->curtime, s_pParasiteAnimThink );
SetParent( NULL );
SetAbsOrigin( GetAbsOrigin() + Vector( 0, 0, 30 ) ); // TODO: position parasite at where his 'idle in egg' animation has him. This has to be some distance off the ground, else the jump will immediately end.
Vector dir = vec3_origin;
AngleVectors( GetAbsAngles(), &dir );
//Vector vecJumpPos = GetAbsOrigin()+ Vector(19,0,60)+ dir * m_flEggJumpDistance;
Vector vecJumpPos = GetAbsOrigin() + dir * m_flEggJumpDistance;
SetActivity( ACT_RANGE_ATTACK1 );
StudioFrameAdvanceManual( 0.0 );
SetParent( NULL );
RemoveFlag( FL_FLY );
AddEffects( EF_NOINTERP );
m_bDoEggIdle = false;
GetMotor()->SetIdealYaw( GetAbsAngles().y );
JumpAttack( false, vecJumpPos, false );
}
void Item::UpdateDuration(Player* owner, uint32 diff)
{
if (!GetUInt32Value(ITEM_FIELD_DURATION))
return;
//DEBUG_LOG("Item::UpdateDuration Item (Entry: %u Duration %u Diff %u)",GetEntry(),GetUInt32Value(ITEM_FIELD_DURATION),diff);
if (GetUInt32Value(ITEM_FIELD_DURATION)<=diff)
{
owner->DestroyItem(GetBagSlot(), GetSlot(), true);
return;
}
SetUInt32Value(ITEM_FIELD_DURATION, GetUInt32Value(ITEM_FIELD_DURATION) - diff);
SetState(ITEM_CHANGED, owner); // save new time in database
//Remove refundable flag for next time if item is no logner refundable
if(HasFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_REFUNDABLE))
if(!GetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME) || (GetOwner() && GetOwner()->m_Played_time[0] > (GetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME) + 2*60*60)))
RemoveFlag(ITEM_FIELD_FLAGS, ITEM_FLAGS_REFUNDABLE);
}
/*
============
idBrushBSPNode::RemoveFlagRecurseFlood
============
*/
void idBrushBSPNode::RemoveFlagRecurseFlood( int flag )
{
RemoveFlag( flag );
if( !children[0] && !children[1] )
{
RemoveFlagFlood( flag );
}
else
{
if( children[0] )
{
children[0]->RemoveFlagRecurseFlood( flag );
}
if( children[1] )
{
children[1]->RemoveFlagRecurseFlood( flag );
}
}
}
bool CHL1NPCTalker::HandleInteraction(int interactionType, void *data, CBaseCombatCharacter* sourceEnt)
{
if (interactionType == g_interactionBarnacleVictimDangle)
{
// Force choosing of a new schedule
ClearSchedule();
m_bInBarnacleMouth = true;
return true;
}
else if ( interactionType == g_interactionBarnacleVictimReleased )
{
SetState ( NPC_STATE_IDLE );
CPASAttenuationFilter filter( this );
EmitSound( filter, entindex(), CHAN_VOICE, "barney/ba_close.wav", 1, SNDLVL_TALKING, 0, GetExpresser()->GetVoicePitch());
m_bInBarnacleMouth = false;
SetAbsVelocity( vec3_origin );
SetMoveType( MOVETYPE_STEP );
return true;
}
else if ( interactionType == g_interactionBarnacleVictimGrab )
{
if ( GetFlags() & FL_ONGROUND )
{
RemoveFlag( FL_ONGROUND );
}
if ( GetState() == NPC_STATE_SCRIPT )
{
m_hCine->CancelScript();
ClearSchedule();
}
SetState( NPC_STATE_PRONE );
PainSound();
return true;
}
return false;
}
void CWndWindow::InitialUpdate()
{
m_data = DataMng->GetWindow(m_ID);
if (!m_data)
return;
m_flags |= m_data->flags;
if (HasFlag(WBS_NOFRAME))
RemoveFlag(WBS_CAPTION);
SetRect(QRect(QPoint(10, 10), m_data->size), false);
m_text = m_data->title;
SetTexture(m_data->texture, m_data->tiles);
m_closeButton = new CWndButton(m_render2D);
m_closeButton->Create(WTBID_CLOSE, QRect(), WBS_DOCKING, this);
m_closeButton->SetTexture("ButtWndExit.tga", false);
m_closeButton->FitTextureSize();
for (int i = 0; i < m_data->controls.GetSize(); i++)
CreateControl(m_data->controls[i]);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CNPC_CeilingTurret::OnTakeDamage( const CTakeDamageInfo &inputInfo )
{
if ( !m_takedamage )
return 0;
CTakeDamageInfo info = inputInfo;
if ( m_bActive == false )
info.ScaleDamage( 0.1f );
// If attacker can't do at least the min required damage to us, don't take any damage from them
if ( info.GetDamage() < m_iMinHealthDmg )
return 0;
m_iHealth -= info.GetDamage();
if ( m_iHealth <= 0 )
{
m_iHealth = 0;
m_takedamage = DAMAGE_NO;
RemoveFlag( FL_NPC ); // why are they set in the first place???
//FIXME: This needs to throw a ragdoll gib or something other than animating the retraction -- jdw
ExplosionCreate( GetAbsOrigin(), GetLocalAngles(), this, 100, 100, false );
SetThink( &CNPC_CeilingTurret::DeathThink );
StopSound( "NPC_CeilingTurret.Alert" );
m_OnDamaged.FireOutput( info.GetInflictor(), this );
SetNextThink( gpGlobals->curtime + 0.1f );
return 0;
}
return 1;
}
int CBaseTurret::OnTakeDamage( const CTakeDamageInfo &inputInfo )
{
if ( !m_takedamage )
return 0;
CTakeDamageInfo info = inputInfo;
if (!m_iOn)
info.ScaleDamage( 0.1f );
m_iHealth -= info.GetDamage();
if (m_iHealth <= 0)
{
m_iHealth = 0;
m_takedamage = DAMAGE_NO;
m_flDamageTime = gpGlobals->curtime;
RemoveFlag( FL_NPC ); // why are they set in the first place???
SetThink(TurretDeath);
m_OnDamaged.FireOutput( info.GetInflictor(), this );
SetNextThink( gpGlobals->curtime + 0.1f );
return 0;
}
if (m_iHealth <= 10)
{
if (m_iOn && (1 || random->RandomInt(0, 0x7FFF) > 800))
{
m_fBeserk = 1;
SetThink(SearchThink);
}
}
return 1;
}
void Creature::OnRespawn(MapMgr * m)
{
sLog.outDetail("Respawning "I64FMT"...", GetGUID());
SetUInt32Value(UNIT_FIELD_HEALTH, GetUInt32Value(UNIT_FIELD_MAXHEALTH));
SetUInt32Value(UNIT_DYNAMIC_FLAGS, 0); // not tagging shiat
if(proto && m_spawn)
{
SetUInt32Value(UNIT_NPC_FLAGS, proto->NPCFLags);
SetUInt32Value(UNIT_NPC_EMOTESTATE, m_spawn->emote_state);
}
RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE);
Skinned = false;
Tagged = false;
TaggerGuid = 0;
m_lootMethod = -1;
/* creature death state */
if(proto && proto->death_state == 1)
{
uint32 newhealth = m_uint32Values[UNIT_FIELD_HEALTH] / 100;
if(!newhealth)
newhealth = 1;
SetUInt32Value(UNIT_FIELD_HEALTH, 1);
m_limbostate = true;
bInvincible = true;
SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_STATE_DEAD);
}
//empty loot
loot.items.clear();
setDeathState(ALIVE);
GetAIInterface()->StopMovement(0); // after respawn monster can move
m_PickPocketed = false;
PushToWorld(m);
}
// input functions
void InputEnable( inputdata_t &inputdata )
{
RemoveFlag( FL_DONTTOUCH );
}
/// \brief
/// Translates the VCullMode value to the face culling bitflags and sets them in the simple render state object.
inline void SetFaceCullMode(VCullMode iMode)
{
SetFlag(RENDERSTATEFLAG_DOUBLESIDED);
if (iMode == CULL_FRONT) RemoveFlag(RENDERSTATEFLAG_FRONTFACE);
if (iMode == CULL_BACK) RemoveFlag(RENDERSTATEFLAG_BACKFACE);
}
void CPWL_Edit::EnableSpellCheck(FX_BOOL bEnabled) {
if (bEnabled)
AddFlag(PES_SPELLCHECK);
else
RemoveFlag(PES_SPELLCHECK);
}
//-----------------------------------------------------------------------------
// Purpose: Allow pre-frame adjustments on the player
//-----------------------------------------------------------------------------
void CHL1_Player::PreThink(void)
{
CheckExplosionEffects();
if ( player_showpredictedposition.GetBool() )
{
Vector predPos;
UTIL_PredictedPosition( this, player_showpredictedposition_timestep.GetFloat(), &predPos );
NDebugOverlay::Box( predPos, NAI_Hull::Mins( GetHullType() ), NAI_Hull::Maxs( GetHullType() ), 0, 255, 0, 0, 0.01f );
NDebugOverlay::Line( GetAbsOrigin(), predPos, 0, 255, 0, 0, 0.01f );
}
int buttonsChanged;
buttonsChanged = m_afButtonPressed | m_afButtonReleased;
g_pGameRules->PlayerThink( this );
if ( g_fGameOver || IsPlayerLockedInPlace() )
return; // intermission or finale
ItemPreFrame( );
WaterMove();
if ( g_pGameRules && g_pGameRules->FAllowFlashlight() )
m_Local.m_iHideHUD &= ~HIDEHUD_FLASHLIGHT;
else
m_Local.m_iHideHUD |= HIDEHUD_FLASHLIGHT;
// checks if new client data (for HUD and view control) needs to be sent to the client
UpdateClientData();
CheckTimeBasedDamage();
CheckSuitUpdate();
if (m_lifeState >= LIFE_DYING)
{
PlayerDeathThink();
return;
}
// So the correct flags get sent to client asap.
//
if ( m_afPhysicsFlags & PFLAG_DIROVERRIDE )
AddFlag( FL_ONTRAIN );
else
RemoveFlag( FL_ONTRAIN );
// Train speed control
if ( m_afPhysicsFlags & PFLAG_DIROVERRIDE )
{
CBaseEntity *pTrain = GetGroundEntity();
float vel;
if ( pTrain )
{
if ( !(pTrain->ObjectCaps() & FCAP_DIRECTIONAL_USE) )
pTrain = NULL;
}
if ( !pTrain )
{
if ( GetActiveWeapon() && (GetActiveWeapon()->ObjectCaps() & FCAP_DIRECTIONAL_USE) )
{
m_iTrain = TRAIN_ACTIVE | TRAIN_NEW;
if ( m_nButtons & IN_FORWARD )
{
m_iTrain |= TRAIN_FAST;
}
else if ( m_nButtons & IN_BACK )
{
m_iTrain |= TRAIN_BACK;
}
else
{
m_iTrain |= TRAIN_NEUTRAL;
}
return;
}
else
{
trace_t trainTrace;
// Maybe this is on the other side of a level transition
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + Vector(0,0,-38),
MASK_PLAYERSOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &trainTrace );
if ( trainTrace.fraction != 1.0 && trainTrace.m_pEnt )
pTrain = trainTrace.m_pEnt;
if ( !pTrain || !(pTrain->ObjectCaps() & FCAP_DIRECTIONAL_USE) || !pTrain->OnControls(GetContainingEntity(pev)) )
{
// Warning( "In train mode with no train!\n" );
m_afPhysicsFlags &= ~PFLAG_DIROVERRIDE;
m_iTrain = TRAIN_NEW|TRAIN_OFF;
return;
}
}
}
else if ( !( GetFlags() & FL_ONGROUND ) || pTrain->HasSpawnFlags( SF_TRACKTRAIN_NOCONTROL ) || (m_nButtons & (IN_MOVELEFT|IN_MOVERIGHT) ) )
{
// Turn off the train if you jump, strafe, or the train controls go dead
m_afPhysicsFlags &= ~PFLAG_DIROVERRIDE;
m_iTrain = TRAIN_NEW|TRAIN_OFF;
return;
}
SetAbsVelocity( vec3_origin );
vel = 0;
if ( m_afButtonPressed & IN_FORWARD )
{
vel = 1;
pTrain->Use( this, this, USE_SET, (float)vel );
}
else if ( m_afButtonPressed & IN_BACK )
{
vel = -1;
pTrain->Use( this, this, USE_SET, (float)vel );
}
if (vel)
{
m_iTrain = TrainSpeed(pTrain->m_flSpeed, ((CFuncTrackTrain*)pTrain)->GetMaxSpeed());
m_iTrain |= TRAIN_ACTIVE|TRAIN_NEW;
}
}
else if (m_iTrain & TRAIN_ACTIVE)
{
m_iTrain = TRAIN_NEW; // turn off train
}
// THIS CODE DOESN'T SEEM TO DO ANYTHING!!!
// WHY IS IT STILL HERE? (sjb)
if (m_nButtons & IN_JUMP)
{
// If on a ladder, jump off the ladder
// else Jump
Jump();
}
// If trying to duck, already ducked, or in the process of ducking
if ((m_nButtons & IN_DUCK) || (GetFlags() & FL_DUCKING) || (m_afPhysicsFlags & PFLAG_DUCKING) )
Duck();
//
// If we're not on the ground, we're falling. Update our falling velocity.
//
if ( !( GetFlags() & FL_ONGROUND ) )
{
m_Local.m_flFallVelocity = -GetAbsVelocity().z;
}
if ( m_afPhysicsFlags & PFLAG_ONBARNACLE )
{
SetAbsVelocity( vec3_origin );
}
// StudioFrameAdvance( );//!!!HACKHACK!!! Can't be hit by traceline when not animating?
//Find targets for NPC to shoot if they decide to miss us
FindMissTargets();
}
void BlobGame::handleMessage(const Message& msg){
switch(msg.type){
case 2:{
Unit* unit = (Unit*)msg.extraInfo;
for(int i = 0;i < m_GameObjects->size();i++){
if((*m_GameObjects)[i] == unit){
m_GameObjects->erase(m_GameObjects->begin()+i);
SafePtrRelease(unit);
return;
}
}
break;
}
case PISTOL_ATTACK:{
Unit* unit;
Tile* tile = (Tile*)msg.extraInfo;
if((unit = unitOnTile(tile))){
unit->hit(PISTOL_DAMAGE);
MessageHandler::Instance()->deleteMessage(msg.name);
}
break;
}
case REMOVE_TILE_EFFECT:{
Tile* tile = (Tile*)msg.extraInfo;
unsigned int tileStatuses = tile->getTileTypes();
if(msg.name == "Fire"){
if(ContainsFlags(tile->getTileTypes(),Fire)){
RemoveFlag(&tileStatuses,Fire);
tile->setTileTypes(tileStatuses);
}
}
else if(msg.name == "Posion"){
if(ContainsFlags(tile->getTileTypes(),Posion)){
RemoveFlag(&tileStatuses,Posion);
tile->setTileTypes(tileStatuses);
}
}
else if(msg.name == "Slime"){
if(ContainsFlags(tile->getTileTypes(),Slime)){
RemoveFlag(&tileStatuses,Slime);
tile->setTileTypes(tileStatuses);
}
}
for(int i = 0;i < m_Effects->size();i++){
if((*m_Effects)[i]->getName() ==
(msg.name + "_" + tile->getName())){
Sprite2d* sprite = (*m_Effects)[i];
m_Effects->erase(m_Effects->begin()+i);
SpriteManager::instance()->deleteSprite(sprite);
}
}
}
case 5:{
for(int i = 0;i < m_GameObjects->size();i++){
if((*m_GameObjects)[i]->getName() == msg.name){
Enemy* enemy = (Enemy*)(*m_GameObjects)[i];
enemy->hold();
return;
}
}
break;
}
case 6:{
for(int i = 0;i < m_GameObjects->size();i++){
if((*m_GameObjects)[i]->getName() == msg.name){
Unit* unit = (Unit*)(*m_GameObjects)[i];
unit->hit(unit->getHealth());
return;
}
}
break;
}
case REMOVE_UNIT_STATUS:{
Unit* unit = (Unit*)msg.extraInfo;
unsigned int unitStatuses = unit->getStatus();
if(msg.name == "Fire"){
if(ContainsFlags(unit->getStatus(),OnFire)){
RemoveFlag(&unitStatuses,OnFire);
unit->setStatus(unitStatuses);
}
}
else if(msg.name == "Posioned"){
if(ContainsFlags(unit->getStatus(),Posioned)){
RemoveFlag(&unitStatuses,Posioned);
unit->setStatus(unitStatuses);
}
}
else if(msg.name == "Slowed"){
if(ContainsFlags(unit->getStatus(),Slowed)){
RemoveFlag(&unitStatuses,Slowed);
unit->setStatus(unitStatuses);
}
}
break;
}
case CHANGE_STATE:{
int s = (int)msg.extraInfo;
changeState((BlobGameStates)s);
break;
}
case LOAD_LEVEL_EDITOR:{
if(m_CurrentState == Editor){
int level = (int)msg.extraInfo - 1;
if(level < 0){
int tileTypes[MAX_HORIZONTAL_TILES*MAX_VERTICAL_TILES];
for(int i = 0;i < (MAX_HORIZONTAL_TILES*MAX_VERTICAL_TILES);i++){
tileTypes[i] = Empty;
}
Level* newLevel = new Level(MAX_HORIZONTAL_TILES,MAX_VERTICAL_TILES,
TILE_SIZE,tileTypes,NULL,NULL);
m_Editor = new LevelEditor(newLevel,m_Camera);
m_Editing = true;
SafePtrRelease(m_LevelSelect);
if(m_GameObjects != NULL){
SafeVectorDelete((*m_GameObjects));
SafePtrRelease(m_GameObjects);
}
return;
}
else{
DIR* dir;
struct stat fileStat;
struct dirent* dirp;
std::string levelName;
std::string filePath;
unsigned int width;
unsigned int height;
int i = 0;
dir = opendir("levels");
if(dir == NULL){
std::cout << "Levels not found!" << std::endl;
return;
}
while(i <= level && (dirp = readdir(dir))){
filePath = "levels/" + std::string(dirp->d_name);
if(stat(filePath.c_str(),&fileStat)){continue;}
if(S_ISDIR(fileStat.st_mode)){continue;}
if(loadPreview(&levelName,&width,&height,filePath)){
if(i == level){
m_Editing = true;
m_Editor = new LevelEditor(NULL,m_Camera);
m_Editor->loadLevelToEditor(filePath);
SafePtrRelease(dir);
SafePtrRelease(m_LevelSelect);
if(m_GameObjects != NULL){
SafeVectorDelete((*m_GameObjects));
SafePtrRelease(m_GameObjects);
}
return;
}
else{
i++;
}
}
}
}
break;
}
}
case LOAD_LEVEL:{
if(m_CurrentState == LevelSelect){
int level = (int)msg.extraInfo;
if(level >= 0){
DIR* dir;
struct stat fileStat;
struct dirent* dirp;
std::string levelName;
std::string filePath;
unsigned int width;
unsigned int height;
int i = 0;
dir = opendir("levels");
if(dir == NULL){
std::cout << "Levels not found!" << std::endl;
return;
}
while(i <= level && (dirp = readdir(dir))){
filePath = "levels/" + std::string(dirp->d_name);
if(stat(filePath.c_str(),&fileStat)){continue;}
if(S_ISDIR(fileStat.st_mode)){continue;}
if(loadPreview(&levelName,&width,&height,filePath)){
if(i == level){
SafePtrRelease(dir);
changeGameState((void*)GamePlay);
m_LevelToLoad = filePath;
return;
}
else{
i++;
}
}
}
}
break;
}
}
default:
break;
}
}
void Transport::BuildStopMovePacket(Map const* targetMap)
{
RemoveFlag(GAMEOBJECT_FLAGS, GO_FLAG_IN_USE);
SetGoState(GO_STATE_READY);
UpdateForMap(targetMap);
}
void ClearEntityNearViewRange() {
RemoveFlag(entity_near);
}
//=========================================================
// HandleAnimEvent - catches the monster-specific messages
// that occur when tagged animation frames are played.
//=========================================================
void CNPC_Bullsquid::HandleAnimEvent( animevent_t *pEvent )
{
switch( pEvent->event )
{
case BSQUID_AE_SPIT:
{
if ( GetEnemy() )
{
Vector vecSpitOffset;
Vector vecSpitDir;
Vector vRight, vUp, vForward;
AngleVectors ( GetAbsAngles(), &vForward, &vRight, &vUp );
// !!!HACKHACK - the spot at which the spit originates (in front of the mouth) was measured in 3ds and hardcoded here.
// we should be able to read the position of bones at runtime for this info.
vecSpitOffset = ( vRight * 8 + vForward * 60 + vUp * 50 );
vecSpitOffset = ( GetAbsOrigin() + vecSpitOffset );
vecSpitDir = ( ( GetEnemy()->BodyTarget( GetAbsOrigin() ) ) - vecSpitOffset );
VectorNormalize( vecSpitDir );
vecSpitDir.x += random->RandomFloat( -0.05, 0.05 );
vecSpitDir.y += random->RandomFloat( -0.05, 0.05 );
vecSpitDir.z += random->RandomFloat( -0.05, 0 );
AttackSound();
CSquidSpit::Shoot( this, vecSpitOffset, vecSpitDir * 900 );
}
}
break;
case BSQUID_AE_BITE:
{
// SOUND HERE!
CBaseEntity *pHurt = CheckTraceHullAttack( 70, Vector(-16,-16,-16), Vector(16,16,16), sk_bullsquid_dmg_bite.GetFloat(), DMG_SLASH );
if ( pHurt )
{
Vector forward, up;
AngleVectors( GetAbsAngles(), &forward, NULL, &up );
pHurt->SetAbsVelocity( pHurt->GetAbsVelocity() - (forward * 100) );
pHurt->SetAbsVelocity( pHurt->GetAbsVelocity() + (up * 100) );
pHurt->RemoveFlag( FL_ONGROUND );
}
}
break;
case BSQUID_AE_TAILWHIP:
{
CBaseEntity *pHurt = CheckTraceHullAttack( 70, Vector(-16,-16,-16), Vector(16,16,16), sk_bullsquid_dmg_whip.GetFloat(), DMG_SLASH | DMG_ALWAYSGIB );
if ( pHurt )
{
Vector right, up;
AngleVectors( GetAbsAngles(), NULL, &right, &up );
if ( pHurt->GetFlags() & ( FL_NPC | FL_CLIENT ) )
pHurt->ViewPunch( QAngle( 20, 0, -20 ) );
pHurt->SetAbsVelocity( pHurt->GetAbsVelocity() + (right * 200) );
pHurt->SetAbsVelocity( pHurt->GetAbsVelocity() + (up * 100) );
}
}
break;
case BSQUID_AE_BLINK:
{
// close eye.
m_nSkin = 1;
}
break;
case BSQUID_AE_HOP:
{
float flGravity = sv_gravity.GetFloat();
// throw the squid up into the air on this frame.
if ( GetFlags() & FL_ONGROUND )
{
RemoveFlag( FL_ONGROUND );
}
// jump into air for 0.8 (24/30) seconds
Vector vecVel = GetAbsVelocity();
vecVel.z += ( 0.625 * flGravity ) * 0.5;
SetAbsVelocity( vecVel );
}
break;
case BSQUID_AE_THROW:
{
int iPitch;
// squid throws its prey IF the prey is a client.
CBaseEntity *pHurt = CheckTraceHullAttack( 70, Vector(-16,-16,-16), Vector(16,16,16), 0, 0 );
if ( pHurt )
{
// croonchy bite sound
iPitch = random->RandomFloat( 90, 110 );
CPASAttenuationFilter filter( this );
switch ( random->RandomInt( 0, 1 ) )
{
case 0:
enginesound->EmitSound( filter, entindex(), CHAN_WEAPON, "bullchicken/bc_bite2.wav", 1, ATTN_NORM, 0, iPitch );
break;
case 1:
enginesound->EmitSound( filter, entindex(), CHAN_WEAPON, "bullchicken/bc_bite3.wav", 1, ATTN_NORM, 0, iPitch );
break;
}
// screeshake transforms the viewmodel as well as the viewangle. No problems with seeing the ends of the viewmodels.
UTIL_ScreenShake( pHurt->GetAbsOrigin(), 25.0, 1.5, 0.7, 2, SHAKE_START );
if ( pHurt->IsPlayer() )
{
Vector forward, up;
AngleVectors( GetAbsAngles(), &forward, NULL, &up );
pHurt->SetAbsVelocity( pHurt->GetAbsVelocity() + forward * 300 + up * 300 );
}
}
}
break;
default:
BaseClass::HandleAnimEvent( pEvent );
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void CBaseHelicopter::Flight( void )
{
if( GetFlags() & FL_ONGROUND )
{
//This would be really bad.
RemoveFlag( FL_ONGROUND );
}
// Generic speed up
if (m_flGoalSpeed < m_flMaxSpeed)
{
m_flGoalSpeed += GetAcceleration();
}
//NDebugOverlay::Line(GetAbsOrigin(), m_vecDesiredPosition, 0,0,255, true, 0.1);
// tilt model 5 degrees (why?! sjb)
QAngle vecAdj = QAngle( 5.0, 0, 0 );
// estimate where I'll be facing in one seconds
Vector forward, right, up;
AngleVectors( GetLocalAngles() + GetLocalAngularVelocity() * 2 + vecAdj, &forward, &right, &up );
// Vector vecEst1 = GetLocalOrigin() + GetAbsVelocity() + up * m_flForce - Vector( 0, 0, 384 );
// float flSide = DotProduct( m_vecDesiredPosition - vecEst1, right );
QAngle angVel = GetLocalAngularVelocity();
float flSide = DotProduct( m_vecDesiredFaceDir, right );
if (flSide < 0)
{
if (angVel.y < 60)
{
angVel.y += 8;
}
}
else
{
if (angVel.y > -60)
{
angVel.y -= 8;
}
}
angVel.y *= ( 0.98 ); // why?! (sjb)
// estimate where I'll be in two seconds
AngleVectors( GetLocalAngles() + angVel * 1 + vecAdj, NULL, NULL, &up );
Vector vecEst = GetAbsOrigin() + GetAbsVelocity() * 2.0 + up * m_flForce * 20 - Vector( 0, 0, 384 * 2 );
// add immediate force
AngleVectors( GetLocalAngles() + vecAdj, &forward, &right, &up );
Vector vecImpulse( 0, 0, 0 );
vecImpulse.x += up.x * m_flForce;
vecImpulse.y += up.y * m_flForce;
vecImpulse.z += up.z * m_flForce;
// add gravity
vecImpulse.z -= 38.4; // 32ft/sec
ApplyAbsVelocityImpulse( vecImpulse );
float flSpeed = GetAbsVelocity().Length();
float flDir = DotProduct( Vector( forward.x, forward.y, 0 ), Vector( GetAbsVelocity().x, GetAbsVelocity().y, 0 ) );
if (flDir < 0)
{
flSpeed = -flSpeed;
}
float flDist = DotProduct( GetDesiredPosition() - vecEst, forward );
// float flSlip = DotProduct( GetAbsVelocity(), right );
float flSlip = -DotProduct( GetDesiredPosition() - vecEst, right );
// fly sideways
if (flSlip > 0)
{
if (GetLocalAngles().z > -30 && angVel.z > -15)
angVel.z -= 4;
else
angVel.z += 2;
}
else
{
if (GetLocalAngles().z < 30 && angVel.z < 15)
angVel.z += 4;
else
angVel.z -= 2;
}
// These functions contain code Ken wrote that used to be right here as part of the flight model,
// but we want different helicopter vehicles to have different drag characteristics, so I made
// them virtual functions (sjb)
ApplySidewaysDrag( right );
ApplyGeneralDrag();
// apply power to stay correct height
// FIXME: these need to be per class variables
#define MAX_FORCE 80
#define FORCE_POSDELTA 12
#define FORCE_NEGDELTA 8
if (m_flForce < MAX_FORCE && vecEst.z < GetDesiredPosition().z)
{
m_flForce += FORCE_POSDELTA;
}
else if (m_flForce > 30)
{
if (vecEst.z > GetDesiredPosition().z)
m_flForce -= FORCE_NEGDELTA;
}
// pitch forward or back to get to target
//-----------------------------------------
// Pitch is reversed since Half-Life! (sjb)
//-----------------------------------------
if (flDist > 0 && flSpeed < m_flGoalSpeed /* && flSpeed < flDist */ && GetLocalAngles().x + angVel.x < 40)
{
// ALERT( at_console, "F " );
// lean forward
angVel.x += 12.0;
}
else if (flDist < 0 && flSpeed > -50 && GetLocalAngles().x + angVel.x > -20)
{
// ALERT( at_console, "B " );
// lean backward
angVel.x -= 12.0;
}
else if (GetLocalAngles().x + angVel.x < 0)
{
// ALERT( at_console, "f " );
angVel.x += 4.0;
}
else if (GetLocalAngles().x + angVel.x > 0)
{
// ALERT( at_console, "b " );
angVel.x -= 4.0;
}
SetLocalAngularVelocity( angVel );
// ALERT( at_console, "%.0f %.0f : %.0f %.0f : %.0f %.0f : %.0f\n", GetAbsOrigin().x, GetAbsVelocity().x, flDist, flSpeed, GetLocalAngles().x, m_vecAngVelocity.x, m_flForce );
// ALERT( at_console, "%.0f %.0f : %.0f %0.f : %.0f\n", GetAbsOrigin().z, GetAbsVelocity().z, vecEst.z, m_vecDesiredPosition.z, m_flForce );
}
void Vehicle::RemovePassenger(Unit *unit)
{
SeatMap::iterator seat;
for(seat = m_Seats.begin(); seat != m_Seats.end(); ++seat)
{
if((seat->second.flags & (SEAT_FULL | SEAT_VEHICLE_FREE | SEAT_VEHICLE_FULL)) && seat->second.passenger == unit)
{
unit->SetVehicleGUID(0);
if(unit->GetTypeId() == TYPEID_PLAYER)
{
((Player*)unit)->SetMover(unit);
((Player*)unit)->SetClientControl(unit, 1);
((Player*)unit)->GetCamera().SetView(unit);
}
if(seat->second.vs_flags & SF_MAIN_RIDER)
{
RemoveSpellsCausingAura(SPELL_AURA_CONTROL_VEHICLE);
if(unit->GetTypeId() == TYPEID_PLAYER)
{
((Player*)unit)->RemovePetActionBar();
if(((Player*)unit)->GetGroup())
((Player*)unit)->SetGroupUpdateFlag(GROUP_UPDATE_VEHICLE);
}
unit->SetCharm(NULL);
SetCharmerGUID(NULL);
setFaction(GetCreatureInfo()->faction_A);
}
if(GetVehicleFlags() & VF_NON_SELECTABLE)
RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
if(seat->second.vs_flags & SF_UNATTACKABLE)
unit->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
// restore player control
if(unit->GetTypeId() == TYPEID_PLAYER)
{
if(seat->second.vs_flags & SF_CAN_CAST)
{
WorldPacket data0(SMSG_FORCE_MOVE_UNROOT, 10);
data0 << unit->GetPackGUID();
data0 << (uint32)(2); // can rotate
unit->SendMessageToSet(&data0,true);
}
else
{
WorldPacket data1(SMSG_FORCE_MOVE_UNROOT, 10);
data1 << unit->GetPackGUID();
data1 << (uint32)(0); // cannot rotate
unit->SendMessageToSet(&data1,true);
}
}
unit->m_movementInfo.RemoveMovementFlag(MOVEFLAG_ONTRANSPORT);
unit->m_movementInfo.RemoveMovementFlag(MOVEFLAG_ROOT);
unit->m_movementInfo.ClearTransportData();
seat->second.passenger = NULL;
seat->second.flags = SEAT_FREE;
EmptySeatsCountChanged();
break;
}
}
}
void Creature::Update(uint32 diff)
{
switch( m_deathState )
{
case JUST_DIED:
// Dont must be called, see Creature::setDeathState JUST_DIED -> CORPSE promoting.
sLog.outError("Creature (GUIDLow: %u Entry: %u ) in wrong state: JUST_DEAD (1)",GetGUIDLow(),GetEntry());
break;
case DEAD:
{
if( m_respawnTime <= time(NULL) )
{
DEBUG_LOG("Respawning...");
m_respawnTime = 0;
CreatureInfo const *cinfo = objmgr.GetCreatureTemplate(this->GetEntry());
SelectLevel(cinfo);
SetUInt32Value(UNIT_DYNAMIC_FLAGS, 0);
RemoveFlag (UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE);
SetUInt32Value(UNIT_NPC_FLAGS, cinfo->npcflag);
SetHealth(GetMaxHealth());
setDeathState( ALIVE );
clearUnitState(UNIT_STAT_ALL_STATE);
i_motionMaster.Clear();
MapManager::Instance().GetMap(GetMapId(), this)->Add(this);
}
break;
}
case CORPSE:
{
if( m_deathTimer <= diff )
{
m_deathTimer = 0;
DEBUG_LOG("Removing corpse... %u ", GetUInt32Value(OBJECT_FIELD_ENTRY));
ObjectAccessor::Instance().RemoveCreatureCorpseFromPlayerView(this);
lootForPickPocketed = false;
lootForBody = false;
loot.clear();
setDeathState(DEAD);
m_respawnTime = time(NULL) + m_respawnDelay;
float x,y,z;
GetRespawnCoord(x, y, z);
MapManager::Instance().GetMap(GetMapId(), this)->CreatureRelocation(this,x,y,z,GetOrientation());
}
else
{
m_deathTimer -= diff;
if (m_groupLootTimer && lootingGroupLeaderGUID)
{
if(diff <= m_groupLootTimer)
{
m_groupLootTimer -= diff;
}
else
{
Group* group = objmgr.GetGroupByLeader(lootingGroupLeaderGUID);
if (group)
group->EndRoll();
m_groupLootTimer = 0;
lootingGroupLeaderGUID = 0;
}
}
}
break;
}
case ALIVE:
{
Unit::Update( diff );
i_motionMaster.UpdateMotion(diff);
i_AI->UpdateAI(diff);
if(m_regenTimer > 0)
{
if(diff >= m_regenTimer)
m_regenTimer = 0;
else
m_regenTimer -= diff;
}
if (m_regenTimer != 0)
break;
if (!isInCombat())
{
RegenerateHealth();
RegenerateMana();
}
m_regenTimer = 2000;
break;
}
default:
break;
}
}
//=========================================================
// HandleAnimEvent - catches the monster-specific messages
// that occur when tagged animation frames are played.
//=========================================================
void CNPC_Bullsquid::HandleAnimEvent( animevent_t *pEvent )
{
switch( pEvent->event )
{
case BSQUID_AE_SPIT:
{
if ( GetEnemy() )
{
Vector vSpitPos;
QAngle vSpitAngle;
GetAttachment( "Mouth", vSpitPos, vSpitAngle);
Vector vTarget = GetEnemy()->GetAbsOrigin();
Vector vToss;
CBaseEntity* pBlocker;
float flGravity = sv_gravity.GetFloat() * SPIT_GRAVITY;
ThrowLimit(vSpitPos, vTarget, flGravity, 3, Vector(0,0,0), Vector(0,0,0), GetEnemy(), &vToss, &pBlocker);
CGrenadeSpit *pGrenade = (CGrenadeSpit*)CreateNoSpawn( "grenade_spit", vSpitPos, vec3_angle, this );
//pGrenade->KeyValue( "velocity", vToss );
pGrenade->Spawn( );
pGrenade->SetOwner( this );
pGrenade->SetOwnerEntity( this );
pGrenade->SetSpitSize( 2 );
pGrenade->SetAbsVelocity( vToss );
// Tumble through the air
pGrenade->SetLocalAngularVelocity(
QAngle(
random->RandomFloat ( -100, -500 ),
random->RandomFloat ( -100, -500 ),
random->RandomFloat ( -100, -500 )
)
);
AttackSound();
CPVSFilter filter( vSpitPos );
te->SpriteSpray( filter, 0.0,
&vSpitPos, &vToss, m_nSquidSpitSprite, 5, 10, 15 );
}
}
break;
case BSQUID_AE_BITE:
{
// SOUND HERE!
CBaseEntity *pHurt = CheckTraceHullAttack( 70, Vector(-16,-16,-16), Vector(16,16,16), sk_bullsquid_dmg_bite.GetFloat(), DMG_SLASH );
if ( pHurt )
{
Vector forward, up;
AngleVectors( GetAbsAngles(), &forward, NULL, &up );
pHurt->SetAbsVelocity( pHurt->GetAbsVelocity() - (forward * 100) );
pHurt->SetAbsVelocity( pHurt->GetAbsVelocity() + (up * 100) );
pHurt->RemoveFlag( FL_ONGROUND );
}
}
break;
case BSQUID_AE_WHIP_SND:
{
EmitSound( "NPC_Bullsquid.TailWhip" );
break;
}
/*
case BSQUID_AE_TAILWHIP:
{
CBaseEntity *pHurt = CheckTraceHullAttack( 70, Vector(-16,-16,-16), Vector(16,16,16), sk_bullsquid_dmg_whip.GetFloat(), DMG_SLASH | DMG_ALWAYSGIB );
if ( pHurt )
{
Vector right, up;
AngleVectors( GetAbsAngles(), NULL, &right, &up );
if ( pHurt->GetFlags() & ( FL_NPC | FL_CLIENT ) )
pHurt->ViewPunch( QAngle( 20, 0, -20 ) );
pHurt->SetAbsVelocity( pHurt->GetAbsVelocity() + (right * 200) );
pHurt->SetAbsVelocity( pHurt->GetAbsVelocity() + (up * 100) );
}
}
break;
*/
case BSQUID_AE_BLINK:
{
// close eye.
m_nSkin = 1;
}
break;
case BSQUID_AE_HOP:
{
float flGravity = sv_gravity.GetFloat();
// throw the squid up into the air on this frame.
if ( GetFlags() & FL_ONGROUND )
{
RemoveFlag( FL_ONGROUND );
}
// jump into air for 0.8 (24/30) seconds
Vector vecVel = GetAbsVelocity();
vecVel.z += ( 0.625 * flGravity ) * 0.5;
SetAbsVelocity( vecVel );
}
break;
case BSQUID_AE_THROW:
{
// squid throws its prey IF the prey is a client.
CBaseEntity *pHurt = CheckTraceHullAttack( 70, Vector(-16,-16,-16), Vector(16,16,16), 0, 0 );
if ( pHurt )
{
pHurt->ViewPunch( QAngle(20,0,-20) );
// screeshake transforms the viewmodel as well as the viewangle. No problems with seeing the ends of the viewmodels.
UTIL_ScreenShake( pHurt->GetAbsOrigin(), 25.0, 1.5, 0.7, 2, SHAKE_START );
// If the player, throw him around
if ( pHurt->IsPlayer())
{
Vector forward, up;
AngleVectors( GetLocalAngles(), &forward, NULL, &up );
pHurt->ApplyAbsVelocityImpulse( forward * 300 + up * 300 );
}
// If not the player see if has bullsquid throw interatcion
else
{
CBaseCombatCharacter *pVictim = ToBaseCombatCharacter( pHurt );
if (pVictim)
{
if ( pVictim->HandleInteraction( g_interactionBullsquidThrow, NULL, this ) )
{
Vector forward, up;
AngleVectors( GetLocalAngles(), &forward, NULL, &up );
pVictim->ApplyAbsVelocityImpulse( forward * 300 + up * 250 );
}
}
}
}
}
break;
default:
BaseClass::HandleAnimEvent( pEvent );
}
}
void Creature::OnRespawn(MapMgr * m)
{
if(m_noRespawn)
return;
InstanceBossInfoMap *bossInfoMap = objmgr.m_InstanceBossInfoMap[m->GetMapId()];
if(bossInfoMap != NULL)
{
bool skip = false;
Instance *pInstance = m->pInstance;
for(std::set<uint32>::iterator killedNpc = pInstance->m_killedNpcs.begin(); killedNpc != pInstance->m_killedNpcs.end(); ++killedNpc)
{
// Is killed boss?
if((*killedNpc) == this->creature_info->Id)
{
skip = true;
break;
}
// Is add from killed boss?
InstanceBossInfoMap::const_iterator bossInfo = bossInfoMap->find((*killedNpc));
if(bossInfo != bossInfoMap->end() && bossInfo->second->trash.find(this->spawnid) != bossInfo->second->trash.end())
{
skip = true;
break;
}
}
if(skip)
{
this->m_noRespawn = true;
this->DeleteMe();
return;
}
}
sLog.outDetail("Respawning "I64FMT"...", GetGUID());
SetUInt32Value(UNIT_FIELD_HEALTH, GetUInt32Value(UNIT_FIELD_MAXHEALTH));
SetUInt32Value(UNIT_DYNAMIC_FLAGS, 0); // not tagging shiat
if(proto && m_spawn)
{
SetUInt32Value(UNIT_NPC_FLAGS, proto->NPCFLags);
SetUInt32Value(UNIT_NPC_EMOTESTATE, m_spawn->emote_state);
}
RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SKINNABLE);
Skinned = false;
Tagged = false;
TaggerGuid = 0;
m_lootMethod = -1;
/* creature death state */
if(proto && proto->death_state == 1)
{
uint32 newhealth = m_uint32Values[UNIT_FIELD_HEALTH] / 100;
if(!newhealth)
newhealth = 1;
SetUInt32Value(UNIT_FIELD_HEALTH, 1);
m_limbostate = true;
bInvincible = true;
SetUInt32Value(UNIT_NPC_EMOTESTATE, EMOTE_STATE_DEAD);
SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE, 35);
}
//empty loot
loot.items.clear();
setDeathState(ALIVE);
GetAIInterface()->StopMovement(0); // after respawn monster can move
GetAIInterface()->m_canMove = true;
m_PickPocketed = false;
PushToWorld(m);
}
bool Vehicle::AddPassenger(Unit *unit, int8 seatId)
{
if(unit->m_Vehicle != this)
return false;
SeatMap::iterator seat;
if(seatId < 0) // no specific seat requirement
{
for(seat = m_Seats.begin(); seat != m_Seats.end(); ++seat)
if(!seat->second.passenger && seat->second.seatInfo->IsUsable())
break;
if(seat == m_Seats.end()) // no available seat
return false;
}
else
{
seat = m_Seats.find(seatId);
if(seat == m_Seats.end())
return false;
if(seat->second.passenger)
seat->second.passenger->ExitVehicle();
assert(!seat->second.passenger);
}
sLog.outDebug("Unit %s enter vehicle entry %u id %u dbguid %u", unit->GetName(), GetEntry(), m_vehicleInfo->m_ID, GetDBTableGUIDLow());
seat->second.passenger = unit;
if(seat->second.seatInfo->IsUsable())
{
assert(m_usableSeatNum);
--m_usableSeatNum;
if(!m_usableSeatNum)
RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPELLCLICK);
}
if(!(seat->second.seatInfo->m_flags & 0x4000))
unit->addUnitState(UNIT_STAT_ONVEHICLE);
//SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_UNK_24);
unit->AddUnitMovementFlag(MOVEMENTFLAG_ONTRANSPORT);
VehicleSeatEntry const *veSeat = seat->second.seatInfo;
unit->m_movementInfo.t_x = veSeat->m_attachmentOffsetX;
unit->m_movementInfo.t_y = veSeat->m_attachmentOffsetY;
unit->m_movementInfo.t_z = veSeat->m_attachmentOffsetZ;
unit->m_movementInfo.t_o = 0;
unit->m_movementInfo.t_time = 0; // 1 for player
unit->m_movementInfo.t_seat = seat->first;
if(unit->GetTypeId() == TYPEID_PLAYER && seat->first == 0 && seat->second.seatInfo->m_flags & 0x800) // not right
if (!SetCharmedBy(unit, CHARM_TYPE_VEHICLE))
assert(false);
if(IsInWorld())
{
unit->SendMonsterMoveTransport(this);
GetMap()->CreatureRelocation(this, GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation());
}
//if(unit->GetTypeId() == TYPEID_PLAYER)
// ((Player*)unit)->SendTeleportAckMsg();
//unit->SendMovementFlagUpdate();
return true;
}
void Vehicle::RemovePassenger(Unit* pPassenger)
{
if(pPassenger == NULL) // We have enough problems that we need to do this :(
return;
uint8 slot = pPassenger->GetSeatID();
pPassenger->SetVehicle(NULL);
pPassenger->SetSeatID(NULL);
pPassenger->RemoveFlag(UNIT_FIELD_FLAGS, (UNIT_FLAG_UNKNOWN_5 | UNIT_FLAG_PREPARATION | UNIT_FLAG_NOT_SELECTABLE));
if( pPassenger->IsPlayer() && TO_PLAYER(pPassenger)->m_MountSpellId != m_mountSpell )
pPassenger->RemoveAura(TO_PLAYER(pPassenger)->m_MountSpellId);
if( m_mountSpell )
pPassenger->RemoveAura( m_mountSpell );
if( m_CastSpellOnMount )
pPassenger->RemoveAura( m_CastSpellOnMount );
WorldPacket data(SMSG_MONSTER_MOVE, 85);
data << pPassenger->GetNewGUID(); // PlayerGUID
data << uint8(0x40); // Unk - blizz uses 0x40
data << pPassenger->GetPosition(); // Player Position xyz
data << getMSTime(); // Timestamp
data << uint8(0x4); // Flags
data << pPassenger->GetOrientation(); // Orientation
data << uint32(MOVEFLAG_AIR_SUSPENSION); // MovementFlags
data << uint32(0); // MovementTime
data << uint32(1); // Pointcount
data << GetPosition(); // Vehicle Position xyz
SendMessageToSet(&data, false);
pPassenger->movement_info.flags &= ~MOVEFLAG_TAXI;
pPassenger->movement_info.transX = 0;
pPassenger->movement_info.transY = 0;
pPassenger->movement_info.transZ = 0;
pPassenger->movement_info.transO = 0;
pPassenger->movement_info.transTime = 0;
pPassenger->movement_info.transSeat = 0;
pPassenger->movement_info.transGuid = WoWGuid(uint64(NULL));
if(pPassenger->IsPlayer())
{
Player* plr = TO_PLAYER(pPassenger);
if(plr == GetControllingUnit())
{
plr->m_CurrentCharm = NULL;
data.Initialize(SMSG_CLIENT_CONTROL_UPDATE);
data << GetNewGUID() << (uint8)0;
plr->GetSession()->SendPacket(&data);
}
RemoveFlag(UNIT_FIELD_FLAGS, (UNIT_FLAG_PLAYER_CONTROLLED_CREATURE | UNIT_FLAG_PLAYER_CONTROLLED));
plr->SetPlayerStatus(TRANSFER_PENDING); // We get an ack later, if we don't set this now, we get disconnected.
sEventMgr.AddEvent(plr, &Player::CheckPlayerStatus, (uint8)TRANSFER_PENDING, EVENT_PLAYER_CHECK_STATUS_Transfer, 5000, 0, 0);
plr->m_sentTeleportPosition.ChangeCoords(GetPositionX(), GetPositionY(), GetPositionZ());
plr->SetPosition(GetPositionX(), GetPositionY(), GetPositionZ(), GetOrientation());
data.Initialize(MSG_MOVE_TELEPORT_ACK);
data << plr->GetNewGUID();
data << plr->m_teleportAckCounter;
plr->m_teleportAckCounter++;
data << uint32(MOVEFLAG_FLYING);
data << uint16(0x40);
data << getMSTime();
data << GetPositionX();
data << GetPositionY();
data << GetPositionZ();
data << GetOrientation();
data << uint32(0);
plr->GetSession()->SendPacket(&data);
plr->SetUInt64Value( PLAYER_FARSIGHT, 0 );
data.Initialize(SMSG_PET_DISMISS_SOUND);
data << uint32(m_vehicleSeats[slot]->m_exitUISoundID);
data << plr->GetPosition();
plr->GetSession()->SendPacket(&data);
data.Initialize(SMSG_PET_SPELLS);
data << uint64(0);
data << uint32(0);
plr->GetSession()->SendPacket(&data);
CreatureProtoVehicle* vehicleproto = CreatureProtoVehicleStorage.LookupEntry(GetEntry());
if(vehicleproto && vehicleproto->healthfromdriver)
{
if(slot == 0)
{
uint32 health = GetUInt32Value(UNIT_FIELD_HEALTH);
uint32 maxhealth = GetUInt32Value(UNIT_FIELD_MAXHEALTH);
uint32 protomaxhealth = GetProto()->MaxHealth;
uint32 healthdiff = maxhealth - health;
uint32 plritemlevel = plr->GetTotalItemLevel();
uint32 convrate = vehicleproto->healthunitfromitemlev;
if(plritemlevel != 0 && convrate != 0)
{
uint32 healthloss = healthdiff+plritemlevel*convrate;
SetUInt32Value(UNIT_FIELD_HEALTH, GetProto()->MaxHealth - healthloss);
}
else if(protomaxhealth > healthdiff)
SetUInt32Value(UNIT_FIELD_HEALTH, protomaxhealth-healthdiff);
else
SetUInt32Value(UNIT_FIELD_HEALTH, 1);
SetUInt32Value(UNIT_FIELD_MAXHEALTH, protomaxhealth);
}
}
}
if(slot == 0)
{
m_redirectSpellPackets = NULLPLR;
CombatStatus.Vanished();
pPassenger->SetUInt64Value( UNIT_FIELD_CHARM, 0 );
SetUInt64Value(UNIT_FIELD_CHARMEDBY, 0);
if(!m_faction || m_faction->ID == 35 || m_faction->ID == 2105)
SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE, GetCharmTempVal());
RemoveAura(62064);
}
SendHeartBeatMsg(false);
m_passengers[slot] = NULL;
pPassenger->m_TransporterGUID = NULL; // We need to null this out
if(pPassenger->IsPlayer())
--m_ppassengerCount;
//note: this is not blizz like we should despawn
//and respawn at spawn point.
//Well actually this is how blizz wanted it
//but they couldnt get it to work xD
bool haspassengers = false;
for(uint8 i = 0; i < m_seatSlotMax; i++)
{
if(m_passengers[i] != NULL && m_passengers[i]->IsPlayer())
{
haspassengers = true;
break;
}
}
if(!haspassengers && !GetVehicle()) // Passenger and accessory checks.
{
if( m_spawn == NULL )
SafeDelete();
}
if(!IsFull())
SetFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPELLCLICK);
if(canFly())
DisableFlight();
_setFaction();
}
uint32 Creature::getDialogStatus(Player *pPlayer, uint32 defstatus)
{
uint32 result = DIALOG_STATUS_NONE;
QuestStatus status;
uint32 quest_id;
Quest *pQuest;
for( std::list<uint32>::iterator i = mInvolvedQuests.begin( ); i != mInvolvedQuests.end( ); i++ )
{
quest_id = *i;
pQuest = objmgr.QuestTemplates[quest_id];
status = pPlayer->GetQuestStatus( quest_id );
if ((status == QUEST_STATUS_COMPLETE && !pPlayer->GetQuestRewardStatus(quest_id)) ||
(pQuest->IsAutoComplete() && pPlayer->CanTakeQuest(pQuest, false)))
{
SetFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TRACK_UNIT);
if ( pQuest->IsAutoComplete() && pQuest->IsRepeatable() )
return DIALOG_STATUS_REWARD_REP;
else
return DIALOG_STATUS_REWARD;
}
else if ( status == QUEST_STATUS_INCOMPLETE )
result = DIALOG_STATUS_INCOMPLETE;
}
RemoveFlag(UNIT_DYNAMIC_FLAGS, UNIT_DYNFLAG_TRACK_UNIT);
if ( result == DIALOG_STATUS_INCOMPLETE )
return result;
for( std::list<uint32>::iterator i = mQuests.begin( ); i != mQuests.end( ); i++ )
{
pQuest = objmgr.QuestTemplates[*i];
if ( !pQuest )
continue;
quest_id = pQuest->GetQuestId();
status = pPlayer->GetQuestStatus( quest_id );
if ( status == QUEST_STATUS_NONE )
{
if ( pPlayer->CanSeeStartQuest( quest_id ) )
{
if ( pPlayer->SatisfyQuestLevel(quest_id, false) )
{
if ( pQuest->IsAutoComplete() )
return DIALOG_STATUS_REWARD_REP;
else
return DIALOG_STATUS_AVAILABLE;
}
result = DIALOG_STATUS_UNAVAILABLE;
}
}
}
// can train and help unlearn talentes (2 action -> chat menu)
if( isCanTrainingAndResetTalentsOf(pPlayer) )
return DIALOG_STATUS_CHAT;
if ( result == DIALOG_STATUS_UNAVAILABLE )
return result;
if ( defstatus == DIALOG_STATUS_NONE )
return DIALOG_STATUS_NONE;
else
return DIALOG_STATUS_CHAT;
}
void Vehicle::RemovePassenger(Unit *unit)
{
SeatMap::iterator seat;
for(seat = m_Seats.begin(); seat != m_Seats.end(); ++seat)
{
if((seat->second.flags & (SEAT_FULL | SEAT_VEHICLE_FREE | SEAT_VEHICLE_FULL)) && seat->second.passenger == unit)
{
unit->SetVehicleGUID(0);
if(seat->second.vs_flags & SF_MAIN_RIDER)
{
RemoveSpellsCausingAura(SPELL_AURA_CONTROL_VEHICLE);
if(unit->GetTypeId() == TYPEID_PLAYER)
{
((Player*)unit)->SetMover(unit);
((Player*)unit)->SetClientControl(unit, 1);
((Player*)unit)->SetMoverInQueve(NULL);
((Player*)unit)->RemovePetActionBar();
if(((Player*)unit)->GetGroup())
((Player*)unit)->SetGroupUpdateFlag(GROUP_UPDATE_VEHICLE);
}
unit->SetCharm(NULL);
SetCharmerGUID(NULL);
setFaction(GetCreatureInfo()->faction_A);
}
if(GetVehicleFlags() & VF_NON_SELECTABLE)
RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
if(GetVehicleFlags() & VF_CAST_AURA && m_VehicleData && m_VehicleData->v_spells[0] != 0)
unit->RemoveAurasDueToSpell(m_VehicleData->v_spells[0]);
if(seat->second.vs_flags & SF_UNATTACKABLE)
unit->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
// restore player control
if(unit->GetTypeId() == TYPEID_PLAYER)
{
((Player*)unit)->SetFarSightGUID(NULL);
if(seat->second.vs_flags & SF_CAN_CAST)
{
WorldPacket data0(SMSG_FORCE_MOVE_UNROOT, 10);
data0 << unit->GetPackGUID();
data0 << (uint32)(2); // can rotate
unit->SendMessageToSet(&data0,true);
}
else
{
WorldPacket data1(SMSG_FORCE_MOVE_UNROOT, 10);
data1 << unit->GetPackGUID();
data1 << (uint32)(0); // cannot rotate
unit->SendMessageToSet(&data1,true);
}
}
unit->m_SeatData.OffsetX = 0.0f;
unit->m_SeatData.OffsetY = 0.0f;
unit->m_SeatData.OffsetZ = 0.0f;
unit->m_SeatData.Orientation = 0.0f;
unit->m_SeatData.c_time = 0;
unit->m_SeatData.dbc_seat = 0;
unit->m_SeatData.seat = 0;
unit->m_SeatData.s_flags = 0;
unit->m_SeatData.v_flags = 0;
seat->second.passenger = NULL;
seat->second.flags = SEAT_FREE;
EmptySeatsCountChanged();
break;
}
}
}
void Vehicle::_AddToSlot(Unit* pPassenger, uint8 slot)
{
assert( slot < m_seatSlotMax );
if(pPassenger->IsPlayer() && TO_PLAYER(pPassenger)->m_CurrentCharm)
return;
if(pPassenger->IsPlayer() && TO_PLAYER(pPassenger)->m_isGmInvisible)
{
sChatHandler.GreenSystemMessage(TO_PLAYER(pPassenger)->GetSession(), "Please turn off invis before entering vehicle.");
return;
}
CreatureProtoVehicle* vehicleproto = CreatureProtoVehicleStorage.LookupEntry(GetEntry());
m_passengers[slot] = pPassenger;
LocationVector v;
v.x = m_vehicleSeats[slot]->m_attachmentOffsetX; /* pPassenger->m_TransporterX = */
v.y = m_vehicleSeats[slot]->m_attachmentOffsetY; /* pPassenger->m_TransporterY = */
v.z = m_vehicleSeats[slot]->m_attachmentOffsetZ; /* pPassenger->m_TransporterZ = */
v.o = 0; /* pPassenger->m_TransporterO = */
//pPassenger->m_transportPosition =& v; // This is handled elsewhere, do not initialize here.
pPassenger->movement_info.flags |= MOVEFLAG_TAXI;
pPassenger->movement_info.transX = v.x;
pPassenger->movement_info.transY = v.y;
pPassenger->movement_info.transZ = v.z;
pPassenger->movement_info.transO = GetOrientation();
pPassenger->movement_info.transSeat = slot;
pPassenger->movement_info.transGuid = WoWGuid(GetGUID());
pPassenger->SetSeatID(slot);
pPassenger->m_TransporterGUID = GetGUID();
if( m_CastSpellOnMount )
pPassenger->CastSpell( pPassenger, m_CastSpellOnMount, true );
RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_SELF_RES);
// This is where the real magic happens
if( pPassenger->IsPlayer() )
{
Player* pPlayer = TO_PLAYER(pPassenger);
//pPlayer->Root();
//Dismount
if(pPlayer->m_MountSpellId && pPlayer->m_MountSpellId != m_mountSpell)
pPlayer->RemoveAura(pPlayer->m_MountSpellId);
//Remove morph spells
if(pPlayer->GetUInt32Value(UNIT_FIELD_DISPLAYID) != pPlayer->GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID))
{
pPlayer->RemoveAllAurasOfType(SPELL_AURA_TRANSFORM);
pPlayer->RemoveAllAurasOfType(SPELL_AURA_MOD_SHAPESHIFT);
}
//Dismiss any pets
if(pPlayer->GetSummon())
{
if(pPlayer->GetSummon()->GetUInt32Value(UNIT_CREATED_BY_SPELL) > 0)
pPlayer->GetSummon()->Dismiss(false); // warlock summon -> dismiss
else
pPlayer->GetSummon()->Remove(false, true, true); // hunter pet -> just remove for later re-call
}
pPlayer->SetVehicle(this);
pPlayer->SetUInt64Value(PLAYER_FARSIGHT, GetGUID());
pPlayer->SetPlayerStatus(TRANSFER_PENDING);
sEventMgr.AddEvent(pPlayer, &Player::CheckPlayerStatus, (uint8)TRANSFER_PENDING, EVENT_PLAYER_CHECK_STATUS_Transfer, 5000, 0, 0);
pPlayer->m_sentTeleportPosition.ChangeCoords(GetPositionX(), GetPositionY(), GetPositionZ());
WorldPacket data(SMSG_MONSTER_MOVE_TRANSPORT, 100);
data << pPlayer->GetNewGUID(); // Passengerguid
data << GetNewGUID(); // Transporterguid (vehicleguid)
data << uint8(slot); // Vehicle Seat ID
data << uint8(0); // Unknown
data << GetPositionX() - pPlayer->GetPositionX(); // OffsetTransporterX
data << GetPositionY() - pPlayer->GetPositionY(); // OffsetTransporterY
data << GetPositionZ() - pPlayer->GetPositionZ(); // OffsetTransporterZ
data << getMSTime(); // Timestamp
data << uint8(0x04); // Flags
data << float(0); // Orientation Offset
data << uint32(MOVEFLAG_TB_MOVED); // MovementFlags
data << uint32(0); // MoveTime
data << uint32(1); // Points
data << v.x; // GetTransOffsetX();
data << v.y; // GetTransOffsetY();
data << v.z; // GetTransOffsetZ();
SendMessageToSet(&data, true);
if(vehicleproto)
{ // We have proto, no accessory in slot, and slot sets unselectable, unlike some seats
if(!vehicleproto->seats[slot].accessoryentry && vehicleproto->seats[slot].unselectableaccessory)
pPlayer->SetFlag(UNIT_FIELD_FLAGS, (UNIT_FLAG_UNKNOWN_5 | UNIT_FLAG_PREPARATION | UNIT_FLAG_NOT_SELECTABLE));
}
else
pPlayer->SetFlag(UNIT_FIELD_FLAGS, (UNIT_FLAG_UNKNOWN_5 | UNIT_FLAG_PREPARATION | UNIT_FLAG_NOT_SELECTABLE));
if(slot == 0)
{
if(m_vehicleSeats[slot]->IsControllable())
{
m_redirectSpellPackets = pPlayer;
SetSpeed(RUN, m_runSpeed);
SetSpeed(FLY, m_flySpeed);
// send "switch mover" packet
data.Initialize(SMSG_CLIENT_CONTROL_UPDATE);
data << GetNewGUID() << uint8(1);
pPlayer->GetSession()->SendPacket(&data);
pPlayer->m_CurrentCharm = TO_UNIT(this);
pPlayer->SetUInt64Value(UNIT_FIELD_CHARM, GetGUID());
SetUInt64Value(UNIT_FIELD_CHARMEDBY, pPlayer->GetGUID());
SetFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_PLAYER_CONTROLLED_CREATURE);
if(!m_faction || m_faction->ID == 35 || m_faction->ID == 2105)
{
SetCharmTempVal(pPlayer->GetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE));
SetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE, pPlayer->GetUInt32Value(UNIT_FIELD_FACTIONTEMPLATE));
}
if(vehicleproto && vehicleproto->healthfromdriver)
{
uint32 health = GetUInt32Value(UNIT_FIELD_HEALTH);
uint32 maxhealth = GetUInt32Value(UNIT_FIELD_MAXHEALTH);
uint32 healthdiff = maxhealth - health;
SetUInt32Value(UNIT_FIELD_MAXHEALTH, (maxhealth+((pPlayer->GetTotalItemLevel())*(vehicleproto->healthunitfromitemlev))));
SetUInt32Value(UNIT_FIELD_HEALTH, (health+((pPlayer->GetTotalItemLevel())*(vehicleproto->healthunitfromitemlev))) - healthdiff);
}
SendSpells(GetEntry(), pPlayer);
if(pPlayer->HasAura(62064))
{
uint32 stack = pPlayer->FindActiveAura(62064)->stackSize;
AddAura(new Aura(dbcSpell.LookupEntry(62064),-1,this,this));
FindActiveAura(62064)->ModStackSize(stack);
}
}
}
else
{
data.Initialize(SMSG_CLIENT_CONTROL_UPDATE);
data << GetNewGUID() << uint8(0);
pPlayer->GetSession()->SendPacket(&data);
}
data.Initialize(SMSG_PET_DISMISS_SOUND);
data << uint32(m_vehicleSeats[slot]->m_enterUISoundID);
data << pPlayer->GetPosition();
pPlayer->GetSession()->SendPacket(&data);
++m_ppassengerCount;
}
else
{
pPassenger->SetVehicle(this);
if(vehicleproto != NULL)
if(vehicleproto->seats[slot].accessoryentry == pPassenger->GetEntry())
if(vehicleproto->seats[slot].unselectableaccessory == true)
pPassenger->SetFlag(UNIT_FIELD_FLAGS, (UNIT_FLAG_UNKNOWN_5 | UNIT_FLAG_PREPARATION | UNIT_FLAG_NOT_SELECTABLE));
else
pPassenger->SetFlag(UNIT_FIELD_FLAGS, (UNIT_FLAG_UNKNOWN_5 | UNIT_FLAG_PREPARATION));
else
pPassenger->SetFlag(UNIT_FIELD_FLAGS, (UNIT_FLAG_UNKNOWN_5 | UNIT_FLAG_PREPARATION | UNIT_FLAG_NOT_SELECTABLE));
pPassenger->SetPosition(GetPositionX()+v.x, GetPositionY()+v.y, GetPositionZ()+v.z, GetOrientation());
}
SendHeartBeatMsg(false);
if(IsFull())
RemoveFlag(UNIT_NPC_FLAGS, UNIT_NPC_FLAG_SPELLCLICK);
if(canFly())
EnableFlight();
_setFaction();
}
bool Item::LoadFromDB(uint32 guidLow, Field* fields, ObjectGuid ownerGuid)
{
// create item before any checks for store correct guid
// and allow use "FSetState(ITEM_REMOVED); SaveToDB();" for deleting item from DB
Object::_Create(ObjectGuid(HIGHGUID_ITEM, guidLow));
if (!LoadValues(fields[0].GetString()))
{
sLog.outError("Item::LoadFromDB: %s have broken data in `data` field. Can't be loaded.", GetGuidStr().c_str());
return false;
}
SetText(fields[1].GetCppString());
bool needSave = false; // need explicit save data at load fixes
// overwrite possible wrong/corrupted guid
ObjectGuid new_item_guid = ObjectGuid(HIGHGUID_ITEM, guidLow);
if (GetGuidValue(OBJECT_FIELD_GUID) != new_item_guid)
{
SetGuidValue(OBJECT_FIELD_GUID, new_item_guid);
needSave = true;
}
ItemPrototype const* proto = GetProto();
if (!proto)
return false;
// update max durability (and durability) if need
if (proto->MaxDurability != GetUInt32Value(ITEM_FIELD_MAXDURABILITY))
{
SetUInt32Value(ITEM_FIELD_MAXDURABILITY, proto->MaxDurability);
if (GetUInt32Value(ITEM_FIELD_DURABILITY) > proto->MaxDurability)
SetUInt32Value(ITEM_FIELD_DURABILITY, proto->MaxDurability);
needSave = true;
}
// recalculate suffix factor
if (GetItemRandomPropertyId() < 0)
{
if (UpdateItemSuffixFactor())
needSave = true;
}
// Remove bind flag for items vs NO_BIND set
if (IsSoulBound() && proto->Bonding == NO_BIND)
{
ApplyModFlag(ITEM_FIELD_FLAGS, ITEM_DYNFLAG_BINDED, false);
needSave = true;
}
// update duration if need, and remove if not need
if ((proto->Duration == 0) != (GetUInt32Value(ITEM_FIELD_DURATION) == 0))
{
SetUInt32Value(ITEM_FIELD_DURATION, proto->Duration);
needSave = true;
}
// set correct owner
if (ownerGuid && GetOwnerGuid() != ownerGuid)
{
SetOwnerGuid(ownerGuid);
needSave = true;
}
// set correct wrapped state
if (HasFlag(ITEM_FIELD_FLAGS, ITEM_DYNFLAG_WRAPPED))
{
// wrapped item must be wrapper (used version that not stackable)
if (!(proto->Flags & ITEM_FLAG_WRAPPER) || GetMaxStackCount() > 1)
{
RemoveFlag(ITEM_FIELD_FLAGS, ITEM_DYNFLAG_WRAPPED);
needSave = true;
// also cleanup for sure gift table
DeleteGiftsFromDB();
}
}
if (needSave) // normal item changed state set not work at loading
{
std::ostringstream ss;
for (uint16 i = 0; i < m_valuesCount; ++i)
ss << GetUInt32Value(i) << " ";
static SqlStatementID updItem;
SqlStatement stmt = CharacterDatabase.CreateStatement(updItem, "UPDATE item_instance SET owner_guid = ?, data = ? WHERE guid = ?");
stmt.PExecute(GetOwnerGuid().GetCounter(), ss.str().c_str(), guidLow);
}
return true;
}
//-----------------------------------------------------------------------------
void Unit::ApplyModifier(const Modifier *mod, bool apply, Affect* parent)
{
//Player * player;
Creature * creature;
Unit * unit;
WorldPacket data;
Unit * caster = WorldGetUnit (parent->GetCasterGUID());
if (caster != NULL && Call_Aura_ApplyModifier (mod->GetType(), caster, this,
apply, mod->GetAmount(), mod->GetMiscValue(), mod->GetMiscValue2()))
{
sLog.outDebug ("ApplyModifier->SCRIPT: Type=%d Amount=%d V1=%d V2=%d",
mod->GetType(), mod->GetAmount(), mod->GetMiscValue(), mod->GetMiscValue2());
return;
}
sLog.outDebug ("ApplyModifier: Type=%d Amount=%d V1=%d V2=%d",
mod->GetType(), mod->GetAmount(), mod->GetMiscValue(), mod->GetMiscValue2());
switch(mod->GetType())
{
case SPELL_AURA_NONE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_NONE");
break; }
case SPELL_AURA_BIND_SIGHT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_BIND_SIGHT");
break; }
case SPELL_AURA_MOD_THREAT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_THREAT");
break; }
case SPELL_AURA_AURAS_VISIBLE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_AURAS_VISIBLE");
break; }
case SPELL_AURA_MOD_RESISTANCE_PCT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_RESISTANCE_PCT");
break; }
case SPELL_AURA_MOD_CREATURE_ATTACK_POWER: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_CREATURE_ATTACK_POWER");
break; }
case SPELL_AURA_MOD_TOTAL_THREAT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_TOTAL_THREAT");
break; }
case SPELL_AURA_WATER_WALK: {
apply ?
data.Initialize(SMSG_MOVE_WATER_WALK)
: data.Initialize(SMSG_MOVE_LAND_WALK);
data << GetGUID();
SendMessageToSet(&data,true);
break; }
case SPELL_AURA_FEATHER_FALL: {
apply ?
data.Initialize(SMSG_MOVE_FEATHER_FALL)
: data.Initialize(SMSG_MOVE_NORMAL_FALL);
data << GetGUID();
SendMessageToSet(&data,true);
break; }
case SPELL_AURA_HOVER: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_HOVER");
break; }
case SPELL_AURA_ADD_FLAT_MODIFIER: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_ADD_FLAT_MODIFIER");
break; }
case SPELL_AURA_ADD_PCT_MODIFIER: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_ADD_PCT_MODIFIER");
break; }
case SPELL_AURA_ADD_TARGET_TRIGGER: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_ADD_TARGET_TRIGGER");
break; }
case SPELL_AURA_MOD_TAUNT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_TAUNT");
break; }
case SPELL_AURA_MOD_POWER_REGEN_PERCENT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_POWER_REGEN_PERCENT");
break; }
case SPELL_AURA_ADD_CASTER_HIT_TRIGGER: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_ADD_CASTER_HIT_TRIGGER");
break; }
case SPELL_AURA_OVERRIDE_CLASS_SCRIPTS: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_OVERRIDE_CLASS_SCRIPTS");
break; }
case SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN");
break; }
case SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN_PCT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_RANGED_DAMAGE_TAKEN_PCT");
break; }
case SPELL_AURA_MOD_HEALING: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_HEALING");
break; }
case SPELL_AURA_IGNORE_REGEN_INTERRUPT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_IGNORE_REGEN_INTERRUPT");
break; }
case SPELL_AURA_MOD_MECHANIC_RESISTANCE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_MECHANIC_RESISTANCE");
break; }
case SPELL_AURA_MOD_HEALING_PCT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_HEALING_PCT");
break; }
case SPELL_AURA_SHARE_PET_TRACKING: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_SHARE_PET_TRACKING");
break; }
case SPELL_AURA_MOD_CONFUSE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_CONFUSE");
break; }
case SPELL_AURA_MOD_STUN: {
//sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_STUN");
if (apply)
SetTarget (0);
break; }
case SPELL_AURA_UNTRACKABLE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_UNTRACKABLE");
break; }
case SPELL_AURA_EMPATHY: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_EMPATHY");
break; }
case SPELL_AURA_MOD_OFFHAND_DAMAGE_PCT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_OFFHAND_DAMAGE_PCT");
break; }
case SPELL_AURA_MOD_POWER_COST_PCT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_POWER_COST_PCT");
break; }
case SPELL_AURA_MOD_RANGED_ATTACK_POWER: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_RANGED_ATTACK_POWER");
break; }
case SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN");
break; }
case SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN_PCT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_MELEE_DAMAGE_TAKEN_PCT");
break; }
case SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_RANGED_ATTACK_POWER_ATTACKER_BONUS");
break; }
case SPELL_AURA_MOD_POSSESS_PET: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_POSSESS_PET");
break; }
case SPELL_AURA_MOD_INCREASE_SPEED_ALWAYS: {
unit = WorldGetUnit (GetGUID());
if (unit != NULL) {
if (apply) unit->ModifySpeedMod (mod->GetAmount() / 100.0f);
else {
if (mod->GetAmount() != 0)
unit->ModifySpeedMod (100.0f / mod->GetAmount());
else
unit->SetSpeedMod (1.0f);
}
} else {
sLog.outDebug ("ApplyModifier SPELL_AURA_MOD_INCREASE_SPEED_ALWAYS: Unit %X not found", GetGUIDLow());
}
break; }
case SPELL_AURA_MOD_DAMAGE_DONE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_DAMAGE_DONE");
break; }
case SPELL_AURA_MOD_MOUNTED_SPEED_ALWAYS: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_MOUNTED_SPEED_ALWAYS");
break; }
case SPELL_AURA_MOD_CREATURE_RANGED_ATTACK_POWER: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_CREATURE_RANGED_ATTACK_POWER");
break; }
case SPELL_AURA_MOD_INCREASE_ENERGY_PERCENT: {
uint32 percent = mod->GetAmount();
uint32 current = GetUInt32Value(UNIT_FIELD_POWER4);
apply ?
SetUInt32Value(UNIT_FIELD_POWER4,current+current/100*percent)
: SetUInt32Value(UNIT_FIELD_POWER4,current-current/(100+percent)*100);
break; }
case SPELL_AURA_MOD_INCREASE_HEALTH_PERCENT: {
uint32 percent = mod->GetAmount();
uint32 current = GetUInt32Value(UNIT_FIELD_MAXHEALTH);
apply ?
SetUInt32Value(UNIT_FIELD_MAXHEALTH,current+current/100*percent)
: SetUInt32Value(UNIT_FIELD_MAXHEALTH,current-current/(100+percent)*100);
break; }
case SPELL_AURA_MOD_MANA_REGEN_INTERRUPT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_MANA_REGEN_INTERRUPT");
break; }
case SPELL_AURA_MOD_HEALING_DONE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_HEALING_DONE");
break; }
case SPELL_AURA_MOD_HEALING_DONE_PERCENT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_HEALING_DONE_PERCENT");
break; }
case SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_TOTAL_STAT_PERCENTAGE");
break; }
case SPELL_AURA_MOD_HASTE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_HASTE");
break; }
case SPELL_AURA_FORCE_REACTION: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_FORCE_REACTION");
break; }
case SPELL_AURA_MOD_DAMAGE_TAKEN: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_DAMAGE_TAKEN");
break; }
case SPELL_AURA_MOD_RANGED_HASTE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_RANGED_HASTE");
break; }
case SPELL_AURA_MOD_RANGED_AMMO_HASTE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_RANGED_AMMO_HASTE");
break; }
case SPELL_AURA_MOD_BASE_RESISTANCE_PCT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_BASE_RESISTANCE_PCT");
break; }
case SPELL_AURA_MOD_RESISTANCE_EXCLUSIVE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_RESISTANCE_EXCLUSIVE");
break; }
case SPELL_AURA_SAFE_FALL: {
apply ? data.Initialize(SMSG_MOVE_FEATHER_FALL) : data.Initialize(SMSG_MOVE_NORMAL_FALL);
data << GetGUID();
SendMessageToSet(&data,true);
break; }
case SPELL_AURA_CHARISMA: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_CHARISMA");
break; }
case SPELL_AURA_PERSUADED: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_PERSUADED");
break; }
case SPELL_AURA_ADD_CREATURE_IMMUNITY: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_ADD_CREATURE_IMMUNITY");
break; }
case SPELL_AURA_RETAIN_COMBO_POINTS: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_RETAIN_COMBO_POINTS");
break; }
case SPELL_AURA_DAMAGE_SHIELD: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_DAMAGE_SHIELD");
break; }
case SPELL_AURA_MOD_STEALTH: {
//sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_STEALTH");
// Convert float stored into integer field to normal view
float amountf;
*((int *)&amountf) = mod->GetAmount();
// Clip effective stealth level by spell level
int amount = min (GetLevel() * 5, (int)amountf + 95);
if (apply) m_stealthLevel += amount;
else m_stealthLevel -= amount;
sLog.outDebug ("ApplyModifier: STEALTH value set to %d", m_stealthLevel);
break; }
case SPELL_AURA_MOD_DETECT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_DETECT");
break; }
case SPELL_AURA_MOD_INVISIBILITY: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_INVISIBILITY");
break; }
case SPELL_AURA_MOD_INVISIBILITY_DETECTION: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_INVISIBILITY_DETECTION");
break; }
case SPELL_AURA_MOD_POSSESS: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_POSSESS");
break; }
case SPELL_AURA_MOD_RESISTANCE: {
uint16 index = 0;
uint16 index2 = 0;
switch(mod->GetMiscValue())
{
case DMG_PHYSICAL: {
index = UNIT_FIELD_RESISTANCES;
mod->GetMiscValue2() == 0 ? index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE : index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE;
break; }
case DMG_HOLY: {
index = UNIT_FIELD_RESISTANCES + DMG_HOLY;
mod->GetMiscValue2() == 0 ?
index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE + DMG_HOLY :
index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE + DMG_HOLY;
break; }
case DMG_FIRE: {
index = UNIT_FIELD_RESISTANCES + DMG_FIRE;
mod->GetMiscValue2() == 0 ?
index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE + DMG_FIRE :
index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE + DMG_FIRE;
break; }
case DMG_NATURE: {
index = UNIT_FIELD_RESISTANCES + DMG_NATURE;
mod->GetMiscValue2() == 0 ?
index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE + DMG_NATURE :
index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE + DMG_NATURE;
break; }
case DMG_FROST: {
index = UNIT_FIELD_RESISTANCES + DMG_FROST;
mod->GetMiscValue2() == 0 ?
index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE + DMG_FROST :
index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE + DMG_FROST;
break; }
case DMG_SHADOW:{
index = UNIT_FIELD_RESISTANCES + DMG_SHADOW;
mod->GetMiscValue2() == 0 ?
index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE + DMG_SHADOW :
index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE + DMG_SHADOW;
break; }
case DMG_ARCANE:{
index = UNIT_FIELD_RESISTANCES + DMG_ARCANE;
mod->GetMiscValue2() == 0 ?
index2 = PLAYER_FIELD_RESISTANCEBUFFMODSPOSITIVE + DMG_ARCANE :
index2 = PLAYER_FIELD_RESISTANCEBUFFMODSNEGATIVE + DMG_ARCANE;
break; }
default:{
sLog.outDetail ("WARNING: Misc Value for SPELL_AURA_MOD_STAT not valid\n");
return;
break; }
}
if(apply){
SetUInt32Value(index,GetUInt32Value(index)+mod->GetAmount());
if (isPlayer())
SetUInt32Value(index2,GetUInt32Value(index2)+mod->GetAmount());
}else{
SetUInt32Value(index,GetUInt32Value(index)-mod->GetAmount());
if (isPlayer())
SetUInt32Value(index2,GetUInt32Value(index2)-mod->GetAmount());
}
break; }
case SPELL_AURA_PERIODIC_TRIGGER_SPELL: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_PERIODIC_TRIGGER_SPELL");
break; }
case SPELL_AURA_PERIODIC_ENERGIZE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_PERIODIC_ENERGIZE");
break; }
case SPELL_AURA_MOD_PACIFY: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_PACIFY");
break; }
case SPELL_AURA_MOD_ROOT: {
apply ? data.Initialize(MSG_MOVE_ROOT)
: data.Initialize(MSG_MOVE_UNROOT);
data << GetGUID();
SendMessageToSet(&data,true);
break; }
case SPELL_AURA_MOD_SILENCE: {
apply ? m_silenced = true
: m_silenced = false;
break; }
case SPELL_AURA_REFLECT_SPELLS: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_REFLECT_SPELLS");
break; }
case SPELL_AURA_MOD_STAT: {
uint16 index = 0;
uint16 index2 = 0;
int32 v = mod->GetAmount();
switch(mod->GetMiscValue())
{
case 0:{
//index = UNIT_FIELD_STAT0;
ModifyStrength (apply ? v : -v);
mod->GetMiscValue2() == 0 ? index2 = PLAYER_FIELD_POSSTAT0 : index2 = PLAYER_FIELD_NEGSTAT0;
break; }
case 1:{
//index = UNIT_FIELD_STAT1;
ModifyAgility (apply ? v : -v);
mod->GetMiscValue2() == 0 ? index2 = PLAYER_FIELD_POSSTAT1 : index2 = PLAYER_FIELD_NEGSTAT1;
break; }
case 2:{
//index = UNIT_FIELD_STAT2;
ModifyStamina (apply ? v : -v);
mod->GetMiscValue2() == 0 ? index2 = PLAYER_FIELD_POSSTAT2 : index2 = PLAYER_FIELD_NEGSTAT2;
break; }
case 3:{
//index = UNIT_FIELD_STAT3;
ModifyIntellect (apply ? v : -v);
mod->GetMiscValue2() == 0 ? index2 = PLAYER_FIELD_POSSTAT3 : index2 = PLAYER_FIELD_NEGSTAT3;
break; }
case 4:{
//index = UNIT_FIELD_STAT4;
ModifySpirit (apply ? v : -v);
mod->GetMiscValue2() == 0 ? index2 = PLAYER_FIELD_POSSTAT4 : index2 = PLAYER_FIELD_NEGSTAT4;
break; }
default:{
printf("WARNING: Misc Value for SPELL_AURA_MOD_STAT not valid\n");
return;
break; }
}
if(apply){
if (isPlayer())
SetUInt32Value(index2,GetUInt32Value(index2) + v);
}else{
if (isPlayer())
SetUInt32Value(index2,GetUInt32Value(index2) - v);
}
break; }
case SPELL_AURA_PERIODIC_DAMAGE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_PERIODIC_DAMAGE");
break; }
case SPELL_AURA_MOD_SKILL: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_SKILL");
break; }
case SPELL_AURA_MOD_INCREASE_SPEED: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_INCREASE_SPEED");
break; }
case SPELL_AURA_MOD_INCREASE_MOUNTED_SPEED: {
if (GetUInt32Value(UNIT_FIELD_FLAGS) & UNIT_FLAG_MOUNTED ) {
float newspeed = (float)mod->GetAmount() / 100.0f;
newspeed = newspeed + 1.0f;
sLog.outDebug("New Speed (With mount): %.1f", newspeed);
unit = WorldGetUnit (GetGUID());
if (unit != NULL)
unit->SetSpeedMod(newspeed);
} else {
unit = WorldGetUnit (GetGUID());
if (unit != NULL)
unit->SetSpeedMod(1.0f);
}
sLog.outDebug ("ApplyModifier: SPELL_AURA_MOD_INCREASE_MOUNTED_SPEED");
break; }
case SPELL_AURA_MOD_DECREASE_SPEED: {
unit = WorldGetUnit (GetGUID());
if (unit != NULL) {
if (apply) unit->ModifySpeedMod (mod->GetAmount() / 100.0f);
else {
if (mod->GetAmount() != 0)
unit->ModifySpeedMod (100.0f / mod->GetAmount());
else
unit->SetSpeedMod (1.0f);
}
}
break; }
case SPELL_AURA_MOD_INCREASE_HEALTH: {
uint32 newValue;
newValue = GetUInt32Value(UNIT_FIELD_MAXHEALTH);
apply ? newValue += mod->GetAmount() : newValue -= mod->GetAmount();
SetUInt32Value(UNIT_FIELD_MAXHEALTH,newValue);
break; }
case SPELL_AURA_MOD_INCREASE_ENERGY: {
uint32 powerField = 23;
uint8 powerType = (uint8)(GetUInt32Value(UNIT_FIELD_BYTES_0) >> 24);
if(powerType == 0) // Mana
powerField = UNIT_FIELD_POWER1;
else if(powerType == 1) // Rage
powerField = UNIT_FIELD_POWER2;
else if(powerType == 3) // Energy
powerField = UNIT_FIELD_POWER4;
uint32 newValue = GetUInt32Value(powerType);
apply ? newValue += mod->GetAmount() : newValue -= mod->GetAmount();
SetUInt32Value(powerType,newValue);
break; }
case SPELL_AURA_MOD_SHAPESHIFT: {
Affect* tmpAff;
uint32 spellId;
switch(mod->GetMiscValue())
{
case FORM_CAT: {
spellId = 3025;
break; }
case FORM_TREE:{
spellId = 3122;
break; }
case FORM_TRAVEL:{
spellId = 5419;
break; }
case FORM_AQUA:{
spellId = 5421;
break; }
case FORM_BEAR:{
spellId = 1178;
break; }
case FORM_AMBIENT:{
spellId = 0;
break; }
case FORM_GHOUL:{
spellId = 0;
break; }
case FORM_DIREBEAR:{
spellId = 9635;
break; }
case FORM_CREATUREBEAR:{
spellId = 2882;
break; }
case FORM_GHOSTWOLF:{
spellId = 0;
break; }
case FORM_BATTLESTANCE:{
spellId = 2457;
break; }
case FORM_DEFENSIVESTANCE:{
spellId = 7376;
break; }
case FORM_BERSERKERSTANCE:{
spellId = 7381;
break; }
case FORM_SHADOW:{
spellId = 0;
break; }
case FORM_STEALTH:{
//spellId = 0;
// Turn on Sneaky Stance, Switch stealth button to unstealth and switch spellbar
SetUInt32Value (UNIT_FIELD_BYTES_1, apply? 0x021E0000: 0);
if (apply == false && isPlayer())
{
data.Initialize (SMSG_COOLDOWN_EVENT);
data << (uint32)1784 << GetGUID();
((Player*)this)->GetSession()->SendPacket (&data);
}
return; }
default:{
printf("Unknown Shapeshift Type\n");
break; }
}
// check for spell id
SpellEntry *spellInfo = sSpellStore.LookupEntry( spellId );
if(!spellInfo)
{
sLog.outError("WORLD: unknown spell id %i\n", spellId);
break;
}
tmpAff = new Affect(spellInfo,parent->GetDuration(),parent->GetCasterGUID());
for(uint8 i=0; i<3; ++i){
if(spellInfo->Effect[i] == 6){
uint32 value = 0;
uint32 type = 0;
uint32 damage = 0;
if(spellInfo->EffectBasePoints[i] < 0){
tmpAff->SetNegative();
type = 1;
}
uint32 sBasePoints = (uint32)sqrt((float)(spellInfo->EffectBasePoints[i]*spellInfo->EffectBasePoints[i]));
if(spellInfo->EffectApplyAuraName[i] == 3){ // Periodic Trigger Damage
damage = spellInfo->EffectBasePoints[i]+rand()%spellInfo->EffectDieSides[i]+1;
//TODO: why the hell it takes uint16?
tmpAff->SetDamagePerTick((uint16)damage, spellInfo->EffectAmplitude[i]);
tmpAff->SetNegative();
}else if(spellInfo->EffectApplyAuraName[i] == 23)// Periodic Trigger Spell
tmpAff->SetPeriodicTriggerSpell(spellInfo->EffectTriggerSpell[i],spellInfo->EffectAmplitude[i]);
else{
if(spellInfo->EffectDieSides[i] != 0)
value = sBasePoints+rand()%spellInfo->EffectDieSides[i];
else
value = sBasePoints;
if(spellInfo->EffectDieSides[i] <= 1)
value += 1;
//TODO: why the hell it takes uint8?
tmpAff->AddMod((uint8)spellInfo->EffectApplyAuraName[i],value,spellInfo->EffectMiscValue[i],type);
}
}
}
if(tmpAff){
parent->SetCoAffect(tmpAff);
AddAffect(tmpAff);
}
break; }
case SPELL_AURA_EFFECT_IMMUNITY: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_EFFECT_IMMUNITY");
break; }
case SPELL_AURA_STATE_IMMUNITY: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_STATE_IMMUNITY");
break; }
case SPELL_AURA_SCHOOL_IMMUNITY: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_SCHOOL_IMMUNITY");
break; }
case SPELL_AURA_DAMAGE_IMMUNITY: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_DAMAGE_IMMUNITY");
break; }
case SPELL_AURA_DISPEL_IMMUNITY: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_DISPEL_IMMUNITY");
break; }
case SPELL_AURA_PROC_TRIGGER_SPELL: {
apply ? m_triggerSpell = mod->GetAmount() : m_triggerSpell = 0;
break; }
case SPELL_AURA_PROC_TRIGGER_DAMAGE: {
apply ? m_triggerDamage = mod->GetAmount() : m_triggerDamage = 0;
break; }
case SPELL_AURA_TRACK_CREATURES: {
apply ? SetUInt32Value(PLAYER_TRACK_CREATURES,mod->GetMiscValue()) : SetUInt32Value(PLAYER_TRACK_CREATURES,0);
break; }
case SPELL_AURA_TRACK_RESOURCES: {
apply ? SetUInt32Value(PLAYER_TRACK_RESOURCES,mod->GetMiscValue()) : SetUInt32Value(PLAYER_TRACK_RESOURCES,0);
break; }
case SPELL_AURA_MOD_PARRY_SKILL: {
break; }
case SPELL_AURA_MOD_PARRY_PERCENT: {
//uint32 current = GetUInt32Value(PLAYER_PARRY_PERCENTAGE);
//apply ? SetUInt32Value(PLAYER_PARRY_PERCENTAGE,current+mod->GetAmount()) : SetUInt32Value(PLAYER_PARRY_PERCENTAGE,current-mod->GetAmount());
ModifyParryChance (apply ? mod->GetAmount() : -mod->GetAmount());
break; }
case SPELL_AURA_MOD_DODGE_SKILL: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_DODGE_SKILL");
break; }
case SPELL_AURA_MOD_DODGE_PERCENT: {
//uint32 current = GetUInt32Value(PLAYER_DODGE_PERCENTAGE);
//apply ? SetUInt32Value(PLAYER_DODGE_PERCENTAGE,current+mod->GetAmount()) : SetUInt32Value(PLAYER_DODGE_PERCENTAGE,current-mod->GetAmount());
ModifyDodgeChance (apply ? mod->GetAmount() : -mod->GetAmount());
break; }
case SPELL_AURA_MOD_BLOCK_SKILL: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_BLOCK_SKILL");
break; }
case SPELL_AURA_MOD_BLOCK_PERCENT: {
//uint32 current = GetUInt32Value(PLAYER_BLOCK_PERCENTAGE);
//apply ? SetUInt32Value(PLAYER_BLOCK_PERCENTAGE,current+mod->GetAmount()) : SetUInt32Value(PLAYER_BLOCK_PERCENTAGE,current-mod->GetAmount());
ModifyBlockChance (apply ? mod->GetAmount() : -mod->GetAmount());
break; }
case SPELL_AURA_MOD_CRIT_PERCENT: {
//uint32 current = GetUInt32Value(PLAYER_CRIT_PERCENTAGE);
//apply ? SetUInt32Value(PLAYER_CRIT_PERCENTAGE,current+mod->GetAmount()) : SetUInt32Value(PLAYER_CRIT_PERCENTAGE,current-mod->GetAmount());
ModifyCritChance (apply ? mod->GetAmount() : -mod->GetAmount());
break; }
case SPELL_AURA_PERIODIC_LEECH: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_PERIODIC_LEECH");
break; }
case SPELL_AURA_MOD_HIT_CHANCE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_HIT_CHANCE");
break; }
case SPELL_AURA_MOD_SPELL_HIT_CHANCE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_SPELL_HIT_CHANCE");
break; }
case SPELL_AURA_TRANSFORM: {
if (parent->GetId() == 118) {
if (apply) {
//((Modifier *)mod)->SetValue1 (GetUInt32Value (UNIT_FIELD_DISPLAYID));
SetUInt32Value (UNIT_FIELD_DISPLAYID, 856);
} else {
SetUInt32Value (UNIT_FIELD_DISPLAYID, GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
if (caster != NULL)
AddHate (caster, 1.0f);
}
}
if (parent->GetId() == 228) {
if (apply) {
//((Modifier *)mod)->SetValue1 (GetUInt32Value (UNIT_FIELD_DISPLAYID));
SetUInt32Value (UNIT_FIELD_DISPLAYID, 304);
} else {
SetUInt32Value (UNIT_FIELD_DISPLAYID, GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
if (caster != NULL)
AddHate (caster, 1.0f);
}
}
if (parent->GetId() == 851) {
if (apply) {
//((Modifier *)mod)->SetValue1 (GetUInt32Value (UNIT_FIELD_DISPLAYID));
SetUInt32Value (UNIT_FIELD_DISPLAYID, 856);
} else {
SetUInt32Value (UNIT_FIELD_DISPLAYID, GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
if (caster != NULL)
AddHate (caster, 1.0f);
}
}
if (parent->GetId() == 4060) {
if (apply) {
//((Modifier *)mod)->SetValue1 (GetUInt32Value (UNIT_FIELD_DISPLAYID));
SetUInt32Value (UNIT_FIELD_DISPLAYID, 131);
} else {
SetUInt32Value (UNIT_FIELD_DISPLAYID, GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
if (caster != NULL)
AddHate (caster, 1.0f);
}
}
if (parent->GetId() == 5254) {
if (apply) {
//((Modifier *)mod)->SetValue1 (GetUInt32Value (UNIT_FIELD_DISPLAYID));
SetUInt32Value (UNIT_FIELD_DISPLAYID, 856);
} else {
SetUInt32Value (UNIT_FIELD_DISPLAYID, GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
if (caster != NULL)
AddHate (caster, 1.0f);
}
}
if (parent->GetId() == 12824) {
if (apply) {
//((Modifier *)mod)->SetValue1 (GetUInt32Value (UNIT_FIELD_DISPLAYID));
SetUInt32Value (UNIT_FIELD_DISPLAYID, 856);
} else {
SetUInt32Value (UNIT_FIELD_DISPLAYID, GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
if (caster != NULL)
AddHate (caster, 1.0f);
}
}
if (parent->GetId() == 12825) {
if (apply) {
//((Modifier *)mod)->SetValue1 (GetUInt32Value (UNIT_FIELD_DISPLAYID));
SetUInt32Value (UNIT_FIELD_DISPLAYID, 856);
} else {
SetUInt32Value (UNIT_FIELD_DISPLAYID, GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
if (caster != NULL)
AddHate (caster, 1.0f);
}
}
if (parent->GetId() == 12826) {
if (apply) {
//((Modifier *)mod)->SetValue1 (GetUInt32Value (UNIT_FIELD_DISPLAYID));
SetUInt32Value (UNIT_FIELD_DISPLAYID, 856);
} else {
SetUInt32Value (UNIT_FIELD_DISPLAYID, GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
if (caster != NULL)
AddHate (caster, 1.0f);
}
}
if (parent->GetId() == 13323) {
if (apply) {
//((Modifier *)mod)->SetValue1 (GetUInt32Value (UNIT_FIELD_DISPLAYID));
SetUInt32Value (UNIT_FIELD_DISPLAYID, 856);
} else {
SetUInt32Value (UNIT_FIELD_DISPLAYID, GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
if (caster != NULL)
AddHate (caster, 1.0f);
}
}
if (parent->GetId() == 15534) {
if (apply) {
//((Modifier *)mod)->SetValue1 (GetUInt32Value (UNIT_FIELD_DISPLAYID));
SetUInt32Value (UNIT_FIELD_DISPLAYID, 856);
} else {
SetUInt32Value (UNIT_FIELD_DISPLAYID, GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
if (caster != NULL)
AddHate (caster, 1.0f);
}
}
if (parent->GetId() == 17738) {
if (apply) {
//((Modifier *)mod)->SetValue1 (GetUInt32Value (UNIT_FIELD_DISPLAYID));
SetUInt32Value (UNIT_FIELD_DISPLAYID, 1141);
} else {
SetUInt32Value (UNIT_FIELD_DISPLAYID, GetUInt32Value(UNIT_FIELD_NATIVEDISPLAYID));
if (caster != NULL)
AddHate (caster, 1.0f);
}
}
break; }
case SPELL_AURA_MOD_SPELL_CRIT_CHANCE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_SPELL_CRIT_CHANCE");
break; }
case SPELL_AURA_MOD_INCREASE_SWIM_SPEED: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_INCREASE_SWIM_SPEED");
break; }
case SPELL_AURA_MOD_DAMAGE_DONE_CREATURE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_DAMAGE_DONE_CREATURE");
break; }
case SPELL_AURA_MOD_CHARM: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_CHARM");
break; }
case SPELL_AURA_MOD_PACIFY_SILENCE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_PACIFY_SILENCE");
break; }
case SPELL_AURA_MOD_SCALE: {
float current = GetFloatValue(OBJECT_FIELD_SCALE_X);
apply ? SetFloatValue(OBJECT_FIELD_SCALE_X,current+current/100*10) : SetFloatValue(OBJECT_FIELD_SCALE_X,current-current/110*100);
break; }
case SPELL_AURA_PERIODIC_HEALTH_FUNNEL: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_PERIODIC_HEALTH_FUNNEL");
break; }
case SPELL_AURA_PERIODIC_MANA_FUNNEL: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_PERIODIC_MANA_FUNNEL");
break; }
case SPELL_AURA_PERIODIC_MANA_LEECH: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_PERIODIC_MANA_LEECH");
break; }
case SPELL_AURA_MOD_CASTING_SPEED: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_CASTING_SPEED");
break; }
case SPELL_AURA_FEIGN_DEATH: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_FEIGN_DEATH");
break; }
case SPELL_AURA_MOD_DISARM: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_DISARM");
break; }
case SPELL_AURA_MOD_STALKED: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_STALKED");
break; }
case SPELL_AURA_SCHOOL_ABSORB: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_SCHOOL_ABSORB");
break; }
case SPELL_AURA_MOD_FEAR: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_FEAR");
break; }
case SPELL_AURA_EXTRA_ATTACKS: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_EXTRA_ATTACKS");
break; }
case SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_SPELL_CRIT_CHANCE_SCHOOL");
break; }
case SPELL_AURA_MOD_POWER_COST: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_POWER_COST");
break; }
case SPELL_AURA_MOD_POWER_COST_SCHOOL: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_POWER_COST_SCHOOL");
break; }
case SPELL_AURA_REFLECT_SPELLS_SCHOOL: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_REFLECT_SPELLS_SCHOOL");
break; }
case SPELL_AURA_MOD_LANGUAGE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_LANGUAGE");
break; }
case SPELL_AURA_FAR_SIGHT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_FAR_SIGHT");
break; }
case SPELL_AURA_MECHANIC_IMMUNITY: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MECHANIC_IMMUNITY");
break; }
case SPELL_AURA_MOUNTED: {
sLog.outDebug ("ApplyModifier: SPELL_AURA_MOUNTED");
if (GetUInt32Value(UNIT_FIELD_FLAGS) & UNIT_FLAG_MOUNTED )
{
SetUInt32Value(UNIT_FIELD_MOUNTDISPLAYID , 0);
RemoveFlag( UNIT_FIELD_FLAGS, UNIT_FLAG_MOUNTED );
// Remove the "player locked" flag, to allow movement
if (GetUInt32Value(UNIT_FIELD_FLAGS) & UNIT_FLAG_LOCKED )
RemoveFlag( UNIT_FIELD_FLAGS, UNIT_FLAG_LOCKED );
// Make sure we're standing ;)
SetUInt32Value(UNIT_FIELD_BYTES_1, STANDSTATE_STAND);
} else {
// Set mount ID from creatures_templ
CreatureTemplate *ptempl = objmgr.GetCreatureTemplate(mod->GetMiscValue(), true);
SetUInt32Value( UNIT_FIELD_MOUNTDISPLAYID , ptempl->Model);
//SetUInt32Value( UNIT_FIELD_FLAGS , UNIT_FLAG_MOUNTED );
SetFlag( UNIT_FIELD_FLAGS, UNIT_FLAG_MOUNTED );
}
break; }
case SPELL_AURA_MOD_DAMAGE_PERCENT_DONE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_DAMAGE_PERCENT_DONE");
break; }
case SPELL_AURA_PERIODIC_HEAL: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_PERIODIC_HEAL");
break; }
case SPELL_AURA_MOD_PERCENT_STAT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_PERCENT_STAT");
break; }
case SPELL_AURA_SPLIT_DAMAGE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_SPLIT_DAMAGE");
break; }
case SPELL_AURA_WATER_BREATHING: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_WATER_BREATHING");
break; }
case SPELL_AURA_MOD_BASE_RESISTANCE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_BASE_RESISTANCE");
break; }
case SPELL_AURA_MOD_REGEN: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_REGEN");
break; }
case SPELL_AURA_MOD_POWER_REGEN: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_POWER_REGEN");
break; }
case SPELL_AURA_CHANNEL_DEATH_ITEM: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_CHANNEL_DEATH_ITEM");
break; }
case SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_DAMAGE_PERCENT_TAKEN");
break; }
case SPELL_AURA_MOD_PERCENT_REGEN: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_PERCENT_REGEN");
break; }
case SPELL_AURA_PERIODIC_DAMAGE_PERCENT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_PERIODIC_DAMAGE_PERCENT");
break; }
case SPELL_AURA_MOD_ATTACKSPEED: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_ATTACKSPEED");
break; }
case SPELL_AURA_MOD_RESIST_CHANCE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_RESIST_CHANCE");
break; }
case SPELL_AURA_MOD_DETECT_RANGE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_DETECT_RANGE");
break; }
case SPELL_AURA_PREVENTS_FLEEING: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_PREVENTS_FLEEING");
break; }
case SPELL_AURA_MOD_UNATTACKABLE: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_UNATTACKABLE");
break; }
case SPELL_AURA_INTERRUPT_REGEN: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_INTERRUPT_REGEN");
break; }
case SPELL_AURA_GHOST: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_GHOST");
break; }
case SPELL_AURA_SPELL_MAGNET: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_SPELL_MAGNET");
break; }
case SPELL_AURA_MANA_SHIELD: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MANA_SHIELD");
break; }
case SPELL_AURA_MOD_SKILL_TALENT: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_SKILL_TALENT");
break; }
case SPELL_AURA_MOD_ATTACK_POWER: {
sLog.outDebug ("ApplyModifier: Unsupported SPELL_AURA_MOD_ATTACK_POWER");
break; }
default: {
sLog.outError("Unknown affect id %u", (uint32)mod->GetType());
}
}
}
