Inheritance diagram for npc_echo_of_medivh:

Public Member Functions
	npc_echo_of_medivh (Creature *creature)

void	Reset () override

void	JustSummoned (Creature *summon) override

void	SummonedCreatureDespawn (Creature *summon) override

void	RemoveCheats ()

void	SetupBoard ()

void	HandleCellInitialData (uint8 row, uint8 col, Creature *trigger, BoardCell &cell)

bool	IsMedivhPiece (uint32 entry) const

Creature *	GetHostileTargetForChangeFacing (Creature *piece, KarazhanChessOrientationType orientation)

void	HandlePieceJustDied (Creature *piece)

int8	HandlePieceRotate (Creature *piece, ObjectGuid const &triggerGUID)

int8	HandlePieceMove (Creature *piece, ObjectGuid const &triggerGUID, bool moveByAI)

void	CastChangeFacing (Creature piece, Creature trigger)

bool	HandlePieceMoveByAI (Creature *piece, KarazhanChessOrientationType orientation)

void	HandleCheat ()

Creature *	GetPiece (Creature *sourcePiece, uint8 searchType, float distance, bool hostile, uint32 minHPDiff, bool checkFront)

void	UpdateAI (uint32 diff) override

void	sGossipHello (Player *player) override

void	sGossipSelect (Player *player, uint32, uint32 gossipListId) override

Public Member Functions inherited from ScriptedAI
	ScriptedAI (Creature *creature)

	~ScriptedAI () override

void	AttackStartNoMove (Unit *target)

void	DamageTaken (Unit *, uint32 &, DamageEffectType, SpellSchoolMask) override

void	UpdateAI (uint32 diff) override

void	JustDied (Unit *) override

void	KilledUnit (Unit *) override

void	JustSummoned (Creature *) override

void	SummonedCreatureDespawn (Creature *) override

void	SpellHit (Unit , SpellInfo const ) override

void	SpellHitTarget (Unit , SpellInfo const ) override

void	MovementInform (uint32, uint32) override

void	OnPossess (bool)

bool	IsInRoom (const Position *pos, Axis axis, bool above)

void	Reset () override

void	JustEngagedWith (Unit *) override
	Called for reaction when initially engaged.

void	AttackStart (Unit *) override

void	DoStartMovement (Unit *target, float distance=0.0f, float angle=0.0f)

void	DoStartNoMovement (Unit *target)

void	DoStopAttack ()

void	DoCastSpell (Unit target, SpellInfo const spellInfo, bool triggered=false)

void	DoPlaySoundToSet (WorldObject *source, uint32 soundId)

void	DoPlayMusic (uint32 soundId, bool zone)

void	DoAddThreat (Unit *unit, float amount)

void	DoModifyThreatByPercent (Unit *unit, int32 pct)

void	DoResetThreat (Unit *unit)

void	DoResetThreatList ()

float	DoGetThreat (Unit *unit)

void	DoTeleportPlayer (Unit *unit, float x, float y, float z, float o)

void	DoTeleportAll (float x, float y, float z, float o)

Unit *	DoSelectLowestHpFriendly (float range, uint32 minHPDiff=1)

std::list< Creature * >	DoFindFriendlyCC (float range)

std::list< Creature * >	DoFindFriendlyMissingBuff (float range, uint32 spellId)

Player *	GetPlayerAtMinimumRange (float minRange)

Creature *	DoSpawnCreature (uint32 entry, float offsetX, float offsetY, float offsetZ, float angle, uint32 type, uint32 despawntime)

bool	HealthBelowPct (uint32 pct) const

bool	HealthAbovePct (uint32 pct) const

SpellInfo const *	SelectSpell (Unit *target, uint32 school, uint32 mechanic, SelectTargetType targets, uint32 powerCostMin, uint32 powerCostMax, float rangeMin, float rangeMax, SelectEffect effect)

void	SetEquipmentSlots (bool loadDefault, int32 mainHand=EQUIP_NO_CHANGE, int32 offHand=EQUIP_NO_CHANGE, int32 ranged=EQUIP_NO_CHANGE)

void	SetCombatMovement (bool allowMovement)

bool	IsCombatMovementAllowed () const

virtual bool	CheckEvadeIfOutOfCombatArea () const

bool	IsHeroic () const

Difficulty	GetDifficulty () const

bool	Is25ManRaid () const

template<class T >
const T &	DUNGEON_MODE (const T &normal5, const T &heroic10) const

template<class T >
const T &	RAID_MODE (const T &normal10, const T &normal25) const

template<class T >
const T &	RAID_MODE (const T &normal10, const T &normal25, const T &heroic10, const T &heroic25) const

Player *	SelectTargetFromPlayerList (float maxdist, uint32 excludeAura=0, bool mustBeInLOS=false) const

Public Member Functions inherited from CreatureAI
void	Talk (uint8 id, WorldObject const *whisperTarget=nullptr, Milliseconds delay=0s)
	Causes the creature to talk/say the text assigned to their entry in the `creature_text` database table.

void	Talk (uint8 id, Milliseconds delay)

	CreatureAI (Creature *creature)

	~CreatureAI () override

void	MoveCircleChecks ()

void	MoveBackwardsChecks ()

void	MoveInLineOfSight_Safe (Unit *who)
	== Reactions At =================================

void	TriggerAlert (Unit const *who) const

virtual bool	CanRespawn ()

virtual void	EnterEvadeMode (EvadeReason why=EVADE_REASON_OTHER)

virtual void	JustEngagedWith (Unit *)
	Called for reaction when initially engaged.

virtual void	JustDied (Unit *)

virtual void	KilledUnit (Unit *)

virtual void	JustSummoned (Creature *)

virtual void	IsSummonedBy (WorldObject *)

virtual void	SummonedCreatureDespawn (Creature *)

virtual void	SummonedCreatureDies (Creature , Unit )

virtual void	SummonedCreatureDespawnAll ()

virtual void	SpellHit (Unit , SpellInfo const )

virtual void	SpellHitTarget (Unit , SpellInfo const )

virtual void	AttackedBy (Unit *)

virtual bool	IsEscorted ()

virtual void	JustRespawned ()

virtual void	MovementInform (uint32, uint32)

virtual void	PathEndReached (uint32)

void	OnCharmed (bool apply) override

virtual void	JustReachedHome ()

void	DoZoneInCombat (Creature *creature=nullptr, float maxRangeToNearestTarget=250.0f)

virtual void	ReceiveEmote (Player *, uint32)

virtual void	OwnerAttackedBy (Unit *)

virtual void	OwnerAttacked (Unit *)

virtual void	CorpseRemoved (uint32 &)
	== Triggered Actions Requested ==================

virtual void	PassengerBoarded (Unit *, int8, bool)
	== Fields =======================================

virtual bool	BeforeSpellClick (Unit *)

virtual void	OnSpellClick (Unit *, bool &)

virtual bool	CanSeeAlways (WorldObject const *)

virtual bool	CanBeSeen (Player const *)

virtual bool	CanAlwaysBeDetectable (WorldObject const *)

virtual void	PetStopAttack ()

virtual bool	CheckInRoom ()

CreatureBoundary const *	GetBoundary () const

void	SetBoundary (CreatureBoundary const *boundary, bool negativeBoundaries=false)

bool	IsInBoundary (Position const *who=nullptr) const

virtual void	CalculateThreat (Unit , float &, SpellInfo const )

virtual bool	OnTeleportUnreacheablePlayer (Player *)

Public Member Functions inherited from UnitAI
	UnitAI (Unit *unit)

virtual	~UnitAI ()

virtual bool	CanAIAttack (Unit const *) const

virtual void	AttackStart (Unit *)

virtual void	UpdateAI (uint32)=0

virtual void	InitializeAI ()

virtual void	Reset ()

virtual void	OnCharmed (bool apply)=0

virtual void	DoAction (int32)

virtual uint32	GetData (uint32) const

virtual void	SetData (uint32, uint32)

virtual void	SetGUID (ObjectGuid, int32=0)

virtual ObjectGuid	GetGUID (int32=0) const

Unit *	SelectTarget (SelectTargetMethod targetType, uint32 position=0, float dist=0.0f, bool playerOnly=false, bool withTank=true, int32 aura=0)

template<class PREDICATE >
Unit *	SelectTarget (SelectTargetMethod targetType, uint32 position, PREDICATE const &predicate)

void	SelectTargetList (std::list< Unit * > &targetList, uint32 num, SelectTargetMethod targetType, uint32 position=0, float dist=0.0f, bool playerOnly=false, bool withTank=true, int32 aura=0)

template<class PREDICATE >
void	SelectTargetList (std::list< Unit * > &targetList, uint32 num, SelectTargetMethod targetType, uint32 position, PREDICATE const &predicate)

virtual void	JustEnteredCombat (Unit *)
	Called when the unit enters combat (NOTE: Creature engage logic should NOT be here, but in JustEngagedWith, which happens once threat is established!)

virtual void	JustExitedCombat ()
	Called when the unit leaves combat.

virtual void	DamageDealt (Unit *, uint32 &, DamageEffectType)

virtual void	DamageTaken (Unit *, uint32 &, DamageEffectType, SpellSchoolMask)

virtual void	HealReceived (Unit *, uint32 &)

virtual void	HealDone (Unit *, uint32 &)

void	AttackStartCaster (Unit *victim, float dist)

SpellCastResult	DoAddAuraToAllHostilePlayers (uint32 spellid)

SpellCastResult	DoCast (uint32 spellId)

SpellCastResult	DoCast (Unit *victim, uint32 spellId, bool triggered=false)

SpellCastResult	DoCastSelf (uint32 spellId, bool triggered=false)

SpellCastResult	DoCastToAllHostilePlayers (uint32 spellid, bool triggered=false)

SpellCastResult	DoCastVictim (uint32 spellId, bool triggered=false)

SpellCastResult	DoCastAOE (uint32 spellId, bool triggered=false)

SpellCastResult	DoCastRandomTarget (uint32 spellId, uint32 threatTablePosition=0, float dist=0.0f, bool playerOnly=true, bool triggered=false)

SpellCastResult	DoCastMaxThreat (uint32 spellId, uint32 threatTablePosition=0, float dist=0.0f, bool playerOnly=true, bool triggered=false)
	Cast spell on the max threat target, which may not always be the current victim.

float	DoGetSpellMaxRange (uint32 spellId, bool positive=false)

void	DoMeleeAttackIfReady ()

bool	DoSpellAttackIfReady (uint32 spell)

void	DoSpellAttackToRandomTargetIfReady (uint32 spell, uint32 threatTablePosition=0, float dist=0.f, bool playerOnly=true)

virtual void	SummonMovementInform (Creature *, uint32, uint32)

virtual void	sGossipHello (Player *)

virtual void	sGossipSelect (Player *, uint32, uint32)

virtual void	sGossipSelectCode (Player , uint32, uint32, char const )

virtual void	sQuestAccept (Player , Quest const )

virtual void	sQuestSelect (Player , Quest const )

virtual void	sQuestComplete (Player , Quest const )

virtual void	sQuestReward (Player , Quest const , uint32)

virtual void	sOnGameEvent (bool, uint16)

virtual std::string	GetDebugInfo () const

Private Attributes
InstanceScript *	_instance

SummonList	_summons

std::array< std::array< BoardCell, MAX_COL >, MAX_ROW >	_boards

std::array< uint32, 2 >	_deadCount

uint32	_cheatTimer

Additional Inherited Members
Public Types inherited from ScriptedAI
enum class	Axis { AXIS_X , AXIS_Y }

Public Types inherited from CreatureAI
enum	EvadeReason { EVADE_REASON_NO_HOSTILES , EVADE_REASON_BOUNDARY , EVADE_REASON_SEQUENCE_BREAK , EVADE_REASON_NO_PATH , EVADE_REASON_OTHER }

Static Public Member Functions inherited from CreatureAI
static bool	IsInBounds (CreatureBoundary const &boundary, Position const *who)

Static Public Member Functions inherited from UnitAI
static void	FillAISpellInfo ()

Public Attributes inherited from ScriptedAI
Creature *	me

bool	IsFleeing

Static Public Attributes inherited from UnitAI
static AISpellInfoType *	AISpellInfo

Protected Member Functions inherited from CreatureAI
bool	UpdateVictim ()

bool	UpdateVictimWithGaze ()

void	SetGazeOn (Unit *target)

Creature *	DoSummon (uint32 entry, Position const &pos, uint32 despawnTime=30000, TempSummonType summonType=TEMPSUMMON_CORPSE_TIMED_DESPAWN)

Creature *	DoSummon (uint32 entry, WorldObject *obj, float radius=5.0f, uint32 despawnTime=30000, TempSummonType summonType=TEMPSUMMON_CORPSE_TIMED_DESPAWN)

Creature *	DoSummonFlyer (uint32 entry, WorldObject *obj, float flightZ, float radius=5.0f, uint32 despawnTime=30000, TempSummonType summonType=TEMPSUMMON_CORPSE_TIMED_DESPAWN)

virtual void	MoveInLineOfSight (Unit *)

bool	_EnterEvadeMode (EvadeReason why=EVADE_REASON_OTHER)

Protected Attributes inherited from CreatureAI
Creature *const	me

EventMap	events

CreatureBoundary const *	_boundary

bool	_negateBoundary

Protected Attributes inherited from UnitAI
Unit *const	me

Detailed Description

Constructor & Destructor Documentation

◆ npc_echo_of_medivh()

npc_echo_of_medivh::npc_echo_of_medivh ( Creature * creature )

inline

                                           : ScriptedAI(creature), _summons(me)
    {
        _instance = creature->GetInstanceScript();
    }

References _instance, and WorldObject::GetInstanceScript().

Member Function Documentation

◆ CastChangeFacing()

void npc_echo_of_medivh::CastChangeFacing	(	Creature *	piece,
		Creature *	trigger
	)

inline

    {
        piece->CastSpell(trigger, SPELL_CHANGE_FACING, true);
    }

References Unit::CastSpell(), and SPELL_CHANGE_FACING.

Referenced by HandlePieceMoveByAI().

◆ GetHostileTargetForChangeFacing()

Creature * npc_echo_of_medivh::GetHostileTargetForChangeFacing	(	Creature *	piece,
		KarazhanChessOrientationType	orientation
	)

inline

    {
        for (uint8 row = 0; row < MAX_ROW; ++row)
        {
            for (uint8 col = 0; col < MAX_COL; ++col)
            {
                BoardCell const& cell = _boards[row][col];
                if (cell.pieceGUID == piece->GetGUID())
                {
                    std::vector<KarazhanChessOrientationType> orientations;
                    switch (orientation)
                    {
                        case ORI_SE:
                            orientations = { ORI_NE, ORI_E, ORI_S, ORI_SW };
                            break;
                        case ORI_S:
                            orientations = { ORI_E, ORI_SE, ORI_SW, ORI_W };
                            break;
                        case ORI_SW:
                            orientations = { ORI_SE, ORI_S, ORI_W, ORI_NW };
                            break;
                        case ORI_W:
                            orientations = { ORI_NE, ORI_SW, ORI_NW, ORI_N };
                            break;
                        case ORI_NW:
                            orientations = { ORI_SW, ORI_W, ORI_N, ORI_NE };
                            break;
                        case ORI_N:
                            orientations = { ORI_W, ORI_NW, ORI_NE, ORI_E };
                            break;
                        case ORI_NE:
                            orientations = { ORI_NW, ORI_N, ORI_E, ORI_SE };
                            break;
                        case ORI_E:
                            orientations = { ORI_N, ORI_NE, ORI_SE, ORI_S };
                            break;
                        default:
                            break;
                    }
 
                    for (KarazhanChessOrientationType orient : orientations)
                    {
                        uint8 newRow = row;
                        uint8 newCol = col;
                        switch (orient)
                        {
                            case ORI_SE:
                                newRow -= 1;
                                break;
                            case ORI_S:
                                newRow -= 1;
                                newCol -= 1;
                                break;
                            case ORI_SW:
                                newCol -= 1;
                                break;
                            case ORI_W:
                                newRow += 1;
                                newCol -= 1;
                                break;
                            case ORI_NW:
                                newRow += 1;
                                break;
                            case ORI_N:
                                newRow += 1;
                                newCol += 1;
                                break;
                            case ORI_NE:
                                newCol += 1;
                                break;
                            case ORI_E:
                                newRow -= 1;
                                newCol += 1;
                                break;
                            default:
                                break;
                        }
 
                        if (Creature* targetPiece = ObjectAccessor::GetCreature(*me, _boards[newRow][newCol].pieceGUID))
                        {
                            if (!IsFriendly(piece, targetPiece))
                            {
                                return targetPiece;
                            }
                        }
                    }
 
                    return nullptr;
                }
            }
        }
 
        return nullptr;
    }

References _boards, ObjectAccessor::GetCreature(), Object::GetGUID(), IsFriendly(), MAX_COL, MAX_ROW, ScriptedAI::me, ORI_E, ORI_N, ORI_NE, ORI_NW, ORI_S, ORI_SE, ORI_SW, ORI_W, orientations, and BoardCell::pieceGUID.

Referenced by HandlePieceMoveByAI().

◆ GetPiece()

Creature * npc_echo_of_medivh::GetPiece	(	Creature *	sourcePiece,
		uint8	searchType,
		float	distance,
		bool	hostile,
		uint32	minHPDiff,
		bool	checkFront
	)

inline

    {
        if (!sourcePiece)
        {
            return nullptr;
        }
 
        Creature* target = nullptr;
        std::vector<Creature*> targets;
 
        for (uint8 row = 0; row < MAX_ROW; ++row)
        {
            for (uint8 col = 0; col < MAX_COL; ++col)
            {
                if (Creature* piece = ObjectAccessor::GetCreature(*me, _boards[row][col].pieceGUID))
                {
                    if (IsFriendly(piece, sourcePiece) == hostile)
                    {
                        continue;
                    }
 
                    if (checkFront && !sourcePiece->HasInArc(float(M_PI) / 3.0f, piece))
                    {
                        continue;
                    }
 
                    if (minHPDiff)
                    {
                        if (piece->GetMaxHealth() - piece->GetHealth() <= minHPDiff)
                        {
                            continue;
                        }
 
                        minHPDiff = piece->GetMaxHealth() - piece->GetHealth();
                    }
 
                    float dist = sourcePiece->GetExactDist2d(piece);
                    if (dist < distance)
                    {
                        if (searchType == CHESS_PIECE_SEARCH_TYPE_CLOSEST)
                        {
                            distance = dist;
                            target = piece;
                        }
                        else
                        {
                            targets.push_back(piece);
                        }
                    }
                }
            }
        }
 
        if (!targets.empty())
        {
            target = Acore::Containers::SelectRandomContainerElement(targets);
        }
 
        return target;
    }

References _boards, CHESS_PIECE_SEARCH_TYPE_CLOSEST, ObjectAccessor::GetCreature(), Position::GetExactDist2d(), Unit::GetMaxHealth(), Position::HasInArc(), IsFriendly(), MAX_COL, MAX_ROW, ScriptedAI::me, and Acore::Containers::SelectRandomContainerElement().

◆ HandleCellInitialData()

void npc_echo_of_medivh::HandleCellInitialData	(	uint8	row,
		uint8	col,
		Creature *	trigger,
		BoardCell &	cell
	)

inline

    {
        switch (row)
        {
            case 0: // Alliance first row
            {
                switch (col)
                {
                    case 0:
                    case 7: // Rook
                        if (Creature* rook = trigger->FindNearestCreature(NPC_ROOK_A, 4.0f, true))
                        {
                            cell.SetPiece(rook);
                        }
                        break;
                    case 1:
                    case 6: // Knight
                        if (Creature* knight = trigger->FindNearestCreature(NPC_KNIGHT_A, 4.0f, true))
                        {
                            cell.SetPiece(knight);
                        }
                        break;
                    case 2:
                    case 5: // Bishop
                        if (Creature* bishop = trigger->FindNearestCreature(NPC_BISHOP_A, 4.0f, true))
                        {
                            cell.SetPiece(bishop);
                        }
                        break;
                    case 3: // Queen
                        if (Creature* queen = trigger->FindNearestCreature(NPC_QUEEN_A, 4.0f, true))
                        {
                            cell.SetPiece(queen);
                        }
                        break;
                    case 4: // King
                        if (Creature* king = trigger->FindNearestCreature(NPC_KING_A, 4.0f, true))
                        {
                            cell.SetPiece(king);
                        }
                        break;
                }
                break;
            }
            case 1: // Alliance second row
                // All pawns
                if (Creature* pawn = trigger->FindNearestCreature(NPC_PAWN_A, 4.0f, true))
                {
                    cell.SetPiece(pawn);
                }
                break;
            case 6: // Horde second row
                // All pawns
                if (Creature* pawn = trigger->FindNearestCreature(NPC_PAWN_H, 4.0f, true))
                {
                    cell.SetPiece(pawn);
                }
                break;
            case 7: // Horde first row
            {
                switch (col)
                {
                    case 0:
                    case 7: // Rook
                        if (Creature* rook = trigger->FindNearestCreature(NPC_ROOK_H, 4.0f, true))
                        {
                            cell.SetPiece(rook);
                        }
                        break;
                    case 1:
                    case 6: // Knight
                        if (Creature* knight = trigger->FindNearestCreature(NPC_KNIGHT_H, 4.0f, true))
                        {
                            cell.SetPiece(knight);
                        }
                        break;
                    case 2:
                    case 5: // Bishop
                        if (Creature* bishop = trigger->FindNearestCreature(NPC_BISHOP_H, 4.0f, true))
                        {
                            cell.SetPiece(bishop);
                        }
                        break;
                    case 3: // Queen
                        if (Creature* queen = trigger->FindNearestCreature(NPC_QUEEN_H, 4.0f, true))
                        {
                            cell.SetPiece(queen);
                        }
                        break;
                    case 4: // King
                        if (Creature* king = trigger->FindNearestCreature(NPC_KING_H, 4.0f, true))
                        {
                            cell.SetPiece(king);
                        }
                        break;
                    default:
                        break;
                }
                break;
            }
            default:
                cell.Reset();
                break;
        }
    }

References WorldObject::FindNearestCreature(), NPC_BISHOP_A, NPC_BISHOP_H, NPC_KING_A, NPC_KING_H, NPC_KNIGHT_A, NPC_KNIGHT_H, NPC_PAWN_A, NPC_PAWN_H, NPC_QUEEN_A, NPC_QUEEN_H, NPC_ROOK_A, NPC_ROOK_H, BoardCell::Reset(), and BoardCell::SetPiece().

Referenced by SetupBoard().

◆ HandleCheat()

void npc_echo_of_medivh::HandleCheat ( )

inline

    {
        Talk(TALK_MEDIHV_CHEAT);
 
        switch (urand(0, 2))
        {
            case 0: // Heal king
            {
                if (_instance->GetData(CHESS_EVENT_TEAM) == TEAM_ALLIANCE)
                {
                    if (Creature* king = me->FindNearestCreature(NPC_KING_H, 80.0f, true))
                    {
                        king->SetHealth(king->GetMaxHealth());
                    }
                }
                else if (_instance->GetData(CHESS_EVENT_TEAM) == TEAM_HORDE)
                {
                    if (Creature* king = me->FindNearestCreature(NPC_KING_A, 80.0f, true))
                    {
                        king->SetHealth(king->GetMaxHealth());
                    }
                }
 
                break;
            }
            case 1: // Fire
            {
                std::list<Creature*> targetList;
                for (uint8 row = 0; row < MAX_ROW; ++row)
                {
                    for (uint8 col = 0; col < MAX_COL; ++col)
                    {
                        BoardCell const& cell = _boards[row][col];
                        if (!cell.pieceGUID || IsMedivhPiece(cell.pieceEntry))
                        {
                            continue;
                        }
 
                        if (Creature* trigger = ObjectAccessor::GetCreature(*me, cell.triggerGUID))
                        {
                            targetList.push_back(trigger);
                        }
                    }
                }
 
                if (targetList.size() > 3)
                {
                    Acore::Containers::RandomResize(targetList, 3);
                }
 
                for (Creature* target : targetList)
                {
                    DoCast(target, SPELL_FURY_OF_MEDIVH_FIRE, true);
                }
 
                break;
            }
            case 2: // Buff
            {
                std::list<Creature*> targetList;
                for (uint8 row = 0; row < MAX_ROW; ++row)
                {
                    for (uint8 col = 0; col < MAX_COL; ++col)
                    {
                        BoardCell const& cell = _boards[row][col];
                        if (!cell.pieceGUID || !IsMedivhPiece(cell.pieceEntry))
                        {
                            continue;
                        }
 
                        if (Creature* piece = ObjectAccessor::GetCreature(*me, cell.pieceGUID))
                        {
                            targetList.push_back(piece);
                        }
                    }
                }
 
                uint8 resizeMax = urand(1, 4);
                if (targetList.size() > resizeMax)
                {
                    Acore::Containers::RandomResize(targetList, resizeMax);
                }
 
                for (Creature* target : targetList)
                {
                    DoCast(target, SPELL_HAND_OF_MEDIVH, true);
                }
 
                break;
            }
        }
 
        Talk(TALK_MEDIHV_CHEAT_EMOTE);
    }

References _boards, _instance, CHESS_EVENT_TEAM, UnitAI::DoCast(), WorldObject::FindNearestCreature(), ObjectAccessor::GetCreature(), ZoneScript::GetData(), IsMedivhPiece(), MAX_COL, MAX_ROW, ScriptedAI::me, NPC_KING_A, NPC_KING_H, BoardCell::pieceEntry, BoardCell::pieceGUID, Acore::Containers::RandomResize(), SPELL_FURY_OF_MEDIVH_FIRE, SPELL_HAND_OF_MEDIVH, TALK_MEDIHV_CHEAT, TALK_MEDIHV_CHEAT_EMOTE, TEAM_ALLIANCE, TEAM_HORDE, BoardCell::triggerGUID, and urand().

Referenced by UpdateAI().

◆ HandlePieceJustDied()

void npc_echo_of_medivh::HandlePieceJustDied ( Creature * piece )

inline

    {
        switch (piece->GetFaction())
        {
            case CHESS_FACTION_ALLIANCE:
            {
                float baseX = -11078.116211f;
                float baseY = -1908.443115f;
                float deltaX = 2.148438f;
                float deltaY = 1.723755f;
                float extraX = 2.416992f;
                float extraY = -2.889649f;
                float offset = 1.3f * (_deadCount[DEAD_ALLIANCE] % MAX_ROW);
                float finalX = baseX + offset * deltaX + (_deadCount[DEAD_ALLIANCE] >= MAX_ROW ? 1 : 0) * extraX;
                float finalY = baseY + offset * deltaY + (_deadCount[DEAD_ALLIANCE] >= MAX_ROW ? 1 : 0) * extraY;
                piece->NearTeleportTo(finalX, finalY, 221.0f, orientations[ORI_SW]);
                ++_deadCount[DEAD_ALLIANCE];
 
                piece->CombatStop();
                piece->SetUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
                piece->setDeathState(JUST_RESPAWNED);
                piece->SetHealth(piece->GetMaxHealth());
                break;
            }
            case CHESS_FACTION_HORDE:
            {
                float baseX = -11081.393555f;
                float baseY = -1844.194092f;
                float deltaX = -2.148438f;
                float deltaY = -1.723755f;
                float extraX = -2.416992f;
                float extraY = 2.889649f;
 
                float offset = 1.3f * (_deadCount[DEAD_HORDE] % MAX_ROW);
 
                float finalX = baseX + offset * deltaX + (_deadCount[DEAD_HORDE] >= MAX_ROW ? 1 : 0) * extraX;
                float finalY = baseY + offset * deltaY + (_deadCount[DEAD_HORDE] >= MAX_ROW ? 1 : 0) * extraY;
                piece->NearTeleportTo(finalX, finalY, 221.0f, orientations[ORI_NE]);
                ++_deadCount[DEAD_HORDE];
 
                piece->CombatStop();
                piece->SetUnitFlag(UNIT_FLAG_NOT_SELECTABLE);
                piece->setDeathState(JUST_RESPAWNED);
                piece->SetHealth(piece->GetMaxHealth());
                break;
            }
        }
 
        for (uint8 row = 0; row < MAX_ROW; ++row)
        {
            for (uint8 col = 0; col < MAX_COL; ++col)
            {
                if (_boards[row][col].pieceGUID == piece->GetGUID())
                {
                    _boards[row][col].Reset();
                }
            }
        }
 
        if (_instance->GetData(CHESS_EVENT_TEAM) == TEAM_HORDE)
        {
            bool ended = false;
            switch (piece->GetEntry())
            {
                case NPC_KING_H:
                    _instance->SetData(DATA_CHESS_EVENT, NOT_STARTED);
                    _instance->SetData(DATA_CHESS_REINIT_PIECES, 0);
                    _instance->SetData(DATA_CHESS_GAME_PHASE, CHESS_PHASE_NOT_STARTED);
                    break;
                case NPC_KING_A:
                    if (_instance->GetData(DATA_CHESS_EVENT) == IN_PROGRESS)
                    {
                        _instance->SetData(DATA_CHESS_EVENT, DONE);
                        _instance->SetData(DATA_CHESS_GAME_PHASE, CHESS_PHASE_PVE_FINISHED);
                        _instance->SetData(DATA_CHESS_REINIT_PIECES, 0);
                        _instance->DoRespawnGameObject(_instance->GetGuidData(DATA_DUST_COVERED_CHEST), DAY);
                        Talk(TALK_EVENT_ENDED);
                        ended = true;
                        _instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_GAME_IN_SESSION);
                    }
                    else if (_instance->GetData(DATA_CHESS_EVENT) == SPECIAL)
                    {
                        _instance->SetData(DATA_CHESS_EVENT, DONE);
                        _instance->SetData(DATA_CHESS_REINIT_PIECES, 0);
                        _instance->SetData(DATA_CHESS_GAME_PHASE, CHESS_PHASE_PVE_FINISHED);
                        ended = true;
                        _instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_GAME_IN_SESSION);
                    }
                    break;
                default:
                    break;
            }
 
            if (!ended)
            {
                uint8 talkIndex = TALK_PLAYER_LOOSE_PAWN;
                if (piece->GetFaction() == CHESS_FACTION_ALLIANCE)
                {
                    talkIndex = TALK_MEDIVH_LOOSE_PAWN;
                }
 
                switch (piece->GetEntry())
                {
                    case NPC_ROOK_A:
                    case NPC_ROOK_H:
                        talkIndex += 1;
                        break;
                    case NPC_KNIGHT_A:
                    case NPC_KNIGHT_H:
                        talkIndex += 2;
                        break;
                    case NPC_BISHOP_A:
                    case NPC_BISHOP_H:
                        talkIndex += 3;
                        break;
                    case NPC_QUEEN_A:
                    case NPC_QUEEN_H:
                        talkIndex += 4;
                        break;
                    case NPC_KING_H:
                    case NPC_KING_A:
                        talkIndex += 5;
                        break;
                }
 
                Talk(talkIndex);
            }
        }
        else if (_instance->GetData(CHESS_EVENT_TEAM) == TEAM_ALLIANCE)
        {
            bool ended = false;
            switch (piece->GetEntry())
            {
                case NPC_KING_A:
                    _instance->SetData(DATA_CHESS_EVENT, NOT_STARTED);
                    _instance->SetData(DATA_CHESS_REINIT_PIECES, 0);
                    _instance->SetData(DATA_CHESS_GAME_PHASE, CHESS_PHASE_NOT_STARTED);
                    break;
                case NPC_KING_H:
                    if (_instance->GetData(DATA_CHESS_EVENT) == IN_PROGRESS)
                    {
                        _instance->SetData(DATA_CHESS_EVENT, DONE);
                        _instance->SetData(DATA_CHESS_GAME_PHASE, CHESS_PHASE_PVE_FINISHED);
                        _instance->SetData(DATA_CHESS_REINIT_PIECES, 0);
                        Talk(TALK_EVENT_ENDED);
                        _instance->DoRespawnGameObject(_instance->GetGuidData(DATA_DUST_COVERED_CHEST), DAY);
                        ended = true;
                        _instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_GAME_IN_SESSION);
                    }
                    else if (_instance->GetData(DATA_CHESS_EVENT) == SPECIAL)
                    {
                        _instance->SetData(DATA_CHESS_EVENT, DONE);
                        _instance->SetData(DATA_CHESS_REINIT_PIECES, 0);
                        _instance->SetData(DATA_CHESS_GAME_PHASE, CHESS_PHASE_PVE_FINISHED);
                        _instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_GAME_IN_SESSION);
                        ended = true;
                    }
                    break;
                default:
                    break;
            }
 
            if (!ended)
            {
                uint8 talkIndex = TALK_PLAYER_LOOSE_PAWN;
                if (piece->GetFaction() == CHESS_FACTION_HORDE)
                {
                    talkIndex = TALK_MEDIVH_LOOSE_PAWN;
                }
 
                switch (piece->GetEntry())
                {
                    case NPC_ROOK_A:
                    case NPC_ROOK_H:
                        talkIndex += 1;
                        break;
                    case NPC_KNIGHT_A:
                    case NPC_KNIGHT_H:
                        talkIndex += 2;
                        break;
                    case NPC_BISHOP_A:
                    case NPC_BISHOP_H:
                        talkIndex += 3;
                        break;
                    case NPC_QUEEN_A:
                    case NPC_QUEEN_H:
                        talkIndex += 4;
                        break;
                    case NPC_KING_H:
                    case NPC_KING_A:
                        talkIndex += 5;
                        break;
                }
 
                Talk(talkIndex);
            }
        }
        else
        {
            switch (piece->GetEntry())
            {
                case NPC_KING_H:
                case NPC_KING_A:
                    _instance->SetData(DATA_CHESS_EVENT, DONE);
                    _instance->SetData(DATA_CHESS_REINIT_PIECES, 0);
                    _instance->SetData(DATA_CHESS_GAME_PHASE, CHESS_PHASE_PVE_FINISHED);
                    _instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_GAME_IN_SESSION);
                    break;
            }
 
            uint8 talkIndex = TALK_PLAYER_LOOSE_PAWN;
            if (piece->GetFaction() == CHESS_FACTION_HORDE)
            {
                talkIndex = TALK_MEDIVH_LOOSE_PAWN;
            }
 
            switch (piece->GetEntry())
            {
                case NPC_ROOK_A:
                case NPC_ROOK_H:
                    talkIndex += 1;
                    break;
                case NPC_KNIGHT_A:
                case NPC_KNIGHT_H:
                    talkIndex += 2;
                    break;
                case NPC_BISHOP_A:
                case NPC_BISHOP_H:
                    talkIndex += 3;
                    break;
                case NPC_QUEEN_A:
                case NPC_QUEEN_H:
                    talkIndex += 4;
                    break;
                case NPC_KING_H:
                case NPC_KING_A:
                    talkIndex += 5;
                    break;
            }
 
            Talk(talkIndex);
        }
    }

References _boards, _deadCount, _instance, CHESS_EVENT_TEAM, CHESS_FACTION_ALLIANCE, CHESS_FACTION_HORDE, CHESS_PHASE_NOT_STARTED, CHESS_PHASE_PVE_FINISHED, Unit::CombatStop(), DATA_CHESS_EVENT, DATA_CHESS_GAME_PHASE, DATA_CHESS_REINIT_PIECES, DATA_DUST_COVERED_CHEST, DAY, DEAD_ALLIANCE, DEAD_HORDE, DONE, InstanceScript::DoRemoveAurasDueToSpellOnPlayers(), InstanceScript::DoRespawnGameObject(), ZoneScript::GetData(), Object::GetEntry(), Unit::GetFaction(), Object::GetGUID(), InstanceScript::GetGuidData(), Unit::GetMaxHealth(), IN_PROGRESS, JUST_RESPAWNED, MAX_COL, MAX_ROW, Unit::NearTeleportTo(), NOT_STARTED, NPC_BISHOP_A, NPC_BISHOP_H, NPC_KING_A, NPC_KING_H, NPC_KNIGHT_A, NPC_KNIGHT_H, NPC_QUEEN_A, NPC_QUEEN_H, NPC_ROOK_A, NPC_ROOK_H, ORI_NE, ORI_SW, orientations, ZoneScript::SetData(), Creature::setDeathState(), Unit::SetHealth(), Unit::SetUnitFlag(), SPECIAL, SPELL_GAME_IN_SESSION, TALK_EVENT_ENDED, TALK_MEDIVH_LOOSE_PAWN, TALK_PLAYER_LOOSE_PAWN, TEAM_ALLIANCE, TEAM_HORDE, and UNIT_FLAG_NOT_SELECTABLE.

◆ HandlePieceMove()

int8 npc_echo_of_medivh::HandlePieceMove	(	Creature *	piece,
		ObjectGuid const &	triggerGUID,
		bool	moveByAI
	)

inline

    {
        bool foundProperCell = false;
        bool foundOld = false;
        bool foundNew = false;
        int8 oldRow = MAX_ROW;
        int8 oldCol = MAX_COL;
        int8 newRow = -1;
        int8 newCol = -1;
 
        for (uint8 row = 0; row < MAX_ROW; ++row)
        {
            for (uint8 col = 0; col < MAX_COL; ++col)
            {
                BoardCell const& cell = _boards[row][col];
                if (!foundNew)
                {
                    if (cell.triggerGUID == triggerGUID)
                    {
                        //is there already a piece on this cell ?
                        if (cell.pieceGUID)
                        {
                            return -1;
                        }
 
                        newCol = col;
                        newRow = row;
                        foundProperCell = true;
                        foundNew = true;
                    }
                }
 
                if (!foundOld)
                {
                    if (cell.pieceGUID == piece->GetGUID())
                    {
                        oldCol = col;
                        oldRow = row;
                        foundOld = true;
                    }
                }
 
                if (foundNew && foundOld)
                {
                    break;
                }
            }
 
            if (foundNew && foundOld)
            {
                break;
            }
        }
 
        if (newCol == -1 || newRow == -1)
        {
            return -1;
        }
 
        if (!moveByAI && foundProperCell)
        {
            uint8 deltaRow = abs(oldRow - newRow);
            uint8 deltaCol = abs(oldCol - newCol);
 
            switch (piece->GetEntry())
            {
                case NPC_PAWN_H:
                case NPC_PAWN_A:
                case NPC_BISHOP_H:
                case NPC_BISHOP_A:
                case NPC_ROOK_H:
                case NPC_ROOK_A:
                case NPC_KING_H:
                case NPC_KING_A:
                    if (deltaRow > 1 || deltaCol > 1)
                    {
                        foundProperCell = false;
                    }
                    break;
                case NPC_QUEEN_H:
                case NPC_QUEEN_A:
                    if (deltaRow > 3 || deltaCol > 3)
                    {
                        foundProperCell = false;
                    }
                    break;
                case NPC_KNIGHT_H:
                case NPC_KNIGHT_A:
                    if (deltaRow > 2 || deltaCol > 2)
                    {
                        foundProperCell = false;
                    }
                    break;
                default:
                    break;
            }
        }
 
        if (foundProperCell || moveByAI)
        {
            int8 orientation = HandlePieceRotate(piece, triggerGUID);
            if (orientation != -1)
            {
                _boards[newRow][newCol].triggerGUID = triggerGUID;
                _boards[newRow][newCol].SetPiece(piece);
 
                if (oldRow != MAX_ROW && oldCol != MAX_COL)
                {
                    _boards[oldRow][oldCol].Reset();
                }
            }
 
            return orientation;
        }
 
        return -1;
    }

References _boards, Object::GetEntry(), Object::GetGUID(), HandlePieceRotate(), MAX_COL, MAX_ROW, NPC_BISHOP_A, NPC_BISHOP_H, NPC_KING_A, NPC_KING_H, NPC_KNIGHT_A, NPC_KNIGHT_H, NPC_PAWN_A, NPC_PAWN_H, NPC_QUEEN_A, NPC_QUEEN_H, NPC_ROOK_A, NPC_ROOK_H, BoardCell::pieceGUID, and BoardCell::triggerGUID.

◆ HandlePieceMoveByAI()

bool npc_echo_of_medivh::HandlePieceMoveByAI	(	Creature *	piece,
		KarazhanChessOrientationType	orientation
	)

inline

Change orientation at edges

Here we shouldn't be facing the edges of the board, check in the 4 first if statements

    {
        uint8 pieceRow = 0;
        uint8 pieceCol = 0;
        bool found = false;
 
        for (uint8 row = 0; row < MAX_ROW; ++row)
        {
            for (uint8 col = 0; col < MAX_COL; ++col)
            {
                if (_boards[row][col].pieceGUID == piece->GetGUID())
                {
                    pieceRow = row;
                    pieceCol = col;
                    found = true;
                    break;
                }
            }
 
            if (found)
            {
                break;
            }
        }
 
        if (orientation == ORI_SE && pieceRow == 0)
        {
            if (Creature* trigger = ObjectAccessor::GetCreature(*me, _boards[pieceRow + 1][pieceCol].triggerGUID))
            {
                CastChangeFacing(piece, trigger);
            }
 
            return true;
        }
        else if (orientation == ORI_NW && pieceRow == 7)
        {
            if (Creature* trigger = ObjectAccessor::GetCreature(*me, _boards[pieceRow - 1][pieceCol].triggerGUID))
            {
                CastChangeFacing(piece, trigger);
            }
 
            return true;
        }
        else if (orientation == ORI_SW && pieceCol == 0)
        {
            if (Creature* trigger = ObjectAccessor::GetCreature(*me, _boards[pieceRow][pieceCol + 1].triggerGUID))
            {
                CastChangeFacing(piece, trigger);
            }
 
            return true;
        }
        else if (orientation == ORI_NE && pieceCol == 7)
        {
            if (Creature* trigger = ObjectAccessor::GetCreature(*me, _boards[pieceRow][pieceCol - 1].triggerGUID))
            {
                CastChangeFacing(piece, trigger);
            }
 
            return true;
        }
        else if (urand(0, 1)) // 50% chance to check for nearby enemies
        {
            if (Creature* target = GetHostileTargetForChangeFacing(piece, orientation))
            {
                CastChangeFacing(me, target);
                return true;
            }
        }
 
        switch (orientation)
        {
            case ORI_W:
            case ORI_N:
                orientation = ORI_NW;
                break;
            case ORI_S:
            case ORI_E:
                orientation = ORI_SE;
                break;
            default:
                break;
        }
 
        switch (orientation) 
        {
            case ORI_SE:
            case ORI_NW:
            {
                int32 randomRow = (orientation == ORI_SE) ? pieceRow - 1 : pieceRow + 1;
                int32 randomCol = pieceCol;
                switch (urand(0, 2))
                {
                    case 0:
                        if ((me->GetEntry() == NPC_QUEEN_A || me->GetEntry() == NPC_QUEEN_H))
                        {
                            randomCol -= irand(1, 2);
                        }
                        else
                        {
                            randomCol -= 1;
                        }
                        break;
                    case 1:
                        if ((me->GetEntry() == NPC_QUEEN_A || me->GetEntry() == NPC_QUEEN_H))
                        {
                            randomCol += irand(1, 2);
                        }
                        else
                        {
                            randomCol += 1;
                        }
                        break;
                    case 2:
                        if ((me->GetEntry() == NPC_QUEEN_A || me->GetEntry() == NPC_QUEEN_H))
                        {
                            randomRow += (orientation == ORI_SE) ? irand(-2, 0) : irand(0, 2);
                        }
                        else if ((me->GetEntry() == NPC_KNIGHT_A || me->GetEntry() == NPC_KNIGHT_H) && urand(0, 1))
                        {
                            randomRow += (orientation == ORI_SE) ? -1 : 1;
                        }
                        break;
                }
 
                randomRow = RoundToInterval(randomRow, 0, 7);
                randomCol = RoundToInterval(randomCol, 0, 7);
 
                BoardCell const& cell = _boards[randomRow][randomCol];
                if (Creature* trigger = ObjectAccessor::GetCreature(*me, cell.triggerGUID))
                {
                    if (!cell.pieceGUID)
                    {
                        piece->CastSpell(trigger, SPELL_MOVE_GENERIC, false);
                        return true;
                    }
                }
                break;
            }
            case ORI_SW:
            case ORI_NE:
            {
                int32 randomRow = pieceRow;
                int32 randomCol = orientation == ORI_SW ? pieceCol - 1 : pieceCol + 1;
                switch (urand(0, 2))
                {
                    case 0:
                        if ((me->GetEntry() == NPC_QUEEN_A || me->GetEntry() == NPC_QUEEN_H))
                        {
                            randomRow -= irand(1, 2);
                        }
                        else
                        {
                            randomRow -= 1;
                        }
                        break;
                    case 1:
                        if ((me->GetEntry() == NPC_QUEEN_A || me->GetEntry() == NPC_QUEEN_H))
                        {
                            randomRow += irand(1, 2);
                        }
                        else
                        {
                            randomRow += 1;
                        }
                        break;
                    case 2:
                        if ((me->GetEntry() == NPC_QUEEN_A || me->GetEntry() == NPC_QUEEN_H))
                        {
                            randomCol += (orientation == ORI_SW) ? irand(-2, 0) : irand(0, 2);
                        }
                        else if ((me->GetEntry() == NPC_KNIGHT_A || me->GetEntry() == NPC_KNIGHT_H) && urand(0, 1))
                        {
                            randomCol += (orientation == ORI_SW) ? -1 : 1;
                        }
                        break;
                }
 
                randomRow = RoundToInterval(randomRow, 0, 7);
                randomCol = RoundToInterval(randomCol, 0, 7);
 
                BoardCell const& cell = _boards[randomRow][randomCol];
                if (Creature* trigger = ObjectAccessor::GetCreature(*me, cell.triggerGUID))
                {
                    if (!cell.pieceGUID)
                    {
                        piece->CastSpell(trigger, SPELL_MOVE_GENERIC, false);
                        return true;
                    }
                }
                break;
            }
            default:
                break;
        }
 
        return false;
    }

References _boards, CastChangeFacing(), Unit::CastSpell(), ObjectAccessor::GetCreature(), Object::GetEntry(), Object::GetGUID(), GetHostileTargetForChangeFacing(), irand(), MAX_COL, MAX_ROW, ScriptedAI::me, NPC_KNIGHT_A, NPC_KNIGHT_H, NPC_QUEEN_A, NPC_QUEEN_H, ORI_E, ORI_N, ORI_NE, ORI_NW, ORI_S, ORI_SE, ORI_SW, ORI_W, BoardCell::pieceGUID, RoundToInterval(), SPELL_MOVE_GENERIC, BoardCell::triggerGUID, and urand().

◆ HandlePieceRotate()

int8 npc_echo_of_medivh::HandlePieceRotate	(	Creature *	piece,
		ObjectGuid const &	triggerGUID
	)

inline

    {
        bool foundOld = false;
        bool foundNew = false;
        int8 pieceRow = MAX_ROW;
        int8 pieceCol = MAX_COL;
        int8 targetRow = -1;
        int8 targetCol = -1;
 
        for (uint8 row = 0; row < MAX_ROW; ++row)
        {
            for (uint8 col = 0; col < MAX_COL; ++col)
            {
                BoardCell const& cell = _boards[row][col];
                if (!foundNew && cell.triggerGUID == triggerGUID)
                {
                    targetRow = row;
                    targetCol = col;
                    foundNew = true;
                }
 
                if (!foundOld && cell.pieceGUID == piece->GetGUID())
                {
                    pieceRow = row;
                    pieceCol = col;
                    foundOld = true;
                }
 
                if (foundNew && foundOld)
                {
                    break;
                }
            }
 
            if (foundNew && foundOld)
            {
                break;
            }
        }
 
        if (targetRow == -1 || targetCol == -1)
        {
            return -1;
        }
 
        int8 deltaRow = targetRow - pieceRow;
        int8 deltaCol = targetCol - pieceCol;
 
        if (!deltaRow && !deltaCol)
        {
            return -1;
        }
 
        switch (deltaRow)
        {
            case -3:
            case -2:
            case -1:
            {
                switch (deltaCol)
                {
                    case -3:
                    case -2:
                    case -1:
                        return ORI_S;
                    case 0:
                        return ORI_SE;
                    case 1:
                    case 2:
                    case 3:
                        return ORI_E;
                    default:
                        break;
                }
                break;
            }
            case 0:
            {
                switch (deltaCol)
                {
                    case -3:
                    case -2:
                    case -1:
                        return ORI_SW;
                    case 1:
                    case 2:
                    case 3:
                        return ORI_NE;
                    default:
                        break;
                }
                break;
            }
            case 1:
            case 2:
            case 3:
            {
                switch (deltaCol)
                {
                    case -3:
                    case -2:
                    case -1:
                        return ORI_W;
                    case 0:
                        return ORI_NW;
                    case 1:
                    case 2:
                    case 3:
                        return ORI_N;
                    default:
                        break;
                }
                break;
            }
            default:
                break;
        }
 
        return -1;
    }

References _boards, Object::GetGUID(), MAX_COL, MAX_ROW, ORI_E, ORI_N, ORI_NE, ORI_NW, ORI_S, ORI_SE, ORI_SW, ORI_W, BoardCell::pieceGUID, and BoardCell::triggerGUID.

Referenced by HandlePieceMove().

◆ IsMedivhPiece()

bool npc_echo_of_medivh::IsMedivhPiece ( uint32 entry ) const

inline

    {
        switch (entry)
        {
            case NPC_PAWN_H:
            case NPC_KNIGHT_H:
            case NPC_QUEEN_H:
            case NPC_BISHOP_H:
            case NPC_ROOK_H:
            case NPC_KING_H:
                return _instance->GetData(CHESS_EVENT_TEAM) == TEAM_ALLIANCE;
            case NPC_PAWN_A:
            case NPC_KNIGHT_A:
            case NPC_QUEEN_A:
            case NPC_BISHOP_A:
            case NPC_ROOK_A:
            case NPC_KING_A:
                return _instance->GetData(CHESS_EVENT_TEAM) == TEAM_HORDE;
        }
 
        return false;
    }

References _instance, CHESS_EVENT_TEAM, ZoneScript::GetData(), NPC_BISHOP_A, NPC_BISHOP_H, NPC_KING_A, NPC_KING_H, NPC_KNIGHT_A, NPC_KNIGHT_H, NPC_PAWN_A, NPC_PAWN_H, NPC_QUEEN_A, NPC_QUEEN_H, NPC_ROOK_A, NPC_ROOK_H, TEAM_ALLIANCE, and TEAM_HORDE.

Referenced by HandleCheat().

◆ JustSummoned()

void npc_echo_of_medivh::JustSummoned ( Creature * summon )

inlineoverridevirtual

Reimplemented from ScriptedAI.

    {
        _summons.Summon(summon);
    }

References _summons, and SummonList::Summon().

◆ RemoveCheats()

void npc_echo_of_medivh::RemoveCheats ( )

inline

    {
        // Buffs
        for (uint8 row = 0; row < MAX_ROW; ++row)
        {
            for (uint8 col = 0; col < MAX_COL; ++col)
            {
                if (ObjectGuid guid = _boards[row][col].pieceGUID)
                {
                    if (Creature* piece = ObjectAccessor::GetCreature(*me, guid))
                    {
                        piece->RemoveAurasDueToSpell(SPELL_HAND_OF_MEDIVH);
                    }
                }
            }
        }
    }

References _boards, ObjectAccessor::GetCreature(), MAX_COL, MAX_ROW, ScriptedAI::me, and SPELL_HAND_OF_MEDIVH.

◆ Reset()

void npc_echo_of_medivh::Reset ( )

inlineoverridevirtual

Reimplemented from ScriptedAI.

    {
        for (uint8 row = 0; row < MAX_ROW; ++row)
        {
            for (uint8 col = 0; col < MAX_COL; ++col)
            {
                _boards[row][col].Reset();
            }
        }
 
        _summons.DespawnAll();
 
        _cheatTimer = urand(45 * IN_MILLISECONDS, 100 * IN_MILLISECONDS);
    }

References _boards, _cheatTimer, _summons, SummonList::DespawnAll(), IN_MILLISECONDS, MAX_COL, MAX_ROW, and urand().

◆ SetupBoard()

void npc_echo_of_medivh::SetupBoard ( )

inline

    {
        _instance->SetData(DATA_CHESS_REINIT_PIECES, 0);
 
        _summons.DespawnAll();
 
        for (uint8 row = 0; row < MAX_ROW; ++row)
        {
            for (uint8 col = 0; col < MAX_COL; ++col)
            {
                BoardCell& cell = _boards[row][col];
 
                if (Creature* trigger = me->SummonCreature(NPC_CHESS_MOVE_TRIGGER, (-11108.099609f + (3.49f * col) + (4.4f * row)), (-1872.910034f - (4.4f * col) + (3.45f * row)), 220.667f, 0, TEMPSUMMON_MANUAL_DESPAWN, 0))
                {
                    cell.SetData(trigger->GetGUID(), row, col);
                    HandleCellInitialData(row, col, trigger, cell);
                }
            }
        }
 
        _deadCount.fill(0);
    }

References _boards, _deadCount, _instance, _summons, DATA_CHESS_REINIT_PIECES, SummonList::DespawnAll(), HandleCellInitialData(), MAX_COL, MAX_ROW, ScriptedAI::me, NPC_CHESS_MOVE_TRIGGER, BoardCell::SetData(), ZoneScript::SetData(), WorldObject::SummonCreature(), and TEMPSUMMON_MANUAL_DESPAWN.

Referenced by sGossipSelect().

◆ sGossipHello()

void npc_echo_of_medivh::sGossipHello ( Player * player )

inlineoverridevirtual

Reimplemented from UnitAI.

    {
        uint32 chessPhase = _instance->GetData(DATA_CHESS_GAME_PHASE);
        switch (chessPhase)
        {
            case CHESS_PHASE_NOT_STARTED:
                AddGossipItemFor(player, GOSSIP_ICON_CHAT, "We want to play a game against you!", GOSSIP_SENDER_MAIN, MEDIVH_GOSSIP_START_PVE);
                break;
            case CHESS_PHASE_INPROGRESS_PVE:
            case CHESS_PHASE_INPROGRESS_PVP:
                AddGossipItemFor(player, GOSSIP_ICON_CHAT, "Restart", GOSSIP_SENDER_MAIN, MEDIVH_GOSSIP_RESTART); // We want to player another game against you
                break;
            case CHESS_PHASE_PVE_FINISHED:
                AddGossipItemFor(player, GOSSIP_ICON_CHAT, "PvP", GOSSIP_SENDER_MAIN, MEDIVH_GOSSIP_START_PVP); // We'd like to fight each other
                break;
        }
 
        SendGossipMenuFor(player, player->GetGossipTextId(me), me->GetGUID());
    }

References _instance, AddGossipItemFor(), CHESS_PHASE_INPROGRESS_PVE, CHESS_PHASE_INPROGRESS_PVP, CHESS_PHASE_NOT_STARTED, CHESS_PHASE_PVE_FINISHED, DATA_CHESS_GAME_PHASE, ZoneScript::GetData(), Player::GetGossipTextId(), Object::GetGUID(), GOSSIP_ICON_CHAT, GOSSIP_SENDER_MAIN, ScriptedAI::me, MEDIVH_GOSSIP_RESTART, MEDIVH_GOSSIP_START_PVE, MEDIVH_GOSSIP_START_PVP, and SendGossipMenuFor().

◆ sGossipSelect()

void npc_echo_of_medivh::sGossipSelect	(	Player *	player,
		uint32	,
		uint32	gossipListId
	)

inlineoverridevirtual

Reimplemented from UnitAI.

    {
        uint32 chessPhase = _instance->GetData(DATA_CHESS_GAME_PHASE);
        _instance->SetData(CHESS_EVENT_TEAM, chessPhase < CHESS_PHASE_PVE_FINISHED ? player->GetTeamId() : TEAM_NEUTRAL);
 
        CloseGossipMenuFor(player);
 
        uint32 const action = player->PlayerTalkClass->GetGossipOptionAction(gossipListId);
        switch (action)
        {
            case MEDIVH_GOSSIP_START_PVE:
                _instance->SetData(DATA_CHESS_GAME_PHASE, CHESS_PHASE_PVE_WARMUP);
                SetupBoard();
                _instance->SetData(DATA_CHESS_EVENT, IN_PROGRESS);
                Talk(TALK_EVENT_BEGIN);
                break;
            case MEDIVH_GOSSIP_RESTART:
                _instance->SetData(DATA_CHESS_GAME_PHASE, CHESS_PHASE_FAILED);
                _instance->SetData(DATA_CHESS_REINIT_PIECES, 0);
                _deadCount.fill(0);
                if (_instance->GetData(DATA_CHESS_EVENT) == IN_PROGRESS)
                {
                    _instance->SetData(DATA_CHESS_EVENT, NOT_STARTED);
                    _instance->SetData(DATA_CHESS_GAME_PHASE, CHESS_PHASE_NOT_STARTED);
                }
                else if (_instance->GetData(DATA_CHESS_EVENT) == SPECIAL)
                {
                    _instance->SetData(DATA_CHESS_EVENT, DONE);
                    _instance->SetData(DATA_CHESS_GAME_PHASE, CHESS_PHASE_PVE_FINISHED);
                }
                _instance->DoRemoveAurasDueToSpellOnPlayers(SPELL_GAME_IN_SESSION);
                break;
            case MEDIVH_GOSSIP_START_PVP:
                _instance->SetData(DATA_CHESS_GAME_PHASE, CHESS_PHASE_PVP_WARMUP);
                SetupBoard();
                _instance->SetData(DATA_CHESS_EVENT, SPECIAL);
                Talk(TALK_EVENT_BEGIN);
                break;
            default:
                break;
        }
    }

References _deadCount, _instance, CHESS_EVENT_TEAM, CHESS_PHASE_FAILED, CHESS_PHASE_NOT_STARTED, CHESS_PHASE_PVE_FINISHED, CHESS_PHASE_PVE_WARMUP, CHESS_PHASE_PVP_WARMUP, CloseGossipMenuFor(), DATA_CHESS_EVENT, DATA_CHESS_GAME_PHASE, DATA_CHESS_REINIT_PIECES, DONE, InstanceScript::DoRemoveAurasDueToSpellOnPlayers(), ZoneScript::GetData(), PlayerMenu::GetGossipOptionAction(), GetTeamId(), IN_PROGRESS, MEDIVH_GOSSIP_RESTART, MEDIVH_GOSSIP_START_PVE, MEDIVH_GOSSIP_START_PVP, NOT_STARTED, Player::PlayerTalkClass, ZoneScript::SetData(), SetupBoard(), SPECIAL, SPELL_GAME_IN_SESSION, TALK_EVENT_BEGIN, and TEAM_NEUTRAL.

◆ SummonedCreatureDespawn()

void npc_echo_of_medivh::SummonedCreatureDespawn ( Creature * summon )

inlineoverridevirtual

Reimplemented from ScriptedAI.

    {
        _summons.Despawn(summon);
    }

References _summons, and SummonList::Despawn().

◆ UpdateAI()

void npc_echo_of_medivh::UpdateAI ( uint32 diff )

inlineoverridevirtual

Reimplemented from ScriptedAI.

    {
        uint32 chessPhase = _instance->GetData(DATA_CHESS_GAME_PHASE);
        if (chessPhase != CHESS_PHASE_INPROGRESS_PVE && chessPhase != CHESS_PHASE_INPROGRESS_PVP)
            return;
 
        if (chessPhase == CHESS_PHASE_INPROGRESS_PVE)
        {
            if (_cheatTimer <= diff)
            {
                HandleCheat();
                _cheatTimer = urand(45000, 100000);
            }
            else
            {
                _cheatTimer -= diff;
            }
        }
    }

References _cheatTimer, _instance, CHESS_PHASE_INPROGRESS_PVE, CHESS_PHASE_INPROGRESS_PVP, DATA_CHESS_GAME_PHASE, ZoneScript::GetData(), HandleCheat(), and urand().

Member Data Documentation

◆ _boards

std::array<std::array<BoardCell, MAX_COL>, MAX_ROW> npc_echo_of_medivh::_boards

private

Referenced by GetHostileTargetForChangeFacing(), GetPiece(), HandleCheat(), HandlePieceJustDied(), HandlePieceMove(), HandlePieceMoveByAI(), HandlePieceRotate(), RemoveCheats(), Reset(), and SetupBoard().

◆ _cheatTimer

uint32 npc_echo_of_medivh::_cheatTimer

private

Referenced by Reset(), and UpdateAI().

◆ _deadCount

std::array<uint32, 2> npc_echo_of_medivh::_deadCount

private

Referenced by HandlePieceJustDied(), SetupBoard(), and sGossipSelect().

◆ _instance

InstanceScript* npc_echo_of_medivh::_instance

private

Referenced by HandleCheat(), HandlePieceJustDied(), IsMedivhPiece(), npc_echo_of_medivh(), SetupBoard(), sGossipHello(), sGossipSelect(), and UpdateAI().

◆ _summons

SummonList npc_echo_of_medivh::_summons

private

Referenced by JustSummoned(), Reset(), SetupBoard(), and SummonedCreatureDespawn().

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ npc_echo_of_medivh()

Member Function Documentation

◆ CastChangeFacing()

◆ GetHostileTargetForChangeFacing()

◆ GetPiece()

◆ HandleCellInitialData()

◆ HandleCheat()

◆ HandlePieceJustDied()

◆ HandlePieceMove()

◆ HandlePieceMoveByAI()

◆ HandlePieceRotate()

◆ IsMedivhPiece()

◆ JustSummoned()

◆ RemoveCheats()

◆ Reset()

◆ SetupBoard()

◆ sGossipHello()

◆ sGossipSelect()

◆ SummonedCreatureDespawn()

◆ UpdateAI()

Member Data Documentation

◆ _boards

◆ _cheatTimer

◆ _deadCount

◆ _instance

◆ _summons