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.7 by elmex, Tue Aug 29 17:29:28 2006 UTC vs.
Revision 1.20 by root, Wed Dec 20 09:14:22 2006 UTC

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

Diff Legend

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