server/server/main.C

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2001-2003 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@schmorp.de>
*/

#include <global.h>
#include <object.h>
#include <tod.h>

#ifdef HAVE_DES_H
# include <des.h>
#else
# ifdef HAVE_CRYPT_H
#  include <crypt.h>
# endif
#endif

#include <sproto.h>
#include <time.h>

#include <../random_maps/random_map.h>
#include <../random_maps/rproto.h>
#include "path.h"

static char days[7][4] = {
  "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};

void
version (object *op)
{
  if (op != NULL)
    clear_win_info (op);

  new_draw_info_format (NDI_UNIQUE, 0, op, "This is Crossfire v%s", VERSION);

/* If in a socket, don't print out the list of authors.  It confuses the
 * crossclient program.
 */
  if (op == NULL)
    return;

  new_draw_info (NDI_UNIQUE, 0, op, "Authors and contributors to this program:");
  new_draw_info (NDI_UNIQUE, 0, op, "Marc A. Lehmann <pcg@goof.com>");
  new_draw_info (NDI_UNIQUE, 0, op, "Robin Redeker <elmex@x-paste.de>");
  new_draw_info (NDI_UNIQUE, 0, op, "Pippijn van Steenhoven <pip88nl@gmail.com>");
  new_draw_info (NDI_UNIQUE, 0, op, "Mark Wedel <mwedel@sonic.net>");
  new_draw_info (NDI_UNIQUE, 0, op, "Frank Tore Johansen <frankj@ifi.uio.no>");
  new_draw_info (NDI_UNIQUE, 0, op, "Kjetil Torgrim Homme <kjetilho@ifi.uio.no>");
  new_draw_info (NDI_UNIQUE, 0, op, "Tyler Van Gorder <tvangod@ecst.csuchico.edu>");
  new_draw_info (NDI_UNIQUE, 0, op, "Tony Elmroth <elmroth@cd.chalmers.se>");
  new_draw_info (NDI_UNIQUE, 0, op, "Dougal Scott <dougal.scott@fcit.monasu.edu.au>");
  new_draw_info (NDI_UNIQUE, 0, op, "William <wchuang@athena.mit.edu>");
  new_draw_info (NDI_UNIQUE, 0, op, "Geoff Bailey <ftww@cs.su.oz.au>");
  new_draw_info (NDI_UNIQUE, 0, op, "Kjetil Wiekhorst Jxrgensen <jorgens@flipper.pvv.unit.no>");
  new_draw_info (NDI_UNIQUE, 0, op, "Cameron Blackwood <c.blackwood@rdt.monash.edu.au>");
  new_draw_info (NDI_UNIQUE, 0, op, "Joseph L. Traub <jtraub+@cmu.edu>");
  new_draw_info (NDI_UNIQUE, 0, op, "Rupert G. Goldie <rgg@aaii.oz.au>");
  new_draw_info (NDI_UNIQUE, 0, op, "Eric A. Anderson <eanders+@cmu.edu>");
  new_draw_info (NDI_UNIQUE, 0, op, "Rickard Eneqvist <eneq@Prag.DoCS.UU.SE>");
  new_draw_info (NDI_UNIQUE, 0, op, "Jarkko Sonninen <Jarkko.Sonninen@lut.fi>");
  new_draw_info (NDI_UNIQUE, 0, op, "Karl Holland <kholland@sunlab.cit.cornell.du>");
  new_draw_info (NDI_UNIQUE, 0, op, "Mikael Lundgren <vick@bern.docs.uu.se>");
  new_draw_info (NDI_UNIQUE, 0, op, "Mikael Olsson <mol@meryl.csd.uu.se>");
  new_draw_info (NDI_UNIQUE, 0, op, "Tero Haatanen <Tero.Haatanen@lut.fi>");
  new_draw_info (NDI_UNIQUE, 0, op, "Lasse Ylitalo <ylitalo@student.docs.uu.se>");
  new_draw_info (NDI_UNIQUE, 0, op, "Niilo Neuvo <anipa@guru.magic.fi>");
  new_draw_info (NDI_UNIQUE, 0, op, "Markku J{rvinen <mta@modeemi.cs.tut.fi>");
  new_draw_info (NDI_UNIQUE, 0, op, "Sylvain Meunier <meunier@inf.enst.fr>");
  new_draw_info (NDI_UNIQUE, 0, op, "Jason Fosback <jfosback@darmok.uoregon.edu>");
  new_draw_info (NDI_UNIQUE, 0, op, "Carl Edman <cedman@capitalist.princeton.edu>");
  new_draw_info (NDI_UNIQUE, 0, op, "Charles Henrich <henrich@crh.cl.msu.edu>");
  new_draw_info (NDI_UNIQUE, 0, op, "Gregor Schmid <schmid@fb3-s7.math.tu-berlin.de>");
  new_draw_info (NDI_UNIQUE, 0, op, "Raphael Quinet <quinet@montefiore.ulg.ac.be>");
  new_draw_info (NDI_UNIQUE, 0, op, "Jari Vanhala <jam@modeemi.cs.tut.fi>");
  new_draw_info (NDI_UNIQUE, 0, op, "Tero Kivinen <kivinen@joker.cs.hut.fi>");
  new_draw_info (NDI_UNIQUE, 0, op, "Peter Mardahl <peterm@soda.berkeley.edu>");
  new_draw_info (NDI_UNIQUE, 0, op, "Matthew Zeher <matt@cs.odu.edu>");
  new_draw_info (NDI_UNIQUE, 0, op, "Scott R. Turner <srt@sun-dimas.aero.org>");
  new_draw_info (NDI_UNIQUE, 0, op, "Ben Fennema <huma@netcom.com>");
  new_draw_info (NDI_UNIQUE, 0, op, "Nick Williams <njw@cs.city.ac.uk>");
  new_draw_info (NDI_UNIQUE, 0, op, "Laurent Wacrenier <Wacren@Gin.ObsPM.Fr>");
  new_draw_info (NDI_UNIQUE, 0, op, "Brian Thomas <thomas@astro.psu.edu>");
  new_draw_info (NDI_UNIQUE, 0, op, "John Steven Moerk <jsm@axon.ksc.nasa.gov>");
  new_draw_info (NDI_UNIQUE, 0, op, "Delbecq David <david.delbecq@mailandnews.com>");
  new_draw_info (NDI_UNIQUE, 0, op, "Chachkoff Yann <yann.chachkoff@mailandnews.com>\n");

  new_draw_info (NDI_UNIQUE, 0, op, "Images and art:");
  new_draw_info (NDI_UNIQUE, 0, op, "Peter Gardner");
  new_draw_info (NDI_UNIQUE, 0, op, "David Gervais <david_eg@mail.com>");
  new_draw_info (NDI_UNIQUE, 0, op, "Mitsuhiro Itakura <ita@gold.koma.jaeri.go.jp>");
  new_draw_info (NDI_UNIQUE, 0, op, "Hansjoerg Malthaner <hansjoerg.malthaner@danet.de>");
  new_draw_info (NDI_UNIQUE, 0, op, "Mårten Woxberg <maxmc@telia.com>");
  new_draw_info (NDI_UNIQUE, 0, op, "And many more!");
}

/* This is a basic little function to put the player back to his
 * savebed.  We do some error checking - its possible that the
 * savebed map may no longer exist, so we make sure the player
 * goes someplace.
 */
void
enter_player_savebed (object *op)
{
  object *tmp = object::create ();
  EXIT_PATH (tmp) = op->contr->savebed_map;
  EXIT_X (tmp) = op->contr->bed_x;
  EXIT_Y (tmp) = op->contr->bed_y;
  op->enter_exit (tmp);
  tmp->destroy ();
}

/*
 * enter_map():  Moves the player and pets from current map (if any) to
 * new map.  map, x, y must be set.  map is the map we are moving the
 * player to - it could be the map he just came from if the load failed for
 * whatever reason.  If default map coordinates are to be used, then
 * the function that calls this should figure them out.
 */
void
object::enter_map (maptile *newmap, int x, int y)
{
  if (out_of_map (newmap, x, y))
    {
      LOG (llevError, "enter_map: supplied coordinates are not within the map! (%s: %d, %d)\n", &newmap->path, x, y);
      x = newmap->enter_x;
      y = newmap->enter_y;
      if (out_of_map (newmap, x, y))
        {
          LOG (llevError, "enter_map: map %s provides invalid default enter location (%d, %d) > (%d, %d)\n",
               &newmap->path, x, y, newmap->width, newmap->height);
          new_draw_info (NDI_UNIQUE, 0, this, "The exit is closed");
          return;
        }
    }

  if (map)
    if (INVOKE_MAP (LEAVE, map, ARG_PLAYER (contr)))
      return;

  /* If it is a player login, he has yet to be inserted anyplace.
   * otherwise, we need to deal with removing the player here.
   */
  remove ();

  /* try to find a spot for the player */
  if (ob_blocked (this, newmap, x, y))
    {                           /* First choice blocked */
      /* We try to find a spot for the player, starting closest in.
       * We could use find_first_free_spot, but that doesn't randomize it at all,
       * So for example, if the north space is free, you would always end up there even
       * if other spaces around are available.
       * Note that for the second and third calls, we could start at a position other
       * than one, but then we could end up on the other side of walls and so forth.
       */
      int i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE1 + 1);

      if (i == -1)
        {
          i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE2 + 1);
          if (i == -1)
            i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE);
        }

      if (i != -1)
        {
          x += freearr_x[i];
          y += freearr_y[i];
        }
      else
        /* not much we can do in this case. */
        LOG (llevInfo, "enter_map: Could not find free spot for player - will dump on top of object (%s: %d, %d)\n", &newmap->path, x, y);
    }

  if (INVOKE_PLAYER (MAP_CHANGE, contr, ARG_MAP (newmap), ARG_INT (x), ARG_INT (y)))
    return;

  if (INVOKE_MAP (ENTER, newmap, ARG_PLAYER (contr), ARG_INT (x), ARG_INT (y)))
    return;

  this->x = x;
  this->y = y;
  map = newmap;

  insert_ob_in_map (this, map, 0, INS_NO_WALK_ON);

  newmap->timeout = 0;
  enemy = NULL;

  if (contr)
    {
      strcpy (contr->maplevel, newmap->path);
      contr->count = 0;
    }

  /* Update any golems */
  if (type == PLAYER && contr->ranges[range_golem])
    {
      int i = find_free_spot (contr->ranges[range_golem], newmap,
                              x, y, 1, SIZEOFFREE);

      contr->ranges[range_golem]->remove ();

      if (i == -1)
        {
          remove_friendly_object (contr->ranges[range_golem]);
          contr->ranges[range_golem]->destroy ();
          contr->ranges[range_golem] = 0;
        }
      else
        {
          for (object *tmp = contr->ranges[range_golem]; tmp != NULL; tmp = tmp->more)
            {
              tmp->x = x + freearr_x[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x);
              tmp->y = y + freearr_y[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y);
              tmp->map = newmap;
            }

          insert_ob_in_map (contr->ranges[range_golem], newmap, NULL, 0);
          contr->ranges[range_golem]->direction =
            find_dir_2 (x - contr->ranges[range_golem]->x, y - contr->ranges[range_golem]->y);
        }
    }

  direction = 0;

  /* since the players map is already loaded, we don't need to worry
   * about pending objects.
   */
  remove_all_pets (newmap);
}

/* process_players1 and process_players2 do all the player related stuff.
 * I moved it out of process events and process_map.  This was to some
 * extent for debugging as well as to get a better idea of the time used
 * by the various functions.  process_players1() does the processing before
 * objects have been updated, process_players2() does the processing that
 * is needed after the players have been updated.
 */
static void
process_players1 ()
{
  int flag;

  /* Basically, we keep looping until all the players have done their actions. */
  for (flag = 1; flag != 0;)
    {
      flag = 0;
      for_all_players (pl)
        {
          pl->refcnt_chk ();

          if (!pl->ob || !pl->ns)
            continue;

          if (pl->ob->speed_left > 0)
            if (handle_newcs_player (pl->ob))
              flag = 1;

          /* If the player is not actively playing, don't make a
           * backup save - nothing to save anyway.  Plus, the
           * map may not longer be valid.  This can happen when the
           * player quits - they exist for purposes of tracking on the map,
           * but don't actually reside on any actual map.
           */
          if (QUERY_FLAG (pl->ob, FLAG_REMOVED))
            continue;

#ifdef AUTOSAVE
          /* check for ST_PLAYING state so that we don't try to save off when
           * the player is logging in.
           */
          if ((pl->last_save_tick + AUTOSAVE) < (uint32) pticks && pl->ns->state == ST_PLAYING)
            {
              pl->ob->contr->save ();
              pl->last_save_tick = pticks;
            }
#endif
        }                       /* end of for loop for all the players */
    }                           /* for flag */

  for_all_players (pl)
    {
      if (!pl->ob || !pl->ns)
        continue;

      if (settings.casting_time)
        {
          if (pl->ob->casting_time > 0)
            {
              pl->ob->casting_time--;
              pl->ob->start_holding = 1;
            }

          /* set spell_state so we can update the range in stats field */
          if ((pl->ob->casting_time == 0) && (pl->ob->start_holding == 1))
            pl->ob->start_holding = 0;
        }

      do_some_living (pl->ob);
    }
}

static void
process_players2 ()
{
  /* Then check if any players should use weapon-speed instead of speed */
  for_all_players (pl)
    {
      /* The code that did weapon_sp handling here was out of place -
       * this isn't called until after the player has finished there
       * actions, and is thus out of place.  All we do here is bounds
       * checking.
       */
      if (pl->has_hit)
        {
          if (pl->ob->speed_left > pl->weapon_sp)
            pl->ob->speed_left = pl->weapon_sp;

          /* This needs to be here - if the player is running, we need to
           * clear this each tick, but new commands are not being received
           * so execute_newserver_command() is never called
           */
          pl->has_hit = 0;
        }
      else if (pl->ob->speed_left > pl->ob->speed)
        pl->ob->speed_left = pl->ob->speed;
    }
}

void
process_events ()
{
  object *op;

  static object_ptr marker_;

  if (!marker_)
    marker_ = object::create ();

  object *marker = marker_;

  process_players1 ();

  marker->active_next = active_objects;

  if (marker->active_next)
    marker->active_next->active_prev = marker;

  marker->active_prev = 0;
  active_objects = marker;

  while (marker->active_next)
    {
      op = marker->active_next;

      /* Move marker forward - swap op and marker */
      op->active_prev = marker->active_prev;

      if (op->active_prev)
        op->active_prev->active_next = op;
      else
        active_objects = op;

      marker->active_next = op->active_next;

      if (marker->active_next)
        marker->active_next->active_prev = marker;

      marker->active_prev = op;
      op->active_next = marker;

      /* Now process op */
      if (QUERY_FLAG (op, FLAG_FREED))
        {
          LOG (llevError, "BUG: process_events(): Free object on list\n");
          op->set_speed (0);
          continue;
        }

      /* I've seen occasional crashes due to this - the object is removed,
       * and thus the map it points to (last map it was on) may be bogus
       * The real bug is to try to find out the cause of this - someone
       * is probably calling remove_ob without either an insert_ob or
       * free_object afterwards, leaving an object dangling.  But I'd
       * rather log this and continue on instead of crashing.
       * Don't remove players - when a player quits, the object is in
       * sort of a limbo, of removed, but something we want to keep
       * around.
       */
      if (QUERY_FLAG (op, FLAG_REMOVED) && op->type != PLAYER && op->map && op->map->in_memory != MAP_IN_MEMORY)
        {
          LOG (llevError, "BUG: process_events(): Removed object on list\n");
          char *dump = dump_object (op);
          LOG (llevError, dump);
          free (dump);
          op->destroy ();
          continue;
        }

      if (!op->has_active_speed ())
        {
          LOG (llevError, "BUG: process_events(): Object %s has no speed (%f), "
                          "but is on active list\n", op->debug_desc (), op->speed);
          op->set_speed (0);
          continue;
        }

      if (op->map == NULL && op->env == NULL && op->name && op->type != MAP)
        {
          LOG (llevError, "BUG: process_events(): Object without map or "
                          "inventory is on active list: %s (%d)\n", &op->name, op->count);
          op->set_speed (0);
          continue;
        }

      /* Animate the object. Bug or feature that anim_speed
       * is based on ticks, and not the creatures speed?
       */
      if (op->anim_speed && op->last_anim >= op->anim_speed)
        {
          if ((op->type == PLAYER))
            animate_object (op, op->facing);
          else
            animate_object (op, op->direction);

          op->last_anim = 1;
        }
      else
        op->last_anim++;

      if (op->speed_left > 0)
        {
#if 0
          /* I've seen occasional crashes in move_symptom() with it
           * crashing because op is removed - add some debugging to
           * track if it is removed at this point.
           * This unfortunately is a bit too verbose it seems - not sure
           * why - I think what happens is a map is freed or something and
           * some objects get 'lost' - removed never to be reclaimed.
           * removed objects generally shouldn't exist.
           */
          if (QUERY_FLAG (op, FLAG_REMOVED))
            {
              LOG (llevDebug, "process_events: calling process_object with removed object %s\n", op->name ? op->name : "null");
            }
#endif
          --op->speed_left;
          process_object (op);

          if (op->destroyed ())
            continue;
        }

      if (settings.casting_time == TRUE && op->casting_time > 0)
        op->casting_time--;

      if (op->speed_left <= 0)
        op->speed_left += FABS (op->speed);
    }

  /* Remove marker object from active list */
  if (marker->active_prev != NULL)
    marker->active_prev->active_next = NULL;
  else
    active_objects = NULL;

  process_players2 ();
}

/* clean up everything before exiting */
void
emergency_save ()
{
  LOG (llevDebug, "emergency save begin.\n");

  LOG (llevDebug, "saving players.\n");
  for_all_players (pl)
    pl->save (1);

//  for_all_players (pl)
//    if (pl->ob)
//      pl->ob->remove ();

  LOG (llevDebug, "saving maps.\n");
  maptile::emergency_save ();

  LOG (llevDebug, "saving book archive.\n");
  write_book_archive ();

  LOG (llevDebug, "emergency save done.\n");
}

/* clean up everything before exiting */
void
cleanup (bool make_core)
{
  LOG (llevDebug, "cleanup begin.\n");

  if (init_done && !in_cleanup)
    {
      in_cleanup = true;
      emergency_save ();
    }
  else
    in_cleanup = true;

  LOG (llevDebug, "running cleanup handlers.\n");
  INVOKE_GLOBAL (CLEANUP);

  LOG (llevDebug, "cleanup done.\n");

  if (make_core)
    abort ();
  else
    _exit (0);
}

void
leave (player *pl, int draw_exit)
{
  if (pl)
    {
      if (pl->ob->type != DEAD_OBJECT)
        {
          /* If a hidden dm dropped connection do not create
           * inconsistencies by showing that they have left the game 
           */
          if (!(QUERY_FLAG (pl->ob, FLAG_WIZ) && pl->ob->contr->hidden)
              && draw_exit)
            {
              if (pl->ob->map)
                {
                  INVOKE_PLAYER (LOGOUT, pl);
                  LOG (llevInfo, "LOGOUT: Player named %s from ip %s\n", &pl->ob->name, pl->ns->host);
                }

              char buf[MAX_BUF];

              sprintf (buf, "%s left the game.", &pl->ob->name);
              new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, 0, buf);
            }

          pl->ob->remove ();
          pl->ob->type = DEAD_OBJECT;   /* To avoid problems with inventory window */
        }

      /* We do this so that the socket handling routine can do the final
       * cleanup.  We also leave that loop to actually handle the freeing
       * of the data.
       */
      if (pl->ns)
        pl->ns->destroy ();

    }
}

int
forbid_play (void)
{
#if !defined(_IBMR2) && !defined(___IBMR2) && defined(PERM_FILE)
  char buf[MAX_BUF], day[MAX_BUF];
  FILE *fp;
  time_t clock;
  struct tm *tm;
  int i, start, stop, forbit = 0, comp;

  clock = time (NULL);
  tm = (struct tm *) localtime (&clock);

  sprintf (buf, "%s/%s", settings.confdir, PERM_FILE);
  if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
    return 0;

  while (fgets (buf, MAX_BUF, fp))
    {
      if (buf[0] == '#')
        continue;
      if (!strncmp (buf, "msg", 3))
        {
          if (forbit)
            while (fgets (buf, MAX_BUF, fp))    /* print message */
              fputs (buf, logfile);
          break;

        }
      else if (sscanf (buf, "%s %d%*c%d\n", day, &start, &stop) != 3)
        {
          LOG (llevDebug, "Warning: Incomplete line in permission file ignored.\n");
          continue;
        }

      for (i = 0; i < 7; i++)
        {
          if (!strncmp (buf, days[i], 3) && (tm->tm_wday == i) && (tm->tm_hour >= start) && (tm->tm_hour < stop))
            forbit = 1;
        }
    }

  close_and_delete (fp, comp);

  return forbit;
#else
  return 0;
#endif
}

/*
 *  do_specials() is a collection of functions to call from time to time.
 * Modified 2000-1-14 MSW to use the global pticks count to determine how
 * often to do things.  This will allow us to spred them out more often.
 * I use prime numbers for the factor count - in that way, it is less likely
 * these actions will fall on the same tick (compared to say using 500/2500/15000
 * which would mean on that 15,000 tick count a whole bunch of stuff gets
 * done).  Of course, there can still be times where multiple specials are
 * done on the same tick, but that will happen very infrequently
 *
 * I also think this code makes it easier to see how often we really are
 * doing the various things.
 */

extern unsigned long todtick;

void
do_specials (void)
{
  if (!(pticks % PTICKS_PER_CLOCK))
    tick_the_clock ();

  if (!(pticks % 7))
    shstr::gc ();

  if (!(pticks % 2503))
    fix_weight ();              /* Hack to fix weightproblems caused by bugs */

  if (!(pticks % 5003))
    write_book_archive ();

  if (!(pticks % 5009))
    clean_friendly_list ();

  if (!(pticks % 5011))
    obsolete_parties ();

  if (!(pticks % 12503))
    fix_luck ();
}

void
server_tick ()
{
  // first do the user visible stuff
  doeric_server ();
  INVOKE_GLOBAL (CLOCK);
  process_events ();           /* "do" something with objects with speed */
  flush_sockets ();

  // then do some bookkeeping, should not really be here
  do_specials ();               /* Routines called from time to time. */
  attachable::check_mortals ();

  ++pticks;
}

int
main (int argc, char **argv)
{
  settings.argc = argc;
  settings.argv = argv;

  init (argc, argv);

  initPlugins ();

  for (;;)
    cfperl_main ();

  cleanup (true);
}

Revision:	1.68
Committed:	Sun Dec 31 10:28:36 2006 UTC (17 years, 5 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.67:	+0 -3 lines
Log Message:	different interface design for c++/perl map handling, some random map framework