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.9 by root, Sun Sep 10 15:59:58 2006 UTC vs.
Revision 1.105 by root, Fri Mar 26 01:04:45 2010 UTC

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

Diff Legend

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