1. #include "chat.h"
  2. #include "Config.h"
  3. #include "math.h"
  4. #include "player.h"
  5. #include "RBAC.h"
  6. #include "ScriptMgr.h"
  7. #include "World.h"
  9. /*
  10. * Main command class.
  11. */
  12. class PremCommand
  13. {
  14. public:
  15. PremCommand(const char* _info) : info(_info) { }
  17. void handleHelpCommand(ChatHandler* handler)
  18. {
  19. handler->PSendSysMessage(info);
  20. }
  22. virtual void handleCommand(ChatHandler* handler, Player* player) = 0;
  23. private:
  24. const char* info;
  25. };
  26. /*
  27. * Sub command class(es).
  28. */
  29. class DrinkCommand : public PremCommand
  30. {
  31. public:
  32. DrinkCommand(const char* _info) : PremCommand(_info) { }
  34. void handleCommand(ChatHandler* handler, Player* player)
  35. {
  36. uint8 drink = player->GetDrunkValue();
  37. player->SetDrunkValue(drink + 5);
  38. handler->PSendSysMessage("!Down the hatch!");
  39. }
  40. };
  42. class DrunkCommand : public PremCommand
  43. {
  44. public:
  45. DrunkCommand(const char* _info) : PremCommand(_info) { }
  47. void handleCommand(ChatHandler* handler, Player* player)
  48. {
  49. player->SetDrunkValue(100);
  50. handler->PSendSysMessage("!You drunk!");
  51. }
  52. };
  54. class SoberCommand : public PremCommand
  55. {
  56. public:
  57. SoberCommand(const char* _info) : PremCommand(_info) { }
  59. void handleCommand(ChatHandler* handler, Player* player)
  60. {
  61. player->SetDrunkValue(1);
  62. handler->PSendSysMessage("You're now sober..");
  63. }
  64. };
  66. std::map<std::string, PremCommand*> command_map;
  68. class Premium_Commands : public CommandScript
  69. {
  70. public:
  71. Premium_Commands() : CommandScript("Premium_Commands")
  72. {
  73. // Setting up the commands.
  74. if (command_map.empty())
  75. {
  76. command_map["drink"] = new DrinkCommand("Allows the player to increase +5 to drunk.");
  77. command_map["drunk"] = new DrunkCommand("Allows the player become 100 drunk.");
  78. command_map["sober"] = new SoberCommand("Allows the player to become sober.");
  79. }
  80. }
  82. std::vector<ChatCommand> GetCommands() const
  83. {
  84. static std::vector<ChatCommand> commandTable =
  85. {
  86. { "premium", rbac::RBAC_IN_GRANTED_LIST, true, &handlePremiumCommand, "Premium custom commands." },
  87. };
  88. return commandTable;
  89. }
  90. /*
  91. * Main command handler. This will be executed, before any of the sub command handlers.
  92. * It uses polymorphism to map the commands.
  93. */
  94. static bool handlePremiumCommand(ChatHandler* handler, const char* args)
  95. {
  96. Player* player = handler->GetSession()->GetPlayer();
  97. // Dummy code, replace with original code..
  98. bool premium = true;
  99. if (!premium)
  100. return false;
  102. std::vector<char*> arguments = getArguments(args);
  103. if (arguments.size() == 0)
  104. return false;
  106. std::string command = arguments[0];
  107. arguments.erase(arguments.begin());
  109. PremCommand* commandHandler = command_map[command];
  110. if (commandHandler == NULL)
  111. return false;
  113. commandHandler->handleCommand(handler, player);
  115. return true;
  116. }
  118. private:
  119. /*
  120. * Method to convert the argument string to a vector.
  121. */
  122. static std::vector<char*> getArguments(const char* args)
  123. {
  124. std::vector<char*> arguments;
  125. // Extracting the arguments and push them to the vector.
  126. char* arg = strtok((char*)args, " ");
  127. while (arg != NULL)
  128. {
  129. arguments.push_back(arg);
  130. arg = strtok((char*)NULL, " ");
  131. }
  132. return arguments;
  133. }
  134. };
  136. void AddSC_Premium_System()
  137. {
  138. new Premium_Commands;
  139. }