server/server/main.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 *
 * Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2001-2003 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992 Frank Tore Johansen
 *
 * Deliantra is free software: you can redistribute it and/or modify it under
 * the terms of the Affero 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 Affero GNU General Public License
 * and 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 <rmg.h>
#include <rproto.h>
#include "path.h"

void
version (object *op)
{
  new_draw_info_format (NDI_UNIQUE, 0, op, "This is Deliantra v%s", VERSION);
}

/* This is a basic little function to put the player back to his
 * savebed.
 */
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.
 */
bool
object::enter_map (maptile *newmap, int x, int y)
{
  if (destroyed () || !newmap || !newmap->linkable ())
    return false;

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

  if (contr && map != newmap && map)
    if (INVOKE_MAP (LEAVE, map, ARG_PLAYER (contr)))
      return false;

  // remove, so stupid blocked 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 < 0)
        {
          i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE2 + 1);
          if (i < 0)
            i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE);
        }

      if (i >= 0)
        {
          maptile *m = newmap;
          sint16 nx  = x + DIRX (i);
          sint16 ny  = y + DIRY (i);

          if (xy_normalise (m, nx, ny))
            {
              newmap = m;
              x = nx;
              y = ny;
            }
        }
      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 false;

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

  enemy = 0;

  newmap->activate (); // workaround for activate activating everyhing on the map, includign the palyer on the {link} map
  //newmap->insert (this, x, y);
  newmap->insert (this, x, y, 0, INS_NO_AUTO_EXIT);
  prefetch_surrounding_maps ();

  if (map == newmap) // see if we actually arrived there - insert might trigger a teleport
    {
      if (contr)
        {
          contr->maplevel = newmap->path;
          contr->count = 0;

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

              if (i < 0)
                golem->drop_and_destroy ();
              else
                {
                  newmap->insert (golem, x + DIRX (i), y + DIRY (i));
                  golem->direction = find_dir_2 (golem->x - x, golem->y - y);
                }
            }
        }

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

      return true;
    }

  return false;
}

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

      // process_objects destroys the speed_left value
      pl->speed_left_save = ob->speed_left;

      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)
    {
      // restore speed_left value saved by process_players1
      pl->ob->speed_left = pl->speed_left_save;

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

static void
process_events ()
{
  process_players1 ();

  for_all_actives (op)
    {
      // try to prefetch some stuff we expect to need
      // obviously, it should be grouped into the same cacheline.
      // preliminary results indicate that this gives halves the speed
      // used for the inner loop
      if (_i < actives.size ()) // HACK, rely on _i :/
        {
          object *next = actives [_i + 1];

          ecb_prefetch (&next->flag      , 0, 1);
          ecb_prefetch (&next->speed     , 0, 1);
          ecb_prefetch (&next->anim_speed, 0, 1);
          ecb_prefetch (&next->contr     , 0, 1);
        }

      /* Now process op */
      if (expect_false (op->flag [FLAG_FREED]))
        {
          LOG (llevError, "BUG: process_events(): Free object on list (%s)\n", op->debug_desc ());
          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);
        }

      // this will destroy the speed_left value for players, but
      // process_players1 and ..2 save/restore the real value,
      // so we can avoid a costly test here.
      op->speed_left = min (op->speed, op->speed_left + op->speed);
    }

  process_players2 ();
}

/* clean up everything before exiting */
void
emergency_save ()
{
  LOG (llevInfo, "emergency_save: enter\n");

  LOG (llevInfo, "emergency_save: saving book archive\n");
  write_book_archive ();

  cfperl_emergency_save ();

  LOG (llevInfo, "emergency_save: leave\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 (make_core ? llevError : llevInfo, "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 server_tick 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.
 */
static void
do_specials ()
{
  shstr::gc ();
  archetype::gc ();

  if (expect_false (!(server_tick % TICKS_PER_HOUR)))
    maptile::adjust_daylight ();

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

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

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

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

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

void
one_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 ();

  // now that we aggressively reuse id's, this is very unlikely to happen...
  if (object::object_count >= RESTART_COUNT)
    cleanup ("running out of protocol ID values - need full restart");
}

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

  rndm.seed (time (0));

  // temporary(?) testing hack
  if (argc >= 2 && !strcmp (argv [1], "--noise"))
    {
      void noise_test ();
      noise_test ();
      exit (0);
    }

#if 0
  // code sometiems used for timing benchmarks
  random_number_generator<freeciv_random_generator> rng;
  rng.seed(0);
  for (int i = 0; i < 10; ++i)
    printf ("%08x\n", rng.get_u32());
  for (int i = 0; i < 1000000; ++i)
    volatile int r = rng.get_u32 ();
  cstamp s = stamp ();
  for (int i = 0; i < 1000000; ++i)
    volatile int r = rng.next ();
  printf ("c %d\n", (int)measure (s));
  exit (0);
#endif
  
  init (argc, argv);

  for (;;)
    cfperl_main ();
}

Revision:	1.180
Committed:	Sat Nov 17 23:40:04 2018 UTC (5 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.179:	+1 -0 lines
Log Message:	copyright update 2018
#	User	Rev	Content
1	elmex	1.1	/*
2	root	1.120	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	root	1.175	*
4	root	1.180	* Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
5	root	1.176	* Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
6	root	1.148	* Copyright (©) 2001-2003 Mark Wedel & Crossfire Development Team
7			* Copyright (©) 1992 Frank Tore Johansen
8	root	1.175	*
9	root	1.139	* Deliantra is free software: you can redistribute it and/or modify it under
10			* the terms of the Affero GNU General Public License as published by the
11			* Free Software Foundation, either version 3 of the License, or (at your
12			* option) any later version.
13	root	1.175	*
14	root	1.112	* This program is distributed in the hope that it will be useful,
15			* but WITHOUT ANY WARRANTY; without even the implied warranty of
16			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17			* GNU General Public License for more details.
18	root	1.175	*
19	root	1.139	* You should have received a copy of the Affero GNU General Public License
20			* and the GNU General Public License along with this program. If not, see
21			* <http://www.gnu.org/licenses/>.
22	root	1.175	*
23	root	1.120	* The authors can be reached via e-mail to <support@deliantra.net>
24	root	1.84	*/
25	elmex	1.1
26			#include <global.h>
27			#include <object.h>
28			#include <tod.h>
29
30	root	1.47	#include <sproto.h>
31			#include <time.h>
32	elmex	1.1
33	root	1.126	#include <glib.h>
34
35	root	1.166	#include <rmg.h>
36			#include <rproto.h>
37	elmex	1.1	#include "path.h"
38
39	root	1.20	void
40	root	1.23	version (object *op)
41	root	1.20	{
42	root	1.121	new_draw_info_format (NDI_UNIQUE, 0, op, "This is Deliantra v%s", VERSION);
43	root	1.20	}
44
45	elmex	1.1	/* This is a basic little function to put the player back to his
46	root	1.157	* savebed.
47	elmex	1.1	*/
48	root	1.20	void
49	root	1.23	enter_player_savebed (object *op)
50	elmex	1.1	{
51	root	1.128	op->player_goto (op->contr->savebed_map, op->contr->bed_x, op->contr->bed_y);
52	elmex	1.1	}
53
54			/*
55	root	1.62	* enter_map(): Moves the player and pets from current map (if any) to
56	elmex	1.1	* new map. map, x, y must be set. map is the map we are moving the
57			* player to - it could be the map he just came from if the load failed for
58			* whatever reason. If default map coordinates are to be used, then
59			* the function that calls this should figure them out.
60			*/
61	root	1.157	bool
62	root	1.62	object::enter_map (maptile *newmap, int x, int y)
63	root	1.20	{
64	root	1.172	if (destroyed () \|\| !newmap \|\| !newmap->linkable ())
65	root	1.157	return false;
66	root	1.69
67	root	1.20	if (out_of_map (newmap, x, y))
68			{
69	root	1.62	LOG (llevError, "enter_map: supplied coordinates are not within the map! (%s: %d, %d)\n", &newmap->path, x, y);
70	root	1.58	x = newmap->enter_x;
71			y = newmap->enter_y;
72	root	1.20	if (out_of_map (newmap, x, y))
73			{
74			LOG (llevError, "enter_map: map %s provides invalid default enter location (%d, %d) > (%d, %d)\n",
75	root	1.62	&newmap->path, x, y, newmap->width, newmap->height);
76			new_draw_info (NDI_UNIQUE, 0, this, "The exit is closed");
77	root	1.157	return false;
78	root	1.20	}
79			}
80	root	1.31
81	root	1.78	if (contr && map != newmap && map)
82	root	1.65	if (INVOKE_MAP (LEAVE, map, ARG_PLAYER (contr)))
83	root	1.157	return false;
84	root	1.65
85	root	1.155	// remove, so stupid blocked does not trigger a failure
86	root	1.65	remove ();
87
88	root	1.20	/* try to find a spot for the player */
89	root	1.117	if (blocked (newmap, x, y))
90	root	1.20	{ /* First choice blocked */
91			/* We try to find a spot for the player, starting closest in.
92			* We could use find_first_free_spot, but that doesn't randomize it at all,
93			* So for example, if the north space is free, you would always end up there even
94			* if other spaces around are available.
95			* Note that for the second and third calls, we could start at a position other
96			* than one, but then we could end up on the other side of walls and so forth.
97			*/
98	root	1.62	int i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE1 + 1);
99	root	1.23
100	root	1.155	if (i < 0)
101	root	1.20	{
102	root	1.62	i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE2 + 1);
103	root	1.155	if (i < 0)
104	root	1.62	i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE);
105	root	1.20	}
106	root	1.31
107	root	1.155	if (i >= 0)
108	root	1.20	{
109	root	1.164	maptile *m = newmap;
110	root	1.178	sint16 nx = x + DIRX (i);
111			sint16 ny = y + DIRY (i);
112	root	1.163
113	root	1.164	if (xy_normalise (m, nx, ny))
114	root	1.163	{
115	root	1.164	newmap = m;
116	root	1.163	x = nx;
117			y = ny;
118			}
119	root	1.20	}
120			else
121	root	1.62	/* not much we can do in this case. */
122			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);
123			}
124	elmex	1.1
125	root	1.78	if (contr && map != newmap)
126	root	1.69	{
127			if (INVOKE_PLAYER (MAP_CHANGE, contr, ARG_MAP (newmap), ARG_INT (x), ARG_INT (y)))
128	root	1.157	return false;
129	root	1.31
130	root	1.69	if (INVOKE_MAP (ENTER, newmap, ARG_PLAYER (contr), ARG_INT (x), ARG_INT (y)))
131	root	1.157	return false;
132	root	1.69	}
133	root	1.20
134	root	1.156	enemy = 0;
135
136	root	1.172	newmap->activate (); // workaround for activate activating everyhing on the map, includign the palyer on the {link} map
137	root	1.160	//newmap->insert (this, x, y);
138			newmap->insert (this, x, y, 0, INS_NO_AUTO_EXIT);
139	root	1.171	prefetch_surrounding_maps ();
140	root	1.20
141	root	1.157	if (map == newmap) // see if we actually arrived there - insert might trigger a teleport
142	root	1.156	{
143			if (contr)
144			{
145			contr->maplevel = newmap->path;
146			contr->count = 0;
147
148			/* Update any golems */
149			if (object *golem = contr->golem)
150			{
151			int i = find_free_spot (golem, newmap, x, y, 1, SIZEOFFREE);
152
153			if (i < 0)
154			golem->drop_and_destroy ();
155			else
156			{
157	root	1.178	newmap->insert (golem, x + DIRX (i), y + DIRY (i));
158	root	1.156	golem->direction = find_dir_2 (golem->x - x, golem->y - y);
159			}
160			}
161			}
162	root	1.20
163	root	1.156	/* since the players map is already loaded, we don't need to worry
164			* about pending objects.
165			*/
166			move_all_pets ();
167	root	1.157
168			return true;
169	root	1.20	}
170	root	1.157
171			return false;
172	elmex	1.1	}
173
174			/* process_players1 and process_players2 do all the player related stuff.
175			* I moved it out of process events and process_map. This was to some
176			* extent for debugging as well as to get a better idea of the time used
177			* by the various functions. process_players1() does the processing before
178			* objects have been updated, process_players2() does the processing that
179			* is needed after the players have been updated.
180			*/
181	root	1.46	static void
182			process_players1 ()
183	elmex	1.1	{
184	root	1.20	/* Basically, we keep looping until all the players have done their actions. */
185	root	1.94	for (int flag = 1; flag != 0;)
186	root	1.20	{
187			flag = 0;
188	root	1.56	for_all_players (pl)
189	root	1.20	{
190	root	1.56	pl->refcnt_chk ();
191	elmex	1.1
192	root	1.109	if (expect_false (!pl->ob \|\| !pl->ns \|\| !pl->ob->active))
193	root	1.20	continue;
194
195	root	1.106	if (handle_newcs_player (pl->ob))
196			flag = 1;
197			}
198			}
199	root	1.46
200	root	1.55	for_all_players (pl)
201	root	1.20	{
202	root	1.102	object *ob = pl->ob;
203
204	root	1.144	// process_objects destroys the speed_left value
205			pl->speed_left_save = ob->speed_left;
206
207	root	1.109	if (expect_false (!ob \|\| !pl->ns \|\| !ob->active))
208	root	1.56	continue;
209
210	root	1.102	do_some_living (ob);
211	elmex	1.1	}
212			}
213
214	root	1.46	static void
215			process_players2 ()
216	elmex	1.1	{
217	root	1.20	/* Then check if any players should use weapon-speed instead of speed */
218	root	1.55	for_all_players (pl)
219	root	1.20	{
220	root	1.144	// restore speed_left value saved by process_players1
221			pl->ob->speed_left = pl->speed_left_save;
222
223	root	1.106	pl->weapon_sp_left = min (pl->weapon_sp, pl->weapon_sp_left + pl->weapon_sp);
224			pl->ob->speed_left = min (pl->ob->speed, pl->ob->speed_left + pl->ob->speed);
225	elmex	1.1	}
226			}
227
228	root	1.142	static void
229	root	1.46	process_events ()
230	root	1.20	{
231	root	1.46	process_players1 ();
232	elmex	1.1
233	root	1.81	for_all_actives (op)
234	root	1.20	{
235	root	1.144	// try to prefetch some stuff we expect to need
236			// obviously, it should be grouped into the same cacheline.
237			// preliminary results indicate that this gives halves the speed
238			// used for the inner loop
239			if (_i < actives.size ()) // HACK, rely on _i :/
240			{
241			object *next = actives [_i + 1];
242
243	root	1.179	ecb_prefetch (&next->flag , 0, 1);
244			ecb_prefetch (&next->speed , 0, 1);
245			ecb_prefetch (&next->anim_speed, 0, 1);
246			ecb_prefetch (&next->contr , 0, 1);
247	root	1.144	}
248
249	root	1.20	/* Now process op */
250	root	1.150	if (expect_false (op->flag [FLAG_FREED]))
251	root	1.20	{
252	root	1.162	LOG (llevError, "BUG: process_events(): Free object on list (%s)\n", op->debug_desc ());
253	root	1.59	op->set_speed (0);
254	root	1.20	continue;
255			}
256
257	root	1.109	if (expect_false (!op->has_active_speed ()))
258	root	1.20	{
259	elmex	1.66	LOG (llevError, "BUG: process_events(): Object %s has no speed (%f), "
260			"but is on active list\n", op->debug_desc (), op->speed);
261	root	1.59	op->set_speed (0);
262	root	1.20	continue;
263	root	1.14	}
264
265	root	1.109	if (expect_false (op->flag [FLAG_REMOVED]))
266	root	1.20	{
267	root	1.96	LOG (llevError, "BUG: process_events(): removed object is on active list: %s\n",
268			op->debug_desc ());
269	root	1.59	op->set_speed (0);
270	root	1.20	continue;
271	root	1.14	}
272
273	root	1.46	/* Animate the object. Bug or feature that anim_speed
274	root	1.20	* is based on ticks, and not the creatures speed?
275			*/
276			if (op->anim_speed && op->last_anim >= op->anim_speed)
277			{
278	root	1.102	animate_object (op, op->contr ? op->facing : op->direction);
279	root	1.20	op->last_anim = 1;
280			}
281			else
282	root	1.102	++op->last_anim;
283	elmex	1.1
284	root	1.127	if (expect_false (op->speed_left > 0.f))
285	root	1.20	{
286			--op->speed_left;
287			process_object (op);
288	root	1.14	}
289	root	1.28
290	root	1.144	// this will destroy the speed_left value for players, but
291			// process_players1 and ..2 save/restore the real value,
292			// so we can avoid a costly test here.
293	root	1.145	op->speed_left = min (op->speed, op->speed_left + op->speed);
294	elmex	1.1	}
295
296	root	1.46	process_players2 ();
297	elmex	1.1	}
298
299	root	1.62	/* clean up everything before exiting */
300	root	1.20	void
301	root	1.62	emergency_save ()
302	root	1.20	{
303	root	1.161	LOG (llevInfo, "emergency_save: enter\n");
304
305			LOG (llevInfo, "emergency_save: saving book archive\n");
306			write_book_archive ();
307	elmex	1.1
308	root	1.83	cfperl_emergency_save ();
309	root	1.62
310	root	1.161	LOG (llevInfo, "emergency_save: leave\n");
311	elmex	1.1	}
312
313	root	1.79	// send all clients some informational text
314			static void
315			cleanup_inform (const char *cause, bool make_core)
316			{
317	root	1.114	int flags = NDI_REPLY \| NDI_UNIQUE \| NDI_ALL \| (make_core ? NDI_RED : NDI_GREEN);
318	root	1.83
319	root	1.111	new_draw_info_format (flags, 0, 0, "The server will now shutdown.");
320			new_draw_info_format (flags, 0, 0, "Cause for this shutdown: %s", cause);
321	root	1.79
322			if (make_core)
323	root	1.111	new_draw_info_format (flags, 0, 0, "This is considered a crash, but all maps and players have been saved.");
324	root	1.79	else
325	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.");
326	root	1.79
327	root	1.111	new_draw_info_format (flags, 0, 0, "%s", CLEANUP_MESSAGE);
328	root	1.79
329	root	1.113	client::flush_sockets ();
330	root	1.79	}
331
332	elmex	1.1	/* clean up everything before exiting */
333	root	1.20	void
334	root	1.79	cleanup (const char *cause, bool make_core)
335	elmex	1.1	{
336	root	1.84	if (make_core)
337	root	1.85	fork_abort (cause);
338	root	1.84
339	root	1.161	LOG (make_core ? llevError : llevInfo, "cleanup cause: %s\n", cause);
340	root	1.79
341			if (!make_core)
342			cleanup_inform (cause, make_core);
343
344	root	1.62	LOG (llevDebug, "cleanup begin.\n");
345
346	root	1.65	if (init_done && !in_cleanup)
347	root	1.67	{
348			in_cleanup = true;
349			emergency_save ();
350			}
351			else
352			in_cleanup = true;
353	root	1.29
354	root	1.62	LOG (llevDebug, "running cleanup handlers.\n");
355			INVOKE_GLOBAL (CLEANUP);
356	root	1.23
357	root	1.62	LOG (llevDebug, "cleanup done.\n");
358	root	1.25
359	root	1.123	log_cleanup ();
360
361	root	1.49	if (make_core)
362	root	1.130	cleanup_inform (cause, make_core);
363	root	1.49	else
364	root	1.88	{
365	root	1.115	new_draw_info_format (NDI_REPLY \| NDI_UNIQUE \| NDI_ALL \| NDI_GREEN, 0, 0, "Maps and players successfully saved, exiting.");
366			new_draw_info_format (NDI_REPLY \| NDI_UNIQUE \| NDI_ALL \| NDI_GREEN, 0, 0, "And again: " CLEANUP_MESSAGE);
367	root	1.113	client::flush_sockets ();
368	root	1.88	}
369	root	1.130
370			cfperl_cleanup (make_core);
371			_exit (make_core);
372	elmex	1.1	}
373
374			/*
375	root	1.73	* do_specials() is a collection of functions to call from time to time.
376	root	1.173	* Modified 2000-1-14 MSW to use the global server_tick count to determine how
377	elmex	1.1	* often to do things. This will allow us to spred them out more often.
378			* I use prime numbers for the factor count - in that way, it is less likely
379			* these actions will fall on the same tick (compared to say using 500/2500/15000
380			* which would mean on that 15,000 tick count a whole bunch of stuff gets
381			* done). Of course, there can still be times where multiple specials are
382			* done on the same tick, but that will happen very infrequently
383			*
384			* I also think this code makes it easier to see how often we really are
385			* doing the various things.
386			*/
387	root	1.141	static void
388	root	1.146	do_specials ()
389	root	1.20	{
390	root	1.122	shstr::gc ();
391	root	1.125	archetype::gc ();
392	root	1.122
393	root	1.173	if (expect_false (!(server_tick % TICKS_PER_HOUR)))
394	root	1.134	maptile::adjust_daylight ();
395	elmex	1.1
396	root	1.173	if (expect_false (!(server_tick % 2503)))
397	root	1.20	fix_weight (); /* Hack to fix weightproblems caused by bugs */
398	elmex	1.1
399	root	1.173	if (expect_false (!(server_tick % 5003)))
400	root	1.20	write_book_archive ();
401	elmex	1.1
402	root	1.173	if (expect_false (!(server_tick % 5009)))
403	root	1.20	clean_friendly_list ();
404	elmex	1.1
405	root	1.173	if (expect_false (!(server_tick % 5011)))
406	root	1.20	obsolete_parties ();
407	elmex	1.1
408	root	1.173	if (expect_false (!(server_tick % 12503)))
409	root	1.20	fix_luck ();
410	elmex	1.1	}
411
412	root	1.20	void
413	root	1.173	one_tick ()
414	root	1.2	{
415	root	1.44	// first do the user visible stuff
416	root	1.12	INVOKE_GLOBAL (CLOCK);
417	root	1.113	process_events (); // "do" something with objects with speed
418			client::clock (); // draw client maps etc.
419	root	1.44
420			// then do some bookkeeping, should not really be here
421	root	1.20	do_specials (); /* Routines called from time to time. */
422	root	1.56	attachable::check_mortals ();
423	root	1.5
424	root	1.173	// now that we aggressively reuse id's, this is very unlikely to happen...
425	root	1.151	if (object::object_count >= RESTART_COUNT)
426			cleanup ("running out of protocol ID values - need full restart");
427	root	1.2	}
428
429	root	1.87	// normal main
430	root	1.20	int
431			main (int argc, char **argv)
432	elmex	1.1	{
433	root	1.6	settings.argc = argc;
434			settings.argv = argv;
435	root	1.165
436	root	1.167	rndm.seed (time (0));
437
438	root	1.170	// temporary(?) testing hack
439			if (argc >= 2 && !strcmp (argv [1], "--noise"))
440			{
441			void noise_test ();
442			noise_test ();
443			exit (0);
444			}
445	root	1.168
446			#if 0
447	root	1.165	// code sometiems used for timing benchmarks
448			random_number_generator<freeciv_random_generator> rng;
449			rng.seed(0);
450			for (int i = 0; i < 10; ++i)
451			printf ("%08x\n", rng.get_u32());
452			for (int i = 0; i < 1000000; ++i)
453			volatile int r = rng.get_u32 ();
454			cstamp s = stamp ();
455			for (int i = 0; i < 1000000; ++i)
456			volatile int r = rng.next ();
457			printf ("c %d\n", (int)measure (s));
458			exit (0);
459			#endif
460	root	1.137
461	root	1.6	init (argc, argv);
462
463			for (;;)
464			cfperl_main ();
465	root	1.64	}
466	root	1.116