mangos-mirror/server
0
0
Fork 0
mirror of https://github.com/mangosfour/server.git synced 2025-12-13 04:37:00 +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 },
{ "setvalue", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDebugSetValueCommand, "", 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 },
{ "update", SEC_ADMINISTRATOR, false, &ChatHandler::HandleDebugUpdateCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
@ -411,9 +411,9 @@ ChatCommand * ChatHandler::getCommandTable()
static ChatCommand questCommandTable[] =
{
{ "add", SEC_ADMINISTRATOR, false, &ChatHandler::HandleQuestAdd, "", NULL },
{ "complete", SEC_ADMINISTRATOR, false, &ChatHandler::HandleQuestComplete, "", NULL },
{ "remove", SEC_ADMINISTRATOR, false, &ChatHandler::HandleQuestRemove, "", NULL },
{ "add", SEC_ADMINISTRATOR, false, &ChatHandler::HandleQuestAddCommand, "", NULL },
{ "complete", SEC_ADMINISTRATOR, false, &ChatHandler::HandleQuestCompleteCommand, "", NULL },
{ "remove", SEC_ADMINISTRATOR, false, &ChatHandler::HandleQuestRemoveCommand, "", NULL },
{ NULL, 0, false, NULL, "", NULL }
};
@ -706,7 +706,7 @@ ChatCommand * ChatHandler::getCommandTable()
{ "additem", SEC_ADMINISTRATOR, false, &ChatHandler::HandleAddItemCommand, "", NULL },
{ "additemset", SEC_ADMINISTRATOR, false, &ChatHandler::HandleAddItemSetCommand, "", 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 },
{ "delticket", SEC_GAMEMASTER, true, &ChatHandler::HandleDelTicketCommand, "", NULL },
{ "maxskill", SEC_ADMINISTRATOR, false, &ChatHandler::HandleMaxSkillCommand, "", NULL },
@ -1110,7 +1110,7 @@ void ChatHandler::ExecuteCommand(const char* text)
case CHAT_COMMAND_OK:
{
SetSentErrorMessage(false);
if ((this->*(command->Handler))(text))
if ((this->*(command->Handler))((char*)text)) // text content destroyed at call
{
if (command->SecurityLevel > SEC_PLAYER)
{

784
src/game/Chat.h
View file

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

26
src/game/Level0.cpp
View file

@ -30,7 +30,7 @@
#include "revision_nr.h"
#include "Util.h"
bool ChatHandler::HandleHelpCommand(const char* args)
bool ChatHandler::HandleHelpCommand(char* args)
{
if(!*args)
{
@ -46,13 +46,13 @@ bool ChatHandler::HandleHelpCommand(const char* args)
return true;
}
bool ChatHandler::HandleCommandsCommand(const char* /*args*/)
bool ChatHandler::HandleCommandsCommand(char* /*args*/)
{
ShowHelpForCommand(getCommandTable(), "");
return true;
}
bool ChatHandler::HandleAccountCommand(const char* args)
bool ChatHandler::HandleAccountCommand(char* args)
{
// let show subcommands at unexpected data in args
if (*args)
@ -63,7 +63,7 @@ bool ChatHandler::HandleAccountCommand(const char* args)
return true;
}
bool ChatHandler::HandleStartCommand(const char* /*args*/)
bool ChatHandler::HandleStartCommand(char* /*args*/)
{
Player *chr = m_session->GetPlayer();
@ -86,7 +86,7 @@ bool ChatHandler::HandleStartCommand(const char* /*args*/)
return true;
}
bool ChatHandler::HandleServerInfoCommand(const char* /*args*/)
bool ChatHandler::HandleServerInfoCommand(char* /*args*/)
{
uint32 activeClientsNum = sWorld.GetActiveSessionCount();
uint32 queuedClientsNum = sWorld.GetQueuedSessionCount();
@ -110,7 +110,7 @@ bool ChatHandler::HandleServerInfoCommand(const char* /*args*/)
return true;
}
bool ChatHandler::HandleDismountCommand(const char* /*args*/)
bool ChatHandler::HandleDismountCommand(char* /*args*/)
{
//If player is not mounted, so go out :)
if (!m_session->GetPlayer( )->IsMounted())
@ -132,7 +132,7 @@ bool ChatHandler::HandleDismountCommand(const char* /*args*/)
return true;
}
bool ChatHandler::HandleSaveCommand(const char* /*args*/)
bool ChatHandler::HandleSaveCommand(char* /*args*/)
{
Player *player=m_session->GetPlayer();
@ -152,7 +152,7 @@ bool ChatHandler::HandleSaveCommand(const char* /*args*/)
return true;
}
bool ChatHandler::HandleGMListIngameCommand(const char* /*args*/)
bool ChatHandler::HandleGMListIngameCommand(char* /*args*/)
{
std::list< std::pair<std::string, bool> > names;
@ -183,7 +183,7 @@ bool ChatHandler::HandleGMListIngameCommand(const char* /*args*/)
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)
if (!GetAccountId())
@ -196,7 +196,7 @@ bool ChatHandler::HandleAccountPasswordCommand(const char* args)
if(!*args)
return false;
char *old_pass = strtok ((char*)args, " ");
char *old_pass = strtok (args, " ");
char *new_pass = strtok (NULL, " ");
char *new_pass_c = strtok (NULL, " ");
@ -242,7 +242,7 @@ bool ChatHandler::HandleAccountPasswordCommand(const char* args)
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)
if (!GetAccountId())
@ -258,7 +258,7 @@ bool ChatHandler::HandleAccountLockCommand(const char* args)
return true;
}
std::string argstr = (char*)args;
std::string argstr = args;
if (argstr == "on")
{
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
bool ChatHandler::HandleServerMotdCommand(const char* /*args*/)
bool ChatHandler::HandleServerMotdCommand(char* /*args*/)
{
PSendSysMessage(LANG_MOTD_CURRENT, sWorld.GetMotd());
return true;

251
src/game/Level1.cpp
View file

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

370
src/game/Level2.cpp
View file

File diff suppressed because it is too large Load diff

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

54
src/mangosd/CliRunnable.cpp
View file

@ -59,20 +59,20 @@ void commandFinished(void*, bool sucess)
/// 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
bool ChatHandler::HandleAccountDeleteCommand(const char* args)
bool ChatHandler::HandleAccountDeleteCommand(char* args)
{
if (!*args)
return false;
std::string account_name;
uint32 account_id = extractAccountId((char*)args,&account_name);
uint32 account_id = extractAccountId(args, &account_name);
if (!account_id)
return false;
/// Commands not recommended call from chat, but support anyway
/// can delete only for account with less security
/// This is also reject self apply in fact
if(HasLowerSecurityAccount (NULL,account_id,true))
if (HasLowerSecurityAccount (NULL, account_id, true))
return false;
AccountOpResult result = sAccountMgr.DeleteAccount(account_id);
@ -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
*/
bool ChatHandler::HandleCharacterDeletedListCommand(const char* args)
bool ChatHandler::HandleCharacterDeletedListCommand(char* args)
{
DeletedInfoList foundList;
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
*/
bool ChatHandler::HandleCharacterDeletedRestoreCommand(const char* args)
bool ChatHandler::HandleCharacterDeletedRestoreCommand(char* args)
{
// It is required to submit at least one argument
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
*/
bool ChatHandler::HandleCharacterDeletedDeleteCommand(const char* args)
bool ChatHandler::HandleCharacterDeletedDeleteCommand(char* args)
{
// It is required to submit at least one argument
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
*/
bool ChatHandler::HandleCharacterDeletedOldCommand(const char* args)
bool ChatHandler::HandleCharacterDeletedOldCommand(char* args)
{
int32 keepDays = sWorld.getConfig(CONFIG_UINT32_CHARDELETE_KEEP_DAYS);
char* px = strtok((char*)args, " ");
if (px)
if (char* px = strtok(args, " "))
{
if (!isNumeric(px))
return false;
@ -415,12 +414,12 @@ bool ChatHandler::HandleCharacterDeletedOldCommand(const char* args)
return true;
}
bool ChatHandler::HandleCharacterEraseCommand(const char* args)
bool ChatHandler::HandleCharacterEraseCommand(char* args)
{
if(!*args)
if (!*args)
return false;
char *character_name_str = strtok((char*)args," ");
char *character_name_str = strtok(args," ");
if(!character_name_str)
return false;
@ -431,8 +430,7 @@ bool ChatHandler::HandleCharacterEraseCommand(const char* args)
uint64 character_guid;
uint32 account_id;
Player *player = sObjectMgr.GetPlayer(character_name.c_str());
if(player)
if (Player *player = sObjectMgr.GetPlayer(character_name.c_str()))
{
character_guid = player->GetGUID();
account_id = player->GetSession()->GetAccountId();
@ -460,7 +458,7 @@ bool ChatHandler::HandleCharacterEraseCommand(const char* args)
}
/// Close RA connection
bool ChatHandler::HandleQuitCommand(const char* /*args*/)
bool ChatHandler::HandleQuitCommand(char* /*args*/)
{
// processed in RASocket
SendSysMessage(LANG_QUIT_WRONG_USE_ERROR);
@ -468,7 +466,7 @@ bool ChatHandler::HandleQuitCommand(const char* /*args*/)
}
/// Exit the realm
bool ChatHandler::HandleServerExitCommand(const char* /*args*/)
bool ChatHandler::HandleServerExitCommand(char* /*args*/)
{
SendSysMessage(LANG_COMMAND_EXIT);
World::StopNow(SHUTDOWN_EXIT_CODE);
@ -476,10 +474,10 @@ bool ChatHandler::HandleServerExitCommand(const char* /*args*/)
}
/// 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;
uint32 limit = limit_str ? atoi (limit_str) : 100;
char* limit_str = *args ? strtok(args, " ") : NULL;
uint32 limit = limit_str ? atoi(limit_str) : 100;
///- Get the list of accounts ID logged to the realm
// 0 1 2 3 4
@ -489,13 +487,13 @@ bool ChatHandler::HandleAccountOnlineListCommand(const char* args)
}
/// Create an account
bool ChatHandler::HandleAccountCreateCommand(const char* args)
bool ChatHandler::HandleAccountCreateCommand(char* args)
{
if(!*args)
if (!*args)
return false;
///- %Parse the command line arguments
char *szAcc = strtok((char*)args, " ");
char *szAcc = strtok(args, " ");
char *szPassword = strtok(NULL, " ");
if(!szAcc || !szPassword)
return false;
@ -532,9 +530,9 @@ bool ChatHandler::HandleAccountCreateCommand(const char* args)
}
/// Set the filters of logging
bool ChatHandler::HandleServerLogFilterCommand(const char* args)
bool ChatHandler::HandleServerLogFilterCommand(char* args)
{
if(!*args)
if (!*args)
{
uint32 logfiler = sLog.getLogFilter();
@ -545,7 +543,7 @@ bool ChatHandler::HandleServerLogFilterCommand(const char* args)
return true;
}
char *filtername = strtok((char*)args, " ");
char *filtername = strtok(args, " ");
if (!filtername)
return false;
@ -589,15 +587,15 @@ bool ChatHandler::HandleServerLogFilterCommand(const char* args)
}
/// Set the level of logging
bool ChatHandler::HandleServerLogLevelCommand(const char *args)
bool ChatHandler::HandleServerLogLevelCommand(char *args)
{
if(!*args)
if (!*args)
{
PSendSysMessage("Log level: %u", sLog.GetLogLevel());
return true;
}
sLog.SetLogLevel((char*)args);
sLog.SetLogLevel(args);
return true;
}

2
src/shared/revision_nr.h
View file

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