fixed a dragon bug where people could quit while they are fighting the dragon, come...

[irc/gameservirc.git] / gameserv / gameserv.cpp

#include "aClient.h"
#include "config.h"
#include "extern.h"
#include "player.h"
#include "pouch.h"
#include "flags.h"
#include "list.h"
#include "level.h"
#include "sockhelp.h"
#include "item.h"

#include <cctype>
#include <fstream>
#include <stdlib.h>
#include <list>
#include <iterator>

using namespace std;

#if defined(HAVE_CRYPT_H)

#include <crypt.h>

#elif defined(HAVE_UNISTD_H)

#include <unistd.h> 

#endif

Monster dragon;                         // The current dragon
Level levels[LEVELS];                   // The newest way to store monsters
list<item*> Items;                      // The master list of items
list<tavernItem> tavern;                // The list of items available at the tavern
list<item*> store;                      // The list of items available at the store

// Database functions
int save_gs_dbase();
int load_gs_dbase();
int load_items();
int load_tavern();
int load_store();
int load_dragon();
int save_dragon();

item *findItemByID(int id);
item *findStoreItemByID(int id);
tavernItem *findTavernItemByID(int id);

// String functions
#ifndef HAVE_STRTOK
char *strtok(char *str, const char *delim);
#endif

int stricmp(const char *s1, const char *s2);
int strnicmp(const char *s1, const char *s2, size_t len);
// String Functions

/********** Password functions **********/

bool passcmp(const char *encrypted, char *plaintext); // Compares an encrypted pass with a plain text one

bool check_password(char *name, char *plaintext); // Finds a password for the given name, and checks it with passcmp against the plaintext password given.

/********** Password functions **********/


/********** GameServ Booleans **********/

bool shuttingdown;
bool timedOut(Player *p);
void updateTS(Player *p);
void timeOutEvent(Player *p);

bool is_playing(char *u); // True if the given nickname in the clients list is playing.
bool is_playing(aClient *user);

bool is_fighting(char *u); // True if the given nick in the clients list is fighting anything.
bool is_fighting(aClient *user);

bool player_fight(char *u); // True if the player is fighting another player.
bool player_fight(aClient *user);

bool master_fight(char *u); // True if the player is fighting their master.
bool master_fight(aClient *user);

bool dragon_fight(char *u); // True if the player is fighting the dragon.
bool dragon_fight(aClient *user);

bool alphaNumeric(const char *str); // Returns true if all of the characters in str are alphanumeric non-special chars
/********** GameServ Booleans **********/

void display_help(char *u, char *file = NULL);
void display_monster(char *u);
void display_players(char *u);
void display_players(aClient *user);
long int chartoint(char ch);
int isstringnum(char *num);
long int pow (int x, int y);
long int stringtoint(char *number);

char *spaces(int len, char *seperator);
void refresh(Player *p);
void refreshall();
void rollover(Player *p);
void rolloverall();

void updateTS(Player *p);
void reset(Player *p);
bool load_masters();
bool load_monsters();
bool load_levels();
void delete_monsters();

void do_admin(char *u);
void do_attack(char *u);
void do_bank(char *u);
void do_check(char *u);
void do_equip(char *u);
void do_fight(char *u);
void do_heal(char *u);
void do_help(char *u);
void do_identify(char *u);
void do_inventory(char *u);
void do_refresh(char *u);
void do_register(char *u);
void do_list(char *u);
void do_logout(char *u);
void do_master(char *u);
void do_dragon(char *u);
void do_play(char *u);
void do_quitg(char *u);
void do_reset(char *u);
void do_run(char *u);
void do_set(char *u);
void do_stats(char *u);
void do_store(char *u);
void do_tavern(char *u);
void do_use(char *u);
void see_master(char *u);

void logout(aClient *user);
void showstats(const char *u, const char *nick);
void showTavern(aClient *user);
void showinventory(Player *from, aClient *to);
void showBankBalance(const char *u);
void end_turn(aClient *user);

#define WNA 16

int hpbonus[11] = {10, 15, 20, 30, 50, 75, 125, 185, 250, 350, 550};
int strbonus[11] = {5, 7, 10, 12, 20, 35, 50, 75, 110, 150, 200};
int defbonus[11] = {2, 3, 5, 10, 15, 22, 35, 60, 80, 120, 150};

void gameserv(char *source, char *buf)
{
    char *cmd, z;
    cmd = strtok(buf, " ");

    #ifndef P10
        source++; // Get rid of that : at the beginning of a :Nick privmsg Gameserv :text
    #endif

    z = cmd[0];
    if (z == ':')
        cmd++;    // Get rid of that : at the beginning of the :text  (command)

    #ifdef DEBUGMODE
        log("Source: %s  Command: %s", source, cmd);
    #endif

    if (strnicmp(cmd, "\1PING", 6) == 0)
    {
        char *ts;
        ts = strtok(NULL, "\1");
        notice(s_GameServ, source, "\1PING %s\1", ts);
    } else if (stricmp(cmd, "\1VERSION\1") == 0) {
        notice(s_GameServ, source, "\1VERSION %s %s\1", PACKAGE, VERSION);
    } else if (stricmp(cmd, "SEARCH") == 0) {
        cmd = strtok(NULL, " ");

        if (!cmd)
            notice(s_GameServ, source, "SYNTAX: /msg %S SEARCH FOREST");
        else
            do_forest(source);

    } else if (stricmp(cmd, "ADMIN") == 0) {
        do_admin(source);
    } else if (stricmp(cmd, "ATTACK") == 0) {
        do_attack(source);
    } else if (stricmp(cmd, "BANK") == 0) {
        do_bank(source);
    } else if (stricmp(cmd, "CHECK") == 0) {
        do_check(source);
    } else if (stricmp(cmd, "DRAGON") == 0) {
        do_dragon(source);
    } else if (stricmp(cmd, "EQUIP") == 0) {
      do_equip(source);
    } else if (stricmp(cmd, "FIGHT") == 0) {
        do_fight(source);
    } else if (stricmp(cmd, "HEAL") == 0) {
        do_heal(source);
    } else if (stricmp(cmd, "HELP") == 0) {
        do_help(source);
    } else if (stricmp(cmd, "IDENTIFY") == 0) {
        do_identify(source);
    } else if (stricmp(cmd, "INVENTORY") == 0) {
        do_inventory(source);
    } else if (stricmp(cmd, "LIST") == 0) {
        do_list(source);
    } else if (stricmp(cmd, "LOGOUT") == 0) {
        do_logout(source);
    } else if (stricmp(cmd, "MASTER") == 0) {
        do_master(source);
    } else if (stricmp(cmd, "NEWS") == 0) {
        do_news(source);
    } else if (stricmp(cmd, "REGISTER") == 0) {
        do_register(source);
    } else if (stricmp(cmd, "REFRESH") == 0) {
        do_refresh(source);
    } else if (stricmp(cmd, "RESET") == 0) {
        do_reset(source);
    } else if (stricmp(cmd, "RUN") == 0) {
        do_run(source);
    } else if (stricmp(cmd, "SET") == 0) {
        do_set(source);
    } else if (stricmp(cmd, "STATS") == 0) {
        do_stats(source);
    } else if (stricmp(cmd, "STORE") == 0) {
        do_store(source);
    } else if (stricmp(cmd, "TAVERN") == 0) {
        do_tavern(source);
    } else if (stricmp(cmd, "USE") == 0) {
        do_use(source);
    } else if (stricmp(cmd, "SHUTDOWN") == 0) {
        aClient *user;

        if (!(user = find(source)))
        {
            notice(s_GameServ, source, "Error: aClient not found. Contact a %S admin");
                log("Error: aClient not found: %s", source);
        }
        else if (!isAdmin(user))
        {
            notice(s_GameServ, source, "You must be a %S admin to use this command!");
        }
        else
        {
            save_gs_dbase();
            #ifdef P10
                raw("[] SQ %s 0 :leaving: %s used the Shutdown command.", servername, user->getRealNick());
            #else
                raw("SQUIT %s :leaving: %s used the Shutdown command.", servername, source);
            #endif
            shuttingdown = true;
        }
    } else if (stricmp(cmd, "SAVE") == 0) {
        aClient *user;

        if (!(user = find(source)))
        {
            notice(s_GameServ, source, "Error: aClient not found. Contact a %S admin");
                log("Error: aClient not found: %s", source);
        }
        else if (!isAdmin(user))
        {
            notice(s_GameServ, source, "You must be a %S admin to use this command!");
        }
        else
        {
            save_gs_dbase();
        }
    } else if (stricmp(cmd, "LOAD") == 0) {
        aClient *user;

        if (!(user = find(source)))
        {
            notice(s_GameServ, source, "Error: aClient not found. Contact a %S admin");
            log("Error: aClient not found: %s", source);
        }
        else if (!isAdmin(user))
        {
            notice(s_GameServ, source, "You must be a %S admin to use this command!");
        }
        else
        {
            char *cmd2 = strtok(NULL, " ");
            if (!cmd2)
            {
                notice(s_GameServ, source, "Loading player data from %s", playerdata);
                load_gs_dbase();
            }
            else if (stricmp(cmd2, "MONSTERS") == 0)
            {
                notice(s_GameServ, source, "Loading monster data");
                load_monsters();
            }
            else
                display_help(source, cmd);
        }
    #ifdef DEBUGMODE
    } else if (stricmp(cmd, "RAW") == 0) {
        aClient *user;

        if (!(user = find(source)))
        {
            notice(s_GameServ, source, "Error: aClient not found. Contact a %S admin");
                log("Error: aClient not found: %s", source);
        }
        else if (!isAdmin(user))
        {
            notice(s_GameServ, source, "You must be a %S admin to use this command!");
        }
        else
        {
            char *rest = strtok(NULL, "");
            raw("%s", rest);
        }
    } else if (stricmp(cmd, "PRINT") == 0) {
        for (int x = 0; x < LEVELS; x++)
            levels[x].monsters.print();
    } else if (stricmp(cmd, "RANDOM") == 0) {
        char *rstr = strtok(NULL, "");
        range trange;
        trange.setRange(rstr);
        notice(s_GameServ, source, "Random number in that range: %d", trange.random());
    #endif
    } else {
        aClient *user;
        if ((user = find(source)))
        {
            if (isIgnore(user))
            {
                #ifdef DEBUGMODE
                    log("Ignoring %s.", user->getNick());
                #endif
            }
            else
            {
                notice(s_GameServ, source, "Unknown command \002%s\002. Type /msg %S \002HELP\002 to get a list of commands.", cmd);
            }
        }
    } 

    #ifndef P10
        source--;  // Bring the ':' back so we don't leak memory
    #endif
    if (z == ':')
        cmd--;     // Same thing :)
}

int stricmp(const char *s1, const char *s2)
{
    register int c;

    while ((c = tolower(*s1)) == tolower(*s2)) {
        if (c == 0)
            return 0;
        s1++;
        s2++;
    }
    if (c < tolower(*s2))
        return -1;
    return 1;
}

void showstats(const char *u, const char *nick)
{
    aClient *ni, *sender = find(u);
    char *buf;
    buf = new char[50];
    char *space;


    if (!(ni = findplayer(nick)))
          {
        notice(s_GameServ, u, "%s not found", nick);
          }
    else if (ni->stats)
          {
        notice(s_GameServ, sender->getNick(), "Stats for %s:", ni->stats->getName().c_str());
                
        sprintf(buf, "Experience: %ld", ni->stats->getExp());
        space = spaces(strlen(buf), " ");
        notice(s_GameServ, sender->getNick(), "%s%sLevel: %d",  buf, space,
                           ni->stats->getLevel());
        delete [] space;
                
        sprintf(buf, "Gold: %ld", ni->stats->getGold());
        space = spaces(strlen(buf), " ");
        notice(s_GameServ, sender->getNick(), "%s%sGold in Bank: %ld", buf, space, ni->stats->getBank());
        delete [] space;
                
        notice(s_GameServ, sender->getNick(), "Hit Points: %d of %d", ni->stats->getHP(),
                           ni->stats->getMaxHP());
                
        sprintf(buf, "Strength: %d", ni->stats->getStrength());
        space = spaces(strlen(buf), " ");
        notice(s_GameServ, sender->getNick(), "%s%sDefense: %d",
                           buf, space, ni->stats->getDefense());
        delete [] space;
                
        sprintf(buf, "Armor: %s", (ni->stats->getArmor() ? ni->stats->getArmor()->getName().c_str() : "Nothing"));
        space = spaces(strlen(buf), " ");
                
        notice(s_GameServ, sender->getNick(), "%s%sWeapon: %s", buf, space,
                           (ni->stats->getWeapon() ? ni->stats->getWeapon()->getName().c_str() : "Fists"));
                
        delete [] space;
                
        sprintf(buf, "Forest Fights: %d", ni->stats->getForestFights());
        space = spaces(strlen(buf), " ");
        notice(s_GameServ, sender->getNick(), "%s%sPlayer Fights: %d", buf, space, ni->stats->getPlayerFights());
        delete [] space;
                if (ni == sender || isAdmin(sender))
                  {
                        showinventory(ni->stats, sender);
                  }
          }
    else
          {
                notice(s_GameServ, u, "%s is not playing!", ni->stats->getName().c_str());
          }
    delete [] buf;
}

char *spaces(int len, char *seperator)
{
    char *final;
    final = new char[30];
    int y;
    strcpy(final, seperator);
    for (y = 0; y < 30 - len; y++)
        strcat(final, seperator);
    return final;
}

void raw(const char *fmt, ...)
{
    va_list args;
    char *input;
    const char *t = fmt;
    input = new char[1024];
    va_start(args, fmt);
    memset(input, 0, sizeof(input)); // Initialize to NULL
    for (; *t; t++)
    {
        if (*t == '%')
        {
            switch(*++t) {
                case 'd': sprintf(input, "%s%d", input, va_arg(args, int)); break;
                case 's': sprintf(input, "%s%s", input, va_arg(args, char *)); break;
                case 'S': sprintf(input, "%s%s", input, s_GameServ); break;
                case 'l':
                   if (*++t == 'd')
                          sprintf(input, "%s%ld", input, va_arg(args, long int)); break;
            }
        }
        else
        {
            sprintf(input, "%s%c", input, *t);
        }

    }
    #ifdef DEBUGMODE
        log("Input: %s", input);
    #endif

    sprintf(input, "%s%s", input, "\r\n");
    sock_puts(sock, input);
    delete [] input;
    va_end(args);
}
/* Send a NOTICE from the given source to the given nick. */

void notice(const char *source, const char *dest, const char *fmt, ...)
{
    if (fmt[0] == '\0')
        return;

    char *commanduse;
    commanduse = new char[16];

    #ifdef P10
        if (isUsePrivmsg())
            strcpy(commanduse, "P");
        else
            strcpy(commanduse, "O");
    #else

        if (isUsePrivmsg())
            strcpy(commanduse, "PRIVMSG");
        else
            strcpy(commanduse, "NOTICE");
    #endif

    va_list args;
    char *input;
    const char *t = fmt;
    input = new char[1024];
    va_start(args, fmt);
    if (dest[0] == ':')
    {
        dest++;

      #if !defined(P10)
        sprintf(input, ":%s %s %s :", source, commanduse, dest);
      #else
        sprintf(input, "%s %s %s :", gsnum, commanduse, dest);
      #endif

        dest--;
    }
    else
    {
      #if !defined(P10)
        sprintf(input, ":%s %s %s :", source, commanduse, dest);
      #else
        sprintf(input, "%s %s %s :", gsnum, commanduse, dest);
      #endif
    }

    for (; *t; t++)
    {
        if (*t == '%')
        {
            switch(*++t) {
                case 'd': sprintf(input, "%s%d", input, va_arg(args, int)); break; 
                case 's': sprintf(input, "%s%s", input, va_arg(args, char *)); break;
                case 'S': sprintf(input, "%s%s", input, s_GameServ); break;
                case 'c': sprintf(input, "%s%c", input, va_arg(args, int)); break;
                case 'l':
                   if (*++t == 'd')
                          sprintf(input, "%s%ld", input, va_arg(args, long int)); break;
            }
        }
        else
        {
            sprintf(input, "%s%c", input, *t);
        }

    }
    #ifdef DEBUGMODE
        log("Input: %s", input);
    #endif
    sprintf(input, "%s%s", input, "\r\n");
    sock_puts(sock, input);
    delete [] commanduse;
    delete [] input;
va_end(args);
}


int strnicmp(const char *s1, const char *s2, size_t len)
{
    register int c;

    if (!len)
        return 0;
    while ((c = tolower(*s1)) == tolower(*s2) && len > 0) {
        if (c == 0 || --len == 0)
            return 0;
        s1++;
        s2++;
    }
    if (c < tolower(*s2))
        return -1;
    return 1;
}

#ifndef HAVE_STRTOK
char *strtok(char *str, const char *delim)
{
    static char *current = NULL;
    char *ret;

    if (str)
        current = str;
    if (!current)
        return NULL;
    current += strspn(current, delim);
    ret = *current ? current : NULL;
    current += strcspn(current, delim);
    if (!*current)
        current = NULL;
    else
        *current++ = 0;
    return ret;
}
#endif

void do_check(char *u)
{
    int days, hours, minutes, seconds;
    long complete;
    complete = (lastrefresh + refreshperiod) - time(NULL);
    days = complete / 86400;
    hours = (complete % 86400) / 3600;
    minutes = (complete % 86400) % 3600 / 60;
    seconds = (complete % 86400) % 3600 % 60;

    notice(s_GameServ, u, "Time left to next refresh: %dd %dh %dm %ds", 
           days, hours, minutes, seconds);

    if (isRolloverForestFights())
      {
        complete = (lastrollover + rolloverperiod) - time(NULL);
        
        days = complete / 86400;
        hours = (complete % 86400) / 3600;
        minutes = (complete % 86400) % 3600 / 60;
        seconds = (complete % 86400) % 3600 % 60;
        
        notice(s_GameServ, u, "Time left to next rollover: %dd %dh %dm %ds",
               days, hours, minutes, seconds);
      }
}

void do_list(char *u)
{
    aClient *user;
    char *cmd = strtok(NULL, " ");

    if (!(user = find(u)))
    {
        log("Fatal Error: Couldn't find %s in the client list", u);
        return;
    }
    else if (isIgnore(user))
    {
        #ifdef DEBUGMODE
            log("Ignoring %s. Command LIST", user->getNick());
        #endif
        return;
    }

    ListNode<aClient> *temp;
    bool header = false;

  for (unsigned long x = 0; x < U_TABLE_SIZE; x++)
  {
    temp = players[x].First();
    if (!players[x].isEmpty())
    {
        while(temp)
        {
            if (cmd || is_playing(temp->getData()))
            {
                if (!header)
                {
                    notice(s_GameServ, u, "Players:");
                    header = true;
                }
                #ifdef P10
                notice(s_GameServ, u, "IRC: %s     Game: %s", temp->getData()->getRealNick(), 
                        temp->getData()->stats->getName().c_str());
                #else
                notice(s_GameServ, u, "IRC: %s     Game: %s", temp->getData()->getNick(), 
                        temp->getData()->stats->getName().c_str());
                #endif
            }

            temp = temp->Next();
        }
    }
   }
    if (!header)
        notice(s_GameServ, u, "No one is playing");
    else
        notice(s_GameServ, u, "End of List");

}
void do_set(char *u)
{
  aClient *user, *target;
  char *name = strtok(NULL, " ");
  char *cmd = strtok(NULL, " ");
  char *cmd2;
  
  if (!(user = find(u)))
    {
      notice(s_GameServ, u, "Fatal error. Cannot find aClient. "\
                         "Buf: %s LOGOUT", u);
      return;
    }
  else if (isIgnore(user))
    {
#ifdef DEBUGMODE
      log("Ignoring %s.", user->getNick());
#endif
      return;
    }
  else if (!name || !cmd)
    {
      notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] {PASSWORD|BANK BALANCE|PLAYER FIGHTS|FOREST FIGHTS|GOLD|STRENGTH|DEFENSE|HP|MAXHP|EXP|LEVEL|ALIVE|SEEN MASTER} {STRING|NUMBER|TRUE|FALSE}");
      return;
    }
  else if (!(target = findplayer(name)))
    {
      // Back the pointers up... they didn't send a name probably
      cmd2 = cmd;
      cmd = name;
      target = user;
          
      if (!is_playing(user))
                {
                  notice(s_GameServ, u, "You must be playing to set things for yourself!");
                  return;
                }
    }
  else
    {
      cmd2 = strtok(NULL, " ");
    }
  if (!cmd2)
        {
          notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] {PASSWORD|BANK BALANCE|PLAYER FIGHTS|FOREST FIGHTS|GOLD|STRENGTH|DEFENSE|HP|MAXHP|EXP|LEVEL|ALIVE|SEEN MASTER} {STRING|NUMBER|TRUE|FALSE}");
          return;
        }
  
  // Regardless of the previous if/else, if it got here, we know we have the cmd pointer at the right spot.
  if (stricmp(cmd, "PASSWORD") == 0)
    {
      // Person is looking to change their password
      // If they're an admin, or it's theirself, allow it
      // cmd2 is pointing to the password now
      if (isAdmin(user) || user == target)
                {
                  target->stats->setPassword(cmd2);
                  notice(s_GameServ, u, "Password successfully changed");
                }
      else if (user != target && !isAdmin(user))
                {
                  notice(s_GameServ, u, "You must be a %S admin to set other peoples' passwords.");
                  return;
                }
    }
  else if (stricmp(cmd, "BANK") == 0 || stricmp(cmd, "BALANCE") == 0)
    {
          if (!isAdmin(user))
                {
                  notice(s_GameServ, u, "Admins Only!");
                  return;
                }
          else if (stricmp(cmd, "BANK") == 0)
                {
                  cmd2 = strtok(NULL, " "); // Need an extra parameter for set bank balance
                }
          if (!cmd2)
                {
                  notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] [BANK] BALANCE <NUMBER>");
                  return;
                }
          
          target->stats->setBank(stringtoint(cmd2));
          
          notice(s_GameServ, u, "Bank balance changed to %ld!", target->stats->getBank());
    }
  else if (stricmp(cmd, "PLAYER") == 0)
    {
      if (!isAdmin(user))
                {
                  notice(s_GameServ, u, "Admins Only!");
                  return;
                }
      else if (stricmp(cmd2, "FIGHTS") != 0)
                {
                  notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] PLAYER FIGHTS <NUMBER>");
                  return;
                }
      else
                {
                  cmd2 = strtok(NULL, " ");
                  if (!cmd2)
                        {
                          notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] PLAYER FIGHTS <NUMBER>");
                          return;
                        }
                  target->stats->setPlayerFights(stringtoint(cmd2));
                  
                  notice(s_GameServ, u, "Player fights changed to %d!", target->stats->getPlayerFights());
                }         
    }
  else if (stricmp(cmd, "FOREST") == 0)
    {
      if (!isAdmin(user))
                {
                  notice(s_GameServ, u, "Admins Only!");
                  return;
                }
      else if (stricmp(cmd2, "FIGHTS") != 0)
                {
                  notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] FOREST FIGHTS <number>");
                  return;
                }
      else
                {
                  cmd2 = strtok(NULL, " ");
                  if (!cmd2)
                        {
                          notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] FOREST FIGHTS <NUMBER>");
                          return;
                        }
                  
                  target->stats->setForestFights(stringtoint(cmd2));
                  
                  notice(s_GameServ, u, "Forest fights changed to %d!", target->stats->getForestFights());
                }         
    }
  else if (stricmp(cmd, "GOLD") == 0)
        {
          if (!isAdmin(user))
                {
                  notice(s_GameServ, u, "Admins Only!");
                  return;
                }
          else
                {
                  if (!cmd2)
                        {
                          notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] GOLD <NUMBER>");
                          return;
                        }
                  target->stats->setGold(stringtoint(cmd2));
                  
                  notice(s_GameServ, u, "Gold set to %ld", target->stats->getGold());
                  return;
                }
        }
  else if (stricmp(cmd, "STRENGTH") == 0 && stricmp(cmd2, "POTIONS") != 0)
        {
          if (!isAdmin(user))
                {
                  notice(s_GameServ, u, "Admins Only!");
                  return;         
                }
          else
                {
                  if (!cmd2)
                        {
                          notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] STRENGTH <NUMBER>");
                          return;
                        }
                  
                  target->stats->setStrength(stringtoint(cmd2));
                  
                  notice(s_GameServ, u, "Strength set to %d", target->stats->getStrength());
                  return;
                }
        }
  else if (stricmp(cmd, "DEFENSE") == 0 && stricmp(cmd2, "POTIONS") != 0)
        {
          if (!isAdmin(user))
                {
                  notice(s_GameServ, u, "Admins Only!");
                  return;         
                }
          else
                {
                  if (!cmd2)
                        {
                          notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] DEFENSE <NUMBER>");
                          return;
                        }
                  
                  target->stats->setDefense(stringtoint(cmd2));
                  
                  notice(s_GameServ, u, "Defense set to %d", target->stats->getDefense());
                  return;
                }
        }
  else if (stricmp(cmd, "HP") == 0 && stricmp(cmd2, "POTIONS") != 0)
        {
          if (!isAdmin(user))
                {
                  notice(s_GameServ, u, "Admins Only!");
                  return;         
                }
          else
                {
                  if (!cmd2)
                        {
                          notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] HP <NUMBER>");
                          return;
                        }
                  target->stats->setHP(stringtoint(cmd2));
                  
                  notice(s_GameServ, u, "HP set to %d", target->stats->getHP());
                  return;
                }
        }
  else if (stricmp(cmd, "MAXHP") == 0)
        {
          if (!isAdmin(user))
                {
                  notice(s_GameServ, u, "Admins Only!");
                  return;         
                }
          else
                {
                  if (!cmd2)
                        {
                          notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] MAXHP <NUMBER>");
                          return;
                        }
                  target->stats->setMaxHP(stringtoint(cmd2));
                  
                  notice(s_GameServ, u, "MaxHP set to %d", target->stats->getMaxHP());
                  return;
                }
        }
  else if (stricmp(cmd, "EXPERIENCE") == 0 || stricmp(cmd, "EXP") == 0)
        {
          if (!isAdmin(user))
                {
                  notice(s_GameServ, u, "Admins Only!");
                  return;         
                }
          else
                {
                  if (!cmd2)
                        {
                          notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] {EXPERIENCE|EXP} <NUMBER>");
                          return;
                        }
                  
                  target->stats->setExp(stringtoint(cmd2));
                  
                  notice(s_GameServ, u, "Exp set to %ld", target->stats->getExp());
                  return;
                }
        }
  else if (stricmp(cmd, "LEVEL") == 0)
        {
          if (!isAdmin(user))
                {
                  notice(s_GameServ, u, "Admins Only!");
                  return;         
                }
          else
                {
                  if (!cmd2)
                        {
                          notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] LEVEL <NUMBER>");
                          return;
                        }
                  target->stats->setLevel(stringtoint(cmd2));
                  
                  notice(s_GameServ, u, "Level set to %d", target->stats->getLevel());
                  return;
                }
        }
  else if (stricmp(cmd, "ALIVE") == 0)
        {
          if (!isAdmin(user))
                {
                  notice(s_GameServ, u, "Admins Only!");
                  return;
                }
          else
                {
                  if (!cmd2)
                        {
                          notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] ALIVE TRUE|FALSE");
                          return;
                        }
                  else if (stricmp(cmd2, "TRUE") == 0)
                        {
                          notice(s_GameServ, u, "%s has been Resurrected!", target->stats->getName().c_str());
                          setAlive(target->stats);
                        }
                  else
                        {
                          notice(s_GameServ, u, "%s is now dead!", target->stats->getName().c_str());
                          clearAlive(target->stats);
                        }
                }
        }
  else if (stricmp(cmd, "SEEN") == 0)
    {
      if (!isAdmin(user))
                {
                  notice(s_GameServ, u, "Admins Only!");
                  return;
                }
      else if (stricmp(cmd2, "MASTER") != 0)
                {
                  notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] SEEN MASTER {TRUE|FALSE}");
                  return;
                }
      else
                {
                  cmd2 = strtok(NULL, " ");
                  if (!cmd2)
                        {
                          notice(s_GameServ, u, "SYNTAX: /msg %S SET [NICK] SEEN MASTER {TRUE|FALSE}");
                          return;
                        }
                  else if (stricmp(cmd2, "TRUE") == 0)
                        {
                          notice(s_GameServ, u, "%s has seen their master now.", target->stats->getName().c_str());
                          target->stats->addFlag(FLAG_MASTER);
                        }
                  else
                        {
                          notice(s_GameServ, u, "%s has not seen their master now.", target->stats->getName().c_str());
                          target->stats->remFlag(FLAG_MASTER);
                        }
                }         
    }
  else
        {
          notice(s_GameServ, u, "Unknown command: SET %s", cmd);
          notice(s_GameServ, u, "SYNTAX: /msg %S SET [NAME] {PASSWORD|BANK BALANCE|PLAYER FIGHTS|FOREST FIGHTS|GOLD|STRENGTH|DEFENSE|HP|MAXHP|EXP|LEVEL|ALIVE|SEEN MASTER} {STRING|NUMBER|TRUE|FALSE}");
          return;
        }
}

void do_logout(char *u)
{
    aClient *user;
    char *name = strtok(NULL, " ");

    if (!(user = find(u)))
    {
        notice(s_GameServ, u, "Fatal error. Cannot find aClient. "\
                "Buf: %s LOGOUT", u);
        log("Could not find aClient Buf: %s LOGOUT", 
                u);
        return;
    }
    else if (isIgnore(user))
    {
        #ifdef DEBUGMODE
            log("Ignoring %s.", user->getNick());
        #endif
        return;
    }

    if (name)
    {
        if (!isAdmin(user))
        {
            notice(s_GameServ, u, "You must be a %S admin to use this command!");
        }
        else if (!(user = findplayer(name)))
        {
            notice(s_GameServ, u, "Couldn't find a player named %s", name);
        }
        else
        {
            notice(s_GameServ, u, "Logging out %s", user->stats->getName().c_str());
            logout(user);
        }
    }
    else if (!name)
    {
        if (!is_playing(user))
        {
            notice(s_GameServ, u, "You're not logged in!");
        }
        else if (is_fighting(user))
        {
            notice(s_GameServ, u, "You can't logout while fighting!");
        }
        else
        {
            notice(s_GameServ, u, "You have left the fields. You have lived to kill another day!");
            logout(user);
        }
    }
}

void logout(aClient *user)
{
  if (is_playing(user))
    {
          ListNode<aClient> *it;
          aClient *temp;
          unsigned long hv = iHASH((unsigned char *) user->stats->getName().c_str());
          it = players[hv].Find(user);
          
          if (!it)
        {
                  notice(s_GameServ, user->getNick(), "Fatal error. Contact "\
                                 "%S Admin. Cannot find you in the players list.");
                  log("Error on logout(). Can't find %s in the players list",
#ifdef P10 
                          user->getRealNick()
#else 
                          user->getNick()
#endif
                          );
                  return;
        }
          user->stats->delMonster();
          user->stats->delMaster();
          clearDragonFight(user->stats);
          
          if (player_fight(user))
            user->stats->getBattle()->stats->delBattle();

          user->stats->delBattle();

          temp = new aClient;
          temp->stats = new Player;
          temp->stats->setData(user->stats);
          user->stats->setClient(NULL);
          
          
          delete user->stats;
          user->stats = NULL;
          temp->stats->setClient(NULL);
#ifdef P10
          temp->setRealNick("Not Playing");
#endif
          temp->setNick("Not Playing");
          
          it->setNewPtr(temp);
#ifdef DEBUGMODE
          log("Logged out player %s",
#ifdef P10 
                  user->getRealNick()
#else 
                  user->getNick()
#endif 
                  );
#endif
    }
  clearPlaying(user);
}

void do_register(char *u)
{
  char *password, *name;
  aClient *user;
  name = strtok(NULL, " ");
  password = strtok(NULL, " ");
  
  if (!name)
    {
          notice(s_GameServ, u, "SYNTAX: /msg %S REGISTER NAME PASSWORD");
    }
  else if (stricmp(name, s_GameServ) == 0)
    {
          notice(s_GameServ, u, "You can't use %S as a name!");
    }
  else if (!password)
    {
          notice(s_GameServ, u, "SYNTAX: /msg %S REGISTER NAME PASSWORD");
    }
  else if ((user = findplayer(name)))
    {
          notice(s_GameServ, u, "%s is already registered!", name);
          notice(s_GameServ, u, "Choose another name!");
    }
  else if (!(user = find(u)))
    {
          log("Fatal Error: Couldn't find %s in the clients list", u);
    }
  else if (!alphaNumeric(name))
        {
          notice(s_GameServ, u, "That is not a valid name. Please use only AlphaNumeric (A-Z, 0-9) characters!");
        }
  else if (isIgnore(user))
    {
#ifdef DEBUGMODE
          log("Ignoring %s.", user->getNick());
#endif
    }
  else
    {
          if (!is_playing(user))
        {
                  ListNode<aClient> *temp;
                  item *tempItem;
                  user->stats = new Player();
                  user->stats->setClient(user); // Set the backwards pointer
                  user->stats->reset(); // set the user up
                  user->stats->setPassword(password);
                  user->stats->setName(name);
                  unsigned long hv = iHASH((unsigned char *) name);
                  updateTS(user->stats);
                  temp = players[hv].insertAtBack_RLN(user);
                  temp->setPtr(user); // This is an extra step, but necessary for now
                  
                  // Update the last login time
                  user->stats->lastlogin = time(NULL);
                  
                  notice(s_GameServ, u, "Player %s registered with password %s.", user->stats->getName().c_str(), password);
                  notice(s_GameServ, u, "Write this password down. If you lose it, there is no way to retrieve it!");
                  log("Nickname %s registered player %s.", u, user->stats->getName().c_str());
                  setPlaying(user); // set the playing flag
                  tempItem = findItemByID(3001);
                  user->stats->inventory->addItem((*Items.begin()))->use(user->stats); // Add the stick
                  user->stats->inventory->addItem(tempItem)->use(user->stats); // Add Clothes
                }
          else
                {
                  notice(s_GameServ, u, "Already registered. Contact a %S admin for help.");
                }
    }
}

void do_identify(char *u)
{
  char *password, *name;
  aClient *user, *p;
  name = strtok(NULL, " ");
  password = strtok(NULL, " ");
  if (!password || !name)
    {
          notice(s_GameServ, u, "SYNTAX: /msg %S IDENTIFY NAME PASSWORD");
    }
  else if (!(user = find(u)))
    {
          notice(s_GameServ, u, "Fatal error. Cannot find aClient. Buf: %s", strtok(NULL, ""));
          log("Error: aClient not found: %s", u);
    }
  else if (isIgnore(user))
    {
#ifdef DEBUGMODE
          log("Ignoring %s.", user->getNick());
#endif
          return;
    }
  else if (!(p = findplayer(name)) || !p->stats)
        notice(s_GameServ, u, "Player %s not found", name);
  else if (is_playing(user))
    {
          notice(s_GameServ, u, "You are already playing!");
    }
  else if (p->stats->getClient() != NULL && !isAdmin(user))
    {
          notice(s_GameServ, u, "That player has already identified.");
    }
  else if (!check_password(name, password) && !isAdmin(user))
    {
          notice(s_GameServ, u, "Password incorrect");
    }
  else
        {
          ListNode<aClient> *temp;
          unsigned long hv = iHASH((unsigned char *) p->stats->getName().c_str());
          temp = players[hv].Find(p);
          if (!temp)
                {
                  notice(s_GameServ, u, "Fatal error. Contact %S Admin. Buf: %s", 
                                 strtok(NULL, ""));
                  return;
                }
          user->stats = new Player(p->stats->getName());
#ifdef DEBUGMODE
            log("Setting data for identified");
#endif
                user->stats->setData(p->stats);
                user->stats->setClient(user);
                updateTS(user->stats);
                
                
#ifdef DEBUGMODE
            log("Player %s IRC: %s Identified", user->stats->getName().c_str(), 
                        user->getNick());
#endif
                
                setPlaying(user); // set the playing flag
                
                temp->setPtr(user);
                
                // Update the last login time
                user->stats->lastlogin = time(NULL);
                
                notice(s_GameServ, u, "Password Accepted. Identified.");
                showNews(u, todaysnews);
    }
}

void do_stats(char *u)
{
  char *nick;
  aClient *user;
  
  nick = strtok(NULL, " ");
  
  if (!(user = find(u)))
    {
          log("Fatal Error: %s not found in client list", u);
          return;
    }
  else if (isIgnore(user))
    {
#ifdef DEBUGMODE
          log("Ignoring %s.", user->getNick());
#endif
          return;
    }
  else if (!nick)
    {
          if (!is_playing(user))
                {
                  notice(s_GameServ, u, "You're not playing, so you have no stats!");
                  return;
                }
          else
                {
                  updateTS(user->stats);
                  showstats(u, user->stats->getName().c_str());
                }
    }
  else
        showstats(u, nick);
}

bool load_masters()
{
  ifstream infile(masterdata);
  char *buf;
  int l = 0;
  buf = new char[1024];
  
  if (infile.fail())
    {
          log("Error opening %s", masterdata);
          return false;
    }
  
#ifdef DEBUGMODE
  log("Loading masters from %s", masterdata);
#endif
  
  for (l = 0; l < LEVELS - 1; l++)
    {
          infile.getline(buf, 1024, '\n');
          
          log("%s", buf);
          if (buf[0] == '#' || buf[0] == '\n' || buf[0] == '\r')
                {
                  l--;
                  continue;
                }
          else if (buf[0] == '^')
            break;
          
          Monster *master = &levels[l].master;
          
          char *name, *weapon, *strength, *gold, *exp, *maxhp, *death;
          
          
          name = strtok(buf, "~");
          weapon = strtok(NULL, "~");
          strength = strtok(NULL, "~");
          gold = strtok(NULL, "~");
          exp = strtok(NULL, "~");
          maxhp = strtok(NULL, "~");
          death = strtok(NULL, "~");
        
          master->name = name;
          master->weapon = weapon;
          master->strength = stringtoint(strength);
          master->gold = stringtoint(gold);
          master->exp = stringtoint(exp);
          master->maxhp = stringtoint(maxhp);
          master->hp = master->maxhp;
          master->death = death;
    }

  delete []buf;
  
  if (l < LEVELS - 1)  // We didn't load a master for every level - check data/masters.dat
        return false;
  else
        return true;
}

void delete_monsters()
{
  for (int x = 0; x < LEVELS; x++)
        levels[x].monsters.deleteNodes();
}

void display_monster(char *u)
{
  if (is_playing(u))
    {
          aClient *user = find(u);
          Player *ni = user->stats;
          
          notice(s_GameServ, u, "Your Hitpoints: \ 2%d\ 2", ni->getHP());
          notice(s_GameServ, u, "%s's Hitpoints: \ 2%d\ 2", ni->getMonster()->name.c_str(), ni->getMonster()->hp);
          notice(s_GameServ, u, "Here are your commands:");
          notice(s_GameServ, u, "/msg %S attack");
          notice(s_GameServ, u, "/msg %S run");
          notice(s_GameServ, u, "What will you do?");
    }
}

void display_players(char *u)
{
  aClient *user;
  if (!(user = find(u)))
    {
          log("Fatal error in display_players(): Couldn't find %s", u);
    }
  else
        display_players(user);
}

void display_players(aClient *user)
{
  char *u = user->getNick();
  if (is_playing(user) && player_fight(user))
    {
          aClient *battle = user->stats->getBattle();
          notice(s_GameServ, u, "Your Hitpoints: \ 2%d\ 2", user->stats->getHP());
          notice(s_GameServ, u, "%s's Hitpoints: \ 2%d\ 2", battle->stats->getName().c_str(), battle->stats->getHP());
          notice(s_GameServ, u, "Here are your commands:");
          notice(s_GameServ, u, "/msg %S attack");
          notice(s_GameServ, u, "/msg %S run");
          notice(s_GameServ, u, "What will you do?");
    }
}


bool is_playing(char *u)
{
  aClient *user;
  if (!(user = find(u)))
        return false;
  else
        return is_playing(user);
}

bool is_playing(aClient *user)
{
  if (user->stats == NULL)
    {
          return false;
    }
  else if (user->stats->getClient() == NULL)
    {
          return false;
    }
  else if (!FL_is_playing(user))
    {
          return false;
    }
  else
        return true;
}

bool is_fighting(char *u)
{
  aClient *user;
  
  if (!(user = find(u)))
        return false;
  else
        return is_fighting(user);
}

bool is_fighting(aClient *user)
{
  if (!is_playing(user))
        return false;
  else
        return player_fight(user) || master_fight(user) || user->stats->getMonster() != NULL;
}

bool player_fight(char *u)
{
  aClient *user;
  
  if (!(user = find(u)))
        return false;
  else 
        return player_fight(user);
}

bool player_fight(aClient *user)
{
  if (!is_playing(user))
        return false;
  else if (user->stats->getBattle() != NULL && is_playing(user->stats->getBattle()))
    {
          return user->stats->getBattle()->stats != NULL;
    }
  return false;
}

bool master_fight(char *u)
{
  aClient *user;
  
  if (!(user = find(u)))
        return false;
  else
        return master_fight(user);
}

bool master_fight(aClient *user)
{
  if (!is_playing(user))
        return false;
  else
        return user->stats->getMaster() != NULL;
}

bool dragon_fight(char *u)
{
  aClient *user;
  if (!(user = find(u)))
        return false;
  else
        return dragon_fight(user);
}

bool dragon_fight(aClient *user)
{
  if (!is_playing(user))
        return false;
  else
        return (isDragonFight(user->stats));
}

bool alphaNumeric(const char *str)
{
  int len = strlen(str);
  for (int x = 0; x < len; x++)
        {
          if (!((int(str[x]) >= 65 && int(str[x]) <= 90) || (int(str[x]) >= 97 && int(str[x]) <= 122) || (int(str[x]) >= 48 && int(str[x]) <= 57) || int(str[x]) == 95))
                return false;
        }
  return true;
}

void do_fight(char *u)
{
  aClient *ni, *battle;
  
  char *nick = strtok(NULL, " ");
  
  if (!nick)
    {
          notice(s_GameServ, u, "SYNTAX: /msg %S FIGHT PLAYER");
          return;
    }
  else if (!(ni = find(u)))
    {
          notice(s_GameServ, u, "Fatal error. Contact a(n) %S admin. buf: %s", strtok(NULL, ""));
          return;
    }
  else if (isIgnore(ni))
    {
#ifdef DEBUGMODE
          log("Ignoring %s.", ni->getNick());
#endif
          return;
    }
  else if (!is_playing(ni))
    {
          notice(s_GameServ, u, "You are not playing!");
          return;
    }
  
  updateTS(ni->stats);
  
  if (ni->stats->getPlayerFights() <= 0)
    {
          ni->stats->setPlayerFights(0); // just to be safe
          notice(s_GameServ, u, "You are out of player fights for the "\
                         "day. You have to wait until tomorrow!");
    }
  else if (!(battle = findplayer(nick)))
    {
          notice(s_GameServ, u, "Player %s not found!", nick);
    }
  else if (!isAlive(ni->stats))
    {
          notice(s_GameServ, u, "You are dead. Wait until tomorrow to fight others!");
    }
  else if (!is_playing(battle))
    {
          notice(s_GameServ, u, "You can't attack %s while they aren't playing!", nick);
    }
  
  /* offline fighting not available yet
         else if (!(fight = finduser(nick)))
         {
         ni->stats->battle = battle;
         battle->battle = ni;
         setYourTurn(ni->stats);
         clearYourTurn(battle->stats);
         
         notice(s_GameServ, u, "You decide to fight %s while they're "\
         "not in the realm!",
         battle->stats->name.c_str());
         display_players(u);
         }
  */
  else if (stricmp(ni->stats->getName().c_str(), battle->stats->getName().c_str()) == 0)
    {
          notice(s_GameServ, u, "Are you trying to commit suicide!?");
    }
  else if (!isAlive(battle->stats))
    {
          notice(s_GameServ, u, "They are dead. Cannot fight dead players!");
    }
  else if (player_fight(battle))
    {
          notice(s_GameServ, u, "%s is fighting %s already!", battle->stats->getName().c_str(), battle->stats->getBattle()->stats->getName().c_str());
    }
  else if (master_fight(battle))
    {
          notice(s_GameServ, u, "%s is fighting their master!", battle->stats->getName().c_str());
    }
  else if (is_fighting(battle))
    {
          notice(s_GameServ, u, "%s is fighting %s already!", battle->stats->getName().c_str(), battle->stats->getMonster()->name.c_str());
    }
  else if (!isAdmin(ni) && isFairFights() && (ni->stats->getStrength()/2 - battle->stats->getDefense()) > battle->stats->getHP())
    {
          notice(s_GameServ, u, "Fair fighting is enabled, and you're too strong for %s!", battle->stats->getName().c_str());
    } 
  else if (ni->stats->getLevel() - battle->stats->getLevel() > maxbfightdistance)
    {
          // You can't fight someone below you by more than X level(s)
          // level 12 can fight level (12 - X) but not < (12 - X)
          notice(s_GameServ, u, "You may not fight %s. You're too strong!", 
                         battle->stats->getName().c_str());
    }
  else if (battle->stats->getLevel() - ni->stats->getLevel() > maxafightdistance)
    {
          // You can't fight someone above you by more than X level(S)
          // level 1 can fight level (1 + X), but not > (1 + X)
          notice(s_GameServ, u, "%s, do you really have a death wish? Try the forest you "\
                         "weakling!", ni->stats->getName().c_str());
    }
  else
        {
          // Set your battle pointer to the other player
          ni->stats->setBattle(battle);
          
          // Set the other player's battle pointer to you
          battle->stats->setBattle(ni);
                  
          // The initiator gets the first move (perhaps this should be 50/50)
          setYourTurn(ni->stats);
          clearYourTurn(battle->stats);
          
          // Initiate Battle sequence!
          ni->stats->subtractPlayerFights(1);
          
          notice(s_GameServ, u, "You challenge %s to an online duel!", battle->stats->getName().c_str());
          notice(s_GameServ, c_Forest, "%s walks up and hits %s in the face! Let's see who will bite the dust.",
                         ni->stats->getName().c_str(), battle->stats->getName().c_str()); /* DrLnet - Modified by Kain*/
          
          notice(s_GameServ, battle->getNick(), "%s has challenged you to an online duel!", ni->stats->getName().c_str());
          notice(s_GameServ, battle->getNick(), "%s gets to go first "\
                         "because they initiated!", ni->stats->getName().c_str());
          notice(s_GameServ, battle->getNick(), "Please wait while %s decides what to do.", ni->stats->getName().c_str());
          display_players(ni);
        }
}

void do_equip(char *u)
{
  aClient *user;
  pouch *p;
  itemContainer *equip;
  int id;

  char *item = strtok(NULL, " ");

  if (!item || int(item[0]) < 48 || int(item[0] > 57))
    {
      notice(s_GameServ, u, "SYNTAX: EQUIP ####");
      notice(s_GameServ, u, "Type /msg %S HELP EQUIP for more information.");
      return;
    }
  else if (!(user = find(u)))
    {
      notice(s_GameServ, u, "Fatal error in do_equip. Contact a(n) %S Admin");
      return;
    }
  else if (isIgnore(user))
    {
#ifdef DEBUGMODE
      log("Ignoring %s.", user->getNick());
#endif
      return;
    }
  else if (!is_playing(user))
    {
      notice(s_GameServ, u, "You must be playing to equip weapons and armor!");
      return;
    }
  id = stringtoint(item);
  updateTS(user->stats);
  p = user->stats->inventory;


        if (!(equip = p->Find(id)))
      {
                if (!p->isEmpty())
                  {
                        notice(s_GameServ, u, "You aren't carrying that item!");
                  }
                showinventory(user->stats, user);
      }
    else if (equip->getItem()->getType() != ARMOR && equip->getItem()->getType() != WEAPON)
      {
                notice(s_GameServ, u, "You can't use %s like that. Try /msg %S use", equip->getItem()->getName().c_str());
      }
    else
      {
                // Use the item
                notice(s_GameServ, u, "You equip %s.", equip->getItem()->getName().c_str());
                equip->use(user->stats);
      }
}
void do_use(char *u)
{
  aClient *user;
  pouch *p;
  
  char *item = strtok(NULL, " ");
  int id;
  itemContainer *used;
  
  if (!item || int(item[0]) < 48 || int(item[0]) > 57)
    {
          notice(s_GameServ, u, "SYNTAX: USE ####");
          notice(s_GameServ, u, "Type /msg %S HELP USE for more information.");
          return;
    }
  else if (!(user = find(u)))
    {
          notice(s_GameServ, u, "Fatal Error in do_use. Contact a(n) %S Admin");
          return;
    }
  else if (isIgnore(user))
    {
#ifdef DEBUGMODE
          log("Ignoring %s.", user->getNick());
#endif
          return;
    }
  else if (!is_playing(user))
    {
          notice(s_GameServ, u, "You must be playing to use items!");
          return;
    }
  id = stringtoint(item);
  updateTS(user->stats);
  p = user->stats->inventory;
  
  
  if (!(used = p->Find(id)))
        {
          if (!p->isEmpty())
                {
                  notice(s_GameServ, u, "You aren't carrying that item!");
                }
          showinventory(user->stats, user);
        }
  else if (used->getItem()->getType() != POTION)
        {
          notice(s_GameServ, u, "You can't use %s like that. Try /msg %S equip", used->getItem()->getName().c_str());
        }
  else
        {
          // Use the item
          notice(s_GameServ, u, "You used %s.", used->getItem()->getName().c_str());
          used->use(user->stats);
          if (used->getUses() <= 0)
                {
                  p->deleteItem(used->getItem());
                }
          end_turn(user);
        }   
}
void do_run(char *u)
{
  aClient *user;
  Player *p, *p2 = NULL;
  
  if (!(user = find(u)))
    {
          notice(s_GameServ, u, "Couldn't find you. Error. Contact a %S admin");
          return;
    }
  else if (isIgnore(user))
    {
#ifdef DEBUGMODE
          log("Ignoring %s.", user->getNick());
#endif
          return;
    }
  else if (!is_playing(user))
    {
          notice(s_GameServ, u, "You must be playing to run!");
          return;
    }
  
  updateTS(user->stats);
  p = user->stats;
  
  if (p->getBattle())
        p2 = p->getBattle()->stats;
  
  if (!is_fighting(user))
        notice(s_GameServ, u, "You run in place... try fighting next time.");
  else if (!player_fight(user) && !master_fight(user) && !dragon_fight(user))
    {
          notice(s_GameServ, u, "You run away from \ 2%s\ 2 like a little baby!", p->getMonster()->name.c_str());
          p->delMonster();
    }
  else if (player_fight(user) && isYourTurn(p))
    {
          notice(s_GameServ, u, "You run away from \ 2%s\ 2 like a little baby!", p2->getName().c_str());
          notice(s_GameServ, p->getBattle()->getNick(), "\ 2%s\ 2 ran away from you like a little baby!", p->getName().c_str());
          addNews(todaysnews, "%s ran away from %s like a little baby!!", p->getName().c_str(), p2->getName().c_str()); /* DrLnet - edited by Kain */
          p2->delBattle();
        }
  else if (player_fight(user) && !isYourTurn(p))
    {
          notice(s_GameServ, u, "It is not your turn. Please wait until \ 2%s\ 2 decides what to do.", p2->getName().c_str());
    }
  else if (master_fight(user))
    {
          notice(s_GameServ, u, "You cannot run from \ 2%s\ 2! FIGHT!", p->getMaster()->name.c_str());
    }
  else if (dragon_fight(user))
        {
          notice(s_GameServ, u, "You cannot run from %s! FIGHT!", dragon.name.c_str());
        }
}

void end_turn(aClient *user)
{
  char *nick, *u = user->getNick();
  Monster *fight;
  aClient *battle;
  int mhit;
  
  nick = new char[strlen(user->getNick()) + 1];
  
  if (!user || !is_playing(user) || !is_fighting(user))
        goto endturn;
  
  if (!player_fight(user) && !master_fight(user))
        fight = user->stats->getMonster();
  else
        fight = user->stats->getMaster();
  battle = user->stats->getBattle();
  
  if (!player_fight(user))
    {
          // Opponent's Hit
          mhit = (fight->strength / 2) + (rand() % (fight->strength / 2)) - (user->stats->getDefense());
    }
  else
    {
          // Opponent's Hit
          mhit = (battle->stats->getStrength() / 2) + (rand() % (battle->stats->getStrength() / 2)) - user->stats->getDefense();
    }
  if (!player_fight(user))
    {
          
          if (mhit > 0)
        {
                  notice(s_GameServ, u, "\1f%s\1f attacks with their \1f%s\1f for \ 2%d\ 2 damage!",
                                 fight->name.c_str(), fight->weapon.c_str(), mhit);
        }
          else if (mhit <= 0)
                notice(s_GameServ, u, "%s completely misses you!", fight->name.c_str());
          
          if (mhit >= user->stats->getHP())
        {
                  if (!master_fight(user))
            {
                          notice(s_GameServ, u, "You have been \ 2\1fkilled\1f\ 2 by %s!", fight->name.c_str());
                          notice(s_GameServ, u, "You lose all gold on hand and lose 10 percent "\
                                         "of your experience!");
                          user->stats->setGold(0);
                          user->stats->subtractExp((long int)(user->stats->getExp() * .10));
                          user->stats->setHP(0);
                          user->stats->delMonster();
                          clearAlive(user->stats);
                          goto endturn;
            }
                  else
            {
                          notice(s_GameServ, u, "%s has bested you! You will have to wait "\
                                         "until tomorrow to try again", user->stats->getMaster()->name.c_str());
                          user->stats->delMonster();
                          user->stats->delMaster();
                          goto endturn;
            }
        }
          else
        {
                  if (mhit > 0)
                        user->stats->subtractHP(mhit);
                  display_monster(u);
                  goto endturn;
        }
    }
  else
    {
          clearYourTurn(user->stats);
          setYourTurn(battle->stats);
          display_players(battle);
    }
 endturn:
  delete []nick;
}

void do_heal(char *u)
{
  aClient *ni;
  char *amount = strtok(NULL, " ");
  int price, num;
  
  if (!amount)
    {
          notice(s_GameServ, u, "SYNTAX: /msg %S HEAL {ALL | #}");
          return;
    }
  else if (!(ni = find(u)))
    {
        notice(s_GameServ, u, "Fatal error. Contact a(n) %S admin. buf: %s", strtok(NULL, ""));
        return;
    }
    else if (isIgnore(ni))
    {
        #ifdef DEBUGMODE
            log("Ignoring %s.", ni->getNick());
        #endif
        return;
    }
    else if (!is_playing(ni))
    {
        notice(s_GameServ, u, "You aren't playing!");
        return;
    }
    else if (!isAlive(ni->stats))
    {
        notice(s_GameServ, u, "You are dead. Wait until tomorrow for healing.");
        return;
    }
    else if (is_fighting(ni))
    {
        notice(s_GameServ, u, "You can't heal in battle!");
        return;
    }
    else if (ni->stats->getHP() >= ni->stats->getMaxHP())
    {
        notice(s_GameServ, u, "You don't need healing!");
        return;
    }

    updateTS(ni->stats);
    if (stricmp(amount, "ALL") == 0)
    {
        price = ni->stats->getLevel() * 3;
        if (ni->stats->getGold() < (ni->stats->getMaxHP() - ni->stats->getHP()) * price)
        {
            notice(s_GameServ, u, "Healing \ 2%d\ 2 points for \ 2%d\ 2 gold per point.",
                     (long int)ni->stats->getGold()/price, price);
            ni->stats->addHP(ni->stats->getGold() / price);
            ni->stats->setGold(ni->stats->getGold() % price);
        }
        else
        {
            notice(s_GameServ, u, "Healing all possible points at \ 2%d\ 2 gold "\
                        "per point.", price);
            notice(s_GameServ, u, "\ 2%d\ 2 points healed for \ 2%ld\ 2 gold. HP at MAX!",
                     (ni->stats->getMaxHP() - ni->stats->getHP()), 
                     (price * (ni->stats->getMaxHP() - ni->stats->getHP())) );
            ni->stats->subtractGold(price * (ni->stats->getMaxHP() - ni->stats->getHP()));
            ni->stats->healall();
        }
    }
    else if (isstringnum(amount))
    {
        num = stringtoint(amount);
        price = ni->stats->getLevel() * 3;
        if (ni->stats->getGold() < price * num)
        {
            notice(s_GameServ, u, "You only have enough gold to heal \ 2%d\ 2 points!",
                     (long int)ni->stats->getGold()/price);
        }
        else if (num <= ni->stats->getMaxHP() - ni->stats->getHP())
        {
            notice(s_GameServ, u, "Healing \ 2%d\ 2 points at \ 2%d\ 2 gold per point.",
                     num, price);
            ni->stats->addHP(num);
            ni->stats->subtractGold(num * price);
        }
        else if (num > ni->stats->getMaxHP() - ni->stats->getHP())
        {
            notice(s_GameServ, u, "Healing all possible points at \ 2%d\ 2 gold "\
                        "per point.", price);
            notice(s_GameServ, u, "\ 2%d\ 2 points healed. HP at MAX!",
                     (ni->stats->getMaxHP() - ni->stats->getHP()));
            ni->stats->subtractGold(price * (ni->stats->getMaxHP() - ni->stats->getHP()));
            ni->stats->healall();
        }
    }
    else if (amount[0] == '-')
        notice(s_GameServ, u, "You trying to cheat?");
    else
        notice(s_GameServ, u, "SYNTAX: /msg %S HEAL {ALL | #}");
}

int isstringnum(char *num)
{
    unsigned int x;
    for (x = 0; x < strlen(num); x++)
    {
        if ((int)num[x] < 48 || (int)num[x] > 57)
            return 0;
    }
return 1;
}

long int stringtoint(char *number)
{
    return atol(number);
}

long int pow(int x, int y)
{
    long int value = 0;
    int count = 0;
    value += x;

    if (x != 0 && y != 0)
    {
        for (count = 1; count <= y - 1; count++)
            value *= x;
    }
    else
        return 1;
return value;
}

long int chartoint(char ch)
{
        if (int(ch) >= 48 && int(ch) <= 57)
                return int(ch) - 48;
        else
                return 0;
}

int save_gs_dbase()
{
    ListNode<aClient> *ptr;
    Player *it;
    ofstream outfile;

    outfile.open(playerdata);

    if (!outfile)
    {
        log("Error opening %s", playerdata);
        return 0;
    }

   for (unsigned long x = 0; x < U_TABLE_SIZE; x++)
   {
    ptr = players[x].First();
    while(ptr)
    {
        it = ptr->getData()->stats;
        clearYourTurn(it);
        item *w, *a;
        w = it->getWeapon();
        a = it->getArmor();

        outfile << it->getName().c_str() << ' ' << it->getLevel() << ' ' << it->getExp() << ' ' << it->getGold() << ' ' << it->getBank() << ' '<< it->getHP() << ' ' << it->getMaxHP() << ' ' << it->getStrength() << ' ' << it->getDefense() << ' ' << it->getForestFights() << ' ' << it->getPlayerFights() <<  ' ' << it->getFlags() << ' ' << it->getPassword().c_str() << ' ' << it->lastlogin << ' ' << (w ? w->getID() : 0) << ' ' << (a ? a->getID() : 0);

        // Traverse the list and write out each item ID and how many uses are left
        if (!it->inventory->isEmpty())
          {
            list<itemContainer> *myitems;
            list<itemContainer>::iterator item_iter;
            myitems = it->inventory->getItems();
            
            for(item_iter = myitems->begin();item_iter != myitems->end();item_iter++)
              {
                outfile << ' ' << (*item_iter).getItem()->getID() << ' ' << (*item_iter).getUses();
              }
          }
        outfile << endl;
        ptr = ptr->Next();
    }
   }
outfile.close();
return 1;
}

int load_dragon()
{
    ifstream infile;
    char *buf;

    infile.open(dragondata);

    if (infile.fail())
    {
        infile.clear();
        log ("Error opening %s. Trying initialdragon.dat", dragondata);
        infile.open("data/initialdragon.dat");
        if (infile.fail())
        {
            log ("Error opening data/initialdragon.dat");
            return 0;
        }
    }

    buf = new char[1024];

    infile.getline(buf, 1024, '\n');
    infile.close(); // Done with the file... we have what we want

    dragon.name = strtok(buf, "~");
    dragon.weapon = strtok(NULL, "~");
    dragon.gold = 0;
    dragon.exp = 0;
    dragon.strength = stringtoint(strtok(NULL, "~"));
    dragon.hp = stringtoint(strtok(NULL, "~"));
    dragon.defense = stringtoint(strtok(NULL, "~"));
    dragon.death = strtok(NULL, "");

    log ("loaded dragon: %s", dragon.name.c_str());

    delete []buf;

return save_dragon();  // Save the dragon file and return the status code :)
}

int save_dragon()
{
    ofstream outfile;

    outfile.open(dragondata);

    if (outfile.fail())
    {
        log ("Error opening %s. Exiting.", dragondata);
        return 0;
    }

    outfile << dragon.name.c_str() << '~' << dragon.weapon.c_str() << '~' 
                << dragon.strength << '~' << dragon.hp << '~' 
                << dragon.defense << '~' << dragon.death.c_str() << "\n^"
                << endl;

outfile.close();

return 1;
}

int load_store()
{
  ifstream infile;
  char *buf;
  item *tempItem;
  buf = new char[1024];
  long id;
  
  infile.open(storeitemdata);
  
  if (infile.fail())
    {
      log("Error opening %s", storeitemdata);
      return 0;
    }
  
  while (infile.getline(buf, 1024, '\n'))
    {
      try
        {
          if (buf[0] != '#' && buf[0] != '\n' && buf[0] != '\0')
            {
              item *tempItem2;
              id = stringtoint(strtok(buf, ""));
              tempItem2 = findItemByID(id);
              if (tempItem2 == NULL)
                {
                  log("Invalid ID in %s", storeitemdata);
                  return 0;
                }

              tempItem = tempItem2;
              store.push_back(tempItem);
            }
        }
      catch (char *str)
        {
          log("Exception loading store: %s", str);
          delete []buf;
          return 0;
        }
    }
  delete []buf;
  return 1;
}
int load_tavern()
{
  ifstream infile;
  char *buf;
  tavernItem tempItem;
  buf = new char[1024];
  long id, level;

  infile.open(tavernitemdata);
  if (infile.fail())
    {
      log("Error opening %s", tavernitemdata);
      return 0;
    }

  while (infile.getline(buf, 1024, '\n'))
    {
      try
        {
          if (buf[0] != '#' && buf[0] != '\n' && buf[0] != '\0')
            {
              item *tempItem2;
              id = stringtoint(strtok(buf, "~"));
              level = stringtoint(strtok(NULL, ""));
              tempItem2 = findItemByID(id);
              if (tempItem2 == NULL)
                {
                  log("Invalid ID in %s", tavernitemdata);
                  return 0;
                }
              tempItem.setItem(tempItem2);
              tempItem.setLevel(level);
              tavern.push_back(tempItem);
            }
        }
      catch (char *str)
        {
          log("Exception loading tavern: %s", str);
          delete []buf;
          return 0;
        }
    }
  delete []buf;
  return 1;
}
int load_items()
{
  ifstream infile;
  char *buf;
  item *tempItem;


  buf = new char[1024];

  infile.open(itemdata);

  if (infile.fail())
    {
      log("Error opening %s", itemdata);
      return 0;
    }

  while (infile.getline(buf, 1024, '\n'))
    {
      if (buf[0] == '^')
        break;
      try
        {
          if (buf[0] != '#' && buf[0] != '\n' && buf[0] != '\0')
            {
              switch(buf[0])
                {
                case '1':
                  tempItem = new weapon();
                  break;
                case '2':
                  tempItem = new armor();
                  break;
                case '3':
                  tempItem = new potion();
                  break;
                default:
                  log("Invalid Item Type %c in %s", buf[0], itemdata);
                  delete []buf;
                  return 0;
                  break;
                }
              if(tempItem->setData(buf))
                {
                  Items.push_back(tempItem);
                }
            }
        }
      catch (char *str)
        {
          log("Exception loading items: %s", str);
          delete []buf;
          return 0;
        }
    }
  delete []buf;
  return 1;
}

int load_gs_dbase()
{
  ifstream infile;
  aClient *temp;
  Player *p;
  char *tempname, *buf, *password;
  int tempnum;
  buf = new char[100000];
  
  infile.open(playerdata);
  
  if (infile.fail())
    {
          log("Error opening %s", playerdata);
          return 0;
    }
  
  for (int x = 0; x < U_TABLE_SIZE; x++)
    {
          ListNode<aClient> *tempNode;
          tempNode = players[x].First();
          while (tempNode)
                {
                  if (tempNode->getData()->stats->getClient())
                        {
                          logout(tempNode->getData()->stats->getClient());
                        }
                  tempNode = tempNode->Next();
                }
          players[x].deleteNodes();
    }
  
  while (infile.getline(buf, 100000, '\n'))
        {
          temp = new aClient;
          tempname = strtok(buf, " ");
          temp->stats = new Player(tempname);
          p = temp->stats;
          
          p->setLevel(stringtoint(strtok(NULL, " ")));
          p->setExp(stringtoint(strtok(NULL, " ")));
          p->setGold(stringtoint(strtok(NULL, " ")));
          p->setBank(stringtoint(strtok(NULL, " ")));
          p->setHP(stringtoint(strtok(NULL, " ")));
          p->setMaxHP(stringtoint(strtok(NULL, " ")));
          p->setStrength(stringtoint(strtok(NULL, " ")));
          p->setDefense(stringtoint(strtok(NULL, " ")));
          p->setForestFights(stringtoint(strtok(NULL, " ")));
          p->setPlayerFights(stringtoint(strtok(NULL, " ")));
          p->setFlags(stringtoint(strtok(NULL, " ")));
  
  
  
  password = strtok(NULL, " ");
  p->setRawPassword(password);
  temp->setNick("Not Playing");
#ifdef P10
  temp->setRealNick("Not Playing");
#endif
  tempname = strtok(NULL, " ");
  if (tempname)
        p->lastlogin = stringtoint(tempname);
  else
        p->lastlogin = time(NULL);
  
  tempname = strtok(NULL, " ");
  tempnum = stringtoint(tempname);
  if (tempnum != 0)
        {
          p->setWeapon(*findItemByID(tempnum));
        }
  
  tempname = strtok(NULL, " ");
  tempnum = stringtoint(tempname);
  
  if (tempnum != 0)
        {
          p->setArmor(*findItemByID(tempnum));
        }
  
  
  for (tempname = strtok(NULL, " "); tempname != NULL; tempname = strtok(NULL, " "))
        {
          long int id, uses;
          list<item*>::iterator item_iter;
          id = stringtoint(tempname);
          tempname = strtok(NULL, " ");
          uses = stringtoint(tempname);
          
          item_iter = Items.begin();
          while (item_iter != Items.end())
                {
                  if ((*item_iter)->getID() == id)
                        {
                          // Don't sort every time you add an item or it eats CPU
                          p->inventory->addItemNoChecks((*item_iter))->setUses(uses);
                        }
                  item_iter++;
                }
        }
  p->inventory->sort();
  
  unsigned long hv = iHASH((unsigned char *) temp->stats->getName().c_str());
  
  temp->stats->setClient(NULL);
  players[hv].insertAtBack(temp);
  delete temp;
}
delete [] buf;
infile.close();
return 1;
}

bool passcmp(const char *encrypted, char *plaintext)
{
  char salt[3];
  char *plaintext2, *plainToencrypt;
  bool same = false;
  
  plaintext2 = new char[strlen(encrypted) + strlen(plaintext)]; // Extra
  strcpy(plaintext2, plaintext);
  
  salt[0] = encrypted[0];
  salt[1] = encrypted[1];
  salt[3] = '\0';
  
  plainToencrypt = crypt(plaintext2, salt);
  
  same = (strcmp((const char *)encrypted, plainToencrypt) == 0 ? true : false);
  
  delete []plaintext2;
  
  return same;
}

bool check_password(char *name, char *plaintext)
{
  aClient *client;
  
  if (!(client = findplayer(name)))
    return false;
  else
    {
      return passcmp(client->stats->getPassword().c_str(), plaintext);
    }
}

void do_store(char *u)
{
  list<item*>::iterator item_iterator;
  item *tempItem;
  char *cmd = strtok(NULL, " ");
  char *num = strtok(NULL, " ");
  char *space;
  int id;
  aClient *user;
  Player *p;
  
  
  if (!cmd || !num)
    {
      notice(s_GameServ, u, "SYNTAX: STORE LIST {ARMOR | WEAPONS}");
      notice(s_GameServ, u, "        \ 2STORE SELL NUMBER\ 2");
      notice(s_GameServ, u, "        \ 2STORE BUY \1fNUMBER\1f\ 2");
      return;
    }
  else if (!(user = find(u)))
    {
      log("Fatal Error: could not find %s in client list", u);
      return;
    }
  else if (isIgnore(user))
    {
#ifdef DEBUGMODE
      log("Ignoring %s.", user->getNick());
#endif
      return;
    }
  else if (!is_playing(user))
    {
      notice(s_GameServ, u, "You must be playing to use the store!");
      return;
    }
  else if (is_fighting(user))
    {
      notice(s_GameServ, u, "You can't go to the store while fighting!");
      return;
    }
  else if (!isAlive(user->stats))
    {
      notice(s_GameServ, u, "You are dead. Wait until tomorrow to purchase weapons and armor!");
      return;
    }
  updateTS(user->stats);
  
  if (stricmp(cmd, "LIST") == 0)
    {
      if (stricmp(num, "WEAPONS") == 0)
                {
                  notice(s_GameServ, u, "Welcome to Kain's Armory");
                  notice(s_GameServ, u, "Here are the weapons we have available for the killing, sire:");
                  for (item_iterator = store.begin(); item_iterator != store.end(); ++item_iterator)
            {
                          if ((*item_iterator)->getType() == WEAPON)
                                {
                                  space = spaces(strlen((*item_iterator)->getName().c_str()), ".");
                                  notice(s_GameServ, u, "%s%ld. %s%s%ld", ((*item_iterator)->getID() < 10 ? " " : ""), (*item_iterator)->getID(), (*item_iterator)->getName().c_str(), space, (*item_iterator)->price());
                                  free(space);
                                }
                        }
                  notice(s_GameServ, u, "To purchase a weapon, type /msg %S STORE BUY \ 2#\ 2.");
                  notice(s_GameServ, u, "Where # is the weapon number from the menu above.");
                  
                }
      else if (stricmp(num, "ARMOR") == 0)
                {
                  notice(s_GameServ, u, "Welcome to Kain's Armory");
                  notice(s_GameServ, u, "I hope you enjoy the fine armor we have available for your protection:");
                  for (item_iterator = store.begin(); item_iterator != store.end(); ++item_iterator)
            {
                          if ((*item_iterator)->getType() == ARMOR)
                                {
                                  space = spaces(strlen((*item_iterator)->getName().c_str()), ".");
                                  notice(s_GameServ, u, "%s%ld. %s%s%d",((*item_iterator)->getID() < 10 ? " " : ""), (*item_iterator)->getID(), (*item_iterator)->getName().c_str(), space, (*item_iterator)->price());
                                  free(space);
                                }
            }
                  
                  notice(s_GameServ, u, "To purchase armor, type /msg %S store buy #");
                  notice(s_GameServ, u, "Where # is the armor number from the menu above.");
                }
      
    } 
  else if (stricmp(cmd, "BUY") == 0) 
    {
      p = user->stats;
      if (!num)
                {
                  notice(s_GameServ, u, "SYNTAX: \ 2STORE BUY \1f#\1f\ 2");
                  return;
                }
      else
                {
                  id = stringtoint(num);
                }
          
      if (!isstringnum(num))
                {
                  notice(s_GameServ, u, "SYNTAX: \ 2STORE BUY \1f#\1f\ 2");
                  return;
                }
      else if (!(tempItem = findStoreItemByID(id)))
                {
                  notice(s_GameServ, u, "Sorry, we don't carry that item!");
                  return;
                }
      else if (p->getGold() < tempItem->price())
                {
                  notice(s_GameServ, u, "You can't afford to buy %s", tempItem->getName().c_str());
                  return;
                }
      else if (p->inventory->addItem(tempItem))
                {
                  notice(s_GameServ, u, "You have purchased %s! Thanks for the gold!", tempItem->getName().c_str());
                  p->subtractGold(tempItem->price());
                  notice(s_GameServ, u, "Don't forget to type /msg %S equip %ld", tempItem->getID());
                }
          else
                {
                  notice(s_GameServ, u, "You can't carry any more!");
                }
    }
  else if (stricmp(cmd, "SELL" ) == 0)
    {
      itemContainer *tempContainer;
      p = user->stats;
      id = stringtoint(num);
      if (!isstringnum(num))
                {
                  notice(s_GameServ, u, "SYNTAX: /msg %S store sell #");
                  return;
                }
      else if (!(tempContainer = p->inventory->Find(id)))
                {
                  notice(s_GameServ, u, "You're not carrying that!");
                  return;
                }
      else if (p->getGold() >= 2000000000)
                {
                  notice(s_GameServ, u, "You have enough gold. Just hang on to it for now.");
                }
      else 
                {
                  tempItem = tempContainer->getItem();
                  
                  notice(s_GameServ, u, "Thank you for your business! We gave you %ld gold for %s!", (tempItem->price() / 2), tempItem->getName().c_str());
                  p->addGold((tempItem->price() / 2));
                  p->inventory->deleteItem(tempItem);
                  if (tempItem == p->getWeapon())
                        {
                          notice(s_GameServ, u, "Since you equipped %s, you're going to have to reequip something", tempItem->getName().c_str());
                          tempItem->undo(p);
                          p->clearWeapon();
                        }
                  else if (tempItem == p->getArmor())
                        {
                          tempItem->undo(p);
                          notice(s_GameServ, u, "Since you equipped %s, you're going to have to reequip something", tempItem->getName().c_str());
                          p->clearArmor();
                        }
                }
    }
  else
    {
      notice(s_GameServ, u, "SYNTAX: STORE LIST {ARMOR | WEAPONS}");
      notice(s_GameServ, u, "        \ 2STORE SELL #\ 2");
      notice(s_GameServ, u, "        \ 2STORE BUY \1f#\1f\ 2");
      return;
    }
}
void do_inventory(char *u)
{
  aClient *user;
  
  if (!(user = find(u)))
    {
          notice(s_GameServ, u, "Fatal Error. Contact a %S admin!");
          return;
    }
  else if (isIgnore(user))
    {
#ifdef DEBUGMODE
          log("Ignoring %s.", user->getNick());
#endif
          return;
    }
  else if (!is_playing(user))
    {
          notice(s_GameServ, u, "You must be playing to check your inventory!");
          return;
    }
  updateTS(user->stats);
  showinventory(user->stats, user);
}

void showinventory(Player *from, aClient *to)
{
  char *nick;
  if (!to || !from)
        {
          return;
        }

  nick = to->getNick();
  
  if (from->inventory->isEmpty())
        {
          notice(s_GameServ, nick, "You aren't carrying anything");
          return;
        }
  
  list <itemContainer> *items;
  items = from->inventory->getItems();
  
  list <itemContainer>::iterator item_iter, item_iter2;
  item_iter = items->begin();
  
  notice(s_GameServ, nick, "Inventory for %s:", from->getName().c_str());
  long count;
  while (item_iter != items->end())
        {
          // Display a list of counted items so as not to show an extra line for duplicate items
          count = 0;
          item_iter2 = item_iter;
          while (item_iter != items->end() && (*item_iter) == (*item_iter2))
            {
              if ((*item_iter) == (*item_iter2))
                        {
                          ++count;
                        }
              else
                        {
                          break;
                        }
              ++item_iter;
            }
          notice(s_GameServ, nick, "%ld.) %s (%ld)", (*item_iter2).getItem()->getID(), (*item_iter2).getItem()->getName().c_str(), count);
        }
}

void do_tavern(char *u)
{
  char *cmd = strtok(NULL, " ");

  aClient *user;
  Player *p;
  
  if (!(user = find(u)))
    {
      notice(s_GameServ, u, "Fatal Error. See a %S admin for help");
      return;
    }
  else if (isIgnore(user))
    {
#ifdef DEBUGMODE
      log("Ignoring %s.", user->getNick());
#endif
      return;
    }
  else if (!is_playing(user))
    {
      notice(s_GameServ, u, "You must be playing to go to the Tavern");
      return;
    }
  else if (is_fighting(user))
    {
      notice(s_GameServ, u, "You cannot go to the Tavern during a fight!");
      return;
    }
  
  updateTS(user->stats);
  p = user->stats;
  
  if (!cmd)
    {
      notice(s_GameServ, u, "Welcome to Boot Liquors Mystic Apothecary and General Store");
      notice(s_GameServ, u, "Your commands:");
      notice(s_GameServ, u, "/msg %S TAVERN {LIST | BUY} [NUMBER]");
      notice(s_GameServ, u, "What'll it be?");
    }
  else if (stricmp(cmd, "LIST") == 0)
    {
      notice(s_GameServ, u, "Here is a list of what we have to offer:");
      showTavern(user);
      notice(s_GameServ, u, "To buy an item, type /msg %S TAVERN BUY #");
    }
  else if (stricmp(cmd, "BUY") == 0)
    {
          int amt = 1;
      char *chid = strtok(NULL, " ");
          char *amount = strtok(NULL, " ");

          if (amount)
                amt = stringtoint(amount);
      
      if (!chid)
                {
                  notice(s_GameServ, u, "SYNTAX: TAVERN BUY # [#]");
                  notice(s_GameServ, u, "Example: /msg %S TAVERN BUY 6001");
                  notice(s_GameServ, u, "Example: /msg %S TAVERN BUY 6001 10");
                  return;
                }
      long id = stringtoint(chid);
      tavernItem *tempItem;
      
      if (!(tempItem = findTavernItemByID(id)) || user->stats->getLevel() < tempItem->getLevel())
                {
                  notice(s_GameServ, u, "Invalid Choice!");
                  notice(s_GameServ, u, "Here is a list of what we have to offer:");
                  showTavern(user);
                  notice(s_GameServ, u, "To buy an item, type /msg %S TAVERN BUY #");
                  return;
                }
      else if (!amount && user->stats->getGold() < tempItem->getItem()->price())
                {
                  notice(s_GameServ, u, "You don't have enough gold!");
                  notice(s_GameServ, u, "Here is a list of what we have to offer:");
                  showTavern(user);
                  notice(s_GameServ, u, "To buy an item, type /msg %S TAVERN BUY #");
                }
          else if (user->stats->getGold() < amt * tempItem->getItem()->price())
                {
                  notice(s_GameServ, u, "You don't have enough gold!");
                  notice(s_GameServ, u, "Here is a list of what we have to offer:");
                  showTavern(user);
                  notice(s_GameServ, u, "To buy an item, type /msg %S TAVERN BUY # [#]");
                }
          else
                {
                  if (amount)
                        {
                          int amt = stringtoint(amount);
                          if (amt < 0 || amount[0] == '-')
                                {
                                  notice(s_GameServ, u, "You trying to steal from me?");
                                }
                          else if (user->stats->inventory->addItem(tempItem->getItem(), amt) == NULL)
                                {
                                  notice(s_GameServ, u, "You can't carry that many!");
                                }
                          else
                                {
                                  notice(s_GameServ, u, "%d %s's coming right up!", amt, tempItem->getItem()->getName().c_str());
                                  user->stats->subtractGold(tempItem->getItem()->price() * amt);
                                }
                        }
                  else
                        {
                          if (user->stats->inventory->addItem(tempItem->getItem()) == NULL)
                                {
                                  notice(s_GameServ, u, "You can't carry any more!");
                                }
                          else
                                {
                                  notice(s_GameServ, u, "One %s coming right up!", tempItem->getItem()->getName().c_str());
                                  user->stats->subtractGold(tempItem->getItem()->price());
                                  notice(s_GameServ, u, "%d", user->stats->inventory->getCount());
                                }
                        }
                }
    }
  else
    {
      notice(s_GameServ, u, "Improper Syntax.");
      notice(s_GameServ, u, "Type /msg %S HELP TAVERN for help");
    }
  return;
}

void do_bank(char *u)
{
  char *cmd = strtok(NULL, " ");
  char *amount = strtok(NULL, " ");
  char *nick = strtok(NULL, " ");
  
  aClient *user;
  Player *p;
  
  if (!cmd || (!amount && stricmp(cmd, "BALANCE") != 0) || (stricmp(cmd, "TRANSFER") == 0 && !nick))
    {
          notice(s_GameServ, u, "BANK {WITHDRAW | DEPOSIT} {ALL | AMOUNT}");
          notice (s_GameServ, u, "BANK BALANCE");
          return;
    }
  else if (!(user = find(u)))
    {
          notice(s_GameServ, u, "Fatal Error. Couldn't find your aClient. Contact a(n) %S "\
                         " admin for help");
          log("Fatal Error. Couldn't find %s while executing do_bank()", u);
          return; 
    }
  else if (isIgnore(user))
    {
#ifdef DEBUGMODE
          log("Ignoring %s.", user->getNick());
#endif
          return;
    }
  else if (!is_playing(user))
    {
          notice(s_GameServ, u, "You must be playing to use the bank!");
          return;
    }
  else if (is_fighting(user))
    {
          notice(s_GameServ, u, "You can't go to the bank during a fight!");
          return;
    }
  updateTS(user->stats);
  if (stricmp(cmd, "BALANCE") == 0)
    {
          showBankBalance(u);
          return;
    }
  else if (!isAlive(user->stats))
    {
          notice(s_GameServ, u, "You are dead. We don't accept gold from dead folk! Wait 'til tomorrow!");
          return;
    }
  else if (!isstringnum(amount) && stricmp(amount, "ALL") != 0)
    {
          notice(s_GameServ, u, "I don't know how to convert alphabet letters into currency, sire!");
          return;
    }
  if (stringtoint(amount) < 0)
    {
          notice(s_GameServ, u, "Sorry. This bank is not licensed "\
                         "to handle such sums of cash, noble Lord.");
          return;
    }
  p = user->stats;
  
  if (stricmp(cmd, "DEPOSIT") == 0)
    {
          if (p->getBank() == 2000000000)
        {
                  notice(s_GameServ, u, "Your bank account is full, sire!");
                  return;
        }
          else if (stricmp(amount, "ALL") == 0)
        {
                  if (2000000000 - p->getBank() < p->getGold())
            {
                          notice(s_GameServ, u, "You don't have enough room for all of your gold.");
                          notice(s_GameServ, u, "Depositing %ld gold into your account", (2000000000 - p->getBank()));
                          p->subtractGold((2000000000 - p->getBank()));
                          p->setBank(2000000000);
                          showBankBalance(u);
            }
                  else
            {
                          notice(s_GameServ, u, "Depositing %ld gold into your account!", p->getGold());
                          p->addBank(p->getGold());
                          p->setGold(0);
                          showBankBalance(u);
            }
        }
          else if (stringtoint(amount) > p->getGold())
        {
                  notice(s_GameServ, u, "Sire, you only have %ld gold!", p->getGold());
                  showBankBalance(u);
                  return;
        }
          else
        {
                  if (2000000000 - p->getBank() < stringtoint(amount))
            {
                          notice(s_GameServ, u, "You don't have room in your account for that much.");
                          notice(s_GameServ, u, "Capping off your account with %ld gold!", (2000000000 - p->getBank()));
                          p->subtractGold((2000000000 - p->getBank()));
                          p->setBank(2000000000);
                          showBankBalance(u);
            }
                  else
            {
                          notice(s_GameServ, u, "Depositing %d gold into your account!", stringtoint(amount));
                          p->addBank(stringtoint(amount));
                          p->subtractGold(stringtoint(amount));
                          showBankBalance(u);
            }
        }
    }
  else if (stricmp(cmd, "WITHDRAW") == 0)
    {
          if (p->getGold() == 2000000000)
        {
                  notice(s_GameServ, u, "You cannot carry any more gold, sire!");
                  showBankBalance(u);
                  return;
        }
          else if (stricmp(amount, "ALL") == 0)
        {
                  if (2000000000 - p->getGold() < p->getBank())
            {
                          notice(s_GameServ, u, "You don't have enough room to carry all that gold.");
                          notice(s_GameServ, u, "Withdrawing %ld gold from your account", (2000000000 - p->getGold()));
                          p->subtractBank((2000000000 - p->getGold()));
                          p->setGold(2000000000);
                          showBankBalance(u);
            }
                  else
            {
                          notice(s_GameServ, u, "Withdrawing %ld gold from your account!", p->getBank());
                          p->addGold(p->getBank());
                          p->setBank(0);
                          showBankBalance(u);
            }
        }
          else if (stringtoint(amount) > p->getBank())
        {
                  notice(s_GameServ, u, "Sire, you only have %ld gold in the bank!", p->getBank());
                  showBankBalance(u);
                  return;
        }
          else
        {
                  if (2000000000 - p->getGold() < stringtoint(amount))
            {
                          notice(s_GameServ, u, "You don't enough have room to carry that much gold!");
                          notice(s_GameServ, u, "You fill your pockets with %ld gold!",
                                         (2000000000 - p->getGold()));
                          p->subtractBank((2000000000 - p->getGold()));
                          p->setGold(2000000000);
                          showBankBalance(u);
            }
                  else
            {
                          notice(s_GameServ, u, "Withdrawing %d gold from your account!", stringtoint(amount));
                          p->addGold(stringtoint(amount));
                          p->subtractBank(stringtoint(amount));
                          showBankBalance(u);
            }
        }
    } 
}

void do_dragon(char *u)
{
  aClient *user;
  
  if (!(user = find(u)))
    {
          notice(s_GameServ, u, "Fatal error. Contact a(n) %S admin. buf: %s", strtok(NULL, ""));
          return;
    }
  else if (isIgnore(user))
    {
#ifdef DEBUGMODE
          log("Ignoring %s.", user->getNick());
#endif
          return;
    }
  else if (!is_playing(user))
    {
          notice(s_GameServ, u, "You must be playing to fight the dragon!");
          return;
    }
  else if (is_fighting(user))
    {
          notice(s_GameServ, u, "You are already in a fight. How will you fight the almighty dragon!?");
          return;
    }
  else if (!isAlive(user->stats))
    {
          notice(s_GameServ, u, "You're dead. Wait until tomorrow to see your master!");
          return;
    }
  else if (user->stats->getLevel() < LEVELS)
    {
          notice(s_GameServ, u, "You fool! Only those strong enough "\
                         "to vanquish any foe should DARE fight the dragon!");
          notice(s_GameServ, u, "To put it in terms you can understand: "\
                         "You are too weak. You must be Level %d!", REALLEVELS);
          return;
    }
  
  updateTS(user->stats);
  
  Player *p = user->stats;
  setMaster(p);
  notice(s_GameServ, u, "You approach the dragon's lair cautiously.");
  notice(s_GameServ, u, "The stench of sulfer fills the air as a "\
                 "deep, red fog rolls in. The air is filled with the "\
                 "heated mist of deadly fire from beyond the cave "\
                 "entrance.");
  notice(s_GameServ, u, "You adjust your %s, tighten your grip on "\
                 "your %s, and venture into the hot, dark cave. "\
                 "You are surprised at the angle of descent as you climb "\
                 "lower and lower, deeper into the dragon's den.", 
                 (p->getArmor() ? p->getArmor()->getName().c_str() : "Fists"), (p->getWeapon() ? p->getWeapon()->getName().c_str() : "Birthday Suit"));
  notice(s_GameServ, u, "You come to the end of the cave to find "\
                 "a tooth. It is a large tooth... bigger than your torso."\
                 " Suddenly the darkness lifts from the gleam of an eye "\
                 " staring into your soul! The eye is large... HUGE!");
  notice(s_GameServ, u, "Just then you notice the eye begin to "\
                 "glare orange! The tooth is moving... but it is still too "\
                 "dark for you to make out.... THE DRAGON! You see it!");
  p->setMonster(new Monster(dragon));
  setDragonFight(p);
  display_monster(u);
}

void do_master(char *u)
{
  aClient *user;
  
  
  if (!(user = find(u)))
    {
          notice(s_GameServ, u, "Fatal error. Contact a(n) %S admin. buf: %s", strtok(NULL, ""));
          return;
    }
  else if (isIgnore(user))
    {
#ifdef DEBUGMODE
          log("Ignoring %s.", user->getNick());
#endif
          return;
    }
  else if (!is_playing(user))
    {
          notice(s_GameServ, u, "You must be playing to see your master!");
          return;
    }
  else if (is_fighting(user))
    {
          notice(s_GameServ, u, "You're in the middle of a fight! Pay attention!");
          return;
    }
  else if (!isAlive(user->stats))
    {
          notice(s_GameServ, u, "You're dead. Wait until tomorrow to see your master!");
          return;
    }
  
  updateTS(user->stats);
  
  char *cmd = strtok(NULL, " ");
  Player *p = user->stats;
  long int need = 0;
  
  if (seenMaster(p))
    {
          notice(s_GameServ, u, "You have already seen your master today. Wait until tomorrow to try again");
          return;
    }
  
  if (cmd != NULL)
    {
          switch(p->getLevel())
                {
            case 1:
                  need = 200;
                  break;
            case 2:
                  need = 800;
                  break;
            case 3:
                  need = 2000;
                  break;
            case 4:
                  need = 8000;
                  break;
            case 5:
                  need = 20000;
                  break;
            case 6:
                  need = 80000;
                  break;
            case 7:
                  need = 200000;
                  break;
            case 8:
                  need = 800000;
                  break;
            case 9:
                  need = 2000000;
                  break;
            case 10:
                  need = 8000000;
                  break;
            case 11:
                  need = 20000000;
                  break;
                  
            case REALLEVELS:
                  need = p->getExp() + 1;
                  notice(s_GameServ, u, "You are at level %d. You are the master. What's left? The DRAGON!", REALLEVELS);
                  return;
                  break;
            default:
                  need = p->getExp() + 1; // Unknown level... don't let them fight a fake master!
                  break;
                }   
    }
  else
    {
          notice(s_GameServ, u, "SYNTAX: MASTER {FIGHT | QUESTION}");
          return;
    }
  
  if (stricmp(cmd, "FIGHT") == 0)
    {
          if (p->getExp() >= need)
                {
                  setMaster(p);
                  see_master(u);
                }
          else
            notice(s_GameServ, u, "You are not worthy of fighting %s! You need %ld more experience.", 
                           levels[p->getLevel() - 1].master.name.c_str(), (need - p->getExp()));
          return;
    }
  else if (stricmp(cmd, "QUESTION") == 0)
    {
          if (p->getExp() >= need)
            notice(s_GameServ, u, "%s looks you up and down and decides you are more ready than you will ever be.", 
                           levels[p->getLevel() - 1].master.name.c_str());
          else
            notice(s_GameServ, u, "You pathetic fool! You are no match for %s, %s!", 
                           levels[p->getLevel() - 1].master.name.c_str(), p->getName().c_str());
          
          return;
    }
  else
    {
          notice(s_GameServ, u, "SYNTAX: MASTER {FIGHT | QUESTION}");
    }
}

void see_master(char *u)
{
  aClient *user;

  if (!(user = find(u)))
    {
          notice(s_GameServ, u, "Fatal error. Contact a(n) %S admin. buf: %s", strtok(NULL, ""));
          return;       
    }
  
  if (!is_fighting(user) && is_playing(user))
    {
          Monster *temp;
          Player *p = user->stats;
          temp = new Monster(levels[p->getLevel() - 1].master);
          p->setMyMaster(temp);
          p->setMonster(temp);
          display_monster(u);  // Since master is the same structure, use this function
    }
}

void showTavern(aClient *user)
{
  Player *p;
  list<tavernItem>::iterator item_iterator;
  item *tempItem;
  
  p = user->stats;
  
  if (!p)
    return;
  
  item_iterator = tavern.begin();
  if (tavern.empty())
    {
      notice(s_GameServ, user->getNick(), "Tavern is empty");
      return;
    }
  
  while (item_iterator != tavern.end())
    {
      if (p->getLevel() < (*item_iterator).getLevel())
                {
                  item_iterator++;
                  continue;
                }
      tempItem = (*item_iterator).getItem();
      notice(s_GameServ, user->getNick(), "%d. %s for %ld gold", tempItem->getID(), tempItem->getName().c_str(), tempItem->price());
      item_iterator++;
    }
}

void showBankBalance(const char *u)
{
  aClient *user;
  Player *p;
  
  if (!(user = find(u)))
        return;
  
  p = user->stats;
  
  if (!p)
        return;
  
  notice(s_GameServ, u, "Account Balance: %ld     Gold On hand: %ld", p->getBank(), p->getGold());
}

void rolloverall()
{
  ListNode <aClient> *it;
  Player *p;
  for (unsigned long x = 0; x < U_TABLE_SIZE; x++)
    {
      it = players[x].First();
      while (it)
                {
                  p = it->getData()->stats;
                  rollover(p);
                  it = it->Next();
                }
    }
}
void refreshall()
{
  ListNode <aClient> *it;
  Player *p;
  for (unsigned long x = 0; x < U_TABLE_SIZE; x++)
    {
      it = players[x].First();
      
      while (it)
                {
                  p = it->getData()->stats;
                  refresh(p);
                  it = it->Next();
                }
    }
}

void rollover(Player *p)
{
  if (!p)
    return;
  
  p->addForestFights(numrolloverfights);
  
  if (p->getForestFights() > maxforestfights)
    p->setForestFights(maxforestfights);
}

void refresh(Player *p)
{
  if (!p)
        return;

  if (p->getHP() < p->getMaxHP())
        p->healall();
  if (p->getForestFights() < forestfights)
        {
          p->setForestFights(forestfights);
        }
  
  p->setPlayerFights(3);
  setAlive(p);
  clearMaster(p);
}

void do_refresh(char *u)
{
  char *nick = strtok(NULL, " ");
  aClient *user;
  
  if (!(user = find(u)))
    {
          notice(s_GameServ, u, "Error: aClient not found. Contact a %S admin");
          log("Error: aClient not found: %s", u);
          return;
    }
  else if (isIgnore(user))
    {
#ifdef DEBUGMODE
          log("Ignoring %s.", user->getNick());
#endif
          return;
    }
  else if (!isAdmin(user))
    {
          notice(s_GameServ, u, "You must be a %S admin to use this command!");
          return;
    }
  if (!nick)
    {
          notice(s_GameServ, u, "SYNTAX: REFRESH {ALL | NICK}");
          return;
    }
  else if (stricmp(nick, "ALL") == 0)
    {
          notice(s_GameServ, u, "Refreshing everyone's stats!");
          refreshall();
    }
  else if ((user = findplayer(nick)))
    {
          if (is_playing(user))
                {
#ifdef P10
                  notice(s_GameServ, u, "Refreshing %s.", user->getRealNick());
#else
                  notice(s_GameServ, u, "Refreshing %s.", user->getNick());
#endif
                  refresh(user->stats);
                }
          else
                {
#ifdef P10
                  notice(s_GameServ, u, "%s is not playing.", user->getRealNick());
#else
                  notice(s_GameServ, u, "%s is not playing.", user->getNick());
#endif
                }
    }
  else
    {
          notice(s_GameServ, u, "Nick %s not found.", nick);
          return;
    }
}


void resetall()
{
  ListNode <aClient> *it;
  Player *p;
  
  for (unsigned long x = 0; x < U_TABLE_SIZE; x++)
        {
          it = players[x].First();
          
          while (it)
                {
                  p = it->getData()->stats;
                  reset(p);
                  it = it->Next();
                }
        }
}

void reset(Player *p)
{
  item *tempItem;
  if (!p)
        return;
  
  p->reset();
  tempItem = findItemByID(3001);
  p->inventory->addItem((*Items.begin()))->use(p); // Add the stick
  p->inventory->addItem(tempItem)->use(p); // Add Clothes
  
}

void updateTS(Player *p)
{
  if (!p)
        return;
  
#ifdef DEBUGMODE
  log("Old timestamp for %s: %ld", p->getName().c_str(), p->lastcommand);
#endif
  p->lastcommand = time(NULL);
#ifdef DEBUGMODE
  log("New timestamp for %s: %ld", p->getName().c_str(), p->lastcommand);
#endif
  
}

bool timedOut(Player *p)
{
  if (!p)
        return false;
  else if (p->lastcommand == 0)
        return false;
  else
    {
          if ((time(NULL) - p->lastcommand) >= maxidletime)
            return true;
          
          return false;
    }
}

void timeOutEvent(Player *p)
{
  aClient *user = findplayer(p->getName().c_str());
  
  if (!user || !p->getClient()) // then they're not playing
        return;
  
  char *nick = user->getNick();
  
  if (player_fight(user) && isYourTurn(p))
    {
          // Check to see if they were the idler or if it was the other 
          // person
          if (p->lastcommand != p->getBattle()->stats->lastcommand)
                {
                  // This person's last command was given earlier,
                  // so this person is the idler
                  notice(s_GameServ, nick, "You timed out "\
                                 "during a fight. You lose your turn!");
                  notice(s_GameServ, p->getBattle()->getNick(),
                                 "%s hesitated for too long. Your move.", p->getName().c_str());
                  clearYourTurn(p);
                  setYourTurn(p->getBattle()->stats);
                  
                  // Update the TS for both players to give them another
                  // Chance to wake up, but if the other player doesn't
                  // Attack now, they both get logged out.
                  updateTS(p);
                  p->getBattle()->stats->lastcommand = p->lastcommand;
                  display_players(p->getBattle());
                  return;
                }
          else
                {
                  notice(s_GameServ, p->getBattle()->getNick(),
                                 "You and %s timed out at the same time."\
                                 " Don't fight if you're just going to "\
                                 "sit there!", p->getName().c_str());
                  notice(s_GameServ, user->getNick(),
                                 "You and %s timed out at the same time."\
                                 " Don't fight if you're just going to "\
                                 "sit there!", p->getBattle()->stats->getName().c_str());
                  logout(p->getBattle());
                  logout(user);
                  return;
                }
    }
  else if (!player_fight(user))
    {
          if (isAlive(user->stats) && user->stats->getGold() > 0)
                {
                  // Place fun stuff here :)
                  int randnum = 1 + rand() % 100; // 1-100
#define GSN(s) notice(s_GameServ, nick, s)
#define GSN2(s, f) notice(s_GameServ, nick, s, f)
                  
                  if (randnum < 50)
                        {
                          // 35-100% of your gold goes pffft - kain
                          int stolen = (35 + (rand() % 66)) * (user->stats->getGold() / 100);
                          
                          GSN("You stop for a moment to rest on the "\
                                  "street corner. All of a sudden, you "\
                                  "are ambushed from all sides by a hoarde "\
                                  "of knife wielding thugs.");
                          GSN2("The thugs beat you into utter submission "\
                                   "and steal %ld gold from you!", stolen);
                          user->stats->subtractGold(stolen);
                        }
                  else if (randnum >= 50 && randnum < 75)
                        {
                          // 25-65% of your gold goes pffft - kain
                          int stolen = (25 + (rand() % 41)) * (user->stats->getGold() / 100);
                          GSN("While dilly dallying around, you lose "\
                                  "your sense of time. Little did you know, "\
                                  "but thieves lifted your gold while you "\
                                  "weren't watching.");
                          GSN2("Better luck next time... you lose %d gold", stolen);
                          user->stats->subtractGold(stolen);
                        }
                  else if (randnum >= 75)
                        {
                          // 25-75% of your gold goes pffft - kain
                          int stolen = (25 + (rand() % 51)) * (user->stats->getGold() / 100);
                          GSN("Good grief! A gaggle of gooey green ghostlike "\
                                  "goblins grabbed your gold!");
                          GSN2("They stole %d gold from you!", stolen);
                          user->stats->subtractGold(stolen);
                        }
                }
          
          // Always log out the user
          logout(user);
    }
}

void do_reset(char *u)
{
  char *nick = strtok(NULL, " ");
  aClient *user;
  
  if (!(user = find(u)))
    {
          notice(s_GameServ, u, "Error: aClient not found. Contact a %S admin");
          log("Error: aClient not found: %s", u);
          return;
    }
  else if (!isAdmin(user))
    {
          notice(s_GameServ, u, "You must be a %S admin to use this command!");
          return;
    }
  
  if (!nick)
    {
          notice(s_GameServ, u, "SYNTAX: RESET {ALL | NICK}");
          return;
    }
  else if (stricmp(nick, "ALL") == 0)
    {
          notice(s_GameServ, u, "Resetting everyone's stats!");
          resetall();
    }
  else if ((user = findplayer(nick)))
    {
          if (is_playing(user))
                {
#ifdef P10
                  notice(s_GameServ, u, "Resetting %s.", user->getRealNick());
#else
                  notice(s_GameServ, u, "Resetting %s.", user->getNick());
#endif
                  reset(user->stats);
                }
          else
                {
                  notice(s_GameServ, u, "Resetting %s", user->stats->getName().c_str());
                  reset(user->stats);
                }
    }
  else
    {
          notice(s_GameServ, u, "Nick %s not found.", nick);
          return;
    }
}

void do_help(char *u)
{
  char *cmd = strtok(NULL, " ");
  
  display_help(u, cmd);
}

void display_help(char *u, char *file)
{
  ifstream infile;
  char *buf;
  
  if (!file)
    {
          infile.open("helpfiles/help");
          if (infile.fail())
                {
                  log("Error opening helpfiles/help");
                  notice(s_GameServ, u, "Error opening helpfiles/help");
                  return;
                }
          buf = new char[1024];
          while(infile.getline(buf, 1024))
                {
                  // Written this way, it will process %S in the helpfiles
                  // Instead of notice(s_GameServ, u, "%s", buf);
                  notice(s_GameServ, u, buf);
                }
          
          // Minor recursion
          aClient *user = find(u);
          if (user && isAdmin(user))
            display_help(u, "admin_commands");
    }
  else
    {
          char *filename;
          filename = new char[strlen(file) + 11];
          strcpy(filename, "helpfiles/");
          strcat(filename, file);
          
          for (unsigned int x = 10; x < strlen(filename); x++)
            filename[x] = tolower(filename[x]);
          
          infile.open(filename);
          delete [] filename;
          if (infile.fail())
                {
                  notice(s_GameServ, u, "No help for \ 2%s\ 2", file);
                  return;
                }
          buf = new char[1024];
          while(infile.getline(buf, 1024))
                {
                  // Written this way, it will process %S in the helpfiles
                  // Instead of notice(s_GameServ, u, "%s", buf);
                  notice(s_GameServ, u, buf);
                }
    }
  infile.close();
  delete [] buf;
}

void do_admin(char *u)
{
  aClient *user;
  char *pass = strtok(NULL, " ");
  
  if (!(user = find(u)))
    {
          log("Error: aClient not found: %s", u);
          notice(s_GameServ, u, "Error: aClient not found. Contact %S admin.");
          return;
    }
  
  if (!pass)
    {
          notice(s_GameServ, u, "SYNTAX: \ 2ADMIN\ 2 \ 2\1fpassword\1f\ 2");
          return;
    }
  
  if (isAdmin(user))
    {
          notice(s_GameServ, u, "You already have administrator privledges.");
          return;
    }
  else if (strcmp(pass, adminpass) == 0)
    {
          notice(s_GameServ, u, "Password accepted. You now have administrator privledges.");
          setAdmin(user);
#ifdef P10
          log("%s became an administrator.", user->getRealNick());
#else
          log("%s became an administrator.", user->getNick());
#endif
    }
  else
    {
          notice(s_GameServ, u, "Invalid password. Remember: case sensitive");
          return;
    }
}

bool load_levels()
{
  char *filename;
  filename = new char[256];
  
  for (int x = 1; x <= LEVELS; x++)
    {
          sprintf(filename, "data/levels/level%d.dat", x);
          if (levels[x - 1].loadLevel(filename) == false)
            return false;
    }
  
  delete []filename;
  return true;
}
bool load_monsters()
{
  char *filename;
  ifstream infile;
  char *buf;
  buf = new char[2048];
  
  for (int level = 1; level <= LEVELS; level++)
        {
          filename = new char[256];
          sprintf(filename, "data/monsters/level%d.dat", level);
          infile.open(filename);
          
          if (!infile)
                {
                  log("Error opening %s", filename);
                  return false;
                }
          
#ifdef DEBUGMODE
          log("Loading monsters from %s", filename);
#endif
          
          while (infile.getline(buf, 2048))
                {
                  if (buf[0] == '^')
                        break;
                  if (buf[0] == '\n' || buf[0] == '\0' || buf[0] == '#')
                        continue;
                  Monster *temp;
                  temp = new Monster;
                  
                  temp->name = strtok(buf, "~");
                  temp->weapon = strtok(NULL, "~");
                  temp->death = strtok(NULL, "~");
                  
                  levels[level - 1].monsters.insertAtBack_RLN(temp);
                  delete temp;
                }
          delete [] filename;
          infile.close();
        }
  delete [] buf;
  return true;
}

item *findItemByID(int id)
{
  list<item*>::iterator item_iterator;
  
  item_iterator = Items.begin();
  
  while (item_iterator != Items.end())
    {
      if ((*item_iterator)->getID() == id)
                {
                  return (*item_iterator);
                }
      item_iterator++;
    }
  return NULL;
}

item *findStoreItemByID(int id)
{
  list<item*>::iterator item_iterator;
  
  item_iterator = store.begin();
  
  while (item_iterator != store.end())
    {
      if ((*item_iterator)->getID() == id)
                {
                  return (*item_iterator);
                }
      item_iterator++;
    }
  return NULL;
}

tavernItem *findTavernItemByID(int id)
{
  list<tavernItem>::iterator item_iterator;
  
  item_iterator = tavern.begin();
  
  while (item_iterator != tavern.end())
    {
      if ((*item_iterator).getItem()->getID() == id)
                {
                  return &(*item_iterator);
                }
      item_iterator++;
    }
  return NULL;
}