src/Core/Editor.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008 by Sverre Rabbelier                                *
   3  *   sverre@rabbelier.nl                                                   *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 3 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include <stdarg.h>
  22
  23 #include "Editor.h"
  24 #include "Parse.h"
  25 #include "Permission.h"
  26 #include "PermissionManager.h"
  27 #include "Command.h"
  28 #include "CommandManager.h"
  29 #include "UBSocket.h"
  30 #include "Account.h"
  31 #include "Global.h"
  32 #include "StringUtilities.h"
  33 #include "Channel.h"
  34
  35 using mud::Permission;
  36 using mud::Command;
  37
  38 Editor::Editor(UBSocket* sock) :
  39 m_sock(sock)
  40 {
  41         Assert(sock);
  42 }
  43
  44 Editor::~Editor()
  45 {
  46
  47 }
  48
  49 std::string Editor::prompt()
  50 {
  51         return Global::Get()->EmptyString;
  52 }
  53
  54 std::string Editor::lookup(const std::string& action)
  55 {
  56         return Global::Get()->EmptyString;
  57 }
  58
  59 void Editor::Send(const std::string& msg)
  60 {
  61         m_sock->Send(msg);
  62 }
  63
  64 void Editor::Sendf(const char* format, ...)
  65 {
  66         va_list args;
  67         va_start(args, format);
  68         Send(Global::Get()->sprint(args, format));
  69         va_end(args);
  70 }
  71
  72 void Editor::Disconnect()
  73 {
  74         m_sock->SetCloseAndDelete();
  75 }
  76
  77 void Editor::OnLine(const std::string& line)
  78 {
  79         Parse p(line);
  80         std::string rawaction = p.getword();
  81         std::string action = String::Get()->tolower(rawaction);
  82
  83         bool helpLookup = false;
  84
  85         if(!action.compare("help"))
  86         {
  87                 helpLookup = true;
  88                 rawaction = p.getword();
  89                 action = String::Get()->tolower(rawaction);
  90
  91                 if(!action.compare("help"))
  92                 {
  93                         Send("Syntax: help <command>\n");
  94                         Send("This command will lookup information on <command> and display it.\n");
  95                         return;
  96                 }
  97         }
  98
  99         std::string argument = p.getrest();
 100         std::string actionname = lookup(action);
 101
 102         if(actionname.size() == 0)
 103         {
 104                 // TODO: Log failure?
 105                 Sendf("Unknown action '%s', type ? for a list of available actions.\n", action.c_str());
 106                 return;
 107         }
 108
 109         std::string commandname = name();
 110         commandname.append("::");
 111         commandname.append(actionname);
 112
 113         bool hasGrant = mud::PermissionManager::Get()->defaultGrant;
 114         bool hasLog = mud::PermissionManager::Get()->defaultLog;
 115
 116         bool canLowForce = mud::CommandManager::Get()->defaultLowForce;
 117         bool canForce = mud::CommandManager::Get()->defaultForce;
 118         bool canHighForce = mud::CommandManager::Get()->defaultHighForce;
 119
 120         bool isLowForced = m_sock->isLowForced();
 121         bool isNormalForced = m_sock->isForced();
 122         bool isHighForced = m_sock->isHighForced();
 123         bool isForced = isLowForced || isNormalForced || isHighForced;
 124
 125         try
 126         {
 127                 long id = mud::CommandManager::Get()->lookupByName(commandname);
 128                 mud::CommandPtr cmd = mud::CommandManager::Get()->GetByKey(id);
 129
 130                 if(helpLookup)
 131                 {
 132                         std::string help = cmd->getHelp();
 133                         if(help.size() == 0)
 134                         {
 135                                 Sendf("Sorry, we do not have help available on '%s'.\n", action.c_str());
 136                                 return;
 137                         }
 138
 139                         Sendf("We have the following information on '%s':\n", action.c_str());
 140                         Send(help);
 141                         Send("\n\n");
 142                         return;
 143                 }
 144
 145                 hasGrant = cmd->getGrant(m_sock);
 146                 hasLog = cmd->getLog(m_sock);
 147
 148                 if(isForced)
 149                 {
 150                         canHighForce = cmd->canHighForce();
 151                         canForce = cmd->canForce();
 152                         canLowForce = cmd->canLowForce();
 153                 }
 154         }
 155         catch(RowNotFoundException& e)
 156         {
 157                 if(helpLookup)
 158                 {
 159                         Sendf("Sorry, '%s' has not yet been added to the database, as a result no help is available for it yet.\n", action.c_str());
 160                         return;
 161                 }
 162         }
 163
 164
 165         if(isForced)
 166         {
 167                 if(isLowForced && !canLowForce)
 168                 {
 169                         m_sock->GetForcer()->Sendf("You can't make them to '%s'!\n", action.c_str());
 170                         return;
 171                 }
 172
 173                 if(isForced && !canForce)
 174                 {
 175                         m_sock->GetForcer()->Sendf("You can't force them to '%s'!\n", action.c_str());
 176                         return;
 177                 }
 178
 179                 if(isHighForced && !canHighForce)
 180                 {
 181                         m_sock->GetForcer()->Sendf("There is no way you can make them '%s'!\n", action.c_str());
 182                         return;
 183                 }
 184         }
 185
 186         if(hasGrant)
 187         {
 188                 if(hasLog || isForced)
 189                 {
 190                         if(isForced)
 191                         {
 192                                 // TODO log
 193                         }
 194                         else
 195                         {
 196                                 // TODO log
 197                         }
 198                 }
 199
 200                 dispatch(action, argument);
 201                 return;
 202         }
 203         else
 204         {
 205                 if(hasLog || isForced)
 206                 {
 207                         if(isForced)
 208                         {
 209                                 m_sock->GetForcer()->Sendf("They are not allowed to '%s'!\n", action.c_str());
 210                                 // TODO log
 211                         }
 212                         else
 213                         {
 214
 215                                 // TODO log
 216                         }
 217                 }
 218
 219                 Sendf("Sorry, you do not have permission to '%s'.\n", actionname.c_str());
 220                 return;
 221         }
 222 }
 223
 224 bool Editor::canReceiveChannel(mud::ChannelPtr channel) const
 225 {
 226         return true;
 227 }
 228
 229 bool Editor::supportPrefixes() const
 230 {
 231         return true;
 232 }