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

Comparing deliantra/server/server/time.C (file contents):
Revision 1.64 by root, Thu Aug 23 15:20:34 2007 UTC vs.
Revision 1.103 by root, Fri Mar 26 00:53:26 2010 UTC

…		…
1	/*	1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team	4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* Crossfire TRT is free software: you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation, either version 3 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	11	* option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the Affero GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
20	*	21	*
21	* The authors can be reached via e-mail to <crossfire@schmorp.de>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	/*	25	/*
25	* Routines that is executed from objects based on their speed have been	26	* Routines that is executed from objects based on their speed have been
26	* collected in this file.	27	* collected in this file.
34	* so those will be removed shortly (in a cascade like fashion.)	35	* so those will be removed shortly (in a cascade like fashion.)
35	*/	36	*/
36	void	37	void
37	remove_door (object *op)	38	remove_door (object *op)
38	{	39	{
39	int i;	40	for (int i = 1; i < SIZEOFFREE1 + 1; i += 2)
		41	{
40	object *tmp;	42	object *tmp;
41		43	mapxy pos (op);
42	for (i = 1; i < 9; i += 2)	44	pos.move (i);
43	if ((tmp = present (DOOR, op->map, op->x + freearr_x[i], op->y + freearr_y[i])) != NULL)	45	if (pos.normalise ()
		46	&& (tmp = present (DOOR, pos.m, pos.x, pos.y)))
44	{	47	{
45	tmp->set_speed (0.1f);	48	tmp->set_speed (0.1f);
46	tmp->speed_left = -0.2f;	49	tmp->speed_left = -0.2f;
47	}	50	}
		51	}
48		52
49	if (op->other_arch)	53	if (op->other_arch)
50	{	54	{
51	tmp = arch_to_object (op->other_arch);	55	object *tmp = op->other_arch->instance ();
52	tmp->x = op->x;	56	tmp->x = op->x;
53	tmp->y = op->y;	57	tmp->y = op->y;
54	tmp->map = op->map;	58	tmp->map = op->map;
55	tmp->level = op->level;	59	tmp->level = op->level;
56	insert_ob_in_map (tmp, op->map, op, 0);	60	insert_ob_in_map (tmp, op->map, op, 0);
57	}	61	}
58		62
59	op->destroy ();	63	op->drop_and_destroy ();
60	}	64	}
61		65
62	void	66	void
63	remove_door2 (object *op)	67	remove_door2 (object *op)
64	{	68	{
…		…
75	}	79	}
76	}	80	}
77		81
78	if (op->other_arch)	82	if (op->other_arch)
79	{	83	{
80	tmp = arch_to_object (op->other_arch);	84	tmp = op->other_arch->instance ();
81	tmp->x = op->x;	85	tmp->x = op->x;
82	tmp->y = op->y;	86	tmp->y = op->y;
83	tmp->map = op->map;	87	tmp->map = op->map;
84	tmp->level = op->level;	88	tmp->level = op->level;
85	insert_ob_in_map (tmp, op->map, op, 0);	89	insert_ob_in_map (tmp, op->map, op, 0);
86	}	90	}
87		91
88	op->destroy ();	92	op->drop_and_destroy ();
89	}	93	}
90		94
91	void	95	static void
92	generate_monster (object *gen)	96	generate_monster (object *gen)
93	{	97	{
94	if (!gen->map)	98	if (!gen->map)
95	return;	99	return;
96		100
97	if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1))	101	if (GENERATE_SPEED (gen) && rndm (0, GENERATE_SPEED (gen) - 1))
98	return;	102	return;
99		103
		104	// sleeping generators won't generate, this will make monsters like
		105	// centipedes not generate more centipedes when being asleep.
		106	if (gen->flag [FLAG_SLEEP])
		107	return;
		108
100	object *op;	109	object *op;
101	int i;	110	int dir;
102		111
103	if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN))	112	if (QUERY_FLAG (gen, FLAG_CONTENT_ON_GEN))
104	{	113	{
105	// either copy one item from the inventory...	114	// either copy one item from the inventory...
106	if (!gen->inv)	115	if (!gen->inv)
…		…
110	int index = 0;	119	int index = 0;
111	for (object *tmp = gen->inv; tmp; tmp = tmp->below)	120	for (object *tmp = gen->inv; tmp; tmp = tmp->below)
112	if (!rndm (++index))	121	if (!rndm (++index))
113	op = tmp;	122	op = tmp;
114		123
115	i = find_free_spot (op, gen->map, gen->x, gen->y, 1, 9);	124	dir = find_free_spot (op, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1);
116	if (i < 0)	125	if (dir < 0)
117	return;	126	return;
118		127
119	op = object_create_clone (op);	128	op = op->deep_clone ();
120		129
121	CLEAR_FLAG (op, FLAG_IS_A_TEMPLATE);	130	CLEAR_FLAG (op, FLAG_IS_A_TEMPLATE);
122	unflag_inv (op, FLAG_IS_A_TEMPLATE);	131	unflag_inv (op, FLAG_IS_A_TEMPLATE);
123	}	132	}
124	else if (gen->other_arch)	133	else if (gen->other_arch)
125	{	134	{
126	// ...or use other_arch	135	// ...or use other_arch
127	i = find_free_spot (gen->other_arch, gen->map, gen->x, gen->y, 1, 9);	136	dir = find_free_spot (gen->other_arch, gen->map, gen->x, gen->y, 1, SIZEOFFREE1 + 1);
128	if (i < 0)	137	if (dir < 0)
129	return;	138	return;
130		139
131	op = arch_to_object (gen->other_arch);	140	op = gen->other_arch->instance ();
132	}	141	}
133	else	142	else
134	return;	143	return;
135		144
136	op->expand_tail ();	145	op->expand_tail ();
137		146
138	if (insert_ob_in_map_at (op, gen->map, gen, 0, gen->x + freearr_x[i], gen->y + freearr_y[i]))	147	mapxy pos (gen); pos.move (dir);
		148
		149	if (pos.insert (op, gen))
139	{	150	{
140	if (rndm (0, 9))	151	if (rndm (0, 9))
141	generate_artifact (op, gen->map->difficulty);	152	generate_artifact (op, gen->map->difficulty);
142		153
143	if (op->has_random_items ())	154	if (op->has_random_items ())
…		…
147	}	158	}
148		159
149	op->destroy ();	160	op->destroy ();
150	}	161	}
151		162
152	void	163	static void
153	remove_force (object *op)	164	remove_force (object *op)
154	{	165	{
155	if (--op->duration > 0)	166	if (--op->duration > 0)
156	return;	167	return;
157		168
…		…
169	}	180	}
170		181
171	op->destroy ();	182	op->destroy ();
172	}	183	}
173		184
174	void	185	static void
175	remove_blindness (object *op)	186	remove_blindness (object *op)
176	{	187	{
177	if (--op->stats.food > 0)	188	if (--op->stats.food > 0)
178	return;	189	return;
179		190
…		…
186	}	197	}
187		198
188	op->destroy ();	199	op->destroy ();
189	}	200	}
190		201
191	void	202	static void
192	poison_more (object *op)	203	poison_more (object *op)
193	{	204	{
194	if (op->env == NULL \|\| !QUERY_FLAG (op->env, FLAG_ALIVE) \|\| op->env->stats.hp < 0)	205	if (op->env == NULL \|\| !QUERY_FLAG (op->env, FLAG_ALIVE) \|\| op->env->stats.hp < 0)
195	{	206	{
196	op->destroy ();	207	op->destroy ();
…		…
221		232
222	hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1);	233	hit_player (op->env, op->stats.dam, op, AT_INTERNAL, 1);
223	}	234	}
224		235
225		236
226	void	237	static void
227	move_gate (object *op)	238	move_gate (object *op)
228	{ /* 1 = going down, 0 = going up */	239	{ /* 1 = going down, 0 = going up */
229	object *tmp;	240	object *tmp;
230		241
231	if (op->stats.wc < 0 \|\| (int) op->stats.wc >= NUM_ANIMATIONS (op))	242	if (op->stats.wc < 0 \|\| (int) op->stats.wc >= NUM_ANIMATIONS (op))
…		…
238	if (op->value)	249	if (op->value)
239	{	250	{
240	if (--op->stats.wc <= 0)	251	if (--op->stats.wc <= 0)
241	{ /* Reached bottom, let's stop */	252	{ /* Reached bottom, let's stop */
242	op->stats.wc = 0;	253	op->stats.wc = 0;
243	if (op->arch->speed)	254	if (op->arch->has_active_speed ())
244	op->value = 0;	255	op->value = 0;
245	else	256	else
246	op->set_speed (0);	257	op->set_speed (0);
247	}	258	}
248		259
…		…
268	* objects are above the gate. If so, we finish closing the gate,	279	* objects are above the gate. If so, we finish closing the gate,
269	* otherwise, we fall through to the code below which should lower	280	* otherwise, we fall through to the code below which should lower
270	* the gate slightly.	281	* the gate slightly.
271	*/	282	*/
272		283
273	for (tmp = op->above; tmp != NULL; tmp = tmp->above)	284	for (tmp = op->above; tmp; tmp = tmp->above)
274	if (!QUERY_FLAG (tmp, FLAG_NO_PICK) \|\| QUERY_FLAG (tmp, FLAG_CAN_ROLL) \|\| QUERY_FLAG (tmp, FLAG_ALIVE))	285	if (!QUERY_FLAG (tmp, FLAG_NO_PICK) \|\| QUERY_FLAG (tmp, FLAG_CAN_ROLL) \|\| QUERY_FLAG (tmp, FLAG_ALIVE))
275	break;	286	break;
276		287
277	if (tmp == NULL)	288	if (!tmp)
278	{	289	{
279	if (op->arch->speed)	290	if (op->arch->has_active_speed ())
280	op->value = 1;	291	op->value = 1;
281	else	292	else
282	op->set_speed (0);	293	op->set_speed (0);
283		294
284	return;	295	return;
…		…
295	}	306	}
296	else	307	else
297	{ /* The gate is still going up */	308	{ /* The gate is still going up */
298	op->stats.wc++;	309	op->stats.wc++;
299		310
300	if ((int) op->stats.wc >= (NUM_ANIMATIONS (op)))	311	if (op->stats.wc >= NUM_ANIMATIONS (op))
301	op->stats.wc = (signed char) NUM_ANIMATIONS (op) - 1;	312	op->stats.wc = NUM_ANIMATIONS (op) - 1;
302		313
303	/* If there is something on top of the gate, we try to roll it off.	314	/* If there is something on top of the gate, we try to roll it off.
304	* If a player/monster, we don't roll, we just hit them with damage	315	* If a player/monster, we don't roll, we just hit them with damage
305	*/	316	*/
306	if ((int) op->stats.wc >= NUM_ANIMATIONS (op) / 2)	317	if (op->stats.wc >= NUM_ANIMATIONS (op) / 2)
307	{	318	{
308	/* Halfway or further, check blocks */	319	/* Halfway or further, check blocks */
309	/* First, get the top object on the square. */	320	/* First, get the top object on the square. */
310	for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)	321	for (tmp = op->above; tmp && tmp->above; tmp = tmp->above)
311	;	322	;
…		…
313	if (tmp)	324	if (tmp)
314	{	325	{
315	if (QUERY_FLAG (tmp, FLAG_ALIVE))	326	if (QUERY_FLAG (tmp, FLAG_ALIVE))
316	{	327	{
317	hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1);	328	hit_player (tmp, random_roll (0, op->stats.dam, tmp, PREFER_LOW), op, AT_PHYSICAL, 1);
		329	op->play_sound (sound_find ("blocked_gate"));
318		330
319	if (tmp->type == PLAYER)	331	if (tmp->type == PLAYER)
320	new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are crushed by the %s!", &op->name);	332	new_draw_info_format (NDI_UNIQUE, 0, tmp, "You are crushed by the %s!", &op->name);
321	}	333	}
322	else
323	/* If the object is not alive, and the object either can	334	/* If the object is not alive, and the object either can
324	* be picked up or the object rolls, move the object	335	* be picked up or the object rolls, move the object
325	* off the gate.	336	* off the gate.
326	*/	337	*/
327	if (!QUERY_FLAG (tmp, FLAG_ALIVE) && (!QUERY_FLAG (tmp, FLAG_NO_PICK) \|\| QUERY_FLAG (tmp, FLAG_CAN_ROLL)))	338	else if (!QUERY_FLAG (tmp, FLAG_ALIVE) && (!QUERY_FLAG (tmp, FLAG_NO_PICK) \|\| QUERY_FLAG (tmp, FLAG_CAN_ROLL)))
328	{	339	{
329	/* If it has speed, it should move itself, otherwise: */	340	/* If it has speed, it should move itself, otherwise: */
330	int i = find_free_spot (tmp, op->map, op->x, op->y, 1, 9);	341	int i = find_free_spot (tmp, op->map, op->x, op->y, 1, SIZEOFFREE1 + 1);
331		342
332	/* If there is a free spot, move the object someplace */	343	/* If there is a free spot, move the object someplace */
333	if (i != -1)	344	if (i > 0)
334	{	345	{
		346	mapxy pos (tmp);
		347	pos.move (i);
		348	if (pos.normalise ())
335	tmp->remove ();	349	tmp->move_to (pos);
336	tmp->x += freearr_x[i], tmp->y += freearr_y[i];
337	insert_ob_in_map (tmp, op->map, op, 0);
338	}	350	}
339	}	351	}
340	}	352	}
341		353
342	/* See if there is still anything blocking the gate */	354	/* See if there is still anything blocking the gate */
343	for (tmp = op->above; tmp != NULL; tmp = tmp->above)	355	for (tmp = op->above; tmp; tmp = tmp->above)
344	if (!QUERY_FLAG (tmp, FLAG_NO_PICK) \|\| QUERY_FLAG (tmp, FLAG_CAN_ROLL) \|\| QUERY_FLAG (tmp, FLAG_ALIVE))	356	if (!QUERY_FLAG (tmp, FLAG_NO_PICK) \|\| QUERY_FLAG (tmp, FLAG_CAN_ROLL) \|\| QUERY_FLAG (tmp, FLAG_ALIVE))
345	break;	357	break;
346		358
347	/* IF there is, start putting the gate down */	359	/* IF there is, start putting the gate down */
348	if (tmp)	360	if (tmp)
349	{
350	op->stats.food = 1;	361	op->stats.food = 1;
351	}
352	else	362	else
353	{	363	{
354	op->move_block = MOVE_ALL;	364	op->move_block = MOVE_ALL;
		365
355	if (!op->arch->stats.ac)	366	if (!op->arch->stats.ac)
356	SET_FLAG (op, FLAG_BLOCKSVIEW);	367	SET_FLAG (op, FLAG_BLOCKSVIEW);
357	update_all_los (op->map, op->x, op->y);	368	update_all_los (op->map, op->x, op->y);
358	}	369	}
359	} /* gate is halfway up */	370	} /* gate is halfway up */
…		…
365		376
366	/* hp : how long door is open/closed	377	/* hp : how long door is open/closed
367	* maxhp : initial value for hp	378	* maxhp : initial value for hp
368	* sp : 1 = open, 0 = close	379	* sp : 1 = open, 0 = close
369	*/	380	*/
370	void	381	static void
371	move_timed_gate (object *op)	382	move_timed_gate (object *op)
372	{	383	{
373	int v = op->value;	384	int v = op->value;
374		385
375	if (op->stats.sp)	386	if (op->stats.sp)
376	{	387	{
377	move_gate (op);	388	move_gate (op);
		389
378	if (op->value != v) /* change direction ? */	390	if (op->value != v) /* change direction ? */
379	op->stats.sp = 0;	391	op->stats.sp = 0;
380	return;	392	return;
381	}	393	}
		394
382	if (--op->stats.hp <= 0)	395	if (--op->stats.hp <= 0)
383	{ /* keep gate down */	396	{ /* keep gate down */
384	move_gate (op);	397	move_gate (op);
		398
385	if (op->value != v)	399	if (op->value != v)
386	op->set_speed (0);	400	op->set_speed (0);
387	}	401	}
388	}	402	}
389		403
…		…
391	* speed: frequency of 'glances'	405	* speed: frequency of 'glances'
392	* connected: connected value of detector	406	* connected: connected value of detector
393	* sp: 1 if detection sets buttons	407	* sp: 1 if detection sets buttons
394	* -1 if detection unsets buttons	408	* -1 if detection unsets buttons
395	*/	409	*/
396		410	static void
397	void
398	move_detector (object *op)	411	move_detector (object *op)
399	{	412	{
400	object *tmp;	413	object *tmp;
401	int last = op->value;	414	int last = op->value;
402	int detected;	415	int detected;
403		416
404	detected = 0;	417	detected = 0;
405		418
406	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL && !detected; tmp = tmp->above)	419	for (tmp = op->ms ().bot; tmp && !detected; tmp = tmp->above)
407	{	420	{
408	object *tmp2;	421	object *tmp2;
409		422
410	if (op->stats.hp)	423	if (op->stats.hp)
411	{	424	{
…		…
429	if (op->stats.sp == 1)	442	if (op->stats.sp == 1)
430	{	443	{
431	if (detected && last == 0)	444	if (detected && last == 0)
432	{	445	{
433	op->value = 1;	446	op->value = 1;
434	push_button (op);	447	push_button (op, tmp);
435	}	448	}
		449
436	if (!detected && last == 1)	450	if (!detected && last == 1)
437	{	451	{
438	op->value = 0;	452	op->value = 0;
439	push_button (op);	453	push_button (op, tmp);
440	}	454	}
441	}	455	}
442	else	456	else
443	{ /* in this case, we unset buttons */	457	{ /* in this case, we unset buttons */
444	if (detected && last == 1)	458	if (detected && last == 1)
445	{	459	{
446	op->value = 0;	460	op->value = 0;
447	push_button (op);	461	push_button (op, tmp);
448	}	462	}
		463
449	if (!detected && last == 0)	464	if (!detected && last == 0)
450	{	465	{
451	op->value = 1;	466	op->value = 1;
452	push_button (op);	467	push_button (op, tmp);
453	}	468	}
454	}	469	}
455	}	470	}
456
457		471
458	void	472	void
459	animate_trigger (object *op)	473	animate_trigger (object *op)
460	{	474	{
461	if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op))	475	if ((unsigned char) ++op->stats.wc >= NUM_ANIMATIONS (op))
…		…
468	SET_ANIMATION (op, op->stats.wc);	482	SET_ANIMATION (op, op->stats.wc);
469	update_object (op, UP_OBJ_FACE);	483	update_object (op, UP_OBJ_FACE);
470	}	484	}
471	}	485	}
472		486
473	void	487	static void
474	move_hole (object *op)	488	move_hole (object *op)
475	{ /* 1 = opening, 0 = closing */	489	{ /* 1 = opening, 0 = closing */
476	object next, tmp;
477
478	if (op->value)	490	if (op->value)
479	{ /* We're opening */	491	{ /* We're opening */
480	if (--op->stats.wc <= 0)	492	if (--op->stats.wc <= 0)
481	{ /* Opened, let's stop */	493	{ /* Opened, let's stop */
482	op->stats.wc = 0;	494	op->stats.wc = 0;
483	op->set_speed (0);	495	op->set_speed (0);
484		496
485	/* Hard coding this makes sense for holes I suppose */	497	/* Hard coding this makes sense for holes I suppose */
486	op->move_on = MOVE_WALK;	498	op->move_on = MOVE_WALK;
487	for (tmp = op->above; tmp != NULL; tmp = next)	499	for (object next, tmp = op->above; tmp; tmp = next)
488	{	500	{
489	next = tmp->above;	501	next = tmp->above;
490	move_apply (op, tmp, tmp);	502	move_apply (op, tmp, tmp);
491	}	503	}
492	}	504	}
493		505
494	SET_ANIMATION (op, op->stats.wc);	506	SET_ANIMATION (op, op->stats.wc);
495	update_object (op, UP_OBJ_FACE);	507	update_object (op, UP_OBJ_FACE);
496	return;	508	return;
497	}	509	}
		510
498	/* We're closing */	511	/* We're closing */
499	op->move_on = 0;	512	op->move_on = 0;
500		513
501	op->stats.wc++;	514	op->stats.wc++;
502	if ((int) op->stats.wc >= NUM_ANIMATIONS (op))	515	if ((int) op->stats.wc >= NUM_ANIMATIONS (op))
…		…
533	{	546	{
534	object *payload = op->inv;	547	object *payload = op->inv;
535		548
536	if (payload == NULL)	549	if (payload == NULL)
537	return NULL;	550	return NULL;
		551
538	payload->remove ();	552	payload->remove ();
539	op->destroy ();	553	op->destroy ();
540	return payload;	554	return payload;
541	}	555	}
542		556
…		…
585		599
586	// restore original wc, dam, attacktype and slaying	600	// restore original wc, dam, attacktype and slaying
587	op->stats.wc = op->stats.sp;	601	op->stats.wc = op->stats.sp;
588	op->stats.dam = op->stats.hp;	602	op->stats.dam = op->stats.hp;
589	op->attacktype = op->stats.grace;	603	op->attacktype = op->stats.grace;
		604	op->slaying = op->custom_name;
590		605
591	if (op->spellarg)
592	{
593	op->slaying = op->spellarg;
594	free (op->spellarg);
595	op->spellarg = 0;
596	}
597	else
598	op->slaying = 0;
599
600	/* Reset these to zero, so that object::can_merge will work properly */	606	/* Reset these to defaults, so that object::can_merge will work properly */
601	op->spellarg = NULL;	607	op->custom_name = 0;
602	op->stats.sp = 0;	608	op->stats.sp = 0;
603	op->stats.hp = 0;	609	op->stats.hp = 0;
604	op->stats.grace = 0;	610	op->stats.grace = 0;
605	op->level = 0;	611	op->level = 0;
606	op->face = op->arch->face;	612	op->face = op->arch->face;
607	op->owner = NULL; /* So that stopped arrows will be saved */	613	op->owner = 0;
		614
608	update_object (op, UP_OBJ_CHANGE);	615	update_object (op, UP_OBJ_CHANGE);
		616
609	return op;	617	return op;
610	}	618	}
611		619
612	/* stop_arrow() - what to do when a non-living flying object	620	/* stop_arrow() - what to do when a non-living flying object
613	* has to stop. Sept 96 - I added in thrown object code in	621	* has to stop. Sept 96 - I added in thrown object code in
…		…
622	if (INVOKE_OBJECT (STOP, op))	630	if (INVOKE_OBJECT (STOP, op))
623	return;	631	return;
624		632
625	if (op->inv)	633	if (op->inv)
626	{	634	{
		635	// replace this by straightforward drop to ground?
627	object *payload = op->inv;	636	object *payload = op->inv;
628		637
629	payload->remove ();
630	payload->owner = 0;	638	payload->owner = 0;
631	insert_ob_in_map (payload, op->map, payload, 0);	639	insert_ob_in_map (payload, op->map, payload, 0);
632	op->destroy ();	640	op->destroy ();
633	}	641	}
634	else	642	else
…		…
643	/* Move an arrow along its course. op is the arrow or thrown object.	651	/* Move an arrow along its course. op is the arrow or thrown object.
644	*/	652	*/
645	void	653	void
646	move_arrow (object *op)	654	move_arrow (object *op)
647	{	655	{
648	object *tmp;
649	sint16 new_x, new_y;
650	int was_reflected, mflags;	656	int was_reflected;
651	maptile *m;
652		657
653	if (op->map == NULL)	658	if (!op->map)
654	{	659	{
655	LOG (llevError, "BUG: Arrow had no map.\n");	660	LOG (llevError, "BUG: Arrow had no map.\n");
656	op->destroy ();	661	op->destroy ();
657	return;	662	return;
658	}	663	}
…		…
666	* is if the player throws a bomb - the bomb explodes on its own,	671	* is if the player throws a bomb - the bomb explodes on its own,
667	* but this object sticks around. We could handle the cleanup in the	672	* but this object sticks around. We could handle the cleanup in the
668	* bomb code, but there are potential other cases where that could happen,	673	* bomb code, but there are potential other cases where that could happen,
669	* and it is easy enough to clean it up here.	674	* and it is easy enough to clean it up here.
670	*/	675	*/
671	if (op->inv == NULL)	676	if (!op->inv)
672	{	677	{
673	op->destroy ();	678	op->destroy ();
674	return;	679	return;
675	}	680	}
676		681
…		…
688	stop_arrow (op);	693	stop_arrow (op);
689	return;	694	return;
690	}	695	}
691		696
692	/* Calculate target map square */	697	/* Calculate target map square */
693	new_x = op->x + DIRX (op);
694	new_y = op->y + DIRY (op);
695	was_reflected = 0;	698	was_reflected = 0;
696		699
697	m = op->map;	700	mapxy pos (op); pos.move (op->direction);
698	mflags = get_map_flags (m, &m, new_x, new_y, &new_x, &new_y);
699		701
700	if (mflags & P_OUT_OF_MAP)	702	if (!pos.normalise ())
701	{	703	{
702	stop_arrow (op);	704	stop_arrow (op);
703	return;	705	return;
704	}	706	}
705		707
706	/* only need to look for living creatures if this flag is set */	708	/* only need to look for living creatures if this flag is set */
707	if (mflags & P_IS_ALIVE)	709	if (pos->flags () & P_IS_ALIVE)
708	{	710	{
709	for (tmp = GET_MAP_OB (m, new_x, new_y); tmp != NULL; tmp = tmp->above)	711	object *tmp;
		712
		713	for (tmp = pos->bot; tmp; tmp = tmp->above)
710	if (QUERY_FLAG (tmp, FLAG_ALIVE))	714	if (QUERY_FLAG (tmp, FLAG_ALIVE))
711	break;	715	break;
712		716
713	/* Not really fair, but don't let monsters hit themselves with	717	/* Not really fair, but don't let monsters hit themselves with
714	* their own arrow - this can be because they fire it then	718	* their own arrow - this can be because they fire it then
…		…
737	return;	741	return;
738	}	742	}
739	} /* if this is not hitting its owner */	743	} /* if this is not hitting its owner */
740	} /* if there is something alive on this space */	744	} /* if there is something alive on this space */
741		745
742	if (OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, new_x, new_y)))	746	if (OB_TYPE_MOVE_BLOCK (op, pos->move_block))
743	{	747	{
744	int retry = 0;	748	int retry = 0;
745		749
746	/* if the object doesn't reflect, stop the arrow from moving	750	/* if the object doesn't reflect, stop the arrow from moving
747	* note that this code will now catch cases where a monster is	751	* note that this code will now catch cases where a monster is
…		…
760	if (op->direction & 1)	764	if (op->direction & 1)
761	{	765	{
762	op->direction = absdir (op->direction + 4);	766	op->direction = absdir (op->direction + 4);
763	retry = 1;	767	retry = 1;
764	}	768	}
		769
765	/* There were two blocks with identical code -	770	/* There were two blocks with identical code -
766	* use this retry here to make this one block	771	* use this retry here to make this one block
767	* that did the same thing.	772	* that did the same thing.
768	*/	773	*/
769	while (retry < 2)	774	while (retry < 2)
770	{	775	{
771	int left, right, mflags;
772	maptile *m1;
773	sint16 x1, y1;
774
775	retry++;	776	retry++;
776		777
777	/* Need to check for P_OUT_OF_MAP: if the arrow is tavelling	778	/* Need to check for P_OUT_OF_MAP: if the arrow is travelling
778	* over a corner in a tiled map, it is possible that	779	* over a corner in a tiled map, it is possible that
779	* op->direction is within an adjacent map but either	780	* op->direction is within an adjacent map but either
780	* op->direction-1 or op->direction+1 does not exist.	781	* op->direction-1 or op->direction+1 does not exist.
781	*/	782	*/
782	mflags = get_map_flags (op->map, &m1, op->x + freearr_x[absdir (op->direction - 1)],	783	mapxy pos1 (pos); pos1.move (absdir (op->direction - 1));
783	op->y + freearr_y[absdir (op->direction - 1)], &x1, &y1);	784	bool left = pos1.normalise () && OB_TYPE_MOVE_BLOCK (op, pos1->move_block);
784	left = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, (GET_MAP_MOVE_BLOCK (m1, x1, y1)));
785		785
786	mflags = get_map_flags (op->map, &m1, op->x + freearr_x[absdir (op->direction + 1)],	786	mapxy pos2 (pos); pos2.move (absdir (op->direction + 1));
787	op->y + freearr_y[absdir (op->direction + 1)], &x1, &y1);	787	bool right = pos2.normalise () && OB_TYPE_MOVE_BLOCK (op, pos2->move_block);
788	right = (mflags & P_OUT_OF_MAP) ? 0 : OB_TYPE_MOVE_BLOCK (op, (GET_MAP_MOVE_BLOCK (m1, x1, y1)));
789		788
790	if (left == right)	789	if (left == right)
791	op->direction = absdir (op->direction + 4);	790	op->direction = absdir (op->direction + 4);
792	else if (left)	791	else if (left)
793	op->direction = absdir (op->direction + 2);	792	op->direction = absdir (op->direction + 2);
794	else if (right)	793	else if (right)
795	op->direction = absdir (op->direction - 2);	794	op->direction = absdir (op->direction - 2);
796		795
797	mflags = get_map_flags (op->map, &m1, op->x + DIRX (op), op->y + DIRY (op), &x1, &y1);
798
799	/* If this space is not out of the map and not blocked, valid space -	796	/* If this space is not out of the map and not blocked, valid space -
800	* don't need to retry again.	797	* don't need to retry again.
801	*/	798	*/
802	if (!(mflags & P_OUT_OF_MAP) && !OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m1, x1, y1)))	799	mapxy pos3 (pos); pos3.move (op->direction);
		800	if (pos3.normalise () && !OB_TYPE_MOVE_BLOCK (op, pos3->move_block))
803	break;	801	break;
804
805	}	802	}
		803
806	/* Couldn't find a direction to move the arrow to - just	804	/* Couldn't find a direction to move the arrow to - just
807	* top it from moving.	805	* stop it from moving.
808	*/	806	*/
809	if (retry == 2)	807	if (retry == 2)
810	{	808	{
811	stop_arrow (op);	809	stop_arrow (op);
812	return;	810	return;
813	}	811	}
		812
814	/* update object image for new facing */	813	/* update object image for new facing */
815	/* many thrown objects don't have more than one face */	814	/* many thrown objects don't have more than one face */
816	if (GET_ANIM_ID (op))	815	if (op->has_anim ())
817	SET_ANIMATION (op, op->direction);	816	op->set_anim_frame (op->direction);
818	} /* object is reflected */	817	} /* object is reflected */
819	} /* object ran into a wall */	818	} /* object ran into a wall */
820
821	/* Move the arrow. */
822	op->remove ();
823	op->x = new_x;
824	op->y = new_y;
825		819
826	/* decrease the speed as it flies. 0.05 means a standard bow will shoot	820	/* decrease the speed as it flies. 0.05 means a standard bow will shoot
827	* about 17 squares. Tune as needed.	821	* about 17 squares. Tune as needed.
828	*/	822	*/
829	op->speed -= 0.05;	823	op->speed -= 0.05;
830	insert_ob_in_map (op, m, op, 0);
831	}
832		824
833	/* This routine doesnt seem to work for "inanimate" objects that	825	/* Move the arrow. */
834	* are being carried, ie a held torch leaps from your hands!.	826	op->move_to (pos);
835	* Modified this routine to allow held objects. b.t. */	827	}
836		828
837	void	829	static void
838	change_object (object *op)	830	change_object (object *op)
839	{ /* Doesn`t handle linked objs yet */	831	{ /* Doesn`t handle linked objs yet */
840	int i, j;
841
842	if (op->other_arch == NULL)	832	if (!op->other_arch)
843	{	833	{
844	LOG (llevError, "Change object (%s) without other_arch error.\n", &op->name);	834	LOG (llevError, "Change object (%s) without other_arch error.\n", op->debug_desc ());
845	return;	835	return;
846	}	836	}
847		837
848	/* In non-living items only change when food value is 0 */	838	/* In non-living items only change when food value is 0 */
849	if (!QUERY_FLAG (op, FLAG_ALIVE))	839	if (!QUERY_FLAG (op, FLAG_ALIVE))
850	{	840	{
851	if (op->stats.food-- > 0)	841	if (op->stats.food-- > 0)
852	return;	842	return;
		843
		844	op->stats.food = 1; /* so 1 other_arch is made */
		845	}
		846
		847	object *env = op->env;
		848
		849	op->remove ();
		850	for (int i = 0; i < op->stats.food; i++)
		851	{
		852	object *tmp = op->other_arch->instance ();
		853
		854	tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
		855
		856	if (env)
		857	env->insert (tmp);
853	else	858	else
854	op->stats.food = 1; /* so 1 other_arch is made */
855	}
856
857	object *pl = op->in_player ();
858	object *env = op->env;
859
860	op->remove ();
861	for (i = 0; i < NROFNEWOBJS (op); i++)
862	{
863	object *tmp = arch_to_object (op->other_arch);
864
865	if (op->type == LAMP)
866	tmp->stats.food = op->stats.food - 1;
867
868	tmp->stats.hp = op->stats.hp; /* The only variable it keeps. */
869	if (env)
870	{
871	tmp->x = env->x, tmp->y = env->y;
872	tmp = insert_ob_in_ob (tmp, env);
873
874	/* If this object is the players inventory, we need to tell the
875	* client of the change. Insert_ob_in_map takes care of the
876	* updating the client, so we don't need to do that below.
877	*/
878	if (pl)
879	{
880	esrv_del_item (pl->contr, op->count);
881	esrv_send_item (pl, tmp);
882	}
883	}	859	{
884	else
885	{
886	j = find_first_free_spot (tmp, op->map, op->x, op->y);	860	int j = find_first_free_spot (tmp, op->map, op->x, op->y);
		861
887	if (j == -1) /* No free spot */	862	if (j < 0) /* No free spot */
888	tmp->destroy ();	863	tmp->destroy ();
889	else	864	else
890	{	865	{
891	tmp->x = op->x + freearr_x[j], tmp->y = op->y + freearr_y[j];	866	mapxy pos (op); pos.move (j);
892	insert_ob_in_map (tmp, op->map, op, 0);	867
		868	if (pos.normalise ())
		869	pos.insert (tmp, op);
893	}	870	}
894	}	871	}
895	}	872	}
896		873
897	op->destroy ();	874	op->destroy ();
…		…
953	else	930	else
954	{	931	{
955	/* Random teleporter */	932	/* Random teleporter */
956	if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))	933	if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (tmp)))
957	return;	934	return;
		935
958	teleport (head, TELEPORTER, tmp);	936	teleport (head, TELEPORTER, tmp);
959	}	937	}
960	}	938	}
961		939
962	/* This object will teleport someone to a different map	940	/* This object will teleport someone to a different map
963	and will also apply changes to the player from its inventory.	941	and will also apply changes to the player from its inventory.
964	This was invented for giving classes, but there's no reason it	942	This was invented for giving classes, but there's no reason it
965	can't be generalized.	943	can't be generalized.
966	*/	944	*/
967	void	945	static void
968	move_player_changer (object *op)	946	move_player_changer (object *op)
969	{	947	{
970	object *player;
971	object *walk;
972
973	if (!op->above \|\| !EXIT_PATH (op))	948	if (!op->above \|\| !EXIT_PATH (op))
974	return;	949	return;
975		950
976	/* This isn't all that great - means that the player_mover	951	/* This isn't all that great - means that the player_mover
977	* needs to be on top.	952	* needs to be on top.
978	*/	953	*/
979	if (op->above->type == PLAYER)	954	if (op->above->type == PLAYER)
980	{	955	{
		956	object *player = op->above;
		957
981	if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player)))	958	if (INVOKE_OBJECT (TRIGGER, op, ARG_OBJECT (player)))
982	return;	959	return;
983		960
984	player = op->above;
985
986	for (walk = op->inv; walk; walk = walk->below)	961	for (object *walk = op->inv; walk; walk = walk->below)
987	apply_changes_to_player (player, walk);	962	apply_changes_to_player (player, walk);
988		963
989	player->update_stats ();	964	player->update_stats ();
990		965
991	esrv_send_inventory (op->above, op->above);	966	esrv_send_inventory (op->above, op->above);
…		…
1038	* moves them in the op->stats.sp direction. speed is how often it'll move.	1013	* moves them in the op->stats.sp direction. speed is how often it'll move.
1039	* If attacktype is nonzero it will paralyze the player. If lifesave is set,	1014	* If attacktype is nonzero it will paralyze the player. If lifesave is set,
1040	* it'll dissapear after hp+1 moves. If hp is set and attacktype is set,	1015	* it'll dissapear after hp+1 moves. If hp is set and attacktype is set,
1041	* it'll paralyze the victim for hp*his speed/op->speed	1016	* it'll paralyze the victim for hp*his speed/op->speed
1042	*/	1017	*/
1043	void	1018	static void
1044	move_player_mover (object *op)	1019	move_player_mover (object *op)
1045	{	1020	{
1046	int dir = op->stats.sp;	1021	int dir = op->stats.sp;
1047	sint16 nx, ny;	1022	sint16 nx, ny;
1048	maptile *m;	1023	maptile *m;
…		…
1092	/* only level >=1 movers move people */	1067	/* only level >=1 movers move people */
1093	if (op->level)	1068	if (op->level)
1094	{	1069	{
1095	/* Following is a bit of hack. We need to make sure it	1070	/* Following is a bit of hack. We need to make sure it
1096	* is cleared, otherwise the player will get stuck in	1071	* is cleared, otherwise the player will get stuck in
1097	* place. This can happen if the player used a spell to	1072	* place. This can happen if the player used a spell to
1098	* get to this space.	1073	* get to this space.
1099	*/	1074	*/
1100	victim->contr->fire_on = 0;	1075	victim->contr->fire_on = 0;
1101	victim->speed_left = 1.f;	1076	victim->speed_left = 1.f;
1102	move_player (victim, dir);	1077	move_player (victim, dir);
1103	}	1078	}
1104	else	1079	else
1105	return;	1080	return;
1106	}	1081	}
1107	else	1082	else
1108	move_object (victim, dir);	1083	victim->move (dir);
1109		1084
1110	if (!op->stats.maxsp && op->attacktype)	1085	if (!op->stats.maxsp && op->attacktype)
1111	op->stats.maxsp = 2;	1086	op->stats.maxsp = 2;
1112		1087
1113	if (op->attacktype)	1088	if (op->attacktype)
1114	{ /* flag to paralyze the player */	1089	{ /* flag to paralyze the player */
1115	victim->speed_left = max (-5.f, -FABS (op->stats.maxsp * victim->speed / op->speed));	1090	victim->speed_left = max (-5.f, -op->stats.maxsp * victim->speed / op->speed);
1116	}	1091	}
1117	}	1092	}
1118	}	1093	}
1119	}	1094	}
1120		1095
…		…
1182	{	1157	{
1183	creator->stats.hp = -1;	1158	creator->stats.hp = -1;
1184	return;	1159	return;
1185	}	1160	}
1186		1161
1187	if (creator->inv != NULL)	1162	if (creator->inv)
1188	{	1163	{
1189	object *ob;	1164	object *ob;
1190	int i;	1165	int i;
1191	object *ob_to_copy;	1166	object *ob_to_copy;
1192		1167
…		…
1197	if (rndm (0, i) == 0)	1172	if (rndm (0, i) == 0)
1198	{	1173	{
1199	ob_to_copy = ob;	1174	ob_to_copy = ob;
1200	}	1175	}
1201	}	1176	}
1202	new_ob = object_create_clone (ob_to_copy);	1177	new_ob = ob_to_copy->deep_clone ();
1203	CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE);	1178	CLEAR_FLAG (new_ob, FLAG_IS_A_TEMPLATE);
1204	unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);	1179	unflag_inv (new_ob, FLAG_IS_A_TEMPLATE);
1205	}	1180	}
1206	else	1181	else
1207	{	1182	{
1208	if (creator->other_arch == NULL)	1183	if (!creator->other_arch)
1209	{	1184	{
1210	LOG (llevError, "move_creator: Creator doesn't have other arch set: %s (%s, %d, %d)\n",	1185	LOG (llevError, "move_creator: Creator doesn't have other arch set: %s (%s, %d, %d)\n",
1211	&creator->name, &creator->map->path, creator->x, creator->y);	1186	&creator->name, &creator->map->path, creator->x, creator->y);
1212	return;	1187	return;
1213	}	1188	}
…		…
1215	new_ob = object_create_arch (creator->other_arch);	1190	new_ob = object_create_arch (creator->other_arch);
1216	fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);	1191	fix_generated_item (new_ob, creator, 0, 0, GT_MINIMAL);
1217	}	1192	}
1218		1193
1219	/* Make sure this multipart object fits */	1194	/* Make sure this multipart object fits */
1220	if (new_ob->arch->more && ob_blocked (new_ob, creator->map, creator->x, creator->y))	1195	if (new_ob->arch->more && new_ob->blocked (creator->map, creator->x, creator->y))
1221	{	1196	{
1222	new_ob->destroy ();	1197	new_ob->destroy ();
1223	return;	1198	return;
1224	}	1199	}
1225		1200
…		…
1230	insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y);	1205	insert_ob_in_map_at (new_ob, creator->map, creator, 0, creator->x, creator->y);
1231	if (QUERY_FLAG (new_ob, FLAG_FREED))	1206	if (QUERY_FLAG (new_ob, FLAG_FREED))
1232	return;	1207	return;
1233		1208
1234	if (creator->slaying)	1209	if (creator->slaying)
1235	{
1236	new_ob->name = new_ob->title = creator->slaying;	1210	new_ob->name = new_ob->title = creator->slaying;
1237	}
1238	}	1211	}
1239		1212
1240	/* move_marker --peterm@soda.csua.berkeley.edu	1213	/* move_marker --peterm@soda.csua.berkeley.edu
1241	when moved, a marker will search for a player sitting above	1214	when moved, a marker will search for a player sitting above
1242	it, and insert an invisible, weightless force into him	1215	it, and insert an invisible, weightless force into him
…		…
1252	{	1225	{
1253	/* remove an old force with a slaying field == op->name */	1226	/* remove an old force with a slaying field == op->name */
1254	if (object *force = tmp->force_find (op->name))	1227	if (object *force = tmp->force_find (op->name))
1255	force->destroy ();	1228	force->destroy ();
1256		1229
1257	if (!tmp->force_find (op->slaying))	1230	if (op->slaying && !tmp->force_find (op->slaying))
1258	{	1231	{
1259	tmp->force_add (op->slaying, op->stats.food);	1232	tmp->force_add (op->slaying, op->stats.food);
1260		1233
1261	if (op->msg)	1234	if (op->msg)
1262	new_draw_info (NDI_UNIQUE \| NDI_NAVY, 0, tmp, op->msg);	1235	new_draw_info (NDI_UNIQUE \| NDI_NAVY, 0, tmp, op->msg);
…		…
1274	}	1247	}
1275	}	1248	}
1276	}	1249	}
1277	}	1250	}
1278		1251
		1252	// mapscript objects activate themselves (only) then their timer fires
		1253	// TODO: maybe they should simply trigger the link like any other object?
		1254	static void
		1255	move_mapscript (object *op)
		1256	{
		1257	op->set_speed (0);
		1258	cfperl_mapscript_activate (op, true, op, 0);
		1259	}
		1260
		1261	static void
		1262	move_lamp (object *op)
		1263	{
		1264	// if the lamp/torch is off, we should disable it.
		1265	if (!op->glow_radius)
		1266	{
		1267	op->set_speed (0);
		1268	return;
		1269	}
		1270	else
		1271	{
		1272	// check whether the face might need to be updated
		1273	// (currently this is needed to have already switched on torches
		1274	// on maps, as they just set the glow_radius in the archetype)
		1275	if (op->other_arch
		1276	&& (
		1277	(op->flag [FLAG_ANIMATE] != op->other_arch->flag [FLAG_ANIMATE])
		1278	\|\| (op->flag [FLAG_ANIMATE]
		1279	? (op->animation_id != op->other_arch->animation_id)
		1280	: (op->face != op->other_arch->face))
		1281	))
		1282	get_animation_from_arch (op, op->other_arch);
		1283	}
		1284
		1285	// lamps and torches on maps don't use up their fuel
		1286	if (op->is_on_map ())
		1287	return;
		1288
		1289	if (op->stats.food > 0)
		1290	{
		1291	op->stats.food--;
		1292	return;
		1293	}
		1294
		1295	apply_lamp (op, false);
		1296	}
		1297
1279	void	1298	void
1280	process_object (object *op)	1299	process_object (object *op)
1281	{	1300	{
1282	if (expect_false (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)))	1301	if (expect_false (QUERY_FLAG (op, FLAG_IS_A_TEMPLATE)))
1283	return;	1302	return;
…		…
1316	{	1335	{
1317	if (QUERY_FLAG (op, FLAG_APPLIED))	1336	if (QUERY_FLAG (op, FLAG_APPLIED))
1318	remove_force (op);	1337	remove_force (op);
1319	else	1338	else
1320	{	1339	{
1321	/* If necessary, delete the item from the players inventory */	1340	op->remove (); // TODO: really necessary?
1322	object *pl = op->in_player ();
1323
1324	if (pl)
1325	esrv_del_item (pl->contr, op->count);
1326
1327	op->remove ();
1328		1341
1329	if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))	1342	if (QUERY_FLAG (op, FLAG_SEE_ANYWHERE))
1330	make_sure_not_seen (op);	1343	make_sure_not_seen (op);
1331		1344
1332	op->destroy ();	1345	op->drop_and_destroy ();
1333	}	1346	}
1334		1347
1335	return;	1348	return;
1336	}	1349	}
1337	}	1350	}
…		…
1461		1474
1462	case PLAYER:	1475	case PLAYER:
1463	// players have their own speed-management, so undo the --speed_left	1476	// players have their own speed-management, so undo the --speed_left
1464	++op->speed_left;	1477	++op->speed_left;
1465	break;	1478	break;
1466	}
1467	}
1468		1479
		1480	case MAPSCRIPT:
		1481	move_mapscript (op);
		1482	break;
		1483
		1484	case LAMP:
		1485	case TORCH:
		1486	move_lamp (op);
		1487	break;
		1488	}
		1489	}
		1490

Diff Legend

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

Comparing deliantra/server/server/time.C (file contents): Revision 1.64 by root, Thu Aug 23 15:20:34 2007 UTC vs. Revision 1.103 by root, Fri Mar 26 00:53:26 2010 UTC

Diff Legend

Comparing deliantra/server/server/time.C (file contents):
Revision 1.64 by root, Thu Aug 23 15:20:34 2007 UTC vs.
Revision 1.103 by root, Fri Mar 26 00:53:26 2010 UTC