server/server/init.C

/*
 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
 * 
 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Crossfire TRT 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 3 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, see <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <crossfire@schmorp.de>
 */

#include <global.h>
#include <material.h>
#include <loader.h>
#include <sproto.h>

void
set_logfile (char *val)
{
  settings.logfilename = val;
}

void
call_version (void)
{
  version (NULL);
  exit (0);
}

void
showscores (void)
{
  display_high_score (NULL, 9999, NULL);
  exit (0);
}

void
set_debug (void)
{
  settings.debug = llevDebug;
}

void
unset_debug (void)
{
  settings.debug = llevInfo;
}

void
set_mondebug (void)
{
  settings.debug = llevMonster;
}

void
set_dumpmon1 (void)
{
  settings.dumpvalues = 1;
}

void
set_dumpmon2 (void)
{
  settings.dumpvalues = 2;
}

void
set_dumpmon3 (void)
{
  settings.dumpvalues = 3;
}

void
set_dumpmon4 (void)
{
  settings.dumpvalues = 4;
}

void
set_dumpmon5 (void)
{
  settings.dumpvalues = 5;
}

void
set_dumpmon6 (void)
{
  settings.dumpvalues = 6;
}

void
set_dumpmon7 (void)
{
  settings.dumpvalues = 7;
}

void
set_dumpmon8 (void)
{
  settings.dumpvalues = 8;
}

void
set_dumpmon9 (void)
{
  settings.dumpvalues = 9;
}

void
set_dumpmont (char *name)
{
  settings.dumpvalues = 10;
  settings.dumparg = name;
}

void
set_daemon (void)
{
  settings.daemonmode = 1;
}

void
set_datadir (char *path)
{
  settings.datadir = path;
}

void
set_confdir (char *path)
{
  settings.confdir = path;
}

void
set_localdir (char *path)
{
  settings.localdir = path;
}

void
set_mapdir (char *path)
{
  settings.mapdir = path;
}

void
set_archetypes (char *path)
{
  settings.archetypes = path;
}

void
set_regions (char *path)
{
  settings.regions = path;
}

void
set_treasures (char *path)
{
  settings.treasures = path;
}

void
set_uniquedir (char *path)
{
  settings.uniquedir = path;
}

void
set_templatedir (char *path)
{
  settings.templatedir = path;
}

void
set_playerdir (char *path)
{
  settings.playerdir = path;
}

void
set_tmpdir (char *path)
{
  settings.tmpdir = path;
}

void
showscoresparm (char *data)
{
  display_high_score (NULL, 9999, data);
  exit (0);
}

void
set_csport (char *val)
{
  settings.csport = atoi (val);
  if (settings.csport <= 0 || settings.csport > 32765 || (settings.csport < 1024 && getuid () != 0))
    {
      LOG (llevError, "%d is an invalid csport number.\n", settings.csport);
      exit (1);
    }
}

/* Most of this is shamelessly stolen from XSysStats.  But since that is
 * also my program, no problem.
 */
struct Command_Line_Options
{
  const char *cmd_option;       /* how it is called on the command line */
  uint8 num_args;               /* Number or args it takes */
  uint8 pass;                   /* What pass this should be processed on. */
  void (*func) ();              /* function to call when we match this.
                                 * if num_args is true, than that gets passed
                                 * to the function, otherwise nothing is passed
                                 */
};

/* The way this system works is pretty simple - parse_args takes
 * the options passed to the program and a pass number.  If an option
 * matches both in name and in pass (and we have enough options),
 * we call the associated function.  This makes writing a multi
 * pass system very easy, and it is very easy to add in new options.
 */
struct Command_Line_Options options[] = {

/* Pass 1 functions - STuff that can/should be called before we actually
 * initialise any data.
 */
  {"-h", 0, 1, help},

/* Honor -help also, since it is somewhat common */
  {"-help", 0, 1, help},
  {"-v", 0, 1, call_version},
  {"-d", 0, 1, set_debug},
  {"+d", 0, 1, unset_debug},
  {"-mon", 0, 1, set_mondebug},
  {"-data", 1, 1, (void (*)()) set_datadir},
  {"-conf", 1, 1, (void (*)()) set_confdir},
  {"-local", 1, 1, (void (*)()) set_localdir},
  {"-maps", 1, 1, (void (*)()) set_mapdir},
  {"-arch", 1, 1, (void (*)()) set_archetypes},
  {"-regions", 1, 1, (void (*)()) set_regions},
  {"-playerdir", 1, 1, (void (*)()) set_playerdir},
  {"-treasures", 1, 1, (void (*)()) set_treasures},
  {"-uniquedir", 1, 1, (void (*)()) set_uniquedir},
  {"-templatedir", 1, 1, (void (*)()) set_templatedir},
  {"-tmpdir", 1, 1, (void (*)()) set_tmpdir},
  {"-log", 1, 1, (void (*)()) set_logfile},

/* Pass 2 functions.  Most of these could probably be in pass 1, 
 * as they don't require much of anything to bet set up.
 */
  {"-csport", 1, 2, (void (*)()) set_csport},
  {"-detach", 0, 2, set_daemon},

/* Start of pass 3 information. In theory, by pass 3, all data paths
 * and defaults should have been set up. 
 */
  {"-o", 0, 3, compile_info},
  {"-m", 0, 3, set_dumpmon1},
  {"-m2", 0, 3, set_dumpmon2},
  {"-m3", 0, 3, set_dumpmon3},
  {"-m4", 0, 3, set_dumpmon4},
  {"-m5", 0, 3, set_dumpmon5},
  {"-m6", 0, 3, set_dumpmon6},
  {"-m7", 0, 3, set_dumpmon7},
  {"-m8", 0, 3, set_dumpmon8},
  {"-m9", 0, 3, set_dumpmon9},
  {"-mt", 1, 3, (void (*)()) set_dumpmont},
  {"-mexp", 0, 3, dump_experience},
  {"-s", 0, 3, showscores},
  {"-score", 1, 3, (void (*)()) showscoresparm}
};


/* Note since this may be called before the library has been set up,
 * we don't use any of crossfires built in logging functions.
 */
static void
parse_args (int argc, char *argv[], int pass)
{
  size_t i;
  int on_arg = 1;

  while (on_arg < argc)
    {
      for (i = 0; i < sizeof (options) / sizeof (struct Command_Line_Options); i++)
        {
          if (!strcmp (options[i].cmd_option, argv[on_arg]))
            {
              /* Found a matching option, but should not be processed on
               * this pass.  Just skip over it
               */
              if (options[i].pass != pass)
                {
                  on_arg += options[i].num_args + 1;
                  break;
                }
              if (options[i].num_args)
                {
                  if ((on_arg + options[i].num_args) >= argc)
                    {
                      fprintf (stderr, "%s requires an argument.\n", options[i].cmd_option);
                      exit (1);
                    }
                  else
                    {
                      if (options[i].num_args == 1)
                        ((void (*)(char *)) options[i].func) (argv[on_arg + 1]);
                      if (options[i].num_args == 2)
                        ((void (*)(char *, char *)) options[i].func) (argv[on_arg + 1], argv[on_arg + 2]);
                      on_arg += options[i].num_args + 1;
                    }
                }
              else
                {               /* takes no args */
                  options[i].func ();
                  on_arg++;
                }
              break;
            }
        }
      if (i == sizeof (options) / sizeof (struct Command_Line_Options))
        {
          fprintf (stderr, "Unknown option: %s\n", argv[on_arg]);
          usage ();
          exit (1);
        }
    }
}

//TODO: make this a constructor
static materialtype_t *
get_empty_mat (void)
{
  materialtype_t *mt;
  int i;

  mt = new materialtype_t;

  mt->name = NULL;
  mt->description = NULL;
  for (i = 0; i < NROFATTACKS; i++)
    {
      mt->save[i] = 0;
      mt->mod[i] = 0;
    }
  mt->chance = 0;
  mt->difficulty = 0;
  mt->magic = 0;
  mt->damage = 0;
  mt->wc = 0;
  mt->ac = 0;
  mt->sp = 0;
  mt->weight = 100;
  mt->value = 100;
  mt->next = NULL;
  return mt;
}

static void
load_materials (void)
{
  char filename[MAX_BUF];
  materialtype_t *mt;

  sprintf (filename, "%s/materials", settings.datadir);
  LOG (llevDebug, "Reading material type data from %s...\n", filename);

  object_thawer thawer (filename);

  if (!thawer)
    {
      LOG (llevError, "Cannot open %s for reading\n", filename);
      mt = get_empty_mat ();
      mt->next = 0;
      materialt = mt;
      return;
    }

  mt = get_empty_mat ();
  materialt = mt;

  for (;;)
    {
      thawer.next ();

      switch (thawer.kw)
        {
          case KW_name:
            /* clean up the previous entry */
            if (mt->next)
              {
                if (!mt->description)
                  mt->description = mt->name;

                mt = mt->next;
              }

            mt->next = get_empty_mat ();
            thawer.get (mt->name);
            break;

          case KW_description:
            thawer.get (mt->description);
            break;

          case KW_material:
            thawer.get (mt->material);
            break;

          case KW_saves:
            {
              const char *cp = thawer.get_str () - 1;

              for (int i = 0; i < NROFATTACKS; i++)
                {
                  if (!cp)
                    {
                      mt->save[i] = 0;
                      continue;
                    }

                  int value;
                  ++cp;
                  sscanf (cp, "%d", &value);
                  mt->save[i] = (sint8) value;
                  cp = strchr (cp, ',');
                }
            }
            break;

          case KW_mods:
            {
              const char *cp = thawer.get_str () - 1;

              for (int i = 0; i < NROFATTACKS; i++)
                {
                  if (!cp)
                    {
                      mt->save[i] = 0;
                      continue;
                    }

                  ++cp;
                  int value;
                  sscanf (cp, "%d", &value);
                  mt->mod[i] = (sint8) value;
                  cp = strchr (cp, ',');
                }
            }
            break;

          case KW_chance:  thawer.get (mt->chance);     break;
          case KW_difficulty: // cf+ alias, not original cf
          case KW_diff:    thawer.get (mt->difficulty); break;
          case KW_magic:   thawer.get (mt->magic);      break;
          case KW_dam:        // cf+ alias, not original cf
          case KW_damage:  thawer.get (mt->damage);     break;
          case KW_wc:      thawer.get (mt->wc);         break;
          case KW_ac:      thawer.get (mt->ac);         break;
          case KW_sp:      thawer.get (mt->sp);         break;
          case KW_weight:  thawer.get (mt->weight);     break;
          case KW_value:   thawer.get (mt->value);      break;
          case KW_density: thawer.get (mt->density);    break;

          case KW_EOF:
            goto done;

          default:
            if (!thawer.parse_error ("materials file", "materials"))
              goto done;
            break;
        }
    }

done:
  if (mt->next)
    {
      delete mt->next;

      mt->next = 0;
    }

  LOG (llevDebug, "Done.\n");
}

/* This loads the settings file.  There could be debate whether this should
 * be here or in the common directory - but since only the server needs this
 * information, having it here probably makes more sense.
 */
static void
load_settings (void)
{
  char buf[MAX_BUF], *cp;
  int has_val, comp;
  FILE *fp;

  sprintf (buf, "%s/settings", settings.confdir);

  /* We don't require a settings file at current time, but down the road,
   * there will probably be so many values that not having a settings file
   * will not be a good thing.
   */
  if (!(fp = open_and_uncompress (buf, 0, &comp)))
    {
      LOG (llevError, "Error: No settings file found\n");
      exit (1);
    }

  while (fgets (buf, MAX_BUF - 1, fp) != NULL)
    {
      if (buf[0] == '#')
        continue;
      /* eliminate newline */
      if ((cp = strrchr (buf, '\n')) != NULL)
        *cp = '\0';

      /* Skip over empty lines */
      if (buf[0] == 0)
        continue;

      /* Skip all the spaces and set them to nulls.  If not space,
       * set cp to "" to make strcpy's and the like easier down below.
       */
      if ((cp = strchr (buf, ' ')) != NULL)
        {
          while (*cp == ' ')
            *cp++ = 0;
          has_val = 1;
        }
      else
        {
          cp = (char *)"";
          has_val = 0;
        }

      if (!strcasecmp (buf, "motd"))
        {
          if (has_val)
            strcpy (settings.motd, cp);
          else
            LOG (llevError, "load_settings: motd must have a value.\n");
        }
      else if (!strcasecmp (buf, "dm_mail"))
        {
          if (has_val)
            strcpy (settings.dm_mail, cp);
          else
            LOG (llevError, "load_settings: dm_mail must have a value.\n");
        }
      else if (!strcasecmp (buf, "worldmapstartx"))
        {
          int size = atoi (cp);

          if (size < 0)
            LOG (llevError, "load_settings: worldmapstartx must be at least " "0, %d is invalid\n", size);
          else
            settings.worldmapstartx = size;
        }
      else if (!strcasecmp (buf, "worldmapstarty"))
        {
          int size = atoi (cp);

          if (size < 0)
            LOG (llevError, "load_settings: worldmapstarty must be at least " "0, %d is invalid\n", size);
          else
            settings.worldmapstarty = size;
        }
      else if (!strcasecmp (buf, "worldmaptilesx"))
        {
          int size = atoi (cp);

          if (size < 1)
            LOG (llevError, "load_settings: worldmaptilesx must be greater " "than 1, %d is invalid\n", size);
          else
            settings.worldmaptilesx = size;
        }
      else if (!strcasecmp (buf, "worldmaptilesy"))
        {
          int size = atoi (cp);

          if (size < 1)
            LOG (llevError, "load_settings: worldmaptilesy must be greater " "than 1, %d is invalid\n", size);
          else
            settings.worldmaptilesy = size;
        }
      else if (!strcasecmp (buf, "worldmaptilesizex"))
        {
          int size = atoi (cp);

          if (size < 1)
            LOG (llevError, "load_settings: worldmaptilesizex must be " "greater than 1, %d is invalid\n", size);
          else
            settings.worldmaptilesizex = size;
        }
      else if (!strcasecmp (buf, "worldmaptilesizey"))
        {
          int size = atoi (cp);

          if (size < 1)
            LOG (llevError, "load_settings: worldmaptilesizey must be " "greater than 1, %d is invalid\n", size);
          else
            settings.worldmaptilesizey = size;
        }
      else if (!strcasecmp (buf, "dynamiclevel"))
        {
          int lev = atoi (cp);

          if (lev < 0)
            LOG (llevError, "load_settings: dynamiclevel must be " "at least 0, %d is invalid\n", lev);
          else
            settings.dynamiclevel = lev;
        }
      else if (!strcasecmp (buf, "fastclock"))
        {
          int lev = atoi (cp);

          if (lev < 0)
            LOG (llevError, "load_settings: fastclock must be at least 0" ", %d is invalid\n", lev);
          else
            settings.fastclock = lev;
        }
      else if (!strcasecmp (buf, "not_permadeth"))
        {
          if (!strcasecmp (cp, "on") || !strcasecmp (cp, "true"))
            {
              settings.not_permadeth = TRUE;
            }
          else if (!strcasecmp (cp, "off") || !strcasecmp (cp, "false"))
            {
              settings.not_permadeth = FALSE;
            }
          else
            {
              LOG (llevError, "load_settings: Unknown value for not_permadeth" ": %s\n", cp);
            }
        }
      else if (!strcasecmp (buf, "resurrection"))
        {
          if (!strcasecmp (cp, "on") || !strcasecmp (cp, "true"))
            {
              settings.resurrection = TRUE;
            }
          else if (!strcasecmp (cp, "off") || !strcasecmp (cp, "false"))
            {
              settings.resurrection = FALSE;
            }
          else
            {
              LOG (llevError, "load_settings: Unknown value for resurrection" ": %s\n", cp);
            }
        }
      else if (!strcasecmp (buf, "set_title"))
        {
          if (!strcasecmp (cp, "on") || !strcasecmp (cp, "true"))
            {
              settings.set_title = TRUE;
            }
          else if (!strcasecmp (cp, "off") || !strcasecmp (cp, "false"))
            {
              settings.set_title = FALSE;
            }
          else
            {
              LOG (llevError, "load_settings: Unknown value for set_title" ": %s\n", cp);
            }
        }
      else if (!strcasecmp (buf, "search_items"))
        {
          if (!strcasecmp (cp, "on") || !strcasecmp (cp, "true"))
            {
              settings.search_items = TRUE;
            }
          else if (!strcasecmp (cp, "off") || !strcasecmp (cp, "false"))
            {
              settings.search_items = FALSE;
            }
          else
            {
              LOG (llevError, "load_settings: Unknown value for search_items" ": %s\n", cp);
            }
        }
      else if (!strcasecmp (buf, "spell_encumbrance"))
        {
          if (!strcasecmp (cp, "on") || !strcasecmp (cp, "true"))
            {
              settings.spell_encumbrance = TRUE;
            }
          else if (!strcasecmp (cp, "off") || !strcasecmp (cp, "false"))
            {
              settings.spell_encumbrance = FALSE;
            }
          else
            {
              LOG (llevError, "load_settings: Unknown value for " "spell_encumbrance: %s\n", cp);
            }
        }
      else if (!strcasecmp (buf, "spell_failure_effects"))
        {
          if (!strcasecmp (cp, "on") || !strcasecmp (cp, "true"))
            {
              settings.spell_failure_effects = TRUE;
            }
          else if (!strcasecmp (cp, "off") || !strcasecmp (cp, "false"))
            {
              settings.spell_failure_effects = FALSE;
            }
          else
            {
              LOG (llevError, "load_settings: Unknown value for " "spell_failure_effects: %s\n", cp);
            }
        }
      else if (!strcasecmp (buf, "spellpoint_level_depend"))
        {
          if (!strcasecmp (cp, "on") || !strcasecmp (cp, "true"))
            {
              settings.spellpoint_level_depend = TRUE;
            }
          else if (!strcasecmp (cp, "off") || !strcasecmp (cp, "false"))
            {
              settings.spellpoint_level_depend = FALSE;
            }
          else
            {
              LOG (llevError, "load_settings: Unknown value for " "spellpoint_level_depend: %s\n", cp);
            }
        }
      else if (!strcasecmp (buf, "stat_loss_on_death"))
        {
          if (!strcasecmp (cp, "on") || !strcasecmp (cp, "true"))
            {
              settings.stat_loss_on_death = TRUE;
            }
          else if (!strcasecmp (cp, "off") || !strcasecmp (cp, "false"))
            {
              settings.stat_loss_on_death = FALSE;
            }
          else
            {
              LOG (llevError, "load_settings: Unknown value for " "stat_loss_on_death: %s\n", cp);
            }
        }
      else if (!strcasecmp (buf, "use_permanent_experience"))
        {
          LOG (llevError, "use_permanent_experience is deprecated, use" "permenent_experience_percentage instead\n");
        }
      else if (!strcasecmp (buf, "permanent_experience_percentage"))
        {
          int val = atoi (cp);

          if (val < 0 || val > 100)
            LOG (llevError, "load_settings: permenent_experience_percentage" "must be between 0 and 100, %d is invalid\n", val);
          else
            settings.permanent_exp_ratio = val;
        }
      else if (!strcasecmp (buf, "death_penalty_percentage"))
        {
          int val = atoi (cp);

          if (val < 0 || val > 100)
            LOG (llevError, "load_settings: death_penalty_percentage" "must be between 0 and 100, %d is invalid\n", val);
          else
            settings.death_penalty_ratio = val;
        }
      else if (!strcasecmp (buf, "death_penalty_levels"))
        {
          int val = atoi (cp);

          if (val < 0 || val > 255)
            LOG (llevError, "load_settings: death_penalty_levels" "can not be negative, %d is invalid\n", val);
          else
            settings.death_penalty_level = val;
        }
      else if (!strcasecmp (buf, "balanced_stat_loss"))
        {
          if (!strcasecmp (cp, "on") || !strcasecmp (cp, "true"))
            {
              settings.balanced_stat_loss = TRUE;
            }
          else if (!strcasecmp (cp, "off") || !strcasecmp (cp, "false"))
            {
              settings.balanced_stat_loss = FALSE;
            }
          else
            {
              LOG (llevError, "load_settings: Unknown value for " "balanced_stat_loss: %s\n", cp);
            }
        }
      else if (!strcasecmp (buf, "simple_exp"))
        {
          if (!strcasecmp (cp, "on") || !strcasecmp (cp, "true"))
            {
              settings.simple_exp = TRUE;
            }
          else if (!strcasecmp (cp, "off") || !strcasecmp (cp, "false"))
            {
              settings.simple_exp = FALSE;
            }
          else
            {
              LOG (llevError, "load_settings: Unknown value for simple_exp: %s\n", cp);
            }
        }
      else if (!strcasecmp (buf, "item_power_factor"))
        {
          float tmp = atof (cp);

          if (tmp < 0)
            LOG (llevError, "load_settings: item_power_factor must be a positive number (%f < 0)\n", tmp);
          else
            settings.item_power_factor = tmp;
        }
      else if (!strcasecmp (buf, "pk_luck_penalty"))
        {
          sint16 val = atoi (cp);

          if (val < -100 || val > 100)
            LOG (llevError, "load_settings: pk_luck_penalty must be between -100 and 100" ", %d is invalid\n", val);
          else
            settings.pk_luck_penalty = val;
        }
      else if (!strcasecmp (buf, "set_friendly_fire"))
        {
          int val = atoi (cp);

          if (val < 0 || val > 100)
            LOG (llevError, "load_settings: set_friendly_fire must be between 0 an 100" ", %d is invalid\n", val);
          else
            settings.set_friendly_fire = val;
        }
      else if (!strcasecmp (buf, "armor_max_enchant"))
        {
          int max_e = atoi (cp);

          if (max_e <= 0)
            LOG (llevError, "load_settings: armor_max_enchant is %d\n", max_e);
          else
            settings.armor_max_enchant = max_e;
        }
      else if (!strcasecmp (buf, "armor_weight_reduction"))
        {
          int wr = atoi (cp);

          if (wr < 0)
            LOG (llevError, "load_settings: armor_weight_reduction is %d\n", wr);
          else
            settings.armor_weight_reduction = wr;
        }
      else if (!strcasecmp (buf, "armor_weight_linear"))
        {
          if (!strcasecmp (cp, "on") || !strcasecmp (cp, "true"))
            {
              settings.armor_weight_linear = TRUE;
            }
          else if (!strcasecmp (cp, "off") || !strcasecmp (cp, "false"))
            {
              settings.armor_weight_linear = FALSE;
            }
          else
            {
              LOG (llevError, "load_settings: unknown value for armor_weight_linear: %s\n", cp);
            }

        }
      else if (!strcasecmp (buf, "armor_speed_improvement"))
        {
          int wr = atoi (cp);

          if (wr < 0)
            LOG (llevError, "load_settings: armor_speed_improvement is %d\n", wr);
          else
            settings.armor_speed_improvement = wr;
        }
      else if (!strcasecmp (buf, "armor_speed_linear"))
        {
          if (!strcasecmp (cp, "on") || !strcasecmp (cp, "true"))
            {
              settings.armor_speed_linear = TRUE;
            }
          else if (!strcasecmp (cp, "off") || !strcasecmp (cp, "false"))
            {
              settings.armor_speed_linear = FALSE;
            }
          else
            {
              LOG (llevError, "load_settings: unknown value for armor_speed_linear: %s\n", cp);
            }

        }
      else
        LOG (llevError, "Unknown value in settings file: %s\n", buf);
    }

  close_and_delete (fp, comp);
}

/*
 * init() is called only once, when starting the program.
 */
void
init (int argc, char **argv)
{
  init_done = 0;                /* Must be done before init_signal() */
  rndm.seed (time (0));

  logfile = stderr;
  init_environ ();
  parse_args (argc, argv, 1);   /* First arg pass - right now it does
                                 * nothing, but in future specifying the
                                 * LibDir in this pass would be reasonable*/

  init_anim ();                 // Must be called before perl
  cfperl_init ();
  init_library ();              /* Must be called early */
  load_settings ();             /* Load the settings file */
  load_materials ();
  parse_args (argc, argv, 2);
  fprintf (logfile, "Welcome to CrossFire, v%s\n", VERSION);
  fprintf (logfile, "Copyright (C) 2005, 2006, 2007 Marc Lehmann.\n");
  fprintf (logfile, "Copyright (C) 1994 Mark Wedel.\n");
  fprintf (logfile, "Copyright (C) 1992 Frank Tore Johansen.\n");

  if (strcmp (settings.dm_mail, "") != 0)
    {
      fprintf (logfile, "Maintained locally by: %s\n", settings.dm_mail);
      fprintf (logfile, "Questions and bugs should be mailed to above address.\n");
    }

  init_startup ();              /* Write (C), check shutdown/forbid files */
  init_uuid ();
  init_signals ();              /* Sets up signal interceptions */
  init_commands ();             /* Sort command tables */
  init_skills ();

  parse_args (argc, argv, 3);

  init_beforeplay ();
  init_done = 1;
}

void
usage (void)
{
  (void) fprintf (logfile, "Usage: crossfire [-h] [-<flags>]...\n");
}

void
help (void)
{

/* The information in usage is redundant with what is given below, so why call it? */

/*    usage();*/
  printf ("Flags:\n");
  printf (" -csport <port> Specifies the port to use for the new client/server code.\n");
  printf (" -d          Turns on some debugging.\n");
  printf (" +d          Turns off debugging (useful if server compiled with debugging\n");
  printf ("             as default).\n");
  printf (" -detach     The server will go in the background, closing all\n");
  printf ("             connections to the tty.\n");
  printf (" -h          Display this information.\n");
  printf (" -log <file> Specifies which file to send output to.\n");
  printf ("             Only has meaning if -detach is specified.\n");
  printf (" -mon        Turns on monster debugging.\n");
  printf (" -o          Prints out info on what was defined at compile time.\n");
  printf (" -s          Display the high-score list.\n");
  printf (" -score <name or class> Displays all high scores with matching name/class.\n");
  printf (" -v          Print version and contributors.\n");
  printf (" -data       Sets the lib dir (archetypes, treasures, etc.)\n");
  printf (" -local      Read/write local data (hiscore, unique items, etc.)\n");
  printf (" -maps       Sets the directory for maps.\n");
  printf (" -arch       Sets the archetype file to use.\n");
  printf (" -regions    Sets the regions file to use.\n");
  printf (" -playerdir  Sets the directory for the player files.\n");
  printf (" -templatedir Sets the directory for template generate maps.\n");
  printf (" -treasures   Sets the treasures file to use.\n");
  printf (" -uniquedir  Sets the unique items/maps directory.\n");
  printf (" -tmpdir     Sets the directory for temporary files (mostly maps.)\n");
  printf (" -m          Lists out suggested experience for all monsters.\n");
  printf (" -m2         Dumps out abilities.\n");
  printf (" -m3         Dumps out artifact information.\n");
  printf (" -m4         Dumps out spell information.\n");
  printf (" -m5         Dumps out skill information.\n");
  printf (" -m6         Dumps out race information.\n");
  printf (" -m7         Dumps out alchemy information.\n");
  printf (" -m8         Dumps out gods information.\n");
  printf (" -m9         Dumps out more alchemy information (formula checking).\n");
  printf (" -mt <name>  Dumps out list of treasures for a monster.\n");
  exit (0);
}

void
init_beforeplay (void)
{
  init_artifacts ();            /* If not called before, reads all artifacts from file */
  init_spells ();               /* If not called before, links archtypes used by spells */
  init_archetype_pointers ();   /* Setup global pointers to archetypes */
  init_races ();                /* overwrite race designations using entries in lib/races file */
  init_gods ();                 /* init linked list of gods from archs */
  init_readable ();             /* inits useful arrays for readable texts */
  init_formulae ();             /* If not called before, reads formulae from file */
}

void
init_startup (void)
{
  char buf[MAX_BUF];
  FILE *fp;
  int comp;

#ifdef SHUTDOWN_FILE
  sprintf (buf, "%s/%s", settings.confdir, SHUTDOWN_FILE);
  if ((fp = open_and_uncompress (buf, 0, &comp)) != NULL)
    {
      while (fgets (buf, MAX_BUF - 1, fp) != NULL)
        printf ("%s", buf);
      close_and_delete (fp, comp);
      exit (1);
    }
#endif

  if (forbid_play ())
    {                           /* Maybe showing highscore should be allowed? */
      LOG (llevError, "CrossFire: Playing not allowed.\n");
      exit (-1);
    }
}

/*
 * compile_info(): activated with the -o flag.
 * It writes out information on how Imakefile and config.h was configured
 * at compile time.
 */

void
compile_info (void)
{
  int i = 0;

  printf ("Non-standard include files:\n");
#if !defined (__STRICT_ANSI__) || defined (__sun__)
# if !defined (Mips)
  printf ("<stdlib.h>\n");
  i = 1;
# endif
# if !defined (MACH) && !defined (sony)
  printf ("<malloc.h>\n");
  i = 1;
# endif
#endif
#ifndef __STRICT_ANSI__
# ifndef MACH
  printf ("<memory.h\n");
  i = 1;
# endif
#endif
#ifndef sgi
  printf ("<sys/timeb.h>\n");
  i = 1;
#endif
  if (!i)
    printf ("(none)\n");
  printf ("Datadir:\t\t%s\n", settings.datadir);
  printf ("Localdir:\t\t%s\n", settings.localdir);
#ifdef PERM_FILE
  printf ("Perm file:\t<ETC>/%s\n", PERM_FILE);
#endif
#ifdef SHUTDOWN_FILE
  printf ("Shutdown file:\t<ETC>/%s\n", SHUTDOWN_FILE);
#endif
  printf ("Save player:\t<true>\n");
  printf ("Save mode:\t%4.4o\n", SAVE_MODE);
  printf ("Playerdir:\t<VAR>/%s\n", settings.playerdir);
  printf ("Itemsdir:\t<VAR>/%s\n", settings.uniquedir);
  printf ("Tmpdir:\t\t%s\n", settings.tmpdir);
#ifdef USE_CALLOC
  printf ("Use_calloc:\t<true>\n");
#else
  printf ("Use_calloc:\t<false>\n");
#endif

#ifdef X_EDITOR
  printf ("Editor:\t\t%s\n", X_EDITOR);
#endif

  printf ("Max_time:\t%d\n", MAX_TIME);

  execl ("/bin/uname", "uname", "-a", NULL);
  LOG (llevError, "Oops, shouldn't have gotten here: execl(/bin/uname) failed: %s\n", strerror (errno));
  exit (-1);
}

/* Signal handlers: */

static void
rec_sigabrt (int i)
{
  signal (SIGABRT, SIG_DFL);

  LOG (llevError, "SIGABRT received.\n");
  cleanup ("SIGABRT received", 1);
}

static void
rec_sigsegv (int i)
{
  signal (SIGSEGV, SIG_DFL);

  LOG (llevError, "SIGSEGV received.\n");
  cleanup ("SIGSEGV received", 1);
}

static void
rec_sigquit (int i)
{
  signal (SIGQUIT, SIG_IGN);

  LOG (llevInfo, "SIGQUIT received\n");
  cleanup ("SIGQUIT received", 1);
}

static void
rec_sigbus (int i)
{
  signal (SIGBUS, SIG_DFL);

  LOG (llevError, "SIGBUS received\n");
  cleanup ("SIGBUS received", 1);
}

void
reset_signals ()
{
  signal (SIGABRT, SIG_DFL);
  signal (SIGQUIT, SIG_DFL);
  signal (SIGSEGV, SIG_DFL);
  signal (SIGBUS , SIG_DFL);
  signal (SIGINT , SIG_DFL);
  signal (SIGTERM, SIG_DFL);
}

void
init_signals (void)
{
  // large stack, but it's important data we want to save, and it is not usually
  // being physically allocated anyways
  const size_t stacksize = 8 * 1024 * 1024 + SIGSTKSZ;

  stack_t ss;
  ss.ss_sp = malloc (stacksize);
  ss.ss_flags = 0;
  ss.ss_size = stacksize;
  sigaltstack (&ss, 0);

  struct sigaction sa;

  sigfillset (&sa.sa_mask);
  sa.sa_flags = SA_RESTART;

  sa.sa_handler = SIG_IGN;     sigaction (SIGPIPE, &sa, 0);
  sa.sa_handler = rec_sigabrt; sigaction (SIGABRT, &sa, 0);
  sa.sa_handler = rec_sigquit; sigaction (SIGQUIT, &sa, 0);
  sa.sa_handler = rec_sigbus;  sigaction (SIGBUS,  &sa, 0);

  sa.sa_flags |= SA_ONSTACK;
  sa.sa_handler = rec_sigsegv; sigaction (SIGSEGV, &sa, 0);
}

/* init_races() - reads the races file in the lib/ directory, then
 * overwrites old 'race' entries. This routine allow us to quickly
 * re-configure the 'alignment' of monsters, objects. Useful for
 * putting together lists of creatures, etc that belong to gods.
 */
void
init_races (void)
{
  FILE *file;
  char race[MAX_BUF], fname[MAX_BUF], buf[MAX_BUF], *cp, variable[MAX_BUF];
  archetype *mon = NULL;
  static int init_done = 0;

  if (init_done)
    return;
  init_done = 1;
  first_race = 0;

  sprintf (fname, "%s/races", settings.datadir);
  LOG (llevDebug, "Reading races from %s...\n", fname);
  if (!(file = fopen (fname, "r")))
    {
      LOG (llevError, "Cannot open races file %s: %s\n", fname, strerror (errno));
      return;
    }

  while (fgets (buf, MAX_BUF, file) != NULL)
    {
      int set_race = 1, set_list = 1;

      if (*buf == '#')
        continue;

      if ((cp = strchr (buf, '\n')) != NULL)
        *cp = '\0';

      cp = buf;
      while (*cp == ' ' || *cp == '!' || *cp == '@')
        {
          if (*cp == '!')
            set_race = 0;
          if (*cp == '@')
            set_list = 0;
          cp++;
        }

      if (sscanf (cp, "RACE %s", variable))
        /* set new race value */
        strcpy (race, variable);
      else
        {
          char *cp1;

          /* Take out beginning spaces */
          for (cp1 = cp; *cp1 == ' '; cp1++)
            ;
          /* Remove newline and trailing spaces */
          for (cp1 = cp + strlen (cp) - 1; *cp1 == '\n' || *cp1 == ' '; cp1--)
            {
              *cp1 = '\0';
              if (cp == cp1)
                break;
            }

          if (cp[strlen (cp) - 1] == '\n')
            cp[strlen (cp) - 1] = '\0';

          /* set creature race to race value */
          if ((mon = archetype::find (cp)) == NULL)
            LOG (llevError, "Creature %s in race file lacks archetype\n", cp);
          else
            {
              if (set_race && (!mon->race || strcmp (mon->race, race)))
                {
                  if (mon->race)
                    LOG (llevDebug, "Resetting race to %s from %s for archetype %s\n", race, &mon->race, &mon->archname);

                  mon->race = race;
                }

              /* if the arch is a monster, add it to the race list */
              if (set_list && QUERY_FLAG (mon, FLAG_MONSTER))
                add_to_racelist (race, mon);
            }
        }
    }

  fclose (file);
  LOG (llevDebug, "done.\n");
}

void
dump_races (void)
{
  racelink *list;
  objectlink *tmp;

  for (list = first_race; list; list = list->next)
    {
      fprintf (stderr, "\nRACE %s:\t", &list->name);
      for (tmp = list->member; tmp; tmp = tmp->next)
        fprintf (stderr, "%s(%d), ", &tmp->ob->arch->archname, tmp->ob->level);
    }

  fprintf (stderr, "\n");
}

void
add_to_racelist (const char *race_name, object *op)
{
  racelink *race;

  if (!op || !race_name)
    return;

  race = find_racelink (race_name);

  if (!race)
    {                           /* add in a new race list */
      race = get_racelist ();
      race->next = first_race;
      first_race = race;
      race->name = race_name;
    }

  if (race->member->ob)
    {
      objectlink *tmp = get_objectlink ();

      tmp->next = race->member;
      race->member = tmp;
    }

  race->nrof++;
  race->member->ob = op;
}

racelink *
get_racelist ()
{
  racelink *list = new racelink;

  list->name = 0;
  list->nrof = 0;
  list->next = 0;
  list->member = get_objectlink ();

  return list;
}

racelink *
find_racelink (const char *name)
{
  if (name)
    for (racelink *link = first_race; link; link = link->next)
      if (!link->name || !strcmp (name, link->name))
        return link;

  return 0;
}
Revision:	1.56
Committed:	Sun Jul 1 05:00:20 2007 UTC (16 years, 11 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.55:	+10 -11 lines
Log Message:	- upgrade crossfire trt to the GPL version 3 (hopefully correctly). - add a single file covered by the GNU Affero General Public License (which is not yet released, so I used the current draft, which is legally a bit wavy, but its likely better than nothing as it expresses direct intent by the authors, and we can upgrade as soon as it has been released). * this should ensure availability of source code for the server at least and hopefully also archetypes and maps even when modified versions are not being distributed, in accordance of section 13 of the agplv3.