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.52 by root, Tue May 22 10:50:01 2007 UTC

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

Diff Legend

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