Changeset 112

trunk/src/game/AccountMgr.h

r102	r112
51	51
52	52	uint32 GetId(std::string username);
53		~~uint32 GetIdByGUID(const uint64 &guid) const;~~
54	53	uint32 GetSecurity(uint32 acc_id);
55	54	bool GetName(uint32 acc_id, std::string &name);

trunk/src/game/Chat.cpp

r102	r112
39	39	ChatCommand * ChatHandler::getCommandTable()
40	40	{
	41	static ChatCommand accountSetCommandTable[] =
	42	{
	43	{ "addon", SEC_ADMINISTRATOR, true, &ChatHandler::HandleAccountSetAddonCommand, "", NULL },
	44	{ "gmlevel", SEC_CONSOLE, true, &ChatHandler::HandleAccountSetGmLevelCommand, "", NULL },
	45	{ "password", SEC_CONSOLE, true, &ChatHandler::HandleAccountSetPasswordCommand, "", NULL },
	46	{ NULL, 0, false, NULL, "", NULL }
	47	};
	48
	49	static ChatCommand accountCommandTable[] =
	50	{
	51	{ "create", SEC_CONSOLE, true, &ChatHandler::HandleAccountCreateCommand, "", NULL },
	52	{ "delete", SEC_CONSOLE, true, &ChatHandler::HandleAccountDeleteCommand, "", NULL },
	53	{ "onlinelist", SEC_CONSOLE, true, &ChatHandler::HandleAccountOnlineListCommand, "", NULL },
	54	{ "set", SEC_ADMINISTRATOR, true, NULL, "", accountSetCommandTable },
	55	{ "", SEC_PLAYER, false, &ChatHandler::HandleAccountCommand, "", NULL },
	56	{ NULL, 0, false, NULL, "", NULL }
	57	};
	58
	59	static ChatCommand serverSetCommandTable[] =
	60	{
	61	{ "loglevel", SEC_CONSOLE, true, &ChatHandler::HandleServerSetLogLevelCommand, "", NULL },
	62	{ "motd", SEC_ADMINISTRATOR, true, &ChatHandler::HandleServerSetMotdCommand, "", NULL },
	63	{ NULL, 0, false, NULL, "", NULL }
	64	};
	65
41	66	static ChatCommand serverCommandTable[] =
42	67	{
43		{ "idlerestart", SEC_ADMINISTRATOR, &ChatHandler::HandleIdleRestartCommand, "", NULL },
44		{ "idleshutdown", SEC_ADMINISTRATOR, &ChatHandler::HandleIdleShutDownCommand, "", NULL },
45		{ "info", SEC_PLAYER, &ChatHandler::HandleInfoCommand, "", NULL },
46		{ "restart", SEC_ADMINISTRATOR, &ChatHandler::HandleRestartCommand, "", NULL },
47		{ "shutdown", SEC_ADMINISTRATOR, &ChatHandler::HandleShutDownCommand, "", NULL },
48		{ NULL, 0, NULL, "", NULL }
	68	{ "corpses", SEC_GAMEMASTER, true, &ChatHandler::HandleServerCorpsesCommand, "", NULL },
	69	{ "exit", SEC_CONSOLE, true, &ChatHandler::HandleServerExitCommand, "", NULL },
	70	{ "idlerestart", SEC_ADMINISTRATOR, true, &ChatHandler::HandleIdleRestartCommand, "", NULL },
	71	{ "idleshutdown", SEC_ADMINISTRATOR, true, &ChatHandler::HandleIdleShutDownCommand, "", NULL },
	72	{ "info", SEC_PLAYER, true, &ChatHandler::HandleInfoCommand, "", NULL },
	73	{ "motd", SEC_PLAYER, true, &ChatHandler::HandleServerMotdCommand, "", NULL },
	74	{ "restart", SEC_ADMINISTRATOR, true, &ChatHandler::HandleRestartCommand, "", NULL },
	75	{ "shutdown", SEC_ADMINISTRATOR, true, &ChatHandler::HandleShutDownCommand, "", NULL },
	76	{ "set", SEC_ADMINISTRATOR, true, NULL, "", serverSetCommandTable },
	77	{ NULL, 0, false, NULL, "", NULL }
49	78	};
50	79
51	80	static ChatCommand modifyCommandTable[] =
52	81	{
53		{ "hp", SEC_MODERATOR, &ChatHandler::HandleModifyHPCommand, "", NULL },
54		~~{ "mana", SEC_MODERATOR,~~ &ChatHandler::HandleModifyManaCommand, "", NULL },
55		~~{ "rage", SEC_MODERATOR,~~ &ChatHandler::HandleModifyRageCommand, "", NULL },
56		~~{ "energy", SEC_MODERATOR,~~ &ChatHandler::HandleModifyEnergyCommand, "", NULL },
57		~~{ "money", SEC_MODERATOR,~~ &ChatHandler::HandleModifyMoneyCommand, "", NULL },
58		~~{ "speed", SEC_MODERATOR,~~ &ChatHandler::HandleModifySpeedCommand, "", NULL },
59		~~{ "swim", SEC_MODERATOR,~~ &ChatHandler::HandleModifySwimCommand, "", NULL },
60		~~{ "scale", SEC_MODERATOR,~~ &ChatHandler::HandleModifyScaleCommand, "", NULL },
61		~~{ "bit", SEC_MODERATOR,~~ &ChatHandler::HandleModifyBitCommand, "", NULL },
62		~~{ "bwalk", SEC_MODERATOR,~~ &ChatHandler::HandleModifyBWalkCommand, "", NULL },
63		~~{ "fly", SEC_MODERATOR,~~ &ChatHandler::HandleModifyFlyCommand, "", NULL },
64		~~{ "aspeed", SEC_MODERATOR,~~ &ChatHandler::HandleModifyASpeedCommand, "", NULL },
65		~~{ "faction", SEC_MODERATOR,~~ &ChatHandler::HandleModifyFactionCommand, "", NULL },
66		~~{ "spell", SEC_MODERATOR,~~ &ChatHandler::HandleModifySpellCommand, "", NULL },
67		~~{ "tp", SEC_MODERATOR,~~ &ChatHandler::HandleModifyTalentCommand, "", NULL },
68		~~{ "titles", SEC_MODERATOR,~~ &ChatHandler::HandleModifyKnownTitlesCommand, "", NULL },
69		~~{ "mount", SEC_MODERATOR,~~ &ChatHandler::HandleModifyMountCommand, "", NULL },
70		~~{ "honor", SEC_MODERATOR,~~ &ChatHandler::HandleModifyHonorCommand, "", NULL },
71		~~{ "rep", SEC_MODERATOR,~~ &ChatHandler::HandleModifyRepCommand, "", NULL },
72		~~{ "arena", SEC_MODERATOR,~~ &ChatHandler::HandleModifyArenaCommand, "", NULL },
73		~~{ "drunk", SEC_MODERATOR,~~ &ChatHandler::HandleDrunkCommand, "", NULL },
74		~~{ "standstate", SEC_GAMEMASTER,~~ &ChatHandler::HandleStandStateCommand, "", NULL },
75		~~{ "morph", SEC_GAMEMASTER,~~ &ChatHandler::HandleMorphCommand, "", NULL },
76		~~{ NULL, 0,~~ NULL, "", NULL }
	82	{ "hp", SEC_MODERATOR, false, &ChatHandler::HandleModifyHPCommand, "", NULL },
	83	{ "mana", SEC_MODERATOR, false, &ChatHandler::HandleModifyManaCommand, "", NULL },
	84	{ "rage", SEC_MODERATOR, false, &ChatHandler::HandleModifyRageCommand, "", NULL },
	85	{ "energy", SEC_MODERATOR, false, &ChatHandler::HandleModifyEnergyCommand, "", NULL },
	86	{ "money", SEC_MODERATOR, false, &ChatHandler::HandleModifyMoneyCommand, "", NULL },
	87	{ "speed", SEC_MODERATOR, false, &ChatHandler::HandleModifySpeedCommand, "", NULL },
	88	{ "swim", SEC_MODERATOR, false, &ChatHandler::HandleModifySwimCommand, "", NULL },
	89	{ "scale", SEC_MODERATOR, false, &ChatHandler::HandleModifyScaleCommand, "", NULL },
	90	{ "bit", SEC_MODERATOR, false, &ChatHandler::HandleModifyBitCommand, "", NULL },
	91	{ "bwalk", SEC_MODERATOR, false, &ChatHandler::HandleModifyBWalkCommand, "", NULL },
	92	{ "fly", SEC_MODERATOR, false, &ChatHandler::HandleModifyFlyCommand, "", NULL },
	93	{ "aspeed", SEC_MODERATOR, false, &ChatHandler::HandleModifyASpeedCommand, "", NULL },
	94	{ "faction", SEC_MODERATOR, false, &ChatHandler::HandleModifyFactionCommand, "", NULL },
	95	{ "spell", SEC_MODERATOR, false, &ChatHandler::HandleModifySpellCommand, "", NULL },
	96	{ "tp", SEC_MODERATOR, false, &ChatHandler::HandleModifyTalentCommand, "", NULL },
	97	{ "titles", SEC_MODERATOR, false, &ChatHandler::HandleModifyKnownTitlesCommand, "", NULL },
	98	{ "mount", SEC_MODERATOR, false, &ChatHandler::HandleModifyMountCommand, "", NULL },
	99	{ "honor", SEC_MODERATOR, false, &ChatHandler::HandleModifyHonorCommand, "", NULL },
	100	{ "rep", SEC_MODERATOR, false, &ChatHandler::HandleModifyRepCommand, "", NULL },
	101	{ "arena", SEC_MODERATOR, false, &ChatHandler::HandleModifyArenaCommand, "", NULL },
	102	{ "drunk", SEC_MODERATOR, false, &ChatHandler::HandleDrunkCommand, "", NULL },
	103	{ "standstate", SEC_GAMEMASTER, false, &ChatHandler::HandleStandStateCommand, "", NULL },
	104	{ "morph", SEC_GAMEMASTER, false, &ChatHandler::HandleMorphCommand, "", NULL },
	105	{ NULL, 0, false, NULL, "", NULL }
77	106	};
78	107
79	108	static ChatCommand wpCommandTable[] =
80	109	{
81		{ "show", SEC_GAMEMASTER, &ChatHandler::HandleWpShowCommand, "", NULL },
82		{ "add", SEC_GAMEMASTER, &ChatHandler::HandleWpAddCommand, "", NULL },
83		{ "modify", SEC_GAMEMASTER, &ChatHandler::HandleWpModifyCommand, "", NULL },
84		{ "export", SEC_ADMINISTRATOR, &ChatHandler::HandleWpExportCommand, "", NULL },
85		{ "import", SEC_ADMINISTRATOR, &ChatHandler::HandleWpImportCommand, "", NULL },
86		{ NULL, 0, NULL, "", NULL }
87		};
	110	{ "show", SEC_GAMEMASTER, false, &ChatHandler::HandleWpShowCommand, "", NULL },
	111	{ "add", SEC_GAMEMASTER, false, &ChatHandler::HandleWpAddCommand, "", NULL },
	112	{ "modify", SEC_GAMEMASTER, false, &ChatHandler::HandleWpModifyCommand, "", NULL },
	113	{ "export", SEC_ADMINISTRATOR, false, &ChatHandler::HandleWpExportCommand, "", NULL },
	114	{ "import", SEC_ADMINISTRATOR, false, &ChatHandler::HandleWpImportCommand, "", NULL },
	115	{ NULL, 0, false, NULL, "", NULL }
	116	};
	117
	118	static ChatCommand banCommandTable[] =
	119	{
	120	{ "account", SEC_ADMINISTRATOR, true, &ChatHandler::HandleBanAccountCommand, "", NULL },
	121	{ "character", SEC_ADMINISTRATOR, true, &ChatHandler::HandleBanCharacterCommand, "", NULL },
	122	{ "ip", SEC_ADMINISTRATOR, true, &ChatHandler::HandleBanIPCommand, "", NULL },
	123	{ NULL, 0, false, NULL, "", NULL }
	124	};
	125
	126	static ChatCommand baninfoCommandTable[] =
	127	{
	128	{ "account", SEC_ADMINISTRATOR, true, &ChatHandler::HandleBanInfoAccountCommand, "", NULL },
	129	{ "character", SEC_ADMINISTRATOR, true, &ChatHandler::HandleBanInfoCharacterCommand, "", NULL },
	130	{ "ip", SEC_ADMINISTRATOR, true, &ChatHandler::HandleBanInfoIPCommand, "", NULL },
	131	{ NULL, 0, false, NULL, "", NULL }
	132	};
	133
	134	static ChatCommand banlistCommandTable[] =
	135	{
	136	{ "account", SEC_ADMINISTRATOR, true, &ChatHandler::HandleBanListAccountCommand, "", NULL },
	137	{ "character", SEC_ADMINISTRATOR, true, &ChatHandler::HandleBanListCharacterCommand, "", NULL },
	138	{ "ip", SEC_ADMINISTRATOR, true, &ChatHandler::HandleBanListIPCommand, "", NULL },
	139	{ NULL, 0, false, NULL, "", NULL }
	140	};
	141
	142	static ChatCommand unbanCommandTable[] =
	143	{
	144	{ "account", SEC_ADMINISTRATOR, true, &ChatHandler::HandleUnBanAccountCommand, "", NULL },
	145	{ "character", SEC_ADMINISTRATOR, true, &ChatHandler::HandleUnBanCharacterCommand, "", NULL },
	146	{ "ip", SEC_ADMINISTRATOR, true, &ChatHandler::HandleUnBanIPCommand, "", NULL },
	147	{ NULL, 0, false, NULL, "", NULL }
	148	};
88	149
89	150	static ChatCommand debugCommandTable[] =
90	151	{
91		{ "inarc", SEC_ADMINISTRATOR, &ChatHandler::HandleDebugInArcCommand, "", NULL },
92		{ "spellfail", SEC_ADMINISTRATOR, &ChatHandler::HandleDebugSpellFailCommand, "", NULL },
93		{ "setpoi", SEC_ADMINISTRATOR, &ChatHandler::HandleSetPoiCommand, "", NULL },
94		{ "qpartymsg", SEC_ADMINISTRATOR, &ChatHandler::HandleSendQuestPartyMsgCommand, "", NULL },
95		{ "qinvalidmsg", SEC_ADMINISTRATOR, &ChatHandler::HandleSendQuestInvalidMsgCommand, "", NULL },
96		{ "equiperr", SEC_ADMINISTRATOR, &ChatHandler::HandleEquipErrorCommand, "", NULL },
97		{ "sellerr", SEC_ADMINISTRATOR, &ChatHandler::HandleSellErrorCommand, "", NULL },
98		{ "buyerr", SEC_ADMINISTRATOR, &ChatHandler::HandleBuyErrorCommand, "", NULL },
99		{ "sendopcode", SEC_ADMINISTRATOR, &ChatHandler::HandleSendOpcodeCommand, "", NULL },
100		{ "uws", SEC_ADMINISTRATOR, &ChatHandler::HandleUpdateWorldStateCommand, "", NULL },
101		{ "ps", SEC_ADMINISTRATOR, &ChatHandler::HandlePlaySound2Command, "", NULL },
102		{ "scn", SEC_ADMINISTRATOR, &ChatHandler::HandleSendChannelNotifyCommand, "", NULL },
103		{ "scm", SEC_ADMINISTRATOR, &ChatHandler::HandleSendChatMsgCommand, "", NULL },
104		{ "getitemstate", SEC_ADMINISTRATOR, &ChatHandler::HandleGetItemState, "", NULL },
105		{ "playsound", SEC_MODERATOR, &ChatHandler::HandlePlaySoundCommand, "", NULL },
106		{ "update", SEC_ADMINISTRATOR, &ChatHandler::HandleUpdate, "", NULL },
107		{ "setvalue", SEC_ADMINISTRATOR, &ChatHandler::HandleSetValue, "", NULL },
108		{ "getvalue", SEC_ADMINISTRATOR, &ChatHandler::HandleGetValue, "", NULL },
109		{ "Mod32Value", SEC_ADMINISTRATOR, &ChatHandler::HandleMod32Value, "", NULL },
110		{ "anim", SEC_GAMEMASTER, &ChatHandler::HandleAnimCommand, "", NULL },
111		{ "lootrecipient", SEC_GAMEMASTER, &ChatHandler::HandleGetLootRecipient, "", NULL },
112		{ "arena", SEC_ADMINISTRATOR, &ChatHandler::HandleDebugArenaCommand, "", NULL },
113		{ "threatlist", SEC_ADMINISTRATOR, &ChatHandler::HandleDebugThreatList, "", NULL },
114		{ "hostilrefs", SEC_ADMINISTRATOR, &ChatHandler::HandleDebugHostilRefList, "", NULL },
115		{ NULL, 0, NULL, "", NULL }
	152	{ "inarc", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDebugInArcCommand, "", NULL },
	153	{ "spellfail", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDebugSpellFailCommand, "", NULL },
	154	{ "setpoi", SEC_ADMINISTRATOR, false, &ChatHandler::HandleSetPoiCommand, "", NULL },
	155	{ "qpartymsg", SEC_ADMINISTRATOR, false, &ChatHandler::HandleSendQuestPartyMsgCommand, "", NULL },
	156	{ "qinvalidmsg", SEC_ADMINISTRATOR, false, &ChatHandler::HandleSendQuestInvalidMsgCommand, "", NULL },
	157	{ "equiperr", SEC_ADMINISTRATOR, false, &ChatHandler::HandleEquipErrorCommand, "", NULL },
	158	{ "sellerr", SEC_ADMINISTRATOR, false, &ChatHandler::HandleSellErrorCommand, "", NULL },
	159	{ "buyerr", SEC_ADMINISTRATOR, false, &ChatHandler::HandleBuyErrorCommand, "", NULL },
	160	{ "sendopcode", SEC_ADMINISTRATOR, false, &ChatHandler::HandleSendOpcodeCommand, "", NULL },
	161	{ "uws", SEC_ADMINISTRATOR, false, &ChatHandler::HandleUpdateWorldStateCommand, "", NULL },
	162	{ "ps", SEC_ADMINISTRATOR, false, &ChatHandler::HandlePlaySound2Command, "", NULL },
	163	{ "scn", SEC_ADMINISTRATOR, false, &ChatHandler::HandleSendChannelNotifyCommand, "", NULL },
	164	{ "scm", SEC_ADMINISTRATOR, false, &ChatHandler::HandleSendChatMsgCommand, "", NULL },
	165	{ "getitemstate", SEC_ADMINISTRATOR, false, &ChatHandler::HandleGetItemState, "", NULL },
	166	{ "playsound", SEC_MODERATOR, false, &ChatHandler::HandlePlaySoundCommand, "", NULL },
	167	{ "update", SEC_ADMINISTRATOR, false, &ChatHandler::HandleUpdate, "", NULL },
	168	{ "setvalue", SEC_ADMINISTRATOR, false, &ChatHandler::HandleSetValue, "", NULL },
	169	{ "getvalue", SEC_ADMINISTRATOR, false, &ChatHandler::HandleGetValue, "", NULL },
	170	{ "Mod32Value", SEC_ADMINISTRATOR, false, &ChatHandler::HandleMod32Value, "", NULL },
	171	{ "anim", SEC_GAMEMASTER, false, &ChatHandler::HandleAnimCommand, "", NULL },
	172	{ "lootrecipient", SEC_GAMEMASTER, false, &ChatHandler::HandleGetLootRecipient, "", NULL },
	173	{ NULL, 0, false, NULL, "", NULL }
116	174	};
117	175
118	176	static ChatCommand eventCommandTable[] =
119	177	{
120		{ "activelist", SEC_GAMEMASTER, &ChatHandler::HandleEventActiveListCommand, "", NULL },
121		~~{ "start", SEC_GAMEMASTER,~~ &ChatHandler::HandleEventStartCommand, "", NULL },
122		~~{ "stop", SEC_GAMEMASTER,~~ &ChatHandler::HandleEventStopCommand, "", NULL },
123		~~{ "", SEC_GAMEMASTER, &ChatHandler::HandleEventInfoCommand,~~ "", NULL },
124		~~{ NULL, 0,~~ NULL, "", NULL }
	178	{ "activelist", SEC_GAMEMASTER, true, &ChatHandler::HandleEventActiveListCommand, "", NULL },
	179	{ "start", SEC_GAMEMASTER, true, &ChatHandler::HandleEventStartCommand, "", NULL },
	180	{ "stop", SEC_GAMEMASTER, true, &ChatHandler::HandleEventStopCommand, "", NULL },
	181	{ "", SEC_GAMEMASTER, true, &ChatHandler::HandleEventInfoCommand, "", NULL },
	182	{ NULL, 0, false, NULL, "", NULL }
125	183	};
126	184
127	185	static ChatCommand learnCommandTable[] =
128	186	{
129		{ "all", SEC_ADMINISTRATOR, &ChatHandler::HandleLearnAllCommand, "", NULL },
130		~~{ "all_gm", SEC_GAMEMASTER,~~ &ChatHandler::HandleLearnAllGMCommand, "", NULL },
131		~~{ "all_crafts", SEC_GAMEMASTER,~~ &ChatHandler::HandleLearnAllCraftsCommand, "", NULL },
132		~~{ "all_default", SEC_MODERATOR,~~ &ChatHandler::HandleLearnAllDefaultCommand, "", NULL },
133		~~{ "all_lang", SEC_MODERATOR,~~ &ChatHandler::HandleLearnAllLangCommand, "", NULL },
134		~~{ "all_myclass", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleLearnAllMyClassCommand, "", NULL },
135		~~{ "all_myspells", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleLearnAllMySpellsCommand, "", NULL },
136		~~{ "all_mytalents", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleLearnAllMyTalentsCommand, "", NULL },
137		~~{ "all_recipes", SEC_GAMEMASTER,~~ &ChatHandler::HandleLearnAllRecipesCommand, "", NULL },
138		~~{ "", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleLearnCommand, "", NULL },
139		~~{ NULL, 0,~~ NULL, "", NULL }
	187	{ "all", SEC_ADMINISTRATOR, false, &ChatHandler::HandleLearnAllCommand, "", NULL },
	188	{ "all_gm", SEC_GAMEMASTER, false, &ChatHandler::HandleLearnAllGMCommand, "", NULL },
	189	{ "all_crafts", SEC_GAMEMASTER, false, &ChatHandler::HandleLearnAllCraftsCommand, "", NULL },
	190	{ "all_default", SEC_MODERATOR, false, &ChatHandler::HandleLearnAllDefaultCommand, "", NULL },
	191	{ "all_lang", SEC_MODERATOR, false, &ChatHandler::HandleLearnAllLangCommand, "", NULL },
	192	{ "all_myclass", SEC_ADMINISTRATOR, false, &ChatHandler::HandleLearnAllMyClassCommand, "", NULL },
	193	{ "all_myspells", SEC_ADMINISTRATOR, false, &ChatHandler::HandleLearnAllMySpellsCommand, "", NULL },
	194	{ "all_mytalents", SEC_ADMINISTRATOR, false, &ChatHandler::HandleLearnAllMyTalentsCommand, "", NULL },
	195	{ "all_recipes", SEC_GAMEMASTER, false, &ChatHandler::HandleLearnAllRecipesCommand, "", NULL },
	196	{ "", SEC_ADMINISTRATOR, false, &ChatHandler::HandleLearnCommand, "", NULL },
	197	{ NULL, 0, false, NULL, "", NULL }
140	198	};
141	199
142	200	static ChatCommand reloadCommandTable[] =
143	201	{
144		{ "all", ~~SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAllCommand,~~ "", NULL },
145		~~{ "all_loot", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAllLootCommand,~~ "", NULL },
146		~~{ "all_npc", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAllNpcCommand,~~ "", NULL },
147		~~{ "all_quest", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAllQuestCommand,~~ "", NULL },
148		~~{ "all_scripts", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAllScriptsCommand,~~ "", NULL },
149		~~{ "all_spell", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAllSpellCommand,~~ "", NULL },
150		~~{ "all_item", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAllItemCommand,~~ "", NULL },
151		~~{ "all_locales", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAllLocalesCommand,~~ "", NULL },
152
153		~~{ "config", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadConfigCommand,~~ "", NULL },
154
155		~~{ "areatrigger_tavern", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAreaTriggerTavernCommand,~~ "", NULL },
156		~~{ "areatrigger_teleport", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadAreaTriggerTeleportCommand,~~ "", NULL },
157		~~{ "areatrigger_involvedrelation",SEC_ADMINISTRATOR, &ChatHandler::HandleReloadQuestAreaTriggersCommand,~~ "", NULL },
158		~~{ "event_scripts", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadEventScriptsCommand,~~ "", NULL },
159		~~{ "command", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadCommandCommand,~~ "", NULL },
160		~~{ "creature_involvedrelation", SEC_ADMINISTRATOR~~, &ChatHandler::HandleReloadCreatureQuestInvRelationsCommand,"",NULL },
161		~~{ "creature_loot_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLootTemplatesCreatureCommand,~~ "", NULL },
162		~~{ "creature_questrelation", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadCreatureQuestRelationsCommand,~~ "", NULL },
163		~~{ "disenchant_loot_template", SEC_ADMINISTRATOR~~, &ChatHandler::HandleReloadLootTemplatesDisenchantCommand, "", NULL },
164		~~{ "fishing_loot_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLootTemplatesFishingCommand,~~ "", NULL },
165		~~{ "game_graveyard_zone", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadGameGraveyardZoneCommand,~~ "", NULL },
166		~~{ "game_tele", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadGameTeleCommand,~~ "", NULL },
167		~~{ "gameobject_involvedrelation", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadGOQuestInvRelationsCommand,~~ "", NULL },
168		~~{ "gameobject_loot_template", SEC_ADMINISTRATOR~~, &ChatHandler::HandleReloadLootTemplatesGameobjectCommand, "", NULL },
169		~~{ "gameobject_questrelation", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadGOQuestRelationsCommand,~~ "", NULL },
170		~~{ "gameobject_scripts", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadGameObjectScriptsCommand,~~ "", NULL },
171		~~{ "item_enchantment_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadItemEnchantementsCommand,~~ "", NULL },
172		~~{ "item_loot_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLootTemplatesItemCommand,~~ "", NULL },
173		~~{ "trinity_string", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadTrinityStringCommand,~~ "", NULL },
174		~~{ "npc_gossip", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadNpcGossipCommand,~~ "", NULL },
175		~~{ "npc_trainer", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadNpcTrainerCommand,~~ "", NULL },
176		~~{ "npc_vendor", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadNpcVendorCommand,~~ "", NULL },
177		~~{ "page_text", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadPageTextsCommand,~~ "", NULL },
178		~~{ "pickpocketing_loot_template", SEC_ADMINISTRATOR~~, &ChatHandler::HandleReloadLootTemplatesPickpocketingCommand,"",NULL},
179		~~{ "prospecting_loot_template", SEC_ADMINISTRATOR~~, &ChatHandler::HandleReloadLootTemplatesProspectingCommand,"", NULL },
180		~~{ "quest_mail_loot_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLootTemplatesQuestMailCommand,~~ "", NULL },
181		~~{ "quest_end_scripts", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadQuestEndScriptsCommand,~~ "", NULL },
182		~~{ "quest_start_scripts", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadQuestStartScriptsCommand,~~ "", NULL },
183		~~{ "quest_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadQuestTemplateCommand,~~ "", NULL },
184		~~{ "reference_loot_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLootTemplatesReferenceCommand,~~ "", NULL },
185		~~{ "reserved_name", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadReservedNameCommand,~~ "", NULL },
186		~~{ "skill_discovery_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSkillDiscoveryTemplateCommand,~~ "", NULL },
187		~~{ "skill_extra_item_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSkillExtraItemTemplateCommand,~~ "", NULL },
188		~~{ "skill_fishing_base_level", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSkillFishingBaseLevelCommand,~~ "", NULL },
189		~~{ "skinning_loot_template", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLootTemplatesSkinningCommand,~~ "", NULL },
190		~~{ "spell_affect", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellAffectCommand,~~ "", NULL },
191		~~{ "spell_chain", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellChainCommand,~~ "", NULL },
192		~~{ "spell_elixir", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellElixirCommand,~~ "", NULL },
193		~~{ "spell_learn_spell", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellLearnSpellCommand,~~ "", NULL },
194		~~{ "spell_pet_auras", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellPetAurasCommand,~~ "", NULL },
195		~~{ "spell_proc_event", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellProcEventCommand,~~ "", NULL },
196		~~{ "spell_script_target", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellScriptTargetCommand,~~ "", NULL },
197		~~{ "spell_scripts", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellScriptsCommand,~~ "", NULL },
198		~~{ "spell_target_position", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellTargetPositionCommand,~~ "", NULL },
199		~~{ "spell_threats", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellThreatsCommand,~~ "", NULL },
200		~~{ "spell_disabled", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadSpellDisabledCommand,~~ "", NULL },
201		~~{ "locales_creature", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLocalesCreatureCommand,~~ "", NULL },
202		~~{ "locales_gameobject", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLocalesGameobjectCommand,~~ "", NULL },
203		~~{ "locales_item", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLocalesItemCommand,~~ "", NULL },
204		~~{ "locales_npc_text", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLocalesNpcTextCommand,~~ "", NULL },
205		~~{ "locales_page_text", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLocalesPageTextCommand,~~ "", NULL },
206		{ "locales_quest", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadLocalesQuestCommand, "", NULL },
207		~~{ "", SEC_ADMINISTRATOR, &ChatHandler::HandleReloadCommand,~~ "", NULL },
208		~~{ NULL, 0,~~ NULL, "", NULL }
	202	{ "all", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadAllCommand, "", NULL },
	203	{"all_loot", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadAllLootCommand, "", NULL },
	204	{ "all_npc", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadAllNpcCommand, "", NULL },
	205	{ "all_quest", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadAllQuestCommand, "", NULL },
	206	{ "all_scripts", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadAllScriptsCommand, "", NULL },
	207	{ "all_spell", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadAllSpellCommand, "", NULL },
	208	{ "all_item", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadAllItemCommand, "", NULL },
	209	{ "all_locales", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadAllLocalesCommand, "", NULL },
	210
	211	{ "config", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadConfigCommand, "", NULL },
	212
	213	{ "areatrigger_tavern", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadAreaTriggerTavernCommand, "", NULL },
	214	{ "areatrigger_teleport", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadAreaTriggerTeleportCommand, "", NULL },
	215	{ "areatrigger_involvedrelation",SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadQuestAreaTriggersCommand, "", NULL },
	216	{ "event_scripts", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadEventScriptsCommand, "", NULL },
	217	{ "command", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadCommandCommand, "", NULL },
	218	{ "creature_involvedrelation", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadCreatureQuestInvRelationsCommand,"",NULL },
	219	{ "creature_loot_template", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLootTemplatesCreatureCommand, "", NULL },
	220	{ "creature_questrelation", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadCreatureQuestRelationsCommand, "", NULL },
	221	{ "disenchant_loot_template", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLootTemplatesDisenchantCommand, "", NULL },
	222	{ "fishing_loot_template", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLootTemplatesFishingCommand, "", NULL },
	223	{ "game_graveyard_zone", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadGameGraveyardZoneCommand, "", NULL },
	224	{ "game_tele", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadGameTeleCommand, "", NULL },
	225	{ "gameobject_involvedrelation", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadGOQuestInvRelationsCommand, "", NULL },
	226	{ "gameobject_loot_template", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLootTemplatesGameobjectCommand, "", NULL },
	227	{ "gameobject_questrelation", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadGOQuestRelationsCommand, "", NULL },
	228	{ "gameobject_scripts", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadGameObjectScriptsCommand, "", NULL },
	229	{ "item_enchantment_template", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadItemEnchantementsCommand, "", NULL },
	230	{ "item_loot_template", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLootTemplatesItemCommand, "", NULL },
	231	{ "trinity_string", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadTrinityStringCommand, "", NULL },
	232	{ "npc_gossip", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadNpcGossipCommand, "", NULL },
	233	{ "npc_trainer", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadNpcTrainerCommand, "", NULL },
	234	{ "npc_vendor", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadNpcVendorCommand, "", NULL },
	235	{ "page_text", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadPageTextsCommand, "", NULL },
	236	{ "pickpocketing_loot_template", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLootTemplatesPickpocketingCommand,"",NULL},
	237	{ "prospecting_loot_template", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLootTemplatesProspectingCommand,"", NULL },
	238	{ "quest_mail_loot_template", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLootTemplatesQuestMailCommand, "", NULL },
	239	{ "quest_end_scripts", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadQuestEndScriptsCommand, "", NULL },
	240	{ "quest_start_scripts", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadQuestStartScriptsCommand, "", NULL },
	241	{ "quest_template", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadQuestTemplateCommand, "", NULL },
	242	{ "reference_loot_template", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLootTemplatesReferenceCommand, "", NULL },
	243	{ "reserved_name", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadReservedNameCommand, "", NULL },
	244	{ "skill_discovery_template", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadSkillDiscoveryTemplateCommand, "", NULL },
	245	{ "skill_extra_item_template", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadSkillExtraItemTemplateCommand, "", NULL },
	246	{ "skill_fishing_base_level", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadSkillFishingBaseLevelCommand, "", NULL },
	247	{ "skinning_loot_template", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLootTemplatesSkinningCommand, "", NULL },
	248	{ "spell_affect", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadSpellAffectCommand, "", NULL },
	249	{ "spell_chain", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadSpellChainCommand, "", NULL },
	250	{ "spell_elixir", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadSpellElixirCommand, "", NULL },
	251	{ "spell_learn_spell", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadSpellLearnSpellCommand, "", NULL },
	252	{ "spell_pet_auras", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadSpellPetAurasCommand, "", NULL },
	253	{ "spell_proc_event", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadSpellProcEventCommand, "", NULL },
	254	{ "spell_script_target", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadSpellScriptTargetCommand, "", NULL },
	255	{ "spell_scripts", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadSpellScriptsCommand, "", NULL },
	256	{ "spell_target_position", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadSpellTargetPositionCommand, "", NULL },
	257	{ "spell_threats", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadSpellThreatsCommand, "", NULL },
	258	{ "locales_creature", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLocalesCreatureCommand, "", NULL },
	259	{ "locales_gameobject", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLocalesGameobjectCommand, "", NULL },
	260	{ "locales_item", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLocalesItemCommand, "", NULL },
	261	{ "locales_npc_text", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLocalesNpcTextCommand, "", NULL },
	262	{ "locales_page_text", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLocalesPageTextCommand, "", NULL },
	263	{ "locales_quest", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadLocalesQuestCommand, "", NULL },
	264
	265	{ "", SEC_ADMINISTRATOR, true, &ChatHandler::HandleReloadCommand, "", NULL },
	266	{ NULL, 0, false, NULL, "", NULL }
209	267	};
210	268
211	269	static ChatCommand honorCommandTable[] =
212	270	{
213		{ "add", SEC_GAMEMASTER, &ChatHandler::HandleAddHonorCommand, "", NULL },
214		~~{ "addkill", SEC_GAMEMASTER,~~ &ChatHandler::HandleHonorAddKillCommand, "", NULL },
215		~~{ "update", SEC_GAMEMASTER,~~ &ChatHandler::HandleUpdateHonorFieldsCommand, "", NULL },
216		~~{ NULL, 0,~~ NULL, "", NULL }
	271	{ "add", SEC_GAMEMASTER, false, &ChatHandler::HandleAddHonorCommand, "", NULL },
	272	{ "addkill", SEC_GAMEMASTER, false, &ChatHandler::HandleHonorAddKillCommand, "", NULL },
	273	{ "update", SEC_GAMEMASTER, false, &ChatHandler::HandleUpdateHonorFieldsCommand, "", NULL },
	274	{ NULL, 0, false, NULL, "", NULL }
217	275	};
218	276
219	277	static ChatCommand guildCommandTable[] =
220	278	{
221		~~{ "create", SEC_GAMEMASTER,~~ &ChatHandler::HandleGuildCreateCommand, "", NULL },
222		~~{ "delete", SEC_GAMEMASTER,~~ &ChatHandler::HandleGuildDeleteCommand, "", NULL },
223		~~{ "invite", SEC_GAMEMASTER,~~ &ChatHandler::HandleGuildInviteCommand, "", NULL },
224		~~{ "uninvite", SEC_GAMEMASTER,~~ &ChatHandler::HandleGuildUninviteCommand, "", NULL },
225		~~{ "rank", SEC_GAMEMASTER,~~ &ChatHandler::HandleGuildRankCommand, "", NULL },
226		~~{ NULL, 0,~~ NULL, "", NULL }
	279	{ "create", SEC_GAMEMASTER, true, &ChatHandler::HandleGuildCreateCommand, "", NULL },
	280	{ "delete", SEC_GAMEMASTER, true, &ChatHandler::HandleGuildDeleteCommand, "", NULL },
	281	{ "invite", SEC_GAMEMASTER, true, &ChatHandler::HandleGuildInviteCommand, "", NULL },
	282	{ "uninvite", SEC_GAMEMASTER, true, &ChatHandler::HandleGuildUninviteCommand, "", NULL },
	283	{ "rank", SEC_GAMEMASTER, true, &ChatHandler::HandleGuildRankCommand, "", NULL },
	284	{ NULL, 0, false, NULL, "", NULL }
227	285	};
228	286
229	287	static ChatCommand groupCommandTable[] =
230	288	{
231		{ "leader", SEC_ADMINISTRATOR, &ChatHandler::HandleGroupLeaderCommand, "", NULL },
232		{ "disband", SEC_ADMINISTRATOR, &ChatHandler::HandleGroupDisbandCommand, "", NULL },
233		{ "remove", SEC_ADMINISTRATOR, &ChatHandler::HandleGroupRemoveCommand, "", NULL },
234		{ NULL, 0, NULL, "", NULL }
	289	{ "leader", SEC_ADMINISTRATOR, false, &ChatHandler::HandleGroupLeaderCommand, "", NULL },
	290	{ "disband", SEC_ADMINISTRATOR, false, &ChatHandler::HandleGroupDisbandCommand, "", NULL },
	291	{ "remove", SEC_ADMINISTRATOR, false, &ChatHandler::HandleGroupRemoveCommand, "", NULL },
	292	{ NULL, 0, false, NULL, "", NULL }
235	293	};
236	294
237	295	static ChatCommand lookupPlayerCommandTable[] =
238	296	{
239		~~{ "ip", SEC_GAMEMASTER, &ChatHandler::HandleLookupPlayerIpCommand,~~ "", NULL },
240		~~{ "account", SEC_GAMEMASTER, &ChatHandler::HandleLookupPlayerAccountCommand,~~ "", NULL },
241		~~{ "email", SEC_GAMEMASTER, &ChatHandler::HandleLookupPlayerEmailCommand,~~ "", NULL },
242		~~{ NULL, 0,~~ NULL, "", NULL }
	297	{ "ip", SEC_GAMEMASTER, true, &ChatHandler::HandleLookupPlayerIpCommand, "", NULL },
	298	{ "account", SEC_GAMEMASTER, true, &ChatHandler::HandleLookupPlayerAccountCommand, "", NULL },
	299	{ "email", SEC_GAMEMASTER, true, &ChatHandler::HandleLookupPlayerEmailCommand, "", NULL },
	300	{ NULL, 0, false, NULL, "", NULL }
243	301	};
244	302
245	303	static ChatCommand lookupCommandTable[] =
246	304	{
247		{ "area", SEC_MODERATOR, &ChatHandler::HandleLookupAreaCommand, "", NULL },
248		~~{ "creature", SEC_ADMINISTRATOR~~, &ChatHandler::HandleLookupCreatureCommand, "", NULL },
249		~~{ "event", SEC_GAMEMASTER,~~ &ChatHandler::HandleLookupEventCommand, "", NULL },
250		~~{ "faction", SEC_ADMINISTRATOR~~, &ChatHandler::HandleLookupFactionCommand, "", NULL },
251		~~{ "item", SEC_ADMINISTRATOR~~, &ChatHandler::HandleLookupItemCommand, "", NULL },
252		~~{ "itemset", SEC_ADMINISTRATOR~~, &ChatHandler::HandleLookupItemSetCommand, "", NULL },
253		~~{ "object", SEC_ADMINISTRATOR~~, &ChatHandler::HandleLookupObjectCommand, "", NULL },
254		~~{ "quest", SEC_ADMINISTRATOR~~, &ChatHandler::HandleLookupQuestCommand, "", NULL },
255		~~{ "player", SEC_GAMEMASTER,~~ NULL, "", lookupPlayerCommandTable },
256		~~{ "skill", SEC_ADMINISTRATOR~~, &ChatHandler::HandleLookupSkillCommand, "", NULL },
257		~~{ "spell", SEC_ADMINISTRATOR~~, &ChatHandler::HandleLookupSpellCommand, "", NULL },
258		~~{ "tele", SEC_MODERATOR,~~ &ChatHandler::HandleLookupTeleCommand, "", NULL },
259		~~{ NULL, 0,~~ NULL, "", NULL }
	305	{ "area", SEC_MODERATOR, true, &ChatHandler::HandleLookupAreaCommand, "", NULL },
	306	{ "creature", SEC_ADMINISTRATOR, true, &ChatHandler::HandleLookupCreatureCommand, "", NULL },
	307	{ "event", SEC_GAMEMASTER, true, &ChatHandler::HandleLookupEventCommand, "", NULL },
	308	{ "faction", SEC_ADMINISTRATOR, true, &ChatHandler::HandleLookupFactionCommand, "", NULL },
	309	{ "item", SEC_ADMINISTRATOR, true, &ChatHandler::HandleLookupItemCommand, "", NULL },
	310	{ "itemset", SEC_ADMINISTRATOR, true, &ChatHandler::HandleLookupItemSetCommand, "", NULL },
	311	{ "object", SEC_ADMINISTRATOR, true, &ChatHandler::HandleLookupObjectCommand, "", NULL },
	312	{ "quest", SEC_ADMINISTRATOR, true, &ChatHandler::HandleLookupQuestCommand, "", NULL },
	313	{ "player", SEC_GAMEMASTER, true, NULL, "", lookupPlayerCommandTable },
	314	{ "skill", SEC_ADMINISTRATOR, true, &ChatHandler::HandleLookupSkillCommand, "", NULL },
	315	{ "spell", SEC_ADMINISTRATOR, true, &ChatHandler::HandleLookupSpellCommand, "", NULL },
	316	{ "tele", SEC_MODERATOR, true, &ChatHandler::HandleLookupTeleCommand, "", NULL },
	317	{ NULL, 0, false, NULL, "", NULL }
260	318	};
261	319
262	320	static ChatCommand resetCommandTable[] =
263	321	{
264		{ "honor", SEC_ADMINISTRATOR, &ChatHandler::HandleResetHonorCommand, "", NULL },
265		~~{ "level", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleResetLevelCommand, "", NULL },
266		~~{ "spells", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleResetSpellsCommand, "", NULL },
267		~~{ "stats", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleResetStatsCommand, "", NULL },
268		~~{ "talents", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleResetTalentsCommand, "", NULL },
269		~~{ "all", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleResetAllCommand, "", NULL },
270		~~{ NULL, 0,~~ NULL, "", NULL }
	322	{ "honor", SEC_ADMINISTRATOR, false, &ChatHandler::HandleResetHonorCommand, "", NULL },
	323	{ "level", SEC_ADMINISTRATOR, false, &ChatHandler::HandleResetLevelCommand, "", NULL },
	324	{ "spells", SEC_ADMINISTRATOR, false, &ChatHandler::HandleResetSpellsCommand, "", NULL },
	325	{ "stats", SEC_ADMINISTRATOR, false, &ChatHandler::HandleResetStatsCommand, "", NULL },
	326	{ "talents", SEC_ADMINISTRATOR, false, &ChatHandler::HandleResetTalentsCommand, "", NULL },
	327	{ "all", SEC_ADMINISTRATOR, false, &ChatHandler::HandleResetAllCommand, "", NULL },
	328	{ NULL, 0, false, NULL, "", NULL }
271	329	};
272	330
273	331	static ChatCommand castCommandTable[] =
274	332	{
275		{ "back", SEC_ADMINISTRATOR, &ChatHandler::HandleCastBackCommand, "", NULL },
276		~~{ "dist", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleCastDistCommand, "", NULL },
277		~~{ "self", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleCastSelfCommand, "", NULL },
278		~~{ "target", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleCastTargetCommand, "", NULL },
279		~~{ "", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleCastCommand, "", NULL },
280		~~{ NULL, 0,~~ NULL, "", NULL }
	333	{ "back", SEC_ADMINISTRATOR, false, &ChatHandler::HandleCastBackCommand, "", NULL },
	334	{ "dist", SEC_ADMINISTRATOR, false, &ChatHandler::HandleCastDistCommand, "", NULL },
	335	{ "self", SEC_ADMINISTRATOR, false, &ChatHandler::HandleCastSelfCommand, "", NULL },
	336	{ "target", SEC_ADMINISTRATOR, false, &ChatHandler::HandleCastTargetCommand, "", NULL },
	337	{ "", SEC_ADMINISTRATOR, false, &ChatHandler::HandleCastCommand, "", NULL },
	338	{ NULL, 0, false, NULL, "", NULL }
281	339	};
282	340
283	341	static ChatCommand pdumpCommandTable[] =
284	342	{
285		{ "load", SEC_ADMINISTRATOR, &ChatHandler::HandleLoadPDumpCommand, "", NULL },
286		~~{ "write", SEC_ADMINISTRATOR~~, &ChatHandler::HandleWritePDumpCommand, "", NULL },
287		~~{ NULL, 0,~~ NULL, "", NULL }
	343	{ "load", SEC_ADMINISTRATOR, true, &ChatHandler::HandleLoadPDumpCommand, "", NULL },
	344	{ "write", SEC_ADMINISTRATOR, true, &ChatHandler::HandleWritePDumpCommand, "", NULL },
	345	{ NULL, 0, false, NULL, "", NULL }
288	346	};
289	347
290	348	static ChatCommand listCommandTable[] =
291	349	{
292		{ "creature", SEC_ADMINISTRATOR, &ChatHandler::HandleListCreatureCommand, "", NULL },
293		~~{ "item", SEC_ADMINISTRATOR~~, &ChatHandler::HandleListItemCommand, "", NULL },
294		~~{ "object", SEC_ADMINISTRATOR~~, &ChatHandler::HandleListObjectCommand, "", NULL },
295		~~{ "auras", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleListAurasCommand, "", NULL },
296		~~{ NULL, 0,~~ NULL, "", NULL }
	350	{ "creature", SEC_ADMINISTRATOR, true, &ChatHandler::HandleListCreatureCommand, "", NULL },
	351	{ "item", SEC_ADMINISTRATOR, true, &ChatHandler::HandleListItemCommand, "", NULL },
	352	{ "object", SEC_ADMINISTRATOR, true, &ChatHandler::HandleListObjectCommand, "", NULL },
	353	{ "auras", SEC_ADMINISTRATOR, false, &ChatHandler::HandleListAurasCommand, "", NULL },
	354	{ NULL, 0, false, NULL, "", NULL }
297	355	};
298	356
299	357	static ChatCommand teleCommandTable[] =
300	358	{
301		{ "add", SEC_ADMINISTRATOR, &ChatHandler::HandleAddTeleCommand, "", NULL },
302		~~{ "del", SEC_ADMINISTRATOR~~, &ChatHandler::HandleDelTeleCommand, "", NULL },
303		~~{ "name", SEC_MODERATOR,~~ &ChatHandler::HandleNameTeleCommand, "", NULL },
304		~~{ "group", SEC_MODERATOR,~~ &ChatHandler::HandleGroupTeleCommand, "", NULL },
305		~~{ "", SEC_MODERATOR,~~ &ChatHandler::HandleTeleCommand, "", NULL },
306		~~{ NULL, 0,~~ NULL, "", NULL }
	359	{ "add", SEC_ADMINISTRATOR, false, &ChatHandler::HandleAddTeleCommand, "", NULL },
	360	{ "del", SEC_ADMINISTRATOR, true, &ChatHandler::HandleDelTeleCommand, "", NULL },
	361	{ "name", SEC_MODERATOR, true, &ChatHandler::HandleNameTeleCommand, "", NULL },
	362	{ "group", SEC_MODERATOR, false, &ChatHandler::HandleGroupTeleCommand, "", NULL },
	363	{ "", SEC_MODERATOR, false, &ChatHandler::HandleTeleCommand, "", NULL },
	364	{ NULL, 0, false, NULL, "", NULL }
307	365	};
308	366
309	367	static ChatCommand npcCommandTable[] =
310	368	{
311		{ "say", SEC_MODERATOR, &ChatHandler::HandleSayCommand, "", NULL },
312		~~{ "whisper", SEC_MODERATOR,~~ &ChatHandler::HandleNpcWhisperCommand, "", NULL },
313		~~{ "yell", SEC_MODERATOR,~~ &ChatHandler::HandleYellCommand, "", NULL },
314		~~{ "textemote", SEC_MODERATOR,~~ &ChatHandler::HandleTextEmoteCommand, "", NULL },
315		~~{ "add", SEC_GAMEMASTER,~~ &ChatHandler::HandleAddSpwCommand, "", NULL },
316		~~{ "delete", SEC_GAMEMASTER,~~ &ChatHandler::HandleDelCreatureCommand, "", NULL },
317		~~{ "spawndist", SEC_GAMEMASTER,~~ &ChatHandler::HandleSpawnDistCommand, "", NULL },
318		~~{ "spawntime", SEC_GAMEMASTER,~~ &ChatHandler::HandleSpawnTimeCommand, "", NULL },
319		~~{ "factionid", SEC_GAMEMASTER,~~ &ChatHandler::HandleFactionIdCommand, "", NULL },
320		~~{ "addmove", SEC_GAMEMASTER,~~ &ChatHandler::HandleAddMoveCommand, "", NULL },
321		~~{ "setmovetype", SEC_GAMEMASTER,~~ &ChatHandler::HandleSetMoveTypeCommand, "", NULL },
322		~~{ "move", SEC_GAMEMASTER,~~ &ChatHandler::HandleMoveCreatureCommand, "", NULL },
323		~~{ "changelevel", SEC_GAMEMASTER,~~ &ChatHandler::HandleChangeLevelCommand, "", NULL },
324		~~{ "setmodel", SEC_GAMEMASTER,~~ &ChatHandler::HandleSetModelCommand, "", NULL },
325		~~{ "additem", SEC_GAMEMASTER,~~ &ChatHandler::HandleAddVendorItemCommand, "", NULL },
326		~~{ "delitem", SEC_GAMEMASTER,~~ &ChatHandler::HandleDelVendorItemCommand, "", NULL },
327		~~{ "flag", SEC_GAMEMASTER,~~ &ChatHandler::HandleNPCFlagCommand, "", NULL },
328		~~{ "changeentry", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleChangeEntryCommand, "", NULL },
329		~~{ "info", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleNpcInfoCommand, "", NULL },
330		~~{ "playemote", SEC_ADMINISTRATOR,~~ &ChatHandler::HandlePlayEmoteCommand, "", NULL },
	369	{ "say", SEC_MODERATOR, false, &ChatHandler::HandleSayCommand, "", NULL },
	370	{ "whisper", SEC_MODERATOR, false, &ChatHandler::HandleNpcWhisperCommand, "", NULL },
	371	{ "yell", SEC_MODERATOR, false, &ChatHandler::HandleYellCommand, "", NULL },
	372	{ "textemote", SEC_MODERATOR, false, &ChatHandler::HandleTextEmoteCommand, "", NULL },
	373	{ "add", SEC_GAMEMASTER, false, &ChatHandler::HandleAddSpwCommand, "", NULL },
	374	{ "delete", SEC_GAMEMASTER, false, &ChatHandler::HandleDelCreatureCommand, "", NULL },
	375	{ "spawndist", SEC_GAMEMASTER, false, &ChatHandler::HandleSpawnDistCommand, "", NULL },
	376	{ "spawntime", SEC_GAMEMASTER, false, &ChatHandler::HandleSpawnTimeCommand, "", NULL },
	377	{ "factionid", SEC_GAMEMASTER, false, &ChatHandler::HandleFactionIdCommand, "", NULL },
	378	{ "addmove", SEC_GAMEMASTER, false, &ChatHandler::HandleAddMoveCommand, "", NULL },
	379	{ "setmovetype", SEC_GAMEMASTER, false, &ChatHandler::HandleSetMoveTypeCommand, "", NULL },
	380	{ "move", SEC_GAMEMASTER, false, &ChatHandler::HandleMoveCreatureCommand, "", NULL },
	381	{ "changelevel", SEC_GAMEMASTER, false, &ChatHandler::HandleChangeLevelCommand, "", NULL },
	382	{ "setmodel", SEC_GAMEMASTER, false, &ChatHandler::HandleSetModelCommand, "", NULL },
	383	{ "additem", SEC_GAMEMASTER, false, &ChatHandler::HandleAddVendorItemCommand, "", NULL },
	384	{ "delitem", SEC_GAMEMASTER, false, &ChatHandler::HandleDelVendorItemCommand, "", NULL },
	385	{ "flag", SEC_GAMEMASTER, false, &ChatHandler::HandleNPCFlagCommand, "", NULL },
	386	{ "changeentry", SEC_ADMINISTRATOR, false, &ChatHandler::HandleChangeEntryCommand, "", NULL },
	387	{ "info", SEC_ADMINISTRATOR, false, &ChatHandler::HandleNpcInfoCommand, "", NULL },
	388	{ "playemote", SEC_ADMINISTRATOR, false, &ChatHandler::HandlePlayEmoteCommand, "", NULL },
331	389
332	390	//{ TODO: fix or remove this commands
333		{ "name", SEC_GAMEMASTER, &ChatHandler::HandleNameCommand, "", NULL },
334		~~{ "subname", SEC_GAMEMASTER,~~ &ChatHandler::HandleSubNameCommand, "", NULL },
335		~~{ "addweapon", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleAddWeaponCommand, "", NULL },
	391	{ "name", SEC_GAMEMASTER, false, &ChatHandler::HandleNameCommand, "", NULL },
	392	{ "subname", SEC_GAMEMASTER, false, &ChatHandler::HandleSubNameCommand, "", NULL },
	393	{ "addweapon", SEC_ADMINISTRATOR, false, &ChatHandler::HandleAddWeaponCommand, "", NULL },
336	394	//}
337	395
338		{ NULL, 0, NULL, "", NULL }
	396	{ NULL, 0, false, NULL, "", NULL }
339	397	};
340	398
341	399	static ChatCommand goCommandTable[] =
342	400	{
343		{ "grid", SEC_MODERATOR, &ChatHandler::HandleGoGridCommand, "", NULL },
344		~~{ "creature", SEC_GAMEMASTER,~~ &ChatHandler::HandleGoCreatureCommand, "", NULL },
345		~~{ "object", SEC_GAMEMASTER,~~ &ChatHandler::HandleGoObjectCommand, "", NULL },
346		~~{ "trigger", SEC_GAMEMASTER,~~ &ChatHandler::HandleGoTriggerCommand, "", NULL },
347		~~{ "graveyard", SEC_GAMEMASTER,~~ &ChatHandler::HandleGoGraveyardCommand, "", NULL },
348		~~{ "zonexy", SEC_MODERATOR,~~ &ChatHandler::HandleGoZoneXYCommand, "", NULL },
349		~~{ "xy", SEC_MODERATOR,~~ &ChatHandler::HandleGoXYCommand, "", NULL },
350		~~{ "xyz", SEC_MODERATOR,~~ &ChatHandler::HandleGoXYZCommand, "", NULL },
351		~~{ "", SEC_MODERATOR,~~ &ChatHandler::HandleGoXYZCommand, "", NULL },
352		~~{ NULL, 0,~~ NULL, "", NULL }
	401	{ "grid", SEC_MODERATOR, false, &ChatHandler::HandleGoGridCommand, "", NULL },
	402	{ "creature", SEC_GAMEMASTER, false, &ChatHandler::HandleGoCreatureCommand, "", NULL },
	403	{ "object", SEC_GAMEMASTER, false, &ChatHandler::HandleGoObjectCommand, "", NULL },
	404	{ "trigger", SEC_GAMEMASTER, false, &ChatHandler::HandleGoTriggerCommand, "", NULL },
	405	{ "graveyard", SEC_GAMEMASTER, false, &ChatHandler::HandleGoGraveyardCommand, "", NULL },
	406	{ "zonexy", SEC_MODERATOR, false, &ChatHandler::HandleGoZoneXYCommand, "", NULL },
	407	{ "xy", SEC_MODERATOR, false, &ChatHandler::HandleGoXYCommand, "", NULL },
	408	{ "xyz", SEC_MODERATOR, false, &ChatHandler::HandleGoXYZCommand, "", NULL },
	409	{ "", SEC_MODERATOR, false, &ChatHandler::HandleGoXYZCommand, "", NULL },
	410	{ NULL, 0, false, NULL, "", NULL }
353	411	};
354	412
355	413	static ChatCommand gobjectCommandTable[] =
356	414	{
357		{ "add", SEC_GAMEMASTER, &ChatHandler::HandleGameObjectCommand, "", NULL },
358		{ "delete", SEC_GAMEMASTER, &ChatHandler::HandleDelObjectCommand, "", NULL },
359		{ "target", SEC_GAMEMASTER, &ChatHandler::HandleTargetObjectCommand, "", NULL },
360		{ "turn", SEC_GAMEMASTER, &ChatHandler::HandleTurnObjectCommand, "", NULL },
361		{ "move", SEC_GAMEMASTER, &ChatHandler::HandleMoveObjectCommand, "", NULL },
362		{ "near", SEC_ADMINISTRATOR, &ChatHandler::HandleNearObjectCommand, "", NULL },
363		{ "state", SEC_ADMINISTRATOR, &ChatHandler::HandleObjectStateCommand, "", NULL },
364		{ NULL, 0, NULL, "", NULL }
	415	{ "add", SEC_GAMEMASTER, false, &ChatHandler::HandleGameObjectCommand, "", NULL },
	416	{ "delete", SEC_GAMEMASTER, false, &ChatHandler::HandleDelObjectCommand, "", NULL },
	417	{ "target", SEC_GAMEMASTER, false, &ChatHandler::HandleTargetObjectCommand, "", NULL },
	418	{ "turn", SEC_GAMEMASTER, false, &ChatHandler::HandleTurnObjectCommand, "", NULL },
	419	{ "move", SEC_GAMEMASTER, false, &ChatHandler::HandleMoveObjectCommand, "", NULL },
	420	{ "near", SEC_ADMINISTRATOR, false, &ChatHandler::HandleNearObjectCommand, "", NULL },
	421	{ NULL, 0, false, NULL, "", NULL }
365	422	};
366	423
367	424	static ChatCommand questCommandTable[] =
368	425	{
369		{ "add", SEC_ADMINISTRATOR, &ChatHandler::HandleAddQuest, "", NULL },
370		~~{ "complete", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleCompleteQuest, "", NULL },
371		~~{ "remove", SEC_ADMINISTRATOR,~~ &ChatHandler::HandleRemoveQuest, "", NULL },
372		~~{ NULL, 0,~~ NULL, "", NULL }
	426	{ "add", SEC_ADMINISTRATOR, false, &ChatHandler::HandleAddQuest, "", NULL },
	427	{ "complete", SEC_ADMINISTRATOR, false, &ChatHandler::HandleCompleteQuest, "", NULL },
	428	{ "remove", SEC_ADMINISTRATOR, false, &ChatHandler::HandleRemoveQuest, "", NULL },
	429	{ NULL, 0, false, NULL, "", NULL }
373	430	};
374	431
375	432	static ChatCommand gmCommandTable[] =
376	433	{
377		{ "chat", SEC_MODERATOR, &ChatHandler::HandleGMChatCommand, "", NULL },
378		{ "list", SEC_PLAYER, &ChatHandler::HandleGMListCommand, "", NULL },
379		{ "visible", SEC_MODERATOR, &ChatHandler::HandleVisibleCommand, "", NULL },
380		{ "fly", SEC_ADMINISTRATOR, &ChatHandler::HandleFlyModeCommand, "", NULL },
381		{ "", SEC_MODERATOR, &ChatHandler::HandleGMmodeCommand, "", NULL },
382		{ NULL, 0, NULL, "", NULL }
	434	{ "chat", SEC_MODERATOR, false, &ChatHandler::HandleGMChatCommand, "", NULL },
	435	{ "ingame", SEC_PLAYER, true, &ChatHandler::HandleGMListIngameCommand, "", NULL },
	436	{ "list", SEC_ADMINISTRATOR, true, &ChatHandler::HandleGMListFullCommand, "", NULL },
	437	{ "visible", SEC_MODERATOR, false, &ChatHandler::HandleVisibleCommand, "", NULL },
	438	{ "fly", SEC_ADMINISTRATOR, false, &ChatHandler::HandleFlyModeCommand, "", NULL },
	439	{ "", SEC_MODERATOR, false, &ChatHandler::HandleGMmodeCommand, "", NULL },
	440	{ NULL, 0, false, NULL, "", NULL }
383	441	};
384	442
385	443	static ChatCommand instanceCommandTable[] =
386	444	{
387		~~{ "listbinds", SEC_MODERATOR,~~ &ChatHandler::HandleInstanceListBindsCommand, "", NULL },
388		~~{ "unbind", SEC_MODERATOR,~~ &ChatHandler::HandleInstanceUnbindCommand, "", NULL },
389		~~{ "stats", SEC_MODERATOR,~~ &ChatHandler::HandleInstanceStatsCommand, "", NULL },
390		~~{ "savedata", SEC_MODERATOR,~~ &ChatHandler::HandleInstanceSaveDataCommand, "", NULL },
391		~~{ NULL, 0,~~ NULL, "", NULL }
	445	{ "listbinds", SEC_MODERATOR, false, &ChatHandler::HandleInstanceListBindsCommand, "", NULL },
	446	{ "unbind", SEC_MODERATOR, false, &ChatHandler::HandleInstanceUnbindCommand, "", NULL },
	447	{ "stats", SEC_MODERATOR, true, &ChatHandler::HandleInstanceStatsCommand, "", NULL },
	448	{ "savedata", SEC_MODERATOR, false, &ChatHandler::HandleInstanceSaveDataCommand, "", NULL },
	449	{ NULL, 0, false, NULL, "", NULL }
392	450	};
393	451
394	452	static ChatCommand commandTable[] =
395	453	{
396		{ "gm", SEC_MODERATOR, NULL, "", gmCommandTable },
397		{ "npc", SEC_MODERATOR, NULL, "", npcCommandTable },
398		{ "go", SEC_MODERATOR, NULL, "", goCommandTable },
399		{ "learn", SEC_MODERATOR, NULL, "", learnCommandTable },
400		{ "modify", SEC_MODERATOR, NULL, "", modifyCommandTable },
401		{ "debug", SEC_MODERATOR, NULL, "", debugCommandTable },
402		{ "tele", SEC_MODERATOR, NULL, "", teleCommandTable },
403		{ "event", SEC_GAMEMASTER, NULL, "", eventCommandTable },
404		{ "gobject", SEC_GAMEMASTER, NULL, "", gobjectCommandTable },
405		{ "honor", SEC_GAMEMASTER, NULL, "", honorCommandTable },
406		{ "wp", SEC_GAMEMASTER, NULL, "", wpCommandTable },
407		{ "quest", SEC_ADMINISTRATOR, NULL, "", questCommandTable },
408		{ "reload", SEC_ADMINISTRATOR, NULL, "", reloadCommandTable },
409		{ "list", SEC_ADMINISTRATOR, NULL, "", listCommandTable },
410		{ "lookup", SEC_ADMINISTRATOR, NULL, "", lookupCommandTable },
411		{ "pdump", SEC_ADMINISTRATOR, NULL, "", pdumpCommandTable },
412		{ "group", SEC_ADMINISTRATOR, NULL, "", groupCommandTable },
413		{ "guild", SEC_ADMINISTRATOR, NULL, "", guildCommandTable },
414		{ "cast", SEC_ADMINISTRATOR, NULL, "", castCommandTable },
415		{ "reset", SEC_ADMINISTRATOR, NULL, "", resetCommandTable },
416		{ "instance", SEC_ADMINISTRATOR, NULL, "", instanceCommandTable },
417		{ "server", SEC_ADMINISTRATOR, NULL, "", serverCommandTable },
418
419		{ "aura", SEC_ADMINISTRATOR, &ChatHandler::HandleAuraCommand, "", NULL },
420		{ "unaura", SEC_ADMINISTRATOR, &ChatHandler::HandleUnAuraCommand, "", NULL },
421		{ "acct", SEC_PLAYER, &ChatHandler::HandleAcctCommand, "", NULL },
422		{ "nameannounce", SEC_MODERATOR, &ChatHandler::HandleNameAnnounceCommand, "", NULL },
423		{ "announce", SEC_ADMINISTRATOR, &ChatHandler::HandleAnnounceCommand, "", NULL },
424		{ "notify", SEC_MODERATOR, &ChatHandler::HandleNotifyCommand, "", NULL },
425		{ "goname", SEC_MODERATOR, &ChatHandler::HandleGonameCommand, "", NULL },
426		{ "namego", SEC_MODERATOR, &ChatHandler::HandleNamegoCommand, "", NULL },
427		{ "groupgo", SEC_MODERATOR, &ChatHandler::HandleGroupgoCommand, "", NULL },
428		{ "commands", SEC_PLAYER, &ChatHandler::HandleCommandsCommand, "", NULL },
429		{ "demorph", SEC_GAMEMASTER, &ChatHandler::HandleDeMorphCommand, "", NULL },
430		{ "die", SEC_ADMINISTRATOR, &ChatHandler::HandleDieCommand, "", NULL },
431		{ "revive", SEC_ADMINISTRATOR, &ChatHandler::HandleReviveCommand, "", NULL },
432		{ "dismount", SEC_PLAYER, &ChatHandler::HandleDismountCommand, "", NULL },
433		{ "gps", SEC_MODERATOR, &ChatHandler::HandleGPSCommand, "", NULL },
434		{ "guid", SEC_GAMEMASTER, &ChatHandler::HandleGUIDCommand, "", NULL },
435		{ "help", SEC_PLAYER, &ChatHandler::HandleHelpCommand, "", NULL },
436		{ "itemmove", SEC_GAMEMASTER, &ChatHandler::HandleItemMoveCommand, "", NULL },
437		{ "cooldown", SEC_ADMINISTRATOR, &ChatHandler::HandleCooldownCommand, "", NULL },
438		{ "unlearn", SEC_ADMINISTRATOR, &ChatHandler::HandleUnLearnCommand, "", NULL },
439		{ "distance", SEC_ADMINISTRATOR, &ChatHandler::HandleGetDistanceCommand, "", NULL },
440		{ "recall", SEC_MODERATOR, &ChatHandler::HandleRecallCommand, "", NULL },
441		{ "save", SEC_PLAYER, &ChatHandler::HandleSaveCommand, "", NULL },
442		{ "saveall", SEC_MODERATOR, &ChatHandler::HandleSaveAllCommand, "", NULL },
443		{ "kick", SEC_GAMEMASTER, &ChatHandler::HandleKickPlayerCommand, "", NULL },
444		{ "security", SEC_ADMINISTRATOR, &ChatHandler::HandleSecurityCommand, "", NULL },
445		{ "ban", SEC_ADMINISTRATOR, &ChatHandler::HandleBanCommand, "", NULL },
446		{ "unban", SEC_ADMINISTRATOR, &ChatHandler::HandleUnBanCommand, "", NULL },
447		{ "baninfo", SEC_ADMINISTRATOR, &ChatHandler::HandleBanInfoCommand, "", NULL },
448		{ "banlist", SEC_ADMINISTRATOR, &ChatHandler::HandleBanListCommand, "", NULL },
449		{ "plimit", SEC_ADMINISTRATOR, &ChatHandler::HandlePLimitCommand, "", NULL },
450		{ "start", SEC_PLAYER, &ChatHandler::HandleStartCommand, "", NULL },
451		{ "taxicheat", SEC_MODERATOR, &ChatHandler::HandleTaxiCheatCommand, "", NULL },
452		{ "allowmove", SEC_ADMINISTRATOR, &ChatHandler::HandleAllowMovementCommand, "", NULL },
453		{ "linkgrave", SEC_ADMINISTRATOR, &ChatHandler::HandleLinkGraveCommand, "", NULL },
454		{ "neargrave", SEC_ADMINISTRATOR, &ChatHandler::HandleNearGraveCommand, "", NULL },
455		{ "transport", SEC_ADMINISTRATOR, &ChatHandler::HandleSpawnTransportCommand, "", NULL },
456		{ "explorecheat", SEC_ADMINISTRATOR, &ChatHandler::HandleExploreCheatCommand, "", NULL },
457		{ "hover", SEC_ADMINISTRATOR, &ChatHandler::HandleHoverCommand, "", NULL },
458		{ "levelup", SEC_ADMINISTRATOR, &ChatHandler::HandleLevelUpCommand, "", NULL },
459		{ "showarea", SEC_ADMINISTRATOR, &ChatHandler::HandleShowAreaCommand, "", NULL },
460		{ "hidearea", SEC_ADMINISTRATOR, &ChatHandler::HandleHideAreaCommand, "", NULL },
461		{ "additem", SEC_ADMINISTRATOR, &ChatHandler::HandleAddItemCommand, "", NULL },
462		{ "additemset", SEC_ADMINISTRATOR, &ChatHandler::HandleAddItemSetCommand, "", NULL },
463		{ "bank", SEC_ADMINISTRATOR, &ChatHandler::HandleBankCommand, "", NULL },
464		{ "wchange", SEC_ADMINISTRATOR, &ChatHandler::HandleChangeWeather, "", NULL },
465		{ "ticket", SEC_GAMEMASTER, &ChatHandler::HandleTicketCommand, "", NULL },
466		{ "delticket", SEC_GAMEMASTER, &ChatHandler::HandleDelTicketCommand, "", NULL },
467		{ "maxskill", SEC_ADMINISTRATOR, &ChatHandler::HandleMaxSkillCommand, "", NULL },
468		{ "setskill", SEC_ADMINISTRATOR, &ChatHandler::HandleSetSkillCommand, "", NULL },
469		{ "whispers", SEC_MODERATOR, &ChatHandler::HandleWhispersCommand, "", NULL },
470		{ "pinfo", SEC_GAMEMASTER, &ChatHandler::HandlePInfoCommand, "", NULL },
471		{ "password", SEC_PLAYER, &ChatHandler::HandlePasswordCommand, "", NULL },
472		{ "lockaccount", SEC_PLAYER, &ChatHandler::HandleLockAccountCommand, "", NULL },
473		{ "respawn", SEC_ADMINISTRATOR, &ChatHandler::HandleRespawnCommand, "", NULL },
474		{ "sendmail", SEC_MODERATOR, &ChatHandler::HandleSendMailCommand, "", NULL },
475		{ "rename", SEC_GAMEMASTER, &ChatHandler::HandleRenameCommand, "", NULL },
476		{ "loadscripts", SEC_ADMINISTRATOR, &ChatHandler::HandleLoadScriptsCommand, "", NULL },
477		{ "mute", SEC_GAMEMASTER, &ChatHandler::HandleMuteCommand, "", NULL },
478		{ "unmute", SEC_GAMEMASTER, &ChatHandler::HandleUnmuteCommand, "", NULL },
479		{ "movegens", SEC_ADMINISTRATOR, &ChatHandler::HandleMovegensCommand, "", NULL },
480		{ "cometome", SEC_ADMINISTRATOR, &ChatHandler::HandleComeToMeCommand, "", NULL },
481		{ "damage", SEC_ADMINISTRATOR, &ChatHandler::HandleDamageCommand, "", NULL },
482		{ "combatstop", SEC_GAMEMASTER, &ChatHandler::HandleCombatStopCommand, "", NULL },
483		{ "freeze", SEC_ADMINISTRATOR, &ChatHandler::HandleFreezeCommand, "", NULL },
484		{ "unfreeze", SEC_ADMINISTRATOR, &ChatHandler::HandleUnFreezeCommand, "", NULL },
485		{ "listfreeze", SEC_ADMINISTRATOR, &ChatHandler::HandleListFreezeCommand, "", NULL },
486		{ "flusharenapoints", SEC_ADMINISTRATOR, &ChatHandler::HandleFlushArenaPointsCommand, "", NULL },
487
488		{ NULL, 0, NULL, "", NULL }
	454	{ "account", SEC_PLAYER, true, NULL, "", accountCommandTable },
	455	{ "gm", SEC_MODERATOR, true, NULL, "", gmCommandTable },
	456	{ "npc", SEC_MODERATOR, false, NULL, "", npcCommandTable },
	457	{ "go", SEC_MODERATOR, false, NULL, "", goCommandTable },
	458	{ "learn", SEC_MODERATOR, false, NULL, "", learnCommandTable },
	459	{ "modify", SEC_MODERATOR, false, NULL, "", modifyCommandTable },
	460	{ "debug", SEC_MODERATOR, false, NULL, "", debugCommandTable },
	461	{ "tele", SEC_MODERATOR, true, NULL, "", teleCommandTable },
	462	{ "event", SEC_GAMEMASTER, false, NULL, "", eventCommandTable },
	463	{ "gobject", SEC_GAMEMASTER, false, NULL, "", gobjectCommandTable },
	464	{ "honor", SEC_GAMEMASTER, false, NULL, "", honorCommandTable },
	465	{ "wp", SEC_GAMEMASTER, false, NULL, "", wpCommandTable },
	466	{ "quest", SEC_ADMINISTRATOR, false, NULL, "", questCommandTable },
	467	{ "reload", SEC_ADMINISTRATOR, true, NULL, "", reloadCommandTable },
	468	{ "list", SEC_ADMINISTRATOR, true, NULL, "", listCommandTable },
	469	{ "lookup", SEC_ADMINISTRATOR, true, NULL, "", lookupCommandTable },
	470	{ "pdump", SEC_ADMINISTRATOR, true, NULL, "", pdumpCommandTable },
	471	{ "guild", SEC_ADMINISTRATOR, true, NULL, "", guildCommandTable },
	472	{ "cast", SEC_ADMINISTRATOR, false, NULL, "", castCommandTable },
	473	{ "reset", SEC_ADMINISTRATOR, false, NULL, "", resetCommandTable },
	474	{ "instance", SEC_ADMINISTRATOR, true, NULL, "", instanceCommandTable },
	475	{ "server", SEC_ADMINISTRATOR, true, NULL, "", serverCommandTable },
	476
	477	{ "aura", SEC_ADMINISTRATOR, false, &ChatHandler::HandleAuraCommand, "", NULL },
	478	{ "unaura", SEC_ADMINISTRATOR, false, &ChatHandler::HandleUnAuraCommand, "", NULL },
	479	{ "announce", SEC_MODERATOR, true, &ChatHandler::HandleAnnounceCommand, "", NULL },
	480	{ "notify", SEC_MODERATOR, true, &ChatHandler::HandleNotifyCommand, "", NULL },
	481	{ "goname", SEC_MODERATOR, false, &ChatHandler::HandleGonameCommand, "", NULL },
	482	{ "namego", SEC_MODERATOR, false, &ChatHandler::HandleNamegoCommand, "", NULL },
	483	{ "groupgo", SEC_MODERATOR, false, &ChatHandler::HandleGroupgoCommand, "", NULL },
	484	{ "commands", SEC_PLAYER, true, &ChatHandler::HandleCommandsCommand, "", NULL },
	485	{ "demorph", SEC_GAMEMASTER, false, &ChatHandler::HandleDeMorphCommand, "", NULL },
	486	{ "die", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDieCommand, "", NULL },
	487	{ "revive", SEC_ADMINISTRATOR, false, &ChatHandler::HandleReviveCommand, "", NULL },
	488	{ "dismount", SEC_PLAYER, false, &ChatHandler::HandleDismountCommand, "", NULL },
	489	{ "gps", SEC_MODERATOR, false, &ChatHandler::HandleGPSCommand, "", NULL },
	490	{ "guid", SEC_GAMEMASTER, false, &ChatHandler::HandleGUIDCommand, "", NULL },
	491	{ "help", SEC_PLAYER, true, &ChatHandler::HandleHelpCommand, "", NULL },
	492	{ "itemmove", SEC_GAMEMASTER, false, &ChatHandler::HandleItemMoveCommand, "", NULL },
	493	{ "cooldown", SEC_ADMINISTRATOR, false, &ChatHandler::HandleCooldownCommand, "", NULL },
	494	{ "unlearn", SEC_ADMINISTRATOR, false, &ChatHandler::HandleUnLearnCommand, "", NULL },
	495	{ "distance", SEC_ADMINISTRATOR, false, &ChatHandler::HandleGetDistanceCommand, "", NULL },
	496	{ "recall", SEC_MODERATOR, false, &ChatHandler::HandleRecallCommand, "", NULL },
	497	{ "save", SEC_PLAYER, false, &ChatHandler::HandleSaveCommand, "", NULL },
	498	{ "saveall", SEC_MODERATOR, true, &ChatHandler::HandleSaveAllCommand, "", NULL },
	499	{ "kick", SEC_GAMEMASTER, true, &ChatHandler::HandleKickPlayerCommand, "", NULL },
	500	{ "ban", SEC_ADMINISTRATOR, true, NULL, "", banCommandTable },
	501	{ "unban", SEC_ADMINISTRATOR, true, NULL, "", unbanCommandTable },
	502	{ "baninfo", SEC_ADMINISTRATOR, false, NULL, "", baninfoCommandTable },
	503	{ "banlist", SEC_ADMINISTRATOR, true, NULL, "", banlistCommandTable },
	504	{ "plimit", SEC_ADMINISTRATOR, true, &ChatHandler::HandlePLimitCommand, "", NULL },
	505	{ "start", SEC_PLAYER, false, &ChatHandler::HandleStartCommand, "", NULL },
	506	{ "taxicheat", SEC_MODERATOR, false, &ChatHandler::HandleTaxiCheatCommand, "", NULL },
	507	{ "allowmove", SEC_ADMINISTRATOR, false, &ChatHandler::HandleAllowMovementCommand, "", NULL },
	508	{ "linkgrave", SEC_ADMINISTRATOR, false, &ChatHandler::HandleLinkGraveCommand, "", NULL },
	509	{ "neargrave", SEC_ADMINISTRATOR, false, &ChatHandler::HandleNearGraveCommand, "", NULL },
	510	{ "explorecheat", SEC_ADMINISTRATOR, false, &ChatHandler::HandleExploreCheatCommand, "", NULL },
	511	{ "hover", SEC_ADMINISTRATOR, false, &ChatHandler::HandleHoverCommand, "", NULL },
	512	{ "levelup", SEC_ADMINISTRATOR, false, &ChatHandler::HandleLevelUpCommand, "", NULL },
	513	{ "showarea", SEC_ADMINISTRATOR, false, &ChatHandler::HandleShowAreaCommand, "", NULL },
	514	{ "hidearea", SEC_ADMINISTRATOR, false, &ChatHandler::HandleHideAreaCommand, "", NULL },
	515	{ "additem", SEC_ADMINISTRATOR, false, &ChatHandler::HandleAddItemCommand, "", NULL },
	516	{ "additemset", SEC_ADMINISTRATOR, false, &ChatHandler::HandleAddItemSetCommand, "", NULL },
	517	{ "bank", SEC_ADMINISTRATOR, false, &ChatHandler::HandleBankCommand, "", NULL },
	518	{ "wchange", SEC_ADMINISTRATOR, false, &ChatHandler::HandleChangeWeather, "", NULL },
	519	{ "ticket", SEC_GAMEMASTER, true, &ChatHandler::HandleTicketCommand, "", NULL },
	520	{ "delticket", SEC_GAMEMASTER, true, &ChatHandler::HandleDelTicketCommand, "", NULL },
	521	{ "maxskill", SEC_ADMINISTRATOR, false, &ChatHandler::HandleMaxSkillCommand, "", NULL },
	522	{ "setskill", SEC_ADMINISTRATOR, false, &ChatHandler::HandleSetSkillCommand, "", NULL },
	523	{ "whispers", SEC_MODERATOR, false, &ChatHandler::HandleWhispersCommand, "", NULL },
	524	{ "pinfo", SEC_GAMEMASTER, true, &ChatHandler::HandlePInfoCommand, "", NULL },
	525	{ "password", SEC_PLAYER, false, &ChatHandler::HandlePasswordCommand, "", NULL },
	526	{ "lockaccount", SEC_PLAYER, false, &ChatHandler::HandleLockAccountCommand, "", NULL },
	527	{ "respawn", SEC_ADMINISTRATOR, false, &ChatHandler::HandleRespawnCommand, "", NULL },
	528	{ "sendmail", SEC_MODERATOR, false, &ChatHandler::HandleSendMailCommand, "", NULL },
	529	{ "rename", SEC_GAMEMASTER, true, &ChatHandler::HandleRenameCommand, "", NULL },
	530	{ "loadscripts", SEC_ADMINISTRATOR, true, &ChatHandler::HandleLoadScriptsCommand, "", NULL },
	531	{ "mute", SEC_GAMEMASTER, true, &ChatHandler::HandleMuteCommand, "", NULL },
	532	{ "unmute", SEC_GAMEMASTER, true, &ChatHandler::HandleUnmuteCommand, "", NULL },
	533	{ "movegens", SEC_ADMINISTRATOR, false, &ChatHandler::HandleMovegensCommand, "", NULL },
	534	{ "cometome", SEC_ADMINISTRATOR, false, &ChatHandler::HandleComeToMeCommand, "", NULL },
	535	{ "damage", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDamageCommand, "", NULL },
	536	{ "combatstop", SEC_GAMEMASTER, false, &ChatHandler::HandleCombatStopCommand, "", NULL },
	537	{ "chardelete", SEC_CONSOLE, true, &ChatHandler::HandleCombatStopCommand, "", NULL },
	538	{ "sendmessage", SEC_ADMINISTRATOR, true, &ChatHandler::HandleSendMessageCommand, "", NULL },
	539
	540	{ NULL, 0, false, NULL, "", NULL }
489	541	};
490	542
…	…
530	582	}
531	583
532		const char *ChatHandler::GetTrinityString(int32 entry)
	584	const char *ChatHandler::GetTrinityString(int32 entry) const
533	585	{
534	586	return m_session->GetTrinityString(entry);
	587	}
	588
	589	bool ChatHandler::isAvailable(ChatCommand const& cmd) const
	590	{
	591	// check security level only for simple command (without child commands)
	592	return m_session->GetSecurity() >= cmd.SecurityLevel;
535	593	}
536	594
…	…
579	637	void ChatHandler::SendGlobalSysMessage(const char *str)
580	638	{
	639	// Chat output
581	640	WorldPacket data;
582	641
…	…
654	713	}
655	714
656		// ~~check security level only for simple command (without child commands)~~
657		~~if(m_session->GetSecurity() < table[i].SecurityLevel~~)
	715	// must be available and have handler
	716	if(!table[i].Handler \|\| !isAvailable(table[i]))
658	717	continue;
659	718
…	…
664	723	if(table[i].SecurityLevel > SEC_PLAYER)
665	724	{
666		Player* p = m_session->GetPlayer();
667		uint64 sel_guid = p->GetSelection();
668		sLog.outCommand("Command: %s [Player: %s (Account: %u) X: %f Y: %f Z: %f Map: %u Selected: %s (GUID: %u)]",
669		fullcmd.c_str(),p->GetName(),m_session->GetAccountId(),p->GetPositionX(),p->GetPositionY(),p->GetPositionZ(),p->GetMapId(),
670		GetLogNameForGuid(sel_guid),GUID_LOPART(sel_guid));
	725	// chat case
	726	if(m_session)
	727	{
	728	Player* p = m_session->GetPlayer();
	729	uint64 sel_guid = p->GetSelection();
	730	sLog.outCommand("Command: %s [Player: %s (Account: %u) X: %f Y: %f Z: %f Map: %u Selected: %s (GUID: %u)]",
	731	fullcmd.c_str(),p->GetName(),m_session->GetAccountId(),p->GetPositionX(),p->GetPositionY(),p->GetPositionZ(),p->GetMapId(),
	732	GetLogNameForGuid(sel_guid),GUID_LOPART(sel_guid));
	733	}
671	734	}
672	735	}
…	…
694	757	// return 0;
695	758
696		if(text[0] != '!' && text[0] != '.')
697		return 0;
698
699		// ignore single . and ! in line
	759	/// chat case (.command or !command format)
	760	if(m_session)
	761	{
	762	if(text[0] != '!' && text[0] != '.')
	763	return 0;
	764	}
	765
	766	/// ignore single . and ! in line
700	767	if(strlen(text) < 2)
701	768	return 0;
702	769
703		// ignore messages staring from many dots.
	770	/// ignore messages staring from many dots.
704	771	if(text[0] == '.' && text[1] == '.' \|\| text[0] == '!' && text[1] == '!')
705	772	return 0;
706	773
707		++text;
	774	/// skip first . or ! (in console allowed use command with . and ! and without its)
	775	if(text[0] == '!' \|\| text[0] == '.')
	776	++text;
708	777
709	778	std::string fullcmd = text; // original `text` can't be used. It content destroyed in command code processing.
…	…
720	789	for(uint32 i = 0; table[i].Name != NULL; ++i)
721	790	{
722		if(m_session->GetSecurity() < table[i].SecurityLevel)
	791	// must be available (ignore handler existence for show command with possibe avalable subcomands
	792	if(!isAvailable(table[i]))
723	793	continue;
724	794
…	…
727	797
728	798	(list += "\n ") += table[i].Name;
	799	if(table[i].ChildCommands)
	800	list += " ...";
729	801	}
730	802
…	…
749	821	for(uint32 i = 0; table[i].Name != NULL; ++i)
750	822	{
751		if(m_session->GetSecurity() < table[i].SecurityLevel)
	823	// must be available (ignore handler existence for show command with possibe avalable subcomands
	824	if(!isAvailable(table[i]))
752	825	continue;
753	826
…	…
778	851	for(uint32 i = 0; table[i].Name != NULL; ++i)
779	852	{
780		if(m_session->GetSecurity() < table[i].SecurityLevel)
	853	// must be available (ignore handler existence for show command with possibe avalable subcomands
	854	if(!isAvailable(table[i]))
781	855	continue;
782	856
…	…
879	953	Player * ChatHandler::getSelectedPlayer()
880	954	{
	955	if(!m_session)
	956	return NULL;
	957
881	958	uint64 guid = m_session->GetPlayer()->GetSelection();
882	959
…	…
889	966	Unit* ChatHandler::getSelectedUnit()
890	967	{
	968	if(!m_session)
	969	return NULL;
	970
891	971	uint64 guid = m_session->GetPlayer()->GetSelection();
892	972
…	…
899	979	Creature* ChatHandler::getSelectedCreature()
900	980	{
	981	if(!m_session)
	982	return NULL;
	983
901	984	return ObjectAccessor::GetCreatureOrPet(*m_session->GetPlayer(),m_session->GetPlayer()->GetSelection());
902	985	}
…	…
1037	1120	GameObject* ChatHandler::GetObjectGlobalyWithGuidOrNearWithDbGuid(uint32 lowguid,uint32 entry)
1038	1121	{
	1122	if(!m_session)
	1123	return NULL;
	1124
1039	1125	Player* pl = m_session->GetPlayer();
1040	1126
…	…
1109	1195
1110	1196	return objmgr.GetGameTele(cId);
	1197	}
	1198
	1199	const char *CliHandler::GetTrinityString(int32 entry) const
	1200	{
	1201	return objmgr.GetTrinityStringForDBCLocale(entry);
	1202	}
	1203
	1204	bool CliHandler::isAvailable(ChatCommand const& cmd) const
	1205	{
	1206	// skip non-console commands in console case
	1207	return cmd.AllowConsole;
	1208	}
	1209
	1210	void CliHandler::SendSysMessage(const char *str)
	1211	{
	1212	m_print(str);
	1213	m_print("\r\n");
1111	1214	}
1112	1215

trunk/src/game/Chat.h

r102	r112
36	36	const char * Name;
37	37	uint32 SecurityLevel; // function pointer required correct align (use uint32)
	38	bool AllowConsole;
38	39	bool (ChatHandler::Handler)(const char args);
39	40	std::string Help;
…	…
62	63	static char* LineFromMessage(char& pos) { char start = strtok(pos,"\n"); pos = NULL; return start; }
63	64
64		~~const char *GetTrinityString(int32 entry)~~;
65
66		v~~oid SendSysMessage(~~ const char *str);
	65	virtual const char *GetTrinityString(int32 entry) const;
	66
	67	virtual void SendSysMessage( const char *str);
67	68	void SendSysMessage( int32 entry);
68	69	void PSendSysMessage( const char *format, ...) ATTR_PRINTF(2,3);
…	…
72	73
73	74	protected:
	75	explicit ChatHandler() : m_session(NULL) {} // for CLI subclass
	76
74	77	bool hasStringAbbr(const char* name, const char* part);
	78
	79	virtual bool isAvailable(ChatCommand const& cmd) const;
	80
75	81	void SendGlobalSysMessage(const char *str);
76	82
…	…
81	87	ChatCommand* getCommandTable();
82	88
	89	bool HandleAccountCommand(const char* args);
	90	bool HandleAccountCreateCommand(const char* args);
	91	bool HandleAccountDeleteCommand(const char* args);
	92	bool HandleAccountOnlineListCommand(const char* args);
	93	bool HandleAccountSetAddonCommand(const char* args);
	94	bool HandleAccountSetGmLevelCommand(const char* args);
	95	bool HandleAccountSetPasswordCommand(const char* args);
	96
83	97	bool HandleHelpCommand(const char* args);
84	98	bool HandleCommandsCommand(const char* args);
85		~~bool HandleAcctCommand(const char* args);~~
86	99	bool HandleStartCommand(const char* args);
87	100	bool HandleInfoCommand(const char* args);
88	101	bool HandleDismountCommand(const char* args);
89	102	bool HandleSaveCommand(const char* args);
90		bool HandleGMListCommand(const char* args);
	103	bool HandleGMListIngameCommand(const char* args);
	104	bool HandleGMListFullCommand(const char* args);
91	105
92	106	bool HandleNamegoCommand(const char* args);
…	…
209	223	bool HandleInstanceSaveDataCommand(const char * args);
210	224
	225	bool HandleServerCorpsesCommand(const char* args);
	226	bool HandleServerExitCommand(const char* args);
	227	bool HandleServerMotdCommand(const char* args);
	228	bool HandleServerSetMotdCommand(const char* args);
	229	bool HandleServerSetLogLevelCommand(const char* args);
	230
211	231	bool HandleAddHonorCommand(const char* args);
212	232	bool HandleHonorAddKillCommand(const char* args);
…	…
258	278	bool HandleListFreezeCommand(const char* args);
259	279
260		bool HandleBanCommand(const char* args);
261		bool HandleUnBanCommand(const char* args);
262		bool HandleBanInfoCommand(const char* args);
263		bool HandleBanListCommand(const char* args);
	280	bool HandleCharacterDeleteCommand(const char* args);
	281	bool HandleBanAccountCommand(const char* args);
	282	bool HandleBanCharacterCommand(const char* args);
	283	bool HandleBanIPCommand(const char* args);
	284	bool HandleUnBanAccountCommand(const char* args);
	285	bool HandleUnBanCharacterCommand(const char* args);
	286	bool HandleUnBanIPCommand(const char* args);
	287	bool HandleBanInfoAccountCommand(const char* args);
	288	bool HandleBanInfoCharacterCommand(const char* args);
	289	bool HandleBanInfoIPCommand(const char* args);
	290	bool HandleBanListAccountCommand(const char* args);
	291	bool HandleBanListCharacterCommand(const char* args);
	292	bool HandleBanListIPCommand(const char* args);
264	293	bool HandleIdleRestartCommand(const char* args);
265	294	bool HandleIdleShutDownCommand(const char* args);
…	…
388	417	bool HandleComeToMeCommand(const char *args);
389	418	bool HandleCombatStopCommand(const char *args);
	419	bool HandleSendMessageCommand(const char * args);
390	420	bool HandleFlushArenaPointsCommand(const char *args);
391	421
…	…
416	446	GameObject* GetObjectGlobalyWithGuidOrNearWithDbGuid(uint32 lowguid,uint32 entry);
417	447
418		~~WorldSession * m_session;~~
419
420	448	// Utility methods for commands
421	449	void ShowTicket(uint64 guid, char const* text, char const* time);
422	450	uint32 GetTicketIDByNum(uint32 num);
423	451	bool LookupPlayerSearchCommand(QueryResult* result, int32 limit);
	452	bool HandleBanListHelper(QueryResult* result);
	453	bool HandleBanHelper(BanMode mode,char const* args);
	454	bool HandleBanInfoHelper(uint32 accountid, char const* accountname);
	455	bool HandleUnBanHelper(BanMode mode,char const* args);
424	456
425	457	void SetSentErrorMessage(bool val){ sentErrorMessage = val;};
426	458	private:
	459	WorldSession * m_session; // != NULL for chat command call and NULL for CLI command
	460
427	461	// common global flag
428	462	static bool load_command_table;
429	463	bool sentErrorMessage;
430	464	};
	465
	466	class CliHandler : public ChatHandler
	467	{
	468	public:
	469	typedef void Print(char const*);
	470	explicit CliHandler(Print* zprint) : m_print(zprint) {}
	471
	472	// overwrite functions
	473	const char *GetTrinityString(int32 entry) const;
	474	bool isAvailable(ChatCommand const& cmd) const;
	475	void SendSysMessage(const char *str);
	476
	477	private:
	478	Print* m_print;
	479	};
	480
	481	char const fmtstring( char const format, ... );
	482
431	483	#endif
432
433		~~char const fmtstring( char const format, ... );~~

trunk/src/game/Language.h

r102	r112
80	80	LANG_COMMAND_INVALID_ITEM_COUNT = 52,
81	81	LANG_COMMAND_MAIL_ITEMS_LIMIT = 53,
82		// Room for more level 0 54-99 not used
	82	LANG_NEW_PASSWORDS_NOT_MATCH = 54,
	83	LANG_PASSWORD_TOO_LONG = 55,
	84	LANG_MOTD_CURRENT = 56,
	85	// Room for more level 0 57-99 not used
83	86
84	87	// level 1 chat
…	…
164	167	LANG_MAIL_SENT = 169,
165	168	LANG_SOUND_NOT_EXIST = 170,
166		// Room for more level 1 171-199 not used
	169	LANG_TELEPORTED_TO_BY_CONSOLE = 171,
	170	// Room for more level 1 172-199 not used
167	171
168	172	// level 2 chat
…	…
332	336	LANG_UNBAN_ERROR = 412,
333	337
334		LANG_BANINFO_NOACCOUNT = 413,
	338	LANG_ACCOUNT_NOT_EXIST = 413,
	339
335	340	LANG_BANINFO_NOCHARACTER = 414,
336	341	LANG_BANINFO_NOIP = 415,
…	…
445	450
446	451	LANG_WRONG_LINK_TYPE = 511,
447		LANG_ITEM_LIST = 512,
448		LANG_QUEST_LIST = 513,
449		LANG_CREATURE_ENTRY_LIST = 514,
450		LANG_CREATURE_LIST = 515,
451		LANG_GO_ENTRY_LIST = 516,
452		LANG_GO_LIST = 517,
453		LANG_ITEMSET_LIST = 518,
	452	LANG_ITEM_LIST_CHAT = 512,
	453	LANG_QUEST_LIST_CHAT = 513,
	454	LANG_CREATURE_ENTRY_LIST_CHAT = 514,
	455	LANG_CREATURE_LIST_CHAT = 515,
	456	LANG_GO_ENTRY_LIST_CHAT = 516,
	457	LANG_GO_LIST_CHAT = 517,
	458	LANG_ITEMSET_LIST_CHAT = 518,
454	459	LANG_TELE_LIST = 519,
455	460	LANG_SPELL_LIST = 520,
456		LANG_SKILL_LIST = 521,
	461	LANG_SKILL_LIST_CHAT = 521,
457	462
458	463	LANG_GAMEOBJECT_NOT_EXIST = 522,
…	…
527	532	LANG_COMMAND_RAWPAWNTIMES = 582,
528	533
529		LANG_EVENT_ENTRY_LIST = 583,
	534	LANG_EVENT_ENTRY_LIST_CHAT = 583,
530	535	LANG_NOEVENTFOUND = 584,
531	536	LANG_EVENT_NOT_EXIST = 585,
…	…
539	544
540	545	LANG_COMMAND_LEARN_ALL_RECIPES = 592,
	546	LANG_BANLIST_ACCOUNTS = 593,
	547	LANG_BANLIST_ACCOUNTS_HEADER = 594,
	548	LANG_BANLIST_IPS = 595,
	549	LANG_BANLIST_IPS_HEADER = 596,
	550	LANG_GMLIST = 597,
	551	LANG_GMLIST_HEADER = 598,
	552	LANG_GMLIST_EMPTY = 599,
	553	// End Level 3 list, continued at 1100
541	554
542	555	// Battleground
…	…
659	672	// Room for in-game strings 810-999 not used
660	673
661		// FREE IDS 1000-9999
662		LANG_COMMAND_FREEZE = 1000,
663		LANG_COMMAND_FREEZE_ERROR = 1001,
664		LANG_COMMAND_FREEZE_WRONG = 1002,
665		LANG_COMMAND_UNFREEZE = 1003,
666		LANG_COMMAND_NO_FROZEN_PLAYERS = 1004,
667		LANG_COMMAND_LIST_FREEZE = 1005,
668		LANG_COMMAND_FROZEN_PLAYERS = 1006,
	674	// Level 4 (CLI only commands)
	675	LANG_COMMAND_EXIT = 1000,
	676	LANG_ACCOUNT_DELETED = 1001,
	677	LANG_ACCOUNT_NOT_DELETED_SQL_ERROR = 1002,
	678	LANG_ACCOUNT_NOT_DELETED = 1003,
	679	LANG_ACCOUNT_CREATED = 1004,
	680	LANG_ACCOUNT_TOO_LONG = 1005,
	681	LANG_ACCOUNT_ALREADY_EXIST = 1006,
	682	LANG_ACCOUNT_NOT_CREATED_SQL_ERROR = 1007,
	683	LANG_ACCOUNT_NOT_CREATED = 1008,
	684	LANG_CHARACTER_DELETED = 1009,
	685	LANG_ACCOUNT_LIST_HEADER = 1010,
	686	LANG_ACCOUNT_LIST_ERROR = 1011,
	687	// Room for more level 4 1012-1099 not used
	688
	689	// Level 3 (continue)
	690	LANG_MOTD_NEW = 1100,
	691	LANG_ACCOUNT_SETADDON = 1101,
	692	LANG_SENDMESSAGE = 1102,
	693	LANG_EVENT_ENTRY_LIST_CONSOLE = 1103,
	694	LANG_CREATURE_ENTRY_LIST_CONSOLE = 1104,
	695	LANG_ITEM_LIST_CONSOLE = 1105,
	696	LANG_ITEMSET_LIST_CONSOLE = 1106,
	697	LANG_GO_ENTRY_LIST_CONSOLE = 1107,
	698	LANG_QUEST_LIST_CONSOLE = 1108,
	699	LANG_SKILL_LIST_CONSOLE = 1109,
	700	LANG_CREATURE_LIST_CONSOLE = 1110,
	701	LANG_GO_LIST_CONSOLE = 1111,
	702	LANG_FILE_OPEN_FAIL = 1112,
	703	LANG_ACCOUNT_CHARACTER_LIST_FULL = 1113,
	704	LANG_DUMP_BROKEN = 1114,
	705	LANG_INVALID_CHARACTER_NAME = 1115,
	706	LANG_INVALID_CHARACTER_GUID = 1116,
	707	LANG_CHARACTER_GUID_IN_USE = 1117,
	708	LANG_ITEMLIST_GUILD = 1118,
	709	// Room for more level 3 1119-1199 not used
	710
	711	// Trinity custom patches 5000-9999
	712	LANG_COMMAND_FREEZE = 5000,
	713	LANG_COMMAND_FREEZE_ERROR = 5001,
	714	LANG_COMMAND_FREEZE_WRONG = 5002,
	715	LANG_COMMAND_UNFREEZE = 5003,
	716	LANG_COMMAND_NO_FROZEN_PLAYERS = 5004,
	717	LANG_COMMAND_LIST_FREEZE = 5005,
	718	LANG_COMMAND_FROZEN_PLAYERS = 5006,
	719	// Room for more Trinity custom patches 5007-9999
669	720
670	721	// Use for not-in-svn patches 10000-10999

trunk/src/game/Level0.cpp

r102	r112
36	36	bool ChatHandler::HandleHelpCommand(const char* args)
37	37	{
38		if(!*args)
39		return false;
40
41		char* cmd = strtok((char*)args, " ");
	38	char* cmd = strtok((char*)args, " ");
42	39	if(!cmd)
43		return false;
44
45		if(!ShowHelpForCommand(getCommandTable(), cmd))
46		SendSysMessage(LANG_NO_HELP_CMD);
	40	{
	41	ShowHelpForCommand(getCommandTable(), "help");
	42	ShowHelpForCommand(getCommandTable(), "");
	43	}
	44	else
	45	{
	46	if(!ShowHelpForCommand(getCommandTable(), cmd))
	47	SendSysMessage(LANG_NO_HELP_CMD);
	48	}
47	49
48	50	return true;
…	…
55	57	}
56	58
57		bool ChatHandler::HandleAcctCommand(const char* /args/)
	59	bool ChatHandler::HandleAccountCommand(const char* /args/)
58	60	{
59	61	uint32 gmlevel = m_session->GetSecurity();
…	…
142	144	}
143	145
144		bool ChatHandler::HandleGMListCommand(const char* /args/)
	146	bool ChatHandler::HandleGMListIngameCommand(const char* /args/)
145	147	{
146	148	bool first = true;
…	…
150	152	for(; itr != m.end(); ++itr)
151	153	{
152		if( itr->second->GetSession()->GetSecurity() && (itr->second->isGameMaster() \|\| sWorld.getConfig(CONFIG_GM_IN_GM_LIST) ) &&
153		itr->second->IsVisibleGloballyFor(m_session->GetPlayer()) )
	154	if (itr->second->GetSession()->GetSecurity() &&
	155	(itr->second->isGameMaster() \|\| sWorld.getConfig(CONFIG_GM_IN_GM_LIST)) &&
	156	(!m_session \|\| itr->second->IsVisibleGloballyFor(m_session->GetPlayer())) )
154	157	{
155	158	if(first)
…	…
178	181	char *new_pass_c = strtok (NULL, " ");
179	182
180		if~~( !old_pass \|\| !new_pass \|\| !new_pass_c~~ )
	183	if (!old_pass \|\| !new_pass \|\| !new_pass_c)
181	184	return false;
182	185
…	…
185	188	std::string password_new_c = new_pass_c;
186	189
187		if(!accmgr.CheckPassword(m_session->GetAccountId(), password_old) \|\| password_new != password_new_c)
188		{
189		SendSysMessage(LANG_COMMAND_WRONGOLDPASSWORD);
190		SetSentErrorMessage(true);
	190	if (password_new != password_new_c)
	191	{
	192	SendSysMessage (LANG_NEW_PASSWORDS_NOT_MATCH);
	193	SetSentErrorMessage (true);
	194	return false;
	195	}
	196
	197	if (!accmgr.CheckPassword (m_session->GetAccountId(), password_old))
	198	{
	199	SendSysMessage (LANG_COMMAND_WRONGOLDPASSWORD);
	200	SetSentErrorMessage (true);
191	201	return false;
192	202	}
…	…
199	209	SendSysMessage(LANG_COMMAND_PASSWORD);
200	210	break;
	211	case AOR_PASS_TOO_LONG:
	212	SendSysMessage(LANG_PASSWORD_TOO_LONG);
	213	SetSentErrorMessage(true);
	214	return false;
	215	case AOR_NAME_NOT_EXIST: // not possible case, don't want get account name for output
201	216	default:
202	217	SendSysMessage(LANG_COMMAND_NOTCHANGEPASSWORD);
…	…
234	249	return true;
235	250	}
	251
	252	/// Display the 'Message of the day' for the realm
	253	bool ChatHandler::HandleServerMotdCommand(const char* /args/)
	254	{
	255	PSendSysMessage(LANG_MOTD_CURRENT, sWorld.GetMotd());
	256	return true;
	257	}

trunk/src/game/Level1.cpp

r102	r112
1693	1693	bool ChatHandler::HandleLookupAreaCommand(const char* args)
1694	1694	{
1695		if(!*args)
	1695	if (!*args)
1696	1696	return false;
1697	1697
…	…
1699	1699	std::wstring wnamepart;
1700	1700
1701		if~~(!Utf8toWStr~~(namepart,wnamepart))
	1701	if (!Utf8toWStr (namepart,wnamepart))
1702	1702	return false;
1703	1703
…	…
1705	1705
1706	1706	// converting string that we try to find to lower case
1707		wstrToLower~~( wnamepart~~ );
	1707	wstrToLower (wnamepart);
1708	1708
1709	1709	// Search in AreaTable.dbc
1710		for (uint32 areaflag = 0; areaflag < sAreaStore.GetNumRows(); ++areaflag)
1711		{
1712		AreaTableEntry const *areaEntry = sAreaStore.LookupEntry(areaflag);
1713		if(areaEntry)
1714		{
1715		int loc = m_session~~->GetSession~~DbcLocale();
	1710	for (uint32 areaflag = 0; areaflag < sAreaStore.GetNumRows (); ++areaflag)
	1711	{
	1712	AreaTableEntry const *areaEntry = sAreaStore.LookupEntry (areaflag);
	1713	if (areaEntry)
	1714	{
	1715	int loc = m_session ? m_session->GetSessionDbcLocale () : sWorld.GetDefaultDbcLocale();
1716	1716	std::string name = areaEntry->area_name[loc];
1717		if(name.empty())
	1717	if (name.empty())
1718	1718	continue;
1719	1719
1720		if~~(!Utf8FitTo~~(name, wnamepart))
	1720	if (!Utf8FitTo (name, wnamepart))
1721	1721	{
1722	1722	loc = 0;
1723	1723	for(; loc < MAX_LOCALE; ++loc)
1724	1724	{
1725		if~~(loc==m_session->GetSessionDbcLocale~~())
	1725	if (m_session && loc==m_session->GetSessionDbcLocale ())
1726	1726	continue;
1727	1727
1728	1728	name = areaEntry->area_name[loc];
1729		if~~(name.empty~~())
	1729	if (name.empty ())
1730	1730	continue;
1731	1731
1732		if (Utf8FitTo(name, wnamepart))
	1732	if (Utf8FitTo (name, wnamepart))
1733	1733	break;
1734	1734	}
1735	1735	}
1736	1736
1737		if(loc < MAX_LOCALE)
	1737	if (loc < MAX_LOCALE)
1738	1738	{
1739	1739	// send area in "id - [name]" format
1740	1740	std::ostringstream ss;
1741		ss << areaEntry->ID << " - \|cffffffff\|Harea:" << areaEntry->ID << "\|h[" << name << " " << localeNames[loc]<< "]\|h\|r";
1742
1743		SendSysMessage(ss.str().c_str());
	1741	if (m_session)
	1742	ss << areaEntry->ID << " - \|cffffffff\|Harea:" << areaEntry->ID << "\|h[" << name << " " << localeNames[loc]<< "]\|h\|r";
	1743	else
	1744	ss << areaEntry->ID << " - " << name << " " << localeNames[loc];
	1745
	1746	SendSysMessage (ss.str ().c_str());
1744	1747
1745	1748	++counter;
…	…
1747	1750	}
1748	1751	}
1749		if (counter == 0) // if counter == 0 then we found nth
1750		SendSysMessage(LANG_COMMAND_NOAREAFOUND);
	1752	if (counter == 0) // if counter == 0 then we found nth
	1753	SendSysMessage (LANG_COMMAND_NOAREAFOUND);
1751	1754	return true;
1752	1755	}
…	…
1761	1764	return false;
1762	1765	}
	1766
1763	1767	char const* str = strtok((char*)args, " ");
1764	1768	if(!str)
…	…
1774	1778	wstrToLower( wnamepart );
1775	1779
1776		~~GameTeleMap const & teleMap = objmgr.GetGameTeleMap();~~
1777
1778	1780	std::ostringstream reply;
	1781
	1782	GameTeleMap const & teleMap = objmgr.GetGameTeleMap();
1779	1783	for(GameTeleMap::const_iterator itr = teleMap.begin(); itr != teleMap.end(); ++itr)
1780	1784	{
…	…
1784	1788	continue;
1785	1789
1786		reply << " \|cffffffff\|Htele:";
1787		reply << itr->first;
1788		reply << "\|h[";
1789		reply << tele->name;
1790		reply << "]\|h\|r\n";
	1790	if (m_session)
	1791	reply << " \|cffffffff\|Htele:" << itr->first << "\|h[" << tele->name << "]\|h\|r\n";
	1792	else
	1793	reply << " " << itr->first << " " << tele->name << "\n";
1791	1794	}
1792	1795
…	…
2073	2076	PSendSysMessage(LANG_TELEPORTING_TO, chr->GetName(),"", tele->name.c_str());
2074	2077
2075		if (m_session->GetPlayer()->IsVisibleGloballyFor(chr))
2076		ChatHandler(chr).PSendSysMessage(LANG_TELEPORTED_TO_BY, m_session->GetPlayer()->GetName());
	2078	if (m_session)
	2079	{
	2080	if(m_session->GetPlayer()->IsVisibleGloballyFor(chr))
	2081	ChatHandler(chr).PSendSysMessage(LANG_TELEPORTED_TO_BY, m_session->GetPlayer()->GetName());
	2082	}
	2083	else
	2084	ChatHandler(chr).SendSysMessage(LANG_TELEPORTED_TO_BY_CONSOLE);
2077	2085
2078	2086	// stop flight if need

trunk/src/game/Level2.cpp

r102	r112
43	43	#include <fstream>
44	44	#include <map>
	45	#include "GlobalEvents.h"
45	46
46	47	static uint32 ReputationRankStrIndex[MAX_REPUTATION_RANK] =
…	…
100	101	}
101	102
102		if(security >= m_session->GetSecurity())
	103	if(m_session && security >= m_session->GetSecurity())
103	104	{
104	105	SendSysMessage(LANG_YOURS_SECURITY_IS_LOW);
…	…
166	167	}
167	168
168		if(security >= m_session->GetSecurity())
	169	if(m_session && security >= m_session->GetSecurity())
169	170	{
170	171	SendSysMessage(LANG_YOURS_SECURITY_IS_LOW);
…	…
556	557	bool ChatHandler::HandleLookupFactionCommand(const char* args)
557	558	{
558		if(!*args)
559		return false;
560
561		Player *target = getSelectedPlayer();
562		if (!target)
563		{
564		SendSysMessage(LANG_NO_CHAR_SELECTED);
565		SetSentErrorMessage(true);
566		return false;
567		}
	559	if (!*args)
	560	return false;
	561
	562	// Can be NULL at console call
	563	Player *target = getSelectedPlayer ();
568	564
569	565	std::string namepart = args;
570	566	std::wstring wnamepart;
571	567
572		if~~(!Utf8toWStr~~(namepart,wnamepart))
	568	if (!Utf8toWStr (namepart,wnamepart))
573	569	return false;
574	570
575	571	// converting string that we try to find to lower case
576		wstrToLower~~( wnamepart~~ );
	572	wstrToLower (wnamepart);
577	573
578	574	uint32 counter = 0; // Counter for figure out that we found smth.
579	575
580		for (uint32 id = 0; id < sFactionStore.GetNumRows(); id++)
581		//for(FactionStateList::const_iterator itr = target->m_factions.begin(); itr != target->m_factions.end(); ++itr)
582		{
583		FactionEntry const *factionEntry = sFactionStore.LookupEntry(id);
584		//FactionEntry const *factionEntry = sFactionStore.LookupEntry(itr->second.ID);
	576	for (uint32 id = 0; id < sFactionStore.GetNumRows(); ++id)
	577	{
	578	FactionEntry const *factionEntry = sFactionStore.LookupEntry (id);
585	579	if (factionEntry)
586	580	{
587		FactionStateList::const_iterator repItr = target->m_factions.find(factionEntry->reputationListID);
588
589		int loc = m_session->GetSessionDbcLocale();
	581	FactionState const* repState = NULL;
	582	if(target)
	583	{
	584	FactionStateList::const_iterator repItr = target->m_factions.find (factionEntry->reputationListID);
	585	if(repItr != target->m_factions.end())
	586	repState = &repItr->second;
	587	}
	588
	589	int loc = m_session ? m_session->GetSessionDbcLocale() : sWorld.GetDefaultDbcLocale();
590	590	std::string name = factionEntry->name[loc];
591	591	if(name.empty())
…	…
597	597	for(; loc < MAX_LOCALE; ++loc)
598	598	{
599		if(loc==m_session->GetSessionDbcLocale())
	599	if(m_session && loc==m_session->GetSessionDbcLocale())
600	600	continue;
601	601
…	…
614	614	// or "id - [faction] [no reputation]" format
615	615	std::ostringstream ss;
616		ss << id << " - \|cffffffff\|Hfaction:" << id << "\|h[" << name << " " << localeNames[loc] << "]\|h\|r";
617
618		if (repItr != target->m_factions.end())
	616	if (m_session)
	617	ss << id << " - \|cffffffff\|Hfaction:" << id << "\|h[" << name << " " << localeNames[loc] << "]\|h\|r";
	618	else
	619	ss << id << " - " << name << " " << localeNames[loc];
	620
	621	if (repState) // and then target!=NULL also
619	622	{
620	623	ReputationRank rank = target->GetReputationRank(factionEntry);
…	…
623	626	ss << " " << rankName << "\|h\|r (" << target->GetReputation(factionEntry) << ")";
624	627
625		if(rep~~Itr->second.~~Flags & FACTION_FLAG_VISIBLE)
	628	if(repState->Flags & FACTION_FLAG_VISIBLE)
626	629	ss << GetTrinityString(LANG_FACTION_VISIBLE);
627		if(rep~~Itr->second.~~Flags & FACTION_FLAG_AT_WAR)
	630	if(repState->Flags & FACTION_FLAG_AT_WAR)
628	631	ss << GetTrinityString(LANG_FACTION_ATWAR);
629		if(rep~~Itr->second.~~Flags & FACTION_FLAG_PEACE_FORCED)
	632	if(repState->Flags & FACTION_FLAG_PEACE_FORCED)
630	633	ss << GetTrinityString(LANG_FACTION_PEACE_FORCED);
631		if(rep~~Itr->second.~~Flags & FACTION_FLAG_HIDDEN)
	634	if(repState->Flags & FACTION_FLAG_HIDDEN)
632	635	ss << GetTrinityString(LANG_FACTION_HIDDEN);
633		if(rep~~Itr->second.~~Flags & FACTION_FLAG_INVISIBLE_FORCED)
	636	if(repState->Flags & FACTION_FLAG_INVISIBLE_FORCED)
634	637	ss << GetTrinityString(LANG_FACTION_INVISIBLE_FORCED);
635		if(rep~~Itr->second.~~Flags & FACTION_FLAG_INACTIVE)
	638	if(repState->Flags & FACTION_FLAG_INACTIVE)
636	639	ss << GetTrinityString(LANG_FACTION_INACTIVE);
637	640	}
…	…
1703	1706	}
1704	1707
1705		if(name==m_session->GetPlayer()->GetName())
	1708	if(m_session && name==m_session->GetPlayer()->GetName())
1706	1709	{
1707	1710	SendSysMessage(LANG_COMMAND_KICKSELF);
…	…
1810	1813	username = fields[0].GetCppString();
1811	1814	security = fields[1].GetUInt32();
1812		if(m_session->GetSecurity() >= security)
	1815
	1816	if(!m_session \|\| m_session->GetSecurity() >= security)
1813	1817	{
1814	1818	last_ip = fields[2].GetCppString();
…	…
1892	1896	if (!px)
1893	1897	{
	1898	if(!m_session)
	1899	{
	1900	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	1901	SetSentErrorMessage(true);
	1902	return false;
	1903	}
	1904
1894	1905	size_t count;
1895	1906	QueryResult *result = CharacterDatabase.Query("SELECT COUNT(ticket_id) FROM character_ticket");
…	…
1902	1913	count = 0;
1903	1914
1904		PSendSysMessage(LANG_COMMAND_TICKETCOUNT, count, m_session->GetPlayer()->isAcceptTickets() ? GetTrinityString(LANG_ON) : GetTrinityString(LANG_OFF));
	1915	bool accept = m_session->GetPlayer()->isAcceptTickets();
	1916
	1917	PSendSysMessage(LANG_COMMAND_TICKETCOUNT, count, accept ? GetTrinityString(LANG_ON) : GetTrinityString(LANG_OFF));
1905	1918	return true;
1906	1919	}
…	…
1909	1922	if(strncmp(px,"on",3) == 0)
1910	1923	{
	1924	if(!m_session)
	1925	{
	1926	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	1927	SetSentErrorMessage(true);
	1928	return false;
	1929	}
	1930
1911	1931	m_session->GetPlayer()->SetAcceptTicket(true);
1912	1932	SendSysMessage(LANG_COMMAND_TICKETON);
…	…
1917	1937	if(strncmp(px,"off",4) == 0)
1918	1938	{
	1939	if(!m_session)
	1940	{
	1941	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	1942	SetSentErrorMessage(true);
	1943	return false;
	1944	}
	1945
1919	1946	m_session->GetPlayer()->SetAcceptTicket(false);
1920	1947	SendSysMessage(LANG_COMMAND_TICKETOFF);
…	…
3591	3618	{
3592	3619	char const* active = activeEvents.find(id) != activeEvents.end() ? GetTrinityString(LANG_ACTIVE) : "";
3593		PSendSysMessage(LANG_EVENT_ENTRY_LIST,id,id,descr.c_str(),active );
	3620
	3621	if(m_session)
	3622	PSendSysMessage(LANG_EVENT_ENTRY_LIST_CHAT,id,id,eventData.description.c_str(),active );
	3623	else
	3624	PSendSysMessage(LANG_EVENT_ENTRY_LIST_CONSOLE,id,eventData.description.c_str(),active );
	3625
3594	3626	++counter;
3595	3627	}
…	…
3616	3648	GameEventData const& eventData = events[event_id];
3617	3649
3618		PSendSysMessage(LANG_EVENT_ENTRY_LIST,event_id,event_id,eventData.description.c_str(),active );
	3650	if(m_session)
	3651	PSendSysMessage(LANG_EVENT_ENTRY_LIST_CHAT,event_id,event_id,eventData.description.c_str(),active );
	3652	else
	3653	PSendSysMessage(LANG_EVENT_ENTRY_LIST_CONSOLE,event_id,eventData.description.c_str(),active );
	3654
3619	3655	++counter;
3620	3656	}
…	…
3849	3885	}
3850	3886
3851		if(!*args)
	3887	if (!*args)
3852	3888	return false;
3853	3889
…	…
3917	3953	{
3918	3954
3919		if(!*args)
3920		return false;
3921
3922		std::string ip = strtok((char*)args, " ");
3923		~~char* limit_str = strtok~~(NULL, " ");
3924		~~int32 limit = limit_str ? atoi~~(limit_str) : -1;
3925
3926		loginDatabase.escape_string(ip);
3927
3928		QueryResult* result = loginDatabase.PQuery~~("SELECT id,username FROM account WHERE last_ip = '%s'", ip.c_str~~());
3929
3930		return LookupPlayerSearchCommand(result,limit);
	3955	if (!*args)
	3956	return false;
	3957
	3958	std::string ip = strtok ((char*)args, " ");
	3959	char* limit_str = strtok (NULL, " ");
	3960	int32 limit = limit_str ? atoi (limit_str) : -1;
	3961
	3962	loginDatabase.escape_string (ip);
	3963
	3964	QueryResult* result = loginDatabase.PQuery ("SELECT id,username FROM account WHERE last_ip = '%s'", ip.c_str ());
	3965
	3966	return LookupPlayerSearchCommand (result,limit);
3931	3967	}
3932	3968
3933	3969	bool ChatHandler::HandleLookupPlayerAccountCommand(const char* args)
3934	3970	{
3935		if(!*args)
3936		return false;
3937
3938		std::string account = strtok((char*)args, " ");
3939		~~char* limit_str = strtok~~(NULL, " ");
3940		~~int32 limit = limit_str ? atoi~~(limit_str) : -1;
3941
3942		if~~(!AccountMgr::normilizeString~~(account))
3943		return false;
3944
3945		loginDatabase.escape_string(account);
3946
3947		QueryResult* result = loginDatabase.PQuery~~("SELECT id,username FROM account WHERE username = '%s'", account.c_str~~());
3948
3949		return LookupPlayerSearchCommand(result,limit);
	3971	if (!*args)
	3972	return false;
	3973
	3974	std::string account = strtok ((char*)args, " ");
	3975	char* limit_str = strtok (NULL, " ");
	3976	int32 limit = limit_str ? atoi (limit_str) : -1;
	3977
	3978	if (!AccountMgr::normilizeString (account))
	3979	return false;
	3980
	3981	loginDatabase.escape_string (account);
	3982
	3983	QueryResult* result = loginDatabase.PQuery ("SELECT id,username FROM account WHERE username = '%s'", account.c_str ());
	3984
	3985	return LookupPlayerSearchCommand (result,limit);
3950	3986	}
3951	3987
…	…
3953	3989	{
3954	3990
3955		if(!*args)
3956		return false;
3957
3958		std::string email = strtok((char*)args, " ");
3959		~~char* limit_str = strtok~~(NULL, " ");
3960		~~int32 limit = limit_str ? atoi~~(limit_str) : -1;
3961
3962		loginDatabase.escape_string(email);
3963
3964		QueryResult* result = loginDatabase.PQuery~~("SELECT id,username FROM account WHERE email = '%s'", email.c_str~~());
3965
3966		return LookupPlayerSearchCommand(result,limit);
	3991	if (!*args)
	3992	return false;
	3993
	3994	std::string email = strtok ((char*)args, " ");
	3995	char* limit_str = strtok (NULL, " ");
	3996	int32 limit = limit_str ? atoi (limit_str) : -1;
	3997
	3998	loginDatabase.escape_string (email);
	3999
	4000	QueryResult* result = loginDatabase.PQuery ("SELECT id,username FROM account WHERE email = '%s'", email.c_str ());
	4001
	4002	return LookupPlayerSearchCommand (result,limit);
3967	4003	}
3968	4004
…	…
4010	4046	return true;
4011	4047	}
	4048
	4049	/// Triggering corpses expire check in world
	4050	bool ChatHandler::HandleServerCorpsesCommand(const char* /args/)
	4051	{
	4052	CorpsesErase();
	4053	return true;
	4054	}

trunk/src/game/Level3.cpp

r102	r112
53	53	#include "InstanceSaveMgr.h"
54	54	#include "InstanceData.h"
	55	#include "AccountMgr.h"
55	56
56	57	//reload commands
…	…
682	683	}
683	684
684		bool ChatHandler::Handle~~Security~~Command(const char* args)
	685	bool ChatHandler::HandleAccountSetGmLevelCommand(const char* args)
685	686	{
686	687	char* arg1 = strtok((char*)args, " ");
…	…
688	689	return false;
689	690
690		char* arg2 = 0;
691
692		std::string targetName;
	691	char* arg2 = strtok(NULL, " ");
	692
	693	std::string targetAccountName;
693	694	uint32 targetAccountId = 0;
694	695	uint32 targetSecurity = 0;
695	696
	697	/// only target player different from self allowed (if targetPlayer!=NULL then not console)
696	698	Player* targetPlayer = getSelectedPlayer();
697		if(targetPlayer)
698		{
699		targetName = targetPlayer->GetName();
	699	if(targetPlayer && m_session->GetPlayer()!=targetPlayer)
	700	{
	701	/// wrong command syntax or unexpected targeting
	702	if(arg2)
	703	return false;
	704
700	705	targetAccountId = targetPlayer->GetSession()->GetAccountId();
701	706	targetSecurity = targetPlayer->GetSession()->GetSecurity();
702		arg2 = arg1;
	707	if(!accmgr.GetName(targetAccountId,targetAccountName))
	708	{
	709	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,targetAccountName.c_str());
	710	SetSentErrorMessage(true);
	711	return false;
	712	}
703	713	}
704	714	else
705	715	{
706		targetName = arg1;
707		if(!~~normalizePlayerName(targe~~tName))
	716	targetAccountName = arg1;
	717	if(!AccountMgr::normilizeString(targetAccountName))
708	718	{
709		~~SendSysMessage(LANG_PLAYER_NOT_FOUND~~);
	719	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,targetAccountName.c_str());
710	720	SetSentErrorMessage(true);
711	721	return false;
712	722	}
713	723
714		targetPlayer = ObjectAccessor::Instance().FindPlayerByName(targetName.c_str());
715		if(targetPlayer)
716		{
717		targetAccountId = targetPlayer->GetSession()->GetAccountId();
718		targetSecurity = targetPlayer->GetSession()->GetSecurity();
719		}
720		else
721		{
722		uint64 targetGUID = objmgr.GetPlayerGUIDByName(targetName.c_str());
723		if(!targetGUID)
724		{
725		SendSysMessage(LANG_PLAYER_NOT_FOUND);
726		SetSentErrorMessage(true);
727		return false;
728		}
729		targetAccountId = objmgr.GetPlayerAccountIdByGUID(targetGUID);
730		targetSecurity = accmgr.GetSecurity(targetAccountId);
731		}
732
733		arg2 = strtok(NULL, " ");
	724	targetAccountId = accmgr.GetId(targetAccountName);
	725	targetSecurity = accmgr.GetSecurity(targetAccountId);
734	726	}
735	727
…	…
742	734	}
743	735
744		// can set security level only for target with less security and to less security that we have
745		if(targetSecurity >= m_session->GetSecurity() \|\| uint32(gm) >= m_session->GetSecurity() )
	736	/// m_session==NULL only for console
	737	uint32 plSecurity = m_session ? m_session->GetSecurity() : SEC_CONSOLE;
	738
	739	/// can set security level only for target with less security and to less security that we have
	740	/// This is also reject self apply in fact
	741	if(targetSecurity >= plSecurity \|\| uint32(gm) >= plSecurity )
746	742	{
747	743	SendSysMessage(LANG_YOURS_SECURITY_IS_LOW);
…	…
752	748	if(targetPlayer)
753	749	{
754		if( targetPlayer != m_session->GetPlayer() )
755		ChatHandler(targetPlayer).PSendSysMessage(LANG_YOURS_SECURITY_CHANGED,m_session->GetPlayer()->GetName(), gm);
756
	750	ChatHandler(targetPlayer).PSendSysMessage(LANG_YOURS_SECURITY_CHANGED,m_session->GetPlayer()->GetName(), gm);
757	751	targetPlayer->GetSession()->SetSecurity(gm);
758	752	}
759	753
760		PSendSysMessage(LANG_YOU_CHANGE_SECURITY, targetName.c_str(), gm);
	754	PSendSysMessage(LANG_YOU_CHANGE_SECURITY, targetAccountName.c_str(), gm);
761	755	loginDatabase.PExecute("UPDATE account SET gmlevel = '%i' WHERE id = '%u'", gm, targetAccountId);
762	756
763	757	return true;
	758	}
	759
	760	/// Set password for account
	761	bool ChatHandler::HandleAccountSetPasswordCommand(const char* args)
	762	{
	763	if(!*args)
	764	return false;
	765
	766	///- Get the command line arguments
	767	char szAccount = strtok ((char)args," ");
	768	char *szPassword1 = strtok (NULL," ");
	769	char *szPassword2 = strtok (NULL," ");
	770
	771	if (!szAccount\|\|!szPassword1 \|\| !szPassword2)
	772	return false;
	773
	774	std::string account_name = szAccount;
	775	if(!AccountMgr::normilizeString(account_name))
	776	{
	777	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
	778	SetSentErrorMessage(true);
	779	return false;
	780	}
	781
	782	uint32 targetAccountId = accmgr.GetId(account_name);
	783	if (!targetAccountId)
	784	{
	785	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
	786	SetSentErrorMessage(true);
	787	return false;
	788	}
	789
	790	uint32 targetSecurity = accmgr.GetSecurity(targetAccountId);
	791
	792	/// m_session==NULL only for console
	793	uint32 plSecurity = m_session ? m_session->GetSecurity() : SEC_CONSOLE;
	794
	795	/// can set password only for target with less security
	796	/// This is also reject self apply in fact
	797	if (targetSecurity >= plSecurity)
	798	{
	799	SendSysMessage (LANG_YOURS_SECURITY_IS_LOW);
	800	SetSentErrorMessage (true);
	801	return false;
	802	}
	803
	804	if (strcmp(szPassword1,szPassword2))
	805	{
	806	SendSysMessage (LANG_NEW_PASSWORDS_NOT_MATCH);
	807	SetSentErrorMessage (true);
	808	return false;
	809	}
	810
	811	AccountOpResult result = accmgr.ChangePassword(targetAccountId, szPassword1);
	812
	813	switch(result)
	814	{
	815	case AOR_OK:
	816	SendSysMessage(LANG_COMMAND_PASSWORD);
	817	break;
	818	case AOR_NAME_NOT_EXIST:
	819	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
	820	SetSentErrorMessage(true);
	821	return false;
	822	case AOR_PASS_TOO_LONG:
	823	SendSysMessage(LANG_PASSWORD_TOO_LONG);
	824	SetSentErrorMessage(true);
	825	return false;
	826	default:
	827	SendSysMessage(LANG_COMMAND_NOTCHANGEPASSWORD);
	828	SetSentErrorMessage(true);
	829	return false;
	830	}
	831
	832	return true;
764	833	}
765	834
…	…
1977	2046	if(!cId)
1978	2047	return false;
	2048
1979	2049	uint32 item_id = atol(cId);
1980
1981		ItemPrototype const* itemProto = item_id ? itemProto = objmgr.GetItemPrototype(item_id) : NULL;
1982
	2050	if(!item_id)
	2051	{
	2052	PSendSysMessage(LANG_COMMAND_ITEMIDINVALID, item_id);
	2053	SetSentErrorMessage(true);
	2054	return false;
	2055	}
	2056
	2057	ItemPrototype const* itemProto = objmgr.GetItemPrototype(item_id);
1983	2058	if(!itemProto)
1984	2059	{
…	…
2136	2211	}
2137	2212
2138		if(inv_count+mail_count+auc_count == 0)
	2213	// guild bank case
	2214	uint32 guild_count = 0;
	2215	result=CharacterDatabase.PQuery("SELECT COUNT(item_entry) FROM guild_bank_item WHERE item_entry='%u'",item_id);
	2216	if(result)
	2217	{
	2218	guild_count = (*result)[0].GetUInt32();
	2219	delete result;
	2220	}
	2221
	2222	result=CharacterDatabase.PQuery(
	2223	// 0 1 2
	2224	"SELECT gi.item_guid, gi.guildid, guild.name "
	2225	"FROM guild_bank_item AS gi, guild WHERE gi.item_entry='%u' AND gi.guildid = guild.guildid LIMIT %u ",
	2226	item_id,uint32(count));
	2227
	2228	if(result)
	2229	{
	2230	do
	2231	{
	2232	Field *fields = result->Fetch();
	2233	uint32 item_guid = fields[0].GetUInt32();
	2234	uint32 guild_guid = fields[1].GetUInt32();
	2235	std::string guild_name = fields[2].GetCppString();
	2236
	2237	char const* item_pos = "[in guild bank]";
	2238
	2239	PSendSysMessage(LANG_ITEMLIST_GUILD,item_guid,guild_name.c_str(),guild_guid,item_pos);
	2240	} while (result->NextRow());
	2241
	2242	int64 res_count = result->GetRowCount();
	2243
	2244	delete result;
	2245
	2246	if(count > res_count)
	2247	count-=res_count;
	2248	else if(count)
	2249	count = 0;
	2250	}
	2251
	2252	if(inv_count+mail_count+auc_count+guild_count == 0)
2139	2253	{
2140	2254	SendSysMessage(LANG_COMMAND_NOITEMFOUND);
…	…
2143	2257	}
2144	2258
2145		PSendSysMessage(LANG_COMMAND_LISTITEMMESSAGE,item_id,inv_count+mail_count+auc_count~~,inv_count,mail_count,auc~~_count);
	2259	PSendSysMessage(LANG_COMMAND_LISTITEMMESSAGE,item_id,inv_count+mail_count+auc_count+guild_count,inv_count,mail_count,auc_count,guild_count);
2146	2260
2147	2261	return true;
…	…
2153	2267	return false;
2154	2268
2155		// number or [name] Shift-click form \|color\|Hgameobject_entry:go_id\|h[name]\|h\|r
	2269	// number or [name] Shift-click form \|color\|Hgameobject_entry:go_id\|h[name]\|h\|r
2156	2270	char* cId = extractKeyFromLink((char*)args,"Hgameobject_entry");
2157	2271	if(!cId)
…	…
2159	2273
2160	2274	uint32 go_id = atol(cId);
	2275	if(!go_id)
	2276	{
	2277	PSendSysMessage(LANG_COMMAND_LISTOBJINVALIDID, go_id);
	2278	SetSentErrorMessage(true);
	2279	return false;
	2280	}
2161	2281
2162	2282	GameObjectInfo const * gInfo = objmgr.GetGameObjectInfo(go_id);
2163
2164		if(!go_id \|\| !gInfo)
	2283	if(!gInfo)
2165	2284	{
2166	2285	PSendSysMessage(LANG_COMMAND_LISTOBJINVALIDID, go_id);
…	…
2175	2294	return false;
2176	2295
2177		~~Player* pl = m_session->GetPlayer();~~
2178	2296	QueryResult *result;
2179	2297
…	…
2186	2304	}
2187	2305
2188		result = WorldDatabase.PQuery("SELECT guid, position_x, position_y, position_z, map, (POW(position_x - '%f', 2) + POW(position_y - '%f', 2) + POW(position_z - '%f', 2)) AS order_ FROM gameobject WHERE id = '%u' ORDER BY order_ ASC LIMIT %u",
2189		pl->GetPositionX(), pl->GetPositionY(), pl->GetPositionZ(),go_id,uint32(count));
	2306	if(m_session)
	2307	{
	2308	Player* pl = m_session->GetPlayer();
	2309	result = WorldDatabase.PQuery("SELECT guid, position_x, position_y, position_z, map, (POW(position_x - '%f', 2) + POW(position_y - '%f', 2) + POW(position_z - '%f', 2)) AS order_ FROM gameobject WHERE id = '%u' ORDER BY order_ ASC LIMIT %u",
	2310	pl->GetPositionX(), pl->GetPositionY(), pl->GetPositionZ(),go_id,uint32(count));
	2311	}
	2312	else
	2313	result = WorldDatabase.PQuery("SELECT guid, position_x, position_y, position_z, map FROM gameobject WHERE id = '%u' LIMIT %u",
	2314	go_id,uint32(count));
2190	2315
2191	2316	if (result)
…	…
2200	2325	int mapid = fields[4].GetUInt16();
2201	2326
2202		PSendSysMessage(LANG_GO_LIST, guid, guid, gInfo->name, x, y, z, mapid);
	2327	if (m_session)
	2328	PSendSysMessage(LANG_GO_LIST_CHAT, guid, guid, gInfo->name, x, y, z, mapid);
	2329	else
	2330	PSendSysMessage(LANG_GO_LIST_CONSOLE, guid, gInfo->name, x, y, z, mapid);
2203	2331	} while (result->NextRow());
2204	2332
…	…
2239	2367	continue;
2240	2368
2241		PSendSysMessage(LANG_GO_LIST, guid, guid, gInfo->name, x, y, z, mapid);
	2369	PSendSysMessage(LANG_GO_LIST_CHAT, guid, guid, gInfo->name, x, y, z, mapid);
2242	2370
2243	2371	++count;
…	…
2294	2422	return false;
2295	2423
2296		// number or [name] Shift-click form \|color\|Hcreature_entry:creature_id\|h[name]\|h\|r
	2424	// number or [name] Shift-click form \|color\|Hcreature_entry:creature_id\|h[name]\|h\|r
2297	2425	char* cId = extractKeyFromLink((char*)args,"Hcreature_entry");
2298	2426	if(!cId)
…	…
2300	2428
2301	2429	uint32 cr_id = atol(cId);
	2430	if(!cr_id)
	2431	{
	2432	PSendSysMessage(LANG_COMMAND_INVALIDCREATUREID, cr_id);
	2433	SetSentErrorMessage(true);
	2434	return false;
	2435	}
2302	2436
2303	2437	CreatureInfo const* cInfo = objmgr.GetCreatureTemplate(cr_id);
2304
2305		if(!cr_id \|\| !cInfo)
	2438	if(!cInfo)
2306	2439	{
2307	2440	PSendSysMessage(LANG_COMMAND_INVALIDCREATUREID, cr_id);
…	…
2316	2449	return false;
2317	2450
2318		~~Player* pl = m_session->GetPlayer();~~
2319	2451	QueryResult *result;
2320	2452
…	…
2327	2459	}
2328	2460
2329		result = WorldDatabase.PQuery("SELECT guid, position_x, position_y, position_z, map, (POW(position_x - '%f', 2) + POW(position_y - '%f', 2) + POW(position_z - '%f', 2)) AS order_ FROM creature WHERE id = '%u' ORDER BY order_ ASC LIMIT %u",
2330		pl->GetPositionX(), pl->GetPositionY(), pl->GetPositionZ(), cr_id,uint32(count));
	2461	if(m_session)
	2462	{
	2463	Player* pl = m_session->GetPlayer();
	2464	result = WorldDatabase.PQuery("SELECT guid, position_x, position_y, position_z, map, (POW(position_x - '%f', 2) + POW(position_y - '%f', 2) + POW(position_z - '%f', 2)) AS order_ FROM creature WHERE id = '%u' ORDER BY order_ ASC LIMIT %u",
	2465	pl->GetPositionX(), pl->GetPositionY(), pl->GetPositionZ(), cr_id,uint32(count));
	2466	}
	2467	else
	2468	result = WorldDatabase.PQuery("SELECT guid, position_x, position_y, position_z, map FROM creature WHERE id = '%u' LIMIT %u",
	2469	cr_id,uint32(count));
2331	2470
2332	2471	if (result)
…	…
2341	2480	int mapid = fields[4].GetUInt16();
2342	2481
2343		PSendSysMessage(LANG_CREATURE_LIST, guid, guid, cInfo->Name, x, y, z, mapid);
	2482	if (m_session)
	2483	PSendSysMessage(LANG_CREATURE_LIST_CHAT, guid, guid, cInfo->Name, x, y, z, mapid);
	2484	else
	2485	PSendSysMessage(LANG_CREATURE_LIST_CONSOLE, guid, cInfo->Name, x, y, z, mapid);
2344	2486	} while (result->NextRow());
2345	2487
…	…
2374	2516	continue;
2375	2517
2376		int loc_idx = m_session~~->GetSessionDb~~LocaleIndex();
	2518	int loc_idx = m_session ? m_session->GetSessionDbLocaleIndex() : objmgr.GetDBCLocaleIndex();
2377	2519	if ( loc_idx >= 0 )
2378	2520	{
…	…
2386	2528	if (Utf8FitTo(name, wnamepart))
2387	2529	{
2388		PSendSysMessage(LANG_ITEM_LIST, id, id, name.c_str());
	2530	if (m_session)
	2531	PSendSysMessage(LANG_ITEM_LIST_CHAT, id, id, name.c_str());
	2532	else
	2533	PSendSysMessage(LANG_ITEM_LIST_CONSOLE, id, name.c_str());
2389	2534	++counter;
2390	2535	continue;
…	…
2400	2545	if (Utf8FitTo(name, wnamepart))
2401	2546	{
2402		PSendSysMessage(LANG_ITEM_LIST, id, id, name.c_str());
	2547	if (m_session)
	2548	PSendSysMessage(LANG_ITEM_LIST_CHAT, id, id, name.c_str());
	2549	else
	2550	PSendSysMessage(LANG_ITEM_LIST_CONSOLE, id, name.c_str());
2403	2551	++counter;
2404	2552	}
…	…
2433	2581	if(set)
2434	2582	{
2435		int loc = m_session~~->GetSession~~DbcLocale();
2436		~~std::string name = set->name[m_session->GetSessionDbcLocale()~~];
	2583	int loc = m_session ? m_session->GetSessionDbcLocale() : sWorld.GetDefaultDbcLocale();
	2584	std::string name = set->name[loc];
2437	2585	if(name.empty())
2438	2586	continue;
…	…
2443	2591	for(; loc < MAX_LOCALE; ++loc)
2444	2592	{
2445		if(loc==m_session->GetSessionDbcLocale())
	2593	if(m_session && loc==m_session->GetSessionDbcLocale())
2446	2594	continue;
2447	2595
2448		name = set->name[~~m_session->GetSessionDbcLocale()~~];
	2596	name = set->name[loc];
2449	2597	if(name.empty())
2450	2598	continue;
…	…
2458	2606	{
2459	2607	// send item set in "id - [namedlink locale]" format
2460		PSendSysMessage(LANG_ITEMSET_LIST,id,id,name.c_str(),localeNames[loc]);
	2608	if (m_session)
	2609	PSendSysMessage(LANG_ITEMSET_LIST_CHAT,id,id,name.c_str(),localeNames[loc]);
	2610	else
	2611	PSendSysMessage(LANG_ITEMSET_LIST_CONSOLE,id,name.c_str(),localeNames[loc]);
2461	2612	++counter;
2462	2613	}
…	…
2470	2621	bool ChatHandler::HandleLookupSkillCommand(const char* args)
2471	2622	{
2472		Player* target = getSelectedPlayer();
2473		if(!target)
2474		{
2475		SendSysMessage(LANG_PLAYER_NOT_FOUND);
2476		SetSentErrorMessage(true);
2477		return false;
2478		}
2479
2480		if(!*args)
2481		return false;
	2623	if (!*args)
	2624	return false;
	2625
	2626	// can be NULL in console call
	2627	Player* target = getSelectedPlayer();
2482	2628
2483	2629	std::string namepart = args;
…	…
2498	2644	if(skillInfo)
2499	2645	{
2500		int loc = m_session~~->GetSession~~DbcLocale();
	2646	int loc = m_session ? m_session->GetSessionDbcLocale() : sWorld.GetDefaultDbcLocale();
2501	2647	std::string name = skillInfo->name[loc];
2502	2648	if(name.empty())
…	…
2508	2654	for(; loc < MAX_LOCALE; ++loc)
2509	2655	{
2510		if(loc==m_session->GetSessionDbcLocale())
	2656	if(m_session && loc==m_session->GetSessionDbcLocale())
2511	2657	continue;
2512	2658
…	…
2522	2668	if(loc < MAX_LOCALE)
2523	2669	{
	2670	char const* knownStr = "";
	2671	if(target && target->HasSkill(id))
	2672	knownStr = GetTrinityString(LANG_KNOWN);
	2673
2524	2674	// send skill in "id - [namedlink locale]" format
2525		PSendSysMessage(LANG_SKILL_LIST,id,id,name.c_str(),localeNames[loc],(target->HasSkill(id) ? m_session->GetTrinityString(LANG_KNOWN) : ""));
	2675	if (m_session)
	2676	PSendSysMessage(LANG_SKILL_LIST_CHAT,id,id,name.c_str(),localeNames[loc],knownStr);
	2677	else
	2678	PSendSysMessage(LANG_SKILL_LIST_CONSOLE,id,name.c_str(),localeNames[loc],knownStr);
2526	2679
2527	2680	++counter;
…	…
2536	2689	bool ChatHandler::HandleLookupSpellCommand(const char* args)
2537	2690	{
2538		Player* target = getSelectedPlayer();
2539		if( !target )
2540		{
2541		SendSysMessage(LANG_PLAYER_NOT_FOUND);
2542		SetSentErrorMessage(true);
2543		return false;
2544		}
2545
2546		if(!*args)
2547		return false;
	2691	if (!*args)
	2692	return false;
	2693
	2694	// can be NULL at console call
	2695	Player* target = getSelectedPlayer();
2548	2696
2549	2697	std::string namepart = args;
…	…
2564	2712	if(spellInfo)
2565	2713	{
2566		int loc = m_session~~->GetSession~~DbcLocale();
	2714	int loc = m_session ? m_session->GetSessionDbcLocale() : sWorld.GetDefaultDbcLocale();
2567	2715	std::string name = spellInfo->SpellName[loc];
2568	2716	if(name.empty())
…	…
2574	2722	for(; loc < MAX_LOCALE; ++loc)
2575	2723	{
2576		if(loc==m_session->GetSessionDbcLocale())
	2724	if(m_session && loc==m_session->GetSessionDbcLocale())
2577	2725	continue;
2578	2726
…	…
2588	2736	if(loc < MAX_LOCALE)
2589	2737	{
2590		bool known = target->HasSpell(id);
	2738	bool known = target && target->HasSpell(id);
2591	2739	bool learn = (spellInfo->Effect[0] == SPELL_EFFECT_LEARN_SPELL);
2592	2740
…	…
2595	2743	bool talent = (telentCost > 0);
2596	2744	bool passive = IsPassiveSpell(id);
2597		bool active = target~~->HasAura(id,0) \|\| target->HasAura(id,1) \|\| target->HasAura(id,2~~);
	2745	bool active = target && (target->HasAura(id,0) \|\| target->HasAura(id,1) \|\| target->HasAura(id,2));
2598	2746
2599	2747	// unit32 used to prevent interpreting uint8 as char at output
…	…
2603	2751	// send spell in "id - [name, rank N] [talent] [passive] [learn] [known]" format
2604	2752	std::ostringstream ss;
2605		ss << id << " - \|cffffffff\|Hspell:" << id << "\|h[" << name;
	2753	if (m_session)
	2754	ss << id << " - \|cffffffff\|Hspell:" << id << "\|h[" << name;
	2755	else
	2756	ss << id << " - " << name;
2606	2757
2607	2758	// include rank in link name
…	…
2609	2760	ss << GetTrinityString(LANG_SPELL_RANK) << rank;
2610	2761
2611		ss << " " << localeNames[loc] << "]\|h\|r";
	2762	if (m_session)
	2763	ss << " " << localeNames[loc] << "]\|h\|r";
	2764	else
	2765	ss << " " << localeNames[loc];
2612	2766
2613	2767	if(talent)
…	…
2635	2789	bool ChatHandler::HandleLookupQuestCommand(const char* args)
2636	2790	{
2637		Player* target = getSelectedPlayer();
2638		if( !target )
2639		{
2640		SendSysMessage(LANG_PLAYER_NOT_FOUND);
2641		SetSentErrorMessage(true);
2642		return false;
2643		}
2644
2645		if(!*args)
2646		return false;
	2791	if (!*args)
	2792	return false;
	2793
	2794	// can be NULL at console call
	2795	Player* target = getSelectedPlayer();
2647	2796
2648	2797	std::string namepart = args;
…	…
2662	2811	Quest * qinfo = iter->second;
2663	2812
2664		int loc_idx = m_session~~->GetSessionDb~~LocaleIndex();
	2813	int loc_idx = m_session ? m_session->GetSessionDbLocaleIndex() : objmgr.GetDBCLocaleIndex();
2665	2814	if ( loc_idx >= 0 )
2666	2815	{
…	…
2674	2823	if (Utf8FitTo(title, wnamepart))
2675	2824	{
2676		~~QuestStatus status = target->GetQuestStatus(qinfo->GetQuestId());~~
2677
2678	2825	char const* statusStr = "";
2679		if(status == QUEST_STATUS_COMPLETE)
	2826
	2827	if(target)
2680	2828	{
2681		if(target->GetQuestRewardStatus(qinfo->GetQuestId()))
2682		statusStr = GetTrinityString(LANG_COMMAND_QUEST_REWARDED);
2683		else
2684		statusStr = GetTrinityString(LANG_COMMAND_QUEST_COMPLETE);
	2829	QuestStatus status = target->GetQuestStatus(qinfo->GetQuestId());
	2830
	2831	if(status == QUEST_STATUS_COMPLETE)
	2832	{
	2833	if(target->GetQuestRewardStatus(qinfo->GetQuestId()))
	2834	statusStr = GetTrinityString(LANG_COMMAND_QUEST_REWARDED);
	2835	else
	2836	statusStr = GetTrinityString(LANG_COMMAND_QUEST_COMPLETE);
	2837	}
	2838	else if(status == QUEST_STATUS_INCOMPLETE)
	2839	statusStr = GetTrinityString(LANG_COMMAND_QUEST_ACTIVE);
2685	2840	}
2686		else if(status == QUEST_STATUS_INCOMPLETE)
2687		statusStr = GetTrinityString(LANG_COMMAND_QUEST_ACTIVE);
2688
2689		PSendSysMessage(LANG_QUEST_LIST,qinfo->GetQuestId(),qinfo->GetQuestId(),title.c_str(),(status == QUEST_STATUS_COMPLETE ? GetTrinityString(LANG_COMPLETE) : (status == QUEST_STATUS_INCOMPLETE ? GetTrinityString(LANG_ACTIVE) : "") ));
	2841
	2842	if (m_session)
	2843	PSendSysMessage(LANG_QUEST_LIST_CHAT,qinfo->GetQuestId(),qinfo->GetQuestId(),title.c_str(),statusStr);
	2844	else
	2845	PSendSysMessage(LANG_QUEST_LIST_CONSOLE,qinfo->GetQuestId(),title.c_str(),statusStr);
	2846
2690	2847	++counter;
2691	2848	continue;
…	…
2701	2858	if (Utf8FitTo(title, wnamepart))
2702	2859	{
2703		~~QuestStatus status = target->GetQuestStatus(qinfo->GetQuestId());~~
2704
2705	2860	char const* statusStr = "";
2706		if(status == QUEST_STATUS_COMPLETE)
	2861
	2862	if(target)
2707	2863	{
2708		if(target->GetQuestRewardStatus(qinfo->GetQuestId()))
2709		statusStr = GetTrinityString(LANG_COMMAND_QUEST_REWARDED);
2710		else
2711		statusStr = GetTrinityString(LANG_COMMAND_QUEST_COMPLETE);
	2864	QuestStatus status = target->GetQuestStatus(qinfo->GetQuestId());
	2865
	2866	if(status == QUEST_STATUS_COMPLETE)
	2867	{
	2868	if(target->GetQuestRewardStatus(qinfo->GetQuestId()))
	2869	statusStr = GetTrinityString(LANG_COMMAND_QUEST_REWARDED);
	2870	else
	2871	statusStr = GetTrinityString(LANG_COMMAND_QUEST_COMPLETE);
	2872	}
	2873	else if(status == QUEST_STATUS_INCOMPLETE)
	2874	statusStr = GetTrinityString(LANG_COMMAND_QUEST_ACTIVE);
2712	2875	}
2713		else if(status == QUEST_STATUS_INCOMPLETE)
2714		statusStr = GetTrinityString(LANG_COMMAND_QUEST_ACTIVE);
2715
2716		PSendSysMessage(LANG_QUEST_LIST,qinfo->GetQuestId(),qinfo->GetQuestId(), title.c_str(),(status == QUEST_STATUS_COMPLETE ? GetTrinityString(LANG_COMPLETE) : (status == QUEST_STATUS_INCOMPLETE ? GetTrinityString(LANG_ACTIVE) : "") ));
	2876
	2877	if (m_session)
	2878	PSendSysMessage(LANG_QUEST_LIST_CHAT,qinfo->GetQuestId(),qinfo->GetQuestId(),title.c_str(),statusStr);
	2879	else
	2880	PSendSysMessage(LANG_QUEST_LIST_CONSOLE,qinfo->GetQuestId(),title.c_str(),statusStr);
	2881
2717	2882	++counter;
2718	2883	}
…	…
2727	2892	bool ChatHandler::HandleLookupCreatureCommand(const char* args)
2728	2893	{
2729		if(!*args)
	2894	if (!*args)
2730	2895	return false;
2731	2896
…	…
2734	2899
2735	2900	// converting string that we try to find to lower case
2736		if~~(!Utf8toWStr~~(namepart,wnamepart))
2737		return false;
2738
2739		wstrToLower(wnamepart);
	2901	if (!Utf8toWStr (namepart,wnamepart))
	2902	return false;
	2903
	2904	wstrToLower (wnamepart);
2740	2905
2741	2906	uint32 counter = 0;
2742	2907
2743		for (uint32 id = 0; id< sCreatureStorage.MaxEntry; ~~id++~~ )
2744		{
2745		CreatureInfo const* cInfo = sCreatureStorage.LookupEntry<CreatureInfo>(id);
	2908	for (uint32 id = 0; id< sCreatureStorage.MaxEntry; ++id)
	2909	{
	2910	CreatureInfo const* cInfo = sCreatureStorage.LookupEntry<CreatureInfo> (id);
2746	2911	if(!cInfo)
2747	2912	continue;
2748	2913
2749		int loc_idx = m_session~~->GetSessionDb~~LocaleIndex();
2750		~~if ( loc_idx >= 0~~ )
	2914	int loc_idx = m_session ? m_session->GetSessionDbLocaleIndex() : objmgr.GetDBCLocaleIndex();
	2915	if (loc_idx >= 0)
2751	2916	{
2752		CreatureLocale const *cl = objmgr.GetCreatureLocale(id);
	2917	CreatureLocale const *cl = objmgr.GetCreatureLocale (id);
2753	2918	if (cl)
2754	2919	{
2755		if (cl->Name.size() > loc_idx && !cl->Name[loc_idx].empty())
	2920	if (cl->Name.size() > loc_idx && !cl->Name[loc_idx].empty ())
2756	2921	{
2757	2922	std::string name = cl->Name[loc_idx];
2758	2923
2759		if (Utf8FitTo(name, wnamepart))
	2924	if (Utf8FitTo (name, wnamepart))
2760	2925	{
2761		PSendSysMessage(LANG_CREATURE_ENTRY_LIST, id, id, name.c_str());
	2926	if (m_session)
	2927	PSendSysMessage (LANG_CREATURE_ENTRY_LIST_CHAT, id, id, name.c_str ());
	2928	else
	2929	PSendSysMessage (LANG_CREATURE_ENTRY_LIST_CONSOLE, id, name.c_str ());
	2930
2762	2931	++counter;
2763	2932	continue;
…	…
2768	2937
2769	2938	std::string name = cInfo->Name;
2770		if~~(name.empty~~())
	2939	if (name.empty ())
2771	2940	continue;
2772	2941
2773	2942	if (Utf8FitTo(name, wnamepart))
2774	2943	{
2775		PSendSysMessage(LANG_CREATURE_ENTRY_LIST,id,id,name.c_str());
	2944	if (m_session)
	2945	PSendSysMessage (LANG_CREATURE_ENTRY_LIST_CHAT, id, id, name.c_str ());
	2946	else
	2947	PSendSysMessage (LANG_CREATURE_ENTRY_LIST_CONSOLE, id, name.c_str ());
2776	2948	++counter;
2777	2949	}
…	…
2779	2951
2780	2952	if (counter==0)
2781		SendSysMessage(LANG_COMMAND_NOCREATUREFOUND);
	2953	SendSysMessage (LANG_COMMAND_NOCREATUREFOUND);
2782	2954
2783	2955	return true;
…	…
2806	2978	continue;
2807	2979
2808		int loc_idx = m_session~~->GetSessionDb~~LocaleIndex();
	2980	int loc_idx = m_session ? m_session->GetSessionDbLocaleIndex() : objmgr.GetDBCLocaleIndex();
2809	2981	if ( loc_idx >= 0 )
2810	2982	{
…	…
2818	2990	if (Utf8FitTo(name, wnamepart))
2819	2991	{
2820		PSendSysMessage(LANG_GO_ENTRY_LIST, id, id, name.c_str());
	2992	if (m_session)
	2993	PSendSysMessage(LANG_GO_ENTRY_LIST_CHAT, id, id, name.c_str());
	2994	else
	2995	PSendSysMessage(LANG_GO_ENTRY_LIST_CONSOLE, id, name.c_str());
2821	2996	++counter;
2822	2997	continue;
…	…
2832	3007	if(Utf8FitTo(name, wnamepart))
2833	3008	{
2834		PSendSysMessage(LANG_GO_ENTRY_LIST, id, id, name.c_str());
	3009	if (m_session)
	3010	PSendSysMessage(LANG_GO_ENTRY_LIST_CHAT, id, id, name.c_str());
	3011	else
	3012	PSendSysMessage(LANG_GO_ENTRY_LIST_CONSOLE, id, name.c_str());
2835	3013	++counter;
2836	3014	}
…	…
2857	3035	return false;
2858	3036
2859		Guild *guild;
2860		Player * player;
2861		char lname,gname;
2862		std::string guildname;
2863
2864		lname = strtok((char*)args, " ");
2865		gname = strtok(NULL, "");
2866
2867		if(!lname)
2868		return false;
2869		else if(!gname)
2870		{
2871		SendSysMessage(LANG_INSERT_GUILD_NAME);
2872		SetSentErrorMessage(true);
2873		return false;
2874		}
2875
2876		guildname = gname;
2877		player = ObjectAccessor::Instance().FindPlayerByName(lname);
2878
2879		if(!player)
2880		{
2881		SendSysMessage(LANG_PLAYER_NOT_FOUND);
2882		SetSentErrorMessage(true);
2883		return false;
2884		}
2885
2886		if(!player->GetGuildId())
2887		{
2888		guild = new Guild;
2889		if(!guild->create(player->GetGUID(),guildname))
2890		{
2891		delete guild;
2892		SendSysMessage(LANG_GUILD_NOT_CREATED);
2893		SetSentErrorMessage(true);
2894		return false;
2895		}
2896
2897		objmgr.AddGuild(guild);
2898		}
2899		else
2900		SendSysMessage(LANG_PLAYER_IN_GUILD);
2901
	3037	char lname = strtok ((char)args, " ");
	3038	char *gname = strtok (NULL, "");
	3039
	3040	if (!lname)
	3041	return false;
	3042
	3043	if (!gname)
	3044	{
	3045	SendSysMessage (LANG_INSERT_GUILD_NAME);
	3046	SetSentErrorMessage (true);
	3047	return false;
	3048	}
	3049
	3050	std::string guildname = gname;
	3051
	3052	Player* player = ObjectAccessor::Instance ().FindPlayerByName (lname);
	3053	if (!player)
	3054	{
	3055	SendSysMessage (LANG_PLAYER_NOT_FOUND);
	3056	SetSentErrorMessage (true);
	3057	return false;
	3058	}
	3059
	3060	if (player->GetGuildId())
	3061	{
	3062	SendSysMessage (LANG_PLAYER_IN_GUILD);
	3063	return true;
	3064	}
	3065
	3066	Guild *guild = new Guild;
	3067	if (!guild->create (player->GetGUID (),guildname))
	3068	{
	3069	delete guild;
	3070	SendSysMessage (LANG_GUILD_NOT_CREATED);
	3071	SetSentErrorMessage (true);
	3072	return false;
	3073	}
	3074
	3075	objmgr.AddGuild (guild);
2902	3076	return true;
2903	3077	}
…	…
2905	3079	bool ChatHandler::HandleGuildInviteCommand(const char *args)
2906	3080	{
2907		if(!*args)
2908		return false;
2909
2910		char* par1 = strtok((char*)args, " ");
	3081	if (!*args)
	3082	return false;
	3083
	3084	char* par1 = strtok ((char*)args, " ");
2911	3085	char* par2 = strtok (NULL, "");
2912	3086	if(!par1 \|\| !par2)
…	…
2914	3088
2915	3089	std::string glName = par2;
2916		Guild* targetGuild = objmgr.GetGuildByName(glName);
2917		if(!targetGuild)
	3090	Guild* targetGuild = objmgr.GetGuildByName (glName);
	3091	if (!targetGuild)
2918	3092	return false;
2919	3093
2920	3094	std::string plName = par1;
2921		if~~(!normalizePlayerName~~(plName))
2922		{
2923		SendSysMessage(LANG_PLAYER_NOT_FOUND);
2924		~~SetSentErrorMessage~~(true);
	3095	if (!normalizePlayerName (plName))
	3096	{
	3097	SendSysMessage (LANG_PLAYER_NOT_FOUND);
	3098	SetSentErrorMessage (true);
2925	3099	return false;
2926	3100	}
2927	3101
2928	3102	uint64 plGuid = 0;
2929		if~~(Player* targetPlayer = ObjectAccessor::Instance().FindPlayerByName(plName.c_str~~()))
2930		~~plGuid = targetPlayer->GetGUID~~();
	3103	if (Player* targetPlayer = ObjectAccessor::Instance ().FindPlayerByName (plName.c_str ()))
	3104	plGuid = targetPlayer->GetGUID ();
2931	3105	else
2932		plGuid = objmgr.GetPlayerGUIDByName~~(plName.c_str~~());
2933
2934		if(!plGuid)
	3106	plGuid = objmgr.GetPlayerGUIDByName (plName.c_str ());
	3107
	3108	if (!plGuid)
2935	3109	false;
2936	3110
2937	3111	// players's guild membership checked in AddMember before add
2938		if~~(!targetGuild->AddMember(plGuid,targetGuild->GetLowestRank~~()))
	3112	if (!targetGuild->AddMember (plGuid,targetGuild->GetLowestRank ()))
2939	3113	return false;
2940	3114
…	…
2944	3118	bool ChatHandler::HandleGuildUninviteCommand(const char *args)
2945	3119	{
2946		if(!*args)
2947		return false;
2948
2949		char* par1 = strtok((char*)args, " ");
	3120	if (!*args)
	3121	return false;
	3122
	3123	char* par1 = strtok ((char*)args, " ");
2950	3124	if(!par1)
2951	3125	return false;
	3126
2952	3127	std::string plName = par1;
2953		if~~(!normalizePlayerName~~(plName))
2954		{
2955		SendSysMessage(LANG_PLAYER_NOT_FOUND);
2956		~~SetSentErrorMessage~~(true);
	3128	if (!normalizePlayerName (plName))
	3129	{
	3130	SendSysMessage (LANG_PLAYER_NOT_FOUND);
	3131	SetSentErrorMessage (true);
2957	3132	return false;
2958	3133	}
…	…
2960	3135	uint64 plGuid = 0;
2961	3136	uint32 glId = 0;
2962		if~~(Player* targetPlayer = ObjectAccessor::Instance().FindPlayerByName(plName.c_str~~()))
2963		{
2964		plGuid = targetPlayer->GetGUID();
2965		~~glId = targetPlayer->GetGuildId~~();
	3137	if (Player* targetPlayer = ObjectAccessor::Instance ().FindPlayerByName (plName.c_str ()))
	3138	{
	3139	plGuid = targetPlayer->GetGUID ();
	3140	glId = targetPlayer->GetGuildId ();
2966	3141	}
2967	3142	else
2968	3143	{
2969		plGuid = objmgr.GetPlayerGUIDByName~~(plName.c_str~~());
2970		~~glId = Player::GetGuildIdFromDB~~(plGuid);
2971		}
2972
2973		if(!plGuid \|\| !glId)
2974		return false;
2975
2976		Guild* targetGuild = objmgr.GetGuildById(glId);
2977		if(!targetGuild)
2978		return false;
2979
2980		targetGuild->DelMember(plGuid);
	3144	plGuid = objmgr.GetPlayerGUIDByName (plName.c_str ());
	3145	glId = Player::GetGuildIdFromDB (plGuid);
	3146	}
	3147
	3148	if (!plGuid \|\| !glId)
	3149	return false;
	3150
	3151	Guild* targetGuild = objmgr.GetGuildById (glId);
	3152	if (!targetGuild)
	3153	return false;
	3154
	3155	targetGuild->DelMember (plGuid);
2981	3156
2982	3157	return true;
…	…
2985	3160	bool ChatHandler::HandleGuildRankCommand(const char *args)
2986	3161	{
2987		if(!*args)
2988		return false;
2989
2990		char* par1 = strtok((char*)args, " ");
2991		char* par2 = strtok(NULL, " ");
2992		if(!par1 \|\| !par2)
2993		return false;
	3162	if (!*args)
	3163	return false;
	3164
	3165	char* par1 = strtok ((char*)args, " ");
	3166	char* par2 = strtok (NULL, " ");
	3167	if (!par1 \|\| !par2)
	3168	return false;
	3169
2994	3170	std::string plName = par1;
2995		if~~(!normalizePlayerName~~(plName))
2996		{
2997		SendSysMessage(LANG_PLAYER_NOT_FOUND);
2998		~~SetSentErrorMessage~~(true);
	3171	if (!normalizePlayerName (plName))
	3172	{
	3173	SendSysMessage (LANG_PLAYER_NOT_FOUND);
	3174	SetSentErrorMessage (true);
2999	3175	return false;
3000	3176	}
…	…
3002	3178	uint64 plGuid = 0;
3003	3179	uint32 glId = 0;
3004		if~~(Player* targetPlayer = ObjectAccessor::Instance().FindPlayerByName(plName.c_str~~()))
3005		{
3006		plGuid = targetPlayer->GetGUID();
3007		~~glId = targetPlayer->GetGuildId~~();
	3180	if (Player* targetPlayer = ObjectAccessor::Instance ().FindPlayerByName (plName.c_str ()))
	3181	{
	3182	plGuid = targetPlayer->GetGUID ();
	3183	glId = targetPlayer->GetGuildId ();
3008	3184	}
3009	3185	else
3010	3186	{
3011		plGuid = objmgr.GetPlayerGUIDByName~~(plName.c_str~~());
3012		~~glId = Player::GetGuildIdFromDB~~(plGuid);
3013		}
3014
3015		if(!plGuid \|\| !glId)
3016		return false;
3017
3018		Guild* targetGuild = objmgr.GetGuildById(glId);
3019		if(!targetGuild)
3020		return false;
3021
3022		uint32 newrank = uint32~~(atoi~~(par2));
3023		~~if(newrank > targetGuild->GetLowestRank~~())
3024		return false;
3025
3026		targetGuild->ChangeRank(plGuid,newrank);
	3187	plGuid = objmgr.GetPlayerGUIDByName (plName.c_str ());
	3188	glId = Player::GetGuildIdFromDB (plGuid);
	3189	}
	3190
	3191	if (!plGuid \|\| !glId)
	3192	return false;
	3193
	3194	Guild* targetGuild = objmgr.GetGuildById (glId);
	3195	if (!targetGuild)
	3196	return false;
	3197
	3198	uint32 newrank = uint32 (atoi (par2));
	3199	if (newrank > targetGuild->GetLowestRank ())
	3200	return false;
	3201
	3202	targetGuild->ChangeRank (plGuid,newrank);
3027	3203
3028	3204	return true;
…	…
3031	3207	bool ChatHandler::HandleGuildDeleteCommand(const char* args)
3032	3208	{
3033		if(!*args)
3034		return false;
3035
3036		char* par1 = strtok((char*)args, " ");
3037		if(!par1)
	3209	if (!*args)
	3210	return false;
	3211
	3212	char* par1 = strtok ((char*)args, " ");
	3213	if (!par1)
3038	3214	return false;
3039	3215
3040	3216	std::string gld = par1;
3041	3217
3042		Guild* targetGuild = objmgr.GetGuildByName(gld);
3043		if(!targetGuild)
3044		return false;
3045
3046		targetGuild->Disband();
	3218	Guild* targetGuild = objmgr.GetGuildByName (gld);
	3219	if (!targetGuild)
	3220	return false;
	3221
	3222	targetGuild->Disband ();
3047	3223
3048	3224	return true;
…	…
3472	3648	}
3473	3649
3474		~~bool ChatHandler::HandleSpawnTransportCommand(const char* /args/)~~
3475		{
3476		~~return true;~~
3477		}
3478
3479	3650	//play npc emote
3480	3651	bool ChatHandler::HandlePlayEmoteCommand(const char* args)
…	…
4721	4892	}
4722	4893
4723		bool ChatHandler::HandleBanCommand(const char* args)
4724		{
4725		if(!args)
4726		return false;
4727
4728		char* type = strtok((char*)args, " ");
4729
4730		if(!type)
4731		return false;
4732		char* nameOrIP = strtok(NULL, " ");
4733
4734		if(!nameOrIP)
4735		return false;
4736
4737		char* duration = strtok(NULL," ");
	4894	bool ChatHandler::HandleBanAccountCommand(const char* args)
	4895	{
	4896	return HandleBanHelper(BAN_ACCOUNT,args);
	4897	}
	4898
	4899	bool ChatHandler::HandleBanCharacterCommand(const char* args)
	4900	{
	4901	return HandleBanHelper(BAN_CHARACTER,args);
	4902	}
	4903
	4904	bool ChatHandler::HandleBanIPCommand(const char* args)
	4905	{
	4906	return HandleBanHelper(BAN_IP,args);
	4907	}
	4908
	4909	bool ChatHandler::HandleBanHelper(BanMode mode, const char* args)
	4910	{
	4911	if(!args)
	4912	return false;
	4913
	4914	char* cnameOrIP = strtok ((char*)args, " ");
	4915	if (!cnameOrIP)
	4916	return false;
	4917
	4918	std::string nameOrIP = cnameOrIP;
	4919
	4920	char* duration = strtok (NULL," ");
4738	4921	if(!duration \|\| !atoi(duration))
4739	4922	return false;
4740	4923
4741		char* reason = strtok(NULL,"");
	4924	char* reason = strtok (NULL,"");
4742	4925	if(!reason)
4743	4926	return false;
4744	4927
4745		switch(sWorld.BanAccount(type, nameOrIP, duration, reason,m_session->GetPlayerName()))
	4928	switch(mode)
	4929	{
	4930	case BAN_ACCOUNT:
	4931	if(!AccountMgr::normilizeString(nameOrIP))
	4932	{
	4933	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,nameOrIP.c_str());
	4934	SetSentErrorMessage(true);
	4935	return false;
	4936	}
	4937	break;
	4938	case BAN_CHARACTER:
	4939	if(!normalizePlayerName(nameOrIP))
	4940	{
	4941	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	4942	SetSentErrorMessage(true);
	4943	return false;
	4944	}
	4945	break;
	4946	case BAN_IP:
	4947	if(!IsIPAddress(nameOrIP.c_str()))
	4948	return false;
	4949	break;
	4950	}
	4951
	4952	switch(sWorld.BanAccount(mode, nameOrIP, duration, reason,m_session ? m_session->GetPlayerName() : ""))
4746	4953	{
4747	4954	case BAN_SUCCESS:
4748	4955	if(atoi(duration)>0)
4749		PSendSysMessage(LANG_BAN_YOUBANNED,nameOrIP,secsToTimeString(TimeStringToSecs(duration),true).c_str(),reason);
	4956	PSendSysMessage(LANG_BAN_YOUBANNED,nameOrIP.c_str(),secsToTimeString(TimeStringToSecs(duration),true).c_str(),reason);
4750	4957	else
4751		PSendSysMessage(LANG_BAN_YOUPERMBANNED,nameOrIP,reason);
	4958	PSendSysMessage(LANG_BAN_YOUPERMBANNED,nameOrIP.c_str(),reason);
4752	4959	break;
4753	4960	case BAN_SYNTAX_ERROR:
4754	4961	return false;
4755	4962	case BAN_NOTFOUND:
4756		PSendSysMessage(LANG_BAN_NOTFOUND,type,nameOrIP);
4757		break;
4758		}
4759
4760		return true;
4761		}
4762
4763		bool ChatHandler::HandleUnBanCommand(const char* args)
	4963	switch(mode)
	4964	{
	4965	default:
	4966	PSendSysMessage(LANG_BAN_NOTFOUND,"account",nameOrIP.c_str());
	4967	break;
	4968	case BAN_CHARACTER:
	4969	PSendSysMessage(LANG_BAN_NOTFOUND,"character",nameOrIP.c_str());
	4970	break;
	4971	case BAN_IP:
	4972	PSendSysMessage(LANG_BAN_NOTFOUND,"ip",nameOrIP.c_str());
	4973	break;
	4974
	4975	}
	4976	SetSentErrorMessage(true);
	4977	return false;
	4978	}
	4979
	4980	return true;
	4981	}
	4982
	4983	bool ChatHandler::HandleUnBanAccountCommand(const char* args)
	4984	{
	4985	return HandleUnBanHelper(BAN_ACCOUNT,args);
	4986	}
	4987
	4988	bool ChatHandler::HandleUnBanCharacterCommand(const char* args)
	4989	{
	4990	return HandleUnBanHelper(BAN_CHARACTER,args);
	4991	}
	4992
	4993	bool ChatHandler::HandleUnBanIPCommand(const char* args)
	4994	{
	4995	return HandleUnBanHelper(BAN_IP,args);
	4996	}
	4997
	4998	bool ChatHandler::HandleUnBanHelper(BanMode mode, const char* args)
4764	4999	{
4765	5000	if(!args)
4766	5001	return false;
4767		char* type = strtok((char*)args, " ");
4768		if(!type)
4769		return false;
4770		char* nameOrIP = strtok(NULL, " ");
4771
4772		if(!nameOrIP)
4773		return false;
4774
4775		if(sWorld.RemoveBanAccount(type,nameOrIP))
4776		PSendSysMessage(LANG_UNBAN_UNBANNED,nameOrIP);
4777		else
4778		PSendSysMessage(LANG_UNBAN_ERROR,nameOrIP);
4779
4780		return true;
4781		}
4782
4783		bool ChatHandler::HandleBanInfoCommand(const char* args)
4784		{
4785		if(!args)
4786		return false;
4787
4788		char* cType = strtok((char*)args, " ");
4789		char* cnameOrIP = strtok(NULL, "");
4790		if(!cType \|\| !cnameOrIP)
	5002
	5003	char* cnameOrIP = strtok ((char*)args, " ");
	5004	if(!cnameOrIP)
4791	5005	return false;
4792	5006
4793	5007	std::string nameOrIP = cnameOrIP;
4794		std::string type = cType;
4795		if (!IsIPAddress(cnameOrIP) && type=="ip")
4796		return false;
4797
4798		Field *fields;
4799		if(type != "ip")
4800		{
4801		//look the accountid up
4802		uint32 accountid;
4803		std::string accountname;
4804		if(type == "account")
4805		{
4806		loginDatabase.escape_string(nameOrIP);
4807		QueryResult *result = loginDatabase.PQuery("SELECT id, username FROM account WHERE username = '%s'",nameOrIP.c_str());
4808		if (!result)
	5008	switch(mode)
	5009	{
	5010	case BAN_ACCOUNT:
	5011	if(!AccountMgr::normilizeString(nameOrIP))
4809	5012	{
4810		PSendSysMessage(LANG_BANINFO_NOACCOUNT);
4811		return true;
4812		}
4813		fields = result->Fetch();
4814		accountid = fields[0].GetUInt32();
4815		accountname = fields[1].GetCppString();
4816		delete result;
4817		}
4818		else if(type == "character")
4819		{
4820		if(!normalizePlayerName(nameOrIP))
	5013	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,nameOrIP.c_str());
	5014	SetSentErrorMessage(true);
	5015	return false;
	5016	}
	5017	break;
	5018	case BAN_CHARACTER:
	5019	if(!normalizePlayerName(nameOrIP))
4821	5020	{
4822	5021	SendSysMessage(LANG_PLAYER_NOT_FOUND);
…	…
4824	5023	return false;
4825	5024	}
4826
4827		accountid = objmgr.GetPlayerAccountIdByPlayerName (nameOrIP);
4828		if (!accountid)
4829		{
4830		PSendSysMessage(LANG_BANINFO_NOCHARACTER);
4831		return true;
4832		}
4833
4834		if (!accmgr.GetName (accountid,accountname))
4835		{
4836		PSendSysMessage(LANG_BANINFO_NOCHARACTER);
4837		return true;
4838		}
4839		}
4840		else
4841		return false;
4842
4843		QueryResult *result = loginDatabase.PQuery("SELECT FROM_UNIXTIME(bandate), unbandate-bandate, active, unbandate,banreason,bannedby FROM account_banned WHERE id = '%u' ORDER BY bandate ASC",accountid);
4844		if(!result)
	5025	break;
	5026	case BAN_IP:
	5027	if(!IsIPAddress(nameOrIP.c_str()))
	5028	return false;
	5029	break;
	5030	}
	5031
	5032	if(sWorld.RemoveBanAccount(mode,nameOrIP))
	5033	PSendSysMessage(LANG_UNBAN_UNBANNED,nameOrIP.c_str());
	5034	else
	5035	PSendSysMessage(LANG_UNBAN_ERROR,nameOrIP.c_str());
	5036
	5037	return true;
	5038	}
	5039
	5040	bool ChatHandler::HandleBanInfoAccountCommand(const char* args)
	5041	{
	5042	if(!args)
	5043	return false;
	5044
	5045	char* cname = strtok((char*)args, "");
	5046	if(!cname)
	5047	return false;
	5048
	5049	std::string account_name = cname;
	5050	if(!AccountMgr::normilizeString(account_name))
	5051	{
	5052	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
	5053	SetSentErrorMessage(true);
	5054	return false;
	5055	}
	5056
	5057	uint32 accountid = accmgr.GetId(account_name);
	5058	if(!accountid)
	5059	{
	5060	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
	5061	return true;
	5062	}
	5063
	5064	return HandleBanInfoHelper(accountid,account_name.c_str());
	5065	}
	5066
	5067	bool ChatHandler::HandleBanInfoCharacterCommand(const char* args)
	5068	{
	5069	if(!args)
	5070	return false;
	5071
	5072	char* cname = strtok ((char*)args, "");
	5073	if(!cname)
	5074	return false;
	5075
	5076	std::string name = cname;
	5077	if(!normalizePlayerName(name))
	5078	{
	5079	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	5080	SetSentErrorMessage(true);
	5081	return false;
	5082	}
	5083
	5084	uint32 accountid = objmgr.GetPlayerAccountIdByPlayerName(name);
	5085	if(!accountid)
	5086	{
	5087	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	5088	SetSentErrorMessage(true);
	5089	return false;
	5090	}
	5091
	5092	std::string accountname;
	5093	if(!accmgr.GetName(accountid,accountname))
	5094	{
	5095	PSendSysMessage(LANG_BANINFO_NOCHARACTER);
	5096	return true;
	5097	}
	5098
	5099	return HandleBanInfoHelper(accountid,accountname.c_str());
	5100	}
	5101
	5102	bool ChatHandler::HandleBanInfoHelper(uint32 accountid, char const* accountname)
	5103	{
	5104	QueryResult *result = loginDatabase.PQuery("SELECT FROM_UNIXTIME(bandate), unbandate-bandate, active, unbandate,banreason,bannedby FROM account_banned WHERE id = '%u' ORDER BY bandate ASC",accountid);
	5105	if(!result)
	5106	{
	5107	PSendSysMessage(LANG_BANINFO_NOACCOUNTBAN, accountname);
	5108	return true;
	5109	}
	5110
	5111	PSendSysMessage(LANG_BANINFO_BANHISTORY,accountname);
	5112	do
	5113	{
	5114	Field* fields = result->Fetch();
	5115
	5116	time_t unbandate = time_t(fields[3].GetUInt64());
	5117	bool active = false;
	5118	if(fields[2].GetBool() && (fields[1].GetUInt64() == (uint64)0 \|\|unbandate >= time(NULL)) )
	5119	active = true;
	5120	bool permanent = (fields[1].GetUInt64() == (uint64)0);
	5121	std::string bantime = permanent?GetTrinityString(LANG_BANINFO_INFINITE):secsToTimeString(fields[1].GetUInt64(), true);
	5122	PSendSysMessage(LANG_BANINFO_HISTORYENTRY,
	5123	fields[0].GetString(), bantime.c_str(), active ? GetTrinityString(LANG_BANINFO_YES):GetTrinityString(LANG_BANINFO_NO), fields[4].GetString(), fields[5].GetString());
	5124	}while (result->NextRow());
	5125
	5126	delete result;
	5127	return true;
	5128	}
	5129
	5130	bool ChatHandler::HandleBanInfoIPCommand(const char* args)
	5131	{
	5132	if(!args)
	5133	return false;
	5134
	5135	char* cIP = strtok ((char*)args, "");
	5136	if(!cIP)
	5137	return false;
	5138
	5139	if (!IsIPAddress(cIP))
	5140	return false;
	5141
	5142	std::string IP = cIP;
	5143
	5144	loginDatabase.escape_string(IP);
	5145	QueryResult *result = loginDatabase.PQuery("SELECT ip, FROM_UNIXTIME(bandate), FROM_UNIXTIME(unbandate), unbandate-UNIX_TIMESTAMP(), banreason,bannedby,unbandate-bandate FROM ip_banned WHERE ip = '%s'",IP.c_str());
	5146	if(!result)
	5147	{
	5148	PSendSysMessage(LANG_BANINFO_NOIP);
	5149	return true;
	5150	}
	5151
	5152	Field *fields = result->Fetch();
	5153	bool permanent = !fields[6].GetUInt64();
	5154	PSendSysMessage(LANG_BANINFO_IPENTRY,
	5155	fields[0].GetString(), fields[1].GetString(), permanent ? GetTrinityString(LANG_BANINFO_NEVER):fields[2].GetString(),
	5156	permanent ? GetTrinityString(LANG_BANINFO_INFINITE):secsToTimeString(fields[3].GetUInt64(), true).c_str(), fields[4].GetString(), fields[5].GetString());
	5157	delete result;
	5158	return true;
	5159	}
	5160
	5161	bool ChatHandler::HandleBanListCharacterCommand(const char* args)
	5162	{
	5163	loginDatabase.Execute("DELETE FROM ip_banned WHERE unbandate<=UNIX_TIMESTAMP() AND unbandate<>bandate");
	5164
	5165	char* cFilter = strtok ((char*)args, " ");
	5166	if(!cFilter)
	5167	return false;
	5168
	5169	std::string filter = cFilter;
	5170	loginDatabase.escape_string(filter);
	5171	QueryResult* result = CharacterDatabase.PQuery("SELECT account FROM characters WHERE name "_LIKE_" "_CONCAT3_("'%%'","'%s'","'%%'"),filter.c_str());
	5172	if (!result)
	5173	{
	5174	PSendSysMessage(LANG_BANLIST_NOCHARACTER);
	5175	return true;
	5176	}
	5177
	5178	return HandleBanListHelper(result);
	5179	}
	5180
	5181	bool ChatHandler::HandleBanListAccountCommand(const char* args)
	5182	{
	5183	loginDatabase.Execute("DELETE FROM ip_banned WHERE unbandate<=UNIX_TIMESTAMP() AND unbandate<>bandate");
	5184
	5185	char* cFilter = strtok((char*)args, " ");
	5186	std::string filter = cFilter ? cFilter : "";
	5187	loginDatabase.escape_string(filter);
	5188
	5189	QueryResult* result;
	5190
	5191	if(filter.empty())
	5192	{
	5193	result = loginDatabase.Query("SELECT account.id, username FROM account, account_banned"
	5194	" WHERE account.id = account_banned.id AND active = 1 GROUP BY account.id");
	5195	}
	5196	else
	5197	{
	5198	result = loginDatabase.PQuery("SELECT account.id, username FROM account, account_banned"
	5199	" WHERE account.id = account_banned.id AND active = 1 AND username "_LIKE_" "_CONCAT3_("'%%'","'%s'","'%%'")" GROUP BY account.id",
	5200	filter.c_str());
	5201	}
	5202
	5203	if (!result)
	5204	{
	5205	PSendSysMessage(LANG_BANLIST_NOACCOUNT);
	5206	return true;
	5207	}
	5208
	5209	return HandleBanListHelper(result);
	5210	}
	5211
	5212	bool ChatHandler::HandleBanListHelper(QueryResult* result)
	5213	{
	5214	PSendSysMessage(LANG_BANLIST_MATCHINGACCOUNT);
	5215
	5216	// Chat short output
	5217	if(m_session)
	5218	{
	5219	do
	5220	{
	5221	Field* fields = result->Fetch();
	5222	uint32 accountid = fields[0].GetUInt32();
	5223
	5224	QueryResult* banresult = loginDatabase.PQuery("SELECT account.username FROM account,account_banned WHERE account_banned.id='%u' AND account_banned.id=account.id",accountid);
	5225	if(banresult)
	5226	{
	5227	Field* fields2 = banresult->Fetch();
	5228	PSendSysMessage("%s",fields2[0].GetString());
	5229	delete banresult;
	5230	}
	5231	} while (result->NextRow());
	5232	}
	5233	// Console wide output
	5234	else
	5235	{
	5236	SendSysMessage(LANG_BANLIST_ACCOUNTS);
	5237	SendSysMessage("===============================================================================");
	5238	SendSysMessage(LANG_BANLIST_ACCOUNTS_HEADER);
	5239	do
	5240	{
	5241	SendSysMessage("-------------------------------------------------------------------------------");
	5242	Field *fields = result->Fetch();
	5243	uint32 account_id = fields[0].GetUInt32 ();
	5244
	5245	std::string account_name;
	5246
	5247	// "account" case, name can be get in same quary
	5248	if(result->GetFieldCount() > 1)
	5249	account_name = fields[1].GetCppString();
	5250	// "character" case, name need extract from another DB
	5251	else
	5252	accmgr.GetName (account_id,account_name);
	5253
	5254	// No SQL injection. id is uint32.
	5255	QueryResult *banInfo = loginDatabase.PQuery("SELECT bandate,unbandate,bannedby,banreason FROM account_banned WHERE id = %u ORDER BY unbandate", account_id);
	5256	if (banInfo)
	5257	{
	5258	Field *fields2 = banInfo->Fetch();
	5259	do
	5260	{
	5261	time_t t_ban = fields2[0].GetUInt64();
	5262	tm* aTm_ban = localtime(&t_ban);
	5263
	5264	if (fields2[0].GetUInt64() == fields2[1].GetUInt64())
	5265	{
	5266	PSendSysMessage("\|%-15.15s\|%02d-%02d-%02d %02d:%02d\| permanent \|%-15.15s\|%-15.15s\|",
	5267	account_name.c_str(),aTm_ban->tm_year%100, aTm_ban->tm_mon+1, aTm_ban->tm_mday, aTm_ban->tm_hour, aTm_ban->tm_min,
	5268	fields2[2].GetString(),fields2[3].GetString());
	5269	}
	5270	else
	5271	{
	5272	time_t t_unban = fields2[1].GetUInt64();
	5273	tm* aTm_unban = localtime(&t_unban);
	5274	PSendSysMessage("\|%-15.15s\|%02d-%02d-%02d %02d:%02d\|%02d-%02d-%02d %02d:%02d\|%-15.15s\|%-15.15s\|",
	5275	account_name.c_str(),aTm_ban->tm_year%100, aTm_ban->tm_mon+1, aTm_ban->tm_mday, aTm_ban->tm_hour, aTm_ban->tm_min,
	5276	aTm_unban->tm_year%100, aTm_unban->tm_mon+1, aTm_unban->tm_mday, aTm_unban->tm_hour, aTm_unban->tm_min,
	5277	fields2[2].GetString(),fields2[3].GetString());
	5278	}
	5279	}while ( banInfo->NextRow() );
	5280	delete banInfo;
	5281	}
	5282	}while( result->NextRow() );
	5283	SendSysMessage("===============================================================================");
	5284	}
	5285
	5286	delete result;
	5287	return true;
	5288	}
	5289
	5290	bool ChatHandler::HandleBanListIPCommand(const char* args)
	5291	{
	5292	loginDatabase.Execute("DELETE FROM ip_banned WHERE unbandate<=UNIX_TIMESTAMP() AND unbandate<>bandate");
	5293
	5294	char* cFilter = strtok((char*)args, " ");
	5295	std::string filter = cFilter ? cFilter : "";
	5296	loginDatabase.escape_string(filter);
	5297
	5298	QueryResult* result;
	5299
	5300	if(filter.empty())
	5301	{
	5302	result = loginDatabase.Query ("SELECT ip,bandate,unbandate,bannedby,banreason FROM ip_banned"
	5303	" WHERE (bandate=unbandate OR unbandate>UNIX_TIMESTAMP())"
	5304	" ORDER BY unbandate" );
	5305	}
	5306	else
	5307	{
	5308	result = loginDatabase.PQuery( "SELECT ip,bandate,unbandate,bannedby,banreason FROM ip_banned"
	5309	" WHERE (bandate=unbandate OR unbandate>UNIX_TIMESTAMP()) AND ip "_LIKE_" "_CONCAT3_("'%%'","'%s'","'%%'")
	5310	" ORDER BY unbandate",filter.c_str() );
	5311	}
	5312
	5313	if(!result)
	5314	{
	5315	PSendSysMessage(LANG_BANLIST_NOIP);
	5316	return true;
	5317	}
	5318
	5319	PSendSysMessage(LANG_BANLIST_MATCHINGIP);
	5320	// Chat short output
	5321	if(m_session)
	5322	{
	5323	do
	5324	{
	5325	Field* fields = result->Fetch();
	5326	PSendSysMessage("%s",fields[0].GetString());
	5327	}while (result->NextRow());
	5328	}
	5329	// Console wide output
	5330	else
	5331	{
	5332	SendSysMessage(LANG_BANLIST_IPS);SendSysMessage("===============================================================================");
	5333	SendSysMessage(LANG_BANLIST_IPS_HEADER);
	5334	do
4845	5335	{
4846		PSendSysMessage(LANG_BANINFO_NOACCOUNTBAN, accountname.c_str());
4847		return true;
4848		}
4849
4850		PSendSysMessage(LANG_BANINFO_BANHISTORY,accountname.c_str());
4851		do
4852		{
4853		fields = result->Fetch();
4854
4855		time_t unbandate = time_t(fields[3].GetUInt64());
4856		bool active = false;
4857		if(fields[2].GetBool() && (fields[1].GetUInt64() == (uint64)0 \|\|unbandate >= time(NULL)) )
4858		active = true;
4859		bool permanent = (fields[1].GetUInt64() == (uint64)0);
4860		std::string bantime = permanent?GetTrinityString(LANG_BANINFO_INFINITE):secsToTimeString(fields[1].GetUInt64(), true);
4861		PSendSysMessage(LANG_BANINFO_HISTORYENTRY,
4862		fields[0].GetString(), bantime.c_str(), active ? GetTrinityString(LANG_BANINFO_YES):GetTrinityString(LANG_BANINFO_NO), fields[4].GetString(), fields[5].GetString());
4863		}while (result->NextRow());
4864
4865		delete result;
4866		}
4867		else
4868		{
4869		loginDatabase.escape_string(nameOrIP);
4870		QueryResult *result = loginDatabase.PQuery("SELECT ip, FROM_UNIXTIME(bandate), FROM_UNIXTIME(unbandate), unbandate-UNIX_TIMESTAMP(), banreason,bannedby,unbandate-bandate FROM ip_banned WHERE ip = '%s'",nameOrIP.c_str());
4871		if(!result)
4872		{
4873		PSendSysMessage(LANG_BANINFO_NOIP);
4874		return true;
4875		}
4876		fields = result->Fetch();
4877		bool permanent = (fields[6].GetUInt64()==(uint64)0);
4878		PSendSysMessage(LANG_BANINFO_IPENTRY,
4879		fields[0].GetString(), fields[1].GetString(), permanent ? GetTrinityString(LANG_BANINFO_NEVER):fields[2].GetString(),
4880		permanent ? GetTrinityString(LANG_BANINFO_INFINITE):secsToTimeString(fields[3].GetUInt64(), true).c_str(), fields[4].GetString(), fields[5].GetString());
4881		delete result;
4882		}
4883		return true;
4884		}
4885
4886		bool ChatHandler::HandleBanListCommand(const char* args)
4887		{
4888		loginDatabase.Execute("DELETE FROM ip_banned WHERE unbandate<=UNIX_TIMESTAMP() AND unbandate<>bandate");
4889		if(!*args)
4890		return false;
4891		char* cType = strtok((char*)args, " ");
4892		char* cFilter = strtok(NULL, "");
4893		if(!cType \|\| !cFilter)
4894		return false;
4895		std::string Filter = cFilter;
4896		std::string Type = cType;
4897		loginDatabase.escape_string(Filter);
4898
4899		QueryResult* result = NULL;
4900		Field *fields = NULL;
4901		if(Type == "ip")
4902		{
4903		result = loginDatabase.PQuery("SELECT ip FROM ip_banned WHERE ip "_LIKE_" "_CONCAT3_("'%%'","'%s'","'%%'"),Filter.c_str());
4904		if(!result)
4905		{
4906		PSendSysMessage(LANG_BANLIST_NOIP);
4907		return true;
4908		}
4909		PSendSysMessage(LANG_BANLIST_MATCHINGIP);
4910		do
4911		{
4912		fields = result->Fetch();
4913		PSendSysMessage("%s",fields[0].GetString());
4914		} while (result->NextRow());
4915
4916		delete result;
4917		return true;
4918		}
4919		//lookup accountid
4920		if(Type == "account")
4921		{
4922		result = loginDatabase.PQuery("SELECT id FROM account WHERE username "_LIKE_" "_CONCAT3_("'%%'","'%s'","'%%'"),Filter.c_str());
4923		if (!result)
4924		{
4925		PSendSysMessage(LANG_BANLIST_NOACCOUNT);
4926		return true;
4927		}
4928		//do not delete result
4929		}
4930		else if(Type == "characters")
4931		{
4932		result = CharacterDatabase.PQuery("SELECT account FROM characters, WHERE name "_LIKE_" "_CONCAT3_("'%%'","'%s'","'%%'"),Filter.c_str());
4933		if (!result)
4934		{
4935		PSendSysMessage(LANG_BANLIST_NOCHARACTER);
4936		return true;
4937		}
4938		}
4939		else
4940		return false;
4941
4942		PSendSysMessage(LANG_BANLIST_MATCHINGACCOUNT);
4943		do
4944		{
4945		fields = result->Fetch();
4946		uint32 accountid = fields[0].GetUInt32();
4947		QueryResult* banresult = loginDatabase.PQuery("SELECT account.username FROM account,account_banned WHERE account_banned.id='%u' AND account_banned.active = '1' AND account_banned.id=account.id",accountid);
4948		if(banresult)
4949		{
4950		Field* fields2 = banresult->Fetch();
4951		PSendSysMessage("%s",fields2[0].GetString());
4952		delete banresult;
4953		}
4954		} while (result->NextRow());
	5336	SendSysMessage("-------------------------------------------------------------------------------");
	5337	Field *fields = result->Fetch();
	5338	time_t t_ban = fields[1].GetUInt64();
	5339	tm* aTm_ban = localtime(&t_ban);
	5340	if ( fields[1].GetUInt64() == fields[2].GetUInt64() )
	5341	{
	5342	PSendSysMessage("\|%-15.15s\|%02d-%02d-%02d %02d:%02d\| permanent \|%-15.15s\|%-15.15s\|",
	5343	fields[0].GetString(), aTm_ban->tm_year%100, aTm_ban->tm_mon+1, aTm_ban->tm_mday, aTm_ban->tm_hour, aTm_ban->tm_min,
	5344	fields[3].GetString(), fields[4].GetString());
	5345	}
	5346	else
	5347	{
	5348	time_t t_unban = fields[2].GetUInt64();
	5349	tm* aTm_unban = localtime(&t_unban);
	5350	PSendSysMessage("\|%-15.15s\|%02d-%02d-%02d %02d:%02d\|%02d-%02d-%02d %02d:%02d\|%-15.15s\|%-15.15s\|",
	5351	fields[0].GetString(), aTm_ban->tm_year%100, aTm_ban->tm_mon+1, aTm_ban->tm_mday, aTm_ban->tm_hour, aTm_ban->tm_min,
	5352	aTm_unban->tm_year%100, aTm_unban->tm_mon+1, aTm_unban->tm_mday, aTm_unban->tm_hour, aTm_unban->tm_min,
	5353	fields[3].GetString(), fields[4].GetString());
	5354	}
	5355	}while( result->NextRow() );
	5356	SendSysMessage("===============================================================================");
	5357	}
4955	5358
4956	5359	delete result;
…	…
5013	5416	bool ChatHandler::HandleLoadPDumpCommand(const char *args)
5014	5417	{
5015		if(!args)
5016		return false;
5017
5018		char * file = strtok((char*)args, " "); if(!file) return false;
5019		char * acc = strtok(NULL, " "); if(!acc) return false;
5020		if(!file \|\| !acc)
5021		return false;
5022
5023		uint32 account_id = accmgr.GetId(acc);
	5418	if (!args)
	5419	return false;
	5420
	5421	char * file = strtok((char*)args, " ");
	5422	if(!file)
	5423	return false;
	5424
	5425	char * account = strtok(NULL, " ");
	5426	if(!account)
	5427	return false;
	5428
	5429	std::string account_name = account;
	5430	if(!AccountMgr::normilizeString(account_name))
	5431	{
	5432	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
	5433	SetSentErrorMessage(true);
	5434	return false;
	5435	}
	5436
	5437	uint32 account_id = accmgr.GetId(account_name);
5024	5438	if(!account_id)
5025	5439	{
5026		account_id = atoi(acc);
5027		if(account_id)
	5440	account_id = atoi(account); // use original string
	5441	if(!account_id)
5028	5442	{
5029		~~std::string acc_name~~;
5030		if(!accmgr.GetName(account_id,acc_name))
5031		return false;
	5443	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
	5444	SetSentErrorMessage(true);
	5445	return false;
5032	5446	}
5033		else
	5447	}
	5448
	5449	if(!accmgr.GetName(account_id,account_name))
	5450	{
	5451	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
	5452	SetSentErrorMessage(true);
	5453	return false;
	5454	}
	5455
	5456	char* guid_str = NULL;
	5457	char* name_str = strtok(NULL, " ");
	5458
	5459	std::string name;
	5460	if(name_str)
	5461	{
	5462	name = name_str;
	5463	// normalize the name if specified and check if it exists
	5464	if(!normalizePlayerName(name))
	5465	{
	5466	PSendSysMessage(LANG_INVALID_CHARACTER_NAME);
	5467	SetSentErrorMessage(true);
	5468	return false;
	5469	}
	5470
	5471	if(!ObjectMgr::IsValidName(name,true))
	5472	{
	5473	PSendSysMessage(LANG_INVALID_CHARACTER_NAME);
	5474	SetSentErrorMessage(true);
5034	5475	return false;
5035		}
5036
5037		char * name = strtok(NULL, " ");
5038		char * guid_str = name ? strtok(NULL, " ") : NULL;
5039
5040		uint32 guid = guid_str ? atoi(guid_str) : 0;
5041
5042		if(PlayerDumpReader().LoadDump(file, account_id, name ? name : "", guid))
5043		PSendSysMessage(LANG_COMMAND_IMPORT_SUCCESS);
5044		else
5045		PSendSysMessage(LANG_COMMAND_IMPORT_FAILED);
	5476	}
	5477
	5478	guid_str = strtok(NULL, " ");
	5479	}
	5480
	5481	uint32 guid = 0;
	5482
	5483	if(guid_str)
	5484	{
	5485	guid = atoi(guid_str);
	5486	if(!guid)
	5487	{
	5488	PSendSysMessage(LANG_INVALID_CHARACTER_GUID);
	5489	SetSentErrorMessage(true);
	5490	return false;
	5491	}
	5492
	5493	if(objmgr.GetPlayerAccountIdByGUID(guid))
	5494	{
	5495	PSendSysMessage(LANG_CHARACTER_GUID_IN_USE,guid);
	5496	SetSentErrorMessage(true);
	5497	return false;
	5498	}
	5499	}
	5500
	5501	switch(PlayerDumpReader().LoadDump(file, account_id, name, guid))
	5502	{
	5503	case DUMP_SUCCESS:
	5504	PSendSysMessage(LANG_COMMAND_IMPORT_SUCCESS);
	5505	break;
	5506	case DUMP_FILE_OPEN_ERROR:
	5507	PSendSysMessage(LANG_FILE_OPEN_FAIL,file);
	5508	SetSentErrorMessage(true);
	5509	return false;
	5510	case DUMP_FILE_BROKEN:
	5511	PSendSysMessage(LANG_DUMP_BROKEN,file);
	5512	SetSentErrorMessage(true);
	5513	return false;
	5514	case DUMP_TOO_MANY_CHARS:
	5515	PSendSysMessage(LANG_ACCOUNT_CHARACTER_LIST_FULL,account_name,account_id);
	5516	SetSentErrorMessage(true);
	5517	return false;
	5518	default:
	5519	PSendSysMessage(LANG_COMMAND_IMPORT_FAILED);
	5520	SetSentErrorMessage(true);
	5521	return false;
	5522	}
5046	5523
5047	5524	return true;
…	…
5087	5564	guid = atoi(p2);
5088	5565
5089		if (PlayerDumpWriter().WriteDump(file, guid))
5090		PSendSysMessage(LANG_COMMAND_EXPORT_SUCCESS);
5091		else
5092		PSendSysMessage(LANG_COMMAND_EXPORT_FAILED);
	5566	if(!objmgr.GetPlayerAccountIdByGUID(guid))
	5567	{
	5568	PSendSysMessage(LANG_PLAYER_NOT_FOUND);
	5569	SetSentErrorMessage(true);
	5570	return false;
	5571	}
	5572
	5573	switch(PlayerDumpWriter().WriteDump(file, guid))
	5574	{
	5575	case DUMP_SUCCESS:
	5576	PSendSysMessage(LANG_COMMAND_EXPORT_SUCCESS);
	5577	break;
	5578	case DUMP_FILE_OPEN_ERROR:
	5579	PSendSysMessage(LANG_FILE_OPEN_FAIL,file);
	5580	SetSentErrorMessage(true);
	5581	return false;
	5582	default:
	5583	PSendSysMessage(LANG_COMMAND_EXPORT_FAILED);
	5584	SetSentErrorMessage(true);
	5585	return false;
	5586	}
5093	5587
5094	5588	return true;
…	…
5574	6068	}
5575	6069
	6070	/// Display the list of GMs
	6071	bool ChatHandler::HandleGMListFullCommand(const char* /args/)
	6072	{
	6073	///- Get the accounts with GM Level >0
	6074	QueryResult *result = loginDatabase.Query( "SELECT username,gmlevel FROM account WHERE gmlevel > 0" );
	6075	if(result)
	6076	{
	6077	SendSysMessage(LANG_GMLIST);
	6078	SendSysMessage("========================");
	6079	SendSysMessage(LANG_GMLIST_HEADER);
	6080	SendSysMessage("========================");
	6081
	6082	///- Circle through them. Display username and GM level
	6083	do
	6084	{
	6085	Field *fields = result->Fetch();
	6086	PSendSysMessage("\|%15s\|%6s\|", fields[0].GetString(),fields[1].GetString());
	6087	} while( result->NextRow() );
	6088
	6089	PSendSysMessage("========================");
	6090	delete result;
	6091	}
	6092	else
	6093	PSendSysMessage(LANG_GMLIST_EMPTY);
	6094	return true;
	6095	}
	6096
	6097	/// Define the 'Message of the day' for the realm
	6098	bool ChatHandler::HandleServerSetMotdCommand(const char* args)
	6099	{
	6100	sWorld.SetMotd(args);
	6101	PSendSysMessage(LANG_MOTD_NEW, args);
	6102	return true;
	6103	}
	6104
	6105	/// Set/Unset the expansion level for an account
	6106	bool ChatHandler::HandleAccountSetAddonCommand(const char* args)
	6107	{
	6108	///- Get the command line arguments
	6109	char szAcc = strtok((char)args," ");
	6110	char *szExp = strtok(NULL," ");
	6111
	6112	if(!szAcc)
	6113	return false;
	6114
	6115	std::string account_name;
	6116	uint32 account_id;
	6117
	6118	if(!szExp)
	6119	{
	6120	Player* player = getSelectedPlayer();
	6121	if(!player)
	6122	return false;
	6123
	6124	account_id = player->GetSession()->GetAccountId();
	6125	accmgr.GetName(account_id,account_name);
	6126	szExp = szAcc;
	6127	}
	6128	else
	6129	{
	6130	///- Convert Account name to Upper Format
	6131	account_name = szAcc;
	6132	if(!AccountMgr::normilizeString(account_name))
	6133	{
	6134	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
	6135	SetSentErrorMessage(true);
	6136	return false;
	6137	}
	6138
	6139	account_id = accmgr.GetId(account_name);
	6140	if(!account_id)
	6141	{
	6142	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
	6143	SetSentErrorMessage(true);
	6144	return false;
	6145	}
	6146	}
	6147
	6148	int lev=atoi(szExp); //get int anyway (0 if error)
	6149	if(lev < 0)
	6150	return false;
	6151
	6152	// No SQL injection
	6153	loginDatabase.PExecute("UPDATE account SET expansion = '%d' WHERE id = '%u'",lev,account_id);
	6154	PSendSysMessage(LANG_ACCOUNT_SETADDON,account_name.c_str(),account_id,lev);
	6155	return true;
	6156	}
	6157
	6158	/// Send a message to a player in game
	6159	bool ChatHandler::HandleSendMessageCommand(const char* args)
	6160	{
	6161	///- Get the command line arguments
	6162	char* name_str = strtok((char*)args, " ");
	6163	char* msg_str = strtok(NULL, "");
	6164
	6165	if(!name_str \|\| !msg_str)
	6166	return false;
	6167
	6168	std::string name = name_str;
	6169
	6170	if(!normalizePlayerName(name))
	6171	return false;
	6172
	6173	///- Find the player and check that he is not logging out.
	6174	Player *rPlayer = objmgr.GetPlayer(name.c_str());
	6175	if(!rPlayer)
	6176	{
	6177	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	6178	SetSentErrorMessage(true);
	6179	return false;
	6180	}
	6181
	6182	if(rPlayer->GetSession()->isLogingOut())
	6183	{
	6184	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	6185	SetSentErrorMessage(true);
	6186	return false;
	6187	}
	6188
	6189	///- Send the message
	6190	//Use SendAreaTriggerMessage for fastest delivery.
	6191	rPlayer->GetSession()->SendAreaTriggerMessage("%s", msg_str);
	6192	rPlayer->GetSession()->SendAreaTriggerMessage("\|cffff0000[Message from administrator]:\|r");
	6193
	6194	//Confirmation message
	6195	PSendSysMessage(LANG_SENDMESSAGE,name.c_str(),msg_str);
	6196	return true;
	6197	}
	6198
5576	6199	bool ChatHandler::HandleFreezeCommand(const char *args)
5577	6200	{

trunk/src/game/ObjectMgr.h

r102	r112
681	681	const char *GetTrinityString(int32 entry, int locale_idx) const;
682	682	const char *GetTrinityStringForDBCLocale(int32 entry) const { return GetTrinityString(entry,DBCLocaleIndex); }
	683	int32 GetDBCLocaleIndex() const { return DBCLocaleIndex; }
683	684	void SetDBCLocaleIndex(uint32 lang) { DBCLocaleIndex = GetIndexForLocale(LocaleConstant(lang)); }
684	685

trunk/src/game/PlayerDump.cpp

r102	r112
27	27
28	28	// Character Dump tables
29		#define DUMP_TABLE_COUNT 20
	29	#define DUMP_TABLE_COUNT 19
30	30
31	31	struct DumpTable
…	…
259	259
260	260	// Writing - High-level functions
261		bool PlayerDumpWriter::DumpTable(std::string& dump, uint32 guid, char consttableFrom, char consttableTo, DumpTableType type)
262		{
263		if (!tableFrom \|\| !tableTo)
264		return false;
265
	261	void PlayerDumpWriter::DumpTable(std::string& dump, uint32 guid, char consttableFrom, char consttableTo, DumpTableType type)
	262	{
266	263	GUIDs const* guids = NULL;
267	264	char const* fieldname = NULL;
…	…
281	278	// for guid set stop if set is empty
282	279	if(guids && guids->empty())
283		return ~~true~~; // nothing to do
	280	return; // nothing to do
284	281
285	282	// setup for guids case start position
…	…
299	296	QueryResult result = CharacterDatabase.PQuery("SELECT FROM %s WHERE %s", tableFrom, wherestr.c_str());
300	297	if(!result)
301		return ~~false~~;
	298	return;
302	299
303	300	do
…	…
329	326	}
330	327	while(guids && guids_itr != guids->end()); // not set case iterate single time, set case iterate for all guids
331
332		~~return true;~~
333	328	}
334	329
…	…
339	334	DumpTable(dump, guid, dumpTables[i].name, dumpTables[i].name, dumpTables[i].type);
340	335
341		// TODO: Add instance/group~~/gifts~~..
	336	// TODO: Add instance/group..
342	337	// TODO: Add a dump level option to skip some non-important tables
343	338
…	…
345	340	}
346	341
347		~~bool~~ PlayerDumpWriter::WriteDump(std::string file, uint32 guid)
	342	DumpReturn PlayerDumpWriter::WriteDump(std::string file, uint32 guid)
348	343	{
349	344	FILE *fout = fopen(file.c_str(), "w");
350		if (!fout) { sLog.outError("Failed to open file!\r\n"); return false; }
	345	if (!fout)
	346	return DUMP_FILE_OPEN_ERROR;
351	347
352	348	std::string dump = GetDump(guid);
…	…
354	350	fprintf(fout,"%s\n",dump.c_str());
355	351	fclose(fout);
356		return ~~true~~;
	352	return DUMP_SUCCESS;
357	353	}
358	354
359	355	// Reading - High-level functions
360		#define ROLLBACK ~~{CharacterDatabase.RollbackTransaction(); fclose(fin); return false~~;}
361
362		~~bool~~ PlayerDumpReader::LoadDump(std::string file, uint32 account, std::string name, uint32 guid)
	356	#define ROLLBACK(DR) {CharacterDatabase.RollbackTransaction(); fclose(fin); return (DR);}
	357
	358	DumpReturn PlayerDumpReader::LoadDump(std::string file, uint32 account, std::string name, uint32 guid)
363	359	{
364	360	// check character count
…	…
373	369
374	370	if (charcount >= 10)
375		{
376		return false;
377		}
	371	return DUMP_TOO_MANY_CHARS;
378	372	}
379	373	}
380	374	FILE *fin = fopen(file.c_str(), "r");
381		if(!fin) return false;
	375	if(!fin)
	376	return DUMP_FILE_OPEN_ERROR;
382	377
383	378	QueryResult * result = NULL;
…	…
435	430	{
436	431	if(feof(fin)) break;
437		sLog.outError("LoadPlayerDump: File read error!");
438		ROLLBACK;
	432	ROLLBACK(DUMP_FILE_BROKEN);
439	433	}
440	434
…	…
450	444	{
451	445	sLog.outError("LoadPlayerDump: Can't extract table name from line: '%s'!", line.c_str());
452		ROLLBACK;
	446	ROLLBACK(DUMP_FILE_BROKEN);
453	447	}
454	448
…	…
467	461	{
468	462	sLog.outError("LoadPlayerDump: Unknown table: '%s'!", tn.c_str());
469		ROLLBACK;
	463	ROLLBACK(DUMP_FILE_BROKEN);
470	464	}
471	465
…	…
474	468	{
475	469	case DTT_CHAR_TABLE:
476		if(!changenth(line, 1, newguid)) ROLLBACK;
	470	if(!changenth(line, 1, newguid))
	471	ROLLBACK(DUMP_FILE_BROKEN);
477	472	break;
478	473
479	474	case DTT_CHARACTER: // character t.
480	475	{
481		if(!changenth(line, 1, newguid)) ROLLBACK;
	476	if(!changenth(line, 1, newguid))
	477	ROLLBACK(DUMP_FILE_BROKEN);
482	478
483	479	// guid, data field:guid, items
484		if(!changenth(line, 2, chraccount)) ROLLBACK;
	480	if(!changenth(line, 2, chraccount))
	481	ROLLBACK(DUMP_FILE_BROKEN);
	482
485	483	std::string vals = getnth(line, 3);
486		if(!changetoknth(vals, OBJECT_FIELD_GUID+1, newguid)) ROLLBACK;
	484	if(!changetoknth(vals, OBJECT_FIELD_GUID+1, newguid))
	485	ROLLBACK(DUMP_FILE_BROKEN);
	486
487	487	for(uint16 field = PLAYER_FIELD_INV_SLOT_HEAD; field < PLAYER_FARSIGHT; field++)
488		if(!changetokGuid(vals, field+1, items, objmgr.m_hiItemGuid, true)) ROLLBACK;
489		if(!changenth(line, 3, vals.c_str())) ROLLBACK;
	488	if(!changetokGuid(vals, field+1, items, objmgr.m_hiItemGuid, true))
	489	ROLLBACK(DUMP_FILE_BROKEN);
	490
	491	if(!changenth(line, 3, vals.c_str()))
	492	ROLLBACK(DUMP_FILE_BROKEN);
	493
490	494	if (name == "")
491	495	{
…	…
499	503	delete result;
500	504	// rename on login: `at_login` field 30 in raw field list
501		if(!changenth(line, 30, "1")) ROLLBACK;
	505	if(!changenth(line, 30, "1"))
	506	ROLLBACK(DUMP_FILE_BROKEN);
502	507	}
503	508	}
504		else if(!changenth(line, 4, name.c_str())) ROLLBACK;
	509	else if(!changenth(line, 4, name.c_str()))
	510	ROLLBACK(DUMP_FILE_BROKEN);
505	511
506	512	break;
…	…
508	514	case DTT_INVENTORY: // character_inventory t.
509	515	{
510		if(!changenth(line, 1, newguid)) ROLLBACK;
	516	if(!changenth(line, 1, newguid))
	517	ROLLBACK(DUMP_FILE_BROKEN);
511	518
512	519	// bag, item
513		if(!changeGuid(line, 2, items, objmgr.m_hiItemGuid, true)) ROLLBACK;
514		if(!changeGuid(line, 4, items, objmgr.m_hiItemGuid)) ROLLBACK;
	520	if(!changeGuid(line, 2, items, objmgr.m_hiItemGuid, true))
	521	ROLLBACK(DUMP_FILE_BROKEN);
	522	if(!changeGuid(line, 4, items, objmgr.m_hiItemGuid))
	523	ROLLBACK(DUMP_FILE_BROKEN);
515	524	break;
516	525	}
…	…
518	527	{
519	528	// item, owner, data field:item, owner guid
520		if(!changeGuid(line, 1, items, objmgr.m_hiItemGuid)) ROLLBACK;
521		if(!changenth(line, 2, newguid)) ROLLBACK;
	529	if(!changeGuid(line, 1, items, objmgr.m_hiItemGuid))
	530	ROLLBACK(DUMP_FILE_BROKEN);
	531	if(!changenth(line, 2, newguid))
	532	ROLLBACK(DUMP_FILE_BROKEN);
	533
522	534	std::string vals = getnth(line,3);
523		if(!changetokGuid(vals, OBJECT_FIELD_GUID+1, items, objmgr.m_hiItemGuid)) ROLLBACK;
524		if(!changetoknth(vals, ITEM_FIELD_OWNER+1, newguid)) ROLLBACK;
525		if(!changenth(line, 3, vals.c_str())) ROLLBACK;
	535	if(!changetokGuid(vals, OBJECT_FIELD_GUID+1, items, objmgr.m_hiItemGuid))
	536	ROLLBACK(DUMP_FILE_BROKEN);
	537	if(!changetoknth(vals, ITEM_FIELD_OWNER+1, newguid))
	538	ROLLBACK(DUMP_FILE_BROKEN);
	539	if(!changenth(line, 3, vals.c_str()))
	540	ROLLBACK(DUMP_FILE_BROKEN);
526	541	break;
527	542	}
…	…
529	544	{
530	545	// guid,item_guid,
531		if(!changenth(line, 1, newguid)) ROLLBACK;
532		if(!changeGuid(line, 2, items, objmgr.m_hiItemGuid)) ROLLBACK;
	546	if(!changenth(line, 1, newguid))
	547	ROLLBACK(DUMP_FILE_BROKEN);
	548	if(!changeGuid(line, 2, items, objmgr.m_hiItemGuid))
	549	ROLLBACK(DUMP_FILE_BROKEN);
533	550	break;
534	551	}
…	…
552	569
553	570	// item, entry, owner, ...
554		if(!changenth(line, 1, newpetid)) ROLLBACK;
555		if(!changenth(line, 3, newguid)) ROLLBACK;
	571	if(!changenth(line, 1, newpetid))
	572	ROLLBACK(DUMP_FILE_BROKEN);
	573	if(!changenth(line, 3, newguid))
	574	ROLLBACK(DUMP_FILE_BROKEN);
556	575
557	576	break;
…	…
563	582	// lookup currpetid and match to new inserted pet id
564	583	std::map<uint32, uint32> :: const_iterator petids_iter = petids.find(atoi(currpetid));
565		if(petids_iter == petids.end()) ROLLBACK; // couldn't find new inserted id
	584	if(petids_iter == petids.end()) // couldn't find new inserted id
	585	ROLLBACK(DUMP_FILE_BROKEN);
566	586
567	587	snprintf(newpetid, 20, "%d", petids_iter->second);
568	588
569		if(!changenth(line, 1, newpetid)) ROLLBACK;
	589	if(!changenth(line, 1, newpetid))
	590	ROLLBACK(DUMP_FILE_BROKEN);
570	591
571	592	break;
…	…
574	595	{
575	596	// id,messageType,stationery,sender,receiver
576		if(!changeGuid(line, 1, mails, objmgr.m_mailid)) ROLLBACK;
577		if(!changenth(line, 5, newguid)) ROLLBACK;
	597	if(!changeGuid(line, 1, mails, objmgr.m_mailid))
	598	ROLLBACK(DUMP_FILE_BROKEN);
	599	if(!changenth(line, 5, newguid))
	600	ROLLBACK(DUMP_FILE_BROKEN);
578	601	break;
579	602	}
…	…
581	604	{
582	605	// mail_id,item_guid,item_template,receiver
583		if(!changeGuid(line, 1, mails, objmgr.m_mailid)) ROLLBACK;
584		if(!changeGuid(line, 2, items, objmgr.m_hiItemGuid)) ROLLBACK;
585		if(!changenth(line, 4, newguid)) ROLLBACK;
	606	if(!changeGuid(line, 1, mails, objmgr.m_mailid))
	607	ROLLBACK(DUMP_FILE_BROKEN);
	608	if(!changeGuid(line, 2, items, objmgr.m_hiItemGuid))
	609	ROLLBACK(DUMP_FILE_BROKEN);
	610	if(!changenth(line, 4, newguid))
	611	ROLLBACK(DUMP_FILE_BROKEN);
586	612	break;
587	613	}
…	…
591	617	}
592	618
593		if(!CharacterDatabase.Execute(line.c_str())) ROLLBACK;
	619	if(!CharacterDatabase.Execute(line.c_str()))
	620	ROLLBACK(DUMP_FILE_BROKEN);
594	621	}
595	622
…	…
604	631	fclose(fin);
605	632
606		return ~~true~~;
607		}
	633	return DUMP_SUCCESS;
	634	}

trunk/src/game/PlayerDump.h

r102	r112
74	74	};
75	75
	76	enum DumpReturn
	77	{
	78	DUMP_SUCCESS,
	79	DUMP_FILE_OPEN_ERROR,
	80	DUMP_TOO_MANY_CHARS,
	81	DUMP_UNEXPECTED_END,
	82	DUMP_FILE_BROKEN,
	83	};
	84
76	85	class PlayerDump
77	86	{
…	…
86	95
87	96	std::string GetDump(uint32 guid);
88		~~bool~~ WriteDump(std::string file, uint32 guid);
	97	DumpReturn WriteDump(std::string file, uint32 guid);
89	98	private:
90	99	typedef std::set<uint32> GUIDs;
91	100
92		~~bool~~ DumpTable(std::string& dump, uint32 guid, char consttableFrom, char consttableTo, DumpTableType type);
	101	void DumpTable(std::string& dump, uint32 guid, char consttableFrom, char consttableTo, DumpTableType type);
93	102	std::string GenerateWhereStr(char const* field, GUIDs const& guids, GUIDs::const_iterator& itr);
94	103	std::string GenerateWhereStr(char const* field, uint32 guid);
…	…
105	114	PlayerDumpReader() {}
106	115
107		~~bool~~ LoadDump(std::string file, uint32 account, std::string name, uint32 guid);
	116	DumpReturn LoadDump(std::string file, uint32 account, std::string name, uint32 guid);
108	117	};
109	118

trunk/src/game/SharedDefines.h

r108	r112
2168	2168	CHAR_NAME_DECLENSION_DOESNT_MATCH_BASE_NAME = 0x5A,
2169	2169	};
	2170
	2171	/// Ban function modes
	2172	enum BanMode
	2173	{
	2174	BAN_ACCOUNT,
	2175	BAN_CHARACTER,
	2176	BAN_IP
	2177	};
	2178
	2179	/// Ban function return codes
	2180	enum BanReturn
	2181	{
	2182	BAN_SUCCESS,
	2183	BAN_SYNTAX_ERROR,
	2184	BAN_NOTFOUND
	2185	};
2170	2186	#endif

trunk/src/game/World.cpp

r111	r112
2265	2265
2266	2266	/// Ban an account or ban an IP address, duration will be parsed using TimeStringToSecs if it is positive, otherwise permban
2267		~~uint8 World::BanAccount(std::string typ~~e, std::string nameOrIP, std::string duration, std::string reason, std::string author)
	2267	BanReturn World::BanAccount(BanMode mode, std::string nameOrIP, std::string duration, std::string reason, std::string author)
2268	2268	{
2269	2269	loginDatabase.escape_string(nameOrIP);
…	…
2272	2272	loginDatabase.escape_string(safe_author);
2273	2273
2274		~~if(type != "ip" && !normalizePlayerName(nameOrIP))~~
2275		~~return BAN_NOTFOUND; // Nobody to ban~~
2276
2277	2274	uint32 duration_secs = TimeStringToSecs(duration);
2278	2275	QueryResult *resultAccounts = NULL; //used for kicking
2279	2276
2280	2277	///- Update the database with ban information
2281
2282		if(type=="ip")
2283		{
2284		//No SQL injection as strings are escaped
2285		resultAccounts = loginDatabase.PQuery("SELECT id FROM account WHERE last_ip = '%s'",nameOrIP.c_str());
2286		loginDatabase.PExecute("INSERT INTO ip_banned VALUES ('%s',UNIX_TIMESTAMP(),UNIX_TIMESTAMP()+%u,'%s','%s')",nameOrIP.c_str(),duration_secs,safe_author.c_str(),reason.c_str());
2287		}
2288		else if(type=="account")
2289		{
2290		//No SQL injection as string is escaped
2291		resultAccounts = loginDatabase.PQuery("SELECT id FROM account WHERE username = '%s'",nameOrIP.c_str());
2292		}
2293		else if(type=="character")
2294		{
2295		//No SQL injection as string is escaped
2296		resultAccounts = CharacterDatabase.PQuery("SELECT account FROM characters WHERE name = '%s'",nameOrIP.c_str());
2297		}
2298		else
2299		return BAN_SYNTAX_ERROR; //Syntax problem
2300
2301		if(!resultAccounts)
2302		if(type=="ip")
2303		return BAN_SUCCESS; // ip correctly banned but nobody affected (yet)
2304		else
2305		return BAN_NOTFOUND; // Nobody to ban
	2278	switch(mode)
	2279	{
	2280	case BAN_IP:
	2281	//No SQL injection as strings are escaped
	2282	resultAccounts = loginDatabase.PQuery("SELECT id FROM account WHERE last_ip = '%s'",nameOrIP.c_str());
	2283	loginDatabase.PExecute("INSERT INTO ip_banned VALUES ('%s',UNIX_TIMESTAMP(),UNIX_TIMESTAMP()+%u,'%s','%s')",nameOrIP.c_str(),duration_secs,safe_author.c_str(),reason.c_str());
	2284	break;
	2285	case BAN_ACCOUNT:
	2286	//No SQL injection as string is escaped
	2287	resultAccounts = loginDatabase.PQuery("SELECT id FROM account WHERE username = '%s'",nameOrIP.c_str());
	2288	break;
	2289	case BAN_CHARACTER:
	2290	//No SQL injection as string is escaped
	2291	resultAccounts = CharacterDatabase.PQuery("SELECT account FROM characters WHERE name = '%s'",nameOrIP.c_str());
	2292	break;
	2293	default:
	2294	return BAN_SYNTAX_ERROR;
	2295	}
	2296
	2297	if(!resultAccounts)
	2298	{
	2299	if(mode==BAN_IP)
	2300	return BAN_SUCCESS;
	2301	else
	2302	return BAN_NOTFOUND; // Nobody to ban
	2303	}
2306	2304
2307	2305	///- Disconnect all affected players (for IP it can be several)
…	…
2311	2309	uint32 account = fieldsAccount->GetUInt32();
2312	2310
2313		if(type != "ip")
	2311	if(mode!=BAN_IP)
	2312	{
2314	2313	//No SQL injection as strings are escaped
2315	2314	loginDatabase.PExecute("INSERT INTO account_banned VALUES ('%u', UNIX_TIMESTAMP(), UNIX_TIMESTAMP()+%u, '%s', '%s', '1')",
2316	2315	account,duration_secs,safe_author.c_str(),reason.c_str());
2317
2318		WorldSession* sess = FindSession(account);
2319		if~~( sess~~ )
	2316	}
	2317
	2318	if (WorldSession* sess = FindSession(account))
2320	2319	if(std::string(sess->GetPlayerName()) != author)
2321	2320	sess->KickPlayer();
…	…
2328	2327
2329	2328	/// Remove a ban from an account or IP address
2330		bool World::RemoveBanAccount(~~std::string typ~~e, std::string nameOrIP)
2331		{
2332		if~~(type == "ip"~~)
	2329	bool World::RemoveBanAccount(BanMode mode, std::string nameOrIP)
	2330	{
	2331	if (mode == BAN_IP)
2333	2332	{
2334	2333	loginDatabase.escape_string(nameOrIP);
…	…
2338	2337	{
2339	2338	uint32 account=0;
2340		if(type == "account")
2341		{
2342		if (!AccountMgr::normilizeString (nameOrIP))
2343		return false;
2344
	2339	if (mode == BAN_ACCOUNT)
2345	2340	account = accmgr.GetId (nameOrIP);
2346		}
2347		else if(type == "character")
2348		{
2349		if(!normalizePlayerName(nameOrIP))
2350		return false;
2351
	2341	else if (mode == BAN_CHARACTER)
2352	2342	account = objmgr.GetPlayerAccountIdByPlayerName (nameOrIP);
2353		}
	2343
2354	2344	if(!account)
2355	2345	return false;
…	…
2504	2494	void World::ProcessCliCommands()
2505	2495	{
2506		if (cliCmdQueue.empty()) ~~return;~~
2507
2508		CliCommandHolder *command;
2509		~~pPrintf p_zprintf~~;
	2496	if (cliCmdQueue.empty())
	2497	return;
	2498
	2499	CliCommandHolder::Print* zprint;
2510	2500	while (!cliCmdQueue.empty())
2511	2501	{
2512	2502	sLog.outDebug("CLI command under processing...");
2513		command = cliCmdQueue.next();
2514		command->Execute();
2515		p_zprintf=command->GetOutputMethod();
	2503	CliCommandHolder *command = cliCmdQueue.next();
	2504
	2505	zprint = command->m_print;
	2506
	2507	CliHandler(zprint).ParseCommands(command->m_command);
	2508
2516	2509	delete command;
2517	2510	}
	2511
2518	2512	// print the console message here so it looks right
2519		~~p_zprintf~~("TC> ");
	2513	zprint("TC> ");
2520	2514	}
2521	2515

trunk/src/game/World.h

r102	r112
29	29	#include "Timer.h"
30	30	#include "Policies/Singleton.h"
	31	#include "SharedDefines.h"
31	32
32	33	#include <map>
…	…
41	42	struct ScriptAction;
42	43	struct ScriptInfo;
43		~~class CliCommandHolder;~~
44	44	class SqlResultQueue;
45	45	class QueryResult;
…	…
297	297	};
298	298
299		~~/// Ban function return codes~~
300		~~enum BanReturn~~
301		{
302		~~BAN_SUCCESS,~~
303		~~BAN_SYNTAX_ERROR,~~
304		~~BAN_NOTFOUND~~
305		};
306
307	299	// DB scripting commands
308	300	#define SCRIPT_COMMAND_TALK 0 // source = unit, target=any, datalong ( 0=say, 1=whisper, 2=yell, 3=emote text)
…	…
322	314	#define SCRIPT_COMMAND_CAST_SPELL 15 // source (datalong2!=0) or target (datalong==0) unit, datalong = spell_id
323	315
324		~~/// CLI related stuff, define here to prevent cyclic dependancies~~
325
326		~~typedef int(* pPrintf)(const char*,...);~~
327		~~typedef void(* pCliFunc)(char *,pPrintf);~~
328
329		~~/// Command Template class~~
330		~~struct CliCommand~~
331		{
332		~~char const * cmd;~~
333		~~pCliFunc Func;~~
334		~~char const * description;~~
335		};
336
337	316	/// Storage class for commands issued for delayed execution
338		class CliCommandHolder
339		{
340		private:
341		const CliCommand *cmd;
342		char *args;
343		pPrintf m_zprintf;
344		public:
345		CliCommandHolder(const CliCommand command, const char arguments, pPrintf p_zprintf)
346		: cmd(command), m_zprintf(p_zprintf)
347		{
348		size_t len = strlen(arguments)+1;
349		args = new char[len];
350		memcpy(args, arguments, len);
351		}
352		~CliCommandHolder() { delete[] args; }
353		void Execute() const { cmd->Func(args, m_zprintf); }
354		pPrintf GetOutputMethod() const {return (m_zprintf);}
	317	struct CliCommandHolder
	318	{
	319	typedef void Print(const char*);
	320
	321	char *m_command;
	322	Print* m_print;
	323
	324	CliCommandHolder(const char command, Print zprint)
	325	: m_print(zprint)
	326	{
	327	size_t len = strlen(command)+1;
	328	m_command = new char[len];
	329	memcpy(m_command, command, len);
	330	}
	331
	332	~CliCommandHolder() { delete[] m_command; }
355	333	};
356	334
…	…
475	453	void KickAllLess(AccountTypes sec);
476	454	void KickAllQueued();
477		~~uint8 BanAccount(std::string typ~~e, std::string nameOrIP, std::string duration, std::string reason, std::string author);
478		~~bool RemoveBanAccount(std::string typ~~e, std::string nameOrIP);
	455	BanReturn BanAccount(BanMode mode, std::string nameOrIP, std::string duration, std::string reason, std::string author);
	456	bool RemoveBanAccount(BanMode mode, std::string nameOrIP);
479	457
480	458	void ScriptsStart(std::map<uint32, std::multimap<uint32, ScriptInfo> > const& scripts, uint32 id, Object* source, Object* target);
…	…
493	471
494	472	void ProcessCliCommands();
495		void QueueCliCommand(~~CliCommandHolder* command) { cliCmdQueue.add(command~~); }
	473	void QueueCliCommand( CliCommandHolder::Print* zprintf, char const* input ) { cliCmdQueue.add(new CliCommandHolder(input, zprintf)); }
496	474
497	475	void UpdateResultQueue();

trunk/src/game/WorldSession.cpp

r102	r112
467	467	}
468	468
469		const char * WorldSession::GetTrinityString( int32 entry )
	469	const char * WorldSession::GetTrinityString( int32 entry ) const
470	470	{
471	471	return objmgr.GetTrinityString(entry,GetSessionDbLocaleIndex());

trunk/src/game/WorldSession.h

r102	r112
195	195
196	196	// Locales
197		LocaleConstant GetSessionDbcLocale() { return m_sessionDbcLocale; }
198		~~int GetSessionDbLocaleIndex()~~ { return m_sessionDbLocaleIndex; }
199		~~const char *GetTrinityString(int32 entry)~~;
	197	LocaleConstant GetSessionDbcLocale() const { return m_sessionDbcLocale; }
	198	int GetSessionDbLocaleIndex() const { return m_sessionDbLocaleIndex; }
	199	const char *GetTrinityString(int32 entry) const;
200	200
201	201	uint32 GetLatency() const { return m_latency; }

trunk/src/shared/Common.h

r102	r112
170	170	SEC_MODERATOR = 1,
171	171	SEC_GAMEMASTER = 2,
172		SEC_ADMINISTRATOR = 3
	172	SEC_ADMINISTRATOR = 3,
	173	SEC_CONSOLE = 4 // must be always last in list, accounts must have less security level always also
173	174	};
174	175

trunk/src/trinitycore/CliRunnable.cpp

r102	r112
28	28	#include "World.h"
29	29	#include "ScriptCalls.h"
30		~~#include "GlobalEvents.h"~~
31	30	#include "ObjectMgr.h"
32	31	#include "WorldSession.h"
…	…
37	36	#include "CliRunnable.h"
38	37	#include "MapManager.h"
39		~~#include "PlayerDump.h"~~
40	38	#include "Player.h"
41
42		//CliCommand and CliCommandHolder are defined in World.h to avoid cyclic deps
43
44		//func prototypes must be defined
45
46		void CliHelp(char*,pPrintf);
47		void CliInfo(char*,pPrintf);
48		void CliBan(char*,pPrintf);
49		void CliBanList(char*,pPrintf);
50		void CliRemoveBan(char*,pPrintf);
51		void CliSetGM(char*,pPrintf);
52		void CliListGM(char*,pPrintf);
53		void CliVersion(char*,pPrintf);
54		void CliExit(char*,pPrintf);
55		void CliIdleRestart(char*,pPrintf zprintf);
56		void CliRestart(char*,pPrintf zprintf);
57		void CliIdleShutdown(char*,pPrintf zprintf);
58		void CliShutdown(char*,pPrintf zprintf);
59		void CliBroadcast(char*,pPrintf);
60		void CliCreate(char*,pPrintf);
61		void CliDelete(char*,pPrintf);
62		void CliCharDelete(char *,pPrintf);
63		void CliLoadScripts(char*,pPrintf);
64		void CliKick(char*,pPrintf);
65		void CliTele(char*,pPrintf);
66		void CliMotd(char*,pPrintf);
67		void CliCorpses(char*,pPrintf);
68		void CliSetLogLevel(char*,pPrintf);
69		void CliUpTime(char*,pPrintf);
70		void CliSetAddon(char*,pPrintf);
71		void CliWritePlayerDump(char*,pPrintf);
72		void CliLoadPlayerDump(char*,pPrintf);
73		void CliSave(char*,pPrintf);
74		void CliSend(char*,pPrintf);
75		void CliPLimit(char*,pPrintf);
76		void CliSetPassword(char*,pPrintf);
77		/// Table of known commands
78		const CliCommand Commands[]=
79		{
80		{"help", & CliHelp,"Display this help message"},
81		{"broadcast", & CliBroadcast,"Announce in-game message"},
82		{"create", & CliCreate,"Create account"},
83		{"delete", & CliDelete,"Delete account and characters"},
84		{"chardelete", & CliCharDelete,"Delete character"},
85		{"info", & CliInfo,"Display Server infomation"},
86		{"uptime", & CliUpTime, "Displays the server uptime"},
87		{"motd", & CliMotd,"Change or display motd"},
88		{"kick", & CliKick,"Kick user"},
89		{"ban", & CliBan,"Ban account\|ip"},
90		{"listbans", & CliBanList,"List bans"},
91		{"unban", & CliRemoveBan,"Remove ban from account\|ip"},
92		{"setgm", & CliSetGM,"Edit user privileges"},
93		{"setpass", & CliSetPassword,"Set password for account"},
94		{"setaddon", & CliSetAddon,"Set user expansion addon level allowed"},
95		{"listgm", & CliListGM,"Display user privileges"},
96		{"loadscripts", & CliLoadScripts,"Load script library"},
97		{"setloglevel", & CliSetLogLevel,"Set Log Level"},
98		{"corpses", & CliCorpses,"Manually call corpses erase global even code"},
99		{"version", & CliVersion,"Display server version"},
100		{"idlerestart", & CliIdleRestart,"Restart server with some delay when there are no active connections remaining"},
101		{"restart", & CliRestart,"Restart server with some delay"},
102		{"idleshutdown", & CliIdleShutdown,"Shutdown server with some delay when there are no active connections remaining"},
103		{"shutdown", & CliShutdown,"Shutdown server with some delay"},
104		{"exit", & CliExit,"Shutdown server NOW"},
105		{"writepdump", &CliWritePlayerDump,"Write a player dump to a file"},
106		{"loadpdump", &CliLoadPlayerDump,"Load a player dump from a file"},
107		{"saveall", &CliSave,"Save all players"},
108		{"send", &CliSend,"Send message to a player"},
109		{"tele", &CliTele,"Teleport player to location"},
110		{"plimit", &CliPLimit,"Show or set player login limitations"}
111		};
112		/// \todo Need some pragma pack? Else explain why in a comment.
113		#define CliTotalCmds sizeof(Commands)/sizeof(CliCommand)
114
	39	#include "Chat.h"
	40
	41	void utf8print(const char* str)
	42	{
115	43	#if PLATFORM == PLATFORM_WINDOWS
116		~~int utf8printf(const char* str,...)~~
117		{
118		~~UTF8PRINTF(stdout,str,1);~~
119		~~return 0;~~
120		}
121	44	#define UTF8ZPRINTF utf8printf
	45	wchar_t wtemp_buf[6000];
	46	size_t wtemp_len = 6000-1;
	47	if(!Utf8toWStr(str,strlen(str),wtemp_buf,wtemp_len))
	48	return;
	49
	50	char temp_buf[6000];
	51	CharToOemBuffW(&wtemp_buf[0],&temp_buf[0],wtemp_len+1);
	52	printf(temp_buf);
122	53	#else
123		#define UTF8ZPRINTF printf
	54	printf(str);
124	55	#endif
125
126		~~/// Create a character dump file~~
127		~~void CliWritePlayerDump(char*command,pPrintf zprintf)~~
128		{
129		~~char * file = strtok(command, " ");~~
130		~~char * p2 = strtok(NULL, " ");~~
131		~~if(!file \|\| !p2)~~
132		{
133		~~zprintf("Syntax is: writepdump $filename $playerNameOrGUID\r\n");~~
134		~~return;~~
135		}
136
137		~~std::string name;~~
138		~~if(!consoleToUtf8(p2,name)) // convert from console encoding to utf8~~
139		~~return;~~
140
141		~~if(!normalizePlayerName(name))~~
142		{
143		~~zprintf("Syntax is: writepdump $filename $playerNameOrGUID\r\n");~~
144		~~return;~~
145		}
146
147		~~uint32 guid = objmgr.GetPlayerGUIDByName(name);~~
148		~~if(!guid)~~
149		~~guid = atoi(p2);~~
150
151		~~if(!guid)~~
152		{
153		~~zprintf("Syntax is: writepdump $filename $playerNameOrGUID\r\n");~~
154		~~return;~~
155		}
156
157		~~PlayerDumpWriter().WriteDump(file, guid);~~
158		}
159
160		~~/// Load a character from a dump file~~
161		~~void CliLoadPlayerDump(char*command,pPrintf zprintf)~~
162		{
163		~~char * file = strtok(command, " ");~~
164		~~char * acc = strtok(NULL, " ");~~
165		~~if (!file \|\|!acc)~~
166		{
167		~~zprintf("Syntax is: loadpdump $filename $account ($newname) ($newguid)\r\n");~~
168		~~return;~~
169		}
170
171		~~uint32 account_id = accmgr.GetId(acc);~~
172		~~if(!account_id)~~
173		{
174		~~account_id = atoi(acc);~~
175		~~if(account_id)~~
176		{
177		~~std::string acc_name;~~
178		~~if(!accmgr.GetName(account_id,acc_name))~~
179		{
180		~~zprintf("Failed to load the character! Account not exist.\r\n");~~
181		~~return;~~
182		}
183		}
184		~~else~~
185		{
186		~~zprintf("Failed to load the character! Account not exist.\r\n");~~
187		~~return;~~
188		}
189		}
190
191		~~char * name_str = strtok(NULL, " ");~~
192		~~char * guid_str = name_str ? strtok(NULL, " ") : NULL;~~
193
194		~~uint32 guid = guid_str ? atoi(guid_str) : 0;~~
195
196		~~std::string name;~~
197		~~if(name_str)~~
198		{
199		~~if(!consoleToUtf8(name_str,name)) // convert from console encoding to utf8~~
200		~~return;~~
201
202		~~if(!normalizePlayerName(name))~~
203		{
204		~~zprintf("Syntax is: loadpdump $filename $account ($newname) ($newguid)\r\n");~~
205		~~return;~~
206		}
207		}
208
209		~~if(PlayerDumpReader().LoadDump(file, account_id, name, guid))~~
210		~~zprintf("Character loaded successfully!\r\n");~~
211		~~else~~
212		~~zprintf("Failed to load the character!\r\n");~~
213		}
214
215		~~/// Reload the scripts and notify the players~~
216		~~void CliLoadScripts(char*command,pPrintf zprintf)~~
217		{
218		~~char const *del=strtok(command," ");~~
219		~~if (!del)~~
220		~~del="";~~
221		~~if(!LoadScriptingModule(del)) // Error report is already done by LoadScriptingModule~~
222		~~return;~~
223
224		~~sWorld.SendWorldText(LANG_SCRIPTS_RELOADED);~~
225	56	}
226	57
227	58	/// Delete a user account and all associated characters in this realm
228	59	/// \todo This function has to be enhanced to respect the login/realm split (delete char, delete account chars in realm, delete account chars in realm then delete account
229		void CliDelete(char*command,pPrintf zprintf)
230		{
	60	bool ChatHandler::HandleAccountDeleteCommand(const char* args)
	61	{
	62	if(!*args)
	63	return false;
	64
231	65	///- Get the account name from the command line
232		char *account_name_str=strtok(command," ");
233		if(!account_name_str)
234		{
235		// \r\n is used because this function can also be called from RA
236		zprintf("Syntax is: delete $account\r\n");
237		return;
238		}
239
240		std::string account_name;
241		if(!consoleToUtf8(account_name_str,account_name)) // convert from console encoding to utf8
242		return;
243
244		AccountOpResult result = accmgr.DeleteAccount(accmgr.GetId(account_name));
	66	char account_name_str=strtok ((char)args," ");
	67	if (!account_name_str)
	68	return false;
	69
	70	std::string account_name = account_name_str;
	71	if(!AccountMgr::normilizeString(account_name))
	72	{
	73	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
	74	SetSentErrorMessage(true);
	75	return false;
	76	}
	77
	78	uint32 account_id = accmgr.GetId(account_name);
	79	if(!account_id)
	80	{
	81	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
	82	SetSentErrorMessage(true);
	83	return false;
	84	}
	85
	86	/// Commands not recommended call from chat, but support anyway
	87	if(m_session)
	88	{
	89	uint32 targetSecurity = accmgr.GetSecurity(account_id);
	90
	91	/// can delete only for account with less security
	92	/// This is also reject self apply in fact
	93	if (targetSecurity >= m_session->GetSecurity())
	94	{
	95	SendSysMessage (LANG_YOURS_SECURITY_IS_LOW);
	96	SetSentErrorMessage (true);
	97	return false;
	98	}
	99	}
	100
	101	AccountOpResult result = accmgr.DeleteAccount(account_id);
245	102	switch(result)
246	103	{
247	104	case AOR_OK:
248		~~zprintf("We deleted account: %s\r\n"~~,account_name.c_str());
	105	PSendSysMessage(LANG_ACCOUNT_DELETED,account_name.c_str());
249	106	break;
250	107	case AOR_NAME_NOT_EXIST:
251		zprintf("User %s does not exist\r\n",account_name.c_str());
252		break;
	108	PSendSysMessage(LANG_ACCOUNT_NOT_EXIST,account_name.c_str());
	109	SetSentErrorMessage(true);
	110	return false;
253	111	case AOR_DB_INTERNAL_ERROR:
254		zprintf("User %s NOT deleted (probably sql file format was updated)\r\n",account_name.c_str());
255		break;
	112	PSendSysMessage(LANG_ACCOUNT_NOT_DELETED_SQL_ERROR,account_name.c_str());
	113	SetSentErrorMessage(true);
	114	return false;
256	115	default:
257		zprintf("User %s NOT deleted (unknown error)\r\n",account_name.c_str());
258		break;
259		}
260		}
261
262		void CliCharDelete(char*command,pPrintf zprintf)
263		{
264		char *character_name_str = strtok(command," ");
265
	116	PSendSysMessage(LANG_ACCOUNT_NOT_DELETED,account_name.c_str());
	117	SetSentErrorMessage(true);
	118	return false;
	119	}
	120
	121	return true;
	122	}
	123
	124	bool ChatHandler::HandleCharacterDeleteCommand(const char* args)
	125	{
	126	if(!*args)
	127	return false;
	128
	129	char character_name_str = strtok((char)args," ");
266	130	if(!character_name_str)
267		{
268		zprintf("Syntax is: chardelete $character_name\r\n");
269		return;
270		}
271
272		std::string character_name;
273		if(!consoleToUtf8(character_name_str,character_name)) // convert from console encoding to utf8
274		return;
275
	131	return false;
	132
	133	std::string character_name = character_name_str;
276	134	if(!normalizePlayerName(character_name))
277		{
278		zprintf("Syntax is: chardelete $character_name\r\n");
279		return;
280		}
281
282		Player *player = objmgr.GetPlayer(character_name.c_str());
	135	return false;
283	136
284	137	uint64 character_guid;
285	138	uint32 account_id;
286	139
	140	Player *player = objmgr.GetPlayer(character_name.c_str());
287	141	if(player)
288	142	{
…	…
296	150	if(!character_guid)
297	151	{
298		zprintf("Player %s not found!\r\n",character_name.c_str());
299		return;
	152	PSendSysMessage(LANG_NO_PLAYER,character_name.c_str());
	153	SetSentErrorMessage(true);
	154	return false;
300	155	}
301	156
…	…
303	158	}
304	159
	160	std::string account_name;
	161	accmgr.GetName (account_id,account_name);
	162
305	163	Player::DeleteFromDB(character_guid, account_id, true);
306		zprintf("Player %s (Guid: %u AccountId: %u) deleted\r\n",character_name.c_str(),GUID_LOPART(character_guid),account_id);
307		}
308
309		/// Broadcast a message to the World
310		void CliBroadcast(char *text,pPrintf zprintf)
311		{
312		std::string textUtf8;
313		if(!consoleToUtf8(text,textUtf8)) // convert from console encoding to utf8
314		return;
315
316		sWorld.SendWorldText(LANG_SYSTEMMESSAGE,textUtf8.c_str());
317		zprintf("Broadcasting to the world: %s\r\n",textUtf8.c_str());
318		}
319
320		/// Print the list of commands and associated description
321		void CliHelp(char*,pPrintf zprintf)
322		{
323		for (unsigned int x=0;x<CliTotalCmds;x++)
324		zprintf("%-13s - %s.\r\n",Commands[x].cmd ,Commands[x].description);
	164	PSendSysMessage(LANG_CHARACTER_DELETED,character_name.c_str(),GUID_LOPART(character_guid),account_name.c_str(), account_id);
	165	return true;
325	166	}
326	167
327	168	/// Exit the realm
328		~~void CliExit(char*,pPrintf zprintf~~)
329		{
330		~~zprintf( "Exiting daemon...\r\n"~~ );
	169	bool ChatHandler::HandleServerExitCommand(const char* args)
	170	{
	171	SendSysMessage(LANG_COMMAND_EXIT);
331	172	World::m_stopEvent = true;
332		}
333
334		/// Restart the server (with some delay) as soon as no active connections remain on the server
335		void CliIdleRestart(char* command,pPrintf zprintf)
336		{
337		char *args = strtok(command," ");
338
339		if(!args)
340		{
341		zprintf("Syntax is: idlerestart $seconds\|cancel\r\n");
342		return;
343		}
344
345		if(std::string(args)=="cancel")
346		{
347		sWorld.ShutdownCancel();
348		}
349		else
350		{
351
352		uint32 time = atoi(args);
353
354		///- Prevent interpret wrong arg value as 0 secs shutdown time
355		if(time==0 && (args[0]!='0' \|\| args[1]!='\0') \|\| time < 0)
356		{
357		zprintf("Syntax is: idlerestart $seconds\|cancel\r\n");
358		return;
359		}
360
361		sWorld.ShutdownServ(time,SHUTDOWN_MASK_RESTART\|SHUTDOWN_MASK_IDLE);
362		}
363		}
364
365		/// Restart the server with some delay
366		void CliRestart(char* command,pPrintf zprintf)
367		{
368		char *args = strtok(command," ");
369
370		if(!args)
371		{
372		zprintf("Syntax is: restart $seconds\|cancel\r\n");
373		return;
374		}
375
376		if(std::string(args)=="cancel")
377		{
378		sWorld.ShutdownCancel();
379		}
380		else
381		{
382		int32 time = atoi(args);
383
384		///- Prevent interpret wrong arg value as 0 secs shutdown time
385		if(time==0 && (args[0]!='0' \|\| args[1]!='\0') \|\| time < 0)
386		{
387		zprintf("Syntax is: restart $seconds\|cancel\r\n");
388		return;
389		}
390
391		sWorld.ShutdownServ(time,SHUTDOWN_MASK_RESTART);
392		}
393		}
394
395		/// Shutdown the server (with some delay) as soon as no active connections remain on the server
396		void CliIdleShutdown(char* command,pPrintf zprintf)
397		{
398		char *args = strtok(command," ");
399
400		if(!args)
401		{
402		zprintf("Syntax is: idleshutdown $seconds\|cancel\r\n");
403		return;
404		}
405
406		if(std::string(args)=="cancel")
407		{
408		sWorld.ShutdownCancel();
409		}
410		else
411		{
412
413		uint32 time = atoi(args);
414
415		///- Prevent interpret wrong arg value as 0 secs shutdown time
416		if(time==0 && (args[0]!='0' \|\| args[1]!='\0') \|\| time < 0)
417		{
418		zprintf("Syntax is: idleshutdown $seconds\|cancel\r\n");
419		return;
420		}
421
422		sWorld.ShutdownServ(time,SHUTDOWN_MASK_IDLE);
423		}
424		}
425
426		/// Shutdown the server with some delay
427		void CliShutdown(char* command,pPrintf zprintf)
428		{
429		char *args = strtok(command," ");
430
431		if(!args)
432		{
433		zprintf("Syntax is: shutdown $seconds\|cancel\r\n");
434		return;
435		}
436
437		if(std::string(args)=="cancel")
438		{
439		sWorld.ShutdownCancel();
440		}
441		else
442		{
443		int32 time = atoi(args);
444
445		///- Prevent interpret wrong arg value as 0 secs shutdown time
446		if(time==0 && (args[0]!='0' \|\| args[1]!='\0') \|\| time < 0)
447		{
448		zprintf("Syntax is: shutdown $seconds\|cancel\r\n");
449		return;
450		}
451
452		sWorld.ShutdownServ(time);
453		}
	173	return true;
454	174	}
455	175
456	176	/// Display info on users currently in the realm
457		void CliInfo(char*,pPrintf zprintf)
458		{
459		uint32 activeClientsNum = sWorld.GetActiveSessionCount();
460		uint32 queuedClientsNum = sWorld.GetQueuedSessionCount();
461		uint32 maxActiveClientsNum = sWorld.GetMaxActiveSessionCount();
462		uint32 maxQueuedClientsNum = sWorld.GetMaxQueuedSessionCount();
463		std::string timeStr = secsToTimeString(sWorld.GetUptime(),true);
464
465		zprintf("Online players: %u (max: %u) queued: %u (max: %u) Uptime: %s\r\n",activeClientsNum,maxActiveClientsNum,queuedClientsNum,maxQueuedClientsNum,timeStr.c_str());
466
	177	bool ChatHandler::HandleAccountOnlineListCommand(const char* args)
	178	{
467	179	///- Get the list of accounts ID logged to the realm
468	180	QueryResult *resultDB = CharacterDatabase.Query("SELECT name,account FROM characters WHERE online > 0");
469
470	181	if (!resultDB)
471		return;
	182	return true;
472	183
473	184	///- Display the list of account/characters online
474		~~zprintf("=====================================================================\r\n~~");
475		~~zprintf("\| Account \| Character \| IP \| GM \| Exp \|\r\n"~~);
476		~~zprintf("=====================================================================\r\n~~");
	185	SendSysMessage("=====================================================================");
	186	SendSysMessage(LANG_ACCOUNT_LIST_HEADER);
	187	SendSysMessage("=====================================================================");
477	188
478	189	///- Circle through accounts
…	…
491	202	{
492	203	Field *fieldsLogin = resultLogin->Fetch();
493		~~zprintf("\|%15s\| %20s \| %15s \|%4d\|%5d\|\r\n~~",
	204	PSendSysMessage("\|%15s\| %20s \| %15s \|%4d\|%5d\|",
494	205	fieldsLogin[0].GetString(),name.c_str(),fieldsLogin[1].GetString(),fieldsLogin[2].GetUInt32(),fieldsLogin[3].GetUInt32());
495	206
…	…
497	208	}
498	209	else
499		~~zprintf("\|<Error> \| %20s \|<Error> \|<Er>\|<Err>\|\r\n"~~,name.c_str());
	210	PSendSysMessage(LANG_ACCOUNT_LIST_ERROR,name.c_str());
500	211
501	212	}while(resultDB->NextRow());
…	…
503	214	delete resultDB;
504	215
505		zprintf("=====================================================================\r\n");
506		}
507
508		/// Display a list of banned accounts and ip addresses
509		void CliBanList(char*,pPrintf zprintf)
510		{
511		bool found = false;
512		///- Get the list of banned accounts and display them
513		QueryResult *result = loginDatabase.Query("SELECT id,username FROM account WHERE id IN (SELECT id FROM account_banned WHERE active = 1)");
514		if(result)
515		{
516		found = true;
517
518		zprintf("Currently Banned Accounts:\r\n");
519		zprintf("===============================================================================\r\n");
520		zprintf("\| Account \| BanDate \| UnbanDate \| Banned By \| Ban Reason \|\r\n");
521		do
522		{
523		zprintf("-------------------------------------------------------------------------------\r\n");
524		Field *fields = result->Fetch();
525		// No SQL injection. id is uint32.
526		QueryResult *banInfo = loginDatabase.PQuery("SELECT bandate,unbandate,bannedby,banreason FROM account_banned WHERE id = %u AND active = 1 ORDER BY unbandate", fields[0].GetUInt32());
527		if (banInfo)
528		{
529		Field *fields2 = banInfo->Fetch();
530		do
531		{
532		time_t t_ban = fields2[0].GetUInt64();
533		tm* aTm_ban = localtime(&t_ban);
534		zprintf("\|%-15.15s\|", fields[1].GetString());
535		zprintf("%02d-%02d-%02d %02d:%02d\|", aTm_ban->tm_year%100, aTm_ban->tm_mon+1, aTm_ban->tm_mday, aTm_ban->tm_hour, aTm_ban->tm_min);
536		if ( fields2[0].GetUInt64() == fields2[1].GetUInt64() )
537		zprintf(" permanent \|");
538		else
539		{
540		time_t t_unban = fields2[1].GetUInt64();
541		tm* aTm_unban = localtime(&t_unban);
542		zprintf("%02d-%02d-%02d %02d:%02d\|",aTm_unban->tm_year%100, aTm_unban->tm_mon+1, aTm_unban->tm_mday, aTm_unban->tm_hour, aTm_unban->tm_min);
543		}
544		zprintf("%-15.15s\|%-15.15s\|\r\n",fields2[2].GetString(),fields2[3].GetString());
545		}while ( banInfo->NextRow() );
546		delete banInfo;
547		}
548		}while( result->NextRow() );
549		zprintf("===============================================================================\r\n");
550		delete result;
551		}
552
553		///- Get the list of banned IP addresses and display them
554		result = loginDatabase.Query( "SELECT ip,bandate,unbandate,bannedby,banreason FROM ip_banned WHERE (bandate=unbandate OR unbandate>UNIX_TIMESTAMP()) ORDER BY unbandate" );
555		if(result)
556		{
557		found = true;
558
559		zprintf("Currently Banned IPs:\r\n");
560		zprintf("===============================================================================\r\n");
561		zprintf("\| IP \| BanDate \| UnbanDate \| Banned By \| Ban Reason \|\r\n");
562		do
563		{
564		zprintf("-------------------------------------------------------------------------------\r\n");
565		Field *fields = result->Fetch();
566		time_t t_ban = fields[1].GetUInt64();
567		tm* aTm_ban = localtime(&t_ban);
568		zprintf("\|%-15.15s\|", fields[0].GetString());
569		zprintf("%02d-%02d-%02d %02d:%02d\|", aTm_ban->tm_year%100, aTm_ban->tm_mon+1, aTm_ban->tm_mday, aTm_ban->tm_hour, aTm_ban->tm_min);
570		if ( fields[1].GetUInt64() == fields[2].GetUInt64() )
571		zprintf(" permanent \|");
572		else
573		{
574		time_t t_unban = fields[2].GetUInt64();
575		tm* aTm_unban = localtime(&t_unban);
576		zprintf("%02d-%02d-%02d %02d:%02d\|", aTm_unban->tm_year%100, aTm_unban->tm_mon+1, aTm_unban->tm_mday, aTm_unban->tm_hour, aTm_unban->tm_min);
577		}
578		zprintf("%-15.15s\|%-15.15s\|\r\n", fields[3].GetString(), fields[4].GetString());
579		}while( result->NextRow() );
580		zprintf("===============================================================================\r\n");
581		delete result;
582		}
583
584		if(!found)
585		zprintf("We do not have banned users\r\n");
586		}
587
588		/// Ban an IP address or a user account
589		void CliBan(char*command,pPrintf zprintf)
590		{
591		///- Get the command parameter
592		char* type_str = strtok((char*)command, " ");
593		char* nameOrIP_str = strtok(NULL, " ");
594		char* duration_str = strtok(NULL," ");
595		char* reason_str = strtok(NULL,"");
596
597		if(!type_str\|\|!nameOrIP_str\|\|!duration_str\|\|!reason_str)// ?!? input of single char "0"-"9" wouldn't detect when with: \|\| !atoi(duration)
598		{
599		zprintf("Syntax: ban account\|ip\|character $AccountOrIpOrCharacter $duration[s\|m\|h\|d] $reason \r\n");
600		return;
601		}
602
603		std::string type;
604		if(!consoleToUtf8(type_str,type)) // convert from console encoding to utf8
605		return;
606
607		std::string nameOrIP;
608		if(!consoleToUtf8(nameOrIP_str,nameOrIP)) // convert from console encoding to utf8
609		return;
610
611		std::string duration;
612		if(!consoleToUtf8(duration_str,duration)) // convert from console encoding to utf8
613		return;
614
615		std::string reason;
616		if(!consoleToUtf8(reason_str,reason)) // convert from console encoding to utf8
617		return;
618
619		switch (sWorld.BanAccount(type, nameOrIP, duration, reason, "Set by console."))
620		{
621		case BAN_SUCCESS:
622		if(atoi(duration_str)>0)
623		zprintf("%s is banned for %s. Reason: %s.\r\n",nameOrIP.c_str(),secsToTimeString(TimeStringToSecs(duration_str),true,false).c_str(),reason.c_str());
624		else
625		zprintf("%s is banned permanently. Reason: %s.\r\n",nameOrIP.c_str(),reason.c_str());
626		break;
627		case BAN_NOTFOUND:
628		zprintf("%s %s not found\r\n", type.c_str(), nameOrIP.c_str());
629		break;
630		case BAN_SYNTAX_ERROR:
631		zprintf("Syntax: ban account\|ip\|character $AccountOrIpOrCharacter $duration[s\|m\|h\|d] $reason \r\n");
632		break;
633		}
634		}
635
636		/// Display %TrinIty version
637		void CliVersion(char*,pPrintf zprintf)
638		{
639		//<--maybe better append to info cmd
640		zprintf( "%s (world-daemon)\r\n", _FULLVERSION );
641		}
642
643		/// Unban an IP adress or a user account
644		void CliRemoveBan(char *command,pPrintf zprintf)
645		{
646		///- Get the command parameter
647		char *type_str = strtok(command," ");
648		char *nameorip_str = strtok(NULL," ");
649		if(!nameorip_str\|\|!type_str)
650		{
651		zprintf("Syntax is: unban account\|ip\|character $nameorip\r\n");
652		return;
653		}
654
655		std::string type;
656		if(!consoleToUtf8(type_str,type)) // convert from console encoding to utf8
657		return;
658
659		std::string nameorip;
660		if(!consoleToUtf8(nameorip_str,nameorip)) // convert from console encoding to utf8
661		return;
662
663		if (!sWorld.RemoveBanAccount(type, nameorip))
664		zprintf("%s %s not found\r\n", type.c_str(), nameorip.c_str());
665		else
666		zprintf("We removed ban from %s: %s\r\n",type_str,nameorip.c_str());
667		}
668
669		/// Display the list of GMs
670		void CliListGM(char*,pPrintf zprintf)
671		{
672
673		///- Get the accounts with GM Level >0
674		Field *fields;
675
676		QueryResult *result = loginDatabase.Query( "SELECT username,gmlevel FROM account WHERE gmlevel > 0" );
677		if(result)
678		{
679
680		zprintf("Current gamemasters:\r\n");
681		zprintf("========================\r\n");
682		zprintf("\| Account \| GM \|\r\n");
683		zprintf("========================\r\n");
684
685		///- Circle through them. Display username and GM level
686		do
687		{
688		fields = result->Fetch();
689		zprintf("\|%15s\|", fields[0].GetString());
690		zprintf("%6s\|\r\n",fields[1].GetString());
691		}while( result->NextRow() );
692
693		zprintf("========================\r\n");
694		delete result;
695		}
696		else
697		{
698		zprintf("No gamemasters\r\n");
699		}
700		}
701
702		/// Set the GM level of an account
703		void CliSetGM(char *command,pPrintf zprintf)
704		{
705		///- Get the command line arguments
706		char *szAcc = strtok(command," ");
707		char *szLevel = strtok(NULL," ");
708
709		if(!szAcc\|\|!szLevel) //wrong syntax 'setgm' without name
710		{
711		zprintf("Syntax is: setgm $account $number (0 - normal, 3 - gamemaster)>\r\n");
712		return;
713		}
714
715		//wow it's ok,let's hope it was integer given
716		int lev=atoi(szLevel); //get int anyway (0 if error)
717
718		std::string safe_account_name;
719		if(!consoleToUtf8(szAcc,safe_account_name)) // convert from console encoding to utf8
720		return;
721
722		///- Convert Account name to Upper Format
723		AccountMgr::normilizeString(safe_account_name);
724
725		///- Escape the account name to allow quotes in names
726		loginDatabase.escape_string(safe_account_name);
727
728		///- Try to find the account, then update the GM level
729		// No SQL injection (account name is escaped)
730		QueryResult *result = loginDatabase.PQuery("SELECT id FROM account WHERE username = '%s'",safe_account_name.c_str());
731
732		if (result)
733		{
734		Field *fields = result->Fetch();
735		uint32 account_id = fields[0].GetUInt32();
736		delete result;
737
738		WorldSession* session = sWorld.FindSession(account_id);
739		if(session)
740		session->SetSecurity(lev);
741
742		// No SQL injection (account name is escaped)
743		loginDatabase.PExecute("UPDATE account SET gmlevel = '%d' WHERE username = '%s'",lev,safe_account_name.c_str());
744		zprintf("We set %s gmlevel %d\r\n",safe_account_name.c_str(),lev);
745		}
746		else
747		{
748		zprintf("No account %s found\r\n",safe_account_name.c_str());
749		}
750		}
751
752		/// Set password for account
753		void CliSetPassword(char *command,pPrintf zprintf)
754		{
755		///- Get the command line arguments
756		char *szAcc = strtok(command," ");
757		char *szPassword1 = strtok(NULL," ");
758		char *szPassword2 = strtok(NULL," ");
759
760		if(!szAcc\|\|!szPassword1 \|\| !szPassword2)
761		{
762		zprintf("Syntax is: setpass $account $password $password\r\n");
763		return;
764		}
765
766		std::string account_name;
767		if(!consoleToUtf8(szAcc,account_name)) // convert from console encoding to utf8
768		return;
769
770		std::string pass1;
771		if(!consoleToUtf8(szPassword1,pass1)) // convert from console encoding to utf8
772		return;
773
774		std::string pass2;
775		if(!consoleToUtf8(szPassword2,pass2)) // convert from console encoding to utf8
776		return;
777
778		uint32 acc_id = accmgr.GetId(szAcc);
779		if (!acc_id)
780		{
781		zprintf("Account '%s' does not exist!\r\n", account_name.c_str());
782		return;
783		}
784
785		if (pass1 != pass2)
786		{
787		zprintf("Password does not match the confirm password, password not changed!\r\n");
788		return;
789		}
790
791		AccountOpResult result = accmgr.ChangePassword(acc_id, pass1);
792
793		switch(result)
794		{
795		case AOR_OK:
796		zprintf("The password was changed for account '%s' (ID: %u).\r\n",account_name.c_str(),acc_id);
797		break;
798		case AOR_PASS_TOO_LONG:
799		zprintf("Password can't be longer than 16 characters (client limit), password not changed!\r\n");
800		break;
801		case AOR_NAME_NOT_EXIST:
802		zprintf("Account '%s' does not exist!\r\n", account_name.c_str());
803		break;
804		case AOR_DB_INTERNAL_ERROR:
805		zprintf("Password not changed! (probably sql file format was updated)\r\n");
806		break;
807		default:
808		zprintf("Password not changed! (unknown error\r\n");
809		break;
810		}
	216	SendSysMessage("=====================================================================");
	217	return true;
811	218	}
812	219
813	220	/// Create an account
814		void CliCreate(char *command,pPrintf zprintf)
815		{
816		//I see no need in this function (why would an admin personally create accounts
817		//instead of using account registration page or accessing db directly?)
818		//but still let it be
	221	bool ChatHandler::HandleAccountCreateCommand(const char* args)
	222	{
	223	if(!*args)
	224	return false;
819	225
820	226	///- %Parse the command line arguments
821		char *szAcc = strtok(~~command~~, " ");
	227	char szAcc = strtok((char)args, " ");
822	228	char *szPassword = strtok(NULL, " ");
823	229	if(!szAcc \|\| !szPassword)
824		{
825		zprintf("Syntax is: create $username $password\r\n");
826		return;
827		}
828
829		std::string account_name;
830		if(!consoleToUtf8(szAcc,account_name)) // convert from console encoding to utf8
831		return;
832
833		std::string password;
834		if(!consoleToUtf8(szPassword,password)) // convert from console encoding to utf8
835		return;
	230	return false;
	231
	232	// normilized in accmgr.CreateAccount
	233	std::string account_name = szAcc;
	234	std::string password = szPassword;
836	235
837	236	AccountOpResult result = accmgr.CreateAccount(account_name, password);
…	…
839	238	{
840	239	case AOR_OK:
841		~~zprintf("User %s with password %s created successfully\r\n",account_name.c_str(),password~~.c_str());
	240	PSendSysMessage(LANG_ACCOUNT_CREATED,account_name.c_str());
842	241	break;
843	242	case AOR_NAME_TOO_LONG:
844		zprintf("Username %s is too long\r\n", account_name.c_str());
845		break;
	243	SendSysMessage(LANG_ACCOUNT_TOO_LONG);
	244	SetSentErrorMessage(true);
	245	return false;
846	246	case AOR_NAME_ALREDY_EXIST:
847		zprintf("User %s already exists\r\n",account_name.c_str());
848		break;
	247	SendSysMessage(LANG_ACCOUNT_ALREADY_EXIST);
	248	SetSentErrorMessage(true);
	249	return false;
849	250	case AOR_DB_INTERNAL_ERROR:
850		zprintf("User %s with password %s NOT created (probably sql file format was updated)\r\n",account_name.c_str(),password.c_str());
851		break;
	251	PSendSysMessage(LANG_ACCOUNT_NOT_CREATED_SQL_ERROR,account_name.c_str());
	252	SetSentErrorMessage(true);
	253	return false;
852	254	default:
853		zprintf("User %s with password %s NOT created (unknown error)\r\n",account_name.c_str(),password.c_str());
854		break;
855		}
856		}
857
858		/// Command parser and dispatcher
859		void ParseCommand( pPrintf zprintf, char* input)
860		{
861		unsigned int x;
862		bool bSuccess=false;
863		if (!input)
864		return;
865
866		unsigned int l=strlen(input);
867		char supposedCommand=NULL, arguments=(char*)("");
868		if(l)
869		{
870		///- Get the command and the arguments
871		supposedCommand = strtok(input," ");
872		if (supposedCommand)
873		{
874		if (l>strlen(supposedCommand))
875		arguments=&input[strlen(supposedCommand)+1];
876
877		///- Circle through the command table and, if found, put the command in the queue
878		for ( x=0;x<CliTotalCmds;x++)
879		if(!strcmp(Commands[x].cmd,supposedCommand))
880		{
881		sWorld.QueueCliCommand(new CliCommandHolder(&Commands[x], arguments, zprintf));
882		bSuccess=true;
883		break;
884		}
885
886		///- Display an error message if the command is unknown
887		if(x==CliTotalCmds)
888		zprintf("Unknown command: %s\r\n", input);
889		}
890		}
891		if (!bSuccess)
892		zprintf("TC>");
893		}
894
895		/// Kick a character out of the realm
896		void CliKick(char*command,pPrintf zprintf)
897		{
898		char *kickName = strtok(command, " ");
899
900		if (!kickName)
901		{
902		zprintf("Syntax is: kick $charactername\r\n");
903		return;
904		}
905
906		std::string name;
907		if(!consoleToUtf8(kickName,name)) // convert from console encoding to utf8
908		return;
909
910		if(!normalizePlayerName(name))
911		return;
912
913		sWorld.KickPlayer(name);
914		}
915
916		/// Teleport a character to location
917		void CliTele(char*command,pPrintf zprintf)
918		{
919		char *charName = strtok(command, " ");
920		char *locName = strtok(NULL, " ");
921
922		if (!charName \|\| !locName)
923		{
924		zprintf("Syntax is: tele $charactername $location\r\n");
925		return;
926		}
927
928		std::string name = charName;
929		if(!consoleToUtf8(charName,name)) // convert from console encoding to utf8
930		return;
931
932		if(!normalizePlayerName(name))
933		return;
934
935		std::string location;
936		if(!consoleToUtf8(locName,location)) // convert from console encoding to utf8
937		return;
938
939		WorldDatabase.escape_string(location);
940		QueryResult *result = WorldDatabase.PQuery("SELECT position_x,position_y,position_z,orientation,map FROM game_tele WHERE name = '%s'",location.c_str());
941		if (!result)
942		{
943		zprintf(objmgr.GetTrinityStringForDBCLocale(LANG_COMMAND_TELE_NOTFOUND),"\r\n");
944		return;
945		}
946
947		Field *fields = result->Fetch();
948		float x = fields[0].GetFloat();
949		float y = fields[1].GetFloat();
950		float z = fields[2].GetFloat();
951		float ort = fields[3].GetFloat();
952		int mapid = fields[4].GetUInt16();
953		delete result;
954
955		if(!MapManager::IsValidMapCoord(mapid,x,y,z,ort))
956		{
957		zprintf(objmgr.GetTrinityStringForDBCLocale(LANG_INVALID_TARGET_COORD),"\r\n",x,y,mapid);
958		return;
959		}
960
961		Player *chr = objmgr.GetPlayer(name.c_str());
962		if (chr)
963		{
964
965		if(chr->IsBeingTeleported()==true)
966		{
967		zprintf(objmgr.GetTrinityStringForDBCLocale(LANG_IS_TELEPORTED),"\r\n",chr->GetName());
968		return;
969		}
970
971		if(chr->isInFlight())
972		{
973		zprintf(objmgr.GetTrinityStringForDBCLocale(LANG_CHAR_IN_FLIGHT),"\r\n",chr->GetName());
974		return;
975		}
976
977		zprintf(objmgr.GetTrinityStringForDBCLocale(LANG_TELEPORTING_TO),"\r\n",chr->GetName(),"", location.c_str());
978
979		chr->SaveRecallPosition();
980
981		chr->TeleportTo(mapid,x,y,z,chr->GetOrientation());
982		}
983		else if (uint64 guid = objmgr.GetPlayerGUIDByName(name.c_str()))
984		{
985		zprintf(objmgr.GetTrinityStringForDBCLocale(LANG_TELEPORTING_TO),"\r\n",name.c_str(), objmgr.GetTrinityStringForDBCLocale(LANG_OFFLINE), location.c_str());
986		Player::SavePositionInDB(mapid,x,y,z,ort,MapManager::Instance().GetZoneId(mapid,x,y),guid);
987		}
988		else
989		zprintf(objmgr.GetTrinityStringForDBCLocale(LANG_NO_PLAYER),"\r\n",name.c_str());
990		}
991
992		/// Display/Define the 'Message of the day' for the realm
993		void CliMotd(char*command,pPrintf zprintf)
994		{
995
996		if (strlen(command) == 0)
997		{
998		zprintf("Current Message of the day: \r\n%s\r\n", sWorld.GetMotd());
999		return;
1000		}
1001		else
1002		{
1003		std::string commandUtf8;
1004		if(!consoleToUtf8(command,commandUtf8)) // convert from console encoding to utf8
1005		return;
1006
1007		sWorld.SetMotd(commandUtf8);
1008		zprintf("Message of the day changed to:\r\n%s\r\n", commandUtf8.c_str());
1009		}
1010		}
1011
1012		/// Comment me
1013		/// \todo What is CorpsesErase for?
1014		void CliCorpses(char*,pPrintf)
1015		{
1016		CorpsesErase();
	255	PSendSysMessage(LANG_ACCOUNT_NOT_CREATED,account_name.c_str());
	256	SetSentErrorMessage(true);
	257	return false;
	258	}
	259
	260	return true;
1017	261	}
1018	262
1019	263	/// Set the level of logging
1020		void CliSetLogLevel(char*command,pPrintf zprintf)
1021		{
1022		char *NewLevel = strtok(command, " ");
	264	bool ChatHandler::HandleServerSetLogLevelCommand(const char *args)
	265	{
	266	if(!*args)
	267	return false;
	268
	269	char NewLevel = strtok((char)args, " ");
1023	270	if (!NewLevel)
1024		{
1025		zprintf("Syntax is: setloglevel $loglevel\r\n");
1026		return;
1027		}
	271	return false;
	272
1028	273	sLog.SetLogLevel(NewLevel);
1029		}
1030
1031		/// Display the server uptime
1032		void CliUpTime(char*,pPrintf zprintf)
1033		{
1034		uint32 uptime = sWorld.GetUptime();
1035		std::string suptime = secsToTimeString(uptime,true,(uptime > 86400));
1036		zprintf("Server has been up for: %s\r\n", suptime.c_str());
1037		}
1038
1039		/// Set/Unset the TBC flag for an account
1040		void CliSetAddon(char *command,pPrintf zprintf)
1041		{
1042		///- Get the command line arguments
1043		char *szAcc = strtok(command," ");
1044		char *szExp = strtok(NULL," ");
1045
1046		if(!szAcc\|\|!szExp)
1047		{
1048		zprintf("Syntax is: setbc $account $number (0 - normal, 1 - tbc, 2 - wotlk)>\r\n");
1049		return;
1050		}
1051
1052		int lev=atoi(szExp); //get int anyway (0 if error)
1053
1054		if(lev < 0)
1055		{
1056		zprintf("Syntax is: setbc $account $number (0 - normal, 1 - tbc, 2 - wotlk)>\r\n");
1057		return;
1058		}
1059
1060		///- Escape the account name to allow quotes in names
1061		std::string safe_account_name;
1062		if(!consoleToUtf8(szAcc,safe_account_name)) // convert from console encoding to utf8
1063		return;
1064
1065		///- Convert Account name to Upper Format
1066		AccountMgr::normilizeString(safe_account_name);
1067
1068		///- Escape the account name to allow quotes in names
1069		loginDatabase.escape_string(safe_account_name);
1070
1071		// No SQL injection (account name is escaped)
1072		QueryResult *result = loginDatabase.PQuery("SELECT 1 FROM account WHERE username = '%s'",safe_account_name.c_str());
1073
1074		if (result)
1075		{
1076		// No SQL injection (account name is escaped)
1077		loginDatabase.PExecute("UPDATE account SET expansion = '%d' WHERE username = '%s'",lev,safe_account_name.c_str());
1078		zprintf("We set %s to expansion allowed %d\r\n",safe_account_name.c_str(),lev);
1079
1080		delete result;
1081		}
1082		else
1083		{
1084		zprintf("No account %s found\r\n",safe_account_name.c_str());
1085		}
1086		}
1087
1088		/// Save all players
1089		void CliSave(char*,pPrintf zprintf)
1090		{
1091		///- Save players
1092		ObjectAccessor::Instance().SaveAllPlayers();
1093		zprintf( objmgr.GetTrinityStringForDBCLocale(LANG_PLAYERS_SAVED) );
1094
1095		///- Send a message
1096		sWorld.SendWorldText(LANG_PLAYERS_SAVED);
1097		}
1098
1099		/// Send a message to a player in game
1100		void CliSend(char *playerN,pPrintf zprintf)
1101		{
1102		///- Get the command line arguments
1103		char* name_str = strtok((char*)playerN, " ");
1104		char* msg_str = strtok(NULL, "");
1105
1106		if(!name_str \|\| !msg_str)
1107		{
1108		zprintf("Syntax: send $player $message (Player name is case sensitive)\r\n");
1109		return;
1110		}
1111
1112		std::string name;
1113		if(!consoleToUtf8(name_str,name)) // convert from console encoding to utf8
1114		return;
1115
1116		std::string msg;
1117		if(!consoleToUtf8(msg_str,msg)) // convert from console encoding to utf8
1118		return;
1119
1120		if(!normalizePlayerName(name))
1121		{
1122		zprintf("Syntax: send $player $message (Player name is case sensitive)\r\n");
1123		return;
1124		}
1125
1126		///- Find the player and check that he is not logging out.
1127		Player *rPlayer = objmgr.GetPlayer(name.c_str());
1128		if(!rPlayer)
1129		{
1130		zprintf("Player %s not found!\r\n", name.c_str());
1131		return;
1132		}
1133
1134		if (rPlayer->GetSession()->isLogingOut())
1135		{
1136		zprintf("Cannot send message while player %s is logging out!\r\n",name.c_str());
1137		return;
1138		}
1139
1140		///- Send the message
1141		//Use SendAreaTriggerMessage for fastest delivery.
1142		rPlayer->GetSession()->SendAreaTriggerMessage("%s", msg.c_str());
1143		rPlayer->GetSession()->SendAreaTriggerMessage("\|cffff0000[Message from administrator]:\|r");
1144
1145		//Confirmation message
1146		zprintf("Message '%s' sent to %s\r\n",msg.c_str(), name.c_str());
1147		}
1148
1149		void CliPLimit(char *args,pPrintf zprintf)
1150		{
1151		if(*args)
1152		{
1153		char* param = strtok((char*)args, " ");
1154		if(!param \|\| !*param)
1155		return;
1156
1157		int l = strlen(param);
1158
1159		if( strncmp(param,"player",l) == 0 )
1160		sWorld.SetPlayerLimit(-SEC_PLAYER);
1161		else if(strncmp(param,"moderator",l) == 0 )
1162		sWorld.SetPlayerLimit(-SEC_MODERATOR);
1163		else if(strncmp(param,"gamemaster",l) == 0 )
1164		sWorld.SetPlayerLimit(-SEC_GAMEMASTER);
1165		else if(strncmp(param,"administrator",l) == 0 )
1166		sWorld.SetPlayerLimit(-SEC_ADMINISTRATOR);
1167		else if(strncmp(param,"reset",l) == 0 )
1168		sWorld.SetPlayerLimit(sConfig.GetIntDefault("PlayerLimit", DEFAULT_PLAYER_LIMIT));
1169		else
1170		{
1171		int val = atoi(param);
1172		if(val < -SEC_ADMINISTRATOR) val = -SEC_ADMINISTRATOR;
1173
1174		sWorld.SetPlayerLimit(val);
1175		}
1176
1177		// kick all low security level players
1178		if(sWorld.GetPlayerAmountLimit() > SEC_PLAYER)
1179		sWorld.KickAllLess(sWorld.GetPlayerSecurityLimit());
1180		}
1181
1182		uint32 pLimit = sWorld.GetPlayerAmountLimit();
1183		AccountTypes allowedAccountType = sWorld.GetPlayerSecurityLimit();
1184		char const* secName = "";
1185		switch(allowedAccountType)
1186		{
1187		case SEC_PLAYER: secName = "Player"; break;
1188		case SEC_MODERATOR: secName = "Moderator"; break;
1189		case SEC_GAMEMASTER: secName = "Gamemaster"; break;
1190		case SEC_ADMINISTRATOR: secName = "Administrator"; break;
1191		default: secName = "<unknown>"; break;
1192		}
1193
1194		zprintf("Player limits: amount %u, min. security level %s.\r\n",pLimit,secName);
	274	return true;
1195	275	}
1196	276
…	…
1222	302	///- Display the list of available CLI functions then beep
1223	303	sLog.outString();
1224		~~/// \todo Shoudn't we use here also the sLog singleton?~~
1225		~~CliHelp(NULL,&UTF8ZPRINTF);~~
1226	304
1227	305	if(sConfig.GetBoolDefault("BeepAtStart", true))
1228		{
1229	306	printf("\a"); // \a = Alert
1230		}
1231	307
1232	308	// print this here the first time
…	…
1245	321	break;
1246	322	#endif
1247		char *command = fgets(commandbuf,sizeof(commandbuf),stdin);
1248		if (command != NULL)
	323	char *command_str = fgets(commandbuf,sizeof(commandbuf),stdin);
	324	if (command_str != NULL)
1249	325	{
1250		for(int x=0;command[x];x++)
1251		if(command[x]=='\r'\|\|command[x]=='\n')
	326	for(int x=0;command_str[x];x++)
	327	if(command_str[x]=='\r'\|\|command_str[x]=='\n')
	328	{
	329	command_str[x]=0;
	330	break;
	331	}
	332
	333	if(!*command_str)
1252	334	{
1253		~~command[x]=0~~;
1254		~~break~~;
	335	printf("TC>");
	336	continue;
1255	337	}
1256		//// \todo Shoudn't we use here also the sLog singleton?
1257		ParseCommand(&UTF8ZPRINTF,command);
	338
	339	std::string command;
	340	if(!consoleToUtf8(command_str,command)) // convert from console encoding to utf8
	341	{
	342	printf("TC>");
	343	continue;
	344	}
	345
	346	sWorld.QueueCliCommand(&utf8print,command.c_str());
1258	347	}
1259	348	else if (feof(stdin))
1260		{
1261	349	World::m_stopEvent = true;
1262		}
1263	350	}
1264	351

trunk/src/trinitycore/RASocket.cpp

r102	r112
45	45	typedef int(* pPrintf)(const char*,...);
46	46
47		void ParseCommand(~~pPrintf zprintf~~, char*command);
	47	void ParseCommand(CliCommandHolder::Print, charcommand);
48	48
49	49	/// RASocket constructor
…	…
223	223	{
224	224	sLog.outRALog("Got '%s' cmd.\n",buff);
225		~~ParseCommand(&RASocket::zprintf~~ , buff);
	225	sWorld.QueueCliCommand(&RASocket::zprint , buff);
226	226	}
227	227	else
…	…
235	235
236	236	/// Output function
237		int RASocket::zprintf( const char * szText, ... )
238		{
239		if( !szText ) return 0;
240		va_list ap;
241		va_start(ap, szText);
242		/// \todo Remove buffer length here. Can be >1024 (e.g. list of users)
243		char *megabuffer=new char[1024];
244		unsigned int sz=vsnprintf(megabuffer,1024,szText,ap);
	237	void RASocket::zprint( const char * szText )
	238	{
	239	if( !szText )
	240	return;
	241
245	242	#ifdef RA_CRYPT
	243
	244	char *megabuffer=strdup(szText);
	245	unsigned int sz=strlen(megabuffer);
246	246	Encrypt(megabuffer,sz);
	247	send(r,megabuffer,sz,0);
	248	delete [] megabuffer;
	249
	250	#else
	251
	252	unsigned int sz=strlen(szText);
	253	send(r,szText,sz,0);
	254
247	255	#endif
248
249		send(r,megabuffer,sz,0);
250		delete [] megabuffer;
251		va_end(ap);
252		return 0;
253		}
	256	}

trunk/src/trinitycore/RASocket.h

r102	r112
62	62	}stage;
63	63
64		static ~~int zprintf( const char * szText, ...~~ );
	64	static void zprint( const char * szText );
65	65	};
66	66	#endif

Context Navigation

Legend:

trunk/src/game/AccountMgr.h

trunk/src/game/Chat.cpp

trunk/src/game/Chat.h

trunk/src/game/Language.h

trunk/src/game/Level0.cpp

trunk/src/game/Level1.cpp

trunk/src/game/Level2.cpp

trunk/src/game/Level3.cpp

trunk/src/game/ObjectMgr.h

trunk/src/game/PlayerDump.cpp

trunk/src/game/PlayerDump.h

trunk/src/game/SharedDefines.h

trunk/src/game/World.cpp

trunk/src/game/World.h

trunk/src/game/WorldSession.cpp

trunk/src/game/WorldSession.h

trunk/src/shared/Common.h

trunk/src/trinitycore/CliRunnable.cpp

trunk/src/trinitycore/RASocket.cpp

trunk/src/trinitycore/RASocket.h

Download in other formats: