server/server/c_misc.C


/*
 * static char *rcsid_c_misc_c =
 *   "$Id: c_misc.C,v 1.6 2006-09-04 11:08:00 root Exp $";
 */

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2002 Mark Wedel & Crossfire Development Team
    Copyright (C) 1992 Frank Tore Johansen

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    The authors can be reached via e-mail at crossfire-devel@real-time.com
*/

#include <global.h>
#include <loader.h>
#ifndef __CEXTRACT__
# include <sproto.h>
#endif

extern weathermap_t **weathermap;

/* Handles misc. input request - things like hash table, malloc, maps,
 * who, etc.
 */

void
map_info (object *op, char *search)
{
  mapstruct *m;
  char buf[MAX_BUF], map_path[MAX_BUF];
  long sec = seconds ();

  new_draw_info_format (NDI_UNIQUE, 0, op, "Current time is: %02ld:%02ld:%02ld.", (sec % 86400) / 3600, (sec % 3600) / 60, sec % 60);
  new_draw_info (NDI_UNIQUE, 0, op, "Path               Pl PlM IM   TO Dif Reset");
  for (m = first_map; m != NULL; m = m->next)
    {

      if (search && strstr (m->path, search) == NULL)
        continue;               /* Skip unwanted maps */
      /* Print out the last 18 characters of the map name... */
      if (strlen (m->path) <= 18)
        strcpy (map_path, m->path);
      else
        strcpy (map_path, m->path + strlen (m->path) - 18);
      sprintf (buf, "%-18.18s %2d %2d   %1d %4d %2d  %02d:%02d:%02d",
               map_path, m->players, players_on_map (m, FALSE),
               m->in_memory, m->timeout, m->difficulty,
               (MAP_WHEN_RESET (m) % 86400) / 3600, (MAP_WHEN_RESET (m) % 3600) / 60, MAP_WHEN_RESET (m) % 60);
      new_draw_info (NDI_UNIQUE, 0, op, buf);
    }
}

/* This command dumps the body information for object *op.
 * it doesn't care what the params are.
 * This is mostly meant as a debug command.
 */
int
command_body (object *op, char *params)
{
  int i;

  /* Too hard to try and make a header that lines everything up, so just 
   * give a description.
   */
  new_draw_info (NDI_UNIQUE, 0, op, "The first column is the name of the body location.");
  new_draw_info (NDI_UNIQUE, 0, op, "The second column is how many of those locations your body has.");
  new_draw_info (NDI_UNIQUE, 0, op, "The third column is how many slots in that location are available.");
  for (i = 0; i < NUM_BODY_LOCATIONS; i++)
    {
      /* really debugging - normally body_used should not be set to anything
       * if body_info isn't also set.
       */
      if (op->body_info[i] || op->body_used[i])
        {
          new_draw_info_format (NDI_UNIQUE, 0, op, "%-30s %5d %5d", body_locations[i].use_name, op->body_info[i], op->body_used[i]);
        }
    }
  if (!QUERY_FLAG (op, FLAG_USE_ARMOUR))
    new_draw_info (NDI_UNIQUE, 0, op, "You are not allowed to wear armor");
  if (!QUERY_FLAG (op, FLAG_USE_WEAPON))
    new_draw_info (NDI_UNIQUE, 0, op, "You are not allowed to use weapons");

  return 1;
}


int
command_motd (object *op, char *params)
{
  display_motd (op);
  return 1;
}

int
command_bug (object *op, char *params)
{
  char buf[MAX_BUF];

  if (params == NULL)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "what bugs?");
      return 1;
    }
  strcpy (buf, op->name);
  strcat (buf, " bug-reports: ");
  strncat (buf, ++params, MAX_BUF - strlen (buf));
  buf[MAX_BUF - 1] = '\0';
  bug_report (buf);
  LOG (llevError, "%s\n", buf);
  new_draw_info (NDI_ALL | NDI_UNIQUE, 1, NULL, buf);
  new_draw_info (NDI_UNIQUE, 0, op, "OK, thanks!");
  return 1;
}

/* 
 * Pretty much identical to current map_info, but on a bigger scale 
 * This function returns the name of the players current region, and
 * a description of it. It is there merely for flavour text.
 */
void
current_region_info (object *op)
{
  /* 
   * Ok I /suppose/ I should write a seperate function for this, but it isn't
   * going to be /that/ slow, and won't get called much
   */
  region *r = get_region_by_name (get_name_of_region_for_map (op->map));

  if (!r)
    return;
  /* This should only be possible if regions are not operating on this server. */

  new_draw_info_format (NDI_UNIQUE, 0, op, "You are in %s. \n %s", get_region_longname (r), get_region_msg (r));
}

void
current_map_info (object *op)
{
  mapstruct *m = op->map;

  if (!m)
    return;

  new_draw_info_format (NDI_UNIQUE, 0, op, "%s (%s) in %s", m->name, m->path, get_name_of_region_for_map (m));

  if (QUERY_FLAG (op, FLAG_WIZ))
    {
      new_draw_info_format (NDI_UNIQUE, 0, op,
                            "players:%d difficulty:%d size:%dx%d start:%dx%d timeout %ld",
                            m->players, m->difficulty, MAP_WIDTH (m), MAP_HEIGHT (m), MAP_ENTER_X (m), MAP_ENTER_Y (m), MAP_TIMEOUT (m));

    }
  if (m->msg)
    new_draw_info (NDI_UNIQUE, NDI_NAVY, op, m->msg);
}

#ifdef DEBUG_MALLOC_LEVEL
int
command_malloc_verify (object *op, char *parms)
{
  extern int malloc_verify (void);

  if (!malloc_verify ())
    new_draw_info (NDI_UNIQUE, 0, op, "Heap is corrupted.");
  else
    new_draw_info (NDI_UNIQUE, 0, op, "Heap checks out OK.");
  return 1;
}
#endif

int
command_whereabouts (object *op, char *params)
{

  region *reg;
  player *pl;

  /*
   * reset the counter on the region, then use it to store the number of
   * players there.
   * I don't know how thread-safe this would be, I suspect not very....
   */
  for (reg = first_region; reg != NULL; reg = reg->next)
    {
      reg->counter = 0;
    }
  for (pl = first_player; pl != NULL; pl = pl->next)
    if (pl->ob->map != NULL)
      get_region_by_map (pl->ob->map)->counter++;

  /* we only want to print out by places with a 'longname' field... */
  for (reg = first_region; reg != NULL; reg = reg->next)
    {
      if (reg->longname == NULL && reg->counter > 0)
        {
          if (reg->parent != NULL)
            {
              reg->parent->counter += reg->counter;
              reg->counter = 0;
            }
          else                  /*uh oh, we shouldn't be here. */
            LOG (llevError, "command_whereabouts() Region %s with no longname has no parent", reg->name);
        }
    }
  new_draw_info_format (NDI_UNIQUE, 0, op, "In the world currently there are:");
  for (reg = first_region; reg != NULL; reg = reg->next)
    if (reg->counter > 0)
      new_draw_info_format (NDI_UNIQUE, 0, op, "%u players in %s", reg->counter, get_region_longname (reg));
  return 1;
}

typedef struct
{
  char namebuf[MAX_BUF];
  int login_order;
} chars_names;

/*local functon for qsort comparison*/
static int
name_cmp (const chars_names * c1, const chars_names * c2)
{
  return strcasecmp (c1->namebuf, c2->namebuf);
}

int
command_who (object *op, char *params)
{
  player *pl;
  uint16 i;
  region *reg;
  char *format;
  int num_players = 0;
  int num_wiz = 0;
  int num_afk = 0;
  chars_names *chars = NULL;

  /* 
   * The who formats are defined in config to be blank. They should have been
   * overridden by the settings file, if there are no entries however, it will
   * have stayed blank. Since this probably isn't what is wanted, we will check if
   * new formats have been specified, and if not we will use the old defaults.
   */
  if (!strcmp (settings.who_format, ""))
    strcpy (settings.who_format, "%N_%T%t%h%d%n[%m]");
  if (!strcmp (settings.who_wiz_format, ""))
    strcpy (settings.who_wiz_format, "%N_%T%t%h%d%nLevel %l [%m](@%i)(%c)");
  if (op == NULL || QUERY_FLAG (op, FLAG_WIZ))
    format = settings.who_wiz_format;
  else
    format = settings.who_format;

  reg = get_region_from_string (params);

  for (pl = first_player; pl != NULL; pl = pl->next)
    {
      if (pl->ob->map == NULL)
        continue;
      if (pl->hidden && !QUERY_FLAG (op, FLAG_WIZ))
        continue;

      if (!region_is_child_of_region (get_region_by_map (pl->ob->map), reg))
        continue;

      if (pl->state == ST_PLAYING || pl->state == ST_GET_PARTY_PASSWORD)
        {

          num_players++;
          chars = (chars_names *) realloc (chars, num_players * sizeof (chars_names));
          if (chars == NULL)
            {
              new_draw_info (NDI_UNIQUE, 0, op, "who failed - out of memory!");
              return 0;
            }
          sprintf (chars[num_players - 1].namebuf, "%s", &pl->ob->name);
          chars[num_players - 1].login_order = num_players;
          /*Check for WIZ's & AFK's */
          if (QUERY_FLAG (pl->ob, FLAG_WIZ))
            num_wiz++;
          if (QUERY_FLAG (pl->ob, FLAG_AFK))
            num_afk++;
        }
    }
  if (first_player != (player *) NULL)
    {
      if (reg == NULL)
        new_draw_info_format (NDI_UNIQUE, 0, op, "Total Players (%d) -- WIZ(%d) AFK(%d)", num_players, num_wiz, num_afk);
      else if (reg->longname == NULL)
        new_draw_info_format (NDI_UNIQUE, 0, op, "Total Players in %s (%d) -- WIZ(%d) AFK(%d)", reg->name, num_players, num_wiz, num_afk);
      else
        new_draw_info_format (NDI_UNIQUE, 0, op, "Total Players in %s (%d) -- WIZ(%d) AFK(%d)",
                              reg->longname, num_players, num_wiz, num_afk);
    }
  qsort (chars, num_players, sizeof (chars_names), (int (*)(const void *, const void *)) name_cmp);
  for (i = 0; i < num_players; i++)
    display_who_entry (op, find_player (chars[i].namebuf), format);
  free (chars);
  return 1;
}

/* Display a line of 'who' to op, about pl, using the formatting specified by format */
void
display_who_entry (object *op, player *pl, const char *format)
{
  char tmpbuf[MAX_BUF];
  char outbuf[MAX_BUF];
  size_t i;

  outbuf[0] = '\0';             /* we strcat to this, so reset it here. */
  if (pl == NULL)
    {
      LOG (llevError, "display_who_entry(): I was passed a null player");
      return;
    }
  for (i = 0; i <= strlen (format); i++)
    {
      if (format[i] == '%')
        {
          i++;
          get_who_escape_code_value (tmpbuf, format[i], pl);
          strcat (outbuf, tmpbuf);
        }
      else if (format[i] == '_')
        strcat (outbuf, " ");   /* allow '_' to be used in place of spaces */
      else
        {
          sprintf (tmpbuf, "%c", format[i]);
          strcat (outbuf, tmpbuf);
        }
    }
  new_draw_info (NDI_UNIQUE, 0, op, outbuf);
}

/* Returns the value of the escape code used in the who format specifier
 * the values are:
 * N    Name of character
 * t    title of character
 * T    the optional "the " sequence value (depend if player has own_title or not)
 * c    count
 * n    newline
 * h    [Hostile] if character is hostile, nothing otherwise
 * d    [WIZ] if character is a dm, nothing otherwise
 * a    [AFK] if character is afk, nothing otherwise
 * l    the level of the character
 * m    the map path the character is currently on
 * M    the map name of the map the character is currently on
 * r    the region name (eg scorn, wolfsburg)
 * R    the regional title (eg The Kingdom of Scorn, The Port of Wolfsburg)
 * i    player's ip adress
 * %    a literal %
 * _    a literal underscore
 */

void
get_who_escape_code_value (char *return_val, const char letter, player *pl)
{

  switch (letter)
    {
        case 'N':
          strcpy (return_val, pl->ob->name);
          break;
        case 't':
          strcpy (return_val, (pl->own_title[0] == '\0' ? pl->title : pl->own_title));
          break;
        case 'T':
          if (pl->own_title[0] == '\0')
            strcpy (return_val, "the ");
          else
            *return_val = '\0';
          break;
        case 'c':
          sprintf (return_val, "%d", pl->ob->count);
          break;
        case 'n':
          strcpy (return_val, "\n");
          break;
        case 'h':
          strcpy (return_val, pl->peaceful ? "" : " [Hostile]");
          break;
        case 'l':
          sprintf (return_val, "%d", pl->ob->level);
          break;
        case 'd':
          strcpy (return_val, (QUERY_FLAG (pl->ob, FLAG_WIZ) ? " [WIZ]" : ""));
          break;
        case 'a':
          strcpy (return_val, (QUERY_FLAG (pl->ob, FLAG_AFK) ? " [AFK]" : ""));
          break;
        case 'm':
          strcpy (return_val, pl->ob->map->path);
          break;
        case 'M':
          strcpy (return_val, pl->ob->map->name ? pl->ob->map->name : "Untitled");
          break;
        case 'r':
          strcpy (return_val, get_name_of_region_for_map (pl->ob->map));
          break;
        case 'R':
          strcpy (return_val, get_region_longname (get_region_by_map (pl->ob->map)));
          break;
        case 'i':
          strcpy (return_val, pl->socket.host);
          break;
        case '%':
          strcpy (return_val, "%");
          break;
        case '_':
          strcpy (return_val, "_");
          break;
    }

}


int
command_afk (object *op, char *params)
{
  if QUERY_FLAG
    (op, FLAG_AFK)
    {
      CLEAR_FLAG (op, FLAG_AFK);
      new_draw_info (NDI_UNIQUE, 0, op, "You are no longer AFK");
    }
  else
    {
      SET_FLAG (op, FLAG_AFK);
      new_draw_info (NDI_UNIQUE, 0, op, "You are now AFK");
    }
  return 1;
}

int
command_mapinfo (object *op, char *params)
{
  current_map_info (op);
  return 1;
}

int
command_whereami (object *op, char *params)
{
  current_region_info (op);
  return 1;
}

int
command_maps (object *op, char *params)
{
  map_info (op, params);
  return 1;
}

int
command_time (object *op, char *params)
{
  print_tod (op);
  return 1;
}

int
command_weather (object *op, char *params)
{
  int wx, wy, temp, sky;
  char buf[MAX_BUF];

  if (settings.dynamiclevel < 1)
    return 1;

  if (op->map == NULL)
    return 1;

  if (worldmap_to_weathermap (op->x, op->y, &wx, &wy, op->map) != 0)
    return 1;

  if (QUERY_FLAG (op, FLAG_WIZ))
    {
      /* dump the weather, Dm style! Yo! */
      new_draw_info_format (NDI_UNIQUE, 0, op, "Real temp: %d", real_world_temperature (op->x, op->y, op->map));
      new_draw_info_format (NDI_UNIQUE, 0, op, "Base temp: %d", weathermap[wx][wy].temp);
      new_draw_info_format (NDI_UNIQUE, 0, op, "Humid: %d", weathermap[wx][wy].humid);
      new_draw_info_format (NDI_UNIQUE, 0, op, "Wind: dir=%d speed=%d", weathermap[wx][wy].winddir, weathermap[wx][wy].windspeed);
      new_draw_info_format (NDI_UNIQUE, 0, op, "Pressure: %d", weathermap[wx][wy].pressure);
      new_draw_info_format (NDI_UNIQUE, 0, op, "Avg Elevation: %d", weathermap[wx][wy].avgelev);
      new_draw_info_format (NDI_UNIQUE, 0, op, "Rainfall: %d  Water: %d", weathermap[wx][wy].rainfall, weathermap[wx][wy].water);
    }

  temp = real_world_temperature (op->x, op->y, op->map);
  new_draw_info_format (NDI_UNIQUE, 0, op, "It's currently %d degrees " "Centigrade out.", temp);

  /* humid */
  if (weathermap[wx][wy].humid < 20)
    new_draw_info (NDI_UNIQUE, 0, op, "It is very dry.");
  else if (weathermap[wx][wy].humid < 40)
    new_draw_info (NDI_UNIQUE, 0, op, "It is very comfortable today.");
  else if (weathermap[wx][wy].humid < 60)
    new_draw_info (NDI_UNIQUE, 0, op, "It is a bit muggy.");
  else if (weathermap[wx][wy].humid < 80)
    new_draw_info (NDI_UNIQUE, 0, op, "It is muggy.");
  else
    new_draw_info (NDI_UNIQUE, 0, op, "It is uncomfortably muggy.");

  /* wind */
  switch (weathermap[wx][wy].winddir)
    {
        case 1:
          sprintf (buf, "north");
          break;
        case 2:
          sprintf (buf, "northeast");
          break;
        case 3:
          sprintf (buf, "east");
          break;
        case 4:
          sprintf (buf, "southeast");
          break;
        case 5:
          sprintf (buf, "south");
          break;
        case 6:
          sprintf (buf, "southwest");
          break;
        case 7:
          sprintf (buf, "west");
          break;
        case 8:
          sprintf (buf, "northwest");
          break;
    }
  if (weathermap[wx][wy].windspeed < 5)
    new_draw_info_format (NDI_UNIQUE, 0, op, "There is a mild breeze " "coming from the %s.", buf);
  else if (weathermap[wx][wy].windspeed < 10)
    new_draw_info_format (NDI_UNIQUE, 0, op, "There is a strong breeze " "coming from the %s.", buf);
  else if (weathermap[wx][wy].windspeed < 15)
    new_draw_info_format (NDI_UNIQUE, 0, op, "There is a light wind " "coming from the %s.", buf);
  else if (weathermap[wx][wy].windspeed < 25)
    new_draw_info_format (NDI_UNIQUE, 0, op, "There is a strong wind " "coming from the %s.", buf);
  else if (weathermap[wx][wy].windspeed < 35)
    new_draw_info_format (NDI_UNIQUE, 0, op, "There is a heavy wind " "coming from the %s.", buf);
  else
    new_draw_info_format (NDI_UNIQUE, 0, op, "The wind from the %s is " "incredibly strong!", buf);

  sky = weathermap[wx][wy].sky;
  if (temp <= 0 && sky > SKY_OVERCAST && sky < SKY_FOG)
    sky += 10;                  /*let it snow */
  switch (sky)
    {
        case SKY_CLEAR:
          new_draw_info (NDI_UNIQUE, 0, op, "There isn''t a cloud in the sky.");
          break;
        case SKY_LIGHTCLOUD:
          new_draw_info (NDI_UNIQUE, 0, op, "There are a few light clouds in the sky.");
          break;
        case SKY_OVERCAST:
          new_draw_info (NDI_UNIQUE, 0, op, "The sky is cloudy and dreary.");
          break;
        case SKY_LIGHT_RAIN:
          new_draw_info (NDI_UNIQUE, 0, op, "It is raining softly.");
          break;
        case SKY_RAIN:
          new_draw_info (NDI_UNIQUE, 0, op, "It is raining.");
          break;
        case SKY_HEAVY_RAIN:
          new_draw_info (NDI_UNIQUE, 0, op, "It is raining heavily.");
          break;
        case SKY_HURRICANE:
          new_draw_info (NDI_UNIQUE, 0, op, "There is a heavy storm!  You should go inside!");
          break;
        case SKY_FOG:
          new_draw_info (NDI_UNIQUE, 0, op, "It''s foggy and miserable.");
          break;
        case SKY_HAIL:
          new_draw_info (NDI_UNIQUE, 0, op, "It''s hailing out!  Take cover!");
          break;
        case SKY_LIGHT_SNOW:
          new_draw_info (NDI_UNIQUE, 0, op, "Snow is gently falling from the sky.");
          break;
        case SKY_SNOW:
          new_draw_info (NDI_UNIQUE, 0, op, "It''s snowing out.");
          break;
        case SKY_HEAVY_SNOW:
          new_draw_info (NDI_UNIQUE, 0, op, "The snow is falling very heavily now.");
          break;
        case SKY_BLIZZARD:
          new_draw_info (NDI_UNIQUE, 0, op, "A full blown blizzard is in effect.  You might want to take cover!");
          break;
    }
  return 1;
}

int
command_archs (object *op, char *params)
{
  arch_info (op);
  return 1;
}

int
command_hiscore (object *op, char *params)
{
  display_high_score (op, op == NULL ? 9999 : 50, params);
  return 1;
}

int
command_debug (object *op, char *params)
{
  int i;
  char buf[MAX_BUF];

  if (params == NULL || !sscanf (params, "%d", &i))
    {
      sprintf (buf, "Global debug level is %d.", settings.debug);
      new_draw_info (NDI_UNIQUE, 0, op, buf);
      return 1;
    }
  if (op != NULL && !QUERY_FLAG (op, FLAG_WIZ))
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Privileged command.");
      return 1;
    }
  settings.debug = (enum LogLevel) FABS (i);
  sprintf (buf, "Set debug level to %d.", i);
  new_draw_info (NDI_UNIQUE, 0, op, buf);
  return 1;
}


/*
 * Those dumps should be just one dump with good parser
 */

int
command_dumpbelow (object *op, char *params)
{
  if (op && op->below)
    {
      dump_object (op->below);
      new_draw_info (NDI_UNIQUE, 0, op, errmsg);
      /* Let's push that item on the dm's stack */
      dm_stack_push (op->contr, op->below->count);
    }
  return 0;
}

int
command_wizpass (object *op, char *params)
{
  int i;

  if (!op)
    return 0;

  if (!params)
    i = (QUERY_FLAG (op, FLAG_WIZPASS)) ? 0 : 1;
  else
    i = onoff_value (params);

  if (i)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You will now walk through walls.\n");
      SET_FLAG (op, FLAG_WIZPASS);
    }
  else
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You will now be stopped by walls.\n");
      CLEAR_FLAG (op, FLAG_WIZPASS);
    }
  return 0;
}

int
command_wizcast (object *op, char *params)
{
  int i;

  if (!op)
    return 0;

  if (!params)
    i = (QUERY_FLAG (op, FLAG_WIZCAST)) ? 0 : 1;
  else
    i = onoff_value (params);

  if (i)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You can now cast spells anywhere.");
      SET_FLAG (op, FLAG_WIZCAST);
    }
  else
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You now cannot cast spells in no-magic areas.");
      CLEAR_FLAG (op, FLAG_WIZCAST);
    }
  return 0;
}

int
command_dumpallobjects (object *op, char *params)
{
  dump_all_objects ();
  return 0;
}

int
command_dumpfriendlyobjects (object *op, char *params)
{
  dump_friendly_objects ();
  return 0;
}

int
command_dumpallarchetypes (object *op, char *params)
{
  dump_all_archetypes ();
  return 0;
}

int
command_dumpmap (object *op, char *params)
{
  if (op)
    dump_map (op->map);
  return 0;
}

int
command_dumpallmaps (object *op, char *params)
{
  dump_all_maps ();
  return 0;
}

int
command_printlos (object *op, char *params)
{
  if (op)
    print_los (op);
  return 0;
}


int
command_version (object *op, char *params)
{
  version (op);
  return 0;
}


#ifndef BUG_LOG
# define BUG_LOG "bug_log"
#endif
void
bug_report (const char *reportstring)
{
  FILE *fp;

  if ((fp = fopen (BUG_LOG, "a")) != NULL)
    {
      fprintf (fp, "%s\n", reportstring);
      fclose (fp);
    }
  else
    {
      LOG (llevError, "Cannot write bugs file %s: %s\n", BUG_LOG, strerror (errno));
    }
}

int
command_output_sync (object *op, char *params)
{
  int val;

  if (!params)
    {
      new_draw_info_format (NDI_UNIQUE, 0, op, "Output sync time is presently %d", op->contr->outputs_sync);
      return 1;
    }
  val = atoi (params);
  if (val > 0)
    {
      op->contr->outputs_sync = val;
      new_draw_info_format (NDI_UNIQUE, 0, op, "Output sync time now set to %d", op->contr->outputs_sync);
    }
  else
    new_draw_info (NDI_UNIQUE, 0, op, "Invalid value for output_sync.");

  return 1;
}

int
command_output_count (object *op, char *params)
{
  int val;

  if (!params)
    {
      new_draw_info_format (NDI_UNIQUE, 0, op, "Output count is presently %d", op->contr->outputs_count);
      return 1;
    }
  val = atoi (params);
  if (val > 0)
    {
      op->contr->outputs_count = val;
      new_draw_info_format (NDI_UNIQUE, 0, op, "Output count now set to %d", op->contr->outputs_count);
    }
  else
    new_draw_info (NDI_UNIQUE, 0, op, "Invalid value for output_count.");

  return 1;
}

int
command_listen (object *op, char *params)
{
  int i;

  if (params == NULL || !sscanf (params, "%d", &i))
    {
      new_draw_info_format (NDI_UNIQUE, 0, op, "Set listen to what (presently %d)?", op->contr->listening);
      return 1;
    }
  op->contr->listening = (char) i;
  new_draw_info_format (NDI_UNIQUE, 0, op, "Your verbose level is now %d.", i);
  return 1;
}

/* Prints out some useful information for the character.  Everything we print
 * out can be determined by the docs, so we aren't revealing anything extra -
 * rather, we are making it convenient to find the values.  params have
 * no meaning here.
 */
int
command_statistics (object *pl, char *params)
{
  if (!pl->contr)
    return 1;
#ifndef WIN32
  new_draw_info_format (NDI_UNIQUE, 0, pl, "  Experience: %lld", pl->stats.exp);
  new_draw_info_format (NDI_UNIQUE, 0, pl, "  Next Level: %lld", level_exp (pl->level + 1, pl->expmul));
#else
  new_draw_info_format (NDI_UNIQUE, 0, pl, "  Experience: %I64d", pl->stats.exp);
  new_draw_info_format (NDI_UNIQUE, 0, pl, "  Next Level: %I64d", level_exp (pl->level + 1, pl->expmul));
#endif
  new_draw_info (NDI_UNIQUE, 0, pl, "\nStat       Nat/Real/Max");

  new_draw_info_format (NDI_UNIQUE, 0, pl, "Str         %2d/ %3d/%3d",
                        pl->contr->orig_stats.Str, pl->stats.Str, 20 + pl->arch->clone.stats.Str);
  new_draw_info_format (NDI_UNIQUE, 0, pl, "Dex         %2d/ %3d/%3d",
                        pl->contr->orig_stats.Dex, pl->stats.Dex, 20 + pl->arch->clone.stats.Dex);
  new_draw_info_format (NDI_UNIQUE, 0, pl, "Con         %2d/ %3d/%3d",
                        pl->contr->orig_stats.Con, pl->stats.Con, 20 + pl->arch->clone.stats.Con);
  new_draw_info_format (NDI_UNIQUE, 0, pl, "Int         %2d/ %3d/%3d",
                        pl->contr->orig_stats.Int, pl->stats.Int, 20 + pl->arch->clone.stats.Int);
  new_draw_info_format (NDI_UNIQUE, 0, pl, "Wis         %2d/ %3d/%3d",
                        pl->contr->orig_stats.Wis, pl->stats.Wis, 20 + pl->arch->clone.stats.Wis);
  new_draw_info_format (NDI_UNIQUE, 0, pl, "Pow         %2d/ %3d/%3d",
                        pl->contr->orig_stats.Pow, pl->stats.Pow, 20 + pl->arch->clone.stats.Pow);
  new_draw_info_format (NDI_UNIQUE, 0, pl, "Cha         %2d/ %3d/%3d",
                        pl->contr->orig_stats.Cha, pl->stats.Cha, 20 + pl->arch->clone.stats.Cha);
  new_draw_info_format (NDI_UNIQUE, 0, pl, "\nAttack Mode: %s", pl->contr->peaceful ? "Peaceful" : "Hostile");

  /* Can't think of anything else to print right now */
  return 0;
}

int
command_fix_me (object *op, char *params)
{
  sum_weight (op);
  fix_player (op);
  return 1;
}

int
command_players (object *op, char *paramss)
{
  char buf[MAX_BUF];
  char *t;
  DIR *Dir;

  sprintf (buf, "%s/%s/", settings.localdir, settings.playerdir);
  t = buf + strlen (buf);
  if ((Dir = opendir (buf)) != NULL)
    {
      const struct dirent *Entry;

      while ((Entry = readdir (Dir)) != NULL)
        {
          /* skip '.' , '..' */
          if (!((Entry->d_name[0] == '.' && Entry->d_name[1] == '\0') ||
                (Entry->d_name[0] == '.' && Entry->d_name[1] == '.' && Entry->d_name[2] == '\0')))
            {
              struct stat Stat;

              strcpy (t, Entry->d_name);
              if (stat (buf, &Stat) == 0)
                {
                  /* This was not posix compatible
                   * if ((Stat.st_mode & S_IFMT)==S_IFDIR) {
                   */
                  if (S_ISDIR (Stat.st_mode))
                    {
                      char buf2[MAX_BUF];
                      struct tm *tm = localtime (&Stat.st_mtime);

                      sprintf (buf2, "%s\t%04d %02d %02d %02d %02d %02d",
                               Entry->d_name, 1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
                      new_draw_info (NDI_UNIQUE, 0, op, buf2);
                    }
                }
            }
        }
    }
  closedir (Dir);
  return 0;
}


int
command_logs (object *op, char *params)
{
  int i;
  int first;

  first = 1;
  for (i = 2; i < socket_info.allocated_sockets; i++)
    {
      if (init_sockets[i].old_mode == Old_Listen)
        {
          if (first)
            {
              new_draw_info (NDI_UNIQUE, 0, op, "Kill-logs are sent to:");
              first = 0;
            }
          new_draw_info_format (NDI_UNIQUE, 0, op, "%s: %s", init_sockets[i].host, init_sockets[i].comment);
        }
    }
  if (first)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Nobody is currently logging kills.");
    }
  return 1;
}

int
command_applymode (object *op, char *params)
{
  unapplymode unapply = op->contr->unapply;
  static const char *const types[] = { "nochoice", "never", "always" };

  if (!params)
    {
      new_draw_info_format (NDI_UNIQUE, 0, op, "applymode is set to %s", types[op->contr->unapply]);
      return 1;
    }

  if (!strcmp (params, "nochoice"))
    op->contr->unapply = unapply_nochoice;
  else if (!strcmp (params, "never"))
    op->contr->unapply = unapply_never;
  else if (!strcmp (params, "always"))
    op->contr->unapply = unapply_always;
  else
    {
      new_draw_info_format (NDI_UNIQUE, 0, op, "applymode: Unknown options %s, valid options are nochoice, never, always", params);
      return 0;
    }
  new_draw_info_format (NDI_UNIQUE, 0, op, "Applymode %s set to %s",
                        (unapply == op->contr->unapply ? "" : " now"), types[op->contr->unapply]);
  return 1;
}

int
command_bowmode (object *op, char *params)
{
  bowtype_t oldtype = op->contr->bowtype;
  static const char *const types[] = { "normal", "threewide", "spreadshot", "firenorth",
    "firene", "fireeast", "firese", "firesouth",
    "firesw", "firewest", "firenw", "bestarrow"
  };
  char buf[MAX_BUF];
  int i, found;

  if (!params)
    {
      new_draw_info_format (NDI_UNIQUE, 0, op, "bowmode is set to %s", types[op->contr->bowtype]);
      return 1;
    }

  for (i = 0, found = 0; i <= bow_bestarrow; i++)
    {
      if (!strcmp (params, types[i]))
        {
          found++;
          op->contr->bowtype = (bowtype_t) i;
          break;
        }
    }
  if (!found)
    {
      sprintf (buf, "bowmode: Unknown options %s, valid options are:", params);
      for (i = 0; i <= bow_bestarrow; i++)
        {
          strcat (buf, " ");
          strcat (buf, types[i]);
          if (i < bow_nw)
            strcat (buf, ",");
          else
            strcat (buf, ".");
        }
      new_draw_info_format (NDI_UNIQUE, 0, op, buf);
      return 0;
    }
  new_draw_info_format (NDI_UNIQUE, 0, op, "bowmode %s set to %s", (oldtype == op->contr->bowtype ? "" : "now"), types[op->contr->bowtype]);
  return 1;
}

int
command_petmode (object *op, char *params)
{
  petmode_t oldtype = op->contr->petmode;
  static const char *const types[] = { "normal", "sad", "defend", "arena" };

  if (!params)
    {
      new_draw_info_format (NDI_UNIQUE, 0, op, "petmode is set to %s", types[op->contr->petmode]);
      return 1;
    }

  if (!strcmp (params, "normal"))
    op->contr->petmode = pet_normal;
  else if (!strcmp (params, "sad"))
    op->contr->petmode = pet_sad;
  else if (!strcmp (params, "defend"))
    op->contr->petmode = pet_defend;
  else if (!strcmp (params, "arena"))
    op->contr->petmode = pet_arena;
  else
    {
      new_draw_info_format (NDI_UNIQUE, 0, op,
                            "petmode: Unknown options %s, valid options are normal," "sad (seek and destroy), defend, arena", params);
      return 0;
    }
  new_draw_info_format (NDI_UNIQUE, 0, op, "petmode %s set to %s", (oldtype == op->contr->petmode ? "" : "now"), types[op->contr->petmode]);
  return 1;
}

int
command_showpets (object *op, char *params)
{
  objectlink *obl, *next;
  int counter = 0, target = 0;
  int have_shown_pet = 0;

  if (params != NULL)
    target = atoi (params);
  for (obl = first_friendly_object; obl != NULL; obl = next)
    {
      object *ob = obl->ob;

      next = obl->next;
      if (get_owner (ob) == op)
        {
          if (target == 0)
            {
              if (counter == 0)
                new_draw_info (NDI_UNIQUE, 0, op, "Pets:");
              new_draw_info_format (NDI_UNIQUE, 0, op, "%d  %s - level %d", ++counter, &ob->name, ob->level);
            }
          else if (!have_shown_pet && ++counter == target)
            {
              new_draw_info_format (NDI_UNIQUE, 0, op, "level %d %s", ob->level, &ob->name);
              new_draw_info_format (NDI_UNIQUE, 0, op, "%d/%d HP, %d/%d SP", ob->stats.hp, ob->stats.maxhp, ob->stats.sp, ob->stats.maxsp);
              /* this is not a nice way to do this, it should be made to be more like the statistics command */
              new_draw_info_format (NDI_UNIQUE, 0, op, "Str %d", ob->stats.Str);
              new_draw_info_format (NDI_UNIQUE, 0, op, "Dex %d", ob->stats.Dex);
              new_draw_info_format (NDI_UNIQUE, 0, op, "Con %d", ob->stats.Con);
              new_draw_info_format (NDI_UNIQUE, 0, op, "Int %d", ob->stats.Int);
              new_draw_info_format (NDI_UNIQUE, 0, op, "Wis %d", ob->stats.Wis);
              new_draw_info_format (NDI_UNIQUE, 0, op, "Cha %d", ob->stats.Cha);
              new_draw_info_format (NDI_UNIQUE, 0, op, "Pow %d", ob->stats.Pow);
              new_draw_info_format (NDI_UNIQUE, 0, op, "wc %d  damage %d ac %d ", ob->stats.wc, ob->stats.dam, ob->stats.ac);
              have_shown_pet = 1;
            }
        }
    }
  if (counter == 0)
    new_draw_info (NDI_UNIQUE, 0, op, "you have no pets.");
  else if (target != 0 && have_shown_pet == 0)
    new_draw_info (NDI_UNIQUE, 0, op, "no such pet.");
  return 0;
}

int
command_usekeys (object *op, char *params)
{
  usekeytype oldtype = op->contr->usekeys;
  static const char *const types[] = { "inventory", "keyrings", "containers" };

  if (!params)
    {
      new_draw_info_format (NDI_UNIQUE, 0, op, "usekeys is set to %s", types[op->contr->usekeys]);
      return 1;
    }

  if (!strcmp (params, "inventory"))
    op->contr->usekeys = key_inventory;
  else if (!strcmp (params, "keyrings"))
    op->contr->usekeys = keyrings;
  else if (!strcmp (params, "containers"))
    op->contr->usekeys = containers;
  else
    {
      new_draw_info_format (NDI_UNIQUE, 0, op, "usekeys: Unknown options %s, valid options are inventory, keyrings, containers", params);
      return 0;
    }
  new_draw_info_format (NDI_UNIQUE, 0, op, "usekeys %s set to %s", (oldtype == op->contr->usekeys ? "" : "now"), types[op->contr->usekeys]);
  return 1;
}

int
command_resistances (object *op, char *params)
{
  int i;

  if (!op)
    return 0;

  for (i = 0; i < NROFATTACKS; i++)
    {
      if (i == ATNR_INTERNAL)
        continue;

      new_draw_info_format (NDI_UNIQUE, 0, op, "%-20s %+5d", attacktype_desc[i], op->resist[i]);
    }

  /* If dragon player, let's display natural resistances */
  if (is_dragon_pl (op))
    {
      int attack;
      object *tmp;

      for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
        {
          if ((tmp->type == FORCE) && (strcmp (tmp->arch->name, "dragon_skin_force") == 0))
            {
              new_draw_info (NDI_UNIQUE, 0, op, "\nNatural skin resistances:");
              for (attack = 0; attack < NROFATTACKS; attack++)
                {
                  if (atnr_is_dragon_enabled (attack))
                    {
                      new_draw_info_format (NDI_UNIQUE, 0, op, "%s: %d", change_resist_msg[attack], tmp->resist[attack]);
                    }
                }
              break;
            }
        }
    }

  return 0;
}

/*
 * Actual commands.
 * Those should be in small separate files (c_object.c, c_wiz.c, cmove.c,...)
 */


static void
help_topics (object *op, int what)
{
  DIR *dirp;
  struct dirent *de;
  char filename[MAX_BUF], line[80];
  int namelen, linelen = 0;

  switch (what)
    {
        case 1:
          sprintf (filename, "%s/wizhelp", settings.datadir);
          new_draw_info (NDI_UNIQUE, 0, op, "      Wiz commands:");
          break;
        case 3:
          sprintf (filename, "%s/mischelp", settings.datadir);
          new_draw_info (NDI_UNIQUE, 0, op, "      Misc help:");
          break;
        default:
          sprintf (filename, "%s/help", settings.datadir);
          new_draw_info (NDI_UNIQUE, 0, op, "      Commands:");
          break;
    }
  if (!(dirp = opendir (filename)))
    return;

  line[0] = '\0';
  for (de = readdir (dirp); de; de = readdir (dirp))
    {
      namelen = NAMLEN (de);
      if (namelen <= 2 && *de->d_name == '.' && (namelen == 1 || de->d_name[1] == '.'))
        continue;
      linelen += namelen + 1;
      if (linelen > 42)
        {
          new_draw_info (NDI_UNIQUE, 0, op, line);
          sprintf (line, " %s", de->d_name);
          linelen = namelen + 1;
          continue;
        }
      strcat (line, " ");
      strcat (line, de->d_name);
    }
  new_draw_info (NDI_UNIQUE, 0, op, line);
  closedir (dirp);
}

static void
show_commands (object *op, int what)
{
  char line[80];
  int i, size, namelen, linelen = 0;
  CommArray_s *ap;
  extern CommArray_s Commands[], WizCommands[];
  extern const int CommandsSize, WizCommandsSize;

  switch (what)
    {
        case 1:
          ap = WizCommands;
          size = WizCommandsSize;
          new_draw_info (NDI_UNIQUE, 0, op, "      Wiz commands:");
          break;
        case 2:
          ap = CommunicationCommands;
          size = CommunicationCommandSize;
          new_draw_info (NDI_UNIQUE, 0, op, "      Communication commands:");
          break;
        default:
          ap = Commands;
          size = CommandsSize;
          new_draw_info (NDI_UNIQUE, 0, op, "      Commands:");
          break;
    }

  line[0] = '\0';
  for (i = 0; i < size; i++)
    {
      namelen = strlen (ap[i].name);
      linelen += namelen + 1;
      if (linelen > 42)
        {
          new_draw_info (NDI_UNIQUE, 0, op, line);
          sprintf (line, " %s", ap[i].name);
          linelen = namelen + 1;
          continue;
        }
      strcat (line, " ");
      strcat (line, ap[i].name);
    }
  new_draw_info (NDI_UNIQUE, 0, op, line);
}


int
command_help (object *op, char *params)
{
  struct stat st;
  FILE *fp;
  char filename[MAX_BUF], line[MAX_BUF];
  int len;

  if (op != NULL)
    clear_win_info (op);

/*
   * Main help page?
 */
  if (!params)
    {
      sprintf (filename, "%s/def_help", settings.datadir);
      if ((fp = fopen (filename, "r")) == NULL)
        {
          LOG (llevError, "Cannot open help file %s: %s\n", filename, strerror (errno));
          return 0;
        }
      while (fgets (line, MAX_BUF, fp))
        {
          line[MAX_BUF - 1] = '\0';
          len = strlen (line) - 1;
          if (line[len] == '\n')
            line[len] = '\0';
          new_draw_info (NDI_UNIQUE, 0, op, line);
        }
      fclose (fp);
      return 0;
    }

  /*
   * Topics list
   */
  if (!strcmp (params, "topics"))
    {
      help_topics (op, 3);
      help_topics (op, 0);
      if (QUERY_FLAG (op, FLAG_WIZ))
        help_topics (op, 1);
      return 0;
    }

  /*
   * Commands list
   */
  if (!strcmp (params, "commands"))
    {
      show_commands (op, 0);
      show_commands (op, 2);    /* show comm commands */
      if (QUERY_FLAG (op, FLAG_WIZ))
        show_commands (op, 1);
      return 0;
    }

  /*
   * User wants info about command
   */
  if (strchr (params, '.') || strchr (params, ' ') || strchr (params, '/'))
    {
      sprintf (line, "Illegal characters in '%s'", params);
      new_draw_info (NDI_UNIQUE, 0, op, line);
      return 0;
    }

  sprintf (filename, "%s/mischelp/%s", settings.datadir, params);
  if (stat (filename, &st) || !S_ISREG (st.st_mode))
    {
      if (op)
        {
          sprintf (filename, "%s/help/%s", settings.datadir, params);
          if (stat (filename, &st) || !S_ISREG (st.st_mode))
            {
              if (QUERY_FLAG (op, FLAG_WIZ))
                {
                  sprintf (filename, "%s/wizhelp/%s", settings.datadir, params);
                  if (stat (filename, &st) || !S_ISREG (st.st_mode))
                    goto nohelp;
                }
              else
                goto nohelp;
            }
        }
    }

  /*
   * Found that. Just cat it to screen.
   */
  if ((fp = fopen (filename, "r")) == NULL)
    {
      LOG (llevError, "Cannot open help file %s: %s\n", filename, strerror (errno));
      return 0;
    }
  sprintf (line, "Help about '%s'", params);
  new_draw_info (NDI_UNIQUE, 0, op, line);
  while (fgets (line, MAX_BUF, fp))
    {
      line[MAX_BUF - 1] = '\0';
      len = strlen (line) - 1;
      if (line[len] == '\n')
        line[len] = '\0';
      new_draw_info (NDI_UNIQUE, 0, op, line);
    }
  fclose (fp);
  return 0;

  /*
   * No_help -escape
   */
nohelp:
  sprintf (line, "No help available on '%s'", params);
  new_draw_info (NDI_UNIQUE, 0, op, line);
  return 0;
}


int
onoff_value (const char *line)
{
  int i;

  if (sscanf (line, "%d", &i))
    return (i != 0);
  switch (line[0])
    {
        case 'o':
          switch (line[1])
            {
                case 'n':
                  return 1;     /* on */
                default:
                  return 0;     /* o[ff] */
            }
        case 'y':              /* y[es] */
        case 'k':              /* k[ylla] */
        case 's':
        case 'd':
          return 1;
        case 'n':              /* n[o] */
        case 'e':              /* e[i] */
        case 'u':
        default:
          return 0;
    }
}

int
command_quit (object *op, char *params)
{
  new_draw_info (NDI_UNIQUE, 0, op,
                 "Quitting will delete your character PERMANENTLY. If you are sure you want to do this, then use the quit_character command instead of quit.");
  return 1;
}

int
command_real_quit (object *op, char *params)
{
  send_query (&op->contr->socket, CS_QUERY_SINGLECHAR, "Quitting will delete your character.\nAre you sure you want to quit (y/n):");

  op->contr->state = ST_CONFIRM_QUIT;
  return 1;
}

/*
 * don't allow people to exit explore mode.  It otherwise becomes
 * really easy to abuse this.
 */
int
command_explore (object *op, char *params)
{
  if (settings.explore_mode == FALSE)
    return 1;
  /*
   * I guess this is the best way to see if we are solo or not.  Actually,
   * are there any cases when first_player->next==NULL and we are not solo?
   */
  if ((first_player != op->contr) || (first_player->next != NULL))
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You can not enter explore mode if you are in a party");
    }
  else if (op->contr->explore)
    new_draw_info (NDI_UNIQUE, 0, op, "There is no return from explore mode");
  else
    {
      op->contr->explore = 1;
      new_draw_info (NDI_UNIQUE, 0, op, "You are now in explore mode");
    }
  return 1;
}

int
command_sound (object *op, char *params)
{
  if (op->contr->socket.sound)
    {
      op->contr->socket.sound = 0;
      new_draw_info (NDI_UNIQUE, 0, op, "Silence is golden...");
    }
  else
    {
      op->contr->socket.sound = 1;
      new_draw_info (NDI_UNIQUE, 0, op, "The sounds are enabled.");
    }
  return 1;
}

/* Perhaps these should be in player.c, but that file is
 * already a bit big.
 */

void
receive_player_name (object *op, char k)
{

  if (!check_name (op->contr, op->contr->write_buf + 1))
    {
      get_name (op);
      return;
    }
  op->name = op->contr->write_buf + 1;
  op->name_pl = op->contr->write_buf + 1;
  new_draw_info (NDI_UNIQUE, 0, op, op->contr->write_buf);
  op->contr->name_changed = 1;
  get_password (op);
}

void
receive_player_password (object *op, char k)
{

  unsigned int pwd_len = strlen (op->contr->write_buf);

  if (pwd_len <= 1 || pwd_len > 17)
    {
      get_name (op);
      return;
    }
  new_draw_info (NDI_UNIQUE, 0, op, "          ");      /* To hide the password better */

  if (checkbanned (op->name, op->contr->socket.host))
    {
      LOG (llevInfo, "Banned player tried to add: [%s@%s]\n", &op->name, op->contr->socket.host);
      new_draw_info (NDI_UNIQUE | NDI_RED, 0, op, "You are not allowed to play.");
      get_name (op);
      return;
    }

  if (op->contr->state == ST_CONFIRM_PASSWORD)
    {
      if (!check_password (op->contr->write_buf + 1, op->contr->password))
        {
          new_draw_info (NDI_UNIQUE, 0, op, "The passwords did not match.");
          get_name (op);
          return;
        }
      clear_win_info (op);
      display_motd (op);
      new_draw_info (NDI_UNIQUE, 0, op, " ");
      new_draw_info (NDI_UNIQUE, 0, op, "Welcome, Brave New Warrior!");
      new_draw_info (NDI_UNIQUE, 0, op, " ");
      Roll_Again (op);
      op->contr->state = ST_ROLL_STAT;
      return;
    }
  strcpy (op->contr->password, crypt_string (op->contr->write_buf + 1, NULL));
  op->contr->state = ST_ROLL_STAT;
  check_login (op);
  return;
}


int
explore_mode (void)
{
  player *pl;

  if (settings.explore_mode == TRUE)
    {
      for (pl = first_player; pl != (player *) NULL; pl = pl->next)
        if (pl->explore)
          return 1;
    }
  return 0;
}


int
command_title (object *op, char *params)
{
  char buf[MAX_BUF];

  if (settings.set_title == FALSE)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You cannot change your title.");
      return 1;
    }

  /* dragon players cannot change titles */
  if (is_dragon_pl (op))
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Dragons cannot change titles.");
      return 1;
    }

  if (params == NULL)
    {
      if (op->contr->own_title[0] == '\0')
        sprintf (buf, "Your title is '%s'.", op->contr->title);
      else
        sprintf (buf, "Your title is '%s'.", op->contr->own_title);
      new_draw_info (NDI_UNIQUE, 0, op, buf);
      return 1;
    }
  if (strcmp (params, "clear") == 0 || strcmp (params, "default") == 0)
    {
      if (op->contr->own_title[0] == '\0')
        new_draw_info (NDI_UNIQUE, 0, op, "Your title is the default title.");
      else
        new_draw_info (NDI_UNIQUE, 0, op, "Title set to default.");
      op->contr->own_title[0] = '\0';
      return 1;
    }

  if ((int) strlen (params) >= MAX_NAME)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "Title too long.");
      return 1;
    }
  strcpy (op->contr->own_title, params);
  return 1;
}

int
command_save (object *op, char *params)
{
//    if (get_map_flags(op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_CLERIC) {
//      new_draw_info(NDI_UNIQUE, 0, op, "You can not save on unholy ground");
//    } else
  if (!op->stats.exp)
    {
      new_draw_info (NDI_UNIQUE, 0, op, "You don't deserve to save yet.");
    }
  else
    {
      if (save_player (op, 1))
        new_draw_info (NDI_UNIQUE, 0, op, "You have been saved.");
      else
        new_draw_info (NDI_UNIQUE, 0, op, "SAVE FAILED!");
    }
  return 1;
}


int
command_peaceful (object *op, char *params)
{
  new_draw_info (NDI_UNIQUE, 0, op,
                 "You cannot change your peaceful setting with this command."
                 " Please speak to the priest in the temple of Gorokh"
                 " if you want to become hostile or in temple of Valriel" " if you want to become peaceful again.");

/*
  if((op->contr->peaceful=!op->contr->peaceful))
    new_draw_info(NDI_UNIQUE, 0,op,"You will not attack other players.");
  else
    new_draw_info(NDI_UNIQUE, 0,op,"You will attack other players.");
*/
  return 1;
}


int
command_wimpy (object *op, char *params)
{
  int i;
  char buf[MAX_BUF];

  if (params == NULL || !sscanf (params, "%d", &i))
    {
      sprintf (buf, "Your current wimpy level is %d.", op->run_away);
      new_draw_info (NDI_UNIQUE, 0, op, buf);
      return 1;
    }
  sprintf (buf, "Your new wimpy level is %d.", i);
  new_draw_info (NDI_UNIQUE, 0, op, buf);
  op->run_away = i;
  return 1;
}


int
command_brace (object *op, char *params)
{
  if (!params)
    op->contr->braced = !op->contr->braced;
  else
    op->contr->braced = onoff_value (params);

  if (op->contr->braced)
    new_draw_info (NDI_UNIQUE, 0, op, "You are braced.");
  else
    new_draw_info (NDI_UNIQUE, 0, op, "Not braced.");

  fix_player (op);
  return 0;
}

int
command_style_map_info (object *op, char *params)
{
  extern mapstruct *styles;
  mapstruct *mp;
  int maps_used = 0, mapmem = 0, objects_used = 0, x, y;
  object *tmp;

  for (mp = styles; mp != NULL; mp = mp->next)
    {
      maps_used++;
      mapmem += MAP_WIDTH (mp) * MAP_HEIGHT (mp) * (sizeof (object *) + sizeof (MapSpace)) + sizeof (mapstruct);
      for (x = 0; x < MAP_WIDTH (mp); x++)
        {
          for (y = 0; y < MAP_HEIGHT (mp); y++)
            {
              for (tmp = get_map_ob (mp, x, y); tmp != NULL; tmp = tmp->above)
                objects_used++;
            }
        }
    }
  new_draw_info_format (NDI_UNIQUE, 0, op, "Style maps loaded:    %d", maps_used);
  new_draw_info (NDI_UNIQUE, 0, op, "Memory used, not");
  new_draw_info_format (NDI_UNIQUE, 0, op, "including objects:    %d", mapmem);
  new_draw_info_format (NDI_UNIQUE, 0, op, "Style objects:        %d", objects_used);
  new_draw_info_format (NDI_UNIQUE, 0, op, "Mem for objects:      %d", objects_used * sizeof (object));
  return 0;
}

int
command_kill_pets (object *op, char *params)
{
  objectlink *obl, *next;
  int counter = 0, removecount = 0;

  if (params == NULL)
    {
      terminate_all_pets (op);
      new_draw_info (NDI_UNIQUE, 0, op, "Your pets have been killed.");
    }
  else
    {
      int target = atoi (params);

      for (obl = first_friendly_object; obl != NULL; obl = next)
        {
          object *ob = obl->ob;

          next = obl->next;
          if (get_owner (ob) == op)
            if (++counter == target || (target == 0 && !strcasecmp (ob->name, params)))
              {
                if (!QUERY_FLAG (ob, FLAG_REMOVED))
                  remove_ob (ob);
                remove_friendly_object (ob);
                free_object (ob);
                removecount++;
              }
        }
      if (removecount != 0)
        new_draw_info_format (NDI_UNIQUE, 0, op, "killed %d pets.\n", removecount);
      else
        new_draw_info (NDI_UNIQUE, 0, op, "Couldn't find any suitable pets to kill.\n");
    }
  return 0;
}
Revision:	1.7
Committed:	Sun Sep 10 15:59:57 2006 UTC (17 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.6:	+1280 -1074 lines
Log Message:	indent