server/server/main.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2001-2003,2007 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992,2007 Frank Tore Johansen
 * 
 * Deliantra 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 <support@deliantra.net>
 */

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

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

#include <glib.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)
{
  new_draw_info_format (NDI_UNIQUE, 0, op, "This is Deliantra v%s", VERSION);

#if 0
  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!");
#endif
}

/* 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)
{
  op->player_goto (op->contr->savebed_map, op->contr->bed_x, op->contr->bed_y);
}

/*
 * 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_ACTIVE)
    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 (blocked (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_inv (true); // be explicit about dropping
            golem->destroy (true);
          }
        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 (expect_false (!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 (expect_false (!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 (expect_false (QUERY_FLAG (op, FLAG_FREED)))
        {
          LOG (llevError, "BUG: process_events(): Free object on list\n");
          op->set_speed (0);
          continue;
        }

      if (expect_false (!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 (expect_false (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 (expect_false (op->speed_left > 0.f))
        {
          --op->speed_left;
          process_object (op);
        }

      if (expect_true (!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_REPLY | NDI_UNIQUE | NDI_ALL | (make_core ? NDI_RED : NDI_GREEN);

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

  if (make_core)
    new_draw_info_format (flags, 0, 0, "This is considered a crash, but all maps and players have been saved.");
  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.");

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

  client::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");

  log_cleanup ();

  if (make_core)
    cleanup_inform (cause, make_core);
  else
    {
      new_draw_info_format (NDI_REPLY | NDI_UNIQUE | NDI_ALL | NDI_GREEN, 0, 0, "Maps and players successfully saved, exiting.");
      new_draw_info_format (NDI_REPLY | NDI_UNIQUE | NDI_ALL | NDI_GREEN, 0, 0, "And again: " CLEANUP_MESSAGE);
      client::flush_sockets ();
    }

  cfperl_cleanup (make_core);
  _exit (make_core);
}

/*
 * 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)
{
  shstr::gc ();
  archetype::gc ();

  if (expect_false (!(pticks % TICKS_PER_HOUR)))
    adjust_daylight ();

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

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

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

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

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

void
server_tick ()
{
  // first do the user visible stuff
  INVOKE_GLOBAL (CLOCK);
  process_events (); // "do" something with objects with speed
  client::clock ();  // draw client maps etc.

  // 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

#if 0 // just goofing around, look elsewhere

#include <malloc.h>
#include <execinfo.h>

static void tr_on ();
static void tr_off ();

static SMUTEX(tr_mutex);

#define ltr_off() SMUTEX_LOCK (tr_mutex); tr_off ()
#define ltr_on()  tr_on (); SMUTEX_UNLOCK (tr_mutex);

static void *
tr_malloc (size_t size, const void *caller)
{
  ltr_off ();

  void *bt [8];
  backtrace (bt, 8);

  void *ptr = malloc (size);

  ltr_on ();
  return (char *)ptr;
}

static void
tr_free (void *ptr, const void *caller)
{
  ltr_off ();

  free (ptr);

  ltr_on ();
}

void static *
tr_realloc (void *ptr, size_t size, const void *caller)
{
  ltr_off ();

  void *nptr = realloc (ptr, size);

  ltr_on ();
  return nptr;
}

static void *
tr_memalign (size_t size, size_t alignment, const void *caller)
{
  ltr_off ();

  void *ptr = memalign (size, alignment < 16 ? 16 : alignment);

  ltr_on ();
  return ptr;
}

static void
tr_on ()
{
  __malloc_hook   = tr_malloc;
  __realloc_hook  = tr_realloc;
  __free_hook     = tr_free;
  __memalign_hook = tr_memalign;
}

static void
tr_off ()
{
  __malloc_hook   = 0;
  __realloc_hook  = 0;
  __free_hook     = 0;
  __memalign_hook = 0;
}

void (*__malloc_initialize_hook)(void) = tr_on;

#endif

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

  g_thread_init (0); // for the slice allocator only

  init (argc, argv);

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

#if 0
int xyzzy ()
{
  return rndm(8);
}

void xyzzy (object_ptr &a, object_ptr &o)
{
  asm volatile ("int3");
  a = o;
  asm volatile ("int3");
}
#endif

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