#include <OutdoorPvPTF.h>

Public Member Functions
	OutdoorPvPTF ()

bool	SetupOutdoorPvP () override

void	HandlePlayerEnterZone (Player *player, uint32 zone) override

void	HandlePlayerLeaveZone (Player *player, uint32 zone) override

bool	Update (uint32 diff) override

void	FillInitialWorldStates (WorldPackets::WorldState::InitWorldStates &packet) override

void	SendRemoveWorldStates (Player *player) override

uint32	GetAllianceTowersControlled () const

void	SetAllianceTowersControlled (uint32 count)

uint32	GetHordeTowersControlled () const

void	SetHordeTowersControlled (uint32 count)

bool	IsLocked () const

Public Member Functions inherited from OutdoorPvP
	OutdoorPvP ()

virtual	~OutdoorPvP ()

void	DeleteSpawns ()

virtual bool	HandleAreaTrigger (Player *, uint32, bool)

virtual bool	HandleCustomSpell (Player player, uint32 spellId, GameObject go)

virtual bool	HandleOpenGo (Player player, GameObject go)

void	OnGameObjectCreate (GameObject *go) override

void	OnGameObjectRemove (GameObject *go) override

void	OnCreatureCreate (Creature *) override

void	SendUpdateWorldState (uint32 field, uint32 value)

virtual void	HandleKill (Player killer, Unit killed)

virtual void	HandleKillImpl (Player , Unit )

bool	IsInsideObjective (Player *player) const

virtual void	AwardKillBonus (Player *)

uint32	GetTypeId () const

virtual bool	HandleDropFlag (Player *player, uint32 spellId)

virtual bool	HandleGossipOption (Player player, Creature creature, uint32 gossipid)

virtual bool	CanTalkTo (Player player, Creature c, GossipMenuItems const &gso)

void	TeamApplyBuff (TeamId team, uint32 spellId, uint32 spellId2=0)

void	SendDefenseMessage (uint32 zoneId, uint32 id)

Map *	GetMap () const

Public Member Functions inherited from ZoneScript
	ZoneScript ()

virtual	~ZoneScript ()

virtual uint32	GetCreatureEntry (ObjectGuid::LowType, CreatureData const *data)

virtual uint32	GetGameObjectEntry (ObjectGuid::LowType, uint32 entry)

virtual void	OnCreatureRemove (Creature *)

virtual void	OnUnitDeath (Unit *)

virtual ObjectGuid	GetGuidData (uint32) const

virtual void	SetGuidData (uint32, ObjectGuid)

virtual uint64	GetData64 (uint32) const

virtual void	SetData64 (uint32, uint64)

virtual uint32	GetData (uint32) const

virtual void	SetData (uint32, uint32)

virtual void	ProcessEvent (WorldObject *, uint32)

Private Attributes
bool	m_IsLocked

uint32	m_LockTimer

uint32	m_LockTimerUpdate

uint32	m_AllianceTowersControlled

uint32	m_HordeTowersControlled

uint32	hours_left

uint32	second_digit

uint32	first_digit

Additional Inherited Members
Public Types inherited from OutdoorPvP
typedef std::map < ObjectGuid::LowType, OPvPCapturePoint * >	OPvPCapturePointMap

Static Public Member Functions inherited from OutdoorPvP
static TeamId	GetTeamIdByTeam (uint32 team)

Protected Member Functions inherited from OutdoorPvP
void	BroadcastPacket (WorldPacket const *data) const

virtual void	HandlePlayerResurrects (Player *player, uint32 zone)

void	AddCapturePoint (OPvPCapturePoint *cp)

OPvPCapturePoint *	GetCapturePoint (ObjectGuid::LowType guid) const

void	RegisterZone (uint32 zoneid)

bool	HasPlayer (Player const *player) const

void	TeamCastSpell (TeamId team, int32 spellId)

template<class Worker >
void	BroadcastWorker (Worker &_worker, uint32 zoneId)

void	SetMapFromZone (uint32 zone)

Protected Attributes inherited from OutdoorPvP
OPvPCapturePointMap	m_capturePoints

GuidSet	m_players [2]

uint32	m_TypeId

bool	m_sendUpdate

Map *	m_map

Constructor & Destructor Documentation

OutdoorPvPTF::OutdoorPvPTF ( )

 {
  m_TypeId = OUTDOOR_PVP_TF;
 
  m_IsLocked = false;
  m_LockTimer = TF_LOCK_TIME;
  m_LockTimerUpdate = 0;
 
  m_AllianceTowersControlled = 0;
  m_HordeTowersControlled = 0;
 
  hours_left = 6;
  second_digit = 0;
  first_digit = 0;
 }

Member Function Documentation

void OutdoorPvPTF::FillInitialWorldStates ( WorldPackets::WorldState::InitWorldStates & packet )

overridevirtual

Reimplemented from OutdoorPvP.

 {
  packet.Worldstates.emplace_back(uint32(TF_UI_TOWER_COUNT_H), int32(m_HordeTowersControlled));
  packet.Worldstates.emplace_back(uint32(TF_UI_TOWER_COUNT_A), int32(m_AllianceTowersControlled));
  packet.Worldstates.emplace_back(uint32(TF_UI_TOWERS_CONTROLLED_DISPLAY), int32(!m_IsLocked));
  packet.Worldstates.emplace_back(uint32(TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT), int32(first_digit));
  packet.Worldstates.emplace_back(uint32(TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT), int32(second_digit));
  packet.Worldstates.emplace_back(uint32(TF_UI_LOCKED_TIME_HOURS), int32(hours_left));
 
  packet.Worldstates.emplace_back(uint32(TF_UI_LOCKED_DISPLAY_NEUTRAL), int32(m_IsLocked && !m_HordeTowersControlled && !m_AllianceTowersControlled));
  packet.Worldstates.emplace_back(uint32(TF_UI_LOCKED_DISPLAY_HORDE), int32(m_IsLocked && (m_HordeTowersControlled > m_AllianceTowersControlled)));
  packet.Worldstates.emplace_back(uint32(TF_UI_LOCKED_DISPLAY_ALLIANCE), int32(m_IsLocked && (m_HordeTowersControlled < m_AllianceTowersControlled)));
 
  for (OPvPCapturePointMap::iterator itr = m_capturePoints.begin(); itr != m_capturePoints.end(); ++itr)
  itr->second->FillInitialWorldStates(packet);
 }

uint32 OutdoorPvPTF::GetAllianceTowersControlled ( ) const

 {
  return m_AllianceTowersControlled;
 }

uint32 OutdoorPvPTF::GetHordeTowersControlled ( ) const

 {
  return m_HordeTowersControlled;
 }

void OutdoorPvPTF::HandlePlayerEnterZone	(	Player *	player,
		uint32	zone
	)

overridevirtual

Reimplemented from OutdoorPvP.

 {
  if (player->GetTeam() == ALLIANCE)
  {
  if (m_AllianceTowersControlled >= TF_TOWER_NUM)
  player->CastSpell(player, TF_CAPTURE_BUFF, true);
  }
  else
  {
  if (m_HordeTowersControlled >= TF_TOWER_NUM)
  player->CastSpell(player, TF_CAPTURE_BUFF, true);
  }
  OutdoorPvP::HandlePlayerEnterZone(player, zone);
 }

Here is the call graph for this function:

void OutdoorPvPTF::HandlePlayerLeaveZone	(	Player *	player,
		uint32	zone
	)

overridevirtual

Reimplemented from OutdoorPvP.

 {
  // remove buffs
  player->RemoveAurasDueToSpell(TF_CAPTURE_BUFF);
  OutdoorPvP::HandlePlayerLeaveZone(player, zone);
 }

Here is the call graph for this function:

bool OutdoorPvPTF::IsLocked ( ) const

 {
  return m_IsLocked;
 }

void OutdoorPvPTF::SendRemoveWorldStates ( Player * player )

overridevirtual

Reimplemented from OutdoorPvP.

 {
  player->SendUpdateWorldState(TF_UI_TOWER_COUNT_H, uint32(0));
  player->SendUpdateWorldState(TF_UI_TOWER_COUNT_A, uint32(0));
  player->SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(0));
 
  player->SendUpdateWorldState(TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT, uint32(0));
  player->SendUpdateWorldState(TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT, uint32(0));
  player->SendUpdateWorldState(TF_UI_LOCKED_TIME_HOURS, uint32(0));
 
  player->SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
  player->SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE, uint32(0));
  player->SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(0));
 
  for (int i = 0; i < TF_TOWER_NUM; ++i)
  {
  player->SendUpdateWorldState(uint32(TFTowerWorldStates[i].n), uint32(0));
  player->SendUpdateWorldState(uint32(TFTowerWorldStates[i].h), uint32(0));
  player->SendUpdateWorldState(uint32(TFTowerWorldStates[i].a), uint32(0));
  }
 }

void OutdoorPvPTF::SetAllianceTowersControlled ( uint32 count )

 {
  m_AllianceTowersControlled = count;
 }

void OutdoorPvPTF::SetHordeTowersControlled ( uint32 count )

 {
  m_HordeTowersControlled = count;
 }

bool OutdoorPvPTF::SetupOutdoorPvP ( )

overridevirtual

Reimplemented from OutdoorPvP.

 {
  m_AllianceTowersControlled = 0;
  m_HordeTowersControlled = 0;
 
  m_IsLocked = false;
  m_LockTimer = TF_LOCK_TIME;
  m_LockTimerUpdate = 0;
  hours_left = 6;
  second_digit = 0;
  first_digit = 0;
 
  SetMapFromZone(OutdoorPvPTFBuffZones[0]);
 
  // add the zones affected by the pvp buff
  for (uint8 i = 0; i < OutdoorPvPTFBuffZonesNum; ++i)
  RegisterZone(OutdoorPvPTFBuffZones[i]);
 
  AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_NW));
  AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_N));
  AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_NE));
  AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_SE));
  AddCapturePoint(new OPvPCapturePointTF(this, TF_TOWER_S));
 
  return true;
 }

Here is the call graph for this function:

bool OutdoorPvPTF::Update ( uint32 diff )

overridevirtual

Reimplemented from OutdoorPvP.

 {
  bool changed = OutdoorPvP::Update(diff);
 
  if (changed)
  {
  if (m_AllianceTowersControlled == TF_TOWER_NUM)
  {
  TeamApplyBuff(TEAM_ALLIANCE, TF_CAPTURE_BUFF);
  m_IsLocked = true;
  SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
  SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE, uint32(0));
  SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(1));
  SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(0));
  }
  else if (m_HordeTowersControlled == TF_TOWER_NUM)
  {
  TeamApplyBuff(TEAM_HORDE, TF_CAPTURE_BUFF);
  m_IsLocked = true;
  SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
  SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE, uint32(1));
  SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(0));
  SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(0));
  }
  else
  {
  TeamCastSpell(TEAM_ALLIANCE, -TF_CAPTURE_BUFF);
  TeamCastSpell(TEAM_HORDE, -TF_CAPTURE_BUFF);
  }
  SendUpdateWorldState(TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
  SendUpdateWorldState(TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
  }
  if (m_IsLocked)
  {
  // lock timer is down, release lock
  if (m_LockTimer < diff)
  {
  m_LockTimer = TF_LOCK_TIME;
  m_LockTimerUpdate = 0;
  m_IsLocked = false;
  SendUpdateWorldState(TF_UI_TOWERS_CONTROLLED_DISPLAY, uint32(1));
  SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_NEUTRAL, uint32(0));
  SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_HORDE, uint32(0));
  SendUpdateWorldState(TF_UI_LOCKED_DISPLAY_ALLIANCE, uint32(0));
  }
  else
  {
  // worldstateui update timer is down, update ui with new time data
  if (m_LockTimerUpdate < diff)
  {
  m_LockTimerUpdate = TF_LOCK_TIME_UPDATE;
  uint32 minutes_left = m_LockTimer / 60000;
  hours_left = minutes_left / 60;
  minutes_left -= hours_left * 60;
  second_digit = minutes_left % 10;
  first_digit = minutes_left / 10;
 
  SendUpdateWorldState(TF_UI_LOCKED_TIME_MINUTES_FIRST_DIGIT, first_digit);
  SendUpdateWorldState(TF_UI_LOCKED_TIME_MINUTES_SECOND_DIGIT, second_digit);
  SendUpdateWorldState(TF_UI_LOCKED_TIME_HOURS, hours_left);
  } else m_LockTimerUpdate -= diff;
  m_LockTimer -= diff;
  }
  }
  return changed;
 }

Here is the call graph for this function:

Member Data Documentation

uint32 OutdoorPvPTF::first_digit

private

uint32 OutdoorPvPTF::hours_left

private

uint32 OutdoorPvPTF::m_AllianceTowersControlled

private

uint32 OutdoorPvPTF::m_HordeTowersControlled

private

bool OutdoorPvPTF::m_IsLocked

private

uint32 OutdoorPvPTF::m_LockTimer

private

uint32 OutdoorPvPTF::m_LockTimerUpdate

private

uint32 OutdoorPvPTF::second_digit

private

The documentation for this class was generated from the following files:

src/server/scripts/OutdoorPvP/OutdoorPvPTF.h
src/server/scripts/OutdoorPvP/OutdoorPvPTF.cpp

Public Member Functions

Private Attributes

Additional Inherited Members

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation