bool ChatHandler::HandleKillCommand(const char *args, WorldSession *m_session)
{
Unit* unit = getSelectedUnit(m_session);
if(!unit)
return true;
sWorld.LogGM(m_session, "used kill command on %s %s", unit->IsPlayer() ? "Player" : "Creature", unit->GetName());
if(unit->IsPlayer())
{
// If we're killing a player, send a message indicating a gm killed them.
BlueSystemMessageToPlr(TO_PLAYER(unit), "%s killed you with a GM command.", m_session->GetPlayer()->GetName());
TO_PLAYER(unit)->SetUInt32Value(UNIT_FIELD_HEALTH, 0); // Die, insect
TO_PLAYER(unit)->KillPlayer();
GreenSystemMessage(m_session, "Killed player %s.", unit->GetName());
}
else if(isTargetDummy(unit->GetEntry()))
RedSystemMessage(m_session, "Target cannot be killed.");
else
{
m_session->GetPlayer()->DealDamage(unit, 0xFFFFFFFF, 0, 0, 0);
GreenSystemMessage(m_session, "Killed unit %s.", unit->GetName());
}
return true;
}
bool ChatHandler::HandleCastSpellCommand(const char* args, WorldSession *m_session)
{
Unit* caster = m_session->GetPlayer();
Unit* target = getSelectedUnit(m_session, false);
if(!target)
target = caster;
uint32 spellid = atol(args);
if(spellid == 0)
spellid = GetSpellIDFromLink( args );
SpellEntry *spellentry = dbcSpell.LookupEntryForced(spellid);
if(spellentry == NULL)
{
RedSystemMessage(m_session, "Invalid spell id!");
return false;
}
Spell* sp = new Spell(caster, spellentry, false, NULLAURA);
if(!sp)
{
RedSystemMessage(m_session, "Spell failed creation!");
return false;
}
BlueSystemMessage(m_session, "Casting spell %d on target.", spellid);
SpellCastTargets targets;
targets.m_unitTarget = target->GetGUID();
sp->prepare(&targets);
sWorld.LogGM(m_session, "Used castspell command on %s" , target->GetName());
return true;
}
void Absorb(AuraEffect* aurEff, DamageInfo & dmgInfo, uint32 & absorbAmount)
{
Unit* victim = GetTarget();
int32 remainingHealth = victim->GetHealth() - dmgInfo.GetDamage();
uint32 allowedHealth = victim->CountPctFromMaxHealth(3);
if (victim->ToPlayer()->duel != NULL)
return;
// If damage kills us
if (remainingHealth <= 0 && !victim->ToPlayer()->HasSpellCooldown(SPELL_EXECUTE_CD))
{
// Cast healing spell, completely avoid damage
absorbAmount = dmgInfo.GetDamage();
int32 healAmount = int32(victim->CountPctFromMaxHealth(uint32(healPct)));
victim->CastCustomSpell(victim, SPELL_EXECUTE_HEAL, &healAmount, NULL, NULL, true, NULL, aurEff);
victim->ToPlayer()->AddSpellCooldown(SPELL_EXECUTE_HEAL, 0, time(NULL) + 120);
victim->AddAura(SPELL_EXECUTE_STUN, victim);
victim->ToPlayer()->AddSpellCooldown(SPELL_EXECUTE_CD, 0, time(NULL) + 600);
victim->ToPlayer()->AddSpellCooldown(SPELL_EXECUTE_STUN, 0, time(NULL) + 600);
victim->AddAura(SPELL_EXECUTE_CD, victim);
std::stringstream message;
message << "Player " << victim->ToPlayer()->GetName() << " has been stunned.";
sWorld->SendGMText(LANG_GM_ANNOUNCE_COLOR, victim->GetName().c_str(), message.str().c_str());
}
}
static bool HandleMmapPathCommand(ChatHandler* handler, char const* args)
{
if (!MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId(), handler->GetSession()->GetPlayer()->GetTerrainSwaps()))
{
handler->PSendSysMessage("NavMesh not loaded for current map.");
return true;
}
handler->PSendSysMessage("mmap path:");
// units
Player* player = handler->GetSession()->GetPlayer();
Unit* target = handler->getSelectedUnit();
if (!player || !target)
{
handler->PSendSysMessage("Invalid target/source selection.");
return true;
}
char* para = strtok((char*)args, " ");
bool useStraightPath = false;
if (para && strcmp(para, "true") == 0)
useStraightPath = true;
bool useStraightLine = false;
if (para && strcmp(para, "line") == 0)
useStraightLine = true;
// unit locations
float x, y, z;
player->GetPosition(x, y, z);
// path
PathGenerator path(target);
path.SetUseStraightPath(useStraightPath);
bool result = path.CalculatePath(x, y, z, false, useStraightLine);
Movement::PointsArray const& pointPath = path.GetPath();
handler->PSendSysMessage("%s's path to %s:", target->GetName().c_str(), player->GetName().c_str());
handler->PSendSysMessage("Building: %s", useStraightPath ? "StraightPath" : useStraightLine ? "Raycast" : "SmoothPath");
handler->PSendSysMessage("Result: %s - Length: %zu - Type: %u", (result ? "true" : "false"), pointPath.size(), path.GetPathType());
G3D::Vector3 const &start = path.GetStartPosition();
G3D::Vector3 const &end = path.GetEndPosition();
G3D::Vector3 const &actualEnd = path.GetActualEndPosition();
handler->PSendSysMessage("StartPosition (%.3f, %.3f, %.3f)", start.x, start.y, start.z);
handler->PSendSysMessage("EndPosition (%.3f, %.3f, %.3f)", end.x, end.y, end.z);
handler->PSendSysMessage("ActualEndPosition (%.3f, %.3f, %.3f)", actualEnd.x, actualEnd.y, actualEnd.z);
if (!player->IsGameMaster())
handler->PSendSysMessage("Enable GM mode to see the path points.");
for (uint32 i = 0; i < pointPath.size(); ++i)
player->SummonCreature(VISUAL_WAYPOINT, pointPath[i].x, pointPath[i].y, pointPath[i].z, 0, TEMPSUMMON_TIMED_DESPAWN, 9000);
return true;
}
int main (int argc, char * argv[])
{
double dIn;
double dOut;
Measure factor;
char op;
Unit * uIn;
Unit * uOut;
if (argc != 3) GiveUsage();
dIn = atof (argv[1]);
switch (argv[2][0])
{
case 'f': case 'F':
factor = CONVERT_FEETPERMETER;
op = '/';
uIn = &FOOT;
uOut = &METER;
break;
case 'k': case 'K':
factor = CONVERT_SLUGSPERKILOGRAM;
op = '*';
uIn = &KILOGRAM;
uOut = &SLUG;
break;
case 'm': case 'M':
factor = CONVERT_FEETPERMETER;
op = '*';
uIn = &METER;
uOut = &FOOT;
break;
case 's': case 'S':
factor = CONVERT_SLUGSPERKILOGRAM;
op = '/';
uIn = &SLUG;
uOut = &KILOGRAM;
break;
default: GiveUsage(); break;
}
dOut = Convert (dIn, uIn, uOut, op, factor);
cout << dIn << ' ' << uIn->GetName() << " = ";
cout << dOut << ' ' << uOut->GetName() << endl;
exit (0);
}
static bool HandleMmapPathCommand(ChatHandler* handler, const char* args)
{
if (!MMAP::MMapFactory::createOrGetMMapManager()->GetNavMesh(handler->GetSession()->GetPlayer()->GetMapId()))
{
handler->PSendSysMessage("NavMesh not loaded for current map.");
return true;
}
handler->PSendSysMessage("mmap path:");
// units
Player* player = handler->GetSession()->GetPlayer();
Unit* target = handler->getSelectedUnit();
if (!player || !target)
{
handler->PSendSysMessage("Invalid target/source selection.");
return true;
}
char* para = strtok((char*)args, " ");
bool useStraightPath = false;
if (para && strcmp(para, "true") == 0)
useStraightPath = true;
// unit locations
float x, y, z;
player->GetPosition(x, y, z);
// path
PathInfo path(target, x, y, z, useStraightPath);
PointPath pointPath = path.getFullPath();
handler->PSendSysMessage("%s's path to %s:", target->GetName(), player->GetName());
handler->PSendSysMessage("Building %s", useStraightPath ? "StraightPath" : "SmoothPath");
handler->PSendSysMessage("length %i type %u", pointPath.size(), path.getPathType());
PathNode start = path.getStartPosition();
PathNode next = path.getNextPosition();
PathNode end = path.getEndPosition();
PathNode actualEnd = path.getActualEndPosition();
handler->PSendSysMessage("start (%.3f, %.3f, %.3f)", start.x, start.y, start.z);
handler->PSendSysMessage("next (%.3f, %.3f, %.3f)", next.x, next.y, next.z);
handler->PSendSysMessage("end (%.3f, %.3f, %.3f)", end.x, end.y, end.z);
handler->PSendSysMessage("actual end (%.3f, %.3f, %.3f)", actualEnd.x, actualEnd.y, actualEnd.z);
if (!player->isGameMaster())
handler->PSendSysMessage("Enable GM mode to see the path points.");
// this entry visible only to GM's with "gm on"
static const uint32 WAYPOINT_NPC_ENTRY = 1;
for (uint32 i = 0; i < pointPath.size(); ++i)
player->SummonCreature(WAYPOINT_NPC_ENTRY, pointPath[i].x, pointPath[i].y, pointPath[i].z, 0, TEMPSUMMON_TIMED_DESPAWN, 9000);
return true;
}
bool ChatHandler::HandleDebugHostilRefList(const char * /*args*/)
{
Unit* target = getSelectedUnit();
if(!target)
target = m_session->GetPlayer();
HostilReference* ref = target->getHostilRefManager().getFirst();
uint32 cnt = 0;
PSendSysMessage("Hostil reference list of %s (guid %u)",target->GetName(), target->GetGUIDLow());
while(ref)
{
if(Unit * unit = ref->getSource()->getOwner())
{
++cnt;
PSendSysMessage(" %u. %s (guid %u) - threat %f",cnt,unit->GetName(), unit->GetGUIDLow(), ref->getThreat());
}
ref = ref->next();
}
SendSysMessage("End of hostil reference list.");
return true;
}
bool ChatHandler::HandleMonsterCastCommand(const char * args, WorldSession * m_session)
{
Unit* crt = getSelectedCreature(m_session, false);
if(crt == NULL)
{
RedSystemMessage(m_session, "Please select a creature before using this command.");
return true;
}
uint32 spellId = (uint32)atoi(args);
if(spellId == 0)
spellId = GetSpellIDFromLink( args );
SpellEntry * tmpsp = dbcSpell.LookupEntryForced(spellId);
if(tmpsp == NULL)
return false;
crt->CastSpell(reinterpret_cast<Unit*>(NULL), tmpsp, false);
sWorld.LogGM(m_session, "Used npc cast command on %s", crt->GetName());
return true;
}
bool ChatHandler::HandleDebugThreatList(const char * /*args*/)
{
Creature* target = getSelectedCreature();
if(!target || target->isTotem() || target->isPet())
return false;
std::list<HostilReference*>& tlist = target->getThreatManager().getThreatList();
std::list<HostilReference*>::iterator itr;
uint32 cnt = 0;
PSendSysMessage("Threat list of %s (guid %u)",target->GetName(), target->GetGUIDLow());
for(itr = tlist.begin(); itr != tlist.end(); ++itr)
{
Unit* unit = (*itr)->getTarget();
if(!unit)
continue;
++cnt;
PSendSysMessage(" %u. %s (guid %u) - threat %f",cnt,unit->GetName(), unit->GetGUIDLow(), (*itr)->getThreat());
}
SendSysMessage("End of threat list.");
return true;
}
void SummonPlanarAnomaly()
{
std::list<HostileReference*>& m_threatlist = me->getThreatManager().getThreatList();
std::list<HostileReference*>::const_iterator i = m_threatlist.begin();
for (i = m_threatlist.begin(); i!= m_threatlist.end(); ++i)
{
Unit* pUnit = Unit::GetUnit((*me), (*i)->getUnitGuid());
if (pUnit )
{
Creature* summon = DoSummon(PLANAR_ANOMALY, me, 3.0f, 30000, TEMPSUMMON_DEAD_DESPAWN);
if(summon)
{
summon->Attack(pUnit,true);
printf("PLANAR_ANOMALY attack uinit %s \n",pUnit->GetName());
summon->SetVisibility(VISIBILITY_ON);
summon->RemoveFlag(UNIT_FIELD_FLAGS, UNIT_FLAG_NOT_SELECTABLE);
summon->SetUnitMovementFlags(MOVEMENTFLAG_FLYING);
}
}
}
}
void WorldSession::HandleTextEmoteOpcode( WorldPacket & recv_data )
{
if(!GetPlayer()->isAlive())
return;
if (!GetPlayer()->CanSpeak())
{
std::string timeStr = secsToTimeString(m_muteTime - time(NULL));
SendNotification(GetMangosString(LANG_WAIT_BEFORE_SPEAKING),timeStr.c_str());
return;
}
CHECK_PACKET_SIZE(recv_data,4+4+8);
uint32 text_emote, emoteNum;
uint64 guid;
recv_data >> text_emote;
recv_data >> emoteNum;
recv_data >> guid;
const char *nam = 0;
uint32 namlen = 1;
Unit* unit = ObjectAccessor::GetUnit(*_player, guid);
Creature *pCreature = dynamic_cast<Creature *>(unit);
if(unit)
{
nam = unit->GetName();
namlen = (nam ? strlen(nam) : 0) + 1;
}
EmotesTextEntry const *em = sEmotesTextStore.LookupEntry(text_emote);
if (em)
{
uint32 emote_anim = em->textid;
WorldPacket data;
switch(emote_anim)
{
case EMOTE_STATE_SLEEP:
case EMOTE_STATE_SIT:
case EMOTE_STATE_KNEEL:
case EMOTE_ONESHOT_NONE:
break;
default:
GetPlayer()->HandleEmoteCommand(emote_anim);
break;
}
data.Initialize(SMSG_TEXT_EMOTE, (20+namlen));
data << GetPlayer()->GetGUID();
data << (uint32)text_emote;
data << emoteNum;
data << (uint32)namlen;
if( namlen > 1 )
{
data.append(nam, namlen);
}
else
{
data << (uint8)0x00;
}
GetPlayer()->SendMessageToSetInRange(&data,sWorld.getConfig(CONFIG_LISTEN_RANGE_TEXTEMOTE),true);
//Send scripted event call
if (pCreature && Script)
Script->ReceiveEmote(GetPlayer(),pCreature,text_emote);
}
}
void UpdateAI(const uint32 diff)
{
//Inhibitmagic_Timer
if (Inhibitmagic_Timer < diff)
{
float dist;
Map *map = m_creature->GetMap();
Map::PlayerList const &PlayerList = map->GetPlayers();
for(Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
if (Player* i_pl = i->getSource())
if (i_pl->isAlive() && (dist = i_pl->GetDistance(m_creature)) < 45)
{
i_pl->RemoveAurasDueToSpell(SPELL_INHIBITMAGIC);
m_creature->AddAura(SPELL_INHIBITMAGIC, i_pl);
if(dist < 35)
m_creature->AddAura(SPELL_INHIBITMAGIC, i_pl);
if(dist < 25)
m_creature->AddAura(SPELL_INHIBITMAGIC, i_pl);
if(dist < 15)
m_creature->AddAura(SPELL_INHIBITMAGIC, i_pl);
}
Inhibitmagic_Timer = 3000+(rand()%1000);
}else Inhibitmagic_Timer -= diff;
//Return since we have no target
if (!UpdateVictim() )
return;
//Attractmagic_Timer
if (Attractmagic_Timer < diff)
{
DoCast(m_creature,SPELL_ATTRACTMAGIC);
Attractmagic_Timer = 30000;
Carnivorousbite_Timer = 1500;
}else Attractmagic_Timer -= diff;
//Carnivorousbite_Timer
if (Carnivorousbite_Timer < diff)
{
DoCast(m_creature,SPELL_CARNIVOROUSBITE);
Carnivorousbite_Timer = 10000;
}else Carnivorousbite_Timer -= diff;
//FocusFire_Timer
if (FocusFire_Timer < diff)
{
// Summon Focus Fire & Emote
Unit *target = SelectUnit(SELECT_TARGET_RANDOM,1);
if (target && target->GetTypeId() == TYPEID_PLAYER && target->isAlive())
{
focusedTarget = target;
m_creature->SummonCreature(ENTRY_FOCUS_FIRE,target->GetPositionX(),target->GetPositionY(),target->GetPositionZ(),0,TEMPSUMMON_TIMED_DESPAWN,5500);
// Emote
std::string *emote = new std::string("focuses on ");
emote->append(target->GetName());
emote->append("!");
DoTextEmote(emote->c_str(),NULL,true);
delete emote;
}
FocusFire_Timer = 15000+(rand()%5000);
}else FocusFire_Timer -= diff;
DoMeleeAttackIfReady();
}
/*this procedure handles clients CMSG_REQUEST_PARTY_MEMBER_STATS request*/
void WorldSession::HandleRequestPartyMemberStatsOpcode( WorldPacket &recv_data )
{
DEBUG_LOG("WORLD: Received CMSG_REQUEST_PARTY_MEMBER_STATS");
ObjectGuid guid;
recv_data >> guid;
Player * player = HashMapHolder<Player>::Find(guid);
if(!player)
{
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 3+4+2);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data << guid.WriteAsPacked();
data << uint32(GROUP_UPDATE_FLAG_STATUS);
data << uint16(MEMBER_STATUS_OFFLINE);
SendPacket(&data);
return;
}
Unit *pet = player->GetCharmOrPet();
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 4+2+2+2+1+2*6+8+1+8);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data << player->GetPackGUID();
uint32 mask1 = 0x00040BFF; // common mask, real flags used 0x000040BFF
if(pet)
mask1 = 0xFFFFFFFF; // for hunters and other classes with pets
Powers powerType = player->getPowerType();
data << uint32(mask1); // group update mask
data << uint16(MEMBER_STATUS_ONLINE); // member's online status
data << uint32(player->GetHealth()); // GROUP_UPDATE_FLAG_CUR_HP
data << uint32(player->GetMaxHealth()); // GROUP_UPDATE_FLAG_MAX_HP
data << uint8(powerType); // GROUP_UPDATE_FLAG_POWER_TYPE
data << uint16(player->GetPower(powerType)); // GROUP_UPDATE_FLAG_CUR_POWER
data << uint16(player->GetMaxPower(powerType)); // GROUP_UPDATE_FLAG_MAX_POWER
data << uint16(player->getLevel()); // GROUP_UPDATE_FLAG_LEVEL
//verify player coordinates and zoneid to send to teammates
uint16 iZoneId = 0;
uint16 iCoordX = 0;
uint16 iCoordY = 0;
if (player->IsInWorld())
{
iZoneId = player->GetZoneId();
iCoordX = player->GetPositionX();
iCoordY = player->GetPositionY();
}
else if (player->IsBeingTeleported()) // Player is in teleportation
{
WorldLocation& loc = player->GetTeleportDest(); // So take teleportation destination
iZoneId = sTerrainMgr.GetZoneId(loc.mapid, loc.coord_x, loc.coord_y, loc.coord_z);
iCoordX = loc.coord_x;
iCoordY = loc.coord_y;
}
else
{
//unknown player status.
}
data << uint16(iZoneId); // GROUP_UPDATE_FLAG_ZONE
data << uint16(iCoordX); // GROUP_UPDATE_FLAG_POSITION
data << uint16(iCoordY); // GROUP_UPDATE_FLAG_POSITION
uint64 auramask = 0;
size_t maskPos = data.wpos();
data << uint64(auramask); // placeholder
for(uint8 i = 0; i < MAX_AURAS; ++i)
{
if(uint32 aura = player->GetVisibleAura(i))
{
auramask |= (uint64(1) << i);
data << uint32(aura);
data << uint8(1);
}
}
data.put<uint64>(maskPos, auramask); // GROUP_UPDATE_FLAG_AURAS
if(pet)
{
Powers petpowertype = pet->getPowerType();
data << pet->GetObjectGuid(); // GROUP_UPDATE_FLAG_PET_GUID
data << pet->GetName(); // GROUP_UPDATE_FLAG_PET_NAME
data << uint16(pet->GetDisplayId()); // GROUP_UPDATE_FLAG_PET_MODEL_ID
data << uint32(pet->GetHealth()); // GROUP_UPDATE_FLAG_PET_CUR_HP
data << uint32(pet->GetMaxHealth()); // GROUP_UPDATE_FLAG_PET_MAX_HP
data << uint8(petpowertype); // GROUP_UPDATE_FLAG_PET_POWER_TYPE
data << uint16(pet->GetPower(petpowertype)); // GROUP_UPDATE_FLAG_PET_CUR_POWER
data << uint16(pet->GetMaxPower(petpowertype)); // GROUP_UPDATE_FLAG_PET_MAX_POWER
uint64 petauramask = 0;
size_t petMaskPos = data.wpos();
data << uint64(petauramask); // placeholder
for(uint8 i = 0; i < MAX_AURAS; ++i)
{
if(uint32 petaura = pet->GetVisibleAura(i))
{
petauramask |= (uint64(1) << i);
data << uint32(petaura);
data << uint8(1);
}
}
data.put<uint64>(petMaskPos, petauramask); // GROUP_UPDATE_FLAG_PET_AURAS
data << (uint32) player->m_movementInfo.GetTransportDBCSeat();
}
else
{
data << uint8(0); // GROUP_UPDATE_FLAG_PET_NAME
data << uint64(0); // GROUP_UPDATE_FLAG_PET_AURAS
}
SendPacket(&data);
}
void WorldSession::BuildPartyMemberStatsChangedPacket(Player *player, WorldPacket *data)
{
uint32 mask = player->GetGroupUpdateFlag();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE) // if update power type, update current/max power also
mask |= (GROUP_UPDATE_FLAG_CUR_POWER | GROUP_UPDATE_FLAG_MAX_POWER);
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE) // same for pets
mask |= (GROUP_UPDATE_FLAG_PET_CUR_POWER | GROUP_UPDATE_FLAG_PET_MAX_POWER);
uint32 byteCount = 0;
for (int i = 1; i < GROUP_UPDATE_FLAGS_COUNT; ++i)
if (mask & (1 << i))
byteCount += GroupUpdateLength[i];
data->Initialize(SMSG_PARTY_MEMBER_STATS, 8 + 4 + byteCount);
*data << player->GetPackGUID();
*data << uint32(mask);
if (mask & GROUP_UPDATE_FLAG_STATUS)
{
if (player)
{
if (player->IsPvP())
*data << uint16(MEMBER_STATUS_ONLINE | MEMBER_STATUS_PVP);
else
*data << uint16(MEMBER_STATUS_ONLINE);
}
else
*data << uint16(MEMBER_STATUS_OFFLINE);
}
if (mask & GROUP_UPDATE_FLAG_CUR_HP)
*data << uint32(player->GetHealth());
if (mask & GROUP_UPDATE_FLAG_MAX_HP)
*data << uint32(player->GetMaxHealth());
Powers powerType = player->getPowerType();
if (mask & GROUP_UPDATE_FLAG_POWER_TYPE)
*data << uint8(powerType);
if (mask & GROUP_UPDATE_FLAG_CUR_POWER)
*data << uint16(player->GetPower(powerType));
if (mask & GROUP_UPDATE_FLAG_MAX_POWER)
*data << uint16(player->GetMaxPower(powerType));
if (mask & GROUP_UPDATE_FLAG_LEVEL)
*data << uint16(player->getLevel());
if (mask & GROUP_UPDATE_FLAG_ZONE)
*data << uint16(player->GetZoneId());
if (mask & GROUP_UPDATE_FLAG_POSITION)
*data << uint16(player->GetPositionX()) << uint16(player->GetPositionY());
if (mask & GROUP_UPDATE_FLAG_AURAS)
{
const uint64& auramask = player->GetAuraUpdateMask();
*data << uint64(auramask);
for(uint32 i = 0; i < MAX_AURAS; ++i)
{
if(auramask & (uint64(1) << i))
{
*data << uint32(player->GetVisibleAura(i));
*data << uint8(1);
}
}
}
Unit *pet = player->GetCharmOrPet();
if (mask & GROUP_UPDATE_FLAG_PET_GUID)
*data << (pet ? pet->GetObjectGuid() : ObjectGuid());
if (mask & GROUP_UPDATE_FLAG_PET_NAME)
{
if(pet)
*data << pet->GetName();
else
*data << uint8(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MODEL_ID)
{
if(pet)
*data << uint16(pet->GetDisplayId());
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_HP)
{
if(pet)
*data << uint32(pet->GetHealth());
else
*data << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_HP)
{
if(pet)
*data << uint32(pet->GetMaxHealth());
else
*data << uint32(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_POWER_TYPE)
{
if(pet)
*data << uint8(pet->getPowerType());
else
*data << uint8(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_CUR_POWER)
{
if(pet)
*data << uint16(pet->GetPower(pet->getPowerType()));
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_MAX_POWER)
{
if(pet)
*data << uint16(pet->GetMaxPower(pet->getPowerType()));
else
*data << uint16(0);
}
if (mask & GROUP_UPDATE_FLAG_PET_AURAS)
{
if(pet)
{
const uint64& auramask = pet->GetAuraUpdateMask();
*data << uint64(auramask);
for(uint32 i = 0; i < MAX_AURAS; ++i)
{
if(auramask & (uint64(1) << i))
{
*data << uint32(pet->GetVisibleAura(i));
*data << uint8(1);
}
}
}
else
*data << uint64(0);
}
if (mask & GROUP_UPDATE_FLAG_VEHICLE_SEAT)
{
*data << (uint32) player->m_movementInfo.GetTransportDBCSeat();
}
}
void UpdateAI(const uint32 uiDiff)
{
if (!m_creature->SelectHostileTarget() || !m_creature->getVictim())
return;
if (m_uiEvadeCheckCooldown < uiDiff)
{
if (m_creature->GetDistance2d(140.34f, -102.34f) > 80.0f)
EnterEvadeMode();
m_uiEvadeCheckCooldown = 2000;
}
else
m_uiEvadeCheckCooldown -= uiDiff;
if (m_bImpaleInProgress)
{
if (m_uiImpaleAfterStompTimer < uiDiff)
{
if (Unit* pTarget = m_creature->getVictim())
{
DoCastSpellIfCan(pTarget, m_bIsRegularMode ? SPELL_IMPALE_DMG_N : SPELL_IMPALE_DMG_H);
pTarget->CastSpell(pTarget, SPELL_IMPALE_STUN, true);
}
m_bImpaleInProgress = false;
}
else
{
m_uiImpaleAfterStompTimer -= uiDiff;
return;
}
}
if (m_bCrushingLeapInProgress)
{
if (m_pCrushingLeapTarget)
{
if (m_pCrushingLeapTarget->isDead() || !m_pCrushingLeapTarget->IsInWorld() && !m_pCrushingLeapTarget->IsInMap(m_creature))
{
m_bCrushingLeapInProgress = false;
return;
}
}
else
{
m_bCrushingLeapInProgress = false;
return;
}
if ((m_uiCrushingLeapSecureTimer < uiDiff) || (m_pCrushingLeapTarget && m_creature->IsWithinDist(m_pCrushingLeapTarget, 5.0f)))
{
m_creature->getThreatManager().addThreat(m_pCrushingLeapTarget, -100000000.0f);
m_creature->SetSpeedRate(MOVE_RUN, m_fDefaultMoveSpeed);
DoCastSpellIfCan(m_pCrushingLeapTarget, m_bIsRegularMode ? SPELL_CRUSHING_LEAP_N : SPELL_CRUSHING_LEAP_H, true);
m_bCrushingLeapInProgress = false;
}
else
m_uiCrushingLeapSecureTimer -= uiDiff;
return;
}
if (m_bRockShardsInProgress)
{
if (m_uiRockShardsProgressTimer < uiDiff)
{
m_bRockShardsInProgress = false;
if (m_pRockShardsTarget)
m_creature->getThreatManager().addThreat(m_pRockShardsTarget, -100000000.0f);
return;
}
else
m_uiRockShardsProgressTimer -= uiDiff;
if (m_uiRockShardTimer < uiDiff)
{
if (m_pRockShardsTarget && m_pRockShardsTarget->isAlive())
{
DoCast(m_pRockShardsTarget, m_bIsRegularMode ? (m_bRLRockShard ? SPELL_ROCK_SHARDS_LEFT_N : SPELL_ROCK_SHARDS_RIGHT_N) : (m_bRLRockShard ? SPELL_ROCK_SHARDS_LEFT_H : SPELL_ROCK_SHARDS_RIGHT_H));
m_bRLRockShard = !m_bRLRockShard;
}
m_uiRockShardTimer = 100;
}
else
m_uiRockShardsTimer -= uiDiff;
return;
}
if (m_uiRockShardsTimer < uiDiff)
{
m_bRockShardsInProgress = true;
m_uiRockShardsProgressTimer = 3000;
m_bRLRockShard = true;
m_pRockShardsTarget = NULL;
if (m_pRockShardsTarget = m_creature->SelectAttackingTarget(ATTACKING_TARGET_RANDOM, 0))
m_creature->getThreatManager().addThreat(m_pRockShardsTarget, 100000000.0f);
m_uiRockShardsTimer = 15000+rand()%15000;
return;
}
else
m_uiRockShardsTimer -= uiDiff;
if (m_uiCrushingLeapTimer < uiDiff)
{
ThreatList const& tList = m_creature->getThreatManager().getThreatList();
std::list<Unit*> lTargets;
for (ThreatList::const_iterator itr = tList.begin();itr != tList.end(); ++itr)
{
Unit *pTemp = Unit::GetUnit(*m_creature, (*itr)->getUnitGuid());
if (pTemp && pTemp->GetTypeId() == TYPEID_PLAYER && !m_creature->IsWithinDist(pTemp, 10.0f) && m_creature->IsWithinDist(pTemp, 80.0f))
lTargets.push_back(pTemp);
}
m_pCrushingLeapTarget = NULL;
if (!lTargets.empty())
{
std::list<Unit*>::iterator pTarget = lTargets.begin();
advance(pTarget, (rand() % lTargets.size()));
m_pCrushingLeapTarget = *pTarget;
if (m_pCrushingLeapTarget)
{
m_creature->MonsterSay(m_pCrushingLeapTarget->GetName(), LANG_UNIVERSAL, NULL);
m_creature->getThreatManager().addThreat(m_pCrushingLeapTarget, 100000000.0f);
m_creature->SetSpeedRate(MOVE_RUN, m_fDefaultMoveSpeed*10.0f);
m_bCrushingLeapInProgress = true;
m_uiCrushingLeapSecureTimer = 2000;
}
}
m_uiCrushingLeapTimer = 30000+rand()%15000;
return;
}
else
m_uiCrushingLeapTimer -= uiDiff;
if (m_uiStompTimer < uiDiff)
{
DoCastSpellIfCan(m_creature, m_bIsRegularMode ? SPELL_STOMP_N : SPELL_STOMP_H);
m_uiImpaleAfterStompTimer = 1000;
m_bImpaleInProgress = true;
m_uiStompTimer = 45000+rand()%15000;
}
else
m_uiStompTimer -= uiDiff;
if (m_uiBerserkTimer < uiDiff)
{
DoCastSpellIfCan(m_creature, SPELL_BERSERK);
m_uiBerserkTimer = 60000;
}
else
m_uiBerserkTimer -= uiDiff;
DoMeleeAttackIfReady();
}
void TradeManager::UpdateCreateList(const PLAYER_INDEX & player_id)
{
Assert(player_id >= 0 && player_id < k_MAX_PLAYERS);
if(player_id < 0 || player_id >= k_MAX_PLAYERS) return;
Player * p = g_player[player_id];
Assert(p);
if (!p) return;
sint32 d;
Unit maxCity[k_MAX_CITIES_PER_GOOD];
m_createList->Clear();
m_createData.DeleteAll();
for (sint32 c = 0; c < p->m_all_cities->Num(); c++)
{
Unit city = p->m_all_cities->Access(c);
for (sint32 g = 0; g < g_theResourceDB->NumRecords(); g++)
{
if(city.CD()->IsLocalResource(g)) {
sint32 op;
sint32 maxPrice[k_MAX_CITIES_PER_GOOD];
sint32 sellingPrice = -1;
Unit curDestCity;
sint32 i,j;
for(i = 0; i < k_MAX_CITIES_PER_GOOD; i++) {
maxCity[i].m_id = 0;
maxPrice[i] = 0;
}
if(!city.CD()->HasResource(g) &&
city.CD()->IsSellingResourceTo(g, curDestCity) ) {
sellingPrice = tradeutil_GetTradeValue(player_id, curDestCity, g);
//need to add something here where cities that have an improvement that needs a good will demand the good. May be increase the value of selling that good?
}
else {
curDestCity.m_id = 0;
sellingPrice = -1;
}
for(op = 1; op < k_MAX_PLAYERS; op++) {
if(!g_player[op]) continue;
if(player_id != op && !p->HasContactWith(op)) continue;
if(m_showCities == TRADE_CITIES_OWN && op != g_selected_item->GetVisiblePlayer()) continue;
if ((m_showCities == TRADE_CITIES_ALL) &&
(op != g_selected_item->GetVisiblePlayer()) &&
(AgreementMatrix::s_agreements.TurnsAtWar(player_id, op) >= 0)
)
continue;
if ((m_showCities == TRADE_CITIES_FRIENDLY) &&
(op != g_selected_item->GetVisiblePlayer()) &&
(!AgreementMatrix::s_agreements.HasAgreement
(player_id, op, PROPOSAL_TREATY_PEACE)
)
)
continue;
if(Diplomat::GetDiplomat(op).GetEmbargo(player_id))
continue;
for(d = 0; d < g_player[op]->m_all_cities->Num(); d++) {
Unit destCity = g_player[op]->m_all_cities->Access(d);
if(!(destCity.IsValid())) continue;
if(!(destCity.GetVisibility() & (1 << player_id))) continue;
if(destCity.m_id == city.m_id) continue;
if(curDestCity.m_id == destCity.m_id) continue;
sint32 price = tradeutil_GetTradeValue(player_id, destCity, g);
for(i = 0; i < m_numCities; i++) {
if(price > maxPrice[i]) {
for(j = m_numCities - 1; j>= i; j--) {
maxPrice[j] = maxPrice[j - 1];
maxCity[j].m_id = maxCity[j - 1].m_id;
}
maxPrice[i] = price;
maxCity[i] = destCity;
break;
}
}
}
}
for(i = 0; i < k_MAX_CITIES_PER_GOOD; i++) {
if(maxPrice[i] > 0) {
if(maxCity[i].m_id == curDestCity.m_id)
continue;
ctp2_ListItem * item =
(ctp2_ListItem *) aui_Ldl::BuildHierarchyFromRoot("CreateRouteItem");
Assert(item);
if(!item)
break;
CreateListData *data = new CreateListData;
data->m_source = city;
data->m_resource = g;
data->m_destination = maxCity[i];
data->m_price = maxPrice[i];
data->m_caravans = tradeutil_GetAccurateTradeDistance(city, maxCity[i]);
data->m_curDestination.m_id = curDestCity.m_id;
m_createData.AddTail(data);
item->SetUserData(data);
if (ctp2_Static * origin = (ctp2_Static *)item->GetChildByIndex(k_CITY_COL_INDEX))
{
MBCHAR name[k_MAX_NAME_LEN + 1];
strncpy(name, city.GetName(), k_MAX_NAME_LEN);
name[k_MAX_NAME_LEN] = 0;
origin->TextReloadFont();
origin->GetTextFont()->TruncateString(name, origin->Width());
origin->SetText(name);
}
if (ctp2_Static * icon = (ctp2_Static *)item->GetChildByIndex(k_GOODICON_COL_INDEX))
{
const char *iconname = g_theResourceDB->Get(g)->GetIcon()->GetIcon();
if (stricmp(iconname, "NULL") == 0)
{
iconname = NULL;
}
icon->SetImage(iconname);
}
if (ctp2_Static * good = (ctp2_Static *)item->GetChildByIndex(k_GOOD_COL_INDEX))
{
good->SetText(g_theResourceDB->Get(g)->GetNameText());
if (curDestCity.m_id != 0)
{
good->SetTextColor(g_colorSet->GetColorRef(COLOR_RED));
}
}
if (ctp2_Static * dest = (ctp2_Static *)item->GetChildByIndex(k_TOCITY_COL_INDEX))
{
MBCHAR name[k_MAX_NAME_LEN + 1];
strncpy(name, maxCity[i].GetName(), k_MAX_NAME_LEN);
name[k_MAX_NAME_LEN] = 0;
dest->TextReloadFont();
dest->GetTextFont()->TruncateString(name, dest->Width());
dest->SetText(name);
}
MBCHAR buf[20];
sprintf(buf, "%d", maxPrice[i]);
if (ctp2_Static * price = (ctp2_Static *)item->GetChildByIndex(k_PRICE_COL_INDEX))
{
price->SetText(buf);
}
if (ctp2_Static * count = (ctp2_Static *)item->GetChildByIndex(k_CARAVANS_COL_INDEX))
{
sprintf(buf, "%d", data->m_caravans);
count->SetText(buf);
}
if (ctp2_Static * nation = (ctp2_Static *)item->GetChildByIndex(k_NATION_COL_INDEX))
{
nation->SetDrawCallbackAndCookie
(DrawNationColumn, (void *)data->m_destination.GetOwner());
}
item->SetCompareCallback(CompareCreateItems);
m_createList->AddItem(item);
}
}
}
}
}
m_createButton->Enable(FALSE);
}
void TradeManager::UpdateSummaryList()
{
sint32 pl = g_selected_item->GetVisiblePlayer();
Assert(pl >= 0 && pl < k_MAX_PLAYERS);
if(pl < 0 || pl >= k_MAX_PLAYERS) return;
Assert(g_player[pl]);
if(!g_player[pl]) return;
Player *p = g_player[pl];
Unit maxCity;
m_summaryList->Clear();
for (sint32 c = 0; c < p->m_all_cities->Num(); c++)
{
Unit city = p->m_all_cities->Access(c);
for (sint32 r = 0; r < city.CD()->GetTradeSourceList()->Num(); r++)
{
ctp2_ListItem * item = (ctp2_ListItem *)
aui_Ldl::BuildHierarchyFromRoot("TradeSummaryItem");
Assert(item);
if(!item)
break;
TradeRoute route = city.CD()->GetTradeSourceList()->Access(r);
if (ctp2_Static * origin = (ctp2_Static *)item->GetChildByIndex(k_CITY_COL_SUM_INDEX))
{
MBCHAR name[k_MAX_NAME_LEN + 1];
strncpy(name, city.GetName(), k_MAX_NAME_LEN);
name[k_MAX_NAME_LEN] = 0;
origin->TextReloadFont();
origin->GetTextFont()->TruncateString(name, origin->Width());
origin->SetText(name);
}
ROUTE_TYPE rtype;
sint32 resource;
route.GetSourceResource(rtype, resource);
if (ctp2_Static * icon = (ctp2_Static *)item->GetChildByIndex(k_GOODICON_COL_SUM_INDEX))
{
if (rtype == ROUTE_TYPE_RESOURCE)
{
const MBCHAR *imageName = g_theResourceDB->Get(resource)->GetIcon()->GetIcon();
if (stricmp(imageName, "NULL") == 0)
{
icon->SetImage(NULL);
}
else
{
icon->SetImage(g_theResourceDB->Get(resource)->GetIcon()->GetIcon());
}
}
}
if (ctp2_Static * good = (ctp2_Static *)item->GetChildByIndex(k_GOOD_COL_SUM_INDEX))
{
if (rtype == ROUTE_TYPE_RESOURCE)
{
good->SetText(g_theResourceDB->Get(resource)->GetNameText());
}
else
{
good->SetText(g_theStringDB->GetNameStr("ROUTE_TYPE_FOOD"));
}
}
if (ctp2_Static * dest = (ctp2_Static *)item->GetChildByIndex(k_TOCITY_COL_SUM_INDEX))
{
MBCHAR name[k_MAX_NAME_LEN + 1];
Unit dCity = route.GetDestination();
strncpy(name, dCity.GetName(), k_MAX_NAME_LEN);
name[k_MAX_NAME_LEN] = 0;
dest->TextReloadFont();
dest->GetTextFont()->TruncateString(name, dest->Width());
dest->SetText(name);
}
if (ctp2_Static * piracy = (ctp2_Static *)item->GetChildByIndex(k_PIRACY_COL_SUM_INDEX))
{
piracy->SetDrawCallbackAndCookie(DrawPiracyColumn, (void *)route.m_id);
}
MBCHAR buf[20];
if(rtype == ROUTE_TYPE_RESOURCE) {
sprintf(buf, "%d", route->GetValue());
} else {
strcpy(buf, "---");
}
if (ctp2_Static * price = (ctp2_Static *)item->GetChildByIndex(k_PRICE_COL_SUM_INDEX))
{
price->SetText(buf);
}
if (ctp2_Static * count = (ctp2_Static *)item->GetChildByIndex(k_CARAVANS_COL_SUM_INDEX))
{
sprintf(buf, "%.0f", route.GetCost());
count->SetText(buf);
}
if (ctp2_Static * nation = (ctp2_Static *)item->GetChildByIndex(k_NATION_COL_SUM_INDEX))
{
nation->SetDrawCallbackAndCookie
(DrawNationColumn, (void *)route.GetDestination().GetOwner());
}
item->SetUserData((void *)route.m_id);
item->SetCompareCallback(CompareSummaryItems);
m_summaryList->AddItem(item);
}
}
m_breakButton->Enable(FALSE);
}
//----------------------------------------------------------------------------
//
// Name : UnseenCell::UnseenCell
//
// Description: Constructor
//
// Parameters : point : The point (RC coordinate)
//
// Globals : g_theWorld : World information
//
// Returns : -
//
// Remark(s) : The constructor to use normally.
//
//----------------------------------------------------------------------------
UnseenCell::UnseenCell(const MapPoint & point)
:
m_env (0),
m_terrain_type (TERRAIN_UNKNOWN),
m_move_cost (MOVECOST_UNKNOWN),
m_flags (0x0000),
m_bioInfectedOwner (0x00), /// @todo Check PLAYER_UNASSIGNED?
m_nanoInfectedOwner (0x00),
m_convertedOwner (0x00),
m_franchiseOwner (0x00),
m_injoinedOwner (0x00),
m_happinessAttackOwner (0x00),
m_citySize (0),
m_cityOwner (0),
m_citySpriteIndex (-1),
m_cell_owner (PLAYER_UNASSIGNED),
m_slaveBits (0x0000),
#ifdef BATTLE_FLAGS
m_battleFlags (0),
#endif
m_tileInfo (NULL),
m_point (point),
m_installations (new PointerList<UnseenInstallationInfo>),
m_improvements (new PointerList<UnseenImprovementInfo>),
m_cityName (NULL),
m_actor (NULL),
m_poolIndex (-1),
m_visibleCityOwner (0)
{
if (g_theWorld->GetTileInfo(point))
{
m_tileInfo = new TileInfo(g_theWorld->GetTileInfo(point));
}
Cell * cell = g_theWorld->GetCell(point);
if (cell)
{
m_env = cell->GetEnv();
m_move_cost = sint16(cell->GetMoveCost());
m_terrain_type = (sint8)TERRAIN_TYPES(cell->GetTerrain());
#ifdef BATTLE_FLAGS
m_battleFlags = cell->GetBattleFlags();
#endif
sint32 i;
// Same as well information about existing
// tile improvments, except roadlike ones,
// so that this information is available
// later as well.
// And in order not to break anythink use the existing
// list for unfinished tile improvements.
for(i = 0; i < cell->GetNumDBImprovements(); i++) {
sint32 imp = cell->GetDBImprovement(i);
m_improvements->AddTail(new UnseenImprovementInfo(imp, 100));
}
for(i = 0; i < cell->GetNumImprovements(); i++) {
TerrainImprovement imp = cell->AccessImprovement(i);
if (imp.IsValid())
{
m_improvements->AddTail(new UnseenImprovementInfo(imp.GetType(),
imp.PercentComplete()));
}
}
DynamicArray<Installation> instArray;
g_theInstallationTree->GetAt(point, instArray);
for(i = 0; i < instArray.Num(); i++) {
m_installations->AddTail(new UnseenInstallationInfo(instArray[i].GetType(),
instArray[i].GetVisibility()));
}
m_cell_owner = (sint8) cell->GetOwner();
// Store the city that controlls this tile.
m_visibleCityOwner = cell->GetCityOwner().m_id;
Unit city = cell->GetCity();
if (city.IsValid())
{
m_citySize = (sint16)city.PopCount();
m_citySpriteIndex = (sint16)city.CD()->GetDesiredSpriteIndex();
const MBCHAR *name = city.GetName();
m_cityName = new MBCHAR[strlen(name) + 1];
strcpy(m_cityName, name);
m_cityOwner = static_cast<sint16>(city.GetCityData()->GetOwner());
CityData *cityData = city.GetData()->GetCityData();
UnitActor *actor = city.GetActor();
if (actor) {
SpriteState *newSS = new SpriteState(city.GetSpriteState()->GetIndex());
UnitActor *newActor = new UnitActor(newSS,
city,
city.GetType(),
point,
city.GetOwner(),
TRUE,
city.GetVisionRange(),
city.CD()->GetDesiredSpriteIndex());
newActor->SetUnitVisibility((1 << g_selected_item->GetVisiblePlayer())
| actor->GetUnitVisibility());
newActor->SetPos(point);
newActor->SetIsFortified(actor->IsFortified());
newActor->SetIsFortifying(actor->IsFortifying());
newActor->SetHasCityWalls(actor->HasCityWalls());
newActor->SetHasForceField(actor->HasForceField());
newActor->SetSize(m_citySize);
newActor->ChangeImage(newSS, city.GetType(), city);
newActor->AddIdle();
newActor->GetNextAction();
m_actor = newActor;
} // actor
SetIsBioInfected(cityData->IsBioInfected());
SetIsNanoInfected(cityData->IsNanoInfected());
SetIsConverted(cityData->IsConverted());
SetIsFranchised(cityData->IsFranchised());
SetIsInjoined(cityData->IsInjoined());
SetWasHappinessAttacked(cityData->WasHappinessAttacked());
SetIsRioting(cityData->GetIsRioting());
SetHasAirport(cityData->HasAirport());
SetHasSleepingUnits(cityData->HasSleepingUnits());
SetIsWatchful(cityData->IsWatchful());
SetIsCapitol(cityData->IsCapitol()); //emod
SetIsReligionIcon(cityData->HasReligionIcon()); //emod
m_bioInfectedOwner = (sint8)cityData->GetBioInfectedBy();
m_nanoInfectedOwner = (sint8)cityData->GetNanoInfectedBy();
m_convertedOwner = (sint8)cityData->IsConvertedTo();
m_franchiseOwner = (sint8)cityData->GetFranchiseOwner();
m_injoinedOwner = (sint8)cityData->InjoinedBy();
m_happinessAttackOwner = (sint8)cityData->GetHappinessAttackedBy();
m_slaveBits = cityData->GetSlaveBits();
SetIsSpecialIcon(cityData->HasSpecialIcon()); //emod
sint32 pollution = cityData->GetPollution();
SetIsPollutionRisk(pollution > g_theConstDB->Get(0)->GetLocalPollutionLevel());
} // city.IsValid
} // cell
SetHasHut(NULL != g_theWorld->GetGoodyHut(point));
}
void UpdateAI(const uint32 diff)
{
//Inhibitmagic_Timer
if (Inhibitmagic_Timer <= diff)
{
float dist;
Map* map = me->GetMap();
Map::PlayerList const &PlayerList = map->GetPlayers();
for (Map::PlayerList::const_iterator i = PlayerList.begin(); i != PlayerList.end(); ++i)
if (Player* i_pl = i->getSource())
if (i_pl->isAlive() && (dist = i_pl->IsWithinDist(me, 45)))
{
i_pl->RemoveAurasDueToSpell(SPELL_INHIBITMAGIC);
me->AddAura(SPELL_INHIBITMAGIC, i_pl);
if (dist < 35)
me->AddAura(SPELL_INHIBITMAGIC, i_pl);
if (dist < 25)
me->AddAura(SPELL_INHIBITMAGIC, i_pl);
if (dist < 15)
me->AddAura(SPELL_INHIBITMAGIC, i_pl);
}
Inhibitmagic_Timer = 3000+(rand()%1000);
} else Inhibitmagic_Timer -= diff;
//Return since we have no target
if (!UpdateVictim())
return;
//Attractmagic_Timer
if (Attractmagic_Timer <= diff)
{
DoCast(me, SPELL_ATTRACTMAGIC);
Attractmagic_Timer = 30000;
Carnivorousbite_Timer = 1500;
} else Attractmagic_Timer -= diff;
//Carnivorousbite_Timer
if (Carnivorousbite_Timer <= diff)
{
DoCast(me, SPELL_CARNIVOROUSBITE);
Carnivorousbite_Timer = 10000;
} else Carnivorousbite_Timer -= diff;
//FocusFire_Timer
if (FocusFire_Timer <= diff)
{
// Summon Focus Fire & Emote
Unit* target = SelectTarget(SELECT_TARGET_RANDOM, 1);
if (target && target->GetTypeId() == TYPEID_PLAYER && target->isAlive())
{
FocusedTargetGUID = target->GetGUID();
me->SummonCreature(ENTRY_FOCUS_FIRE, target->GetPositionX(), target->GetPositionY(), target->GetPositionZ(), 0, TEMPSUMMON_TIMED_DESPAWN, 5500);
// TODO: Find better way to handle emote
// Emote
std::string emote(EMOTE_FOCUSES_ON);
emote.append(target->GetName());
emote.push_back('!');
me->MonsterTextEmote(emote.c_str(), 0, true);
}
FocusFire_Timer = 15000+(rand()%5000);
} else FocusFire_Timer -= diff;
DoMeleeAttackIfReady();
}
bool ChatHandler::HandleMonsterYellCommand(const char* args, WorldSession *m_session)
{
Unit* crt = getSelectedUnit(m_session, false);
if(!crt)
return true;
if(crt->IsPlayer())
{
WorldPacket * data = FillMessageData(CHAT_MSG_YELL, LANG_UNIVERSAL, args, crt->GetGUID(), 0);
crt->SendMessageToSet(data, true);
delete data;
}
else
crt->SendChatMessage(CHAT_MSG_MONSTER_YELL, LANG_UNIVERSAL, args);
sWorld.LogGM(m_session, "Used npc yell command on %s %s", crt->IsPlayer() ? "Player" : "Creature", crt->GetName());
return true;
}
/*this procedure handles clients CMSG_REQUEST_PARTY_MEMBER_STATS request*/
void WorldSession::HandleRequestPartyMemberStatsOpcode( WorldPacket &recv_data )
{
DEBUG_LOG("WORLD: Received CMSG_REQUEST_PARTY_MEMBER_STATS");
uint64 Guid;
recv_data >> Guid;
Player *player = sObjectMgr.GetPlayer(Guid);
if(!player)
{
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 3+4+2);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data.appendPackGUID(Guid);
data << uint32(GROUP_UPDATE_FLAG_STATUS);
data << uint16(MEMBER_STATUS_OFFLINE);
SendPacket(&data);
return;
}
Unit *pet = player->GetCharmOrPet();
WorldPacket data(SMSG_PARTY_MEMBER_STATS_FULL, 4+2+2+2+1+2*6+8+1+8);
data << uint8(0); // only for SMSG_PARTY_MEMBER_STATS_FULL, probably arena/bg related
data << player->GetPackGUID();
uint32 mask1 = 0x00040BFF; // common mask, real flags used 0x000040BFF
if(pet)
mask1 = 0xFFFFFFFF; // for hunters and other classes with pets
Powers powerType = player->getPowerType();
data << uint32(mask1); // group update mask
data << uint16(MEMBER_STATUS_ONLINE); // member's online status
data << uint32(player->GetHealth()); // GROUP_UPDATE_FLAG_CUR_HP
data << uint32(player->GetMaxHealth()); // GROUP_UPDATE_FLAG_MAX_HP
data << uint8(powerType); // GROUP_UPDATE_FLAG_POWER_TYPE
data << uint16(player->GetPower(powerType)); // GROUP_UPDATE_FLAG_CUR_POWER
data << uint16(player->GetMaxPower(powerType)); // GROUP_UPDATE_FLAG_MAX_POWER
data << uint16(player->getLevel()); // GROUP_UPDATE_FLAG_LEVEL
data << uint16(player->GetZoneId()); // GROUP_UPDATE_FLAG_ZONE
data << uint16(player->GetPositionX()); // GROUP_UPDATE_FLAG_POSITION
data << uint16(player->GetPositionY()); // GROUP_UPDATE_FLAG_POSITION
uint64 auramask = 0;
size_t maskPos = data.wpos();
data << uint64(auramask); // placeholder
for(uint8 i = 0; i < MAX_AURAS; ++i)
{
if(uint32 aura = player->GetVisibleAura(i))
{
auramask |= (uint64(1) << i);
data << uint32(aura);
data << uint8(1);
}
}
data.put<uint64>(maskPos, auramask); // GROUP_UPDATE_FLAG_AURAS
if(pet)
{
Powers petpowertype = pet->getPowerType();
data << pet->GetObjectGuid(); // GROUP_UPDATE_FLAG_PET_GUID
data << pet->GetName(); // GROUP_UPDATE_FLAG_PET_NAME
data << uint16(pet->GetDisplayId()); // GROUP_UPDATE_FLAG_PET_MODEL_ID
data << uint32(pet->GetHealth()); // GROUP_UPDATE_FLAG_PET_CUR_HP
data << uint32(pet->GetMaxHealth()); // GROUP_UPDATE_FLAG_PET_MAX_HP
data << uint8(petpowertype); // GROUP_UPDATE_FLAG_PET_POWER_TYPE
data << uint16(pet->GetPower(petpowertype)); // GROUP_UPDATE_FLAG_PET_CUR_POWER
data << uint16(pet->GetMaxPower(petpowertype)); // GROUP_UPDATE_FLAG_PET_MAX_POWER
uint64 petauramask = 0;
size_t petMaskPos = data.wpos();
data << uint64(petauramask); // placeholder
for(uint8 i = 0; i < MAX_AURAS; ++i)
{
if(uint32 petaura = pet->GetVisibleAura(i))
{
petauramask |= (uint64(1) << i);
data << uint32(petaura);
data << uint8(1);
}
}
data.put<uint64>(petMaskPos, petauramask); // GROUP_UPDATE_FLAG_PET_AURAS
data << (uint32) player->m_movementInfo.GetTransportDBCSeat();
}
else
{
data << uint8(0); // GROUP_UPDATE_FLAG_PET_NAME
data << uint64(0); // GROUP_UPDATE_FLAG_PET_AURAS
}
SendPacket(&data);
}
bool ChatHandler::HandleSendOpcodeCommand(const char* args)
{
Unit *unit = getSelectedUnit();
if (!unit || (unit->GetTypeId() != TYPEID_PLAYER))
unit = m_session->GetPlayer();
FILE *file = fopen("opcode.txt", "r");
if(!file)
return false;
uint32 type;
uint32 val1;
uint64 val2;
float val3;
char val4[101];
uint32 opcode = 0;
fscanf(file, "%u", &opcode);
if(!opcode)
{
fclose(file);
return false;
}
WorldPacket data(opcode, 0);
while(fscanf(file, "%u", &type) != EOF)
{
switch(type)
{
case 0: // uint8
fscanf(file, "%u", &val1);
data << uint8(val1);
break;
case 1: // uint16
fscanf(file, "%u", &val1);
data << uint16(val1);
break;
case 2: // uint32
fscanf(file, "%u", &val1);
data << uint32(val1);
break;
case 3: // uint64
fscanf(file, I64FMTD, &val2);
data << uint64(val2);
break;
case 4: // float
fscanf(file, "%f", &val3);
data << float(val3);
break;
case 5: // string
fscanf(file, "%s", val4, 101);
data << val4;
break;
case 6: // packed guid
data.append(unit->GetPackGUID());
break;
default:
fclose(file);
return false;
}
}
fclose(file);
sLog.outDebug("Sending opcode %u", data.GetOpcode());
data.hexlike();
((Player*)unit)->GetSession()->SendPacket(&data);
PSendSysMessage(LANG_COMMAND_OPCODESENT, data.GetOpcode(), unit->GetName());
return true;
}
