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
const CreatureGroupMemberType &	GetMembers () const
void	AddMember (Creature *member)
void	RemoveMember (Creature *member)
void	FormationReset (bool dismiss, bool initMotionMaster)
void	LeaderMoveTo (float x, float y, float z, uint32 move_type)
void	MemberEngagingTarget (Creature *member, Unit *target)
Unit *	GetNewTargetForMember (Creature *member)
void	MemberEvaded (Creature *member)
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().

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()->Initialize();
                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, MotionMaster::Initialize(), Unit::IsAlive(), LOG_DEBUG, m_Formed, m_leader, m_members, MotionMaster::MoveIdle(), 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::IsUpdateNeeded(), Creature::Motion_Initialize(), Creature::setDeathState(), and WaypointMovementGenerator< Creature >::StartMove().

GetMembers()

const CreatureGroupMemberType & 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.

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().

LeaderMoveTo()

void CreatureGroup::LeaderMoveTo	(	float	x,
		float	y,
		float	z,
		uint32	move_type
	)

To do: This should probably get its own movement generator or use WaypointMovementGenerator. If the leader's path is known, member's path can be plotted as well using formation offsets.

{
    if (!m_leader)
        return;
 
    float pathDist = m_leader->GetExactDist(x, y, z);
    float pathAngle = std::atan2(m_leader->GetPositionY() - y, m_leader->GetPositionX() - x);
 
    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 is stunned / rooted etc don't allow to move him
        // Or if charmed/controlled
        if (member->HasUnitState(UNIT_STATE_NOT_MOVE) || member->isPossessed() || member->HasUnitFlag(UNIT_FLAG_PLAYER_CONTROLLED))
            continue;
 
        // Xinef: this should be automatized, if turn angle is greater than PI/2 (90�) we should swap formation angle
        float followAngle = pFormationInfo.follow_angle;
        if (static_cast<float>(M_PI) - std::fabs(std::fabs(m_leader->GetOrientation() - pathAngle) - static_cast<float>(M_PI)) > static_cast<float>(M_PI)* 0.5f)
        {
            // pussywizard: in both cases should be 2*M_PI - follow_angle
            // pussywizard: also, GetCurrentWaypointID() returns 0..n-1, while point_1 must be > 0, so +1
            // pussywizard: db table waypoint_data shouldn't have point id 0 and shouldn't have any gaps for this to work!
            // if (m_leader->GetCurrentWaypointID()+1 == pFormationInfo->point_1 || m_leader->GetCurrentWaypointID()+1 == itr->second->point_2)
            followAngle = Position::NormalizeOrientation(pFormationInfo.follow_angle + static_cast<float>(M_PI)); //(2 * M_PI) - itr->second->follow_angle;
        }
 
        float const followDist = pFormationInfo.follow_dist;
 
        float dx = x + std::cos(followAngle + pathAngle) * followDist;
        float dy = y + std::sin(followAngle + pathAngle) * followDist;
        float dz = z;
 
        Acore::NormalizeMapCoord(dx);
        Acore::NormalizeMapCoord(dy);
        if (move_type < 2)
            member->UpdateGroundPositionZ(dx, dy, dz);
 
        // pussywizard: setting the same movementflags is not enough, spline decides whether leader walks/runs, so spline param is now passed as "run" parameter to this function
        member->SetUnitMovementFlags(m_leader->GetUnitMovementFlags());
        switch (move_type)
        {
        case WAYPOINT_MOVE_TYPE_WALK:
            member->AddUnitMovementFlag(MOVEMENTFLAG_WALKING);
            break;
        case WAYPOINT_MOVE_TYPE_RUN:
            member->RemoveUnitMovementFlag(MOVEMENTFLAG_WALKING);
            break;
        case WAYPOINT_MOVE_TYPE_LAND:
            member->AddUnitMovementFlag(MOVEMENTFLAG_DISABLE_GRAVITY);
            break;
        }
 
        // xinef: if we move members to position without taking care of sizes, we should compare distance without sizes
        // xinef: change members speed basing on distance - if too far speed up, if too close slow down
        UnitMoveType const mtype = Movement::SelectSpeedType(member->GetUnitMovementFlags());
        float const speedRate = m_leader->GetSpeedRate(mtype) * member->GetExactDist(dx, dy, dz) / pathDist;
 
        if (speedRate > 0.01f) // don't move if speed rate is too low
        {
            member->SetSpeedRate(mtype, speedRate);
            member->GetMotionMaster()->MovePoint(0, dx, dy, dz);
            member->SetHomePosition(dx, dy, dz, pathAngle);
        }
    }
}

References Unit::AddUnitMovementFlag(), FormationInfo::follow_angle, FormationInfo::follow_dist, Position::GetExactDist(), Unit::GetMotionMaster(), Position::GetOrientation(), Position::GetPositionX(), Position::GetPositionY(), Unit::GetSpeedRate(), Unit::GetUnitMovementFlags(), Unit::GetVictim(), GROUP_AI_FLAG_FOLLOW_LEADER, FormationInfo::HasGroupFlag(), Unit::HasUnitFlag(), Unit::HasUnitState(), Unit::IsAlive(), Unit::isPossessed(), m_leader, m_members, MOVEMENTFLAG_DISABLE_GRAVITY, MOVEMENTFLAG_WALKING, MotionMaster::MovePoint(), Acore::NormalizeMapCoord(), Position::NormalizeOrientation(), Unit::RemoveUnitMovementFlag(), Movement::SelectSpeedType(), Creature::SetHomePosition(), Unit::SetSpeedRate(), Unit::SetUnitMovementFlags(), UNIT_FLAG_PLAYER_CONTROLLED, UNIT_STATE_NOT_MOVE, WorldObject::UpdateGroundPositionZ(), WAYPOINT_MOVE_TYPE_LAND, WAYPOINT_MOVE_TYPE_RUN, and WAYPOINT_MOVE_TYPE_WALK.

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

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->AI())
        {
            pMember->AI()->AttackStart(target);
        }
    }
}

References Creature::AI(), UnitAI::AttackStart(), 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;
    }
 
    for (auto const& itr : m_members)
    {
        Creature* pMember = itr.first;
        // This should never happen
        if (!pMember)
            continue;
 
        if (pMember == member || pMember->IsInEvadeMode() || !itr.second.HasGroupFlag(std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_EVADE_MASK)))
            continue;
 
        if (itr.second.HasGroupFlag(std::underlying_type_t<GroupAIFlags>(GroupAIFlags::GROUP_AI_FLAG_EVADE_TOGETHER)))
        {
            if (!pMember->IsAlive() || !pMember->IsInCombat())
                continue;
 
            if (pMember->IsAIEnabled)
                if (CreatureAI* pMemberAI = pMember->AI())
                    pMemberAI->EnterEvadeMode();
        }
        else
        {
            if (pMember->IsAlive())
                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();
        }
    }
}

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

RemoveMember()

void CreatureGroup::RemoveMember

(

Creature *

member

)

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

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

Referenced by FormationMgr::RemoveCreatureFromGroup().

RespawnFormation()

void CreatureGroup::RespawnFormation

(

bool

force = false

)

{
    for (auto const& itr : m_members)
    {
        if (itr.first && !itr.first->IsAlive())
        {
            itr.first->Respawn(force);
        }
    }
}

References m_members.

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(), and GetId().

m_leader

Creature* CreatureGroup::m_leader

private

Referenced by AddMember(), FormationReset(), GetLeader(), GetNewTargetForMember(), IsAnyMemberAlive(), LeaderMoveTo(), MemberEngagingTarget(), MemberEvaded(), and RemoveMember().

m_members

CreatureGroupMemberType CreatureGroup::m_members

private

Referenced by AddMember(), FormationReset(), GetMembers(), GetNewTargetForMember(), IsAnyMemberAlive(), IsEmpty(), IsFormationInCombat(), LeaderMoveTo(), MemberEngagingTarget(), MemberEvaded(), RemoveMember(), and RespawnFormation().

---

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