mangos-mirror/server
0
0
Fork 0
mirror of https://github.com/mangosfour/server.git synced 2025-12-14 07:37:01 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

[10322] In chat command handlers use char* arg instead "const char*"

Browse source 
We in any case modify args string content at parsing in commands,
so cast it to char* early. This let avoid lot later casts.

Some other code style exist in related code.
This commit is contained in:
VladimirMangos 2010-08-06 01:02:21 +04:00
parent 17ecab0030
commit 0cc1fbe697
9 changed files with 1200 additions and 1264 deletions
Download patch file Download diff file Expand all files Collapse all files

12
src/game/Chat.cpp
View file

@ -192,7 +192,7 @@ ChatCommand * ChatHandler::getCommandTable()
{ "setitemvalue", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDebugSetItemValueCommand, "", NULL }, { "setitemvalue", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDebugSetItemValueCommand, "", NULL },
{ "setvalue", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDebugSetValueCommand, "", NULL }, { "setvalue", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDebugSetValueCommand, "", NULL },
{ "spellcheck", SEC_CONSOLE, true, &ChatHandler::HandleDebugSpellCheckCommand, "", NULL }, { "spellcheck", SEC_CONSOLE, true, &ChatHandler::HandleDebugSpellCheckCommand, "", NULL },
{ "spawnvehicle", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDebugSpawnVehicle, "", NULL }, { "spawnvehicle", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDebugSpawnVehicleCommand, "", NULL },
{ "uws", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDebugUpdateWorldStateCommand, "", NULL }, { "uws", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDebugUpdateWorldStateCommand, "", NULL },
{ "update", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDebugUpdateCommand, "", NULL }, { "update", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDebugUpdateCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL } { NULL, 0, false, NULL, "", NULL }
@ -411,9 +411,9 @@ ChatCommand * ChatHandler::getCommandTable()
static ChatCommand questCommandTable[] = static ChatCommand questCommandTable[] =
{ {
{ "add", SEC_ADMINISTRATOR, false, &ChatHandler::HandleQuestAdd, "", NULL }, { "add", SEC_ADMINISTRATOR, false, &ChatHandler::HandleQuestAddCommand, "", NULL },
{ "complete", SEC_ADMINISTRATOR, false, &ChatHandler::HandleQuestComplete, "", NULL }, { "complete", SEC_ADMINISTRATOR, false, &ChatHandler::HandleQuestCompleteCommand, "", NULL },
{ "remove", SEC_ADMINISTRATOR, false, &ChatHandler::HandleQuestRemove, "", NULL }, { "remove", SEC_ADMINISTRATOR, false, &ChatHandler::HandleQuestRemoveCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL } { NULL, 0, false, NULL, "", NULL }
}; };
@ -706,7 +706,7 @@ ChatCommand * ChatHandler::getCommandTable()
{ "additem", SEC_ADMINISTRATOR, false, &ChatHandler::HandleAddItemCommand, "", NULL }, { "additem", SEC_ADMINISTRATOR, false, &ChatHandler::HandleAddItemCommand, "", NULL },
{ "additemset", SEC_ADMINISTRATOR, false, &ChatHandler::HandleAddItemSetCommand, "", NULL }, { "additemset", SEC_ADMINISTRATOR, false, &ChatHandler::HandleAddItemSetCommand, "", NULL },
{ "bank", SEC_ADMINISTRATOR, false, &ChatHandler::HandleBankCommand, "", NULL }, { "bank", SEC_ADMINISTRATOR, false, &ChatHandler::HandleBankCommand, "", NULL },
{ "wchange", SEC_ADMINISTRATOR, false, &ChatHandler::HandleChangeWeather, "", NULL }, { "wchange", SEC_ADMINISTRATOR, false, &ChatHandler::HandleChangeWeatherCommand, "", NULL },
{ "ticket", SEC_GAMEMASTER, true, &ChatHandler::HandleTicketCommand, "", NULL }, { "ticket", SEC_GAMEMASTER, true, &ChatHandler::HandleTicketCommand, "", NULL },
{ "delticket", SEC_GAMEMASTER, true, &ChatHandler::HandleDelTicketCommand, "", NULL }, { "delticket", SEC_GAMEMASTER, true, &ChatHandler::HandleDelTicketCommand, "", NULL },
{ "maxskill", SEC_ADMINISTRATOR, false, &ChatHandler::HandleMaxSkillCommand, "", NULL }, { "maxskill", SEC_ADMINISTRATOR, false, &ChatHandler::HandleMaxSkillCommand, "", NULL },
@ -1110,7 +1110,7 @@ void ChatHandler::ExecuteCommand(const char* text)
case CHAT_COMMAND_OK: case CHAT_COMMAND_OK:
{ {
SetSentErrorMessage(false); SetSentErrorMessage(false);
if ((this->*(command->Handler))(text)) if ((this->*(command->Handler))((char*)text)) // text content destroyed at call
{ {
if (command->SecurityLevel > SEC_PLAYER) if (command->SecurityLevel > SEC_PLAYER)
{ {

784
src/game/Chat.h
View file

@ -38,7 +38,7 @@ class ChatCommand
const char * Name; const char * Name;
uint32 SecurityLevel; // function pointer required correct align (use uint32) uint32 SecurityLevel; // function pointer required correct align (use uint32)
bool AllowConsole; bool AllowConsole;
bool (ChatHandler::*Handler)(const char* args); bool (ChatHandler::*Handler)(char* args);
std::string Help; std::string Help;
ChatCommand * ChildCommands; ChatCommand * ChildCommands;
}; };
@ -112,440 +112,440 @@ class ChatHandler
void CheckIntegrity(ChatCommand *table, ChatCommand *parentCommand); void CheckIntegrity(ChatCommand *table, ChatCommand *parentCommand);
ChatCommand* getCommandTable(); ChatCommand* getCommandTable();
bool HandleAccountCommand(const char* args); bool HandleAccountCommand(char* args);
bool HandleAccountCharactersCommand(const char* args); bool HandleAccountCharactersCommand(char* args);
bool HandleAccountCreateCommand(const char* args); bool HandleAccountCreateCommand(char* args);
bool HandleAccountDeleteCommand(const char* args); bool HandleAccountDeleteCommand(char* args);
bool HandleAccountLockCommand(const char* args); bool HandleAccountLockCommand(char* args);
bool HandleAccountOnlineListCommand(const char* args); bool HandleAccountOnlineListCommand(char* args);
bool HandleAccountPasswordCommand(const char* args); bool HandleAccountPasswordCommand(char* args);
bool HandleAccountSetAddonCommand(const char* args); bool HandleAccountSetAddonCommand(char* args);
bool HandleAccountSetGmLevelCommand(const char* args); bool HandleAccountSetGmLevelCommand(char* args);
bool HandleAccountSetPasswordCommand(const char* args); bool HandleAccountSetPasswordCommand(char* args);
bool HandleAuctionAllianceCommand(const char* args); bool HandleAuctionAllianceCommand(char* args);
bool HandleAuctionGoblinCommand(const char* args); bool HandleAuctionGoblinCommand(char* args);
bool HandleAuctionHordeCommand(const char* args); bool HandleAuctionHordeCommand(char* args);
bool HandleAuctionCommand(const char* args); bool HandleAuctionCommand(char* args);
bool HandleBanAccountCommand(const char* args); bool HandleBanAccountCommand(char* args);
bool HandleBanCharacterCommand(const char* args); bool HandleBanCharacterCommand(char* args);
bool HandleBanIPCommand(const char* args); bool HandleBanIPCommand(char* args);
bool HandleBanInfoAccountCommand(const char* args); bool HandleBanInfoAccountCommand(char* args);
bool HandleBanInfoCharacterCommand(const char* args); bool HandleBanInfoCharacterCommand(char* args);
bool HandleBanInfoIPCommand(const char* args); bool HandleBanInfoIPCommand(char* args);
bool HandleBanListAccountCommand(const char* args); bool HandleBanListAccountCommand(char* args);
bool HandleBanListCharacterCommand(const char* args); bool HandleBanListCharacterCommand(char* args);
bool HandleBanListIPCommand(const char* args); bool HandleBanListIPCommand(char* args);
bool HandleCastCommand(const char *args); bool HandleCastCommand(char* args);
bool HandleCastBackCommand(const char *args); bool HandleCastBackCommand(char* args);
bool HandleCastDistCommand(const char *args); bool HandleCastDistCommand(char* args);
bool HandleCastSelfCommand(const char *args); bool HandleCastSelfCommand(char* args);
bool HandleCastTargetCommand(const char *args); bool HandleCastTargetCommand(char* args);
bool HandleCharacterCustomizeCommand(const char * args); bool HandleCharacterCustomizeCommand(char* args);
bool HandleCharacterDeletedDeleteCommand(const char* args); bool HandleCharacterDeletedDeleteCommand(char* args);
bool HandleCharacterDeletedListCommand(const char* args); bool HandleCharacterDeletedListCommand(char* args);
bool HandleCharacterDeletedRestoreCommand(const char* args); bool HandleCharacterDeletedRestoreCommand(char* args);
bool HandleCharacterDeletedOldCommand(const char* args); bool HandleCharacterDeletedOldCommand(char* args);
bool HandleCharacterEraseCommand(const char* args); bool HandleCharacterEraseCommand(char* args);
bool HandleCharacterLevelCommand(const char* args); bool HandleCharacterLevelCommand(char* args);
bool HandleCharacterRenameCommand(const char * args); bool HandleCharacterRenameCommand(char* args);
bool HandleCharacterReputationCommand(const char* args); bool HandleCharacterReputationCommand(char* args);
bool HandleCharacterTitlesCommand(const char* args); bool HandleCharacterTitlesCommand(char* args);
bool HandleDebugAnimCommand(const char* args); bool HandleDebugAnimCommand(char* args);
bool HandleDebugArenaCommand(const char * args); bool HandleDebugArenaCommand(char* args);
bool HandleDebugBattlegroundCommand(const char * args); bool HandleDebugBattlegroundCommand(char* args);
bool HandleDebugGetItemStateCommand(const char * args); bool HandleDebugGetItemStateCommand(char* args);
bool HandleDebugGetLootRecipientCommand(const char * args); bool HandleDebugGetLootRecipientCommand(char* args);
bool HandleDebugGetValueCommand(const char* args); bool HandleDebugGetValueCommand(char* args);
bool HandleDebugGetItemValueCommand(const char* args); bool HandleDebugGetItemValueCommand(char* args);
bool HandleDebugMod32ValueCommand(const char* args); bool HandleDebugMod32ValueCommand(char* args);
bool HandleDebugSetAuraStateCommand(const char * args); bool HandleDebugSetAuraStateCommand(char* args);
bool HandleDebugSetItemValueCommand(const char * args); bool HandleDebugSetItemValueCommand(char* args);
bool HandleDebugSetValueCommand(const char* args); bool HandleDebugSetValueCommand(char* args);
bool HandleDebugSpawnVehicle(const char * args); bool HandleDebugSpawnVehicleCommand(char* args);
bool HandleDebugSpellCheckCommand(const char* args); bool HandleDebugSpellCheckCommand(char* args);
bool HandleDebugUpdateCommand(const char* args); bool HandleDebugUpdateCommand(char* args);
bool HandleDebugUpdateWorldStateCommand(const char* args); bool HandleDebugUpdateWorldStateCommand(char* args);
bool HandleDebugPlayCinematicCommand(const char* args); bool HandleDebugPlayCinematicCommand(char* args);
bool HandleDebugPlayMovieCommand(const char* args); bool HandleDebugPlayMovieCommand(char* args);
bool HandleDebugPlaySoundCommand(const char* args); bool HandleDebugPlaySoundCommand(char* args);
bool HandleDebugSendBuyErrorCommand(const char* args); bool HandleDebugSendBuyErrorCommand(char* args);
bool HandleDebugSendChannelNotifyCommand(const char* args); bool HandleDebugSendChannelNotifyCommand(char* args);
bool HandleDebugSendChatMsgCommand(const char* args); bool HandleDebugSendChatMsgCommand(char* args);
bool HandleDebugSendEquipErrorCommand(const char* args); bool HandleDebugSendEquipErrorCommand(char* args);
bool HandleDebugSendLargePacketCommand(const char * args); bool HandleDebugSendLargePacketCommand(char* args);
bool HandleDebugSendOpcodeCommand(const char* args); bool HandleDebugSendOpcodeCommand(char* args);
bool HandleDebugSendPoiCommand(const char* args); bool HandleDebugSendPoiCommand(char* args);
bool HandleDebugSendQuestPartyMsgCommand(const char* args); bool HandleDebugSendQuestPartyMsgCommand(char* args);
bool HandleDebugSendQuestInvalidMsgCommand(const char* args); bool HandleDebugSendQuestInvalidMsgCommand(char* args);
bool HandleDebugSendSellErrorCommand(const char* args); bool HandleDebugSendSellErrorCommand(char* args);
bool HandleDebugSendSetPhaseShiftCommand(const char * args); bool HandleDebugSendSetPhaseShiftCommand(char* args);
bool HandleDebugSendSpellFailCommand(const char* args); bool HandleDebugSendSpellFailCommand(char* args);
bool HandleEventListCommand(const char* args); bool HandleEventListCommand(char* args);
bool HandleEventStartCommand(const char* args); bool HandleEventStartCommand(char* args);
bool HandleEventStopCommand(const char* args); bool HandleEventStopCommand(char* args);
bool HandleEventInfoCommand(const char* args); bool HandleEventInfoCommand(char* args);
bool HandleGameObjectAddCommand(const char* args); bool HandleGameObjectAddCommand(char* args);
bool HandleGameObjectDeleteCommand(const char* args); bool HandleGameObjectDeleteCommand(char* args);
bool HandleGameObjectMoveCommand(const char* args); bool HandleGameObjectMoveCommand(char* args);
bool HandleGameObjectNearCommand(const char* args); bool HandleGameObjectNearCommand(char* args);
bool HandleGameObjectPhaseCommand(const char* args); bool HandleGameObjectPhaseCommand(char* args);
bool HandleGameObjectTargetCommand(const char* args); bool HandleGameObjectTargetCommand(char* args);
bool HandleGameObjectTurnCommand(const char* args); bool HandleGameObjectTurnCommand(char* args);
bool HandleGMCommand(const char* args); bool HandleGMCommand(char* args);
bool HandleGMChatCommand(const char* args); bool HandleGMChatCommand(char* args);
bool HandleGMFlyCommand(const char* args); bool HandleGMFlyCommand(char* args);
bool HandleGMListFullCommand(const char* args); bool HandleGMListFullCommand(char* args);
bool HandleGMListIngameCommand(const char* args); bool HandleGMListIngameCommand(char* args);
bool HandleGMVisibleCommand(const char* args); bool HandleGMVisibleCommand(char* args);
bool HandleGoCommand(const char* args); bool HandleGoCommand(char* args);
bool HandleGoCreatureCommand(const char* args); bool HandleGoCreatureCommand(char* args);
bool HandleGoGraveyardCommand(const char* args); bool HandleGoGraveyardCommand(char* args);
bool HandleGoGridCommand(const char* args); bool HandleGoGridCommand(char* args);
bool HandleGoObjectCommand(const char* args); bool HandleGoObjectCommand(char* args);
bool HandleGoTaxinodeCommand(const char* args); bool HandleGoTaxinodeCommand(char* args);
bool HandleGoTriggerCommand(const char* args); bool HandleGoTriggerCommand(char* args);
bool HandleGoXYCommand(const char* args); bool HandleGoXYCommand(char* args);
bool HandleGoXYZCommand(const char* args); bool HandleGoXYZCommand(char* args);
bool HandleGoZoneXYCommand(const char* args); bool HandleGoZoneXYCommand(char* args);
bool HandleGuildCreateCommand(const char* args); bool HandleGuildCreateCommand(char* args);
bool HandleGuildInviteCommand(const char* args); bool HandleGuildInviteCommand(char* args);
bool HandleGuildUninviteCommand(const char* args); bool HandleGuildUninviteCommand(char* args);
bool HandleGuildRankCommand(const char* args); bool HandleGuildRankCommand(char* args);
bool HandleGuildDeleteCommand(const char* args); bool HandleGuildDeleteCommand(char* args);
bool HandleHonorAddCommand(const char* args); bool HandleHonorAddCommand(char* args);
bool HandleHonorAddKillCommand(const char* args); bool HandleHonorAddKillCommand(char* args);
bool HandleHonorUpdateCommand(const char* args); bool HandleHonorUpdateCommand(char* args);
bool HandleInstanceListBindsCommand(const char* args); bool HandleInstanceListBindsCommand(char* args);
bool HandleInstanceUnbindCommand(const char* args); bool HandleInstanceUnbindCommand(char* args);
bool HandleInstanceStatsCommand(const char* args); bool HandleInstanceStatsCommand(char* args);
bool HandleInstanceSaveDataCommand(const char * args); bool HandleInstanceSaveDataCommand(char* args);
bool HandleLearnCommand(const char* args); bool HandleLearnCommand(char* args);
bool HandleLearnAllCommand(const char* args); bool HandleLearnAllCommand(char* args);
bool HandleLearnAllGMCommand(const char* args); bool HandleLearnAllGMCommand(char* args);
bool HandleLearnAllCraftsCommand(const char* args); bool HandleLearnAllCraftsCommand(char* args);
bool HandleLearnAllRecipesCommand(const char* args); bool HandleLearnAllRecipesCommand(char* args);
bool HandleLearnAllDefaultCommand(const char* args); bool HandleLearnAllDefaultCommand(char* args);
bool HandleLearnAllLangCommand(const char* args); bool HandleLearnAllLangCommand(char* args);
bool HandleLearnAllMyClassCommand(const char* args); bool HandleLearnAllMyClassCommand(char* args);
bool HandleLearnAllMyPetTalentsCommand(const char* args); bool HandleLearnAllMyPetTalentsCommand(char* args);
bool HandleLearnAllMySpellsCommand(const char* args); bool HandleLearnAllMySpellsCommand(char* args);
bool HandleLearnAllMyTalentsCommand(const char* args); bool HandleLearnAllMyTalentsCommand(char* args);
bool HandleListAurasCommand(const char * args); bool HandleListAurasCommand(char* args);
bool HandleListCreatureCommand(const char* args); bool HandleListCreatureCommand(char* args);
bool HandleListItemCommand(const char* args); bool HandleListItemCommand(char* args);
bool HandleListObjectCommand(const char* args); bool HandleListObjectCommand(char* args);
bool HandleListTalentsCommand(const char * args); bool HandleListTalentsCommand(char* args);
bool HandleLookupAccountEmailCommand(const char* args); bool HandleLookupAccountEmailCommand(char* args);
bool HandleLookupAccountIpCommand(const char* args); bool HandleLookupAccountIpCommand(char* args);
bool HandleLookupAccountNameCommand(const char* args); bool HandleLookupAccountNameCommand(char* args);
bool HandleLookupAreaCommand(const char* args); bool HandleLookupAreaCommand(char* args);
bool HandleLookupCreatureCommand(const char* args); bool HandleLookupCreatureCommand(char* args);
bool HandleLookupEventCommand(const char* args); bool HandleLookupEventCommand(char* args);
bool HandleLookupFactionCommand(const char * args); bool HandleLookupFactionCommand(char* args);
bool HandleLookupItemCommand(const char * args); bool HandleLookupItemCommand(char* args);
bool HandleLookupItemSetCommand(const char * args); bool HandleLookupItemSetCommand(char* args);
bool HandleLookupObjectCommand(const char* args); bool HandleLookupObjectCommand(char* args);
bool HandleLookupPlayerIpCommand(const char* args); bool HandleLookupPlayerIpCommand(char* args);
bool HandleLookupPlayerAccountCommand(const char* args); bool HandleLookupPlayerAccountCommand(char* args);
bool HandleLookupPlayerEmailCommand(const char* args); bool HandleLookupPlayerEmailCommand(char* args);
bool HandleLookupQuestCommand(const char* args); bool HandleLookupQuestCommand(char* args);
bool HandleLookupSkillCommand(const char* args); bool HandleLookupSkillCommand(char* args);
bool HandleLookupSpellCommand(const char* args); bool HandleLookupSpellCommand(char* args);
bool HandleLookupTaxiNodeCommand(const char * args); bool HandleLookupTaxiNodeCommand(char* args);
bool HandleLookupTeleCommand(const char * args); bool HandleLookupTeleCommand(char* args);
bool HandleLookupTitleCommand(const char * args); bool HandleLookupTitleCommand(char* args);
bool HandleModifyHPCommand(const char* args); bool HandleModifyHPCommand(char* args);
bool HandleModifyManaCommand(const char* args); bool HandleModifyManaCommand(char* args);
bool HandleModifyRageCommand(const char* args); bool HandleModifyRageCommand(char* args);
bool HandleModifyRunicPowerCommand(const char* args); bool HandleModifyRunicPowerCommand(char* args);
bool HandleModifyEnergyCommand(const char* args); bool HandleModifyEnergyCommand(char* args);
bool HandleModifyMoneyCommand(const char* args); bool HandleModifyMoneyCommand(char* args);
bool HandleModifyASpeedCommand(const char* args); bool HandleModifyASpeedCommand(char* args);
bool HandleModifySpeedCommand(const char* args); bool HandleModifySpeedCommand(char* args);
bool HandleModifyBWalkCommand(const char* args); bool HandleModifyBWalkCommand(char* args);
bool HandleModifyFlyCommand(const char* args); bool HandleModifyFlyCommand(char* args);
bool HandleModifySwimCommand(const char* args); bool HandleModifySwimCommand(char* args);
bool HandleModifyScaleCommand(const char* args); bool HandleModifyScaleCommand(char* args);
bool HandleModifyMountCommand(const char* args); bool HandleModifyMountCommand(char* args);
bool HandleModifyBitCommand(const char* args); bool HandleModifyBitCommand(char* args);
bool HandleModifyFactionCommand(const char* args); bool HandleModifyFactionCommand(char* args);
bool HandleModifySpellCommand(const char* args); bool HandleModifySpellCommand(char* args);
bool HandleModifyTalentCommand (const char* args); bool HandleModifyTalentCommand(char* args);
bool HandleModifyHonorCommand (const char* args); bool HandleModifyHonorCommand(char* args);
bool HandleModifyRepCommand(const char* args); bool HandleModifyRepCommand(char* args);
bool HandleModifyArenaCommand(const char* args); bool HandleModifyArenaCommand(char* args);
bool HandleModifyPhaseCommand(const char* args); bool HandleModifyPhaseCommand(char* args);
bool HandleModifyGenderCommand(const char* args); bool HandleModifyGenderCommand(char* args);
//-----------------------Npc Commands----------------------- //-----------------------Npc Commands-----------------------
bool HandleNpcAddCommand(const char* args); bool HandleNpcAddCommand(char* args);
bool HandleNpcAddMoveCommand(const char* args); bool HandleNpcAddMoveCommand(char* args);
bool HandleNpcAddVendorItemCommand(const char* args); bool HandleNpcAddVendorItemCommand(char* args);
bool HandleNpcAllowMovementCommand(const char* args); bool HandleNpcAllowMovementCommand(char* args);
bool HandleNpcChangeEntryCommand(const char *args); bool HandleNpcChangeEntryCommand(char* args);
bool HandleNpcChangeLevelCommand(const char* args); bool HandleNpcChangeLevelCommand(char* args);
bool HandleNpcDeleteCommand(const char* args); bool HandleNpcDeleteCommand(char* args);
bool HandleNpcDelVendorItemCommand(const char* args); bool HandleNpcDelVendorItemCommand(char* args);
bool HandleNpcFactionIdCommand(const char* args); bool HandleNpcFactionIdCommand(char* args);
bool HandleNpcFlagCommand(const char* args); bool HandleNpcFlagCommand(char* args);
bool HandleNpcFollowCommand(const char* args); bool HandleNpcFollowCommand(char* args);
bool HandleNpcInfoCommand(const char* args); bool HandleNpcInfoCommand(char* args);
bool HandleNpcMoveCommand(const char* args); bool HandleNpcMoveCommand(char* args);
bool HandleNpcPlayEmoteCommand(const char* args); bool HandleNpcPlayEmoteCommand(char* args);
bool HandleNpcSayCommand(const char* args); bool HandleNpcSayCommand(char* args);
bool HandleNpcSetDeathStateCommand(const char* args); bool HandleNpcSetDeathStateCommand(char* args);
bool HandleNpcSetModelCommand(const char* args); bool HandleNpcSetModelCommand(char* args);
bool HandleNpcSetMoveTypeCommand(const char* args); bool HandleNpcSetMoveTypeCommand(char* args);
bool HandleNpcSetPhaseCommand(const char* args); bool HandleNpcSetPhaseCommand(char* args);
bool HandleNpcSpawnDistCommand(const char* args); bool HandleNpcSpawnDistCommand(char* args);
bool HandleNpcSpawnTimeCommand(const char* args); bool HandleNpcSpawnTimeCommand(char* args);
bool HandleNpcTameCommand(const char* args); bool HandleNpcTameCommand(char* args);
bool HandleNpcTextEmoteCommand(const char* args); bool HandleNpcTextEmoteCommand(char* args);
bool HandleNpcUnFollowCommand(const char* args); bool HandleNpcUnFollowCommand(char* args);
bool HandleNpcWhisperCommand(const char* args); bool HandleNpcWhisperCommand(char* args);
bool HandleNpcYellCommand(const char* args); bool HandleNpcYellCommand(char* args);
//TODO: NpcCommands that needs to be fixed : //TODO: NpcCommands that needs to be fixed :
bool HandleNpcAddWeaponCommand(const char* args); bool HandleNpcAddWeaponCommand(char* args);
bool HandleNpcNameCommand(const char* args); bool HandleNpcNameCommand(char* args);
bool HandleNpcSubNameCommand(const char* args); bool HandleNpcSubNameCommand(char* args);
//---------------------------------------------------------- //----------------------------------------------------------
bool HandlePDumpLoadCommand(const char *args); bool HandlePDumpLoadCommand(char* args);
bool HandlePDumpWriteCommand(const char *args); bool HandlePDumpWriteCommand(char* args);
bool HandleQuestAdd(const char * args); bool HandleQuestAddCommand(char* args);
bool HandleQuestRemove(const char * args); bool HandleQuestRemoveCommand(char* args);
bool HandleQuestComplete(const char * args); bool HandleQuestCompleteCommand(char* args);
bool HandleReloadAllCommand(const char* args); bool HandleReloadAllCommand(char* args);
bool HandleReloadAllAchievementCommand(const char* args); bool HandleReloadAllAchievementCommand(char* args);
bool HandleReloadAllAreaCommand(const char* args); bool HandleReloadAllAreaCommand(char* args);
bool HandleReloadAllGossipsCommand(const char* args); bool HandleReloadAllGossipsCommand(char* args);
bool HandleReloadAllItemCommand(const char* args); bool HandleReloadAllItemCommand(char* args);
bool HandleReloadAllLootCommand(const char* args); bool HandleReloadAllLootCommand(char* args);
bool HandleReloadAllNpcCommand(const char* args); bool HandleReloadAllNpcCommand(char* args);
bool HandleReloadAllQuestCommand(const char* args); bool HandleReloadAllQuestCommand(char* args);
bool HandleReloadAllScriptsCommand(const char* args); bool HandleReloadAllScriptsCommand(char* args);
bool HandleReloadAllEventAICommand(const char* args); bool HandleReloadAllEventAICommand(char* args);
bool HandleReloadAllSpellCommand(const char* args); bool HandleReloadAllSpellCommand(char* args);
bool HandleReloadAllLocalesCommand(const char* args); bool HandleReloadAllLocalesCommand(char* args);
bool HandleReloadConfigCommand(const char* args); bool HandleReloadConfigCommand(char* args);
bool HandleReloadAchievementCriteriaRequirementCommand(const char* args); bool HandleReloadAchievementCriteriaRequirementCommand(char* args);
bool HandleReloadAchievementRewardCommand(const char* args); bool HandleReloadAchievementRewardCommand(char* args);
bool HandleReloadAreaTriggerTavernCommand(const char* args); bool HandleReloadAreaTriggerTavernCommand(char* args);
bool HandleReloadAreaTriggerTeleportCommand(const char* args); bool HandleReloadAreaTriggerTeleportCommand(char* args);
bool HandleReloadEventScriptsCommand(const char* args); bool HandleReloadEventScriptsCommand(char* args);
bool HandleReloadEventAITextsCommand(const char* args); bool HandleReloadEventAITextsCommand(char* args);
bool HandleReloadEventAISummonsCommand(const char* args); bool HandleReloadEventAISummonsCommand(char* args);
bool HandleReloadEventAIScriptsCommand(const char* args); bool HandleReloadEventAIScriptsCommand(char* args);
bool HandleReloadCommandCommand(const char* args); bool HandleReloadCommandCommand(char* args);
bool HandleReloadBattleEventCommand(const char* args); bool HandleReloadBattleEventCommand(char* args);
bool HandleReloadCreatureQuestRelationsCommand(const char* args); bool HandleReloadCreatureQuestRelationsCommand(char* args);
bool HandleReloadCreatureQuestInvRelationsCommand(const char* args); bool HandleReloadCreatureQuestInvRelationsCommand(char* args);
bool HandleReloadDbScriptStringCommand(const char* args); bool HandleReloadDbScriptStringCommand(char* args);
bool HandleReloadGameGraveyardZoneCommand(const char* args); bool HandleReloadGameGraveyardZoneCommand(char* args);
bool HandleReloadGameObjectScriptsCommand(const char* args); bool HandleReloadGameObjectScriptsCommand(char* args);
bool HandleReloadGameTeleCommand(const char* args); bool HandleReloadGameTeleCommand(char* args);
bool HandleReloadGossipMenuCommand(const char* args); bool HandleReloadGossipMenuCommand(char* args);
bool HandleReloadGossipMenuOptionCommand(const char* args); bool HandleReloadGossipMenuOptionCommand(char* args);
bool HandleReloadGossipScriptsCommand(const char* args); bool HandleReloadGossipScriptsCommand(char* args);
bool HandleReloadGOQuestRelationsCommand(const char* args); bool HandleReloadGOQuestRelationsCommand(char* args);
bool HandleReloadGOQuestInvRelationsCommand(const char* args); bool HandleReloadGOQuestInvRelationsCommand(char* args);
bool HandleReloadItemEnchantementsCommand(const char* args); bool HandleReloadItemEnchantementsCommand(char* args);
bool HandleReloadItemRequiredTragetCommand(const char* args); bool HandleReloadItemRequiredTragetCommand(char* args);
bool HandleReloadLocalesAchievementRewardCommand(const char* args); bool HandleReloadLocalesAchievementRewardCommand(char* args);
bool HandleReloadLocalesCreatureCommand(const char* args); bool HandleReloadLocalesCreatureCommand(char* args);
bool HandleReloadLocalesGameobjectCommand(const char* args); bool HandleReloadLocalesGameobjectCommand(char* args);
bool HandleReloadLocalesGossipMenuOptionCommand(const char* args); bool HandleReloadLocalesGossipMenuOptionCommand(char* args);
bool HandleReloadLocalesItemCommand(const char* args); bool HandleReloadLocalesItemCommand(char* args);
bool HandleReloadLocalesNpcTextCommand(const char* args); bool HandleReloadLocalesNpcTextCommand(char* args);
bool HandleReloadLocalesPageTextCommand(const char* args); bool HandleReloadLocalesPageTextCommand(char* args);
bool HandleReloadLocalesPointsOfInterestCommand(const char* args); bool HandleReloadLocalesPointsOfInterestCommand(char* args);
bool HandleReloadLocalesQuestCommand(const char* args); bool HandleReloadLocalesQuestCommand(char* args);
bool HandleReloadLootTemplatesCreatureCommand(const char* args); bool HandleReloadLootTemplatesCreatureCommand(char* args);
bool HandleReloadLootTemplatesDisenchantCommand(const char* args); bool HandleReloadLootTemplatesDisenchantCommand(char* args);
bool HandleReloadLootTemplatesFishingCommand(const char* args); bool HandleReloadLootTemplatesFishingCommand(char* args);
bool HandleReloadLootTemplatesGameobjectCommand(const char* args); bool HandleReloadLootTemplatesGameobjectCommand(char* args);
bool HandleReloadLootTemplatesItemCommand(const char* args); bool HandleReloadLootTemplatesItemCommand(char* args);
bool HandleReloadLootTemplatesMailCommand(const char* args); bool HandleReloadLootTemplatesMailCommand(char* args);
bool HandleReloadLootTemplatesMillingCommand(const char* args); bool HandleReloadLootTemplatesMillingCommand(char* args);
bool HandleReloadLootTemplatesPickpocketingCommand(const char* args); bool HandleReloadLootTemplatesPickpocketingCommand(char* args);
bool HandleReloadLootTemplatesProspectingCommand(const char* args); bool HandleReloadLootTemplatesProspectingCommand(char* args);
bool HandleReloadLootTemplatesReferenceCommand(const char* args); bool HandleReloadLootTemplatesReferenceCommand(char* args);
bool HandleReloadLootTemplatesSkinningCommand(const char* args); bool HandleReloadLootTemplatesSkinningCommand(char* args);
bool HandleReloadLootTemplatesSpellCommand(const char* args); bool HandleReloadLootTemplatesSpellCommand(char* args);
bool HandleReloadMailLevelRewardCommand(const char* args); bool HandleReloadMailLevelRewardCommand(char* args);
bool HandleReloadMangosStringCommand(const char* args); bool HandleReloadMangosStringCommand(char* args);
bool HandleReloadNpcGossipCommand(const char* args); bool HandleReloadNpcGossipCommand(char* args);
bool HandleReloadNpcTrainerCommand(const char* args); bool HandleReloadNpcTrainerCommand(char* args);
bool HandleReloadNpcVendorCommand(const char* args); bool HandleReloadNpcVendorCommand(char* args);
bool HandleReloadPageTextsCommand(const char* args); bool HandleReloadPageTextsCommand(char* args);
bool HandleReloadPointsOfInterestCommand(const char* args); bool HandleReloadPointsOfInterestCommand(char* args);
bool HandleReloadSpellClickSpellsCommand(const char* args); bool HandleReloadSpellClickSpellsCommand(char* args);
bool HandleReloadQuestAreaTriggersCommand(const char* args); bool HandleReloadQuestAreaTriggersCommand(char* args);
bool HandleReloadQuestEndScriptsCommand(const char* args); bool HandleReloadQuestEndScriptsCommand(char* args);
bool HandleReloadQuestPOICommand(const char* args); bool HandleReloadQuestPOICommand(char* args);
bool HandleReloadQuestStartScriptsCommand(const char* args); bool HandleReloadQuestStartScriptsCommand(char* args);
bool HandleReloadQuestTemplateCommand(const char* args); bool HandleReloadQuestTemplateCommand(char* args);
bool HandleReloadReservedNameCommand(const char*); bool HandleReloadReservedNameCommand(char* args);
bool HandleReloadReputationRewardRateCommand(const char* args); bool HandleReloadReputationRewardRateCommand(char* args);
bool HandleReloadReputationSpilloverTemplateCommand(const char* args); bool HandleReloadReputationSpilloverTemplateCommand(char* args);
bool HandleReloadSkillDiscoveryTemplateCommand(const char* args); bool HandleReloadSkillDiscoveryTemplateCommand(char* args);
bool HandleReloadSkillExtraItemTemplateCommand(const char* args); bool HandleReloadSkillExtraItemTemplateCommand(char* args);
bool HandleReloadSkillFishingBaseLevelCommand(const char* args); bool HandleReloadSkillFishingBaseLevelCommand(char* args);
bool HandleReloadSpellAreaCommand(const char* args); bool HandleReloadSpellAreaCommand(char* args);
bool HandleReloadSpellChainCommand(const char* args); bool HandleReloadSpellChainCommand(char* args);
bool HandleReloadSpellElixirCommand(const char* args); bool HandleReloadSpellElixirCommand(char* args);
bool HandleReloadSpellLearnSpellCommand(const char* args); bool HandleReloadSpellLearnSpellCommand(char* args);
bool HandleReloadSpellProcEventCommand(const char* args); bool HandleReloadSpellProcEventCommand(char* args);
bool HandleReloadSpellProcItemEnchantCommand(const char* args); bool HandleReloadSpellProcItemEnchantCommand(char* args);
bool HandleReloadSpellBonusesCommand(const char* args); bool HandleReloadSpellBonusesCommand(char* args);
bool HandleReloadSpellScriptTargetCommand(const char* args); bool HandleReloadSpellScriptTargetCommand(char* args);
bool HandleReloadSpellScriptsCommand(const char* args); bool HandleReloadSpellScriptsCommand(char* args);
bool HandleReloadSpellTargetPositionCommand(const char* args); bool HandleReloadSpellTargetPositionCommand(char* args);
bool HandleReloadSpellThreatsCommand(const char* args); bool HandleReloadSpellThreatsCommand(char* args);
bool HandleReloadSpellPetAurasCommand(const char* args); bool HandleReloadSpellPetAurasCommand(char* args);
bool HandleResetAchievementsCommand(const char * args); bool HandleResetAchievementsCommand(char* args);
bool HandleResetAllCommand(const char * args); bool HandleResetAllCommand(char* args);
bool HandleResetHonorCommand(const char * args); bool HandleResetHonorCommand(char* args);
bool HandleResetLevelCommand(const char * args); bool HandleResetLevelCommand(char* args);
bool HandleResetSpecsCommand(const char * args); bool HandleResetSpecsCommand(char* args);
bool HandleResetSpellsCommand(const char * args); bool HandleResetSpellsCommand(char* args);
bool HandleResetStatsCommand(const char * args); bool HandleResetStatsCommand(char* args);
bool HandleResetTalentsCommand(const char * args); bool HandleResetTalentsCommand(char* args);
bool HandleSendItemsCommand(const char* args); bool HandleSendItemsCommand(char* args);
bool HandleSendMailCommand(const char* args); bool HandleSendMailCommand(char* args);
bool HandleSendMessageCommand(const char * args); bool HandleSendMessageCommand(char* args);
bool HandleSendMoneyCommand(const char* args); bool HandleSendMoneyCommand(char* args);
bool HandleServerCorpsesCommand(const char* args); bool HandleServerCorpsesCommand(char* args);
bool HandleServerExitCommand(const char* args); bool HandleServerExitCommand(char* args);
bool HandleServerIdleRestartCommand(const char* args); bool HandleServerIdleRestartCommand(char* args);
bool HandleServerIdleShutDownCommand(const char* args); bool HandleServerIdleShutDownCommand(char* args);
bool HandleServerInfoCommand(const char* args); bool HandleServerInfoCommand(char* args);
bool HandleServerLogFilterCommand(const char* args); bool HandleServerLogFilterCommand(char* args);
bool HandleServerLogLevelCommand(const char* args); bool HandleServerLogLevelCommand(char* args);
bool HandleServerMotdCommand(const char* args); bool HandleServerMotdCommand(char* args);
bool HandleServerPLimitCommand(const char* args); bool HandleServerPLimitCommand(char* args);
bool HandleServerRestartCommand(const char* args); bool HandleServerRestartCommand(char* args);
bool HandleServerSetMotdCommand(const char* args); bool HandleServerSetMotdCommand(char* args);
bool HandleServerShutDownCommand(const char* args); bool HandleServerShutDownCommand(char* args);
bool HandleServerShutDownCancelCommand(const char* args); bool HandleServerShutDownCancelCommand(char* args);
bool HandleTeleCommand(const char * args); bool HandleTeleCommand(char* args);
bool HandleTeleAddCommand(const char * args); bool HandleTeleAddCommand(char* args);
bool HandleTeleDelCommand(const char * args); bool HandleTeleDelCommand(char* args);
bool HandleTeleGroupCommand(const char* args); bool HandleTeleGroupCommand(char* args);
bool HandleTeleNameCommand(const char* args); bool HandleTeleNameCommand(char* args);
bool HandleTitlesAddCommand(const char* args); bool HandleTitlesAddCommand(char* args);
bool HandleTitlesCurrentCommand(const char* args); bool HandleTitlesCurrentCommand(char* args);
bool HandleTitlesRemoveCommand(const char* args); bool HandleTitlesRemoveCommand(char* args);
bool HandleTitlesSetMaskCommand(const char* args); bool HandleTitlesSetMaskCommand(char* args);
bool HandleTriggerActiveCommand(const char* args); bool HandleTriggerActiveCommand(char* args);
bool HandleTriggerNearCommand(const char* args); bool HandleTriggerNearCommand(char* args);
bool HandleTriggerCommand(const char* args); bool HandleTriggerCommand(char* args);
bool HandleUnBanAccountCommand(const char* args); bool HandleUnBanAccountCommand(char* args);
bool HandleUnBanCharacterCommand(const char* args); bool HandleUnBanCharacterCommand(char* args);
bool HandleUnBanIPCommand(const char* args); bool HandleUnBanIPCommand(char* args);
bool HandleWpAddCommand(const char* args); bool HandleWpAddCommand(char* args);
bool HandleWpModifyCommand(const char* args); bool HandleWpModifyCommand(char* args);
bool HandleWpShowCommand(const char* args); bool HandleWpShowCommand(char* args);
bool HandleWpExportCommand(const char* args); bool HandleWpExportCommand(char* args);
bool HandleWpImportCommand(const char* args); bool HandleWpImportCommand(char* args);
bool HandleHelpCommand(const char* args); bool HandleHelpCommand(char* args);
bool HandleCommandsCommand(const char* args); bool HandleCommandsCommand(char* args);
bool HandleStartCommand(const char* args); bool HandleStartCommand(char* args);
bool HandleDismountCommand(const char* args); bool HandleDismountCommand(char* args);
bool HandleSaveCommand(const char* args); bool HandleSaveCommand(char* args);
bool HandleNamegoCommand(const char* args); bool HandleNamegoCommand(char* args);
bool HandleGonameCommand(const char* args); bool HandleGonameCommand(char* args);
bool HandleGroupgoCommand(const char* args); bool HandleGroupgoCommand(char* args);
bool HandleRecallCommand(const char* args); bool HandleRecallCommand(char* args);
bool HandleAnnounceCommand(const char* args); bool HandleAnnounceCommand(char* args);
bool HandleNotifyCommand(const char* args); bool HandleNotifyCommand(char* args);
bool HandleGPSCommand(const char* args); bool HandleGPSCommand(char* args);
bool HandleTaxiCheatCommand(const char* args); bool HandleTaxiCheatCommand(char* args);
bool HandleWhispersCommand(const char* args); bool HandleWhispersCommand(char* args);
bool HandleModifyDrunkCommand(const char* args); bool HandleModifyDrunkCommand(char* args);
bool HandleLoadScriptsCommand(const char* args); bool HandleLoadScriptsCommand(char* args);
bool HandleGUIDCommand(const char* args); bool HandleGUIDCommand(char* args);
bool HandleItemMoveCommand(const char* args); bool HandleItemMoveCommand(char* args);
bool HandleDeMorphCommand(const char* args); bool HandleDeMorphCommand(char* args);
bool HandlePInfoCommand(const char* args); bool HandlePInfoCommand(char* args);
bool HandleMuteCommand(const char* args); bool HandleMuteCommand(char* args);
bool HandleUnmuteCommand(const char* args); bool HandleUnmuteCommand(char* args);
bool HandleMovegensCommand(const char* args); bool HandleMovegensCommand(char* args);
bool HandleCooldownCommand(const char* args); bool HandleCooldownCommand(char* args);
bool HandleUnLearnCommand(const char* args); bool HandleUnLearnCommand(char* args);
bool HandleGetDistanceCommand(const char* args); bool HandleGetDistanceCommand(char* args);
bool HandleModifyStandStateCommand(const char* args); bool HandleModifyStandStateCommand(char* args);
bool HandleDieCommand(const char* args); bool HandleDieCommand(char* args);
bool HandleDamageCommand(const char *args); bool HandleDamageCommand(char* args);
bool HandleReviveCommand(const char* args); bool HandleReviveCommand(char* args);
bool HandleModifyMorphCommand(const char* args); bool HandleModifyMorphCommand(char* args);
bool HandleAuraCommand(const char* args); bool HandleAuraCommand(char* args);
bool HandleUnAuraCommand(const char* args); bool HandleUnAuraCommand(char* args);
bool HandleLinkGraveCommand(const char* args); bool HandleLinkGraveCommand(char* args);
bool HandleNearGraveCommand(const char* args); bool HandleNearGraveCommand(char* args);
bool HandleExploreCheatCommand(const char* args); bool HandleExploreCheatCommand(char* args);
bool HandleHoverCommand(const char* args); bool HandleHoverCommand(char* args);
bool HandleLevelUpCommand(const char* args); bool HandleLevelUpCommand(char* args);
bool HandleShowAreaCommand(const char* args); bool HandleShowAreaCommand(char* args);
bool HandleHideAreaCommand(const char* args); bool HandleHideAreaCommand(char* args);
bool HandleAddItemCommand(const char* args); bool HandleAddItemCommand(char* args);
bool HandleAddItemSetCommand(const char* args); bool HandleAddItemSetCommand(char* args);
bool HandleBankCommand(const char* args); bool HandleBankCommand(char* args);
bool HandleChangeWeather(const char* args); bool HandleChangeWeatherCommand(char* args);
bool HandleKickPlayerCommand(const char * args); bool HandleKickPlayerCommand(char* args);
bool HandleTicketCommand(const char* args); bool HandleTicketCommand(char* args);
bool HandleDelTicketCommand(const char* args); bool HandleDelTicketCommand(char* args);
bool HandleMaxSkillCommand(const char* args); bool HandleMaxSkillCommand(char* args);
bool HandleSetSkillCommand(const char* args); bool HandleSetSkillCommand(char* args);
bool HandleRespawnCommand(const char* args); bool HandleRespawnCommand(char* args);
bool HandleComeToMeCommand(const char *args); bool HandleComeToMeCommand(char* args);
bool HandleCombatStopCommand(const char *args); bool HandleCombatStopCommand(char* args);
bool HandleFlushArenaPointsCommand(const char *args); bool HandleFlushArenaPointsCommand(char* args);
bool HandleRepairitemsCommand(const char* args); bool HandleRepairitemsCommand(char* args);
bool HandleStableCommand(const char* args); bool HandleStableCommand(char* args);
bool HandleWaterwalkCommand(const char* args); bool HandleWaterwalkCommand(char* args);
bool HandleQuitCommand(const char* args); bool HandleQuitCommand(char* args);
//! Development Commands //! Development Commands
bool HandleSaveAllCommand(const char* args); bool HandleSaveAllCommand(char* args);
Player* getSelectedPlayer(); Player* getSelectedPlayer();
Creature* getSelectedCreature(); Creature* getSelectedCreature();
@ -585,9 +585,9 @@ class ChatHandler
void ShowTriggerTargetListHelper(uint32 id, AreaTrigger const* at, bool subpart = false); void ShowTriggerTargetListHelper(uint32 id, AreaTrigger const* at, bool subpart = false);
bool LookupPlayerSearchCommand(QueryResult* result, uint32* limit = NULL); bool LookupPlayerSearchCommand(QueryResult* result, uint32* limit = NULL);
bool HandleBanListHelper(QueryResult* result); bool HandleBanListHelper(QueryResult* result);
bool HandleBanHelper(BanMode mode,char const* args); bool HandleBanHelper(BanMode mode, char* args);
bool HandleBanInfoHelper(uint32 accountid, char const* accountname); bool HandleBanInfoHelper(uint32 accountid, char const* accountname);
bool HandleUnBanHelper(BanMode mode,char const* args); bool HandleUnBanHelper(BanMode mode, char* args);
void HandleCharacterLevel(Player* player, uint64 player_guid, uint32 oldlevel, uint32 newlevel); void HandleCharacterLevel(Player* player, uint64 player_guid, uint32 oldlevel, uint32 newlevel);
void HandleLearnSkillRecipesHelper(Player* player,uint32 skill_id); void HandleLearnSkillRecipesHelper(Player* player,uint32 skill_id);
bool HandleGoHelper(Player* _player, uint32 mapid, float x, float y, float const* zPtr = NULL, float const* ortPtr = NULL); bool HandleGoHelper(Player* _player, uint32 mapid, float x, float y, float const* zPtr = NULL, float const* ortPtr = NULL);

26
src/game/Level0.cpp
View file

@ -30,7 +30,7 @@
#include "revision_nr.h" #include "revision_nr.h"
#include "Util.h" #include "Util.h"
bool ChatHandler::HandleHelpCommand(const char* args) bool ChatHandler::HandleHelpCommand(char* args)
{ {
if(!*args) if(!*args)
{ {
@ -46,13 +46,13 @@ bool ChatHandler::HandleHelpCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleCommandsCommand(const char* /*args*/) bool ChatHandler::HandleCommandsCommand(char* /*args*/)
{ {
ShowHelpForCommand(getCommandTable(), ""); ShowHelpForCommand(getCommandTable(), "");
return true; return true;
} }
bool ChatHandler::HandleAccountCommand(const char* args) bool ChatHandler::HandleAccountCommand(char* args)
{ {
// let show subcommands at unexpected data in args // let show subcommands at unexpected data in args
if (*args) if (*args)
@ -63,7 +63,7 @@ bool ChatHandler::HandleAccountCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleStartCommand(const char* /*args*/) bool ChatHandler::HandleStartCommand(char* /*args*/)
{ {
Player *chr = m_session->GetPlayer(); Player *chr = m_session->GetPlayer();
@ -86,7 +86,7 @@ bool ChatHandler::HandleStartCommand(const char* /*args*/)
return true; return true;
} }
bool ChatHandler::HandleServerInfoCommand(const char* /*args*/) bool ChatHandler::HandleServerInfoCommand(char* /*args*/)
{ {
uint32 activeClientsNum = sWorld.GetActiveSessionCount(); uint32 activeClientsNum = sWorld.GetActiveSessionCount();
uint32 queuedClientsNum = sWorld.GetQueuedSessionCount(); uint32 queuedClientsNum = sWorld.GetQueuedSessionCount();
@ -110,7 +110,7 @@ bool ChatHandler::HandleServerInfoCommand(const char* /*args*/)
return true; return true;
} }
bool ChatHandler::HandleDismountCommand(const char* /*args*/) bool ChatHandler::HandleDismountCommand(char* /*args*/)
{ {
//If player is not mounted, so go out :) //If player is not mounted, so go out :)
if (!m_session->GetPlayer( )->IsMounted()) if (!m_session->GetPlayer( )->IsMounted())
@ -132,7 +132,7 @@ bool ChatHandler::HandleDismountCommand(const char* /*args*/)
return true; return true;
} }
bool ChatHandler::HandleSaveCommand(const char* /*args*/) bool ChatHandler::HandleSaveCommand(char* /*args*/)
{ {
Player *player=m_session->GetPlayer(); Player *player=m_session->GetPlayer();
@ -152,7 +152,7 @@ bool ChatHandler::HandleSaveCommand(const char* /*args*/)
return true; return true;
} }
bool ChatHandler::HandleGMListIngameCommand(const char* /*args*/) bool ChatHandler::HandleGMListIngameCommand(char* /*args*/)
{ {
std::list< std::pair<std::string, bool> > names; std::list< std::pair<std::string, bool> > names;
@ -183,7 +183,7 @@ bool ChatHandler::HandleGMListIngameCommand(const char* /*args*/)
return true; return true;
} }
bool ChatHandler::HandleAccountPasswordCommand(const char* args) bool ChatHandler::HandleAccountPasswordCommand(char* args)
{ {
// allow use from RA, but not from console (not have associated account id) // allow use from RA, but not from console (not have associated account id)
if (!GetAccountId()) if (!GetAccountId())
@ -196,7 +196,7 @@ bool ChatHandler::HandleAccountPasswordCommand(const char* args)
if(!*args) if(!*args)
return false; return false;
char *old_pass = strtok ((char*)args, " "); char *old_pass = strtok (args, " ");
char *new_pass = strtok (NULL, " "); char *new_pass = strtok (NULL, " ");
char *new_pass_c = strtok (NULL, " "); char *new_pass_c = strtok (NULL, " ");
@ -242,7 +242,7 @@ bool ChatHandler::HandleAccountPasswordCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleAccountLockCommand(const char* args) bool ChatHandler::HandleAccountLockCommand(char* args)
{ {
// allow use from RA, but not from console (not have associated account id) // allow use from RA, but not from console (not have associated account id)
if (!GetAccountId()) if (!GetAccountId())
@ -258,7 +258,7 @@ bool ChatHandler::HandleAccountLockCommand(const char* args)
return true; return true;
} }
std::string argstr = (char*)args; std::string argstr = args;
if (argstr == "on") if (argstr == "on")
{ {
LoginDatabase.PExecute( "UPDATE account SET locked = '1' WHERE id = '%d'",GetAccountId()); LoginDatabase.PExecute( "UPDATE account SET locked = '1' WHERE id = '%d'",GetAccountId());
@ -278,7 +278,7 @@ bool ChatHandler::HandleAccountLockCommand(const char* args)
} }
/// Display the 'Message of the day' for the realm /// Display the 'Message of the day' for the realm
bool ChatHandler::HandleServerMotdCommand(const char* /*args*/) bool ChatHandler::HandleServerMotdCommand(char* /*args*/)
{ {
PSendSysMessage(LANG_MOTD_CURRENT, sWorld.GetMotd()); PSendSysMessage(LANG_MOTD_CURRENT, sWorld.GetMotd());
return true; return true;

235
src/game/Level1.cpp
View file

@ -38,7 +38,7 @@
#endif #endif
//-----------------------Npc Commands----------------------- //-----------------------Npc Commands-----------------------
bool ChatHandler::HandleNpcSayCommand(const char* args) bool ChatHandler::HandleNpcSayCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
@ -56,7 +56,7 @@ bool ChatHandler::HandleNpcSayCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleNpcYellCommand(const char* args) bool ChatHandler::HandleNpcYellCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
@ -75,7 +75,7 @@ bool ChatHandler::HandleNpcYellCommand(const char* args)
} }
//show text emote by creature in chat //show text emote by creature in chat
bool ChatHandler::HandleNpcTextEmoteCommand(const char* args) bool ChatHandler::HandleNpcTextEmoteCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
@ -95,12 +95,12 @@ bool ChatHandler::HandleNpcTextEmoteCommand(const char* args)
} }
// make npc whisper to player // make npc whisper to player
bool ChatHandler::HandleNpcWhisperCommand(const char* args) bool ChatHandler::HandleNpcWhisperCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
char* receiver_str = strtok((char*)args, " "); char* receiver_str = strtok(args, " ");
char* text = strtok(NULL, ""); char* text = strtok(NULL, "");
uint64 guid = m_session->GetPlayer()->GetSelection(); uint64 guid = m_session->GetPlayer()->GetSelection();
@ -124,7 +124,7 @@ bool ChatHandler::HandleNpcWhisperCommand(const char* args)
//---------------------------------------------------------- //----------------------------------------------------------
// global announce // global announce
bool ChatHandler::HandleAnnounceCommand(const char* args) bool ChatHandler::HandleAnnounceCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
@ -134,7 +134,7 @@ bool ChatHandler::HandleAnnounceCommand(const char* args)
} }
//notification player at the screen //notification player at the screen
bool ChatHandler::HandleNotifyCommand(const char* args) bool ChatHandler::HandleNotifyCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
@ -150,7 +150,7 @@ bool ChatHandler::HandleNotifyCommand(const char* args)
} }
//Enable\Dissable GM Mode //Enable\Dissable GM Mode
bool ChatHandler::HandleGMCommand(const char* args) bool ChatHandler::HandleGMCommand(char* args)
{ {
if(!*args) if(!*args)
{ {
@ -161,7 +161,7 @@ bool ChatHandler::HandleGMCommand(const char* args)
return true; return true;
} }
std::string argstr = (char*)args; std::string argstr = args;
if (argstr == "on") if (argstr == "on")
{ {
@ -191,7 +191,7 @@ bool ChatHandler::HandleGMCommand(const char* args)
} }
// Enables or disables hiding of the staff badge // Enables or disables hiding of the staff badge
bool ChatHandler::HandleGMChatCommand(const char* args) bool ChatHandler::HandleGMChatCommand(char* args)
{ {
if(!*args) if(!*args)
{ {
@ -202,7 +202,7 @@ bool ChatHandler::HandleGMChatCommand(const char* args)
return true; return true;
} }
std::string argstr = (char*)args; std::string argstr = args;
if (argstr == "on") if (argstr == "on")
{ {
@ -224,7 +224,7 @@ bool ChatHandler::HandleGMChatCommand(const char* args)
} }
//Enable\Dissable Invisible mode //Enable\Dissable Invisible mode
bool ChatHandler::HandleGMVisibleCommand(const char* args) bool ChatHandler::HandleGMVisibleCommand(char* args)
{ {
if (!*args) if (!*args)
{ {
@ -232,7 +232,7 @@ bool ChatHandler::HandleGMVisibleCommand(const char* args)
return true; return true;
} }
std::string argstr = (char*)args; std::string argstr = args;
if (argstr == "on") if (argstr == "on")
{ {
@ -255,12 +255,12 @@ bool ChatHandler::HandleGMVisibleCommand(const char* args)
bool ChatHandler::HandleGPSCommand(const char* args) bool ChatHandler::HandleGPSCommand(char* args)
{ {
WorldObject *obj = NULL; WorldObject *obj = NULL;
if (*args) if (*args)
{ {
uint64 guid = extractGuidFromLink((char*)args); uint64 guid = extractGuidFromLink(args);
if(guid) if(guid)
obj = (WorldObject*)m_session->GetPlayer()->GetObjectByTypeMask(guid, TYPEMASK_CREATURE_OR_GAMEOBJECT); obj = (WorldObject*)m_session->GetPlayer()->GetObjectByTypeMask(guid, TYPEMASK_CREATURE_OR_GAMEOBJECT);
@ -355,12 +355,12 @@ bool ChatHandler::HandleGPSCommand(const char* args)
} }
//Summon Player //Summon Player
bool ChatHandler::HandleNamegoCommand(const char* args) bool ChatHandler::HandleNamegoCommand(char* args)
{ {
Player* target; Player* target;
uint64 target_guid; uint64 target_guid;
std::string target_name; std::string target_name;
if (!extractPlayerTarget((char*)args,&target,&target_guid,&target_name)) if (!extractPlayerTarget(args,&target,&target_guid,&target_name))
return false; return false;
Player* _player = m_session->GetPlayer(); Player* _player = m_session->GetPlayer();
@ -476,12 +476,12 @@ bool ChatHandler::HandleNamegoCommand(const char* args)
} }
//Teleport to Player //Teleport to Player
bool ChatHandler::HandleGonameCommand(const char* args) bool ChatHandler::HandleGonameCommand(char* args)
{ {
Player* target; Player* target;
uint64 target_guid; uint64 target_guid;
std::string target_name; std::string target_name;
if (!extractPlayerTarget((char*)args,&target,&target_guid,&target_name)) if (!extractPlayerTarget(args,&target,&target_guid,&target_name))
return false; return false;
Player* _player = m_session->GetPlayer(); Player* _player = m_session->GetPlayer();
@ -615,10 +615,10 @@ bool ChatHandler::HandleGonameCommand(const char* args)
} }
// Teleport player to last position // Teleport player to last position
bool ChatHandler::HandleRecallCommand(const char* args) bool ChatHandler::HandleRecallCommand(char* args)
{ {
Player* target; Player* target;
if(!extractPlayerTarget((char*)args,&target)) if(!extractPlayerTarget(args,&target))
return false; return false;
// check online security // check online security
@ -636,24 +636,13 @@ bool ChatHandler::HandleRecallCommand(const char* args)
} }
//Edit Player HP //Edit Player HP
bool ChatHandler::HandleModifyHPCommand(const char* args) bool ChatHandler::HandleModifyHPCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
// char* pHp = strtok((char*)args, " "); int32 hp = atoi(args);
// if (!pHp) int32 hpm = atoi(args);
// return false;
// char* pHpMax = strtok(NULL, " ");
// if (!pHpMax)
// return false;
// int32 hpm = atoi(pHpMax);
// int32 hp = atoi(pHp);
int32 hp = atoi((char*)args);
int32 hpm = atoi((char*)args);
if (hp <= 0 || hpm <= 0 || hpm < hp) if (hp <= 0 || hpm <= 0 || hpm < hp)
{ {
@ -685,23 +674,13 @@ bool ChatHandler::HandleModifyHPCommand(const char* args)
} }
//Edit Player Mana //Edit Player Mana
bool ChatHandler::HandleModifyManaCommand(const char* args) bool ChatHandler::HandleModifyManaCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
// char* pmana = strtok((char*)args, " "); int32 mana = atoi(args);
// if (!pmana) int32 manam = atoi(args);
// return false;
// char* pmanaMax = strtok(NULL, " ");
// if (!pmanaMax)
// return false;
// int32 manam = atoi(pmanaMax);
// int32 mana = atoi(pmana);
int32 mana = atoi((char*)args);
int32 manam = atoi((char*)args);
if (mana <= 0 || manam <= 0 || manam < mana) if (mana <= 0 || manam <= 0 || manam < mana)
{ {
@ -733,24 +712,13 @@ bool ChatHandler::HandleModifyManaCommand(const char* args)
} }
//Edit Player Energy //Edit Player Energy
bool ChatHandler::HandleModifyEnergyCommand(const char* args) bool ChatHandler::HandleModifyEnergyCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
// char* pmana = strtok((char*)args, " "); int32 energy = atoi(args)*10;
// if (!pmana) int32 energym = atoi(args)*10;
// return false;
// char* pmanaMax = strtok(NULL, " ");
// if (!pmanaMax)
// return false;
// int32 manam = atoi(pmanaMax);
// int32 mana = atoi(pmana);
int32 energy = atoi((char*)args)*10;
int32 energym = atoi((char*)args)*10;
if (energy <= 0 || energym <= 0 || energym < energy) if (energy <= 0 || energym <= 0 || energym < energy)
{ {
@ -784,24 +752,13 @@ bool ChatHandler::HandleModifyEnergyCommand(const char* args)
} }
//Edit Player Rage //Edit Player Rage
bool ChatHandler::HandleModifyRageCommand(const char* args) bool ChatHandler::HandleModifyRageCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
// char* pmana = strtok((char*)args, " "); int32 rage = atoi(args)*10;
// if (!pmana) int32 ragem = atoi(args)*10;
// return false;
// char* pmanaMax = strtok(NULL, " ");
// if (!pmanaMax)
// return false;
// int32 manam = atoi(pmanaMax);
// int32 mana = atoi(pmana);
int32 rage = atoi((char*)args)*10;
int32 ragem = atoi((char*)args)*10;
if (rage <= 0 || ragem <= 0 || ragem < rage) if (rage <= 0 || ragem <= 0 || ragem < rage)
{ {
@ -833,13 +790,13 @@ bool ChatHandler::HandleModifyRageCommand(const char* args)
} }
// Edit Player Runic Power // Edit Player Runic Power
bool ChatHandler::HandleModifyRunicPowerCommand(const char* args) bool ChatHandler::HandleModifyRunicPowerCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
int32 rune = atoi((char*)args)*10; int32 rune = atoi(args)*10;
int32 runem = atoi((char*)args)*10; int32 runem = atoi(args)*10;
if (rune <= 0 || runem <= 0 || runem < rune) if (rune <= 0 || runem <= 0 || runem < rune)
{ {
@ -867,12 +824,12 @@ bool ChatHandler::HandleModifyRunicPowerCommand(const char* args)
} }
//Edit Player Faction //Edit Player Faction
bool ChatHandler::HandleModifyFactionCommand(const char* args) bool ChatHandler::HandleModifyFactionCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
char* pfactionid = extractKeyFromLink((char*)args,"Hfaction"); char* pfactionid = extractKeyFromLink(args,"Hfaction");
Creature* chr = getSelectedCreature(); Creature* chr = getSelectedCreature();
if(!chr) if(!chr)
@ -945,10 +902,10 @@ bool ChatHandler::HandleModifyFactionCommand(const char* args)
} }
//Edit Player Spell //Edit Player Spell
bool ChatHandler::HandleModifySpellCommand(const char* args) bool ChatHandler::HandleModifySpellCommand(char* args)
{ {
if(!*args) return false; if(!*args) return false;
char* pspellflatid = strtok((char*)args, " "); char* pspellflatid = strtok(args, " ");
if (!pspellflatid) if (!pspellflatid)
return false; return false;
@ -999,12 +956,12 @@ bool ChatHandler::HandleModifySpellCommand(const char* args)
} }
//Edit Player TP //Edit Player TP
bool ChatHandler::HandleModifyTalentCommand (const char* args) bool ChatHandler::HandleModifyTalentCommand (char* args)
{ {
if (!*args) if (!*args)
return false; return false;
int tp = atoi((char*)args); int tp = atoi(args);
if (tp < 0) if (tp < 0)
return false; return false;
@ -1047,7 +1004,7 @@ bool ChatHandler::HandleModifyTalentCommand (const char* args)
} }
//Enable On\OFF all taxi paths //Enable On\OFF all taxi paths
bool ChatHandler::HandleTaxiCheatCommand(const char* args) bool ChatHandler::HandleTaxiCheatCommand(char* args)
{ {
if (!*args) if (!*args)
{ {
@ -1056,7 +1013,7 @@ bool ChatHandler::HandleTaxiCheatCommand(const char* args)
return false; return false;
} }
std::string argstr = (char*)args; std::string argstr = args;
Player *chr = getSelectedPlayer(); Player *chr = getSelectedPlayer();
if (!chr) if (!chr)
@ -1093,12 +1050,12 @@ bool ChatHandler::HandleTaxiCheatCommand(const char* args)
} }
//Edit Player Aspeed //Edit Player Aspeed
bool ChatHandler::HandleModifyASpeedCommand(const char* args) bool ChatHandler::HandleModifyASpeedCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
float modSpeed = (float)atof((char*)args); float modSpeed = (float)atof(args);
if (modSpeed > 10 || modSpeed < 0.1) if (modSpeed > 10 || modSpeed < 0.1)
{ {
@ -1141,12 +1098,12 @@ bool ChatHandler::HandleModifyASpeedCommand(const char* args)
} }
//Edit Player Speed //Edit Player Speed
bool ChatHandler::HandleModifySpeedCommand(const char* args) bool ChatHandler::HandleModifySpeedCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
float modSpeed = (float)atof((char*)args); float modSpeed = (float)atof(args);
if (modSpeed > 10 || modSpeed < 0.1) if (modSpeed > 10 || modSpeed < 0.1)
{ {
@ -1186,12 +1143,12 @@ bool ChatHandler::HandleModifySpeedCommand(const char* args)
} }
//Edit Player Swim Speed //Edit Player Swim Speed
bool ChatHandler::HandleModifySwimCommand(const char* args) bool ChatHandler::HandleModifySwimCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
float modSpeed = (float)atof((char*)args); float modSpeed = (float)atof(args);
if (modSpeed > 10.0f || modSpeed < 0.01f) if (modSpeed > 10.0f || modSpeed < 0.01f)
{ {
@ -1231,12 +1188,12 @@ bool ChatHandler::HandleModifySwimCommand(const char* args)
} }
//Edit Player Walk Speed //Edit Player Walk Speed
bool ChatHandler::HandleModifyBWalkCommand(const char* args) bool ChatHandler::HandleModifyBWalkCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
float modSpeed = (float)atof((char*)args); float modSpeed = (float)atof(args);
if (modSpeed > 10.0f || modSpeed < 0.1f) if (modSpeed > 10.0f || modSpeed < 0.1f)
{ {
@ -1276,12 +1233,12 @@ bool ChatHandler::HandleModifyBWalkCommand(const char* args)
} }
//Edit Player Fly //Edit Player Fly
bool ChatHandler::HandleModifyFlyCommand(const char* args) bool ChatHandler::HandleModifyFlyCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
float modSpeed = (float)atof((char*)args); float modSpeed = (float)atof(args);
if (modSpeed > 10.0f || modSpeed < 0.1f) if (modSpeed > 10.0f || modSpeed < 0.1f)
{ {
@ -1312,12 +1269,12 @@ bool ChatHandler::HandleModifyFlyCommand(const char* args)
} }
//Edit Player Scale //Edit Player Scale
bool ChatHandler::HandleModifyScaleCommand(const char* args) bool ChatHandler::HandleModifyScaleCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
float Scale = (float)atof((char*)args); float Scale = (float)atof(args);
if (Scale > 10.0f || Scale <= 0.0f) if (Scale > 10.0f || Scale <= 0.0f)
{ {
SendSysMessage(LANG_BAD_VALUE); SendSysMessage(LANG_BAD_VALUE);
@ -1350,16 +1307,14 @@ bool ChatHandler::HandleModifyScaleCommand(const char* args)
} }
//Enable Player mount //Enable Player mount
bool ChatHandler::HandleModifyMountCommand(const char* args) bool ChatHandler::HandleModifyMountCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
uint16 mId = 1147; uint16 mId = 1147;
float speed = (float)15; float speed = (float)15;
uint32 num = 0; uint32 num = atoi(args);
num = atoi((char*)args);
switch(num) switch(num)
{ {
case 1: case 1:
@ -1576,7 +1531,7 @@ bool ChatHandler::HandleModifyMountCommand(const char* args)
} }
Player *chr = getSelectedPlayer(); Player *chr = getSelectedPlayer();
if (chr == NULL) if (!chr)
{ {
SendSysMessage(LANG_NO_CHAR_SELECTED); SendSysMessage(LANG_NO_CHAR_SELECTED);
SetSentErrorMessage(true); SetSentErrorMessage(true);
@ -1611,7 +1566,7 @@ bool ChatHandler::HandleModifyMountCommand(const char* args)
} }
//Edit Player money //Edit Player money
bool ChatHandler::HandleModifyMoneyCommand(const char* args) bool ChatHandler::HandleModifyMoneyCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
@ -1628,7 +1583,7 @@ bool ChatHandler::HandleModifyMoneyCommand(const char* args)
if (HasLowerSecurity(chr, 0)) if (HasLowerSecurity(chr, 0))
return false; return false;
int32 addmoney = atoi((char*)args); int32 addmoney = atoi(args);
uint32 moneyuser = chr->GetMoney(); uint32 moneyuser = chr->GetMoney();
@ -1674,7 +1629,7 @@ bool ChatHandler::HandleModifyMoneyCommand(const char* args)
} }
//Edit Unit field //Edit Unit field
bool ChatHandler::HandleModifyBitCommand(const char* args) bool ChatHandler::HandleModifyBitCommand(char* args)
{ {
if( !*args ) if( !*args )
return false; return false;
@ -1691,7 +1646,7 @@ bool ChatHandler::HandleModifyBitCommand(const char* args)
if (unit->GetTypeId() == TYPEID_PLAYER && HasLowerSecurity((Player *)unit, 0)) if (unit->GetTypeId() == TYPEID_PLAYER && HasLowerSecurity((Player *)unit, 0))
return false; return false;
char* pField = strtok((char*)args, " "); char* pField = strtok(args, " ");
if (!pField) if (!pField)
return false; return false;
@ -1728,7 +1683,7 @@ bool ChatHandler::HandleModifyBitCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleModifyHonorCommand (const char* args) bool ChatHandler::HandleModifyHonorCommand (char* args)
{ {
if (!*args) if (!*args)
return false; return false;
@ -1745,7 +1700,7 @@ bool ChatHandler::HandleModifyHonorCommand (const char* args)
if (HasLowerSecurity(target, 0)) if (HasLowerSecurity(target, 0))
return false; return false;
int32 amount = (uint32)atoi(args); int32 amount = (int32)atoi(args);
target->ModifyHonorPoints(amount); target->ModifyHonorPoints(amount);
@ -1754,7 +1709,7 @@ bool ChatHandler::HandleModifyHonorCommand (const char* args)
return true; return true;
} }
bool ChatHandler::HandleTeleCommand(const char * args) bool ChatHandler::HandleTeleCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
@ -1762,7 +1717,7 @@ bool ChatHandler::HandleTeleCommand(const char * args)
Player* _player = m_session->GetPlayer(); Player* _player = m_session->GetPlayer();
// id, or string, or [name] Shift-click form |color|Htele:id|h[name]|h|r // id, or string, or [name] Shift-click form |color|Htele:id|h[name]|h|r
GameTele const* tele = extractGameTeleFromLink((char*)args); GameTele const* tele = extractGameTeleFromLink(args);
if (!tele) if (!tele)
{ {
@ -1774,7 +1729,7 @@ bool ChatHandler::HandleTeleCommand(const char * args)
return HandleGoHelper(_player, tele->mapId, tele->position_x, tele->position_y, &tele->position_z, &tele->orientation); return HandleGoHelper(_player, tele->mapId, tele->position_x, tele->position_y, &tele->position_z, &tele->orientation);
} }
bool ChatHandler::HandleLookupAreaCommand(const char* args) bool ChatHandler::HandleLookupAreaCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
@ -1841,7 +1796,7 @@ bool ChatHandler::HandleLookupAreaCommand(const char* args)
} }
//Find tele in game_tele order by name //Find tele in game_tele order by name
bool ChatHandler::HandleLookupTeleCommand(const char * args) bool ChatHandler::HandleLookupTeleCommand(char * args)
{ {
if(!*args) if(!*args)
{ {
@ -1850,7 +1805,7 @@ bool ChatHandler::HandleLookupTeleCommand(const char * args)
return false; return false;
} }
char const* str = strtok((char*)args, " "); char const* str = strtok(args, " ");
if(!str) if(!str)
return false; return false;
@ -1888,7 +1843,7 @@ bool ChatHandler::HandleLookupTeleCommand(const char * args)
} }
//Enable\Dissable accept whispers (for GM) //Enable\Dissable accept whispers (for GM)
bool ChatHandler::HandleWhispersCommand(const char* args) bool ChatHandler::HandleWhispersCommand(char* args)
{ {
if(!*args) if(!*args)
{ {
@ -1896,7 +1851,7 @@ bool ChatHandler::HandleWhispersCommand(const char* args)
return true; return true;
} }
std::string argstr = (char*)args; std::string argstr = args;
// whisper on // whisper on
if (argstr == "on") if (argstr == "on")
{ {
@ -1919,7 +1874,7 @@ bool ChatHandler::HandleWhispersCommand(const char* args)
} }
//Save all players in the world //Save all players in the world
bool ChatHandler::HandleSaveAllCommand(const char* /*args*/) bool ChatHandler::HandleSaveAllCommand(char* /*args*/)
{ {
sObjectAccessor.SaveAllPlayers(); sObjectAccessor.SaveAllPlayers();
SendSysMessage(LANG_PLAYERS_SAVED); SendSysMessage(LANG_PLAYERS_SAVED);
@ -1927,13 +1882,13 @@ bool ChatHandler::HandleSaveAllCommand(const char* /*args*/)
} }
//Send mail by command //Send mail by command
bool ChatHandler::HandleSendMailCommand(const char* args) bool ChatHandler::HandleSendMailCommand(char* args)
{ {
// format: name "subject text" "mail text" // format: name "subject text" "mail text"
Player* target; Player* target;
uint64 target_guid; uint64 target_guid;
std::string target_name; std::string target_name;
if(!extractPlayerTarget((char*)args,&target,&target_guid,&target_name)) if (!extractPlayerTarget(args, &target, &target_guid, &target_name))
return false; return false;
char* tail1 = strtok(NULL, ""); char* tail1 = strtok(NULL, "");
@ -1968,11 +1923,11 @@ bool ChatHandler::HandleSendMailCommand(const char* args)
} }
// teleport player to given game_tele.entry // teleport player to given game_tele.entry
bool ChatHandler::HandleTeleNameCommand(const char * args) bool ChatHandler::HandleTeleNameCommand(char* args)
{ {
char* nameStr; char* nameStr;
char* teleStr; char* teleStr;
extractOptFirstArg((char*)args,&nameStr,&teleStr); extractOptFirstArg(args, &nameStr, &teleStr);
if (!teleStr) if (!teleStr)
return false; return false;
@ -2029,7 +1984,7 @@ bool ChatHandler::HandleTeleNameCommand(const char * args)
} }
//Teleport group to given game_tele.entry //Teleport group to given game_tele.entry
bool ChatHandler::HandleTeleGroupCommand(const char * args) bool ChatHandler::HandleTeleGroupCommand(char * args)
{ {
if (!*args) if (!*args)
return false; return false;
@ -2047,7 +2002,7 @@ bool ChatHandler::HandleTeleGroupCommand(const char * args)
return false; return false;
// id, or string, or [name] Shift-click form |color|Htele:id|h[name]|h|r // id, or string, or [name] Shift-click form |color|Htele:id|h[name]|h|r
GameTele const* tele = extractGameTeleFromLink((char*)args); GameTele const* tele = extractGameTeleFromLink(args);
if(!tele) if(!tele)
{ {
SendSysMessage(LANG_COMMAND_TELE_NOTFOUND); SendSysMessage(LANG_COMMAND_TELE_NOTFOUND);
@ -2105,10 +2060,10 @@ bool ChatHandler::HandleTeleGroupCommand(const char * args)
} }
//Summon group of player //Summon group of player
bool ChatHandler::HandleGroupgoCommand(const char* args) bool ChatHandler::HandleGroupgoCommand(char* args)
{ {
Player* target; Player* target;
if(!extractPlayerTarget((char*)args,&target)) if (!extractPlayerTarget(args, &target))
return false; return false;
// check online security // check online security
@ -2245,14 +2200,14 @@ bool ChatHandler::HandleGoHelper( Player* player, uint32 mapid, float x, float y
return true; return true;
} }
bool ChatHandler::HandleGoTaxinodeCommand(const char* args) bool ChatHandler::HandleGoTaxinodeCommand(char* args)
{ {
Player* _player = m_session->GetPlayer(); Player* _player = m_session->GetPlayer();
if (!*args) if (!*args)
return false; return false;
char* cNodeId = extractKeyFromLink((char*)args,"Htaxinode"); char* cNodeId = extractKeyFromLink(args, "Htaxinode");
if (!cNodeId) if (!cNodeId)
return false; return false;
@ -2278,7 +2233,7 @@ bool ChatHandler::HandleGoTaxinodeCommand(const char* args)
return HandleGoHelper(_player, node->map_id, node->x, node->y, &node->z); return HandleGoHelper(_player, node->map_id, node->x, node->y, &node->z);
} }
bool ChatHandler::HandleGoCommand(const char* args) bool ChatHandler::HandleGoCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
@ -2291,7 +2246,7 @@ bool ChatHandler::HandleGoCommand(const char* args)
// raw coordinates case // raw coordinates case
if (isNumeric(args[0]) || args[0] == '-') if (isNumeric(args[0]) || args[0] == '-')
{ {
char* px = strtok((char*)args, " "); char* px = strtok(args, " ");
char* py = strtok(NULL, " "); char* py = strtok(NULL, " ");
char* pz = strtok(NULL, " "); char* pz = strtok(NULL, " ");
char* pmapid = strtok(NULL, " "); char* pmapid = strtok(NULL, " ");
@ -2309,7 +2264,7 @@ bool ChatHandler::HandleGoCommand(const char* args)
} }
// link case // link case
else if (!extractLocationFromLink((char*)args, mapid, x, y, z)) else if (!extractLocationFromLink(args, mapid, x, y, z))
return false; return false;
return HandleGoHelper(_player, mapid, x, y, &z); return HandleGoHelper(_player, mapid, x, y, &z);
@ -2318,14 +2273,14 @@ bool ChatHandler::HandleGoCommand(const char* args)
//teleport at coordinates //teleport at coordinates
bool ChatHandler::HandleGoXYCommand(const char* args) bool ChatHandler::HandleGoXYCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
Player* _player = m_session->GetPlayer(); Player* _player = m_session->GetPlayer();
char* px = strtok((char*)args, " "); char* px = strtok(args, " ");
char* py = strtok(NULL, " "); char* py = strtok(NULL, " ");
char* pmapid = strtok(NULL, " "); char* pmapid = strtok(NULL, " ");
@ -2343,14 +2298,14 @@ bool ChatHandler::HandleGoXYCommand(const char* args)
} }
//teleport at coordinates, including Z //teleport at coordinates, including Z
bool ChatHandler::HandleGoXYZCommand(const char* args) bool ChatHandler::HandleGoXYZCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
Player* _player = m_session->GetPlayer(); Player* _player = m_session->GetPlayer();
char* px = strtok((char*)args, " "); char* px = strtok(args, " ");
char* py = strtok(NULL, " "); char* py = strtok(NULL, " ");
char* pz = strtok(NULL, " "); char* pz = strtok(NULL, " ");
char* pmapid = strtok(NULL, " "); char* pmapid = strtok(NULL, " ");
@ -2371,14 +2326,14 @@ bool ChatHandler::HandleGoXYZCommand(const char* args)
} }
//teleport at coordinates //teleport at coordinates
bool ChatHandler::HandleGoZoneXYCommand(const char* args) bool ChatHandler::HandleGoZoneXYCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
Player* _player = m_session->GetPlayer(); Player* _player = m_session->GetPlayer();
char* px = strtok((char*)args, " "); char* px = strtok(args, " ");
char* py = strtok(NULL, " "); char* py = strtok(NULL, " ");
char* tail = strtok(NULL,""); char* tail = strtok(NULL,"");
@ -2430,14 +2385,14 @@ bool ChatHandler::HandleGoZoneXYCommand(const char* args)
} }
//teleport to grid //teleport to grid
bool ChatHandler::HandleGoGridCommand(const char* args) bool ChatHandler::HandleGoGridCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
Player* _player = m_session->GetPlayer(); Player* _player = m_session->GetPlayer();
char* px = strtok((char*)args, " "); char* px = strtok(args, " ");
char* py = strtok(NULL, " "); char* py = strtok(NULL, " ");
char* pmapid = strtok(NULL, " "); char* pmapid = strtok(NULL, " ");
@ -2455,7 +2410,7 @@ bool ChatHandler::HandleGoGridCommand(const char* args)
return HandleGoHelper(_player, mapid, x, y); return HandleGoHelper(_player, mapid, x, y);
} }
bool ChatHandler::HandleModifyDrunkCommand(const char* args) bool ChatHandler::HandleModifyDrunkCommand(char* args)
{ {
if(!*args) return false; if(!*args) return false;

302
src/game/Level2.cpp
View file

File diff suppressed because it is too large Load diff

623
src/game/Level3.cpp
View file

File diff suppressed because it is too large Load diff

94
src/game/debugcmds.cpp
View file

@ -33,12 +33,12 @@
#include "ObjectGuid.h" #include "ObjectGuid.h"
#include "SpellMgr.h" #include "SpellMgr.h"
bool ChatHandler::HandleDebugSendSpellFailCommand(const char* args) bool ChatHandler::HandleDebugSendSpellFailCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
char* px = strtok((char*)args, " "); char* px = strtok(args, " ");
if (!px) if (!px)
return false; return false;
@ -66,7 +66,7 @@ bool ChatHandler::HandleDebugSendSpellFailCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugSendPoiCommand(const char* args) bool ChatHandler::HandleDebugSendPoiCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
@ -79,7 +79,7 @@ bool ChatHandler::HandleDebugSendPoiCommand(const char* args)
return true; return true;
} }
char* icon_text = strtok((char*)args, " "); char* icon_text = strtok(args, " ");
char* flags_text = strtok(NULL, " "); char* flags_text = strtok(NULL, " ");
if (!icon_text || !flags_text) if (!icon_text || !flags_text)
return false; return false;
@ -92,7 +92,7 @@ bool ChatHandler::HandleDebugSendPoiCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugSendEquipErrorCommand(const char* args) bool ChatHandler::HandleDebugSendEquipErrorCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
@ -102,7 +102,7 @@ bool ChatHandler::HandleDebugSendEquipErrorCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugSendSellErrorCommand(const char* args) bool ChatHandler::HandleDebugSendSellErrorCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
@ -112,7 +112,7 @@ bool ChatHandler::HandleDebugSendSellErrorCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugSendBuyErrorCommand(const char* args) bool ChatHandler::HandleDebugSendBuyErrorCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
@ -122,7 +122,7 @@ bool ChatHandler::HandleDebugSendBuyErrorCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugSendOpcodeCommand(const char* /*args*/) bool ChatHandler::HandleDebugSendOpcodeCommand(char* /*args*/)
{ {
Unit *unit = getSelectedUnit(); Unit *unit = getSelectedUnit();
if (!unit || (unit->GetTypeId() != TYPEID_PLAYER)) if (!unit || (unit->GetTypeId() != TYPEID_PLAYER))
@ -199,9 +199,9 @@ bool ChatHandler::HandleDebugSendOpcodeCommand(const char* /*args*/)
return true; return true;
} }
bool ChatHandler::HandleDebugUpdateWorldStateCommand(const char* args) bool ChatHandler::HandleDebugUpdateWorldStateCommand(char* args)
{ {
char* w = strtok((char*)args, " "); char* w = strtok(args, " ");
char* s = strtok(NULL, " "); char* s = strtok(NULL, " ");
if (!w || !s) if (!w || !s)
@ -213,7 +213,7 @@ bool ChatHandler::HandleDebugUpdateWorldStateCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugPlayCinematicCommand(const char* args) bool ChatHandler::HandleDebugPlayCinematicCommand(char* args)
{ {
// USAGE: .debug play cinematic #cinematicid // USAGE: .debug play cinematic #cinematicid
// #cinematicid - ID decimal number from CinemaicSequences.dbc (1st column) // #cinematicid - ID decimal number from CinemaicSequences.dbc (1st column)
@ -224,7 +224,7 @@ bool ChatHandler::HandleDebugPlayCinematicCommand(const char* args)
return false; return false;
} }
uint32 dwId = atoi((char*)args); uint32 dwId = atoi(args);
if (!sCinematicSequencesStore.LookupEntry(dwId)) if (!sCinematicSequencesStore.LookupEntry(dwId))
{ {
@ -237,7 +237,7 @@ bool ChatHandler::HandleDebugPlayCinematicCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugPlayMovieCommand(const char* args) bool ChatHandler::HandleDebugPlayMovieCommand(char* args)
{ {
// USAGE: .debug play movie #movieid // USAGE: .debug play movie #movieid
// #movieid - ID decimal number from Movie.dbc (1st column) // #movieid - ID decimal number from Movie.dbc (1st column)
@ -248,7 +248,7 @@ bool ChatHandler::HandleDebugPlayMovieCommand(const char* args)
return false; return false;
} }
uint32 dwId = atoi((char*)args); uint32 dwId = atoi(args);
if (!sMovieStore.LookupEntry(dwId)) if (!sMovieStore.LookupEntry(dwId))
{ {
@ -262,7 +262,7 @@ bool ChatHandler::HandleDebugPlayMovieCommand(const char* args)
} }
//Play sound //Play sound
bool ChatHandler::HandleDebugPlaySoundCommand(const char* args) bool ChatHandler::HandleDebugPlaySoundCommand(char* args)
{ {
// USAGE: .debug playsound #soundid // USAGE: .debug playsound #soundid
// #soundid - ID decimal number from SoundEntries.dbc (1st column) // #soundid - ID decimal number from SoundEntries.dbc (1st column)
@ -273,7 +273,7 @@ bool ChatHandler::HandleDebugPlaySoundCommand(const char* args)
return false; return false;
} }
uint32 dwSoundId = atoi((char*)args); uint32 dwSoundId = atoi(args);
if (!sSoundEntriesStore.LookupEntry(dwSoundId)) if (!sSoundEntriesStore.LookupEntry(dwSoundId))
{ {
@ -300,7 +300,7 @@ bool ChatHandler::HandleDebugPlaySoundCommand(const char* args)
} }
//Send notification in channel //Send notification in channel
bool ChatHandler::HandleDebugSendChannelNotifyCommand(const char* args) bool ChatHandler::HandleDebugSendChannelNotifyCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
@ -318,7 +318,7 @@ bool ChatHandler::HandleDebugSendChannelNotifyCommand(const char* args)
} }
//Send notification in chat //Send notification in chat
bool ChatHandler::HandleDebugSendChatMsgCommand(const char* args) bool ChatHandler::HandleDebugSendChatMsgCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
@ -331,14 +331,14 @@ bool ChatHandler::HandleDebugSendChatMsgCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugSendQuestPartyMsgCommand(const char* args) bool ChatHandler::HandleDebugSendQuestPartyMsgCommand(char* args)
{ {
uint32 msg = atol((char*)args); uint32 msg = atol(args);
m_session->GetPlayer()->SendPushToPartyResponse(m_session->GetPlayer(), msg); m_session->GetPlayer()->SendPushToPartyResponse(m_session->GetPlayer(), msg);
return true; return true;
} }
bool ChatHandler::HandleDebugGetLootRecipientCommand(const char* /*args*/) bool ChatHandler::HandleDebugGetLootRecipientCommand(char* /*args*/)
{ {
Creature* target = getSelectedCreature(); Creature* target = getSelectedCreature();
if (!target) if (!target)
@ -357,14 +357,14 @@ bool ChatHandler::HandleDebugGetLootRecipientCommand(const char* /*args*/)
return true; return true;
} }
bool ChatHandler::HandleDebugSendQuestInvalidMsgCommand(const char* args) bool ChatHandler::HandleDebugSendQuestInvalidMsgCommand(char* args)
{ {
uint32 msg = atol((char*)args); uint32 msg = atol(args);
m_session->GetPlayer()->SendCanTakeQuestResponse(msg); m_session->GetPlayer()->SendCanTakeQuestResponse(msg);
return true; return true;
} }
bool ChatHandler::HandleDebugGetItemStateCommand(const char* args) bool ChatHandler::HandleDebugGetItemStateCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
@ -598,24 +598,24 @@ bool ChatHandler::HandleDebugGetItemStateCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugBattlegroundCommand(const char * /*args*/) bool ChatHandler::HandleDebugBattlegroundCommand(char* /*args*/)
{ {
sBattleGroundMgr.ToggleTesting(); sBattleGroundMgr.ToggleTesting();
return true; return true;
} }
bool ChatHandler::HandleDebugArenaCommand(const char * /*args*/) bool ChatHandler::HandleDebugArenaCommand(char* /*args*/)
{ {
sBattleGroundMgr.ToggleArenaTesting(); sBattleGroundMgr.ToggleArenaTesting();
return true; return true;
} }
bool ChatHandler::HandleDebugSpawnVehicle(const char* args) bool ChatHandler::HandleDebugSpawnVehicleCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
char* e = strtok((char*)args, " "); char* e = strtok(args, " ");
char* i = strtok(NULL, " "); char* i = strtok(NULL, " ");
if (!e || !i) if (!e || !i)
@ -660,14 +660,14 @@ bool ChatHandler::HandleDebugSpawnVehicle(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugSpellCheckCommand(const char* /*args*/) bool ChatHandler::HandleDebugSpellCheckCommand(char* /*args*/)
{ {
sLog.outString( "Check expected in code spell properties base at table 'spell_check' content..."); sLog.outString( "Check expected in code spell properties base at table 'spell_check' content...");
sSpellMgr.CheckUsedSpells("spell_check"); sSpellMgr.CheckUsedSpells("spell_check");
return true; return true;
} }
bool ChatHandler::HandleDebugSendLargePacketCommand(const char* /*args*/) bool ChatHandler::HandleDebugSendLargePacketCommand(char* /*args*/)
{ {
const char* stuffingString = "This is a dummy string to push the packet's size beyond 128000 bytes. "; const char* stuffingString = "This is a dummy string to push the packet's size beyond 128000 bytes. ";
std::ostringstream ss; std::ostringstream ss;
@ -677,7 +677,7 @@ bool ChatHandler::HandleDebugSendLargePacketCommand(const char* /*args*/)
return true; return true;
} }
bool ChatHandler::HandleDebugSendSetPhaseShiftCommand(const char* args) bool ChatHandler::HandleDebugSendSetPhaseShiftCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
@ -687,12 +687,12 @@ bool ChatHandler::HandleDebugSendSetPhaseShiftCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugGetItemValueCommand(const char* args) bool ChatHandler::HandleDebugGetItemValueCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
char* e = strtok((char*)args, " "); char* e = strtok(args, " ");
char* f = strtok(NULL, " "); char* f = strtok(NULL, " ");
if (!e || !f) if (!e || !f)
@ -716,12 +716,12 @@ bool ChatHandler::HandleDebugGetItemValueCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugSetItemValueCommand(const char* args) bool ChatHandler::HandleDebugSetItemValueCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
char* e = strtok((char*)args, " "); char* e = strtok(args, " ");
char* f = strtok(NULL, " "); char* f = strtok(NULL, " ");
char* g = strtok(NULL, " "); char* g = strtok(NULL, " ");
@ -746,17 +746,17 @@ bool ChatHandler::HandleDebugSetItemValueCommand(const char* args)
} }
//show animation //show animation
bool ChatHandler::HandleDebugAnimCommand(const char* args) bool ChatHandler::HandleDebugAnimCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
uint32 emote_id = atoi((char*)args); uint32 emote_id = atoi(args);
m_session->GetPlayer()->HandleEmoteCommand(emote_id); m_session->GetPlayer()->HandleEmoteCommand(emote_id);
return true; return true;
} }
bool ChatHandler::HandleDebugSetAuraStateCommand(const char* args) bool ChatHandler::HandleDebugSetAuraStateCommand(char* args)
{ {
if (!*args) if (!*args)
{ {
@ -773,7 +773,7 @@ bool ChatHandler::HandleDebugSetAuraStateCommand(const char* args)
return false; return false;
} }
int32 state = atoi((char*)args); int32 state = atoi(args);
if (!state) if (!state)
{ {
// reset all states // reset all states
@ -786,12 +786,12 @@ bool ChatHandler::HandleDebugSetAuraStateCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugSetValueCommand(const char* args) bool ChatHandler::HandleDebugSetValueCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
char* px = strtok((char*)args, " "); char* px = strtok(args, " ");
char* py = strtok(NULL, " "); char* py = strtok(NULL, " ");
char* pz = strtok(NULL, " "); char* pz = strtok(NULL, " ");
@ -837,12 +837,12 @@ bool ChatHandler::HandleDebugSetValueCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugGetValueCommand(const char* args) bool ChatHandler::HandleDebugGetValueCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
char* px = strtok((char*)args, " "); char* px = strtok(args, " ");
char* pz = strtok(NULL, " "); char* pz = strtok(NULL, " ");
if (!px) if (!px)
@ -886,12 +886,12 @@ bool ChatHandler::HandleDebugGetValueCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugMod32ValueCommand(const char* args) bool ChatHandler::HandleDebugMod32ValueCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
char* px = strtok((char*)args, " "); char* px = strtok(args, " ");
char* py = strtok(NULL, " "); char* py = strtok(NULL, " ");
if (!px || !py) if (!px || !py)
@ -918,7 +918,7 @@ bool ChatHandler::HandleDebugMod32ValueCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleDebugUpdateCommand(const char* args) bool ChatHandler::HandleDebugUpdateCommand(char* args)
{ {
if(!*args) if(!*args)
return false; return false;
@ -926,7 +926,7 @@ bool ChatHandler::HandleDebugUpdateCommand(const char* args)
uint32 updateIndex; uint32 updateIndex;
uint32 value; uint32 value;
char* pUpdateIndex = strtok((char*)args, " "); char* pUpdateIndex = strtok(args, " ");
Unit* chr = getSelectedUnit(); Unit* chr = getSelectedUnit();
if (chr == NULL) if (chr == NULL)

42
src/mangosd/CliRunnable.cpp
View file

@ -59,13 +59,13 @@ void commandFinished(void*, bool sucess)
/// Delete a user account and all associated characters in this realm /// Delete a user account and all associated characters in this realm
/// \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 /// \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
bool ChatHandler::HandleAccountDeleteCommand(const char* args) bool ChatHandler::HandleAccountDeleteCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
std::string account_name; std::string account_name;
uint32 account_id = extractAccountId((char*)args,&account_name); uint32 account_id = extractAccountId(args, &account_name);
if (!account_id) if (!account_id)
return false; return false;
@ -227,7 +227,7 @@ void ChatHandler::HandleCharacterDeletedListHelper(DeletedInfoList const& foundL
* *
* @param args the search string which either contains a player GUID or a part fo the character-name * @param args the search string which either contains a player GUID or a part fo the character-name
*/ */
bool ChatHandler::HandleCharacterDeletedListCommand(const char* args) bool ChatHandler::HandleCharacterDeletedListCommand(char* args)
{ {
DeletedInfoList foundList; DeletedInfoList foundList;
if (!GetDeletedCharacterInfoList(foundList, args)) if (!GetDeletedCharacterInfoList(foundList, args))
@ -291,7 +291,7 @@ void ChatHandler::HandleCharacterDeletedRestoreHelper(DeletedInfo const& delInfo
* *
* @param args the search string which either contains a player GUID or a part of the character-name * @param args the search string which either contains a player GUID or a part of the character-name
*/ */
bool ChatHandler::HandleCharacterDeletedRestoreCommand(const char* args) bool ChatHandler::HandleCharacterDeletedRestoreCommand(char* args)
{ {
// It is required to submit at least one argument // It is required to submit at least one argument
if (!*args) if (!*args)
@ -356,7 +356,7 @@ bool ChatHandler::HandleCharacterDeletedRestoreCommand(const char* args)
* *
* @param args the search string which either contains a player GUID or a part fo the character-name * @param args the search string which either contains a player GUID or a part fo the character-name
*/ */
bool ChatHandler::HandleCharacterDeletedDeleteCommand(const char* args) bool ChatHandler::HandleCharacterDeletedDeleteCommand(char* args)
{ {
// It is required to submit at least one argument // It is required to submit at least one argument
if (!*args) if (!*args)
@ -393,12 +393,11 @@ bool ChatHandler::HandleCharacterDeletedDeleteCommand(const char* args)
* *
* @param args the search string which either contains a player GUID or a part fo the character-name * @param args the search string which either contains a player GUID or a part fo the character-name
*/ */
bool ChatHandler::HandleCharacterDeletedOldCommand(const char* args) bool ChatHandler::HandleCharacterDeletedOldCommand(char* args)
{ {
int32 keepDays = sWorld.getConfig(CONFIG_UINT32_CHARDELETE_KEEP_DAYS); int32 keepDays = sWorld.getConfig(CONFIG_UINT32_CHARDELETE_KEEP_DAYS);
char* px = strtok((char*)args, " "); if (char* px = strtok(args, " "))
if (px)
{ {
if (!isNumeric(px)) if (!isNumeric(px))
return false; return false;
@ -415,12 +414,12 @@ bool ChatHandler::HandleCharacterDeletedOldCommand(const char* args)
return true; return true;
} }
bool ChatHandler::HandleCharacterEraseCommand(const char* args) bool ChatHandler::HandleCharacterEraseCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
char *character_name_str = strtok((char*)args," "); char *character_name_str = strtok(args," ");
if(!character_name_str) if(!character_name_str)
return false; return false;
@ -431,8 +430,7 @@ bool ChatHandler::HandleCharacterEraseCommand(const char* args)
uint64 character_guid; uint64 character_guid;
uint32 account_id; uint32 account_id;
Player *player = sObjectMgr.GetPlayer(character_name.c_str()); if (Player *player = sObjectMgr.GetPlayer(character_name.c_str()))
if(player)
{ {
character_guid = player->GetGUID(); character_guid = player->GetGUID();
account_id = player->GetSession()->GetAccountId(); account_id = player->GetSession()->GetAccountId();
@ -460,7 +458,7 @@ bool ChatHandler::HandleCharacterEraseCommand(const char* args)
} }
/// Close RA connection /// Close RA connection
bool ChatHandler::HandleQuitCommand(const char* /*args*/) bool ChatHandler::HandleQuitCommand(char* /*args*/)
{ {
// processed in RASocket // processed in RASocket
SendSysMessage(LANG_QUIT_WRONG_USE_ERROR); SendSysMessage(LANG_QUIT_WRONG_USE_ERROR);
@ -468,7 +466,7 @@ bool ChatHandler::HandleQuitCommand(const char* /*args*/)
} }
/// Exit the realm /// Exit the realm
bool ChatHandler::HandleServerExitCommand(const char* /*args*/) bool ChatHandler::HandleServerExitCommand(char* /*args*/)
{ {
SendSysMessage(LANG_COMMAND_EXIT); SendSysMessage(LANG_COMMAND_EXIT);
World::StopNow(SHUTDOWN_EXIT_CODE); World::StopNow(SHUTDOWN_EXIT_CODE);
@ -476,9 +474,9 @@ bool ChatHandler::HandleServerExitCommand(const char* /*args*/)
} }
/// Display info on users currently in the realm /// Display info on users currently in the realm
bool ChatHandler::HandleAccountOnlineListCommand(const char* args) bool ChatHandler::HandleAccountOnlineListCommand(char* args)
{ {
char* limit_str = *args ? strtok((char*)args, " ") : NULL; char* limit_str = *args ? strtok(args, " ") : NULL;
uint32 limit = limit_str ? atoi(limit_str) : 100; uint32 limit = limit_str ? atoi(limit_str) : 100;
///- Get the list of accounts ID logged to the realm ///- Get the list of accounts ID logged to the realm
@ -489,13 +487,13 @@ bool ChatHandler::HandleAccountOnlineListCommand(const char* args)
} }
/// Create an account /// Create an account
bool ChatHandler::HandleAccountCreateCommand(const char* args) bool ChatHandler::HandleAccountCreateCommand(char* args)
{ {
if (!*args) if (!*args)
return false; return false;
///- %Parse the command line arguments ///- %Parse the command line arguments
char *szAcc = strtok((char*)args, " "); char *szAcc = strtok(args, " ");
char *szPassword = strtok(NULL, " "); char *szPassword = strtok(NULL, " ");
if(!szAcc || !szPassword) if(!szAcc || !szPassword)
return false; return false;
@ -532,7 +530,7 @@ bool ChatHandler::HandleAccountCreateCommand(const char* args)
} }
/// Set the filters of logging /// Set the filters of logging
bool ChatHandler::HandleServerLogFilterCommand(const char* args) bool ChatHandler::HandleServerLogFilterCommand(char* args)
{ {
if (!*args) if (!*args)
{ {
@ -545,7 +543,7 @@ bool ChatHandler::HandleServerLogFilterCommand(const char* args)
return true; return true;
} }
char *filtername = strtok((char*)args, " "); char *filtername = strtok(args, " ");
if (!filtername) if (!filtername)
return false; return false;
@ -589,7 +587,7 @@ bool ChatHandler::HandleServerLogFilterCommand(const char* args)
} }
/// Set the level of logging /// Set the level of logging
bool ChatHandler::HandleServerLogLevelCommand(const char *args) bool ChatHandler::HandleServerLogLevelCommand(char *args)
{ {
if (!*args) if (!*args)
{ {
@ -597,7 +595,7 @@ bool ChatHandler::HandleServerLogLevelCommand(const char *args)
return true; return true;
} }
sLog.SetLogLevel((char*)args); sLog.SetLogLevel(args);
return true; return true;
} }

2
src/shared/revision_nr.h
View file

@ -1,4 +1,4 @@
#ifndef __REVISION_NR_H__ #ifndef __REVISION_NR_H__
#define __REVISION_NR_H__ #define __REVISION_NR_H__
#define REVISION_NR "10321" #define REVISION_NR "10322"
#endif // __REVISION_NR_H__ #endif // __REVISION_NR_H__