Arena Replay Module for AzerothCore - Wow wotlk 3.3.5a

ArenaReplay.cpp

//
// Created by romain-p on 17/10/2021.
//
#include "Player.h"
#include "Opcodes.h"
#include "Battleground.h"
#include "BattlegroundMgr.h"
#include "ScriptMgr.h"
#include <unordered_map>


std::vector<Opcodes> watchList = {
        SMSG_NOTIFICATION,
        SMSG_AURA_UPDATE,
        SMSG_WORLD_STATE_UI_TIMER_UPDATE,
        SMSG_COMPRESSED_UPDATE_OBJECT,
        SMSG_AURA_UPDATE_ALL,
        SMSG_NAME_QUERY_RESPONSE,
        SMSG_DESTROY_OBJECT,
        MSG_MOVE_START_FORWARD,
        MSG_MOVE_SET_FACING,
        MSG_MOVE_HEARTBEAT,
        MSG_MOVE_JUMP,
        SMSG_MONSTER_MOVE,
        MSG_MOVE_FALL_LAND,
        SMSG_PERIODICAURALOG,
        SMSG_ARENA_UNIT_DESTROYED,
        MSG_MOVE_START_STRAFE_RIGHT,
        MSG_MOVE_STOP_STRAFE,
        MSG_MOVE_START_STRAFE_LEFT,
        MSG_MOVE_STOP,
        MSG_MOVE_START_BACKWARD,
        MSG_MOVE_START_TURN_LEFT,
        MSG_MOVE_STOP_TURN,
        MSG_MOVE_START_TURN_RIGHT,
        SMSG_SPELL_START,
        SMSG_SPELL_GO,
        SMSG_FORCE_RUN_SPEED_CHANGE,
        SMSG_ATTACKSTART,
        SMSG_POWER_UPDATE,
        SMSG_ATTACKERSTATEUPDATE,
        SMSG_SPELLDAMAGESHIELD,
        SMSG_SPELLHEALLOG,
        SMSG_SPELLENERGIZELOG,
        SMSG_SPELLNONMELEEDAMAGELOG,
        SMSG_ATTACKSTOP,
        SMSG_SPELLLOGEXECUTE,
        SMSG_EMOTE,
        SMSG_SPELL_DELAYED,
        SMSG_AI_REACTION,
        SMSG_PET_NAME_QUERY_RESPONSE,
        SMSG_CANCEL_AUTO_REPEAT,
        SMSG_UPDATE_OBJECT,
        SMSG_FORCE_FLIGHT_SPEED_CHANGE,
        SMSG_GAMEOBJECT_QUERY_RESPONSE,
        SMSG_FORCE_SWIM_SPEED_CHANGE,
        SMSG_GAMEOBJECT_DESPAWN_ANIM,
        SMSG_CANCEL_COMBAT
};


struct PacketRecord {uint32 timestamp; WorldPacket packet;};
struct MatchRecord {BattlegroundTypeId typeId; uint8 arenaTypeId; std::deque<PacketRecord> packets;};
std::unordered_map<uint32, MatchRecord> records;
std::unordered_map<uint64, MatchRecord> loadedReplays;

class ArenaReplayServerScript: public ServerScript {
public:
    ArenaReplayServerScript() : ServerScript("ArenaReplayServerScript") {}


    void OnPacketSend(WorldSession *session, WorldPacket &packet) override {
        if (session == nullptr || session->GetPlayer() == nullptr) return;

        Battleground *bg = session->GetPlayer()->GetBattleground();

        //ignore packet when no bg or casual games
        if (bg == nullptr || !bg->isArena() || !bg->isRated() || bg->isReplay()) return;
        //ignore packets until arena started
        if (bg->GetStatus() != BattlegroundStatus::STATUS_IN_PROGRESS) return;
        //record packets from 1 player of each team
        //iterate just in case a player leaves and used as reference
        for (auto it: bg->GetPlayers()) {
            if (it.second->GetBgTeamId() == session->GetPlayer()->GetBgTeamId()) {
                if (it.second->GetGUID() != session->GetPlayer()->GetGUID())
                    return; else break;
            }
        }
        //ignore packets not in watch list
        if (std::find(watchList.begin(), watchList.end(), packet.GetOpcode()) == watchList.end()) return;

        if (records.find(bg->GetInstanceID()) == records.end())
            records[bg->GetInstanceID()].packets.clear();
        MatchRecord &record = records[bg->GetInstanceID()];

        uint32 timestamp = bg->getAccurateTimeElapsed();
        record.typeId = bg->GetBgTypeID();
        record.arenaTypeId = bg->GetArenaType();

        //push back packet inside queue of matchId 0
        record.packets.push_back({timestamp, /* copy */ WorldPacket(packet)});
    }
};

class ArenaReplayBGScript: public BGScript {
public:
    ArenaReplayBGScript() : BGScript("ArenaReplayBGScript") {}

    void OnBattlegroundUpdate(Battleground *bg, uint32 diff) override {
        //save replay when a ranked arena is terminated
        if (!bg->isReplay() && bg->GetStatus() == BattlegroundStatus::STATUS_WAIT_LEAVE) {
            saveReplay(bg);
            return;
        }

        if (!bg->isReplay() || bg->GetStatus() != BattlegroundStatus::STATUS_IN_PROGRESS) return;

        //retrieve arena replay data
        auto it = loadedReplays.find(bg->replayId());
        if (it == loadedReplays.end()) return;
        MatchRecord &match = it->second;

        //if replay ends or spectator left > free arena replay data and/or kick player
        if (match.packets.empty() || bg->GetPlayers().empty()) {
            loadedReplays.erase(it);

            if (!bg->GetPlayers().empty())
                bg->GetPlayers().begin()->second->LeaveBattleground(bg);
            return;
        }

        //send replay data to spectator
        while(!match.packets.empty() && match.packets.front().timestamp <= bg->getAccurateTimeElapsed()) {
            if (bg->GetPlayers().empty())
                break;
            bg->GetPlayers().begin()->second->GetSession()->SendPacket(&match.packets.front().packet);
            match.packets.pop_front();
        }
    }

    void saveReplay(Battleground *bg) {
        uint32 id = bg->fightId();
        //wait until arena end
        if (id <= 0) return;

        //retrieve replay data
        auto it = records.find(bg->GetInstanceID());
        if (it == records.end()) return;
        MatchRecord &match = it->second;

        /** serialize arena replay data **/
        ByteBuffer buffer;
        uint32 headerSize;
        uint32 timestamp;
        for (auto it: match.packets) {
            headerSize = it.packet.size(); //header 4Bytes packet size
            timestamp = it.timestamp;

            buffer << headerSize; //4 bytes
            buffer << timestamp; //4 bytes
            buffer << it.packet.GetOpcode(); // 2 bytes
            if (headerSize > 0)
                buffer.append(it.packet.contents(), it.packet.size()); // headerSize bytes
        }
        /********************************/

        SQLTransaction tx = CharacterDatabase.BeginTransaction();
        PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_ARENA_REPLAYS);
        stmt->setUInt32(0, id);
        stmt->setUInt32(1, uint32(match.arenaTypeId));
        stmt->setUInt32(2, uint32(match.typeId));
        stmt->setUInt32(3, buffer.size());
        stmt->setBinary(4, buffer.contentAsVector());
        tx->Append(stmt);
        CharacterDatabase.CommitTransaction(tx);

        //prevents duplicates
        bg->setFightId(0);
        records.erase(it);
    }
};

class ReplayGossip : public CreatureScript{
public:

    ReplayGossip() : CreatureScript("ReplayGossip") { }

    bool OnGossipHello(Player *player, Creature *creature) override {
        auto matchIds = loadLast10Replays();
        for (uint32 matchId: matchIds)
            AddGossipItemFor(player, GOSSIP_ICON_BATTLE, "Replay match "+std::to_string(matchId), GOSSIP_SENDER_MAIN, matchId);
        SendGossipMenuFor(player, 1775757, creature->GetGUID());
        return true;
    }

    bool OnGossipSelect(Player *player, Creature *creature, uint32 sender, uint32 action) override {
        player->PlayerTalkClass->ClearMenus();

        replayArenaMatch(player, action);
        CloseGossipMenuFor(player);
        return true;
    }
private:
    bool replayArenaMatch(Player *player, uint32 replayId) {
        auto handler = ChatHandler(player->GetSession());

        if (!loadReplayDataForPlayer(player, replayId))
            return false;

        MatchRecord record = loadedReplays[player->GetGUID()];

        Battleground* bg = sBattlegroundMgr->CreateNewBattleground(record.typeId, 80, 80, ArenaType(2), false);
        if (!bg) {
            handler.PSendSysMessage("Couldn't create arena map!");
            handler.SetSentErrorMessage(true);
            return false;
        }

        bg->toggleReplayArena(player->GetGUID());
        bg->StartBattleground();

        BattlegroundTypeId bgTypeId = bg->GetBgTypeID();

        TeamId teamId = Player::TeamIdForRace(player->getRace());
        player->SetEntryPoint();

        uint32 queueSlot = 0;
        WorldPacket data;
        sBattlegroundMgr->BuildBattlegroundStatusPacket(&data, bg, queueSlot, STATUS_IN_PROGRESS, 0, bg->GetStartTime(), bg->GetArenaType(), teamId);
        player->GetSession()->SendPacket(&data);

        player->SetBattlegroundId(bg->GetInstanceID(), bgTypeId, queueSlot, true, false, teamId);
        sBattlegroundMgr->SendToBattleground(player, bg->GetInstanceID(), bgTypeId);

        handler.PSendSysMessage("Replay begins.");
        return true;
    }
    
    bool loadReplayDataForPlayer(Player *p, uint32 matchId) {
        PreparedStatement *stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_ARENA_REPLAYS);
        stmt->setUInt32(0, matchId);

        PreparedQueryResult result = CharacterDatabase.Query(stmt);
        if (!result) {
            ChatHandler(p->GetSession()).PSendSysMessage("Replay data not found.");
            return false;
        }

        Field* fields = result->Fetch();
        if (!fields) {
            ChatHandler(p->GetSession()).PSendSysMessage("Replay data not found.");
            return false;
        }
        MatchRecord record;
        deserializeMatchData(record, fields);

        loadedReplays[p->GetGUID()] = std::move(record);
        return true;
    }

    std::vector<uint32> loadLast10Replays() {
        std::vector<uint32> records;
        PreparedStatement *stmt = CharacterDatabase.GetPreparedStatement(CHAR_SEL_LAST_10_ARENA_REPLAYS);
        PreparedQueryResult result = CharacterDatabase.Query(stmt);
        if (!result)
            return records;

        do {
            Field* fields = result->Fetch();
            if (!fields)
                return records;

            uint32 matchId = fields[0].GetUInt32();
            records.push_back(matchId);
        } while (result->NextRow());

        return records;
    }

    void deserializeMatchData(MatchRecord &record, Field *fields) {
        record.arenaTypeId = uint8(fields[1].GetUInt32());
        record.typeId = BattlegroundTypeId(fields[2].GetUInt32());


        std::vector<uint8> data = fields[4].GetBinary();
        ByteBuffer buffer;
        buffer.append(&data[0], data.size());

        /** deserialize replay binary data **/
        uint32 packetSize;
        uint32 packetTimestamp;
        uint16 opcode;
        while (buffer.rpos() <= buffer.size() - 1) {
            buffer >> packetSize;
            buffer >> packetTimestamp;
            buffer >> opcode;

            WorldPacket packet(opcode, packetSize);

            if (packetSize > 0) {
                std::vector<uint8> tmp(packetSize, 0);
                buffer.read(&tmp[0], packetSize);
                packet.append(&tmp[0], packetSize);
            }

            record.packets.push_back({packetTimestamp, packet});
        }
    }
};

void addArenaReplayScript() {
    new ArenaReplayServerScript();
    new ArenaReplayBGScript();
    new ReplayGossip();
}

Hey man, do you have the larger context for which this file should exist? (i.e. references to the character stored procs, etc.)?

Hey man, do you have the larger context for which this file should exist? (i.e. references to the character stored procs, etc.)?

Sadly I lost the sources but it's not hard to adapt. It requires a few changes here and there, I couldnt make a PR because it was too much custom.
But the system was working great