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

/* 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->drop_and_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 (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.
 */
static void
do_specials (void)
{
  shstr::gc ();
  archetype::gc ();

  if (expect_false (!(pticks % TICKS_PER_HOUR)))
    maptile::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;
}

// normal main
int
main (int argc, char **argv)
{
  settings.argc = argc;
  settings.argv = argv;
  
  rndm.seed (time (0));
  g_thread_init (0); // for the slice allocator only

  init (argc, argv);

  for (;;)
    cfperl_main ();
}

Revision:	1.141
Committed:	Fri Nov 6 12:49:19 2009 UTC (14 years, 6 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.140:	+1 -1 lines
Log Message:	make effectively static symbols actually static, part 1
#	Content
1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001-2003,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*
8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* the terms of the Affero GNU General Public License as published by the
10	* Free Software Foundation, either version 3 of the License, or (at your
11	* 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 Affero GNU General Public License
19	* and the GNU General Public License along with this program. If not, see
20	* <http://www.gnu.org/licenses/>.
21	*
22	* The authors can be reached via e-mail to <support@deliantra.net>
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 <glib.h>
33
34	#include <../random_maps/random_map.h>
35	#include <../random_maps/rproto.h>
36	#include "path.h"
37
38	static char days[7][4] = {
39	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
40	};
41
42	void
43	version (object *op)
44	{
45	new_draw_info_format (NDI_UNIQUE, 0, op, "This is Deliantra v%s", VERSION);
46	}
47
48	/* This is a basic little function to put the player back to his
49	* savebed. We do some error checking - its possible that the
50	* savebed map may no longer exist, so we make sure the player
51	* goes someplace.
52	*/
53	void
54	enter_player_savebed (object *op)
55	{
56	op->player_goto (op->contr->savebed_map, op->contr->bed_x, op->contr->bed_y);
57	}
58
59	/*
60	* enter_map(): Moves the player and pets from current map (if any) to
61	* new map. map, x, y must be set. map is the map we are moving the
62	* player to - it could be the map he just came from if the load failed for
63	* whatever reason. If default map coordinates are to be used, then
64	* the function that calls this should figure them out.
65	*/
66	void
67	object::enter_map (maptile *newmap, int x, int y)
68	{
69	if (destroyed () \|\| !newmap \|\| newmap->in_memory != MAP_ACTIVE)
70	return;
71
72	if (out_of_map (newmap, x, y))
73	{
74	LOG (llevError, "enter_map: supplied coordinates are not within the map! (%s: %d, %d)\n", &newmap->path, x, y);
75	x = newmap->enter_x;
76	y = newmap->enter_y;
77	if (out_of_map (newmap, x, y))
78	{
79	LOG (llevError, "enter_map: map %s provides invalid default enter location (%d, %d) > (%d, %d)\n",
80	&newmap->path, x, y, newmap->width, newmap->height);
81	new_draw_info (NDI_UNIQUE, 0, this, "The exit is closed");
82	return;
83	}
84	}
85
86	if (contr && map != newmap && map)
87	if (INVOKE_MAP (LEAVE, map, ARG_PLAYER (contr)))
88	return;
89
90	// remove, so stupid ob_locked does not trigger a failure
91	remove ();
92
93	/* try to find a spot for the player */
94	if (blocked (newmap, x, y))
95	{ /* First choice blocked */
96	/* We try to find a spot for the player, starting closest in.
97	* We could use find_first_free_spot, but that doesn't randomize it at all,
98	* So for example, if the north space is free, you would always end up there even
99	* if other spaces around are available.
100	* Note that for the second and third calls, we could start at a position other
101	* than one, but then we could end up on the other side of walls and so forth.
102	*/
103	int i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE1 + 1);
104
105	if (i == -1)
106	{
107	i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE2 + 1);
108	if (i == -1)
109	i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE);
110	}
111
112	if (i != -1)
113	{
114	x += freearr_x[i];
115	y += freearr_y[i];
116	}
117	else
118	/* not much we can do in this case. */
119	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);
120	}
121
122	if (contr && map != newmap)
123	{
124	if (INVOKE_PLAYER (MAP_CHANGE, contr, ARG_MAP (newmap), ARG_INT (x), ARG_INT (y)))
125	return;
126
127	if (INVOKE_MAP (ENTER, newmap, ARG_PLAYER (contr), ARG_INT (x), ARG_INT (y)))
128	return;
129	}
130
131	this->x = x;
132	this->y = y;
133	map = newmap;
134
135	insert_ob_in_map (this, map, 0, INS_NO_WALK_ON);
136
137	enemy = 0;
138
139	if (contr)
140	{
141	contr->maplevel = newmap->path;
142	contr->count = 0;
143	}
144
145	/* Update any golems */
146	if (type == PLAYER)
147	if (object *golem = contr->golem)
148	{
149	int i = find_free_spot (golem, newmap, x, y, 1, SIZEOFFREE);
150
151	if (i < 0)
152	golem->drop_and_destroy ();
153	else
154	{
155	newmap->insert (golem, x + freearr_x[i], y + freearr_y[i]);
156	golem->direction = find_dir_2 (x - golem->x, y - golem->y);
157	}
158	}
159
160	/* since the players map is already loaded, we don't need to worry
161	* about pending objects.
162	*/
163	remove_all_pets (newmap);
164	}
165
166	/* process_players1 and process_players2 do all the player related stuff.
167	* I moved it out of process events and process_map. This was to some
168	* extent for debugging as well as to get a better idea of the time used
169	* by the various functions. process_players1() does the processing before
170	* objects have been updated, process_players2() does the processing that
171	* is needed after the players have been updated.
172	*/
173	static void
174	process_players1 ()
175	{
176	/* Basically, we keep looping until all the players have done their actions. */
177	for (int flag = 1; flag != 0;)
178	{
179	flag = 0;
180	for_all_players (pl)
181	{
182	pl->refcnt_chk ();
183
184	if (expect_false (!pl->ob \|\| !pl->ns \|\| !pl->ob->active))
185	continue;
186
187	if (handle_newcs_player (pl->ob))
188	flag = 1;
189	}
190	}
191
192	for_all_players (pl)
193	{
194	object *ob = pl->ob;
195
196	if (expect_false (!ob \|\| !pl->ns \|\| !ob->active))
197	continue;
198
199	do_some_living (ob);
200	}
201	}
202
203	static void
204	process_players2 ()
205	{
206	/* Then check if any players should use weapon-speed instead of speed */
207	for_all_players (pl)
208	{
209	pl->weapon_sp_left = min (pl->weapon_sp, pl->weapon_sp_left + pl->weapon_sp);
210	pl->ob->speed_left = min (pl->ob->speed, pl->ob->speed_left + pl->ob->speed);
211	}
212	}
213
214	void
215	process_events ()
216	{
217	process_players1 ();
218
219	for_all_actives (op)
220	{
221	/* Now process op */
222	if (expect_false (QUERY_FLAG (op, FLAG_FREED)))
223	{
224	LOG (llevError, "BUG: process_events(): Free object on list\n");
225	op->set_speed (0);
226	continue;
227	}
228
229	if (expect_false (!op->has_active_speed ()))
230	{
231	LOG (llevError, "BUG: process_events(): Object %s has no speed (%f), "
232	"but is on active list\n", op->debug_desc (), op->speed);
233	op->set_speed (0);
234	continue;
235	}
236
237	if (expect_false (op->flag [FLAG_REMOVED]))
238	{
239	LOG (llevError, "BUG: process_events(): removed object is on active list: %s\n",
240	op->debug_desc ());
241	op->set_speed (0);
242	continue;
243	}
244
245	/* Animate the object. Bug or feature that anim_speed
246	* is based on ticks, and not the creatures speed?
247	*/
248	if (op->anim_speed && op->last_anim >= op->anim_speed)
249	{
250	animate_object (op, op->contr ? op->facing : op->direction);
251	op->last_anim = 1;
252	}
253	else
254	++op->last_anim;
255
256	if (expect_false (op->speed_left > 0.f))
257	{
258	--op->speed_left;
259	process_object (op);
260	}
261
262	if (expect_true (!op->contr))
263	op->speed_left = min (abs (op->speed), op->speed_left + abs (op->speed));
264	}
265
266	process_players2 ();
267	}
268
269	/* clean up everything before exiting */
270	void
271	emergency_save ()
272	{
273	LOG (llevDebug, "emergency save begin.\n");
274
275	cfperl_emergency_save ();
276
277	LOG (llevDebug, "saving book archive.\n");
278	write_book_archive ();
279
280	LOG (llevDebug, "emergency save done.\n");
281	}
282
283	// send all clients some informational text
284	static void
285	cleanup_inform (const char *cause, bool make_core)
286	{
287	int flags = NDI_REPLY \| NDI_UNIQUE \| NDI_ALL \| (make_core ? NDI_RED : NDI_GREEN);
288
289	new_draw_info_format (flags, 0, 0, "The server will now shutdown.");
290	new_draw_info_format (flags, 0, 0, "Cause for this shutdown: %s", cause);
291
292	if (make_core)
293	new_draw_info_format (flags, 0, 0, "This is considered a crash, but all maps and players have been saved.");
294	else
295	new_draw_info_format (flags, 0, 0, "This is considered to be a clean shutdown, and all maps and players will be saved now.");
296
297	new_draw_info_format (flags, 0, 0, "%s", CLEANUP_MESSAGE);
298
299	client::flush_sockets ();
300	}
301
302	/* clean up everything before exiting */
303	void
304	cleanup (const char *cause, bool make_core)
305	{
306	if (make_core)
307	fork_abort (cause);
308
309	LOG (llevError, "cleanup cause: %s\n", cause);
310
311	if (!make_core)
312	cleanup_inform (cause, make_core);
313
314	LOG (llevDebug, "cleanup begin.\n");
315
316	if (init_done && !in_cleanup)
317	{
318	in_cleanup = true;
319	emergency_save ();
320	}
321	else
322	in_cleanup = true;
323
324	LOG (llevDebug, "running cleanup handlers.\n");
325	INVOKE_GLOBAL (CLEANUP);
326
327	LOG (llevDebug, "cleanup done.\n");
328
329	log_cleanup ();
330
331	if (make_core)
332	cleanup_inform (cause, make_core);
333	else
334	{
335	new_draw_info_format (NDI_REPLY \| NDI_UNIQUE \| NDI_ALL \| NDI_GREEN, 0, 0, "Maps and players successfully saved, exiting.");
336	new_draw_info_format (NDI_REPLY \| NDI_UNIQUE \| NDI_ALL \| NDI_GREEN, 0, 0, "And again: " CLEANUP_MESSAGE);
337	client::flush_sockets ();
338	}
339
340	cfperl_cleanup (make_core);
341	_exit (make_core);
342	}
343
344	/*
345	* do_specials() is a collection of functions to call from time to time.
346	* Modified 2000-1-14 MSW to use the global pticks count to determine how
347	* often to do things. This will allow us to spred them out more often.
348	* I use prime numbers for the factor count - in that way, it is less likely
349	* these actions will fall on the same tick (compared to say using 500/2500/15000
350	* which would mean on that 15,000 tick count a whole bunch of stuff gets
351	* done). Of course, there can still be times where multiple specials are
352	* done on the same tick, but that will happen very infrequently
353	*
354	* I also think this code makes it easier to see how often we really are
355	* doing the various things.
356	*/
357	static void
358	do_specials (void)
359	{
360	shstr::gc ();
361	archetype::gc ();
362
363	if (expect_false (!(pticks % TICKS_PER_HOUR)))
364	maptile::adjust_daylight ();
365
366	if (expect_false (!(pticks % 2503)))
367	fix_weight (); /* Hack to fix weightproblems caused by bugs */
368
369	if (expect_false (!(pticks % 5003)))
370	write_book_archive ();
371
372	if (expect_false (!(pticks % 5009)))
373	clean_friendly_list ();
374
375	if (expect_false (!(pticks % 5011)))
376	obsolete_parties ();
377
378	if (expect_false (!(pticks % 12503)))
379	fix_luck ();
380	}
381
382	void
383	server_tick ()
384	{
385	// first do the user visible stuff
386	INVOKE_GLOBAL (CLOCK);
387	process_events (); // "do" something with objects with speed
388	client::clock (); // draw client maps etc.
389
390	// then do some bookkeeping, should not really be here
391	do_specials (); /* Routines called from time to time. */
392	attachable::check_mortals ();
393
394	++pticks;
395	}
396
397	// normal main
398	int
399	main (int argc, char **argv)
400	{
401	settings.argc = argc;
402	settings.argv = argv;
403
404	rndm.seed (time (0));
405	g_thread_init (0); // for the slice allocator only
406
407	init (argc, argv);
408
409	for (;;)
410	cfperl_main ();
411	}
412