DarkflameServer/dScripts/BaseSurvivalServer.h

#pragma once
#include "ActivityManager.h"

/**
 * State for each active game
 */
struct GameState {
    std::vector<LWOOBJID> players {};
    std::vector<LWOOBJID> waitingPlayers {};
    uint32_t totalSpawned = 0;
    uint32_t rewardTick = 0;
    uint32_t waveNumber = 1;
};

/**
 * Constants that have to be set for each game
 */
struct Constants {
    uint32_t acceptedDelay = 0;
    uint32_t startDelay = 0;
    uint32_t waveTime = 0;
    uint32_t rewardInterval = 0;
    uint32_t coolDownTime = 0;
    uint32_t mobSet2Wave = 0;
    uint32_t mobSet3Wave = 0;
    uint32_t unlockNetwork3 = 0;
    uint32_t lotPhase = 0;
    bool useMobLots = false;
    std::vector<uint32_t> baseMobsStartTier {};
    std::vector<uint32_t> randMobsStartTier {};
};

/**
 * The lots of the mobs to spawn along with amounts to spawn for each wave
 */
struct MobSets {
    std::map<std::string, std::vector<LOT>> mobLots {};
    std::map<std::string, std::vector<std::vector<std::vector<uint32_t>>>> sets {};
};

struct SpawnerNetwork {
    std::vector<std::string> names {};
    std::string number;
    bool isLocked = false;
    bool isActive = false;
};

struct SpawnerNetworkCollection {
    std::string mobSetName;
    std::vector<SpawnerNetwork> networks {};
};

struct SpawnerNetworks {
    SpawnerNetworkCollection baseNetworks {};
    SpawnerNetworkCollection randomNetworks {};
    SpawnerNetworkCollection rewardNetworks {};
    SpawnerNetworkCollection smashNetworks {};
};

class BaseSurvivalServer : public ActivityManager {
public:
    void OnStartup(Entity* self) override { SetGameVariables(self); BaseStartup(self); };
    void OnPlayerLoaded(Entity* self, Entity* player) override { BasePlayerLoaded(self, player); };
    void OnPlayerExit(Entity* self, Entity* player) override { BasePlayerExit(self, player); };
    void OnFireEventServerSide(Entity *self, Entity *sender, std::string args, int32_t param1, int32_t param2,
                               int32_t param3) override { BaseFireEvent(self, sender, args, param1, param2, param3); };
    void OnPlayerDied(Entity* self, Entity* player) override { BasePlayerDied(self, player); };
    void OnPlayerResurrected(Entity* self, Entity* player) override { BasePlayerResurrected(self, player); };
    void OnMessageBoxResponse(Entity* self, Entity* sender, int32_t button, const std::u16string& identifier,
                              const std::u16string& userData) override
                              { BaseMessageBoxResponse(self, sender, button, identifier, userData); };

    void BasePlayerLoaded(Entity* self, Entity* player);
	void BaseStartup(Entity* self);
	void BasePlayerExit(Entity* self, Entity* player);
	void BaseFireEvent(Entity *self, Entity *sender, const std::string& args, int32_t param1, int32_t param2,
                       int32_t param3);
	void BasePlayerDied(Entity* self, Entity* player);
	void BasePlayerResurrected(Entity* self, Entity* player);
	void BaseMessageBoxResponse(Entity* self, Entity* sender, int32_t button, const std::u16string& identifier, const std::u16string& userData);

	void OnActivityTimerDone(Entity *self, const std::string &name) override;
	void OnActivityTimerUpdate(Entity *self, const std::string &name, float_t remainingTime, float_t elapsedTime) override;
protected:
    virtual Constants GetConstants() { return Constants(); };
    virtual MobSets GetMobSets() { return MobSets(); };
    virtual SpawnerNetworks GetSpawnerNetworks() { return SpawnerNetworks(); };
    virtual std::map<uint32_t, uint32_t> GetMissionsToUpdate() { return {}; };
    GameState state {};

    // Mob set default names
    std::string BaseMobSet = "baseMobSet";
    std::string RandMobSet = "randMobSet";

    // Variable names
    std::u16string WavesStartedVariable = u"wavesStarted";
    std::u16string ShowScoreboardVariable = u"Show_ScoreBoard";
    std::u16string ClearScoreboardVariable = u"Clear_Scoreboard";
    std::u16string DefinePlayerToUIVariable = u"Define_Player_To_UI";
    std::u16string UpdateScoreboardPlayersVariable = u"Update_ScoreBoard_Players.";
    std::u16string PlayerConfirmVariable = u"PlayerConfirm_ScoreBoard.";
    std::u16string PlayersAcceptedVariable = u"playersAccepted";
    std::u16string PlayersReadyVariable = u"playersReady";
    std::u16string BaseMobSetIndexVariable = u"baseMobSetNum";
    std::u16string RandMobSetIndexVariable = u"randMobSetNum";
    std::u16string AcceptedDelayStartedVariable = u"AcceptedDelayStarted";
    std::u16string NumberOfPlayersVariable = u"NumberOfPlayers";
    std::u16string FirstTimeDoneVariable = u"firstTimeDone";
    std::u16string MissionTypeVariable = u"missionType";
    std::u16string StartWaveMessageVariable = u"Start_Wave_Message";
    std::u16string ExitWavesVariable = u"Exit_waves";
    std::u16string UpdateDefaultStartTimerVariable = u"Update_Default_Start_Timer";
    std::u16string UpdateTimerVariable = u"Update_Timer";
    std::u16string IsCooldownVariable = u"isCoolDown";
    std::u16string SpawnMobVariable = u"Spawn_Mob";

    // Timer names
    std::string SpawnTickTimer = "SpawnTick";
    std::string AllAcceptedDelayTimer = "AllAcceptedDelay";
    std::string AcceptedDelayTimer = "AcceptedDelay";
    std::string StartDelayTimer = "StartDelay";
    std::string ClockTickTimer = "ClockTick";
    std::string CoolDownStartTimer = "CoolDownStart";
    std::string CoolDownStopTimer = "CoolDownStop";
    std::string PlaySpawnSoundTimer = "PlaySpawnSound";

    std::string spawnSoundGUID = "{ca36045d-89df-4e96-a317-1e152d226b69}";
private:
    void SetGameVariables(Entity* self);
    static void ResetStats(LWOOBJID player);
    void GameOver(Entity* self);

    void StartWaves(Entity* self);
	static void ActivateSpawnerNetwork(SpawnerNetworkCollection& spawnerNetworkCollection);
    void SpawnerReset(SpawnerNetworkCollection& spawnerNetworkCollection, bool hardReset = true);
    void SpawnerUpdate(Entity* self, SpawnerNetworkCollection& spawnerNetworkCollection, uint32_t amount = 0);
    void SpawnMobs(Entity* self);
    static SpawnerNetwork GetRandomSpawner(SpawnerNetworkCollection& spawnerNetworkCollection);
    std::vector<uint32_t> GetRandomMobSet(SpawnerNetworkCollection& spawnerNetworkCollection, uint32_t setNumber);

    static void SpawnNow(Spawner* spawner, uint32_t amount);

    bool CheckAllPlayersDead();
    void SetPlayerSpawnPoints();
	void UpdateMobLots(SpawnerNetworkCollection& spawnerNetworkCollection);
	void PlayerConfirmed(Entity* self);
	void PlayerAccepted(Entity* self, LWOOBJID playerID);

	Constants constants {};
	MobSets mobSets {};
	SpawnerNetworks spawnerNetworks {};
    std::map<uint32_t, uint32_t> missionsToUpdate {};
};