server/server/main.C

/*
 * CrossFire, A Multiplayer game
 *
 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
 * 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>

#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)
    clear_win_info (op);

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

  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, "");
  new_draw_info (NDI_UNIQUE, 0, op, "Authors and contributors to the original Crossfire:");
  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 Jørgensen <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, "");
  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, "");
  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 (destroyed () || !newmap || newmap->in_memory != MAP_IN_MEMORY)
    return;

  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 (contr && map != newmap && map)
    if (INVOKE_MAP (LEAVE, map, ARG_PLAYER (contr)))
      return;

  // remove, so stupid ob_locked does not trigger a failure
  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 (contr && map != newmap)
    {
      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);

  enemy = 0;

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

  /* Update any golems */
  if (type == PLAYER)
    if (object *golem = contr->golem)
      {
        int i = find_free_spot (golem, newmap, x, y, 1, SIZEOFFREE);

        if (i < 0)
          golem->destroy ();
        else
          {
            newmap->insert (golem, x + freearr_x[i], y + freearr_y[i]);
            golem->direction = find_dir_2 (x - golem->x, y - golem->y);
          }
      }

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

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

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

  for_all_players (pl)
    {
      object *ob = pl->ob;

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

      do_some_living (ob);
    }
}

static void
process_players2 ()
{
  /* Then check if any players should use weapon-speed instead of speed */
  for_all_players (pl)
    {
      pl->weapon_sp_left = min (pl->weapon_sp, pl->weapon_sp_left + pl->weapon_sp);
      pl->ob->speed_left = min (pl->ob->speed, pl->ob->speed_left + pl->ob->speed);
    }
}

void
process_events ()
{
  process_players1 ();

  for_all_actives (op)
    {
      /* Now process op */
      if (QUERY_FLAG (op, FLAG_FREED))
        {
          LOG (llevError, "BUG: process_events(): Free object on list\n");
          op->set_speed (0);
          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->flag [FLAG_REMOVED])
        {
          LOG (llevError, "BUG: process_events(): removed object is on active list: %s\n",
               op->debug_desc ());
          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)
        {
          animate_object (op, op->contr ? op->facing : op->direction);
          op->last_anim = 1;
        }
      else
        ++op->last_anim;

      if (op->speed_left > 0.f)
        {
          --op->speed_left;
          process_object (op);

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

      if (!op->contr)
        op->speed_left = min (abs (op->speed), op->speed_left + abs (op->speed));
    }

  process_players2 ();
}

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

  cfperl_emergency_save ();

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

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

// send all clients some informational text
static void
cleanup_inform (const char *cause, bool make_core)
{
  int flags = NDI_UNIQUE | NDI_ALL | (make_core ? NDI_RED : NDI_GREEN);

  new_draw_info_format (flags, 0, 0, "The server will now shutdown.\n");
  new_draw_info_format (flags, 0, 0, "Cause for this shutdown: %s\n", cause);

  if (make_core)
    new_draw_info_format (flags, 0, 0, "This is considered a crash, but all maps and players have been saved.\n");
  else
    new_draw_info_format (flags, 0, 0, "This is considered to be a clean shutdown, and all maps and players will be saved now.\n");

  new_draw_info_format (flags, 0, 0, "%s\n", CLEANUP_MESSAGE);

  flush_sockets ();
}

/* clean up everything before exiting */
void
cleanup (const char *cause, bool make_core)
{
  if (make_core)
    fork_abort (cause);

  LOG (llevError, "cleanup cause: %s\n", cause);

  if (!make_core)
    cleanup_inform (cause, 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)
    {
      cleanup_inform (cause, make_core);
      cfperl_cleanup (make_core);
      _exit (1);
    }
  else
    {
      new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_GREEN, 0, 0, "Maps and players successfully saved, exiting.\n");
      new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_GREEN, 0, 0, "And again: " CLEANUP_MESSAGE "\n");
      flush_sockets ();
      cfperl_cleanup (make_core);
      _exit (0);
    }
}

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.
 */
void
do_specials (void)
{
  if (!(pticks % TICKS_PER_HOUR))
    adjust_daylight ();

  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;
}

#if 0
// used fro benchmarking (x86/amd64-specific)
typedef unsigned long tval;
typedef unsigned long long stamp64;

extern inline tval
stamp (void)
{
  tval tsc;
  asm volatile ("rdtsc":"=a" (tsc)::"edx");

  return tsc;
}

extern inline tval
measure (tval t)
{
  tval tsc;
  asm volatile ("rdtsc":"=a" (tsc)::"edx");

  if (tsc > t)
    return tsc - t;
  else
    return t - tsc;
}

int
main (int argc, char **argv)
{
  rand_gen rg(0);
  tval fastest = 0x7fffffff;
  for (int loop = 10000; loop--; )
    {
      tval s = stamp ();
      volatile int i = rg.get_int(25);
      fastest = min (fastest, measure (s));
    }

  //printf ("fastest %d\n", fastest);
  for (int i = 0; i < 1024*1024*3; ++i)
    {
      char c = rg.get_int (256);
      write (2, &c, 1);
    }
}

#else

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

  init (argc, argv);

  initPlugins ();

  for (;;)
    cfperl_main ();
}
#endif

Revision:	1.107
Committed:	Fri May 18 20:45:37 2007 UTC (17 years ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_1
Changes since 1.106:	+0 -4 lines
Log Message:	some more optimisations
#	Content
1	/*
2	* CrossFire, A Multiplayer game
3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
5	* Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen
7	*
8	* This program is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or
11	* (at your option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>
23	*/
24
25	#include <global.h>
26	#include <object.h>
27	#include <tod.h>
28
29	#include <sproto.h>
30	#include <time.h>
31
32	#include <../random_maps/random_map.h>
33	#include <../random_maps/rproto.h>
34	#include "path.h"
35
36	static char days[7][4] = {
37	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
38	};
39
40	void
41	version (object *op)
42	{
43	if (op)
44	clear_win_info (op);
45
46	new_draw_info_format (NDI_UNIQUE, 0, op, "This is Crossfire+ v%s", VERSION);
47
48	new_draw_info (NDI_UNIQUE, 0, op, "Authors and contributors to this program:");
49	new_draw_info (NDI_UNIQUE, 0, op, "Marc A. Lehmann <pcg@goof.com>");
50	new_draw_info (NDI_UNIQUE, 0, op, "Robin Redeker <elmex@x-paste.de>");
51	new_draw_info (NDI_UNIQUE, 0, op, "Pippijn van Steenhoven <pip88nl@gmail.com>");
52	new_draw_info (NDI_UNIQUE, 0, op, "");
53	new_draw_info (NDI_UNIQUE, 0, op, "Authors and contributors to the original Crossfire:");
54	new_draw_info (NDI_UNIQUE, 0, op, "Mark Wedel <mwedel@sonic.net>");
55	new_draw_info (NDI_UNIQUE, 0, op, "Frank Tore Johansen <frankj@ifi.uio.no>");
56	new_draw_info (NDI_UNIQUE, 0, op, "Kjetil Torgrim Homme <kjetilho@ifi.uio.no>");
57	new_draw_info (NDI_UNIQUE, 0, op, "Tyler Van Gorder <tvangod@ecst.csuchico.edu>");
58	new_draw_info (NDI_UNIQUE, 0, op, "Tony Elmroth <elmroth@cd.chalmers.se>");
59	new_draw_info (NDI_UNIQUE, 0, op, "Dougal Scott <dougal.scott@fcit.monasu.edu.au>");
60	new_draw_info (NDI_UNIQUE, 0, op, "William <wchuang@athena.mit.edu>");
61	new_draw_info (NDI_UNIQUE, 0, op, "Geoff Bailey <ftww@cs.su.oz.au>");
62	new_draw_info (NDI_UNIQUE, 0, op, "Kjetil Wiekhorst Jørgensen <jorgens@flipper.pvv.unit.no>");
63	new_draw_info (NDI_UNIQUE, 0, op, "Cameron Blackwood <c.blackwood@rdt.monash.edu.au>");
64	new_draw_info (NDI_UNIQUE, 0, op, "Joseph L. Traub <jtraub+@cmu.edu>");
65	new_draw_info (NDI_UNIQUE, 0, op, "Rupert G. Goldie <rgg@aaii.oz.au>");
66	new_draw_info (NDI_UNIQUE, 0, op, "Eric A. Anderson <eanders+@cmu.edu>");
67	new_draw_info (NDI_UNIQUE, 0, op, "Rickard Eneqvist <eneq@Prag.DoCS.UU.SE>");
68	new_draw_info (NDI_UNIQUE, 0, op, "Jarkko Sonninen <Jarkko.Sonninen@lut.fi>");
69	new_draw_info (NDI_UNIQUE, 0, op, "Karl Holland <kholland@sunlab.cit.cornell.du>");
70	new_draw_info (NDI_UNIQUE, 0, op, "Mikael Lundgren <vick@bern.docs.uu.se>");
71	new_draw_info (NDI_UNIQUE, 0, op, "Mikael Olsson <mol@meryl.csd.uu.se>");
72	new_draw_info (NDI_UNIQUE, 0, op, "Tero Haatanen <Tero.Haatanen@lut.fi>");
73	new_draw_info (NDI_UNIQUE, 0, op, "Lasse Ylitalo <ylitalo@student.docs.uu.se>");
74	new_draw_info (NDI_UNIQUE, 0, op, "Niilo Neuvo <anipa@guru.magic.fi>");
75	new_draw_info (NDI_UNIQUE, 0, op, "Markku J{rvinen <mta@modeemi.cs.tut.fi>");
76	new_draw_info (NDI_UNIQUE, 0, op, "Sylvain Meunier <meunier@inf.enst.fr>");
77	new_draw_info (NDI_UNIQUE, 0, op, "Jason Fosback <jfosback@darmok.uoregon.edu>");
78	new_draw_info (NDI_UNIQUE, 0, op, "Carl Edman <cedman@capitalist.princeton.edu>");
79	new_draw_info (NDI_UNIQUE, 0, op, "Charles Henrich <henrich@crh.cl.msu.edu>");
80	new_draw_info (NDI_UNIQUE, 0, op, "Gregor Schmid <schmid@fb3-s7.math.tu-berlin.de>");
81	new_draw_info (NDI_UNIQUE, 0, op, "Raphael Quinet <quinet@montefiore.ulg.ac.be>");
82	new_draw_info (NDI_UNIQUE, 0, op, "Jari Vanhala <jam@modeemi.cs.tut.fi>");
83	new_draw_info (NDI_UNIQUE, 0, op, "Tero Kivinen <kivinen@joker.cs.hut.fi>");
84	new_draw_info (NDI_UNIQUE, 0, op, "Peter Mardahl <peterm@soda.berkeley.edu>");
85	new_draw_info (NDI_UNIQUE, 0, op, "Matthew Zeher <matt@cs.odu.edu>");
86	new_draw_info (NDI_UNIQUE, 0, op, "Scott R. Turner <srt@sun-dimas.aero.org>");
87	new_draw_info (NDI_UNIQUE, 0, op, "Ben Fennema <huma@netcom.com>");
88	new_draw_info (NDI_UNIQUE, 0, op, "Nick Williams <njw@cs.city.ac.uk>");
89	new_draw_info (NDI_UNIQUE, 0, op, "Laurent Wacrenier <Wacren@Gin.ObsPM.Fr>");
90	new_draw_info (NDI_UNIQUE, 0, op, "Brian Thomas <thomas@astro.psu.edu>");
91	new_draw_info (NDI_UNIQUE, 0, op, "John Steven Moerk <jsm@axon.ksc.nasa.gov>");
92	new_draw_info (NDI_UNIQUE, 0, op, "Delbecq David <david.delbecq@mailandnews.com>");
93	new_draw_info (NDI_UNIQUE, 0, op, "Chachkoff Yann <yann.chachkoff@mailandnews.com>\n");
94	new_draw_info (NDI_UNIQUE, 0, op, "");
95	new_draw_info (NDI_UNIQUE, 0, op, "Images and art:");
96	new_draw_info (NDI_UNIQUE, 0, op, "Peter Gardner");
97	new_draw_info (NDI_UNIQUE, 0, op, "David Gervais <david_eg@mail.com>");
98	new_draw_info (NDI_UNIQUE, 0, op, "Mitsuhiro Itakura <ita@gold.koma.jaeri.go.jp>");
99	new_draw_info (NDI_UNIQUE, 0, op, "Hansjoerg Malthaner <hansjoerg.malthaner@danet.de>");
100	new_draw_info (NDI_UNIQUE, 0, op, "Mårten Woxberg <maxmc@telia.com>");
101	new_draw_info (NDI_UNIQUE, 0, op, "");
102	new_draw_info (NDI_UNIQUE, 0, op, "And many more!");
103	}
104
105	/* This is a basic little function to put the player back to his
106	* savebed. We do some error checking - its possible that the
107	* savebed map may no longer exist, so we make sure the player
108	* goes someplace.
109	*/
110	void
111	enter_player_savebed (object *op)
112	{
113	object *tmp = object::create ();
114	EXIT_PATH (tmp) = op->contr->savebed_map;
115	EXIT_X (tmp) = op->contr->bed_x;
116	EXIT_Y (tmp) = op->contr->bed_y;
117	op->enter_exit (tmp);
118	tmp->destroy ();
119	}
120
121	/*
122	* enter_map(): Moves the player and pets from current map (if any) to
123	* new map. map, x, y must be set. map is the map we are moving the
124	* player to - it could be the map he just came from if the load failed for
125	* whatever reason. If default map coordinates are to be used, then
126	* the function that calls this should figure them out.
127	*/
128	void
129	object::enter_map (maptile *newmap, int x, int y)
130	{
131	if (destroyed () \|\| !newmap \|\| newmap->in_memory != MAP_IN_MEMORY)
132	return;
133
134	if (out_of_map (newmap, x, y))
135	{
136	LOG (llevError, "enter_map: supplied coordinates are not within the map! (%s: %d, %d)\n", &newmap->path, x, y);
137	x = newmap->enter_x;
138	y = newmap->enter_y;
139	if (out_of_map (newmap, x, y))
140	{
141	LOG (llevError, "enter_map: map %s provides invalid default enter location (%d, %d) > (%d, %d)\n",
142	&newmap->path, x, y, newmap->width, newmap->height);
143	new_draw_info (NDI_UNIQUE, 0, this, "The exit is closed");
144	return;
145	}
146	}
147
148	if (contr && map != newmap && map)
149	if (INVOKE_MAP (LEAVE, map, ARG_PLAYER (contr)))
150	return;
151
152	// remove, so stupid ob_locked does not trigger a failure
153	remove ();
154
155	/* try to find a spot for the player */
156	if (ob_blocked (this, newmap, x, y))
157	{ /* First choice blocked */
158	/* We try to find a spot for the player, starting closest in.
159	* We could use find_first_free_spot, but that doesn't randomize it at all,
160	* So for example, if the north space is free, you would always end up there even
161	* if other spaces around are available.
162	* Note that for the second and third calls, we could start at a position other
163	* than one, but then we could end up on the other side of walls and so forth.
164	*/
165	int i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE1 + 1);
166
167	if (i == -1)
168	{
169	i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE2 + 1);
170	if (i == -1)
171	i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE);
172	}
173
174	if (i != -1)
175	{
176	x += freearr_x[i];
177	y += freearr_y[i];
178	}
179	else
180	/* not much we can do in this case. */
181	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);
182	}
183
184	if (contr && map != newmap)
185	{
186	if (INVOKE_PLAYER (MAP_CHANGE, contr, ARG_MAP (newmap), ARG_INT (x), ARG_INT (y)))
187	return;
188
189	if (INVOKE_MAP (ENTER, newmap, ARG_PLAYER (contr), ARG_INT (x), ARG_INT (y)))
190	return;
191	}
192
193	this->x = x;
194	this->y = y;
195	map = newmap;
196
197	insert_ob_in_map (this, map, 0, INS_NO_WALK_ON);
198
199	enemy = 0;
200
201	if (contr)
202	{
203	contr->maplevel = newmap->path;
204	contr->count = 0;
205	}
206
207	/* Update any golems */
208	if (type == PLAYER)
209	if (object *golem = contr->golem)
210	{
211	int i = find_free_spot (golem, newmap, x, y, 1, SIZEOFFREE);
212
213	if (i < 0)
214	golem->destroy ();
215	else
216	{
217	newmap->insert (golem, x + freearr_x[i], y + freearr_y[i]);
218	golem->direction = find_dir_2 (x - golem->x, y - golem->y);
219	}
220	}
221
222	/* since the players map is already loaded, we don't need to worry
223	* about pending objects.
224	*/
225	remove_all_pets (newmap);
226	}
227
228	/* process_players1 and process_players2 do all the player related stuff.
229	* I moved it out of process events and process_map. This was to some
230	* extent for debugging as well as to get a better idea of the time used
231	* by the various functions. process_players1() does the processing before
232	* objects have been updated, process_players2() does the processing that
233	* is needed after the players have been updated.
234	*/
235	static void
236	process_players1 ()
237	{
238	/* Basically, we keep looping until all the players have done their actions. */
239	for (int flag = 1; flag != 0;)
240	{
241	flag = 0;
242	for_all_players (pl)
243	{
244	pl->refcnt_chk ();
245
246	if (!pl->ob \|\| !pl->ns \|\| !pl->ob->active)
247	continue;
248
249	if (handle_newcs_player (pl->ob))
250	flag = 1;
251	}
252	}
253
254	for_all_players (pl)
255	{
256	object *ob = pl->ob;
257
258	if (!ob \|\| !pl->ns \|\| !ob->active)
259	continue;
260
261	do_some_living (ob);
262	}
263	}
264
265	static void
266	process_players2 ()
267	{
268	/* Then check if any players should use weapon-speed instead of speed */
269	for_all_players (pl)
270	{
271	pl->weapon_sp_left = min (pl->weapon_sp, pl->weapon_sp_left + pl->weapon_sp);
272	pl->ob->speed_left = min (pl->ob->speed, pl->ob->speed_left + pl->ob->speed);
273	}
274	}
275
276	void
277	process_events ()
278	{
279	process_players1 ();
280
281	for_all_actives (op)
282	{
283	/* Now process op */
284	if (QUERY_FLAG (op, FLAG_FREED))
285	{
286	LOG (llevError, "BUG: process_events(): Free object on list\n");
287	op->set_speed (0);
288	continue;
289	}
290
291	if (!op->has_active_speed ())
292	{
293	LOG (llevError, "BUG: process_events(): Object %s has no speed (%f), "
294	"but is on active list\n", op->debug_desc (), op->speed);
295	op->set_speed (0);
296	continue;
297	}
298
299	if (op->flag [FLAG_REMOVED])
300	{
301	LOG (llevError, "BUG: process_events(): removed object is on active list: %s\n",
302	op->debug_desc ());
303	op->set_speed (0);
304	continue;
305	}
306
307	/* Animate the object. Bug or feature that anim_speed
308	* is based on ticks, and not the creatures speed?
309	*/
310	if (op->anim_speed && op->last_anim >= op->anim_speed)
311	{
312	animate_object (op, op->contr ? op->facing : op->direction);
313	op->last_anim = 1;
314	}
315	else
316	++op->last_anim;
317
318	if (op->speed_left > 0.f)
319	{
320	--op->speed_left;
321	process_object (op);
322
323	if (op->destroyed ())
324	continue;
325	}
326
327	if (!op->contr)
328	op->speed_left = min (abs (op->speed), op->speed_left + abs (op->speed));
329	}
330
331	process_players2 ();
332	}
333
334	/* clean up everything before exiting */
335	void
336	emergency_save ()
337	{
338	LOG (llevDebug, "emergency save begin.\n");
339
340	cfperl_emergency_save ();
341
342	LOG (llevDebug, "saving book archive.\n");
343	write_book_archive ();
344
345	LOG (llevDebug, "emergency save done.\n");
346	}
347
348	// send all clients some informational text
349	static void
350	cleanup_inform (const char *cause, bool make_core)
351	{
352	int flags = NDI_UNIQUE \| NDI_ALL \| (make_core ? NDI_RED : NDI_GREEN);
353
354	new_draw_info_format (flags, 0, 0, "The server will now shutdown.\n");
355	new_draw_info_format (flags, 0, 0, "Cause for this shutdown: %s\n", cause);
356
357	if (make_core)
358	new_draw_info_format (flags, 0, 0, "This is considered a crash, but all maps and players have been saved.\n");
359	else
360	new_draw_info_format (flags, 0, 0, "This is considered to be a clean shutdown, and all maps and players will be saved now.\n");
361
362	new_draw_info_format (flags, 0, 0, "%s\n", CLEANUP_MESSAGE);
363
364	flush_sockets ();
365	}
366
367	/* clean up everything before exiting */
368	void
369	cleanup (const char *cause, bool make_core)
370	{
371	if (make_core)
372	fork_abort (cause);
373
374	LOG (llevError, "cleanup cause: %s\n", cause);
375
376	if (!make_core)
377	cleanup_inform (cause, make_core);
378
379	LOG (llevDebug, "cleanup begin.\n");
380
381	if (init_done && !in_cleanup)
382	{
383	in_cleanup = true;
384	emergency_save ();
385	}
386	else
387	in_cleanup = true;
388
389	LOG (llevDebug, "running cleanup handlers.\n");
390	INVOKE_GLOBAL (CLEANUP);
391
392	LOG (llevDebug, "cleanup done.\n");
393
394	if (make_core)
395	{
396	cleanup_inform (cause, make_core);
397	cfperl_cleanup (make_core);
398	_exit (1);
399	}
400	else
401	{
402	new_draw_info_format (NDI_UNIQUE \| NDI_ALL \| NDI_GREEN, 0, 0, "Maps and players successfully saved, exiting.\n");
403	new_draw_info_format (NDI_UNIQUE \| NDI_ALL \| NDI_GREEN, 0, 0, "And again: " CLEANUP_MESSAGE "\n");
404	flush_sockets ();
405	cfperl_cleanup (make_core);
406	_exit (0);
407	}
408	}
409
410	int
411	forbid_play (void)
412	{
413	#if !defined(_IBMR2) && !defined(___IBMR2) && defined(PERM_FILE)
414	char buf[MAX_BUF], day[MAX_BUF];
415	FILE *fp;
416	time_t clock;
417	struct tm *tm;
418	int i, start, stop, forbit = 0, comp;
419
420	clock = time (NULL);
421	tm = (struct tm *) localtime (&clock);
422
423	sprintf (buf, "%s/%s", settings.confdir, PERM_FILE);
424	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
425	return 0;
426
427	while (fgets (buf, MAX_BUF, fp))
428	{
429	if (buf[0] == '#')
430	continue;
431
432	if (!strncmp (buf, "msg", 3))
433	{
434	if (forbit)
435	while (fgets (buf, MAX_BUF, fp)) /* print message */
436	fputs (buf, logfile);
437	break;
438	}
439	else if (sscanf (buf, "%s %d%*c%d\n", day, &start, &stop) != 3)
440	{
441	LOG (llevDebug, "Warning: Incomplete line in permission file ignored.\n");
442	continue;
443	}
444
445	for (i = 0; i < 7; i++)
446	{
447	if (!strncmp (buf, days[i], 3) && (tm->tm_wday == i) && (tm->tm_hour >= start) && (tm->tm_hour < stop))
448	forbit = 1;
449	}
450	}
451
452	close_and_delete (fp, comp);
453
454	return forbit;
455	#else
456	return 0;
457	#endif
458	}
459
460	/*
461	* do_specials() is a collection of functions to call from time to time.
462	* Modified 2000-1-14 MSW to use the global pticks count to determine how
463	* often to do things. This will allow us to spred them out more often.
464	* I use prime numbers for the factor count - in that way, it is less likely
465	* these actions will fall on the same tick (compared to say using 500/2500/15000
466	* which would mean on that 15,000 tick count a whole bunch of stuff gets
467	* done). Of course, there can still be times where multiple specials are
468	* done on the same tick, but that will happen very infrequently
469	*
470	* I also think this code makes it easier to see how often we really are
471	* doing the various things.
472	*/
473	void
474	do_specials (void)
475	{
476	if (!(pticks % TICKS_PER_HOUR))
477	adjust_daylight ();
478
479	if (!(pticks % 7))
480	shstr::gc ();
481
482	if (!(pticks % 2503))
483	fix_weight (); /* Hack to fix weightproblems caused by bugs */
484
485	if (!(pticks % 5003))
486	write_book_archive ();
487
488	if (!(pticks % 5009))
489	clean_friendly_list ();
490
491	if (!(pticks % 5011))
492	obsolete_parties ();
493
494	if (!(pticks % 12503))
495	fix_luck ();
496	}
497
498	void
499	server_tick ()
500	{
501	// first do the user visible stuff
502	doeric_server ();
503	INVOKE_GLOBAL (CLOCK);
504	process_events (); /* "do" something with objects with speed */
505	flush_sockets ();
506
507	// then do some bookkeeping, should not really be here
508	do_specials (); /* Routines called from time to time. */
509	attachable::check_mortals ();
510
511	++pticks;
512	}
513
514	#if 0
515	// used fro benchmarking (x86/amd64-specific)
516	typedef unsigned long tval;
517	typedef unsigned long long stamp64;
518
519	extern inline tval
520	stamp (void)
521	{
522	tval tsc;
523	asm volatile ("rdtsc":"=a" (tsc)::"edx");
524
525	return tsc;
526	}
527
528	extern inline tval
529	measure (tval t)
530	{
531	tval tsc;
532	asm volatile ("rdtsc":"=a" (tsc)::"edx");
533
534	if (tsc > t)
535	return tsc - t;
536	else
537	return t - tsc;
538	}
539
540	int
541	main (int argc, char **argv)
542	{
543	rand_gen rg(0);
544	tval fastest = 0x7fffffff;
545	for (int loop = 10000; loop--; )
546	{
547	tval s = stamp ();
548	volatile int i = rg.get_int(25);
549	fastest = min (fastest, measure (s));
550	}
551
552	//printf ("fastest %d\n", fastest);
553	for (int i = 0; i < 102410243; ++i)
554	{
555	char c = rg.get_int (256);
556	write (2, &c, 1);
557	}
558	}
559
560	#else
561
562	// normal main
563	int
564	main (int argc, char **argv)
565	{
566	settings.argc = argc;
567	settings.argv = argv;
568
569	init (argc, argv);
570
571	initPlugins ();
572
573	for (;;)
574	cfperl_main ();
575	}
576	#endif
577