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

Comparing deliantra/server/server/time.C (file contents):
Revision 1.52 by root, Tue May 22 10:50:01 2007 UTC vs.
Revision 1.90 by root, Tue May 5 04:51: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 (op->has_anim ())
814	SET_ANIMATION (op, op->direction);	822	op->set_anim_frame (op->direction);
815	} /* object is reflected */	823	} /* object is reflected */
816	} /* object ran into a wall */	824	} /* object ran into a wall */
817
818	/* Move the arrow. */
819	op->remove ();
820	op->x = new_x;
821	op->y = new_y;
822		825
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		946
959	/* This object will teleport someone to a different map	947	/* This object will teleport someone to a different map
…		…
1015	return; /* dm has created a firewall in his inventory */	1003	return; /* dm has created a firewall in his inventory */
1016		1004
1017	spell = op->inv;	1005	spell = op->inv;
1018		1006
1019	if (!spell \|\| spell->type != SPELL)	1007	if (!spell \|\| spell->type != SPELL)
1020	spell = &op->other_arch->clone;	1008	spell = op->other_arch;
1021		1009
1022	if (!spell)	1010	if (!spell)
1023	{	1011	{
1024	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);
1025	return;	1013	return;
…		…
1136	if (op->above == NULL)	1124	if (op->above == NULL)
1137	return;	1125	return;
1138		1126
1139	for (tmp = op->above; tmp; tmp = tmp->above)	1127	for (tmp = op->above; tmp; tmp = tmp->above)
1140	{	1128	{
1141	if (op->other_arch->name == tmp->arch->name)	1129	if (op->other_arch->archname == tmp->arch->archname)
1142	{	1130	{
1143	if (op->level <= 0)	1131	if (op->level <= 0)
1144	tmp->destroy ();	1132	tmp->destroy ();
1145	else	1133	else
1146	{	1134	{
…		…
1168	* 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.
1169	* 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
1170	* more concern with large objects, most notably a part being placed	1158	* more concern with large objects, most notably a part being placed
1171	* outside of the map which would cause the server to crash	1159	* outside of the map which would cause the server to crash
1172	*/	1160	*/
1173
1174	void	1161	void
1175	move_creator (object *creator)	1162	move_creator (object *creator)
1176	{	1163	{
1177	object *new_ob;	1164	object *new_ob;
1178		1165
…		…
1180	{	1167	{
1181	creator->stats.hp = -1;	1168	creator->stats.hp = -1;
1182	return;	1169	return;
1183	}	1170	}
1184		1171
1185	if (creator->inv != NULL)	1172	if (creator->inv)
1186	{	1173	{
1187	object *ob;	1174	object *ob;
1188	int i;	1175	int i;
1189	object *ob_to_copy;	1176	object *ob_to_copy;
1190		1177
…		…
1195	if (rndm (0, i) == 0)	1182	if (rndm (0, i) == 0)
1196	{	1183	{
1197	ob_to_copy = ob;	1184	ob_to_copy = ob;
1198	}	1185	}
1199	}	1186	}
1200	new_ob = object_create_clone (ob_to_copy);	1187	new_ob = ob_to_copy->deep_clone ();
1201	CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE);	1188	CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE);
1202	unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);	1189	unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);
1203	}	1190	}
1204	else	1191	else
1205	{	1192	{
1206	if (creator->other_arch == NULL)	1193	if (!creator->other_arch)
1207	{	1194	{
1208	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",
1209	&creator->name, &creator->map->path, creator->x, creator->y);	1196	&creator->name, &creator->map->path, creator->x, creator->y);
1210	return;	1197	return;
1211	}	1198	}
…		…
1213	new_ob = object_create_arch (creator->other_arch);	1200	new_ob = object_create_arch (creator->other_arch);
1214	fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);	1201	fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);
1215	}	1202	}
1216		1203
1217	/* Make sure this multipart object fits */	1204	/* Make sure this multipart object fits */
1218	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))
1219	{	1206	{
1220	new_ob->destroy ();	1207	new_ob->destroy ();
1221	return;	1208	return;
1222	}	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);
1223		1214
1224	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);
1225	if (QUERY_FLAG (new_ob, FLAG_FREED))	1216	if (QUERY_FLAG (new_ob, FLAG_FREED))
1226	return;	1217	return;
1227		1218
1228	if (creator->slaying)	1219	if (creator->slaying)
1229	{
1230	new_ob->name = new_ob->title = creator->slaying;	1220	new_ob->name = new_ob->title = creator->slaying;
1231	}
1232	}	1221	}
1233		1222
1234	/* move_marker --peterm@soda.csua.berkeley.edu	1223	/* move_marker --peterm@soda.csua.berkeley.edu
1235	when moved, a marker will search for a player sitting above	1224	when moved, a marker will search for a player sitting above
1236	it, and insert an invisible, weightless force into him	1225	it, and insert an invisible, weightless force into him
…		…
1242	void	1231	void
1243	move_marker (object *op)	1232	move_marker (object *op)
1244	{	1233	{
1245	if (object *tmp = op->ms ().player ())	1234	if (object *tmp = op->ms ().player ())
1246	{	1235	{
1247	object *tmp2;
1248
1249	/* remove an old force with a slaying field == op->name */	1236	/* remove an old force with a slaying field == op->name */
1250	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)	1237	if (object *force = tmp->force_find (op->name))
1251	if (tmp2->type == FORCE && tmp2->slaying && tmp2->slaying == op->name)	1238	force->destroy ();
		1239
		1240	if (!tmp->force_find (op->slaying))
1252	{	1241	{
1253	tmp2->destroy ();	1242	tmp->force_add (op->slaying, op->stats.food);
1254	break;
1255	}
1256		1243
1257	/* cycle through his inventory to look for the MARK we want to
1258	* place
1259	*/
1260	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1261	if (tmp2->type == FORCE && tmp2->slaying && tmp2->slaying == op->slaying)
1262	break;
1263
1264	/* if we didn't find our own MARK */
1265	if (!tmp2)
1266	{
1267	object *force = get_archetype (FORCE_NAME);
1268
1269	if (op->stats.food)
1270	{
1271	force->set_speed (0.01);
1272	force->speed_left = -op->stats.food;
1273	}
1274	else
1275	force->set_speed (0);
1276
1277	/* put in the lock code */
1278	force->slaying = op->slaying;
1279
1280	if (op->lore)
1281	force->lore = op->lore;
1282
1283	insert_ob_in_ob (force, tmp);
1284	if (op->msg)	1244	if (op->msg)
1285	new_draw_info (NDI_UNIQUE \| NDI_NAVY, 0, tmp, op->msg);	1245	new_draw_info (NDI_UNIQUE \| NDI_NAVY, 0, tmp, op->msg);
1286		1246
1287	if (op->stats.hp > 0)	1247	if (op->stats.hp > 0)
1288	{	1248	{
1289	op->stats.hp--;	1249	op->stats.hp--;
		1250
1290	if (op->stats.hp == 0)	1251	if (op->stats.hp == 0)
1291	{	1252	{
1292	/* marker expires--granted mark number limit */	1253	/* marker expires--granted mark number limit */
1293	op->destroy ();	1254	op->destroy ();
1294	return;	1255	return;
…		…
1296	}	1257	}
1297	}	1258	}
1298	}	1259	}
1299	}	1260	}
1300		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	else
		1280	{
		1281	// check whether the face might needs to be updated
		1282	// (currently this is needed to have already switched on torches
		1283	// on maps, as they just set the glow_radius in the archetype)
		1284	if (op->other_arch
		1285	&& (
		1286	(op->flag [FLAG_ANIMATE] != op->other_arch->flag [FLAG_ANIMATE])
		1287	\|\| (op->flag [FLAG_ANIMATE]
		1288	? (op->animation_id != op->other_arch->animation_id)
		1289	: (op->face != op->other_arch->face))
		1290	))
		1291	get_animation_from_arch (op, op->other_arch);
		1292	}
		1293
		1294	// lamps and torches auf maps don't use up their fuel
		1295	if (op->is_on_map ())
		1296	return;
		1297
		1298	if (op->stats.food > 0)
		1299	{
		1300	op->stats.food--;
		1301	return;
		1302	}
		1303
		1304	apply_lamp (op, false);
		1305	}
		1306
1301	void	1307	void
1302	process_object (object *op)	1308	process_object (object *op)
1303	{	1309	{
1304	if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))	1310	if (expect_false (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)))
1305	return;	1311	return;
1306		1312
1307	if (INVOKE_OBJECT (TICK, op))	1313	if (expect_false (INVOKE_OBJECT (TICK, op)))
1308	return;	1314	return;
1309		1315
1310	if (QUERY_FLAG (op, FLAG_MONSTER))	1316	if (QUERY_FLAG (op, FLAG_MONSTER))
1311	if (move_monster (op) \|\| QUERY_FLAG (op, FLAG_FREED))	1317	if (move_monster (op) \|\| QUERY_FLAG (op, FLAG_FREED))
1312	return;	1318	return;
…		…
1317		1323
1318	if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))	1324	if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
1319	make_sure_seen (op);	1325	make_sure_seen (op);
1320	}	1326	}
1321		1327
		1328	if (expect_false (
1322	if (op->flag [FLAG_GENERATOR]	1329	op->flag [FLAG_GENERATOR]
1323	\|\| op->flag [FLAG_CHANGING]	1330	\|\| op->flag [FLAG_CHANGING]
1324	\|\| op->flag [FLAG_IS_USED_UP])	1331	\|\| op->flag [FLAG_IS_USED_UP]
		1332	))
1325	{	1333	{
1326	if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state)	1334	if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state)
1327	{	1335	{
1328	change_object (op);	1336	change_object (op);
1329	return;	1337	return;
…		…
1336	{	1344	{
1337	if (QUERY_FLAG (op, FLAG_APPLIED))	1345	if (QUERY_FLAG (op, FLAG_APPLIED))
1338	remove_force (op);	1346	remove_force (op);
1339	else	1347	else
1340	{	1348	{
1341	/* If necessary, delete the item from the players inventory */	1349	op->remove (); // TODO: really necessary?
1342	object *pl = op->in_player ();
1343
1344	if (pl)
1345	esrv_del_item (pl->contr, op->count);
1346
1347	op->remove ();
1348		1350
1349	if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))	1351	if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
1350	make_sure_not_seen (op);	1352	make_sure_not_seen (op);
1351		1353
1352	op->destroy ();	1354	op->drop_and_destroy ();
1353	}	1355	}
1354		1356
1355	return;	1357	return;
1356	}	1358	}
1357	}	1359	}
…		…
1481		1483
1482	case PLAYER:	1484	case PLAYER:
1483	// players have their own speed-management, so undo the --speed_left	1485	// players have their own speed-management, so undo the --speed_left
1484	++op->speed_left;	1486	++op->speed_left;
1485	break;	1487	break;
1486	}
1487	}
1488		1488
		1489	case MAPSCRIPT:
		1490	move_mapscript (op);
		1491	break;
		1492
		1493	case LAMP:
		1494	case TORCH:
		1495	move_lamp (op);
		1496	break;
		1497	}
		1498	}
		1499

Diff Legend

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

Comparing deliantra/server/server/time.C (file contents): Revision 1.52 by root, Tue May 22 10:50:01 2007 UTC vs. Revision 1.90 by root, Tue May 5 04:51:56 2009 UTC

Diff Legend

Comparing deliantra/server/server/time.C (file contents):
Revision 1.52 by root, Tue May 22 10:50:01 2007 UTC vs.
Revision 1.90 by root, Tue May 5 04:51:56 2009 UTC