CreatureGroup Class Reference

#include "CreatureGroups.h"

Public Types
typedef std::map< Creature *, FormationInfo >	CreatureGroupMemberType

Public Member Functions
	CreatureGroup (uint32 id)
	~CreatureGroup ()
Creature *	GetLeader () const
uint32	GetId () const
bool	IsEmpty () const
bool	IsFormed () const
CreatureGroupMemberType const &	GetMembers () const
void	AddMember (Creature *member)
void	RemoveMember (Creature *member)
void	FormationReset (bool dismiss, bool initMotionMaster)
void	LeaderStartedMoving ()
bool	CanLeaderStartMoving () const
void	RemoveFormationMovement ()
void	MemberEngagingTarget (Creature *member, Unit *target)
Unit *	GetNewTargetForMember (Creature *member)
void	MemberEvaded (Creature *member)
void	RespawnRemovedMembers (Map *map)
void	DespawnFormation (Milliseconds timeToDespawn=0ms, Seconds forcedRespawnTimer=0s)
void	RespawnFormation (bool force=false)
bool	IsFormationInCombat ()
bool	IsAnyMemberAlive (bool ignoreLeader=false)

Private Attributes
Creature *	m_leader
CreatureGroupMemberType	m_members
uint32	m_groupID
bool	m_Formed

Detailed Description

Member Typedef Documentation

CreatureGroupMemberType

typedef std::map<Creature*, FormationInfo> CreatureGroup::CreatureGroupMemberType

Constructor & Destructor Documentation

CreatureGroup()

CreatureGroup::CreatureGroup ( uint32  id )

inlineexplicit

: m_leader(nullptr), m_groupID(id), m_Formed(false) {}

~CreatureGroup()

CreatureGroup::~CreatureGroup ( )

inline

{}

Member Function Documentation

AddMember()

void CreatureGroup::AddMember

(

Creature *

member

)

{
    LOG_DEBUG("entities.unit", "CreatureGroup::AddMember: Adding unit {}.", member->GetGUID().ToString());
 
    //Check if it is a leader
    if (member->GetSpawnId() == m_groupID)
    {
        LOG_DEBUG("entities.unit", "Unit {} is formation leader. Adding group.", member->GetGUID().ToString());
        m_leader = member;
    }
 
    m_members[member] = sFormationMgr->CreatureGroupMap.find(member->GetSpawnId())->second;
    member->SetFormation(this);
}

References Object::GetGUID(), Creature::GetSpawnId(), LOG_DEBUG, m_groupID, m_leader, m_members, Creature::SetFormation(), sFormationMgr, and ObjectGuid::ToString().

Referenced by FormationMgr::AddCreatureToGroup().

CanLeaderStartMoving()

bool CreatureGroup::CanLeaderStartMoving

(

)

const

{
    for (auto const& itr : m_members)
    {
        if (itr.first && itr.first != m_leader && itr.first->IsAlive())
            if (itr.first->IsEngaged() || itr.first->IsInEvadeMode())
                return false;
    }
 
    return true;
}

References Unit::IsAlive(), m_leader, and m_members.

Referenced by RandomMovementGenerator< T >::_setRandomLocation(), and Creature::IsFormationLeaderMoveAllowed().

DespawnFormation()

void CreatureGroup::DespawnFormation	(	Milliseconds	timeToDespawn = 0ms,
		Seconds	forcedRespawnTimer = 0s
	)

{
    // Copy the member list first: DespawnOrUnsummon() takes the member out of
    // the world, which erases it from m_members and would invalidate this loop.
    CreatureGroupMemberType members = m_members;
 
    for (auto const& itr : members)
    {
        if (itr.first && itr.first->GetFormation() == this)
            itr.first->DespawnOrUnsummon(timeToDespawn, forcedRespawnTimer);
    }
}

References m_members.

FormationReset()

void CreatureGroup::FormationReset	(	bool	dismiss,
		bool	initMotionMaster
	)

{
    if (m_members.size() && !(m_members.begin()->second.HasGroupFlag(std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_FOLLOW_LEADER))))
        return;
 
    for (auto const& itr : m_members)
    {
        Creature* member = itr.first;
        if (member && member != m_leader && member->IsAlive())
        {
            if (initMotionMaster)
            {
                if (dismiss)
                    member->GetMotionMaster()->MovementExpiredOnSlot(MOTION_SLOT_IDLE, false);
                else
                    member->GetMotionMaster()->MoveIdle();
 
                LOG_DEBUG("entities.unit", "Set {} movement for member {}", dismiss ? "default" : "idle", member->GetGUID().ToString());
            }
        }
    }
    m_Formed = !dismiss;
}

References Object::GetGUID(), Unit::GetMotionMaster(), GROUP_AI_FLAG_FOLLOW_LEADER, Unit::IsAlive(), LOG_DEBUG, m_Formed, m_leader, m_members, MOTION_SLOT_IDLE, MotionMaster::MoveIdle(), MotionMaster::MovementExpiredOnSlot(), and ObjectGuid::ToString().

Referenced by Creature::Motion_Initialize(), and Creature::setDeathState().

GetId()

uint32 CreatureGroup::GetId ( ) const

inline

{ return m_groupID; }

References m_groupID.

Referenced by npc_commandscript::HandleNpcAddFormationCommand(), and FormationMgr::RemoveCreatureFromGroup().

GetLeader()

Creature * CreatureGroup::GetLeader ( ) const

inline

{ return m_leader; }

References m_leader.

Referenced by RandomMovementGenerator< T >::_setRandomLocation(), Creature::IsFormationLeader(), Creature::IsUpdateNeeded(), Creature::Motion_Initialize(), instance_azjol_nerub::instance_azjol_nerub_InstanceScript::OnUnitDeath(), Creature::setDeathState(), and Creature::SignalFormationMovement().

GetMembers()

CreatureGroupMemberType const & CreatureGroup::GetMembers ( ) const

inline

{ return m_members; }

References m_members.

GetNewTargetForMember()

Unit * CreatureGroup::GetNewTargetForMember

(

Creature *

member

)

{
    uint8 const groupAI = sFormationMgr->CreatureGroupMap[member->GetSpawnId()].groupAI;
    if (!(groupAI & std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_ACQUIRE_NEW_TARGET_ON_EVADE)))
    {
        return nullptr;
    }
 
    if (member == m_leader)
    {
        if (!(groupAI & std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_MEMBER_ASSIST_LEADER)))
        {
            return nullptr;
        }
    }
    else if (!(groupAI & std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_LEADER_ASSIST_MEMBER)))
    {
        return nullptr;
    }
 
    for (auto const& itr : m_members)
    {
        Creature* pMember = itr.first;
        if (!pMember)
        {
            continue;
        }
 
        if (pMember == member || !pMember->IsAlive() || !pMember->GetVictim())
        {
            continue;
        }
 
        if (pMember == m_leader && !(groupAI & std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_MEMBER_ASSIST_LEADER)))
        {
            continue;
        }
 
        if (member->IsValidAttackTarget(pMember->GetVictim()))
        {
            return pMember->GetVictim();
        }
    }
 
    return nullptr;
}

References Creature::GetSpawnId(), Unit::GetVictim(), GROUP_AI_FLAG_ACQUIRE_NEW_TARGET_ON_EVADE, GROUP_AI_FLAG_LEADER_ASSIST_MEMBER, GROUP_AI_FLAG_MEMBER_ASSIST_LEADER, Unit::IsAlive(), Unit::IsValidAttackTarget(), m_leader, m_members, and sFormationMgr.

IsAnyMemberAlive()

bool CreatureGroup::IsAnyMemberAlive

(

bool

ignoreLeader = false

)

{
    for (auto const& itr : m_members)
    {
        if (itr.first && itr.first->IsAlive())
        {
            if (!ignoreLeader || itr.first != m_leader)
            {
                return true;
            }
        }
    }
 
    return false;
}

References m_leader, and m_members.

Referenced by instance_azjol_nerub::instance_azjol_nerub_InstanceScript::OnUnitDeath().

IsEmpty()

bool CreatureGroup::IsEmpty ( ) const

inline

{ return m_members.empty(); }

References m_members.

Referenced by FormationMgr::RemoveCreatureFromGroup().

IsFormationInCombat()

bool CreatureGroup::IsFormationInCombat

(

)

{
    for (auto const& itr : m_members)
    {
        if (itr.first && itr.first->IsInCombat())
        {
            return true;
        }
    }
 
    return false;
}

References m_members.

IsFormed()

bool CreatureGroup::IsFormed ( ) const

inline

{ return m_Formed; }

References m_Formed.

Referenced by Creature::Motion_Initialize(), and npc_cameron::UpdateAI().

LeaderStartedMoving()

void CreatureGroup::LeaderStartedMoving

(

)

{
    if (!m_leader)
        return;
 
    for (auto const& itr : m_members)
    {
        Creature* member = itr.first;
        FormationInfo const& pFormationInfo = itr.second;
        if (member == m_leader || !member->IsAlive() || member->GetVictim() || !pFormationInfo.HasGroupFlag(std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_FOLLOW_LEADER)))
            continue;
 
        if (member->HasUnitState(UNIT_STATE_NOT_MOVE) || member->isPossessed() || member->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED))
            continue;
 
        float const followAngle = pFormationInfo.follow_angle;
        float const followDist = pFormationInfo.follow_dist;
 
        if (!member->HasUnitState(UNIT_STATE_FOLLOW_MOVE))
            member->GetMotionMaster()->MoveFormation(m_leader, followDist, followAngle, pFormationInfo.point_1, pFormationInfo.point_2);
    }
}

References FormationInfo::follow_angle, FormationInfo::follow_dist, Unit::GetMotionMaster(), Unit::GetVictim(), GROUP_AI_FLAG_FOLLOW_LEADER, FormationInfo::HasGroupFlag(), Unit::HasUnitFlag(), Unit::HasUnitState(), Unit::IsAlive(), Unit::isPossessed(), m_leader, m_members, MotionMaster::MoveFormation(), FormationInfo::point_1, FormationInfo::point_2, UNIT_FLAG_PLAYER_CONTROLLED, UNIT_STATE_FOLLOW_MOVE, and UNIT_STATE_NOT_MOVE.

Referenced by RandomMovementGenerator< T >::_setRandomLocation(), Creature::Motion_Initialize(), and Creature::SignalFormationMovement().

MemberEngagingTarget()

void CreatureGroup::MemberEngagingTarget	(	Creature *	member,
		Unit *	target
	)

{
    uint8 const groupAI = sFormationMgr->CreatureGroupMap[member->GetSpawnId()].groupAI;
    if (member == m_leader)
    {
        if (!(groupAI & std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_MEMBER_ASSIST_LEADER)))
        {
            return;
        }
    }
    else if (!(groupAI & std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_LEADER_ASSIST_MEMBER)))
    {
        return;
    }
 
    for (auto const& itr : m_members)
    {
        Creature* pMember = itr.first;
        if (!pMember)
        {
            continue;
        }
 
        if (pMember == member || !pMember->IsAlive() || pMember->GetVictim())
        {
            continue;
        }
 
        if (pMember == m_leader && !(groupAI & std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_LEADER_ASSIST_MEMBER)))
        {
            continue;
        }
 
        if (pMember->IsValidAttackTarget(target))
        {
            pMember->EngageWithTarget(target);
        }
    }
}

References Unit::EngageWithTarget(), Creature::GetSpawnId(), Unit::GetVictim(), GROUP_AI_FLAG_LEADER_ASSIST_MEMBER, GROUP_AI_FLAG_MEMBER_ASSIST_LEADER, Unit::IsAlive(), Unit::IsValidAttackTarget(), m_leader, m_members, and sFormationMgr.

MemberEvaded()

void CreatureGroup::MemberEvaded

(

Creature *

member

)

{
    uint8 const groupAI = sFormationMgr->CreatureGroupMap[member->GetSpawnId()].groupAI;
    if (!(groupAI & std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_EVADE_MASK)))
    {
        return;
    }
 
    // Copy the member list first: Respawn() below takes the member out of the
    // world, which erases it from m_members and would invalidate this loop.
    CreatureGroupMemberType members = m_members;
 
    for (auto const& itr : members)
    {
        Creature* pMember = itr.first;
        // This should never happen
        if (!pMember)
            continue;
 
        // A previous member's Respawn() or EnterEvadeMode() may have removed
        // this one from the group already.
        if (pMember->GetFormation() != this)
            continue;
 
        if (pMember == member || pMember->IsInEvadeMode() || !itr.second.HasGroupFlag(std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_EVADE_MASK)))
            continue;
 
        // EVADE_TOGETHER and RESPAWN_ON_EVADE are independent: living members evade, dead members respawn.
        if (pMember->IsAlive())
        {
            if (!itr.second.HasGroupFlag(
                    std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_EVADE_TOGETHER)))
                continue;
 
            if (!pMember->IsInCombat())
                continue;
 
            if (pMember->IsAIEnabled)
                if (CreatureAI* pMemberAI = pMember->AI())
                    pMemberAI->EnterEvadeMode();
        }
        else
        {
            if (!itr.second.HasGroupFlag(
                    std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_RESPAWN_ON_EVADE)))
                continue;
 
            if (itr.second.HasGroupFlag(std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_DONT_RESPAWN_LEADER_ON_EVADE)) && pMember == m_leader)
                continue;
 
            pMember->Respawn();
        }
    }
 
    RespawnRemovedMembers(member->GetMap());
}

References Creature::AI(), Creature::GetFormation(), WorldObject::GetMap(), Creature::GetSpawnId(), GROUP_AI_FLAG_DONT_RESPAWN_LEADER_ON_EVADE, GROUP_AI_FLAG_EVADE_MASK, GROUP_AI_FLAG_EVADE_TOGETHER, GROUP_AI_FLAG_RESPAWN_ON_EVADE, Unit::IsAIEnabled, Unit::IsAlive(), Unit::IsInCombat(), Creature::IsInEvadeMode(), m_leader, m_members, Creature::Respawn(), RespawnRemovedMembers(), and sFormationMgr.

RemoveFormationMovement()

void CreatureGroup::RemoveFormationMovement

(

)

{
    for (auto const& itr : m_members)
    {
        Creature* member = itr.first;
        if (!member || member == m_leader)
            continue;
 
        if (member->GetMotionMaster()->GetMotionSlotType(MOTION_SLOT_IDLE) == FORMATION_MOTION_TYPE)
            member->GetMotionMaster()->MovementExpiredOnSlot(MOTION_SLOT_IDLE, false);
    }
}

References FORMATION_MOTION_TYPE, Unit::GetMotionMaster(), MotionMaster::GetMotionSlotType(), m_leader, m_members, MOTION_SLOT_IDLE, and MotionMaster::MovementExpiredOnSlot().

Referenced by RemoveMember().

RemoveMember()

void CreatureGroup::RemoveMember

(

Creature *

member

)

{
    if (m_leader == member)
    {
        RemoveFormationMovement();
        m_leader = nullptr;
    }
 
    m_members.erase(member);
    member->SetFormation(nullptr);
}

References m_leader, m_members, RemoveFormationMovement(), and Creature::SetFormation().

Referenced by FormationMgr::RemoveCreatureFromGroup().

RespawnFormation()

void CreatureGroup::RespawnFormation

(

bool

force = false

)

{
    // Copy the member list first: Respawn() takes the member out of the world,
    // which erases it from m_members and would invalidate this loop.
    CreatureGroupMemberType members = m_members;
 
    for (auto const& itr : members)
    {
        if (itr.first && itr.first->GetFormation() == this && !itr.first->IsAlive())
        {
            itr.first->Respawn(force);
        }
    }
}

References m_members.

Referenced by boss_krik_thir::boss_krik_thirAI::Reset().

RespawnRemovedMembers()

void CreatureGroup::RespawnRemovedMembers

(

Map *

map

)

{
    auto const membersItr = sFormationMgr->CreatureGroupMembers.find(m_groupID);
    if (membersItr == sFormationMgr->CreatureGroupMembers.end())
        return;
 
    time_t now = GameTime::GetGameTime().count();
    for (ObjectGuid::LowType spawnId : membersItr->second)
    {
        bool const inWorld = std::any_of(m_members.begin(), m_members.end(), [spawnId](auto const& itr)
        {
            return itr.first->GetSpawnId() == spawnId;
        });
        if (inWorld)
            continue;
 
        auto const infoItr = sFormationMgr->CreatureGroupMap.find(spawnId);
        if (infoItr == sFormationMgr->CreatureGroupMap.end())
            continue;
 
        FormationInfo const& info = infoItr->second;
        if (!info.HasGroupFlag(std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_RESPAWN_ON_EVADE)))
            continue;
 
        if (spawnId == m_groupID && info.HasGroupFlag(
                std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_DONT_RESPAWN_LEADER_ON_EVADE)))
            continue;
 
        // Only creatures with a respawn still pending on this map: one without a stored time (alive, never loaded)
        // is left alone, one already due (evade cascade of the same tick) is left to ProcessRespawns().
        if (map->GetCreatureRespawnTime(spawnId) <= now)
            continue;
 
        map->SaveCreatureRespawnTime(spawnId, now);
    }
}

References Map::GetCreatureRespawnTime(), GameTime::GetGameTime(), GROUP_AI_FLAG_DONT_RESPAWN_LEADER_ON_EVADE, GROUP_AI_FLAG_RESPAWN_ON_EVADE, FormationInfo::HasGroupFlag(), m_groupID, m_members, Map::SaveCreatureRespawnTime(), and sFormationMgr.

Referenced by MemberEvaded().

Member Data Documentation

m_Formed

bool CreatureGroup::m_Formed

private

Referenced by FormationReset(), and IsFormed().

m_groupID

uint32 CreatureGroup::m_groupID

private

Referenced by AddMember(), GetId(), and RespawnRemovedMembers().

m_leader

Creature* CreatureGroup::m_leader

private

Referenced by AddMember(), CanLeaderStartMoving(), FormationReset(), GetLeader(), GetNewTargetForMember(), IsAnyMemberAlive(), LeaderStartedMoving(), MemberEngagingTarget(), MemberEvaded(), RemoveFormationMovement(), and RemoveMember().

m_members

CreatureGroupMemberType CreatureGroup::m_members

private

Referenced by AddMember(), CanLeaderStartMoving(), DespawnFormation(), FormationReset(), GetMembers(), GetNewTargetForMember(), IsAnyMemberAlive(), IsEmpty(), IsFormationInCombat(), LeaderStartedMoving(), MemberEngagingTarget(), MemberEvaded(), RemoveFormationMovement(), RemoveMember(), RespawnFormation(), and RespawnRemovedMembers().

---

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

• azerothcore-wotlk/src/server/game/Entities/Creature/CreatureGroups.h
• azerothcore-wotlk/src/server/game/Entities/Creature/CreatureGroups.cpp