- Logging System is asyncronous to improve performance.
- Each msg and Logger has a Log Type and Log Level assigned. Each msg is assigned the Logger of same Log Type or "root" Logger is selected if there is no Logger configured for the given Log Type
- Loggers have a list of Appenders to send the msg to. The Msg in the Logger is not sent to Appenders if the msg LogLevel is lower than Logger LogLevel.
- There are three (at the moment) types of Appenders: Console, File or DB (this is WIP, not working ATM). Msg is not written to the resource if msg LogLevel is lower than Appender LogLevel.
- Appender and Console Log levels can be changed while server is active with command '.set loglevel (a/l) name level'
Explanation of use with Sample config:
Appender.Console.Type=1 (1 = Console)
Appender.Console.Level=2 (2 = Debug)
Appender.Server.Type=2 (2 = File)
Appender.Server.Level=3 (3 = Info)
Appender.Server.File=Server.log
Appender.SQL.Type=2 (2 = File)
Appender.SQL.Level=1 (1 = Trace)
Appender.SQL.File=sql.log
Appenders=Console Server (NOTE: SQL has not been included here... that will make core ignore the config for "SQL" as it's not in this list)
Logger.root.Type=0 (0 = Default - if it's not created by config, server will create it with LogLevel = DISABLED)
Logger.root.Level=5 (5 = Error)
Logger.root.Appenders=Console
Logger.SQL.Type=26 (26 = SQL)
Logger.SQL.Level=3 (2 = Debug)
Logger.SQL.Appenders=Console Server SQL
Logger.SomeRandomName.Type=24 (24 = Guild)
Logger.SomeRandomName.Level=5 (5 = Error)
Loggers=root SQL SomeRandomName
* At loading Appender SQL will be ignored, as it's not present on "Appenders"
* sLog->outDebug(LOG_FILTER_GUILD, "Some log msg related to Guilds")
- Msg is sent to Logger of Type LOG_FILTER_GUILD (24). Logger with name SomeRandomName is found but it's LogLevel = 5 and Msg LogLevel=2... Msg is not logged
* sLog->outError(LOG_FILTER_GUILD, "Some error log msg related to Guilds")
- Msg is sent to Logger of Type LOG_FILTER_GUILD (24). Logger with name SomeRandomeName is found with proper LogLevel but Logger does not have any Appenders assigned to that logger... Msg is not logged
* sLog->outDebug(LOG_FILTER_SQL, "Some msg related to SQLs")
- Msg is sent to Logger SQL (matches type), as it matches LogLevel the msg is sent to Appenders Console, Server and SQL
- Appender Console has lower Log Level: Msg is logged to Console
- Appender Server has higher Log Level: Msg is not logged to file
- Appender SQL has lower Log Level: Msg is logged to file sql.log
* sLog->outDebug(LOG_FILTER_BATTLEGROUND, "Some msg related to Battelgrounds")
- Msg is sent to Logger root (Type 0) as no Logger was found with Type LOG_FILTER_BATTLEGROUND (13). As Logger has higher LogLevel msg is not sent to any appender
* sLog->outError(LOG_FILTER_BATTLEGROUND, "Some error msg related to Battelgrounds")
- Msg is sent to Logger root (Type 0) as no Logger was found with Type LOG_FILTER_BATTLEGROUND (13). Msg has lower LogLevel and is sent to Appender Console
- Appender Console has lower LogLevel: Msg is logged to Console
237 lines
8.8 KiB
C++
Executable File
237 lines
8.8 KiB
C++
Executable File
/*
|
|
* Copyright (C) 2008-2012 TrinityCore <http://www.trinitycore.org/>
|
|
* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
* more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef TRINITY_INSTANCE_DATA_H
|
|
#define TRINITY_INSTANCE_DATA_H
|
|
|
|
#include "ZoneScript.h"
|
|
#include "World.h"
|
|
#include "ObjectMgr.h"
|
|
//#include "GameObject.h"
|
|
//#include "Map.h"
|
|
|
|
#define OUT_SAVE_INST_DATA sLog->outDebug(LOG_FILTER_TSCR, "Saving Instance Data for Instance %s (Map %d, Instance Id %d)", instance->GetMapName(), instance->GetId(), instance->GetInstanceId())
|
|
#define OUT_SAVE_INST_DATA_COMPLETE sLog->outDebug(LOG_FILTER_TSCR, "Saving Instance Data for Instance %s (Map %d, Instance Id %d) completed.", instance->GetMapName(), instance->GetId(), instance->GetInstanceId())
|
|
#define OUT_LOAD_INST_DATA(a) sLog->outDebug(LOG_FILTER_TSCR, "Loading Instance Data for Instance %s (Map %d, Instance Id %d). Input is '%s'", instance->GetMapName(), instance->GetId(), instance->GetInstanceId(), a)
|
|
#define OUT_LOAD_INST_DATA_COMPLETE sLog->outDebug(LOG_FILTER_TSCR, "Instance Data Load for Instance %s (Map %d, Instance Id: %d) is complete.", instance->GetMapName(), instance->GetId(), instance->GetInstanceId())
|
|
#define OUT_LOAD_INST_DATA_FAIL sLog->outError(LOG_FILTER_TSCR, "Unable to load Instance Data for Instance %s (Map %d, Instance Id: %d).", instance->GetMapName(), instance->GetId(), instance->GetInstanceId())
|
|
|
|
class Map;
|
|
class Unit;
|
|
class Player;
|
|
class GameObject;
|
|
class Creature;
|
|
|
|
typedef std::set<GameObject*> DoorSet;
|
|
typedef std::set<Creature*> MinionSet;
|
|
|
|
enum EncounterFrameType
|
|
{
|
|
ENCOUNTER_FRAME_ENGAGE = 0,
|
|
ENCOUNTER_FRAME_DISENGAGE = 1,
|
|
ENCOUNTER_FRAME_UPDATE_PRIORITY = 2,
|
|
ENCOUNTER_FRAME_ADD_TIMER = 3,
|
|
ENCOUNTER_FRAME_ENABLE_OBJECTIVE = 4,
|
|
ENCOUNTER_FRAME_UPDATE_OBJECTIVE = 5,
|
|
ENCOUNTER_FRAME_DISABLE_OBJECTIVE = 6,
|
|
ENCOUNTER_FRAME_UNK7 = 7, // Seems to have something to do with sorting the encounter units
|
|
};
|
|
|
|
enum EncounterState
|
|
{
|
|
NOT_STARTED = 0,
|
|
IN_PROGRESS = 1,
|
|
FAIL = 2,
|
|
DONE = 3,
|
|
SPECIAL = 4,
|
|
TO_BE_DECIDED = 5,
|
|
};
|
|
|
|
enum DoorType
|
|
{
|
|
DOOR_TYPE_ROOM = 0, // Door can open if encounter is not in progress
|
|
DOOR_TYPE_PASSAGE = 1, // Door can open if encounter is done
|
|
DOOR_TYPE_SPAWN_HOLE = 2, // Door can open if encounter is in progress, typically used for spawning places
|
|
MAX_DOOR_TYPES,
|
|
};
|
|
|
|
enum BoundaryType
|
|
{
|
|
BOUNDARY_NONE = 0,
|
|
BOUNDARY_N,
|
|
BOUNDARY_S,
|
|
BOUNDARY_E,
|
|
BOUNDARY_W,
|
|
BOUNDARY_NE,
|
|
BOUNDARY_NW,
|
|
BOUNDARY_SE,
|
|
BOUNDARY_SW,
|
|
BOUNDARY_MAX_X = BOUNDARY_N,
|
|
BOUNDARY_MIN_X = BOUNDARY_S,
|
|
BOUNDARY_MAX_Y = BOUNDARY_W,
|
|
BOUNDARY_MIN_Y = BOUNDARY_E,
|
|
};
|
|
|
|
typedef std::map<BoundaryType, float> BossBoundaryMap;
|
|
|
|
struct DoorData
|
|
{
|
|
uint32 entry, bossId;
|
|
DoorType type;
|
|
uint32 boundary;
|
|
};
|
|
|
|
struct MinionData
|
|
{
|
|
uint32 entry, bossId;
|
|
};
|
|
|
|
struct BossInfo
|
|
{
|
|
BossInfo() : state(TO_BE_DECIDED) {}
|
|
EncounterState state;
|
|
DoorSet door[MAX_DOOR_TYPES];
|
|
MinionSet minion;
|
|
BossBoundaryMap boundary;
|
|
};
|
|
|
|
struct DoorInfo
|
|
{
|
|
explicit DoorInfo(BossInfo* _bossInfo, DoorType _type, BoundaryType _boundary)
|
|
: bossInfo(_bossInfo), type(_type), boundary(_boundary) {}
|
|
BossInfo* bossInfo;
|
|
DoorType type;
|
|
BoundaryType boundary;
|
|
};
|
|
|
|
struct MinionInfo
|
|
{
|
|
explicit MinionInfo(BossInfo* _bossInfo) : bossInfo(_bossInfo) {}
|
|
BossInfo* bossInfo;
|
|
};
|
|
|
|
typedef std::multimap<uint32 /*entry*/, DoorInfo> DoorInfoMap;
|
|
typedef std::map<uint32 /*entry*/, MinionInfo> MinionInfoMap;
|
|
|
|
class InstanceScript : public ZoneScript
|
|
{
|
|
public:
|
|
explicit InstanceScript(Map* map) : instance(map), completedEncounters(0) {}
|
|
|
|
virtual ~InstanceScript() {}
|
|
|
|
Map* instance;
|
|
|
|
//On creation, NOT load.
|
|
virtual void Initialize() {}
|
|
|
|
//On load
|
|
virtual void Load(char const* data) { LoadBossState(data); }
|
|
|
|
//When save is needed, this function generates the data
|
|
virtual std::string GetSaveData() { return GetBossSaveData(); }
|
|
|
|
void SaveToDB();
|
|
|
|
virtual void Update(uint32 /*diff*/) {}
|
|
|
|
//Used by the map's CanEnter function.
|
|
//This is to prevent players from entering during boss encounters.
|
|
virtual bool IsEncounterInProgress() const;
|
|
|
|
//Called when a player successfully enters the instance.
|
|
virtual void OnPlayerEnter(Player* /*player*/) {}
|
|
|
|
//Handle open / close objects
|
|
//use HandleGameObject(0, boolen, GO); in OnObjectCreate in instance scripts
|
|
//use HandleGameObject(GUID, boolen, NULL); in any other script
|
|
void HandleGameObject(uint64 guid, bool open, GameObject* go = NULL);
|
|
|
|
//change active state of doors or buttons
|
|
void DoUseDoorOrButton(uint64 guid, uint32 withRestoreTime = 0, bool useAlternativeState = false);
|
|
|
|
//Respawns a GO having negative spawntimesecs in gameobject-table
|
|
void DoRespawnGameObject(uint64 guid, uint32 timeToDespawn = MINUTE);
|
|
|
|
//sends world state update to all players in instance
|
|
void DoUpdateWorldState(uint32 worldstateId, uint32 worldstateValue);
|
|
|
|
// Send Notify to all players in instance
|
|
void DoSendNotifyToInstance(char const* format, ...);
|
|
|
|
// Update Achievement Criteria for all players in instance
|
|
void DoUpdateAchievementCriteria(AchievementCriteriaTypes type, uint32 miscValue1 = 0, uint32 miscValue2 = 0, Unit* unit = NULL);
|
|
|
|
// Start/Stop Timed Achievement Criteria for all players in instance
|
|
void DoStartTimedAchievement(AchievementCriteriaTimedTypes type, uint32 entry);
|
|
void DoStopTimedAchievement(AchievementCriteriaTimedTypes type, uint32 entry);
|
|
|
|
// Remove Auras due to Spell on all players in instance
|
|
void DoRemoveAurasDueToSpellOnPlayers(uint32 spell);
|
|
|
|
// Cast spell on all players in instance
|
|
void DoCastSpellOnPlayers(uint32 spell);
|
|
|
|
// Return wether server allow two side groups or not
|
|
bool ServerAllowsTwoSideGroups() { return sWorld->getBoolConfig(CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP); }
|
|
|
|
virtual bool SetBossState(uint32 id, EncounterState state);
|
|
EncounterState GetBossState(uint32 id) const { return id < bosses.size() ? bosses[id].state : TO_BE_DECIDED; }
|
|
BossBoundaryMap const* GetBossBoundary(uint32 id) const { return id < bosses.size() ? &bosses[id].boundary : NULL; }
|
|
|
|
// Achievement criteria additional requirements check
|
|
// NOTE: not use this if same can be checked existed requirement types from AchievementCriteriaRequirementType
|
|
virtual bool CheckAchievementCriteriaMeet(uint32 /*criteria_id*/, Player const* /*source*/, Unit const* /*target*/ = NULL, uint32 /*miscvalue1*/ = 0);
|
|
|
|
// Checks boss requirements (one boss required to kill other)
|
|
virtual bool CheckRequiredBosses(uint32 /*bossId*/, Player const* /*player*/ = NULL) const { return true; }
|
|
|
|
// Checks encounter state at kill/spellcast
|
|
void UpdateEncounterState(EncounterCreditType type, uint32 creditEntry, Unit* source);
|
|
|
|
// Used only during loading
|
|
void SetCompletedEncountersMask(uint32 newMask) { completedEncounters = newMask; }
|
|
|
|
// Returns completed encounters mask for packets
|
|
uint32 GetCompletedEncounterMask() const { return completedEncounters; }
|
|
|
|
void SendEncounterUnit(uint32 type, Unit* unit = NULL, uint8 param1 = 0, uint8 param2 = 0);
|
|
|
|
virtual void FillInitialWorldStates(WorldPacket& /*data*/) {}
|
|
|
|
protected:
|
|
void SetBossNumber(uint32 number) { bosses.resize(number); }
|
|
void LoadDoorData(DoorData const* data);
|
|
void LoadMinionData(MinionData const* data);
|
|
|
|
void AddDoor(GameObject* door, bool add);
|
|
void AddMinion(Creature* minion, bool add);
|
|
|
|
void UpdateDoorState(GameObject* door);
|
|
void UpdateMinionState(Creature* minion, EncounterState state);
|
|
|
|
std::string LoadBossState(char const* data);
|
|
std::string GetBossSaveData();
|
|
private:
|
|
std::vector<BossInfo> bosses;
|
|
DoorInfoMap doors;
|
|
MinionInfoMap minions;
|
|
uint32 completedEncounters; // completed encounter mask, bit indexes are DungeonEncounter.dbc boss numbers, used for packets
|
|
};
|
|
#endif
|