[ViewVC] Diff of: cvs/deliantra/server/server/time.C

Comparing deliantra/server/server/time.C (file contents):
Revision 1.51 by root, Fri May 18 20:45:37 2007 UTC vs.
Revision 1.87 by elmex, Tue Jan 13 12:14:56 2009 UTC

…		…
1	/*	1	/*
2	* CrossFire, A Multiplayer game	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team	4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your option) any later version.	11	* (at your option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*	20	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	22	*/
24		23
25	/*	24	/*
26	* Routines that is executed from objects based on their speed have been	25	* Routines that is executed from objects based on their speed have been
27	* collected in this file.	26	* collected in this file.
35	* so those will be removed shortly (in a cascade like fashion.)	34	* so those will be removed shortly (in a cascade like fashion.)
36	*/	35	*/
37	void	36	void
38	remove_door (object *op)	37	remove_door (object *op)
39	{	38	{
		39	for (int i = 1; i < SIZEOFFREE1 + 1; i += 2)
		40	{
		41	object *tmp;
		42	mapxy pos (op);
		43	pos.move (i);
		44	if (pos.normalise ()
		45	&& (tmp = present (DOOR, pos.m, pos.x, pos.y)))
		46	{
		47	tmp->set_speed (0.1f);
		48	tmp->speed_left = -0.2f;
		49	}
		50	}
		51
		52	if (op->other_arch)
		53	{
		54	object *tmp = arch_to_object (op->other_arch);
		55	tmp->x = op->x;
		56	tmp->y = op->y;
		57	tmp->map = op->map;
		58	tmp->level = op->level;
		59	insert_ob_in_map (tmp, op->map, op, 0);
		60	}
		61
		62	op->drop_and_destroy ();
		63	}
		64
		65	void
		66	remove_door2 (object *op)
		67	{
40	int i;	68	int i;
41	object *tmp;	69	object *tmp;
42		70
43	for (i = 1; i < 9; i += 2)	71	for (i = 1; i < 9; i += 2)
		72	{
44	if ((tmp = present (DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i])) != NULL)	73	tmp = present (LOCKED_DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i]);
45	{	74	if (tmp && tmp->slaying == op->slaying)
		75	{ /* same key both doors */
46	tmp->set_speed (0.1f);	76	tmp->set_speed (0.1f);
47	tmp->speed_left = -0.2f;	77	tmp->speed_left = -0.2f;
48	}	78	}
		79	}
49		80
50	if (op->other_arch)	81	if (op->other_arch)
51	{	82	{
52	tmp = arch_to_object (op->other_arch);	83	tmp = arch_to_object (op->other_arch);
53	tmp->x = op->x;	84	tmp->x = op->x;
…		…
55	tmp->map = op->map;	86	tmp->map = op->map;
56	tmp->level = op->level;	87	tmp->level = op->level;
57	insert_ob_in_map (tmp, op->map, op, 0);	88	insert_ob_in_map (tmp, op->map, op, 0);
58	}	89	}
59		90
60	op->destroy ();	91	op->drop_and_destroy ();
61	}
62
63	void
64	remove_door2 (object *op)
65	{
66	int i;
67	object *tmp;
68
69	for (i = 1; i < 9; i += 2)
70	{
71	tmp = present (LOCKED_DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i]);
72	if (tmp && tmp->slaying == op->slaying)
73	{ /* same key both doors */
74	tmp->set_speed (0.1f);
75	tmp->speed_left = -0.2f;
76	}
77	}
78
79	if (op->other_arch)
80	{
81	tmp = arch_to_object (op->other_arch);
82	tmp->x = op->x;
83	tmp->y = op->y;
84	tmp->map = op->map;
85	tmp->level = op->level;
86	insert_ob_in_map (tmp, op->map, op, 0);
87	}
88
89	op->destroy ();
90	}	92	}
91		93
92	void	94	void
93	generate_monster (object *gen)	95	generate_monster (object *gen)
94	{	96	{
…		…
96	return;	98	return;
97		99
98	if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1))	100	if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1))
99	return;	101	return;
100		102
		103	// sleeping generators won't generate, this will make monsters like
		104	// centipedes not generate more centipedes when being asleep.
		105	if (gen->flag [FLAG_SLEEP])
		106	return;
		107
101	object *op;	108	object *op;
		109	int dir;
102		110
103	if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN))	111	if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN))
104	{	112	{
105	// either copy one item form the inventory...	113	// either copy one item from the inventory...
106	if (!gen->inv)	114	if (!gen->inv)
107	return;	115	return;
108		116
109	// first select one item from the inventory	117	// first select one item from the inventory
110	int index = 0;	118	int index = 0;
111	for (object *tmp = gen->inv; tmp; tmp = tmp->below)	119	for (object *tmp = gen->inv; tmp; tmp = tmp->below)
112	if (!rndm (++index))	120	if (!rndm (++index))
113	op = tmp;	121	op = tmp;
114		122
115	op = object_create_clone (op);	123	dir = find_free_spot (op, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1);
		124	if (dir < 0)
		125	return;
		126
		127	op = op->deep_clone ();
116		128
117	CLEAR_FLAG (op, FLAG_IS_A_TEMPLATE);	129	CLEAR_FLAG (op, FLAG_IS_A_TEMPLATE);
118	unflag_inv (op, FLAG_IS_A_TEMPLATE);	130	unflag_inv (op, FLAG_IS_A_TEMPLATE);
119	}	131	}
		132	else if (gen->other_arch)
		133	{
		134	// ...or use other_arch
		135	dir = find_free_spot (gen->other_arch, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1);
		136	if (dir < 0)
		137	return;
		138
		139	op = arch_to_object (gen->other_arch);
		140	}
120	else	141	else
121	{
122	// ...or use other_arch
123	if (archetype *at = gen->other_arch)
124	op = arch_to_object (at);
125	else
126	return;	142	return;
127	}
128		143
129	op->expand_tail ();	144	op->expand_tail ();
130		145
131	int i = find_free_spot (op, gen->map, gen->x, gen->y, 1, 9);	146	mapxy pos (gen); pos.move (dir);
132	if (i >= 0)	147
		148	if (pos.insert (op, gen))
133	{	149	{
134	if (insert_ob_in_map_at (op, gen->map, gen, 0, gen->x + freearr_x[i], gen->y + freearr_y[i]))
135	{
136	if (rndm (0, 9))	150	if (rndm (0, 9))
137	generate_artifact (op, gen->map->difficulty);	151	generate_artifact (op, gen->map->difficulty);
138		152
139	if (op->has_random_items ())	153	if (op->has_random_items ())
140	create_treasure (op->randomitems, op, GT_APPLY, gen->map->difficulty);	154	create_treasure (op->randomitems, op, GT_APPLY, gen->map->difficulty);
141		155
142	return;	156	return;
143	}
144	}	157	}
145		158
146	op->destroy ();	159	op->destroy ();
147	}	160	}
148		161
…		…
235	if (op->value)	248	if (op->value)
236	{	249	{
237	if (--op->stats.wc <= 0)	250	if (--op->stats.wc <= 0)
238	{ /* Reached bottom, let's stop */	251	{ /* Reached bottom, let's stop */
239	op->stats.wc = 0;	252	op->stats.wc = 0;
240	if (op->arch->clone.speed)	253	if (op->arch->speed)
241	op->value = 0;	254	op->value = 0;
242	else	255	else
243	op->set_speed (0);	256	op->set_speed (0);
244	}	257	}
245		258
…		…
265	* objects are above the gate. If so, we finish closing the gate,	278	* objects are above the gate. If so, we finish closing the gate,
266	* otherwise, we fall through to the code below which should lower	279	* otherwise, we fall through to the code below which should lower
267	* the gate slightly.	280	* the gate slightly.
268	*/	281	*/
269		282
270	for (tmp = op->above; tmp != NULL; tmp = tmp->above)	283	for (tmp = op->above; tmp; tmp = tmp->above)
271	if (!QUERY_FLAG (tmp, FLAG_NO_PICK) \|\| QUERY_FLAG (tmp, FLAG_CAN_ROLL) \|\| QUERY_FLAG (tmp, FLAG_ALIVE))	284	if (!QUERY_FLAG (tmp, FLAG_NO_PICK) \|\| QUERY_FLAG (tmp, FLAG_CAN_ROLL) \|\| QUERY_FLAG (tmp, FLAG_ALIVE))
272	break;	285	break;
273		286
274	if (tmp == NULL)	287	if (!tmp)
275	{	288	{
276	if (op->arch->clone.speed)	289	if (op->arch->speed)
277	op->value = 1;	290	op->value = 1;
278	else	291	else
279	op->set_speed (0);	292	op->set_speed (0);
280		293
281	return;	294	return;
…		…
292	}	305	}
293	else	306	else
294	{ /* The gate is still going up */	307	{ /* The gate is still going up */
295	op->stats.wc++;	308	op->stats.wc++;
296		309
297	if ((int) op->stats.wc >= (NUM_ANIMATIONS (op)))	310	if (op->stats.wc >= NUM_ANIMATIONS (op))
298	op->stats.wc = (signed char) NUM_ANIMATIONS (op) - 1;	311	op->stats.wc = NUM_ANIMATIONS (op) - 1;
299		312
300	/* If there is something on top of the gate, we try to roll it off.	313	/* If there is something on top of the gate, we try to roll it off.
301	* If a player/monster, we don't roll, we just hit them with damage	314	* If a player/monster, we don't roll, we just hit them with damage
302	*/	315	*/
303	if ((int) op->stats.wc >= NUM_ANIMATIONS (op) / 2)	316	if (op->stats.wc >= NUM_ANIMATIONS (op) / 2)
304	{	317	{
305	/* Halfway or further, check blocks */	318	/* Halfway or further, check blocks */
306	/* First, get the top object on the square. */	319	/* First, get the top object on the square. */
307	for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)	320	for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)
308	;	321	;
…		…
310	if (tmp)	323	if (tmp)
311	{	324	{
312	if (QUERY_FLAG (tmp, FLAG_ALIVE))	325	if (QUERY_FLAG (tmp, FLAG_ALIVE))
313	{	326	{
314	hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1);	327	hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1);
		328	op->play_sound (sound_find ("blocked_gate"));
315		329
316	if (tmp->type == PLAYER)	330	if (tmp->type == PLAYER)
317	new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are crushed by the %s!", &op->name);	331	new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are crushed by the %s!", &op->name);
318	}	332	}
319	else
320	/* If the object is not alive, and the object either can	333	/* If the object is not alive, and the object either can
321	* be picked up or the object rolls, move the object	334	* be picked up or the object rolls, move the object
322	* off the gate.	335	* off the gate.
323	*/	336	*/
324	if (!QUERY_FLAG (tmp, FLAG_ALIVE) && (!QUERY_FLAG (tmp, FLAG_NO_PICK) \|\| QUERY_FLAG (tmp, FLAG_CAN_ROLL)))	337	else if (!QUERY_FLAG (tmp, FLAG_ALIVE) && (!QUERY_FLAG (tmp, FLAG_NO_PICK) \|\| QUERY_FLAG (tmp, FLAG_CAN_ROLL)))
325	{	338	{
326	/* If it has speed, it should move itself, otherwise: */	339	/* If it has speed, it should move itself, otherwise: */
327	int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9);	340	int i = find_free_spot (tmp, op->map, op->x, op->y, 1, SIZEOFFREE1 + 1);
328		341
329	/* If there is a free spot, move the object someplace */	342	/* If there is a free spot, move the object someplace */
330	if (i != -1)	343	if (i > 0)
331	{	344	{
		345	mapxy pos (tmp);
		346	pos.move (i);
		347	if (pos.normalise ())
332	tmp->remove ();	348	tmp->move_to (pos);
333	tmp->x += freearr_x[i], tmp->y += freearr_y[i];
334	insert_ob_in_map (tmp, op->map, op, 0);
335	}	349	}
336	}	350	}
337	}	351	}
338		352
339	/* See if there is still anything blocking the gate */	353	/* See if there is still anything blocking the gate */
340	for (tmp = op->above; tmp != NULL; tmp = tmp->above)	354	for (tmp = op->above; tmp; tmp = tmp->above)
341	if (!QUERY_FLAG (tmp, FLAG_NO_PICK) \|\| QUERY_FLAG (tmp, FLAG_CAN_ROLL) \|\| QUERY_FLAG (tmp, FLAG_ALIVE))	355	if (!QUERY_FLAG (tmp, FLAG_NO_PICK) \|\| QUERY_FLAG (tmp, FLAG_CAN_ROLL) \|\| QUERY_FLAG (tmp, FLAG_ALIVE))
342	break;	356	break;
343		357
344	/* IF there is, start putting the gate down */	358	/* IF there is, start putting the gate down */
345	if (tmp)	359	if (tmp)
346	{
347	op->stats.food = 1;	360	op->stats.food = 1;
348	}
349	else	361	else
350	{	362	{
351	op->move_block = MOVE_ALL;	363	op->move_block = MOVE_ALL;
		364
352	if (!op->arch->clone.stats.ac)	365	if (!op->arch->stats.ac)
353	SET_FLAG (op, FLAG_BLOCKSVIEW);	366	SET_FLAG (op, FLAG_BLOCKSVIEW);
354	update_all_los (op->map, op->x, op->y);	367	update_all_los (op->map, op->x, op->y);
355	}	368	}
356	} /* gate is halfway up */	369	} /* gate is halfway up */
357		370
…		…
370	int v = op->value;	383	int v = op->value;
371		384
372	if (op->stats.sp)	385	if (op->stats.sp)
373	{	386	{
374	move_gate (op);	387	move_gate (op);
		388
375	if (op->value != v) /* change direction ? */	389	if (op->value != v) /* change direction ? */
376	op->stats.sp = 0;	390	op->stats.sp = 0;
377	return;	391	return;
378	}	392	}
		393
379	if (--op->stats.hp <= 0)	394	if (--op->stats.hp <= 0)
380	{ /* keep gate down */	395	{ /* keep gate down */
381	move_gate (op);	396	move_gate (op);
		397
382	if (op->value != v)	398	if (op->value != v)
383	op->set_speed (0);	399	op->set_speed (0);
384	}	400	}
385	}	401	}
386		402
…		…
398	int last = op->value;	414	int last = op->value;
399	int detected;	415	int detected;
400		416
401	detected = 0;	417	detected = 0;
402		418
403	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL && !detected; tmp = tmp->above)	419	for (tmp = op->ms ().bot; tmp && !detected; tmp = tmp->above)
404	{	420	{
405	object *tmp2;	421	object *tmp2;
406		422
407	if (op->stats.hp)	423	if (op->stats.hp)
408	{	424	{
…		…
426	if (op->stats.sp == 1)	442	if (op->stats.sp == 1)
427	{	443	{
428	if (detected && last == 0)	444	if (detected && last == 0)
429	{	445	{
430	op->value = 1;	446	op->value = 1;
431	push_button (op);	447	push_button (op, tmp);
432	}	448	}
		449
433	if (!detected && last == 1)	450	if (!detected && last == 1)
434	{	451	{
435	op->value = 0;	452	op->value = 0;
436	push_button (op);	453	push_button (op, tmp);
437	}	454	}
438	}	455	}
439	else	456	else
440	{ /* in this case, we unset buttons */	457	{ /* in this case, we unset buttons */
441	if (detected && last == 1)	458	if (detected && last == 1)
442	{	459	{
443	op->value = 0;	460	op->value = 0;
444	push_button (op);	461	push_button (op, tmp);
445	}	462	}
		463
446	if (!detected && last == 0)	464	if (!detected && last == 0)
447	{	465	{
448	op->value = 1;	466	op->value = 1;
449	push_button (op);	467	push_button (op, tmp);
450	}	468	}
451	}	469	}
452	}	470	}
453
454		471
455	void	472	void
456	animate_trigger (object *op)	473	animate_trigger (object *op)
457	{	474	{
458	if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op))	475	if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op))
…		…
468	}	485	}
469		486
470	void	487	void
471	move_hole (object *op)	488	move_hole (object *op)
472	{ /* 1 = opening, 0 = closing */	489	{ /* 1 = opening, 0 = closing */
473	object next, tmp;
474
475	if (op->value)	490	if (op->value)
476	{ /* We're opening */	491	{ /* We're opening */
477	if (--op->stats.wc <= 0)	492	if (--op->stats.wc <= 0)
478	{ /* Opened, let's stop */	493	{ /* Opened, let's stop */
479	op->stats.wc = 0;	494	op->stats.wc = 0;
480	op->set_speed (0);	495	op->set_speed (0);
481		496
482	/* Hard coding this makes sense for holes I suppose */	497	/* Hard coding this makes sense for holes I suppose */
483	op->move_on = MOVE_WALK;	498	op->move_on = MOVE_WALK;
484	for (tmp = op->above; tmp != NULL; tmp = next)	499	for (object next, tmp = op->above; tmp; tmp = next)
485	{	500	{
486	next = tmp->above;	501	next = tmp->above;
487	move_apply (op, tmp, tmp);	502	move_apply (op, tmp, tmp);
488	}	503	}
489	}	504	}
490		505
491	SET_ANIMATION (op, op->stats.wc);	506	SET_ANIMATION (op, op->stats.wc);
492	update_object (op, UP_OBJ_FACE);	507	update_object (op, UP_OBJ_FACE);
493	return;	508	return;
494	}	509	}
		510
495	/* We're closing */	511	/* We're closing */
496	op->move_on = 0;	512	op->move_on = 0;
497		513
498	op->stats.wc++;	514	op->stats.wc++;
499	if ((int) op->stats.wc >= NUM_ANIMATIONS (op))	515	if ((int) op->stats.wc >= NUM_ANIMATIONS (op))
…		…
530	{	546	{
531	object *payload = op->inv;	547	object *payload = op->inv;
532		548
533	if (payload == NULL)	549	if (payload == NULL)
534	return NULL;	550	return NULL;
		551
535	payload->remove ();	552	payload->remove ();
536	op->destroy ();	553	op->destroy ();
537	return payload;	554	return payload;
538	}	555	}
539		556
…		…
598	op->spellarg = NULL;	615	op->spellarg = NULL;
599	op->stats.sp = 0;	616	op->stats.sp = 0;
600	op->stats.hp = 0;	617	op->stats.hp = 0;
601	op->stats.grace = 0;	618	op->stats.grace = 0;
602	op->level = 0;	619	op->level = 0;
603	op->face = op->arch->clone.face;	620	op->face = op->arch->face;
604	op->owner = NULL; /* So that stopped arrows will be saved */	621	op->owner = NULL; /* So that stopped arrows will be saved */
605	update_object (op, UP_OBJ_CHANGE);	622	update_object (op, UP_OBJ_CHANGE);
606	return op;	623	return op;
607	}	624	}
608		625
…		…
619	if (INVOKE_OBJECT (STOP, op))	636	if (INVOKE_OBJECT (STOP, op))
620	return;	637	return;
621		638
622	if (op->inv)	639	if (op->inv)
623	{	640	{
		641	// replace this by straightforward drop to ground?
624	object *payload = op->inv;	642	object *payload = op->inv;
625		643
626	payload->remove ();
627	payload->owner = 0;	644	payload->owner = 0;
628	insert_ob_in_map (payload, op->map, payload, 0);	645	insert_ob_in_map (payload, op->map, payload, 0);
629	op->destroy ();	646	op->destroy ();
630	}	647	}
631	else	648	else
…		…
640	/* Move an arrow along its course. op is the arrow or thrown object.	657	/* Move an arrow along its course. op is the arrow or thrown object.
641	*/	658	*/
642	void	659	void
643	move_arrow (object *op)	660	move_arrow (object *op)
644	{	661	{
645	object *tmp;
646	sint16 new_x, new_y;
647	int was_reflected, mflags;	662	int was_reflected;
648	maptile *m;
649		663
650	if (op->map == NULL)	664	if (!op->map)
651	{	665	{
652	LOG (llevError, "BUG: Arrow had no map.\n");	666	LOG (llevError, "BUG: Arrow had no map.\n");
653	op->destroy ();	667	op->destroy ();
654	return;	668	return;
655	}	669	}
…		…
663	* is if the player throws a bomb - the bomb explodes on its own,	677	* is if the player throws a bomb - the bomb explodes on its own,
664	* but this object sticks around. We could handle the cleanup in the	678	* but this object sticks around. We could handle the cleanup in the
665	* bomb code, but there are potential other cases where that could happen,	679	* bomb code, but there are potential other cases where that could happen,
666	* and it is easy enough to clean it up here.	680	* and it is easy enough to clean it up here.
667	*/	681	*/
668	if (op->inv == NULL)	682	if (!op->inv)
669	{	683	{
670	op->destroy ();	684	op->destroy ();
671	return;	685	return;
672	}	686	}
673		687
…		…
685	stop_arrow (op);	699	stop_arrow (op);
686	return;	700	return;
687	}	701	}
688		702
689	/* Calculate target map square */	703	/* Calculate target map square */
690	new_x = op->x + DIRX (op);
691	new_y = op->y + DIRY (op);
692	was_reflected = 0;	704	was_reflected = 0;
693		705
694	m = op->map;	706	mapxy pos (op); pos.move (op->direction);
695	mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
696		707
697	if (mflags & P_OUT_OF_MAP)	708	if (!pos.normalise ())
698	{	709	{
699	stop_arrow (op);	710	stop_arrow (op);
700	return;	711	return;
701	}	712	}
702		713
703	/* only need to look for living creatures if this flag is set */	714	/* only need to look for living creatures if this flag is set */
704	if (mflags & P_IS_ALIVE)	715	if (pos->flags () & P_IS_ALIVE)
705	{	716	{
706	for (tmp = GET_MAP_OB (m, new_x, new_y); tmp != NULL; tmp = tmp->above)	717	object *tmp;
		718
		719	for (tmp = pos->bot; tmp; tmp = tmp->above)
707	if (QUERY_FLAG (tmp, FLAG_ALIVE))	720	if (QUERY_FLAG (tmp, FLAG_ALIVE))
708	break;	721	break;
709		722
710	/* Not really fair, but don't let monsters hit themselves with	723	/* Not really fair, but don't let monsters hit themselves with
711	* their own arrow - this can be because they fire it then	724	* their own arrow - this can be because they fire it then
…		…
734	return;	747	return;
735	}	748	}
736	} /* if this is not hitting its owner */	749	} /* if this is not hitting its owner */
737	} /* if there is something alive on this space */	750	} /* if there is something alive on this space */
738		751
739	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))	752	if (OB_TYPE_MOVE_BLOCK (op, pos->move_block))
740	{	753	{
741	int retry = 0;	754	int retry = 0;
742		755
743	/* if the object doesn't reflect, stop the arrow from moving	756	/* if the object doesn't reflect, stop the arrow from moving
744	* note that this code will now catch cases where a monster is	757	* note that this code will now catch cases where a monster is
…		…
757	if (op->direction & 1)	770	if (op->direction & 1)
758	{	771	{
759	op->direction = absdir (op->direction + 4);	772	op->direction = absdir (op->direction + 4);
760	retry = 1;	773	retry = 1;
761	}	774	}
		775
762	/* There were two blocks with identical code -	776	/* There were two blocks with identical code -
763	* use this retry here to make this one block	777	* use this retry here to make this one block
764	* that did the same thing.	778	* that did the same thing.
765	*/	779	*/
766	while (retry < 2)	780	while (retry < 2)
767	{	781	{
768	int left, right, mflags;
769	maptile *m1;
770	sint16 x1, y1;
771
772	retry++;	782	retry++;
773		783
774	/* Need to check for P_OUT_OF_MAP: if the arrow is tavelling	784	/* Need to check for P_OUT_OF_MAP: if the arrow is travelling
775	* over a corner in a tiled map, it is possible that	785	* over a corner in a tiled map, it is possible that
776	* op->direction is within an adjacent map but either	786	* op->direction is within an adjacent map but either
777	* op->direction-1 or op->direction+1 does not exist.	787	* op->direction-1 or op->direction+1 does not exist.
778	*/	788	*/
779	mflags = get_map_flags (op->map, &m1, op->x + freearr_x[absdir (op->direction - 1)],	789	mapxy pos1 (pos); pos1.move (absdir (op->direction - 1));
780	op->y + freearr_y[absdir (op->direction - 1)], &x1, &y1);	790	bool left = pos1.normalise () && OB_TYPE_MOVE_BLOCK (op, pos1->move_block);
781	left = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, (GET_MAP_MOVE_BLOCK (m1, x1, y1)));
782		791
783	mflags = get_map_flags (op->map, &m1, op->x + freearr_x[absdir (op->direction + 1)],	792	mapxy pos2 (pos); pos2.move (absdir (op->direction + 1));
784	op->y + freearr_y[absdir (op->direction + 1)], &x1, &y1);	793	bool right = pos2.normalise () && OB_TYPE_MOVE_BLOCK (op, pos2->move_block);
785	right = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, (GET_MAP_MOVE_BLOCK (m1, x1, y1)));
786		794
787	if (left == right)	795	if (left == right)
788	op->direction = absdir (op->direction + 4);	796	op->direction = absdir (op->direction + 4);
789	else if (left)	797	else if (left)
790	op->direction = absdir (op->direction + 2);	798	op->direction = absdir (op->direction + 2);
791	else if (right)	799	else if (right)
792	op->direction = absdir (op->direction - 2);	800	op->direction = absdir (op->direction - 2);
793		801
794	mflags = get_map_flags (op->map, &m1, op->x + DIRX (op), op->y + DIRY (op), &x1, &y1);
795
796	/* If this space is not out of the map and not blocked, valid space -	802	/* If this space is not out of the map and not blocked, valid space -
797	* don't need to retry again.	803	* don't need to retry again.
798	*/	804	*/
799	if (!(mflags & P_OUT_OF_MAP) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m1, x1, y1)))	805	mapxy pos3 (pos); pos3.move (op->direction);
		806	if (pos3.normalise () && !OB_TYPE_MOVE_BLOCK (op, pos3->move_block))
800	break;	807	break;
801
802	}	808	}
		809
803	/* Couldn't find a direction to move the arrow to - just	810	/* Couldn't find a direction to move the arrow to - just
804	* top it from moving.	811	* stop it from moving.
805	*/	812	*/
806	if (retry == 2)	813	if (retry == 2)
807	{	814	{
808	stop_arrow (op);	815	stop_arrow (op);
809	return;	816	return;
810	}	817	}
		818
811	/* update object image for new facing */	819	/* update object image for new facing */
812	/* many thrown objects don't have more than one face */	820	/* many thrown objects don't have more than one face */
813	if (GET_ANIM_ID (op))	821	if (GET_ANIM_ID (op))
814	SET_ANIMATION (op, op->direction);	822	SET_ANIMATION (op, op->direction);
815	} /* object is reflected */	823	} /* object is reflected */
816	} /* object ran into a wall */	824	} /* object ran into a wall */
817		825
818	/* Move the arrow. */
819	op->remove ();
820	op->x = new_x;
821	op->y = new_y;
822
823	/* decrease the speed as it flies. 0.05 means a standard bow will shoot	826	/* decrease the speed as it flies. 0.05 means a standard bow will shoot
824	* about 17 squares. Tune as needed.	827	* about 17 squares. Tune as needed.
825	*/	828	*/
826	op->speed -= 0.05;	829	op->speed -= 0.05;
827	insert_ob_in_map (op, m, op, 0);
828	}
829		830
830	/* This routine doesnt seem to work for "inanimate" objects that	831	/* Move the arrow. */
831	* are being carried, ie a held torch leaps from your hands!.	832	op->move_to (pos);
832	* Modified this routine to allow held objects. b.t. */	833	}
833		834
834	void	835	void
835	change_object (object *op)	836	change_object (object *op)
836	{ /* Doesn`t handle linked objs yet */	837	{ /* Doesn`t handle linked objs yet */
837	int i, j;	838	int i, j;
838		839
839	if (op->other_arch == NULL)	840	if (!op->other_arch)
840	{	841	{
841	LOG (llevError, "Change object (%s) without other_arch error.\n", &op->name);	842	LOG (llevError, "Change object (%s) without other_arch error.\n", op->debug_desc ());
842	return;	843	return;
843	}	844	}
844		845
845	/* In non-living items only change when food value is 0 */	846	/* In non-living items only change when food value is 0 */
846	if (!QUERY_FLAG (op, FLAG_ALIVE))	847	if (!QUERY_FLAG (op, FLAG_ALIVE))
847	{	848	{
848	if (op->stats.food-- > 0)	849	if (op->stats.food-- > 0)
849	return;	850	return;
		851
		852	op->stats.food = 1; /* so 1 other_arch is made */
		853	}
		854
		855	object *env = op->env;
		856
		857	op->remove ();
		858	for (i = 0; i < op->stats.food; i++)
		859	{
		860	object *tmp = arch_to_object (op->other_arch);
		861
		862	tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
		863
		864	if (env)
		865	env->insert (tmp);
850	else	866	else
851	op->stats.food = 1; /* so 1 other_arch is made */
852	}
853
854	object *pl = op->in_player ();
855	object *env = op->env;
856
857	op->remove ();
858	for (i = 0; i < NROFNEWOBJS (op); i++)
859	{
860	object *tmp = arch_to_object (op->other_arch);
861
862	if (op->type == LAMP)
863	tmp->stats.food = op->stats.food - 1;
864
865	tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
866	if (env)
867	{
868	tmp->x = env->x, tmp->y = env->y;
869	tmp = insert_ob_in_ob (tmp, env);
870
871	/* If this object is the players inventory, we need to tell the
872	* client of the change. Insert_ob_in_map takes care of the
873	* updating the client, so we don't need to do that below.
874	*/
875	if (pl)
876	{
877	esrv_del_item (pl->contr, op->count);
878	esrv_send_item (pl, tmp);
879	}
880	}
881	else
882	{	867	{
883	j = find_first_free_spot (tmp, op->map, op->x, op->y);	868	j = find_first_free_spot (tmp, op->map, op->x, op->y);
884	if (j == -1) /* No free spot */	869	if (j < 0) /* No free spot */
885	tmp->destroy ();	870	tmp->destroy ();
886	else	871	else
887	{	872	{
888	tmp->x = op->x + freearr_x[j], tmp->y = op->y + freearr_y[j];	873	mapxy pos (op); pos.move (j);
889	insert_ob_in_map (tmp, op->map, op, 0);	874
		875	if (pos.normalise ())
		876	pos.insert (tmp, op);
890	}	877	}
891	}	878	}
892	}	879	}
893		880
894	op->destroy ();	881	op->destroy ();
…		…
910	move_teleporter (op->more);	897	move_teleporter (op->more);
911		898
912	if (op->head)	899	if (op->head)
913	head = op->head;	900	head = op->head;
914		901
915	for (tmp = op->above; tmp != NULL; tmp = tmp->above)	902	for (tmp = op->above; tmp; tmp = tmp->above)
916	if (!QUERY_FLAG (tmp, FLAG_IS_FLOOR))	903	if (!QUERY_FLAG (tmp, FLAG_IS_FLOOR))
917	break;	904	break;
918		905
919	/* If nothing above us to move, nothing to do */	906	/* If nothing above us to move, nothing to do */
920	if (!tmp \|\| QUERY_FLAG (tmp, FLAG_WIZPASS))	907	if (!tmp \|\| QUERY_FLAG (tmp, FLAG_WIZPASS))
…		…
950	else	937	else
951	{	938	{
952	/* Random teleporter */	939	/* Random teleporter */
953	if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))	940	if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))
954	return;	941	return;
		942
955	teleport (head, TELEPORTER, tmp);	943	teleport (head, TELEPORTER, tmp);
956	}	944	}
957	}	945	}
958
959		946
960	/* This object will teleport someone to a different map	947	/* This object will teleport someone to a different map
961	and will also apply changes to the player from its inventory.	948	and will also apply changes to the player from its inventory.
962	This was invented for giving classes, but there's no reason it	949	This was invented for giving classes, but there's no reason it
963	can't be generalized.	950	can't be generalized.
…		…
1016	return; /* dm has created a firewall in his inventory */	1003	return; /* dm has created a firewall in his inventory */
1017		1004
1018	spell = op->inv;	1005	spell = op->inv;
1019		1006
1020	if (!spell \|\| spell->type != SPELL)	1007	if (!spell \|\| spell->type != SPELL)
1021	spell = &op->other_arch->clone;	1008	spell = op->other_arch;
1022		1009
1023	if (!spell)	1010	if (!spell)
1024	{	1011	{
1025	LOG (llevError, "move_firewall: no spell specified (%s, %s, %d, %d)\n", &op->name, &op->map->name, op->x, op->y);	1012	LOG (llevError, "move_firewall: no spell specified (%s, %s, %d, %d)\n", &op->name, &op->map->name, op->x, op->y);
1026	return;	1013	return;
…		…
1094	* is cleared, otherwise the player will get stuck in	1081	* is cleared, otherwise the player will get stuck in
1095	* place. This can happen if the player used a spell to	1082	* place. This can happen if the player used a spell to
1096	* get to this space.	1083	* get to this space.
1097	*/	1084	*/
1098	victim->contr->fire_on = 0;	1085	victim->contr->fire_on = 0;
1099	victim->speed_left = 0.f;	1086	victim->speed_left = 1.f;
1100	move_player (victim, dir);	1087	move_player (victim, dir);
1101	}	1088	}
1102	else	1089	else
1103	return;	1090	return;
1104	}	1091	}
…		…
1137	if (op->above == NULL)	1124	if (op->above == NULL)
1138	return;	1125	return;
1139		1126
1140	for (tmp = op->above; tmp; tmp = tmp->above)	1127	for (tmp = op->above; tmp; tmp = tmp->above)
1141	{	1128	{
1142	if (op->other_arch->name == tmp->arch->name)	1129	if (op->other_arch->archname == tmp->arch->archname)
1143	{	1130	{
1144	if (op->level <= 0)	1131	if (op->level <= 0)
1145	tmp->destroy ();	1132	tmp->destroy ();
1146	else	1133	else
1147	{	1134	{
…		…
1169	* has to make sure that there is in fact space for the object.	1156	* has to make sure that there is in fact space for the object.
1170	* It should really do this for small objects also, but there is	1157	* It should really do this for small objects also, but there is
1171	* more concern with large objects, most notably a part being placed	1158	* more concern with large objects, most notably a part being placed
1172	* outside of the map which would cause the server to crash	1159	* outside of the map which would cause the server to crash
1173	*/	1160	*/
1174
1175	void	1161	void
1176	move_creator (object *creator)	1162	move_creator (object *creator)
1177	{	1163	{
1178	object *new_ob;	1164	object *new_ob;
1179		1165
…		…
1181	{	1167	{
1182	creator->stats.hp = -1;	1168	creator->stats.hp = -1;
1183	return;	1169	return;
1184	}	1170	}
1185		1171
1186	if (creator->inv != NULL)	1172	if (creator->inv)
1187	{	1173	{
1188	object *ob;	1174	object *ob;
1189	int i;	1175	int i;
1190	object *ob_to_copy;	1176	object *ob_to_copy;
1191		1177
…		…
1196	if (rndm (0, i) == 0)	1182	if (rndm (0, i) == 0)
1197	{	1183	{
1198	ob_to_copy = ob;	1184	ob_to_copy = ob;
1199	}	1185	}
1200	}	1186	}
1201	new_ob = object_create_clone (ob_to_copy);	1187	new_ob = ob_to_copy->deep_clone ();
1202	CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE);	1188	CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE);
1203	unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);	1189	unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);
1204	}	1190	}
1205	else	1191	else
1206	{	1192	{
1207	if (creator->other_arch == NULL)	1193	if (!creator->other_arch)
1208	{	1194	{
1209	LOG (llevError, "move_creator: Creator doesn't have other arch set: %s (%s, %d, %d)\n",	1195	LOG (llevError, "move_creator: Creator doesn't have other arch set: %s (%s, %d, %d)\n",
1210	&creator->name, &creator->map->path, creator->x, creator->y);	1196	&creator->name, &creator->map->path, creator->x, creator->y);
1211	return;	1197	return;
1212	}	1198	}
…		…
1214	new_ob = object_create_arch (creator->other_arch);	1200	new_ob = object_create_arch (creator->other_arch);
1215	fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);	1201	fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);
1216	}	1202	}
1217		1203
1218	/* Make sure this multipart object fits */	1204	/* Make sure this multipart object fits */
1219	if (new_ob->arch->more && ob_blocked (new_ob, creator->map, creator->x, creator->y))	1205	if (new_ob->arch->more && new_ob->blocked (creator->map, creator->x, creator->y))
1220	{	1206	{
1221	new_ob->destroy ();	1207	new_ob->destroy ();
1222	return;	1208	return;
1223	}	1209	}
		1210
		1211	// for now lets try to identify everything generated here, it mostly
		1212	// happens automated, so this will at least fix many identify-experience holes
		1213	SET_FLAG (new_ob, FLAG_IDENTIFIED);
1224		1214
1225	insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y);	1215	insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y);
1226	if (QUERY_FLAG (new_ob, FLAG_FREED))	1216	if (QUERY_FLAG (new_ob, FLAG_FREED))
1227	return;	1217	return;
1228		1218
1229	if (creator->slaying)	1219	if (creator->slaying)
1230	{
1231	new_ob->name = new_ob->title = creator->slaying;	1220	new_ob->name = new_ob->title = creator->slaying;
1232	}
1233	}	1221	}
1234		1222
1235	/* move_marker --peterm@soda.csua.berkeley.edu	1223	/* move_marker --peterm@soda.csua.berkeley.edu
1236	when moved, a marker will search for a player sitting above	1224	when moved, a marker will search for a player sitting above
1237	it, and insert an invisible, weightless force into him	1225	it, and insert an invisible, weightless force into him
…		…
1243	void	1231	void
1244	move_marker (object *op)	1232	move_marker (object *op)
1245	{	1233	{
1246	if (object *tmp = op->ms ().player ())	1234	if (object *tmp = op->ms ().player ())
1247	{	1235	{
1248	object *tmp2;
1249
1250	/* remove an old force with a slaying field == op->name */	1236	/* remove an old force with a slaying field == op->name */
1251	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)	1237	if (object *force = tmp->force_find (op->name))
1252	if (tmp2->type == FORCE && tmp2->slaying && tmp2->slaying == op->name)	1238	force->destroy ();
		1239
		1240	if (!tmp->force_find (op->slaying))
1253	{	1241	{
1254	tmp2->destroy ();	1242	tmp->force_add (op->slaying, op->stats.food);
1255	break;
1256	}
1257		1243
1258	/* cycle through his inventory to look for the MARK we want to
1259	* place
1260	*/
1261	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1262	if (tmp2->type == FORCE && tmp2->slaying && tmp2->slaying == op->slaying)
1263	break;
1264
1265	/* if we didn't find our own MARK */
1266	if (!tmp2)
1267	{
1268	object *force = get_archetype (FORCE_NAME);
1269
1270	if (op->stats.food)
1271	{
1272	force->set_speed (0.01);
1273	force->speed_left = -op->stats.food;
1274	}
1275	else
1276	force->set_speed (0);
1277
1278	/* put in the lock code */
1279	force->slaying = op->slaying;
1280
1281	if (op->lore)
1282	force->lore = op->lore;
1283
1284	insert_ob_in_ob (force, tmp);
1285	if (op->msg)	1244	if (op->msg)
1286	new_draw_info (NDI_UNIQUE \| NDI_NAVY, 0, tmp, op->msg);	1245	new_draw_info (NDI_UNIQUE \| NDI_NAVY, 0, tmp, op->msg);
1287		1246
1288	if (op->stats.hp > 0)	1247	if (op->stats.hp > 0)
1289	{	1248	{
1290	op->stats.hp--;	1249	op->stats.hp--;
		1250
1291	if (op->stats.hp == 0)	1251	if (op->stats.hp == 0)
1292	{	1252	{
1293	/* marker expires--granted mark number limit */	1253	/* marker expires--granted mark number limit */
1294	op->destroy ();	1254	op->destroy ();
1295	return;	1255	return;
…		…
1297	}	1257	}
1298	}	1258	}
1299	}	1259	}
1300	}	1260	}
1301		1261
		1262	// mapscript objects activate themselves (only) then their timer fires
		1263	// TODO: maybe they should simply trigger the link like any other object?
		1264	void
		1265	move_mapscript (object *op)
		1266	{
		1267	op->set_speed (0);
		1268	cfperl_mapscript_activate (op, true, op, 0);
		1269	}
		1270
		1271	void move_lamp (object *op)
		1272	{
		1273	// if the lamp/torch is off, we should disable it.
		1274	if (!op->glow_radius)
		1275	{
		1276	op->set_speed (0);
		1277	return;
		1278	}
		1279
		1280	// lamps and torches auf maps don't use up their fuel
		1281	if (op->is_on_map ())
		1282	return;
		1283
		1284	if (op->stats.food > 0)
		1285	{
		1286	op->stats.food--;
		1287	return;
		1288	}
		1289
		1290	apply_lamp (op, false);
		1291	}
		1292
1302	void	1293	void
1303	process_object (object *op)	1294	process_object (object *op)
1304	{	1295	{
1305	if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))	1296	if (expect_false (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)))
1306	return;	1297	return;
1307		1298
1308	if (INVOKE_OBJECT (TICK, op))	1299	if (expect_false (INVOKE_OBJECT (TICK, op)))
1309	return;	1300	return;
1310		1301
1311	if (QUERY_FLAG (op, FLAG_MONSTER))	1302	if (QUERY_FLAG (op, FLAG_MONSTER))
1312	if (move_monster (op) \|\| QUERY_FLAG (op, FLAG_FREED))	1303	if (move_monster (op) \|\| QUERY_FLAG (op, FLAG_FREED))
1313	return;	1304	return;
…		…
1318		1309
1319	if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))	1310	if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
1320	make_sure_seen (op);	1311	make_sure_seen (op);
1321	}	1312	}
1322		1313
		1314	if (expect_false (
1323	if (op->flag [FLAG_GENERATOR]	1315	op->flag [FLAG_GENERATOR]
1324	\|\| op->flag [FLAG_CHANGING]	1316	\|\| op->flag [FLAG_CHANGING]
1325	\|\| op->flag [FLAG_IS_USED_UP])	1317	\|\| op->flag [FLAG_IS_USED_UP]
		1318	))
1326	{	1319	{
1327	if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state)	1320	if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state)
1328	{	1321	{
1329	change_object (op);	1322	change_object (op);
1330	return;	1323	return;
…		…
1337	{	1330	{
1338	if (QUERY_FLAG (op, FLAG_APPLIED))	1331	if (QUERY_FLAG (op, FLAG_APPLIED))
1339	remove_force (op);	1332	remove_force (op);
1340	else	1333	else
1341	{	1334	{
1342	/* If necessary, delete the item from the players inventory */	1335	op->remove (); // TODO: really necessary?
1343	object *pl = op->in_player ();
1344
1345	if (pl)
1346	esrv_del_item (pl->contr, op->count);
1347
1348	op->remove ();
1349		1336
1350	if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))	1337	if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
1351	make_sure_not_seen (op);	1338	make_sure_not_seen (op);
1352		1339
1353	op->destroy ();	1340	op->drop_and_destroy ();
1354	}	1341	}
1355		1342
1356	return;	1343	return;
1357	}	1344	}
1358	}	1345	}
…		…
1482		1469
1483	case PLAYER:	1470	case PLAYER:
1484	// players have their own speed-management, so undo the --speed_left	1471	// players have their own speed-management, so undo the --speed_left
1485	++op->speed_left;	1472	++op->speed_left;
1486	break;	1473	break;
1487	}
1488	}
1489		1474
		1475	case MAPSCRIPT:
		1476	move_mapscript (op);
		1477	break;
		1478
		1479	case LAMP:
		1480	case TORCH:
		1481	move_lamp (op);
		1482	break;
		1483	}
		1484	}
		1485

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing deliantra/server/server/time.C (file contents): Revision 1.51 by root, Fri May 18 20:45:37 2007 UTC vs. Revision 1.87 by elmex, Tue Jan 13 12:14:56 2009 UTC

Diff Legend

Comparing deliantra/server/server/time.C (file contents):
Revision 1.51 by root, Fri May 18 20:45:37 2007 UTC vs.
Revision 1.87 by elmex, Tue Jan 13 12:14:56 2009 UTC