ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/time.C

Comparing deliantra/server/server/time.C (file contents):
Revision 1.21 by elmex, Wed Dec 20 11:20:50 2006 UTC vs.
Revision 1.118 by root, Fri Jan 27 22:00:40 2012 UTC

1	/*	1	/*
2	CrossFire, A Multiplayer game for X-windows	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3		3	*
		4	* Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
4	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002 Mark Wedel & Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
6		7	*
7	This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
8	it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
9	the Free Software Foundation; either version 2 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
10	(at your option) any later version.	11	* option) any later version.
11		12	*
12	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,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	16	* GNU General Public License for more details.
16		17	*
17	You should have received a copy of the GNU General Public License	18	* You should have received a copy of the Affero GNU General Public License
18	along with this program; if not, write to the Free Software	19	* and the GNU General Public License along with this program. If not, see
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* <http://www.gnu.org/licenses/>.
20		21	*
21	The authors can be reached via e-mail at <crossfire@schmorp.de>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	/*	25	/*
25	* Routines that is executed from objects based on their speed have been	26	* Routines that is executed from objects based on their speed have been
26	* collected in this file.	27	* collected in this file.
27	*/	28	*/
28
29	#include <global.h>	29	#include <global.h>
30	#include <spells.h>	30	#include <spells.h>
31	#ifndef __CEXTRACT__
32	# include <sproto.h>	31	#include <sproto.h>
33	#endif
34		32
35	/* The following removes doors. The functions check to see if similar	33	/* The following removes doors. The functions check to see if similar
36	* doors are next to the one that is being removed, and if so, set it	34	* doors are next to the one that is being removed, and if so, set it
37	* so those will be removed shortly (in a cascade like fashion.)	35	* so those will be removed shortly (in a cascade like fashion.)
38	*/	36	*/
39
40	void	37	void
41	remove_door (object *op)	38	remove_door (object *op)
42	{	39	{
43	int i;	40	for (int i = 1; i < SIZEOFFREE1 + 1; i += 2)
		41	{
44	object *tmp;	42	object *tmp;
45		43	mapxy pos (op);
46	for (i = 1; i < 9; i += 2)	44	pos.move (i);
47	if ((tmp = present (DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i])) != NULL)	45	if (pos.normalise ()
		46	&& (tmp = present (DOOR, pos.m, pos.x, pos.y)))
48	{	47	{
49	tmp->speed = 0.1;	48	tmp->set_speed (0.1f);
50	update_ob_speed (tmp);
51	tmp->speed_left = -0.2;	49	tmp->speed_left = -0.2f;
52	}	50	}
		51	}
53		52
54	if (op->other_arch)	53	if (op->other_arch)
55	{	54	{
56	tmp = arch_to_object (op->other_arch);	55	object *tmp = op->other_arch->instance ();
57	tmp->x = op->x;	56	tmp->x = op->x;
58	tmp->y = op->y;	57	tmp->y = op->y;
59	tmp->map = op->map;	58	tmp->map = op->map;
60	tmp->level = op->level;	59	tmp->level = op->level;
61	insert_ob_in_map (tmp, op->map, op, 0);	60	insert_ob_in_map (tmp, op->map, op, 0);
62	}	61	}
63		62
64	op->destroy ();	63	op->drop_and_destroy ();
65	}	64	}
66		65
67	void	66	void
68	remove_door2 (object *op)	67	remove_door2 (object *op)
69	{	68	{
…		…
73	for (i = 1; i < 9; i += 2)	72	for (i = 1; i < 9; i += 2)
74	{	73	{
75	tmp = present (LOCKED_DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i]);	74	tmp = present (LOCKED_DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i]);
76	if (tmp && tmp->slaying == op->slaying)	75	if (tmp && tmp->slaying == op->slaying)
77	{ /* same key both doors */	76	{ /* same key both doors */
78	tmp->speed = 0.1;	77	tmp->set_speed (0.1f);
79	update_ob_speed (tmp);
80	tmp->speed_left = -0.2;	78	tmp->speed_left = -0.2f;
81	}	79	}
82	}	80	}
		81
83	if (op->other_arch)	82	if (op->other_arch)
84	{	83	{
85	tmp = arch_to_object (op->other_arch);	84	tmp = op->other_arch->instance ();
86	tmp->x = op->x;	85	tmp->x = op->x;
87	tmp->y = op->y;	86	tmp->y = op->y;
88	tmp->map = op->map;	87	tmp->map = op->map;
89	tmp->level = op->level;	88	tmp->level = op->level;
90	insert_ob_in_map (tmp, op->map, op, 0);	89	insert_ob_in_map (tmp, op->map, op, 0);
91	}	90	}
92		91
93	op->destroy ();	92	op->drop_and_destroy ();
94	}	93	}
95		94
96	/* Will generate a monster according to content	95	static void
97	* of generator.
98	*/
99	void
100	generate_monster_inv (object *gen)	96	generate_monster (object *gen)
101	{	97	{
102	int i;
103	object *op, *head = NULL;
104
105	int qty = 0;
106
107	/* Code below assumes the generator is on a map, as it tries
108	* to place the monster on the map. So if the generator
109	* isn't on a map, complain and exit.
110	*/
111	if (gen->map == NULL)	98	if (!gen->map)
112	{
113	//LOG(llevError,"Generator (%s) not on a map?\n", gen->name);
114	return;
115	}
116	/*First count numer of objects in inv */
117	for (op = gen->inv; op; op = op->below)
118	qty++;
119	if (!qty)
120	{
121	LOG (llevError, "Generator (%s) has no inventory in generate_monster_inv?\n", &gen->name);
122	return; /*No inventory */
123	}
124	qty = rndm (0, qty - 1);
125	for (op = gen->inv; qty; qty--)
126	op = op->below;
127	i = find_free_spot (op, gen->map, gen->x, gen->y, 1, 9);
128	if (i == -1)
129	return;	99	return;
130	head = object_create_clone (op);	100
131	CLEAR_FLAG (head, FLAG_IS_A_TEMPLATE);	101	if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1))
132	unflag_inv (head, FLAG_IS_A_TEMPLATE);
133	if (rndm (0, 9))
134	generate_artifact (head, gen->map->difficulty);
135	insert_ob_in_map_at (head, gen->map, gen, 0, gen->x + freearr_x[i], gen->y + freearr_y[i]);
136	if (QUERY_FLAG (head, FLAG_FREED))
137	return;	102	return;
138	if (head->has_random_items ())
139	create_treasure (head->randomitems, head, GT_APPLY, gen->map->difficulty, 0);
140	}
141		103
142	void	104	// sleeping generators won't generate, this will make monsters like
143	generate_monster_arch (object *gen)	105	// centipedes not generate more centipedes when being asleep.
144	{	106	if (gen->flag [FLAG_SLEEP])
145	int i;
146	object *op, *head = NULL, *prev = NULL;
147	archetype *at = gen->other_arch;
148
149	if (gen->other_arch == NULL)
150	{
151	//LOG(llevError,"Generator without other_arch: %s\n",gen->name);
152	return;
153	}
154	/* Code below assumes the generator is on a map, as it tries
155	* to place the monster on the map. So if the generator
156	* isn't on a map, complain and exit.
157	*/
158	if (gen->map == NULL)
159	{
160	//LOG(llevError,"Generator (%s) not on a map?\n", gen->name);
161	return;
162	}
163	i = find_free_spot (&at->clone, gen->map, gen->x, gen->y, 1, 9);
164	if (i == -1)
165	return;	107	return;
166	while (at != NULL)	108
		109	object *op;
		110	int dir;
		111
		112	if (gen->flag [FLAG_CONTENT_ON_GEN])
		113	{
		114	// either copy one item from the inventory...
		115	if (!gen->inv)
		116	return;
		117
		118	// first select one item from the inventory
		119	int index = 0;
		120	for (object *tmp = gen->inv; tmp; tmp = tmp->below)
		121	if (!rndm (++index))
		122	op = tmp;
		123
		124	dir = find_free_spot (op, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1);
		125	if (dir < 0)
		126	return;
		127
		128	op = op->deep_clone ();
		129
		130	op->clr_flag (FLAG_IS_A_TEMPLATE);
		131	unflag_inv (op, FLAG_IS_A_TEMPLATE);
167	{	132	}
168	op = arch_to_object (at);	133	else if (gen->other_arch)
169	op->x = gen->x + freearr_x[i] + at->clone.x;	134	{
170	op->y = gen->y + freearr_y[i] + at->clone.y;	135	// ...or use other_arch
		136	dir = find_free_spot (gen->other_arch, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1);
		137	if (dir < 0)
		138	return;
171		139
172	if (head != NULL)	140	op = gen->other_arch->instance ();
173	op->head = head, prev->more = op;	141	}
		142	else
		143	return;
174		144
		145	op->expand_tail ();
		146
		147	mapxy pos (gen); pos.move (dir);
		148
		149	if (pos.insert (op, gen))
		150	{
175	if (rndm (0, 9))	151	if (rndm (0, 9))
176	generate_artifact (op, gen->map->difficulty);	152	generate_artifact (op, gen->map->difficulty);
177	insert_ob_in_map (op, gen->map, gen, 0);	153
178	if (QUERY_FLAG (op, FLAG_FREED))
179	return;
180	if (op->has_random_items ())	154	if (op->has_random_items ())
181	create_treasure (op->randomitems, op, GT_APPLY, gen->map->difficulty, 0);	155	create_treasure (op->randomitems, op, GT_APPLY, gen->map->difficulty);
182	if (head == NULL)
183	head = op;
184	prev = op;
185	at = at->more;
186	}
187	}
188		156
189	void
190	generate_monster (object *gen)
191	{
192
193	if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1))
194	return;	157	return;
195	if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN))	158	}
196	generate_monster_inv (gen);
197	else
198	generate_monster_arch (gen);
199		159
		160	op->destroy ();
200	}	161	}
201		162
202	void	163	static void
203	remove_force (object *op)	164	remove_force (object *op)
204	{	165	{
205	if (--op->duration > 0)	166	if (--op->duration > 0)
206	return;	167	return;
207		168
		169	if (op->env)
208	switch (op->subtype)	170	switch (op->subtype)
209	{	171	{
210	case FORCE_CONFUSION:	172	case FORCE_CONFUSION:
211	if (op->env != NULL)	173	op->env->clr_flag (FLAG_CONFUSED);
212	{
213	CLEAR_FLAG (op->env, FLAG_CONFUSED);
214	new_draw_info (NDI_UNIQUE, 0, op->env, "You regain your senses.\n");	174	new_draw_info (NDI_UNIQUE, 0, op->env, "You regain your senses.\n");
215	}
216		175
217	default:	176	default:
218	if (op->env != NULL)	177	op->clr_flag (FLAG_APPLIED);
219	{
220	CLEAR_FLAG (op, FLAG_APPLIED);
221	change_abil (op->env, op);	178	change_abil (op->env, op);
222	fix_player (op->env);	179	op->env->update_stats ();
223	}
224	}	180	}
225		181
226	op->destroy ();	182	op->destroy ();
227	}	183	}
228		184
229	void	185	static void
230	remove_blindness (object *op)	186	remove_blindness (object *op)
231	{	187	{
232	if (--op->stats.food > 0)	188	if (--op->stats.food > 0)
233	return;	189	return;
234		190
235	CLEAR_FLAG (op, FLAG_APPLIED);	191	op->clr_flag (FLAG_APPLIED);
236		192
237	if (op->env != NULL)	193	if (op->env)
238	{	194	{
239	change_abil (op->env, op);	195	change_abil (op->env, op);
240	fix_player (op->env);	196	op->env->update_stats ();
241	}	197	}
242		198
243	op->destroy ();	199	op->destroy ();
244	}	200	}
245		201
246	void	202	static void
247	poison_more (object *op)	203	poison_more (object *op)
248	{	204	{
249	if (op->env == NULL || !QUERY_FLAG (op->env, FLAG_ALIVE) || op->env->stats.hp < 0)	205	if (op->env == NULL || !op->env->flag [FLAG_ALIVE] || op->env->stats.hp < 0)
250	{	206	{
251	op->destroy ();	207	op->destroy ();
252	return;	208	return;
253	}	209	}
254		210
255	if (op->stats.food == 1)	211	if (op->stats.food == 1)
256	{	212	{
257	/* need to remove the object before fix_player is called, else fix_player	213	/* need to unapply the object before update_stats is called, else fix_player
258	* will not do anything.	214	* will not do anything.
259	*/	215	*/
260	if (op->env->type == PLAYER)	216	if (op->env->type == PLAYER)
261	{	217	{
262	CLEAR_FLAG (op, FLAG_APPLIED);	218	op->clr_flag (FLAG_APPLIED);
263	fix_player (op->env);	219	op->env->update_stats ();
264	new_draw_info (NDI_UNIQUE, 0, op->env, "You feel much better now.");	220	new_draw_info (NDI_UNIQUE, 0, op->env, "You feel much better now.");
265	}	221	}
266		222
267	op->destroy ();	223	op->destroy ();
268	return;	224	return;
…		…
271	if (op->env->type == PLAYER)	227	if (op->env->type == PLAYER)
272	{	228	{
273	op->env->stats.food--;	229	op->env->stats.food--;
274	new_draw_info (NDI_UNIQUE, 0, op->env, "You feel very sick...");	230	new_draw_info (NDI_UNIQUE, 0, op->env, "You feel very sick...");
275	}	231	}
		232
276	(void) hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1);	233	hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1);
277	}	234	}
278		235
279		236
280	void	237	static void
281	move_gate (object *op)	238	move_gate (object *op)
282	{ /* 1 = going down, 0 = goind up */	239	{ /* 1 = going down, 0 = going up */
283	object *tmp;	240	object *tmp;
284		241
285	if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op))	242	if (op->stats.wc < 0 || (int) op->stats.wc >= NUM_ANIMATIONS (op))
286	{	243	{
287	LOG (llevError, "Gate error: animation was %d, max=%d\n", op->stats.wc, NUM_ANIMATIONS (op));	244	LOG (llevError, "%s: gate error: animation was %d, max=%d\n", op->debug_desc (), op->stats.wc, NUM_ANIMATIONS (op));
288	op->stats.wc = 0;	245	op->stats.wc = 0;
289	}	246	}
290		247
291	/* We're going down */	248	/* We're going down */
292	if (op->value)	249	if (op->value)
293	{	250	{
294	if (--op->stats.wc <= 0)	251	if (--op->stats.wc <= 0)
295	{ /* Reached bottom, let's stop */	252	{ /* Reached bottom, let's stop */
296	op->stats.wc = 0;	253	op->stats.wc = 0;
297	if (op->arch->clone.speed)	254	if (op->arch->has_active_speed ())
298	op->value = 0;	255	op->value = 0;
299	else	256	else
300	{
301	op->speed = 0;	257	op->set_speed (0);
302	update_ob_speed (op);
303	}	258	}
304	}	259
305	if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1))	260	if ((int) op->stats.wc < (NUM_ANIMATIONS (op) / 2 + 1))
306	{	261	{
307	op->move_block = 0;	262	op->move_block = 0;
308	CLEAR_FLAG (op, FLAG_BLOCKSVIEW);	263	op->clr_flag (FLAG_BLOCKSVIEW);
309	update_all_los (op->map, op->x, op->y);	264	update_all_los (op->map, op->x, op->y);
310	}	265	}
		266
311	SET_ANIMATION (op, op->stats.wc);	267	SET_ANIMATION (op, op->stats.wc);
312	update_object (op, UP_OBJ_CHANGE);	268	update_object (op, UP_OBJ_CHANGE);
313	return;	269	return;
314	}	270	}
315		271
316	/* We're going up */	272	/* We're going up */
317		273
318	/* First, lets see if we are already at the top */	274	/* First, lets see if we are already at the top */
319	if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))	275	if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))
320	{	276	{
321
322	/* Check to make sure that only non pickable and non rollable	277	/* Check to make sure that only non pickable and non rollable
323	* 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,
324	* otherwise, we fall through to the code below which should lower	279	* otherwise, we fall through to the code below which should lower
325	* the gate slightly.	280	* the gate slightly.
326	*/	281	*/
327		282
328	for (tmp = op->above; tmp != NULL; tmp = tmp->above)	283	for (tmp = op->above; tmp; tmp = tmp->above)
329	if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE))	284	if (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL] || tmp->flag [FLAG_ALIVE])
330	break;	285	break;
331		286
332	if (tmp == NULL)	287	if (!tmp)
333	{	288	{
334	if (op->arch->clone.speed)	289	if (op->arch->has_active_speed ())
335	op->value = 1;	290	op->value = 1;
336	else	291	else
337	{
338	op->speed = 0;	292	op->set_speed (0);
339	update_ob_speed (op); /* Reached top, let's stop */	293
340	}
341	return;	294	return;
342	}	295	}
343	}	296	}
344		297
345	if (op->stats.food)	298	if (op->stats.food)
…		…
352	}	305	}
353	else	306	else
354	{ /* The gate is still going up */	307	{ /* The gate is still going up */
355	op->stats.wc++;	308	op->stats.wc++;
356		309
357	if ((int) op->stats.wc >= (NUM_ANIMATIONS (op)))	310	if (op->stats.wc >= NUM_ANIMATIONS (op))
358	op->stats.wc = (signed char) NUM_ANIMATIONS (op) - 1;	311	op->stats.wc = NUM_ANIMATIONS (op) - 1;
359		312
360	/* 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.
361	* 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
362	*/	315	*/
363	if ((int) op->stats.wc >= NUM_ANIMATIONS (op) / 2)	316	if (op->stats.wc >= NUM_ANIMATIONS (op) / 2)
364	{	317	{
365	/* Halfway or further, check blocks */	318	/* Halfway or further, check blocks */
366	/* First, get the top object on the square. */	319	/* First, get the top object on the square. */
367	for (tmp = op->above; tmp != NULL && tmp->above != NULL; tmp = tmp->above);	320	for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)
368
369	if (tmp != NULL)
370	{	321	;
371	if (QUERY_FLAG (tmp, FLAG_ALIVE))	322
		323	if (tmp)
		324	{
		325	if (tmp->flag [FLAG_ALIVE])
372	{	326	{
373	hit_player (tmp, random_roll (1, 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"));
		329
374	if (tmp->type == PLAYER)	330	if (tmp->type == PLAYER)
375	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);
376	}	332	}
377	else
378	/* If the object is not alive, and the object either can	333	/* If the object is not alive, and the object either can
379	* be picked up or the object rolls, move the object	334	* be picked up or the object rolls, move the object
380	* off the gate.	335	* off the gate.
381	*/	336	*/
382	if (!QUERY_FLAG (tmp, FLAG_ALIVE) && (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL)))	337	else if (!tmp->flag [FLAG_ALIVE] && (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL]))
383	{	338	{
384	/* If it has speed, it should move itself, otherwise: */	339	/* If it has speed, it should move itself, otherwise: */
385	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);
386		341
387	/* If there is a free spot, move the object someplace */	342	/* If there is a free spot, move the object someplace */
388	if (i != -1)	343	if (i > 0)
389	{	344	{
		345	mapxy pos (tmp);
		346	pos.move (i);
		347	if (pos.normalise ())
390	tmp->remove ();	348	tmp->move_to (pos);
391	tmp->x += freearr_x[i], tmp->y += freearr_y[i];
392	insert_ob_in_map (tmp, op->map, op, 0);
393	}	349	}
394	}	350	}
395	}	351	}
396		352
397	/* See if there is still anything blocking the gate */	353	/* See if there is still anything blocking the gate */
398	for (tmp = op->above; tmp != NULL; tmp = tmp->above)	354	for (tmp = op->above; tmp; tmp = tmp->above)
399	if (!QUERY_FLAG (tmp, FLAG_NO_PICK) || QUERY_FLAG (tmp, FLAG_CAN_ROLL) || QUERY_FLAG (tmp, FLAG_ALIVE))	355	if (!tmp->flag [FLAG_NO_PICK] || tmp->flag [FLAG_CAN_ROLL] || tmp->flag [FLAG_ALIVE])
400	break;	356	break;
401		357
402	/* IF there is, start putting the gate down */	358	/* IF there is, start putting the gate down */
403	if (tmp)	359	if (tmp)
404	{
405	op->stats.food = 1;	360	op->stats.food = 1;
406	}
407	else	361	else
408	{	362	{
409	op->move_block = MOVE_ALL;	363	op->move_block = MOVE_ALL;
		364
410	if (!op->arch->clone.stats.ac)	365	if (!op->arch->stats.ac)
411	SET_FLAG (op, FLAG_BLOCKSVIEW);	366	op->set_flag (FLAG_BLOCKSVIEW);
412	update_all_los (op->map, op->x, op->y);	367	update_all_los (op->map, op->x, op->y);
413	}	368	}
414	} /* gate is halfway up */	369	} /* gate is halfway up */
415		370
416	SET_ANIMATION (op, op->stats.wc);	371	SET_ANIMATION (op, op->stats.wc);
…		…
420		375
421	/* hp : how long door is open/closed	376	/* hp : how long door is open/closed
422	* maxhp : initial value for hp	377	* maxhp : initial value for hp
423	* sp : 1 = open, 0 = close	378	* sp : 1 = open, 0 = close
424	*/	379	*/
425	void	380	static void
426	move_timed_gate (object *op)	381	move_timed_gate (object *op)
427	{	382	{
428	int v = op->value;	383	int v = op->value;
429		384
430	if (op->stats.sp)	385	if (op->stats.sp)
431	{	386	{
432	move_gate (op);	387	move_gate (op);
		388
433	if (op->value != v) /* change direction ? */	389	if (op->value != v) /* change direction ? */
434	op->stats.sp = 0;	390	op->stats.sp = 0;
435	return;	391	return;
436	}	392	}
		393
437	if (--op->stats.hp <= 0)	394	if (--op->stats.hp <= 0)
438	{ /* keep gate down */	395	{ /* keep gate down */
439	move_gate (op);	396	move_gate (op);
		397
440	if (op->value != v)	398	if (op->value != v)
441	{ /* ready ? */
442	op->speed = 0;	399	op->set_speed (0);
443	update_ob_speed (op);
444	}
445	}	400	}
446	}	401	}
447		402
448	/* slaying: name of the thing the detector is to look for	403	/* slaying: name of the thing the detector is to look for
449	* speed: frequency of 'glances'	404	* speed: frequency of 'glances'
450	* connected: connected value of detector	405	* connected: connected value of detector
451	* sp: 1 if detection sets buttons	406	* sp: 1 if detection sets buttons
452	* -1 if detection unsets buttons	407	* -1 if detection unsets buttons
453	*/	408	*/
454		409	static void
455	void
456	move_detector (object *op)	410	move_detector (object *op)
457	{	411	{
458	object *tmp;	412	object *tmp;
459	int last = op->value;	413	int last = op->value;
460	int detected;	414	int detected;
461		415
462	detected = 0;	416	detected = 0;
463		417
464	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL && !detected; tmp = tmp->above)	418	for (tmp = op->ms ().bot; tmp && !detected; tmp = tmp->above)
465	{	419	{
466	object *tmp2;	420	object *tmp2;
467		421
468	if (op->stats.hp)	422	if (op->stats.hp)
469	{	423	{
470	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)	424	for (tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
471	{	425	{
472	if (op->slaying && !strcmp (op->slaying, tmp->name))	426	if (op->slaying && op->slaying == tmp->name)
473	detected = 1;	427	detected = 1;
		428
474	if (tmp2->type == FORCE && tmp2->slaying && !strcmp (tmp2->slaying, op->slaying))	429	if (tmp2->type == FORCE && tmp2->slaying && tmp2->slaying == op->slaying)
475	detected = 1;	430	detected = 1;
476	}	431	}
477	}	432	}
		433
478	if (op->slaying && !strcmp (op->slaying, tmp->name))	434	if (op->slaying && op->slaying == tmp->name)
479	{
480	detected = 1;	435	detected = 1;
481	}
482	else if (tmp->type == SPECIAL_KEY && tmp->slaying == op->slaying)	436	else if (tmp->type == SPECIAL_KEY && tmp->slaying == op->slaying)
483	detected = 1;	437	detected = 1;
484	}	438	}
485		439
486	/* the detector sets the button if detection is found */	440	/* the detector sets the button if detection is found */
487	if (op->stats.sp == 1)	441	if (op->stats.sp == 1)
488	{	442	{
489	if (detected && last == 0)	443	if (detected && last == 0)
490	{	444	{
491	op->value = 1;	445	op->value = 1;
492	push_button (op);	446	push_button (op, tmp);
493	}	447	}
		448
494	if (!detected && last == 1)	449	if (!detected && last == 1)
495	{	450	{
496	op->value = 0;	451	op->value = 0;
497	push_button (op);	452	push_button (op, tmp);
498	}	453	}
499	}	454	}
500	else	455	else
501	{ /* in this case, we unset buttons */	456	{ /* in this case, we unset buttons */
502	if (detected && last == 1)	457	if (detected && last == 1)
503	{	458	{
504	op->value = 0;	459	op->value = 0;
505	push_button (op);	460	push_button (op, tmp);
506	}	461	}
		462
507	if (!detected && last == 0)	463	if (!detected && last == 0)
508	{	464	{
509	op->value = 1;	465	op->value = 1;
510	push_button (op);	466	push_button (op, tmp);
511	}	467	}
512	}	468	}
513	}	469	}
514
515		470
516	void	471	void
517	animate_trigger (object *op)	472	animate_trigger (object *op)
518	{	473	{
519	if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op))	474	if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op))
…		…
526	SET_ANIMATION (op, op->stats.wc);	481	SET_ANIMATION (op, op->stats.wc);
527	update_object (op, UP_OBJ_FACE);	482	update_object (op, UP_OBJ_FACE);
528	}	483	}
529	}	484	}
530		485
531	void	486	static void
532	move_hole (object *op)	487	move_hole (object *op)
533	{ /* 1 = opening, 0 = closing */	488	{ /* 1 = opening, 0 = closing */
534	object *next, *tmp;
535
536	if (op->value)	489	if (op->value)
537	{ /* We're opening */	490	{ /* We're opening */
538	if (--op->stats.wc <= 0)	491	if (--op->stats.wc <= 0)
539	{ /* Opened, let's stop */	492	{ /* Opened, let's stop */
540	op->stats.wc = 0;	493	op->stats.wc = 0;
541	op->speed = 0;	494	op->set_speed (0);
542	update_ob_speed (op);
543		495
544	/* Hard coding this makes sense for holes I suppose */	496	/* Hard coding this makes sense for holes I suppose */
545	op->move_on = MOVE_WALK;	497	op->move_on = MOVE_WALK;
546	for (tmp = op->above; tmp != NULL; tmp = next)	498	for (object *next, *tmp = op->above; tmp; tmp = next)
547	{	499	{
548	next = tmp->above;	500	next = tmp->above;
549	move_apply (op, tmp, tmp);	501	move_apply (op, tmp, tmp);
550	}	502	}
551	}	503	}
		504
552	SET_ANIMATION (op, op->stats.wc);	505	SET_ANIMATION (op, op->stats.wc);
553	update_object (op, UP_OBJ_FACE);	506	update_object (op, UP_OBJ_CHANGE);
554	return;	507	return;
555	}	508	}
		509
556	/* We're closing */	510	/* We're closing */
557	op->move_on = 0;	511	op->move_on = 0;
558		512
559	op->stats.wc++;	513	op->stats.wc++;
560	if ((int) op->stats.wc >= NUM_ANIMATIONS (op))	514	if (op->stats.wc >= NUM_ANIMATIONS (op))
561	op->stats.wc = NUM_ANIMATIONS (op) - 1;	515	op->stats.wc = NUM_ANIMATIONS (op) - 1;
		516
562	SET_ANIMATION (op, op->stats.wc);	517	SET_ANIMATION (op, op->stats.wc);
563	update_object (op, UP_OBJ_FACE);	518	update_object (op, UP_OBJ_CHANGE);
564	if ((unsigned char) op->stats.wc == (NUM_ANIMATIONS (op) - 1))	519	if (op->stats.wc == (NUM_ANIMATIONS (op) - 1))
565	{
566	op->speed = 0;
567	update_ob_speed (op); /* closed, let's stop */	520	op->set_speed (0); /* closed, let's stop */
568	return;
569	}
570	}	521	}
571		522
572		523
573	/* stop_item() returns a pointer to the stopped object. The stopped object	524	/* stop_item() returns a pointer to the stopped object. The stopped object
574	* may or may not have been removed from maps or inventories. It will not	525	* may or may not have been removed from maps or inventories. It will not
…		…
594	{	545	{
595	object *payload = op->inv;	546	object *payload = op->inv;
596		547
597	if (payload == NULL)	548	if (payload == NULL)
598	return NULL;	549	return NULL;
		550
599	payload->remove ();	551	payload->remove ();
600	op->destroy ();	552	op->destroy ();
601	return payload;	553	return payload;
602	}	554	}
603		555
604	case ARROW:	556	case ARROW:
605	if (op->speed >= MIN_ACTIVE_SPEED)	557	if (op->has_active_speed ())
606	op = fix_stopped_arrow (op);	558	op = fix_stopped_arrow (op);
607	return op;	559	return op;
608		560
609	default:	561	default:
610	return op;	562	return op;
…		…
619	void	571	void
620	fix_stopped_item (object *op, maptile *map, object *originator)	572	fix_stopped_item (object *op, maptile *map, object *originator)
621	{	573	{
622	if (map == NULL)	574	if (map == NULL)
623	return;	575	return;
624	if (QUERY_FLAG (op, FLAG_REMOVED))	576
		577	if (op->flag [FLAG_REMOVED])
625	insert_ob_in_map (op, map, originator, 0);	578	insert_ob_in_map (op, map, originator, 0);
626	else if (op->type == ARROW)	579	else if (op->type == ARROW)
627	merge_ob (op, NULL); /* only some arrows actually need this */	580	merge_ob (op, NULL); /* only some arrows actually need this */
628	}	581	}
629		582
630
631	object *	583	object *
632	fix_stopped_arrow (object *op)	584	fix_stopped_arrow (object *op)
633	{	585	{
634	if (rndm (0, 99) < op->stats.food)	586	if (rndm (0, 99) < op->stats.food)
635	{	587	{
636	/* Small chance of breaking */	588	/* Small chance of breaking */
637	op->destroy ();	589	op->destroy ();
638	return NULL;	590	return NULL;
639	}	591	}
640		592
		593	op->set_speed (0);
641	op->direction = 0;	594	op->direction = 0;
642	op->move_on = 0;	595	op->move_on = 0;
643	op->move_type = 0;	596	op->move_type = 0;
644	op->speed = 0;	597	op->skill = 0; // really?
645	update_ob_speed (op);	598
		599	// restore original wc, dam, attacktype and slaying
646	op->stats.wc = op->stats.sp;	600	op->stats.wc = op->stats.sp;
647	op->stats.dam = op->stats.hp;	601	op->stats.dam = op->stats.hp;
648	op->attacktype = op->stats.grace;	602	op->attacktype = op->stats.grace;
649	op->slaying = 0;	603	op->slaying = op->custom_name;
650	op->skill = 0;
651		604
652	if (op->spellarg != NULL)
653	{
654	op->slaying = op->spellarg;
655	free (op->spellarg);
656	op->spellarg = NULL;
657	}
658	else
659	op->slaying = NULL;
660
661	/* Reset these to zero, so that object::can_merge will work properly */	605	/* Reset these to defaults, so that object::can_merge will work properly */
662	op->spellarg = NULL;	606	op->custom_name = 0;
663	op->stats.sp = 0;	607	op->stats.sp = 0;
664	op->stats.hp = 0;	608	op->stats.hp = 0;
665	op->stats.grace = 0;	609	op->stats.grace = 0;
666	op->level = 0;	610	op->level = 0;
667	op->face = op->arch->clone.face;	611	op->face = op->arch->face;
668	op->owner = NULL; /* So that stopped arrows will be saved */	612	op->owner = 0;
		613
669	update_object (op, UP_OBJ_FACE);	614	update_object (op, UP_OBJ_CHANGE);
		615
670	return op;	616	return op;
671	}	617	}
672		618
673	/* stop_arrow() - what to do when a non-living flying object	619	/* stop_arrow() - what to do when a non-living flying object
674	* has to stop. Sept 96 - I added in thrown object code in	620	* has to stop. Sept 96 - I added in thrown object code in
675	* here too. -b.t.	621	* here too. -b.t.
676	*	622	*
677	* Returns a pointer to the stopped object (which will have been removed	623	* Returns a pointer to the stopped object (which will have been removed
678	* from maps or inventories), or NULL if was destroyed.	624	* from maps or inventories), or NULL if was destroyed.
679	*/	625	*/
680
681	static void	626	static void
682	stop_arrow (object *op)	627	stop_arrow (object *op)
683	{	628	{
684	if (INVOKE_OBJECT (STOP, op))	629	if (INVOKE_OBJECT (STOP, op))
685	return;	630	return;
686		631
687	if (op->inv)	632	if (op->inv)
688	{	633	{
		634	// replace this by straightforward drop to ground?
689	object *payload = op->inv;	635	object *payload = op->inv;
690		636
691	payload->remove ();
692	payload->owner = 0;	637	payload->owner = 0;
693	insert_ob_in_map (payload, op->map, payload, 0);	638	insert_ob_in_map (payload, op->map, payload, 0);
694	op->destroy ();	639	op->destroy ();
695	}	640	}
696	else	641	else
697	{	642	{
698	op = fix_stopped_arrow (op);	643	op = fix_stopped_arrow (op);
		644
699	if (op)	645	if (op)
700	merge_ob (op, NULL);	646	merge_ob (op, 0);
701	}	647	}
702	}	648	}
703		649
704	/* Move an arrow along its course. op is the arrow or thrown object.	650	/* Move an arrow or throwen_obj along its course. op is the arrow or thrown object.
705	*/	651	*/
706
707	void	652	void
708	move_arrow (object *op)	653	move_arrow (object *op)
709	{	654	{
710	object *tmp;
711	sint16 new_x, new_y;
712	int was_reflected, mflags;	655	int was_reflected;
713	maptile *m;
714		656
715	if (op->map == NULL)	657	if (!op->map)
716	{	658	{
717	LOG (llevError, "BUG: Arrow had no map.\n");	659	LOG (llevError | logBacktrace, "BUG: Arrow %s had no map.\n", op->debug_desc ());
718	op->destroy ();	660	op->destroy ();
719	return;	661	return;
720	}	662	}
721		663
722	/* we need to stop thrown objects at some point. Like here. */	664	/* we need to stop thrown objects at some point. Like here. */
…		…
728	* is if the player throws a bomb - the bomb explodes on its own,	670	* is if the player throws a bomb - the bomb explodes on its own,
729	* but this object sticks around. We could handle the cleanup in the	671	* but this object sticks around. We could handle the cleanup in the
730	* bomb code, but there are potential other cases where that could happen,	672	* bomb code, but there are potential other cases where that could happen,
731	* and it is easy enough to clean it up here.	673	* and it is easy enough to clean it up here.
732	*/	674	*/
733	if (op->inv == NULL)	675	if (!op->inv)
734	{	676	{
735	op->destroy ();	677	op->destroy ();
736	return;	678	return;
737	}	679	}
738		680
…		…
741	stop_arrow (op);	683	stop_arrow (op);
742	return;	684	return;
743	}	685	}
744	}	686	}
745		687
		688	/* decrease the speed as it flies. 0.05 means a standard bow will shoot
		689	* about 17 squares. Tune as needed.
		690	*/
		691	op->set_speed (op->speed - 0.05);
		692
746	/* if the arrow is moving too slow.. stop it. 0.5 was chosen as lower	693	/* if the arrow is moving too slow.. stop it. 0.5 was chosen as lower
747	values look rediculous. */	694	values look rediculous. */
748	if (op->speed < 0.5 && op->type == ARROW)	695	if (op->speed < (op->type == ARROW ? 0.5 : MIN_ACTIVE_SPEED))
749	{	696	{
750	stop_arrow (op);	697	stop_arrow (op);
751	return;	698	return;
752	}	699	}
753		700
754	/* Calculate target map square */	701	/* Calculate target map square */
755	new_x = op->x + DIRX (op);
756	new_y = op->y + DIRY (op);
757	was_reflected = 0;	702	was_reflected = 0;
758		703
759	m = op->map;	704	mapxy pos (op); pos.move (op->direction);
760	mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
761		705
762	if (mflags & P_OUT_OF_MAP)	706	if (!pos.normalise ())
763	{	707	{
764	stop_arrow (op);	708	stop_arrow (op);
765	return;	709	return;
766	}	710	}
767		711
768	/* only need to look for living creatures if this flag is set */	712	/* only need to look for living creatures if this flag is set */
769	if (mflags & P_IS_ALIVE)	713	if (pos->flags () & P_IS_ALIVE)
770	{	714	{
771	for (tmp = GET_MAP_OB (m, new_x, new_y); tmp != NULL; tmp = tmp->above)	715	object *tmp;
772	if (QUERY_FLAG (tmp, FLAG_ALIVE))	716
		717	for (tmp = pos->bot; tmp; tmp = tmp->above)
		718	if (tmp->flag [FLAG_ALIVE])
773	break;	719	break;
774		720
775	/* Not really fair, but don't let monsters hit themselves with	721	/* Not really fair, but don't let monsters hit themselves with
776	* their own arrow - this can be because they fire it then	722	* their own arrow - this can be because they fire it then
777	* move into it.	723	* move into it.
…		…
780	{	726	{
781	/* Found living object, but it is reflecting the missile. Update	727	/* Found living object, but it is reflecting the missile. Update
782	* as below. (Note that for living creatures there is a small	728	* as below. (Note that for living creatures there is a small
783	* chance that reflect_missile fails.)	729	* chance that reflect_missile fails.)
784	*/	730	*/
785	if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE) && (rndm (0, 99)) < (90 - op->level / 10))	731	if (tmp->flag [FLAG_REFL_MISSILE] && (rndm (0, 99)) < (90 - op->level / 10))
786	{	732	{
787	int number = op->face->number;
788
789	op->direction = absdir (op->direction + 4);	733	op->direction = absdir (op->direction + 4);
790	op->state = 0;	734	update_turn_face (op);
791
792	if (GET_ANIM_ID (op))
793	{
794	number += 4;
795
796	if (number > GET_ANIMATION (op, 8))
797	number -= 8;
798
799	op->face = &new_faces[number];
800	}
801
802	was_reflected = 1; /* skip normal movement calculations */	735	was_reflected = 1; /* skip normal movement calculations */
803	}	736	}
804	else	737	else
805	{	738	{
806	/* Attack the object. */	739	/* Attack the object. */
…		…
810	return;	743	return;
811	}	744	}
812	} /* if this is not hitting its owner */	745	} /* if this is not hitting its owner */
813	} /* if there is something alive on this space */	746	} /* if there is something alive on this space */
814		747
815	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))	748	if (OB_TYPE_MOVE_BLOCK (op, pos->move_block))
816	{	749	{
817	int retry = 0;	750	int retry = 0;
818		751
819	/* if the object doesn't reflect, stop the arrow from moving	752	/* if the object doesn't reflect, stop the arrow from moving
820	* note that this code will now catch cases where a monster is	753	* note that this code will now catch cases where a monster is
821	* on a wall but has reflecting - the arrow won't reflect.	754	* on a wall but has reflecting - the arrow won't reflect.
822	* Mapmakers shouldn't put monsters on top of wall in the first	755	* Mapmakers shouldn't put monsters on top of wall in the first
823	* place, so I don't consider that a problem.	756	* place, so I don't consider that a problem.
824	*/	757	*/
825	if (!QUERY_FLAG (op, FLAG_REFLECTING) || !(rndm (0, 19)))	758	if (!op->flag [FLAG_REFLECTING] || !rndm (0, 19))
826	{	759	{
827	stop_arrow (op);	760	stop_arrow (op);
828	return;	761	return;
829	}	762	}
830	else	763	else
…		…
833	if (op->direction & 1)	766	if (op->direction & 1)
834	{	767	{
835	op->direction = absdir (op->direction + 4);	768	op->direction = absdir (op->direction + 4);
836	retry = 1;	769	retry = 1;
837	}	770	}
		771
838	/* There were two blocks with identical code -	772	/* There were two blocks with identical code -
839	* use this retry here to make this one block	773	* use this retry here to make this one block
840	* that did the same thing.	774	* that did the same thing.
841	*/	775	*/
842	while (retry < 2)	776	while (retry < 2)
843	{	777	{
844	int left, right, mflags;
845	maptile *m1;
846	sint16 x1, y1;
847
848	retry++;	778	retry++;
849		779
850	/* Need to check for P_OUT_OF_MAP: if the arrow is tavelling	780	/* Need to check for P_OUT_OF_MAP: if the arrow is travelling
851	* over a corner in a tiled map, it is possible that	781	* over a corner in a tiled map, it is possible that
852	* op->direction is within an adjacent map but either	782	* op->direction is within an adjacent map but either
853	* op->direction-1 or op->direction+1 does not exist.	783	* op->direction-1 or op->direction+1 does not exist.
854	*/	784	*/
855	mflags = get_map_flags (op->map, &m1, op->x + freearr_x[absdir (op->direction - 1)],	785	mapxy pos1 (pos); pos1.move (absdir (op->direction - 1));
856	op->y + freearr_y[absdir (op->direction - 1)], &x1, &y1);	786	bool left = pos1.normalise () && OB_TYPE_MOVE_BLOCK (op, pos1->move_block);
857	left = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, (GET_MAP_MOVE_BLOCK (m1, x1, y1)));
858		787
859	mflags = get_map_flags (op->map, &m1, op->x + freearr_x[absdir (op->direction + 1)],	788	mapxy pos2 (pos); pos2.move (absdir (op->direction + 1));
860	op->y + freearr_y[absdir (op->direction + 1)], &x1, &y1);	789	bool right = pos2.normalise () && OB_TYPE_MOVE_BLOCK (op, pos2->move_block);
861	right = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, (GET_MAP_MOVE_BLOCK (m1, x1, y1)));
862		790
863	if (left == right)	791	if (left == right)
864	op->direction = absdir (op->direction + 4);	792	op->direction = absdir (op->direction + 4);
865	else if (left)	793	else if (left)
866	op->direction = absdir (op->direction + 2);	794	op->direction = absdir (op->direction + 2);
867	else if (right)	795	else if (right)
868	op->direction = absdir (op->direction - 2);	796	op->direction = absdir (op->direction - 2);
869		797
870	mflags = get_map_flags (op->map, &m1, op->x + DIRX (op), op->y + DIRY (op), &x1, &y1);
871
872	/* If this space is not out of the map and not blocked, valid space -	798	/* If this space is not out of the map and not blocked, valid space -
873	* don't need to retry again.	799	* don't need to retry again.
874	*/	800	*/
875	if (!(mflags & P_OUT_OF_MAP) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m1, x1, y1)))	801	mapxy pos3 (pos); pos3.move (op->direction);
		802	if (pos3.normalise () && !OB_TYPE_MOVE_BLOCK (op, pos3->move_block))
876	break;	803	break;
877
878	}	804	}
		805
879	/* Couldn't find a direction to move the arrow to - just	806	/* Couldn't find a direction to move the arrow to - just
880	* top it from moving.	807	* stop it from moving.
881	*/	808	*/
882	if (retry == 2)	809	if (retry == 2)
883	{	810	{
884	stop_arrow (op);	811	stop_arrow (op);
885	return;	812	return;
886	}	813	}
		814
887	/* update object image for new facing */	815	/* update object image for new facing */
888	/* many thrown objects *don't* have more than one face */	816	/* many thrown objects *don't* have more than one face */
889	if (GET_ANIM_ID (op))	817	if (op->has_anim ())
890	SET_ANIMATION (op, op->direction);	818	op->set_anim_frame (op->direction);
891	} /* object is reflected */	819	} /* object is reflected */
892	} /* object ran into a wall */	820	} /* object ran into a wall */
893		821
894	/* Move the arrow. */	822	/* Move the arrow. */
895	op->remove ();	823	op->move_to (pos);
896	op->x = new_x;
897	op->y = new_y;
898
899	/* decrease the speed as it flies. 0.05 means a standard bow will shoot
900	* about 17 squares. Tune as needed.
901	*/
902	op->speed -= 0.05;
903	insert_ob_in_map (op, m, op, 0);
904	}	824	}
905		825
906	/* This routine doesnt seem to work for "inanimate" objects that	826	static void
907	* are being carried, ie a held torch leaps from your hands!.
908	* Modified this routine to allow held objects. b.t. */
909
910	void
911	change_object (object *op)	827	change_object (object *op)
912	{ /* Doesn`t handle linked objs yet */	828	{ /* Doesn`t handle linked objs yet */
913	int i, j;
914
915	if (op->other_arch == NULL)	829	if (!op->other_arch)
916	{	830	{
917	LOG (llevError, "Change object (%s) without other_arch error.\n", &op->name);	831	LOG (llevError, "Change object (%s) without other_arch error.\n", op->debug_desc ());
918	return;	832	return;
919	}	833	}
920		834
921	/* In non-living items only change when food value is 0 */	835	/* In non-living items only change when food value is 0 */
922	if (!QUERY_FLAG (op, FLAG_ALIVE))	836	if (!op->flag [FLAG_ALIVE])
923	{	837	{
924	if (op->stats.food-- > 0)	838	if (op->stats.food-- > 0)
925	return;	839	return;
		840
		841	op->stats.food = 1; /* so 1 other_arch is made */
		842	}
		843
		844	object *env = op->env;
		845
		846	op->remove ();
		847	for (int i = 0; i < op->stats.food; i++)
		848	{
		849	object *tmp = op->other_arch->instance ();
		850
		851	tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
		852
		853	if (env)
		854	env->insert (tmp);
926	else	855	else
927	op->stats.food = 1; /* so 1 other_arch is made */
928	}
929
930	object *pl = op->in_player ();
931	object *env = op->env;
932
933	op->remove ();
934	for (i = 0; i < NROFNEWOBJS (op); i++)
935	{
936	object *tmp = arch_to_object (op->other_arch);
937
938	if (op->type == LAMP)
939	tmp->stats.food = op->stats.food - 1;
940
941	tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
942	if (env)
943	{
944	tmp->x = env->x, tmp->y = env->y;
945	tmp = insert_ob_in_ob (tmp, env);
946
947	/* If this object is the players inventory, we need to tell the
948	* client of the change. Insert_ob_in_map takes care of the
949	* updating the client, so we don't need to do that below.
950	*/
951	if (pl)
952	{
953	esrv_del_item (pl->contr, op->count);
954	esrv_send_item (pl, tmp);
955	}
956	}	856	{
957	else
958	{
959	j = find_first_free_spot (tmp, op->map, op->x, op->y);	857	int j = find_first_free_spot (tmp, op->map, op->x, op->y);
		858
960	if (j == -1) /* No free spot */	859	if (j < 0) /* No free spot */
961	tmp->destroy ();	860	tmp->destroy ();
962	else	861	else
963	{	862	{
964	tmp->x = op->x + freearr_x[j], tmp->y = op->y + freearr_y[j];	863	mapxy pos (op); pos.move (j);
965	insert_ob_in_map (tmp, op->map, op, 0);	864
		865	if (pos.normalise ())
		866	pos.insert (tmp, op);
966	}	867	}
967	}	868	}
968	}	869	}
969		870
970	op->destroy ();	871	op->destroy ();
…		…
980	* there is an old multipart teleporter in which the other parts	881	* there is an old multipart teleporter in which the other parts
981	* have speed, we don't really want to call it twice for the same	882	* have speed, we don't really want to call it twice for the same
982	* function - in fact, as written below, part N would get called	883	* function - in fact, as written below, part N would get called
983	* N times without the speed check.	884	* N times without the speed check.
984	*/	885	*/
985	if (op->more && FABS (op->more->speed) < MIN_ACTIVE_SPEED)	886	if (op->more && !op->more->has_active_speed ())
986	move_teleporter (op->more);	887	move_teleporter (op->more);
987		888
988	if (op->head)	889	if (op->head)
989	head = op->head;	890	head = op->head;
990		891
991	for (tmp = op->above; tmp != NULL; tmp = tmp->above)	892	for (tmp = op->above; tmp; tmp = tmp->above)
992	if (!QUERY_FLAG (tmp, FLAG_IS_FLOOR))	893	if (!tmp->flag [FLAG_IS_FLOOR])
993	break;	894	break;
994		895
995	/* If nothing above us to move, nothing to do */	896	/* If nothing above us to move, nothing to do */
996	if (!tmp || QUERY_FLAG (tmp, FLAG_WIZPASS))	897	if (!tmp || tmp->flag [FLAG_WIZPASS])
997	return;	898	return;
998		899
999	if (EXIT_PATH (head))	900	if (EXIT_PATH (head))
1000	{	901	{
1001	if (tmp->type == PLAYER)	902	if (tmp->type == PLAYER)
1002	{	903	{
1003	if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))	904	if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))
1004	return;	905	return;
1005		906
1006	enter_exit (tmp, head);	907	tmp->enter_exit (head);
1007	}	908	}
1008	else	909	else
1009	/* Currently only players can transfer maps */	910	/* Currently only players can transfer maps */
1010	return;	911	return;
1011	}	912	}
…		…
1026	else	927	else
1027	{	928	{
1028	/* Random teleporter */	929	/* Random teleporter */
1029	if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))	930	if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))
1030	return;	931	return;
		932
1031	teleport (head, TELEPORTER, tmp);	933	teleport (head, TELEPORTER, tmp);
1032	}	934	}
1033	}	935	}
1034
1035		936
1036	/* This object will teleport someone to a different map	937	/* This object will teleport someone to a different map
1037	and will also apply changes to the player from its inventory.	938	and will also apply changes to the player from its inventory.
1038	This was invented for giving classes, but there's no reason it	939	This was invented for giving classes, but there's no reason it
1039	can't be generalized.	940	can't be generalized.
1040	*/	941	*/
1041		942	static void
1042	void
1043	move_player_changer (object *op)	943	move_player_changer (object *op)
1044	{	944	{
1045	object *player;
1046	object *walk;
1047	char c;
1048
1049	if (!op->above || !EXIT_PATH (op))	945	if (!op->above || !EXIT_PATH (op))
1050	return;	946	return;
1051		947
1052	/* This isn't all that great - means that the player_mover	948	/* This isn't all that great - means that the player_mover
1053	* needs to be on top.	949	* needs to be on top.
1054	*/	950	*/
1055	if (op->above->type == PLAYER)	951	if (op->above->type == PLAYER)
1056	{	952	{
		953	object *player = op->above;
		954
1057	if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player)))	955	if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player)))
1058	return;	956	return;
1059	player = op->above;
1060		957
1061	for (walk = op->inv; walk != NULL; walk = walk->below)	958	for (object *walk = op->inv; walk; walk = walk->below)
1062	apply_changes_to_player (player, walk);	959	apply_changes_to_player (player, walk);
1063		960
1064	fix_player (player);	961	player->update_stats ();
1065		962
1066	esrv_send_inventory (op->above, op->above);	963	esrv_send_inventory (op->above, op->above);
1067	esrv_update_item (UPD_FACE, op->above, op->above);	964	esrv_update_item (UPD_FACE, op->above, op->above);
1068		965
1069	/* update players death & WoR home-position */	966	/* update players death & WoR home-position */
1070	sscanf (EXIT_PATH (op), "%c", &c);	967	if (*EXIT_PATH (op) == '/')
1071	if (c == '/')
1072	{	968	{
1073	strcpy (player->contr->savebed_map, EXIT_PATH (op));	969	player->contr->savebed_map = EXIT_PATH (op);
1074	player->contr->bed_x = EXIT_X (op);	970	player->contr->bed_x = EXIT_X (op);
1075	player->contr->bed_y = EXIT_Y (op);	971	player->contr->bed_y = EXIT_Y (op);
1076	}	972	}
1077	else	973	else
1078	LOG (llevDebug, "WARNING: destination '%s' in player_changer must be an absolute path!\n", &EXIT_PATH (op));	974	LOG (llevDebug, "WARNING: destination '%s' in player_changer must be an absolute path!\n", &EXIT_PATH (op));
1079		975
1080	enter_exit (op->above, op);	976	op->above->enter_exit (op);
1081	save_player (player, 1);
1082	}	977	}
1083	}	978	}
1084		979
1085	/* firewalls fire other spells.	980	/* firewalls fire other spells.
1086	* The direction of the wall is stored in op->stats.sp.	981	* The direction of the wall is stored in op->stats.sp.
…		…
1093		988
1094	if (!op->map)	989	if (!op->map)
1095	return; /* dm has created a firewall in his inventory */	990	return; /* dm has created a firewall in his inventory */
1096		991
1097	spell = op->inv;	992	spell = op->inv;
		993
1098	if (!spell || spell->type != SPELL)	994	if (!spell || spell->type != SPELL)
1099	spell = &op->other_arch->clone;	995	spell = op->other_arch;
		996
1100	if (!spell)	997	if (!spell)
1101	{	998	{
1102	LOG (llevError, "move_firewall: no spell specified (%s, %s, %d, %d)\n", &op->name, op->map->name, op->x, op->y);	999	LOG (llevError, "move_firewall: no spell specified (%s, %s, %d, %d)\n", &op->name, &op->map->name, op->x, op->y);
1103	return;	1000	return;
1104	}	1001	}
1105		1002
1106	cast_spell (op, op, op->stats.sp ? op->stats.sp : rndm (1, 8), spell, NULL);	1003	cast_spell (op, op, op->stats.sp ? op->stats.sp : rndm (1, 8), spell, NULL);
1107	}	1004	}
1108		1005
1109
1110	/* move_player_mover: this function takes a "player mover" as an	1006	/* move_player_mover: this function takes a "player mover" as an
1111	* argument, and performs the function of a player mover, which is:	1007	* argument, and performs the function of a player mover, which is:
1112	*	1008	*
1113	* a player mover finds any players that are sitting on it. It	1009	* a player mover finds any players that are sitting on it. It
1114	* moves them in the op->stats.sp direction. speed is how often it'll move.	1010	* moves them in the op->stats.sp direction. speed is how often it'll move.
1115	* If attacktype is nonzero it will paralyze the player. If lifesave is set,	1011	* If attacktype is nonzero it will paralyze the player. If lifesave is set,
1116	* it'll dissapear after hp+1 moves. If hp is set and attacktype is set,	1012	* it'll dissapear after hp+1 moves. If hp is set and attacktype is set,
1117	* it'll paralyze the victim for hp*his speed/op->speed	1013	* it'll paralyze the victim for hp*his speed/op->speed
1118	*/	1014	*/
1119	void	1015	static void
1120	move_player_mover (object *op)	1016	move_player_mover (object *op)
1121	{	1017	{
1122	object *victim, *nextmover;	1018	int dir = 0;
1123	int dir = op->stats.sp;
1124	sint16 nx, ny;
1125	maptile *m;
1126		1019
1127	/* Determine direction now for random movers so we do the right thing */	1020	for (object *victim = op->ms ().bot; victim; victim = victim->above)
1128	if (!dir)
1129	dir = rndm (1, 8);
1130
1131	for (victim = GET_MAP_OB (op->map, op->x, op->y); victim != NULL; victim = victim->above)
1132	{	1021	{
1133	if (QUERY_FLAG (victim, FLAG_ALIVE) && !QUERY_FLAG (victim, FLAG_WIZPASS) &&	1022	if (victim->flag [FLAG_ALIVE]
		1023	&& !victim->flag [FLAG_WIZPASS]
1134	(victim->move_type & op->move_type || !victim->move_type))	1024	&& (victim->move_type & op->move_type || !victim->move_type))
		1025	{
		1026	if (op->flag [FLAG_LIFESAVE] && op->stats.hp-- < 0)
1135	{	1027	{
		1028	op->destroy ();
		1029	return;
		1030	}
		1031
		1032	/* Determine direction only once so we do the right thing */
		1033	// why is it the right thing, though?
		1034	if (!dir)
		1035	dir = op->stats.sp ? op->stats.sp : rndm (1, 8);
		1036
		1037	sint16 nx = op->x + freearr_x[dir];
		1038	sint16 ny = op->y + freearr_y[dir];
		1039	maptile *m = op->map;
		1040	if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)
		1041	{
		1042	LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", &m->path, op->x, op->y);
		1043	return;
		1044	}
1136		1045
1137	if (victim->head)	1046	if (victim->head)
1138	victim = victim->head;	1047	victim = victim->head;
1139		1048
1140	if (QUERY_FLAG (op, FLAG_LIFESAVE) && op->stats.hp-- < 0)
1141	{
1142	op->remove ();
1143	return;
1144	}
1145
1146	nx = op->x + freearr_x[dir];
1147	ny = op->y + freearr_y[dir];
1148	m = op->map;
1149	if (get_map_flags (m, &m, nx, ny, &nx, &ny) & P_OUT_OF_MAP)
1150	{
1151	LOG (llevError, "move_player_mover: Trying to push player off the map! map=%s (%d, %d)\n", m->path, op->x, op->y);
1152	return;
1153	}
1154
1155	if (should_director_abort (op, victim))	1049	if (should_director_abort (op, victim))
1156	return;	1050	return;
1157		1051
1158	for (nextmover = GET_MAP_OB (m, nx, ny); nextmover != NULL; nextmover = nextmover->above)	1052	for (object *nextmover = m->at (nx, ny).bot; nextmover; nextmover = nextmover->above)
1159	{	1053	{
1160	if (nextmover->type == PLAYERMOVER)	1054	if (nextmover->type == PLAYERMOVER)
1161	nextmover->speed_left = -.99;	1055	nextmover->speed_left = -.99f;
		1056
1162	if (QUERY_FLAG (nextmover, FLAG_ALIVE))	1057	if (nextmover->flag [FLAG_ALIVE])
1163	{
1164	op->speed_left = -1.1; /* wait until the next thing gets out of the way */	1058	op->speed_left = -1.1f; /* wait until the next thing gets out of the way */
1165	}
1166	}	1059	}
1167		1060
1168	if (victim->type == PLAYER)	1061	if (victim->type == PLAYER)
1169	{	1062	{
1170	/* only level >=1 movers move people */	1063	/* only level >=1 movers move people */
1171	if (op->level)	1064	if (op->level)
1172	{	1065	{
1173	/* Following is a bit of hack. We need to make sure it	1066	/* Following is a bit of hack. We need to make sure it
1174	* is cleared, otherwise the player will get stuck in	1067	* is cleared, otherwise the player will get stuck in
1175	* place. This can happen if the player used a spell to	1068	* place. This can happen if the player used a spell to
1176	* get to this space.	1069	* get to this space.
1177	*/	1070	*/
1178	victim->contr->fire_on = 0;	1071	victim->contr->fire_on = 0;
1179	victim->speed_left = -FABS (victim->speed);	1072	victim->speed_left = 1.f;
1180	move_player (victim, dir);	1073	move_player (victim, dir);
1181	}	1074	}
1182	else	1075	else
1183	return;	1076	return;
1184	}	1077	}
1185	else	1078	else
1186	move_object (victim, dir);	1079	victim->move (dir);
1187		1080
1188	if (!op->stats.maxsp && op->attacktype)	1081	if (!op->stats.maxsp && op->attacktype)
1189	op->stats.maxsp = 2;	1082	op->stats.maxsp = 2;
1190		1083
1191	if (op->attacktype)	1084	if (op->attacktype)
1192	{ /* flag to paralyze the player */	1085	{ /* flag to paralyze the player */
1193
1194	victim->speed_left = -FABS (op->stats.maxsp * victim->speed / op->speed);	1086	victim->speed_left = max (-5.f, -op->stats.maxsp * victim->speed / op->speed);
1195	/* Not sure why, but for some chars on metalforge, they
1196	* would sometimes get -inf speed_left, and from the
1197	* description, it could only happen here, so just put
1198	* a lower sanity limit. My only guess is that the
1199	* mover has 0 speed.
1200	*/
1201	if (victim->speed_left < -5.0)
1202	victim->speed_left = -5.0;
1203	}	1087	}
1204	}	1088	}
1205	}	1089	}
1206	}	1090	}
1207		1091
…		…
1217	{	1101	{
1218	object *tmp;	1102	object *tmp;
1219		1103
1220	if (!op->other_arch)	1104	if (!op->other_arch)
1221	{	1105	{
1222	LOG (llevInfo, "Duplicator with no other_arch! %d %d %s\n", op->x, op->y, op->map ? op->map->path : "nullmap");	1106	LOG (llevInfo, "Duplicator with no other_arch! %d %d %s\n", op->x, op->y, op->map ? &op->map->path : "nullmap");
1223	return;	1107	return;
1224	}	1108	}
1225		1109
1226	if (op->above == NULL)	1110	if (op->above == NULL)
1227	return;	1111	return;
		1112
1228	for (tmp = op->above; tmp != NULL; tmp = tmp->above)	1113	for (tmp = op->above; tmp; tmp = tmp->above)
1229	{	1114	{
1230	if (strcmp (op->other_arch->name, tmp->arch->name) == 0)	1115	if (op->other_arch->archname == tmp->arch->archname)
1231	{	1116	{
1232	if (op->level <= 0)	1117	if (op->level <= 0)
1233	tmp->destroy ();	1118	tmp->destroy ();
1234	else	1119	else
1235	{	1120	{
…		…
1257	* has to make sure that there is in fact space for the object.	1142	* has to make sure that there is in fact space for the object.
1258	* It should really do this for small objects also, but there is	1143	* It should really do this for small objects also, but there is
1259	* more concern with large objects, most notably a part being placed	1144	* more concern with large objects, most notably a part being placed
1260	* outside of the map which would cause the server to crash	1145	* outside of the map which would cause the server to crash
1261	*/	1146	*/
1262
1263	void	1147	void
1264	move_creator (object *creator)	1148	move_creator (object *creator)
1265	{	1149	{
1266	object *new_ob;	1150	object *new_ob;
1267		1151
1268	if (!QUERY_FLAG (creator, FLAG_LIFESAVE) && --creator->stats.hp < 0)	1152	if (!creator->flag [FLAG_LIFESAVE] && --creator->stats.hp < 0)
1269	{	1153	{
1270	creator->stats.hp = -1;	1154	creator->stats.hp = -1;
1271	return;	1155	return;
1272	}	1156	}
1273		1157
1274	if (creator->inv != NULL)	1158	if (creator->inv)
1275	{	1159	{
1276	object *ob;	1160	object *ob;
1277	int i;	1161	int i;
1278	object *ob_to_copy;	1162	object *ob_to_copy;
1279		1163
1280	/* select random object from inventory to copy */	1164	/* select random object from inventory to copy */
1281	ob_to_copy = creator->inv;	1165	ob_to_copy = creator->inv;
1282	for (ob = creator->inv->below, i = 1; ob != NULL; ob = ob->below, i++)	1166	for (ob = creator->inv->below, i = 1; ob; ob = ob->below, i++)
1283	{	1167	{
1284	if (rndm (0, i) == 0)	1168	if (rndm (0, i) == 0)
1285	{	1169	{
1286	ob_to_copy = ob;	1170	ob_to_copy = ob;
1287	}	1171	}
1288	}	1172	}
1289	new_ob = object_create_clone (ob_to_copy);	1173
1290	CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE);	1174	new_ob = ob_to_copy->deep_clone ();
		1175	new_ob->clr_flag (FLAG_IS_A_TEMPLATE);
1291	unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);	1176	unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);
1292	}	1177	}
1293	else	1178	else
1294	{	1179	{
1295	if (creator->other_arch == NULL)	1180	if (!creator->other_arch)
1296	{	1181	{
1297	LOG (llevError, "move_creator: Creator doesn't have other arch set: %s (%s, %d, %d)\n", &creator->name, creator->map->path,	1182	LOG (llevError, "move_creator: Creator doesn't have other arch set: %s (%s, %d, %d)\n",
1298	creator->x, creator->y);	1183	&creator->name, &creator->map->path, creator->x, creator->y);
1299	return;	1184	return;
1300	}	1185	}
1301		1186
1302	new_ob = object_create_arch (creator->other_arch);	1187	new_ob = object_create_arch (creator->other_arch);
1303	fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);	1188	fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);
1304	}	1189	}
1305		1190
1306	/* Make sure this multipart object fits */	1191	/* Make sure this multipart object fits */
1307	if (new_ob->arch->more && ob_blocked (new_ob, creator->map, creator->x, creator->y))	1192	if (new_ob->arch->more && new_ob->blocked (creator->map, creator->x, creator->y))
1308	{	1193	{
1309	new_ob->destroy ();	1194	new_ob->destroy ();
1310	return;	1195	return;
1311	}	1196	}
1312		1197
		1198	// for now lets try to identify everything generated here, it mostly
		1199	// happens automated, so this will at least fix many identify-experience holes
		1200	if (new_ob->need_identify ())
		1201	new_ob->set_flag (FLAG_IDENTIFIED);
		1202
1313	insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y);	1203	insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y);
1314	if (QUERY_FLAG (new_ob, FLAG_FREED))	1204	if (new_ob->flag [FLAG_FREED])
1315	return;	1205	return;
1316		1206
1317	if (creator->slaying)	1207	if (creator->slaying)
1318	{
1319	new_ob->name = new_ob->title = creator->slaying;	1208	new_ob->name = new_ob->title = creator->slaying;
1320	}
1321	}	1209	}
1322		1210
1323	/* move_marker --peterm@soda.csua.berkeley.edu	1211	/* move_marker --peterm@soda.csua.berkeley.edu
1324	when moved, a marker will search for a player sitting above	1212	when moved, a marker will search for a player sitting above
1325	it, and insert an invisible, weightless force into him	1213	it, and insert an invisible, weightless force into him
1326	with a specific code as the slaying field.	1214	with a specific code as the slaying field.
1327	At that time, it writes the contents of its own message	1215	At that time, it writes the contents of its own message
1328	field to the player. The marker will decrement hp to	1216	field to the player. The marker will decrement hp to
1329	0 and then delete itself every time it grants a mark.	1217	0 and then delete itself every time it grants a mark.
1330	unless hp was zero to start with, in which case it is infinite.*/	1218	unless hp was zero to start with, in which case it is infinite.*/
1331
1332	void	1219	void
1333	move_marker (object *op)	1220	move_marker (object *op)
1334	{	1221	{
1335	object *tmp, *tmp2;	1222	if (object *tmp = op->ms ().player ())
1336
1337	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1338	{	1223	{
1339	if (tmp->type == PLAYER)
1340	{ /* we've got someone to MARK */
1341
1342	/* remove an old force with a slaying field == op->name */	1224	/* remove an old force with a slaying field == op->name */
1343	for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below)	1225	if (object *force = tmp->force_find (op->name))
		1226	force->destroy ();
		1227
		1228	if (op->slaying && !tmp->force_find (op->slaying))
1344	{	1229	{
1345	if (tmp2->type == FORCE && tmp2->slaying && !strcmp (tmp2->slaying, op->name))	1230	tmp->force_add (op->slaying, op->stats.food);
1346	break;	1231
		1232	if (op->msg)
		1233	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg);
		1234
		1235	if (op->stats.hp > 0)
1347	}	1236	{
		1237	op->stats.hp--;
1348		1238
1349	if (tmp2)
1350	tmp2->destroy ();
1351
1352	/* cycle through his inventory to look for the MARK we want to
1353	* place
1354	*/
1355	for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below)
1356	{
1357	if (tmp2->type == FORCE && tmp2->slaying && !strcmp (tmp2->slaying, op->slaying))
1358	break;
1359	}
1360
1361	/* if we didn't find our own MARK */
1362	if (tmp2 == NULL)
1363	{
1364	object *force = get_archetype (FORCE_NAME);
1365
1366	force->speed = 0;
1367	if (op->stats.food)	1239	if (op->stats.hp == 0)
1368	{	1240	{
1369	force->speed = 0.01;	1241	/* marker expires--granted mark number limit */
1370	force->speed_left = -op->stats.food;	1242	op->destroy ();
		1243	return;
1371	}	1244	}
1372	update_ob_speed (force);
1373	/* put in the lock code */
1374	force->slaying = op->slaying;
1375
1376	if (op->lore)
1377	force->lore = op->lore;
1378
1379	insert_ob_in_ob (force, tmp);
1380	if (op->msg)
1381	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, tmp, op->msg);
1382
1383	if (op->stats.hp > 0)
1384	{
1385	op->stats.hp--;
1386	if (op->stats.hp == 0)
1387	{
1388	/* marker expires--granted mark number limit */
1389	op->destroy ();
1390	return;
1391	}
1392	}	1245	}
1393	} /* if tmp2 == NULL */	1246	}
1394	} /* if tmp->type == PLAYER */	1247	}
1395	} /* For all objects on this space */
1396	}	1248	}
1397		1249
1398	int	1250	// mapscript objects activate themselves (only) then their timer fires
		1251	// TODO: maybe they should simply trigger the link like any other object?
		1252	static void
		1253	move_mapscript (object *op)
		1254	{
		1255	op->set_speed (0);
		1256	cfperl_mapscript_activate (op, true, op, 0);
		1257	}
		1258
		1259	static void
		1260	move_lamp (object *op)
		1261	{
		1262	// if the lamp/torch is off, we should disable it.
		1263	if (!op->glow_radius)
		1264	{
		1265	op->set_speed (0);
		1266	return;
		1267	}
		1268	else
		1269	{
		1270	// check whether the face might need to be updated
		1271	// (currently this is needed to have already switched on torches
		1272	// on maps, as they just set the glow_radius in the archetype)
		1273	if (op->other_arch
		1274	&& (
		1275	(op->flag [FLAG_ANIMATE] != op->other_arch->flag [FLAG_ANIMATE])
		1276	|| (op->flag [FLAG_ANIMATE]
		1277	? (op->animation_id != op->other_arch->animation_id)
		1278	: (op->face != op->other_arch->face))
		1279	))
		1280	get_animation_from_arch (op, op->other_arch);
		1281	}
		1282
		1283	// lamps and torches on maps don't use up their fuel
		1284	if (op->is_on_map ())
		1285	return;
		1286
		1287	if (op->stats.food > 0)
		1288	{
		1289	op->stats.food--;
		1290	return;
		1291	}
		1292
		1293	apply_lamp (op, false);
		1294	}
		1295
		1296	void
1399	process_object (object *op)	1297	process_object (object *op)
1400	{	1298	{
1401	if (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE))	1299	if (expect_false (op->flag [FLAG_IS_A_TEMPLATE]))
1402	return 0;	1300	return;
1403		1301
1404	if (INVOKE_OBJECT (TICK, op))	1302	if (expect_false (INVOKE_OBJECT (TICK, op)))
1405	return 0;	1303	return;
1406		1304
1407	if (QUERY_FLAG (op, FLAG_MONSTER))	1305	if (op->flag [FLAG_MONSTER])
1408	if (move_monster (op) || QUERY_FLAG (op, FLAG_FREED))	1306	if (move_monster (op) || op->flag [FLAG_FREED])
1409	return 1;	1307	return;
1410		1308
1411	if (QUERY_FLAG (op, FLAG_ANIMATE) && op->anim_speed == 0)	1309	if (op->flag [FLAG_ANIMATE] && op->anim_speed == 0)
1412	{	1310	{
1413	if (op->type == PLAYER)
1414	animate_object (op, op->facing);
1415	else
1416	animate_object (op, op->direction);	1311	animate_object (op, op->contr ? op->facing : op->direction);
1417		1312
1418	if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))	1313	if (op->flag [FLAG_SEE_ANYWHERE])
1419	make_sure_seen (op);	1314	make_sure_seen (op);
1420	}	1315	}
1421		1316
1422	if (QUERY_FLAG (op, FLAG_CHANGING) && !op->state)	1317	if (expect_false (
		1318	op->flag [FLAG_GENERATOR]
		1319	|| op->flag [FLAG_CHANGING]
		1320	|| op->flag [FLAG_IS_USED_UP]
		1321	))
1423	{	1322	{
		1323	if (op->flag [FLAG_CHANGING] && !op->state)
		1324	{
1424	change_object (op);	1325	change_object (op);
1425	return 1;	1326	return;
1426	}	1327	}
1427		1328
1428	if (QUERY_FLAG (op, FLAG_GENERATOR) && !QUERY_FLAG (op, FLAG_FRIENDLY))	1329	if (op->flag [FLAG_GENERATOR] && !op->flag [FLAG_FRIENDLY])
1429	generate_monster (op);	1330	generate_monster (op);
1430		1331
1431	if (QUERY_FLAG (op, FLAG_IS_USED_UP) && --op->stats.food <= 0)	1332	if (op->flag [FLAG_IS_USED_UP] && --op->stats.food <= 0)
1432	{	1333	{
1433	if (QUERY_FLAG (op, FLAG_APPLIED))	1334	if (op->flag [FLAG_APPLIED])
1434	remove_force (op);	1335	remove_force (op);
1435	else	1336	else
1436	{	1337	{
1437	/* IF necessary, delete the item from the players inventory */	1338	op->remove (); // TODO: really necessary?
1438	object *pl = op->in_player ();
1439		1339
1440	if (pl)	1340	if (op->flag [FLAG_SEE_ANYWHERE])
1441	esrv_del_item (pl->contr, op->count);
1442
1443	op->remove ();
1444
1445	if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
1446	make_sure_not_seen (op);	1341	make_sure_not_seen (op);
1447		1342
1448	op->destroy ();	1343	op->drop_and_destroy ();
1449	}	1344	}
1450		1345
1451	return 1;	1346	return;
		1347	}
1452	}	1348	}
1453		1349
1454	switch (op->type)	1350	switch (op->type)
1455	{	1351	{
1456	case SPELL_EFFECT:	1352	case SPELL_EFFECT:
1457	move_spell_effect (op);	1353	move_spell_effect (op);
1458	return 1;	1354	break;
1459		1355
1460	case ROD:	1356	case ROD:
1461	case HORN:	1357	case HORN:
1462	regenerate_rod (op);	1358	regenerate_rod (op);
1463	return 1;	1359	break;
1464		1360
1465	case FORCE:	1361	case FORCE:
1466	case POTION_EFFECT:	1362	case POTION_EFFECT:
1467	remove_force (op);	1363	remove_force (op);
1468	return 1;	1364	break;
1469		1365
1470	case BLINDNESS:	1366	case BLINDNESS:
1471	remove_blindness (op);	1367	remove_blindness (op);
1472	return 0;	1368	break;
1473		1369
1474	case POISONING:	1370	case POISONING:
1475	poison_more (op);	1371	poison_more (op);
1476	return 0;	1372	break;
1477		1373
1478	case DISEASE:	1374	case DISEASE:
1479	move_disease (op);	1375	move_disease (op);
1480	return 0;	1376	break;
1481		1377
1482	case SYMPTOM:	1378	case SYMPTOM:
1483	move_symptom (op);	1379	move_symptom (op);
1484	return 0;	1380	break;
1485		1381
1486	case THROWN_OBJ:	1382	case THROWN_OBJ:
1487	case ARROW:	1383	case ARROW:
1488	move_arrow (op);	1384	move_arrow (op);
1489	return 0;	1385	break;
1490		1386
1491	case DOOR:	1387	case DOOR:
1492	remove_door (op);	1388	remove_door (op);
1493	return 0;	1389	break;
1494		1390
1495	case LOCKED_DOOR:	1391	case LOCKED_DOOR:
1496	remove_door2 (op);	1392	remove_door2 (op);
1497	return 0;	1393	break;
1498		1394
1499	case TELEPORTER:	1395	case TELEPORTER:
1500	move_teleporter (op);	1396	move_teleporter (op);
1501	return 0;	1397	break;
1502		1398
1503	case GOLEM:	1399	case GOLEM:
1504	move_golem (op);	1400	move_golem (op);
1505	return 0;	1401	break;
1506		1402
1507	case EARTHWALL:	1403	case EARTHWALL:
1508	hit_player (op, 2, op, AT_PHYSICAL, 1);	1404	hit_player (op, 2, op, AT_PHYSICAL, 1);
1509	return 0;	1405	break;
1510		1406
1511	case FIREWALL:	1407	case FIREWALL:
1512	move_firewall (op);	1408	move_firewall (op);
1513	if (op->stats.maxsp)	1409	if (op->stats.maxsp)
1514	animate_turning (op);	1410	animate_turning (op);
1515	return 0;	1411	break;
1516		1412
1517	case MOOD_FLOOR:	1413	case MOOD_FLOOR:
1518	do_mood_floor (op);	1414	do_mood_floor (op);
1519	return 0;	1415	break;
1520		1416
1521	case GATE:	1417	case GATE:
1522	move_gate (op);	1418	move_gate (op);
1523	return 0;	1419	break;
1524		1420
1525	case TIMED_GATE:	1421	case TIMED_GATE:
1526	move_timed_gate (op);	1422	move_timed_gate (op);
1527	return 0;	1423	break;
1528		1424
1529	case TRIGGER:	1425	case TRIGGER:
1530	case TRIGGER_BUTTON:	1426	case TRIGGER_BUTTON:
1531	case TRIGGER_PEDESTAL:	1427	case TRIGGER_PEDESTAL:
1532	case TRIGGER_ALTAR:	1428	case TRIGGER_ALTAR:
1533	animate_trigger (op);	1429	animate_trigger (op);
1534	return 0;	1430	break;
1535		1431
1536	case DETECTOR:	1432	case DETECTOR:
1537	move_detector (op);	1433	move_detector (op);
1538		1434
1539	case DIRECTOR:	1435	case DIRECTOR:
1540	if (op->stats.maxsp)	1436	if (op->stats.maxsp)
1541	animate_turning (op);	1437	animate_turning (op);
1542	return 0;	1438	break;
1543		1439
1544	case HOLE:	1440	case HOLE:
1545	move_hole (op);	1441	move_hole (op);
1546	return 0;	1442	break;
1547		1443
1548	case DEEP_SWAMP:	1444	case DEEP_SWAMP:
1549	move_deep_swamp (op);	1445	move_deep_swamp (op);
1550	return 0;	1446	break;
1551		1447
1552	case RUNE:	1448	case RUNE:
1553	case TRAP:	1449	case TRAP:
1554	move_rune (op);	1450	move_rune (op);
1555	return 0;	1451	break;
1556		1452
1557	case PLAYERMOVER:	1453	case PLAYERMOVER:
1558	move_player_mover (op);	1454	move_player_mover (op);
1559	return 0;	1455	break;
1560		1456
1561	case CREATOR:	1457	case CREATOR:
1562	move_creator (op);	1458	move_creator (op);
1563	return 0;	1459	break;
1564		1460
1565	case MARKER:	1461	case MARKER:
1566	move_marker (op);	1462	move_marker (op);
1567	return 0;	1463	break;
1568		1464
1569	case PLAYER_CHANGER:	1465	case PLAYER_CHANGER:
1570	move_player_changer (op);	1466	move_player_changer (op);
1571	return 0;	1467	break;
1572		1468
1573	case PEACEMAKER:	1469	case PEACEMAKER:
1574	move_peacemaker (op);	1470	move_peacemaker (op);
1575	return 0;	1471	break;
1576	}
1577		1472
1578	return 0;	1473	case PLAYER:
		1474	// players have their own speed-management, so undo the --speed_left
		1475	++op->speed_left;
		1476	break;
		1477
		1478	case MAPSCRIPT:
		1479	move_mapscript (op);
		1480	break;
		1481
		1482	case LAMP:
		1483	case TORCH:
		1484	move_lamp (op);
		1485	break;
		1486
		1487	case PHYSICS: // hmm, bad naming
		1488	move_physics (op);
		1489	break;
		1490	}
1579	}	1491	}
		1492

Diff Legend

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