ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/spell_effect.C

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.112 by root, Wed Nov 4 18:17:58 2009 UTC vs.
Revision 1.148 by root, Sat Nov 17 23:40:04 2018 UTC

1	/*	1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
		4	* Copyright (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	5	* Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team	6	* Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	7	* Copyright (©) 1992 Frank Tore Johansen
7	*	8	*
8	* Deliantra is free software: you can redistribute it and/or modify it under	9	* Deliantra is free software: you can redistribute it and/or modify it under
9	* the terms of the Affero GNU General Public License as published by the	10	* the terms of the Affero GNU General Public License as published by the
10	* Free Software Foundation, either version 3 of the License, or (at your	11	* Free Software Foundation, either version 3 of the License, or (at your
11	* option) any later version.	12	* option) any later version.
12	*	13	*
13	* This program is distributed in the hope that it will be useful,	14	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	17	* GNU General Public License for more details.
17	*	18	*
18	* You should have received a copy of the Affero GNU General Public License	19	* You should have received a copy of the Affero GNU General Public License
19	* and the GNU General Public License along with this program. If not, see	20	* and the GNU General Public License along with this program. If not, see
20	* <http://www.gnu.org/licenses/>.	21	* <http://www.gnu.org/licenses/>.
21	*	22	*
22	* The authors can be reached via e-mail to <support@deliantra.net>	23	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	24	*/
24		25
25	#include <global.h>	26	#include <global.h>
26	#include <object.h>	27	#include <object.h>
…		…
58	}	59	}
59		60
60	int	61	int
61	recharge (object *op, object *caster, object *spell_ob)	62	recharge (object *op, object *caster, object *spell_ob)
62	{	63	{
63	object *wand, *tmp;
64	int ncharges;	64	int ncharges;
65		65
66	wand = find_marked_object (op);	66	object *wand = op->mark ();
		67
67	if (!wand || wand->type != WAND)	68	if (!wand || wand->type != WAND)
68	{	69	{
69	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");	70	op->failmsg ("You need to mark the wand you want to recharge.");
70	return 0;	71	return 0;
71	}	72	}
		73
72	if (!(random_roll (0, 3, op, PREFER_HIGH)))	74	if (!(random_roll (0, 3, op, PREFER_HIGH)))
73	{	75	{
74	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));	76	op->failmsgf ("The %s vibrates violently, then explodes!", query_name (wand));
75	op->play_sound (sound_find ("ob_explode"));	77	op->play_sound (sound_find ("ob_explode"));
76	wand->destroy ();	78	wand->destroy ();
77	tmp = get_archetype ("fireball");	79	object *tmp = archetype::get (shstr_fireball);
78	tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;	80	tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
79		81
80	if (!tmp->stats.dam)	82	if (!tmp->stats.dam)
81	tmp->stats.dam = 1;	83	tmp->stats.dam = 1;
82		84
…		…
93		95
94	if (wand->inv && wand->inv->level)	96	if (wand->inv && wand->inv->level)
95	ncharges /= wand->inv->level;	97	ncharges /= wand->inv->level;
96	else	98	else
97	{	99	{
98	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand));	100	op->failmsgf ("Your %s is broken.", query_name (wand));
99	return 0;	101	return 0;
100	}	102	}
101		103
102	if (!ncharges)	104	if (!ncharges)
103	ncharges = 1;	105	ncharges = 1;
104		106
105	wand->stats.food += ncharges;	107	wand->stats.food += ncharges;
106	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));	108	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
107		109
108	if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE))	110	if (wand->arch && wand->arch->flag [FLAG_ANIMATE])
109	{	111	{
110	SET_FLAG (wand, FLAG_ANIMATE);	112	wand->set_flag (FLAG_ANIMATE);
111	wand->set_speed (wand->arch->speed);	113	wand->set_speed (wand->arch->speed);
112	}	114	}
113		115
114	return 1;	116	return 1;
115	}	117	}
…		…
129	{	131	{
130	int bonus_plus = 0;	132	int bonus_plus = 0;
131	const char *missile_name = "arrow";	133	const char *missile_name = "arrow";
132		134
133	for (object *tmp = op->inv; tmp; tmp = tmp->below)	135	for (object *tmp = op->inv; tmp; tmp = tmp->below)
134	if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))	136	if (tmp->type == BOW && tmp->flag [FLAG_APPLIED])
135	missile_name = tmp->race;	137	missile_name = tmp->race;
136		138
137	int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);	139	int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
138		140
139	archetype *missile_arch = archetype::find (missile_name);	141	archetype *missile_arch = archetype::find (missile_name);
…		…
158	break;	160	break;
159		161
160	if (!al)	162	if (!al)
161	{	163	{
162	missile->destroy ();	164	missile->destroy ();
163	new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, spellparam);	165	op->failmsgf ("No such object %ss of %s", missile_name, spellparam);
164	return 0;	166	return 0;
165	}	167	}
166		168
167	if (al->item->slaying)	169	if (al->item->slaying)
168	{	170	{
169	missile->destroy ();	171	missile->destroy ();
170	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, spellparam);	172	op->failmsgf ("You are not allowed to create %ss of %s", missile_name, spellparam);
171	return 0;	173	return 0;
172	}	174	}
173		175
174	give_artifact_abilities (missile, al->item);	176	give_artifact_abilities (missile, al->item);
175	/* These special arrows cost something extra. Don't have them also be magical -	177	/* These special arrows cost something extra. Don't have them also be magical -
…		…
193		195
194	missile->magic = missile_plus;	196	missile->magic = missile_plus;
195	/* Can't get any money for these objects */	197	/* Can't get any money for these objects */
196	missile->value = 0;	198	missile->value = 0;
197		199
198	SET_FLAG (missile, FLAG_IDENTIFIED);	200	missile->set_flag (FLAG_IDENTIFIED);
199		201
200	if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !missile->destroyed ())	202	cast_create_obj (op, caster, missile, dir);
		203
		204	if (!dir
		205	&& op->type == PLAYER
		206	&& !missile->destroyed ())
201	pick_up (op, missile);	207	pick_up (op, missile);
202		208
203	return 1;	209	return 1;
204	}	210	}
205
206		211
207	/* allows the choice of what sort of food object to make.	212	/* allows the choice of what sort of food object to make.
208	* If spellparam is NULL, it will create food dependent on level --PeterM*/	213	* If spellparam is NULL, it will create food dependent on level --PeterM*/
209	int	214	int
210	cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *spellparam)	215	cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *spellparam)
…		…
257	/* Pretty unlikely (there are some very low food items), but you never	262	/* Pretty unlikely (there are some very low food items), but you never
258	* know	263	* know
259	*/	264	*/
260	if (!at)	265	if (!at)
261	{	266	{
262	new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");	267	op->failmsgf ("You don't have enough experience to create any food.");
263	return 0;	268	return 0;
264	}	269	}
265		270
266	food_value /= at->stats.food;	271	food_value /= at->stats.food;
267	new_op = arch_to_object (at);	272	new_op = at->instance ();
268	new_op->nrof = food_value;	273	new_op->nrof = food_value;
269		274
270	new_op->value = 0;	275	new_op->value = 0;
271	if (new_op->nrof < 1)	276	if (new_op->nrof < 1)
272	new_op->nrof = 1;	277	new_op->nrof = 1;
…		…
289	}	294	}
290		295
291	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	296	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
292	for (r = 1; r < maxrange; r++)	297	for (r = 1; r < maxrange; r++)
293	{	298	{
294	sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];	299	sint16 x = op->x + r * DIRX (dir), y = op->y + r * DIRY (dir);
295		300
296	m = op->map;	301	m = op->map;
297	mflags = get_map_flags (m, &m, x, y, &x, &y);	302	mflags = get_map_flags (m, &m, x, y, &x, &y);
298		303
299	if (mflags & P_OUT_OF_MAP)	304	if (mflags & P_OUT_OF_MAP)
300	break;	305	break;
301		306
302	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))	307	if (!op->flag [FLAG_WIZCAST] && (mflags & P_NO_MAGIC))
303	{	308	{
304	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");	309	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
305	return 0;	310	return 0;
306	}	311	}
307		312
308	if (mflags & P_IS_ALIVE)	313	if (mflags & P_IS_ALIVE)
309	{	314	{
310	for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)	315	for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
311	if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))	316	if (tmp->flag [FLAG_ALIVE] && (tmp->type == PLAYER || tmp->flag [FLAG_MONSTER]))
312	{	317	{
313	new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");	318	new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
314	if (tmp->head != NULL)	319	if (tmp->head != NULL)
315	tmp = tmp->head;	320	tmp = tmp->head;
316	examine_monster (op, tmp);	321	examine_monster (op, tmp);
…		…
339	if (pl->type == PLAYER)	344	if (pl->type == PLAYER)
340	{	345	{
341	/* If race isn't set, then invisible unless it is undead */	346	/* If race isn't set, then invisible unless it is undead */
342	if (!pl->contr->invis_race)	347	if (!pl->contr->invis_race)
343	{	348	{
344	if (QUERY_FLAG (mon, FLAG_UNDEAD))	349	if (mon->flag [FLAG_UNDEAD])
345	return 0;	350	return 0;
346		351
347	return 1;	352	return 1;
348	}	353	}
349		354
…		…
380	int	385	int
381	cast_invisible (object *op, object *caster, object *spell_ob)	386	cast_invisible (object *op, object *caster, object *spell_ob)
382	{	387	{
383	if (op->invisible > 1000)	388	if (op->invisible > 1000)
384	{	389	{
385	new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");	390	op->failmsg ("You can not extend the duration of your invisibility any further");
386	return 0;	391	return 0;
387	}	392	}
388		393
389	/* Remove the switch with 90% duplicate code - just handle the differences with	394	/* Remove the switch with 90% duplicate code - just handle the differences with
390	* and if statement or two.	395	* and if statement or two.
391	*/	396	*/
392	op->invisible += spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	397	op->invisible += spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
		398
393	/* max duration */	399	/* limit duration */
394	if (op->invisible > 1000)	400	min_it (op->invisible, 1000);
395	op->invisible = 1000;
396		401
397	if (op->type == PLAYER)	402	if (op->type == PLAYER)
398	{	403	{
399	op->contr->invis_race = spell_ob->race;	404	op->contr->invis_race = spell_ob->race;
400		405
401	if (QUERY_FLAG (spell_ob, FLAG_MAKE_INVIS))	406	if (spell_ob->flag [FLAG_MAKE_INVIS])
402	op->contr->tmp_invis = 0;	407	op->contr->tmp_invis = 0;
403	else	408	else
404	op->contr->tmp_invis = 1;	409	op->contr->tmp_invis = 1;
405
406	op->contr->hidden = 0;
407	}	410	}
408		411
409	if (makes_invisible_to (op, op))	412	if (makes_invisible_to (op, op))
410	new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");	413	new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");
411	else	414	else
…		…
448	// earth to dust tears down everything that can be torn down	451	// earth to dust tears down everything that can be torn down
449	for (object *next, *tmp = m->at (sx, sy).bot; tmp; tmp = next)	452	for (object *next, *tmp = m->at (sx, sy).bot; tmp; tmp = next)
450	{	453	{
451	next = tmp->above;	454	next = tmp->above;
452		455
453	if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))	456	if (tmp->flag [FLAG_TEAR_DOWN])
454	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);	457	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
455	}	458	}
456	}	459	}
457		460
458	return 1;	461	return 1;
…		…
460		463
461	void	464	void
462	execute_word_of_recall (object *op)	465	execute_word_of_recall (object *op)
463	{	466	{
464	if (object *pl = op->in_player ())	467	if (object *pl = op->in_player ())
465	{
466	if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))	468	if (pl->ms ().flags () & P_NO_CLERIC && !pl->flag [FLAG_WIZCAST])
467	new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");	469	new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
468	else	470	else
469	pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);	471	pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);
470	}
471		472
472	op->destroy ();	473	op->destroy ();
473	}	474	}
474		475
475	/* Word of recall causes the player to return 'home'.	476	/* Word of recall causes the player to return 'home'.
476	* we put a force into the player object, so that there is a	477	* we put a force into the player object, so that there is a
477	* time delay effect.	478	* time delay effect.
478	*/	479	*/
479	int	480	int
480	cast_word_of_recall (object *op, object *caster, object *spell_ob)	481	cast_word_of_recall (object *op, object *caster, object *spell_ob)
481	{	482	{
482	object *dummy;	483	if (!op->is_player ())
483	int time;
484
485	if (op->type != PLAYER)
486	return 0;	484	return 0;
487		485
488	if (find_obj_by_type_subtype (op, SPELL_EFFECT, SP_WORD_OF_RECALL))	486	if (find_obj_by_type_subtype (op, SPELL_EFFECT, SP_WORD_OF_RECALL))
489	{	487	{
490	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");	488	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
491	return 1;	489	return 1;
492	}	490	}
493		491
494	dummy = get_archetype (FORCE_NAME);	492	object *dummy = archetype::get (FORCE_NAME);
495		493
496	if (!dummy)
497	{
498	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
499	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
500	return 0;
501	}
502
503	time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);	494	int time = max (1, spell_ob->duration - SP_level_duration_adjust (caster, spell_ob));
504	if (time < 1)
505	time = 1;
506		495
507	/* value of speed really doesn't make much difference, as long as it is	496	/* value of speed really doesn't make much difference, as long as it is
508	* positive. Lower value may be useful so that the problem doesn't	497	* positive. Lower value may be useful so that the problem doesn't
509	* do anything really odd if it say a -1000 or something.	498	* do anything really odd if it say a -1000 or something.
510	*/	499	*/
511	dummy->set_speed (0.002);	500	dummy->set_speed (0.002);
512	dummy->speed_left = -dummy->speed * time;	501	dummy->speed_left = -dummy->speed * time;
513	dummy->type = SPELL_EFFECT;	502	dummy->type = SPELL_EFFECT;
514	dummy->subtype = SP_WORD_OF_RECALL;	503	dummy->subtype = SP_WORD_OF_RECALL;
515		504	dummy->slaying = op->contr->savebed_map;
516	/* If we could take advantage of enter_player_savebed() here, it would be	505	dummy->stats.hp = op->contr->bed_x;
517	* nice, but until the map load fails, we can't.	506	dummy->stats.sp = op->contr->bed_y;
518	*/
519	EXIT_PATH (dummy) = op->contr->savebed_map;
520	EXIT_X (dummy) = op->contr->bed_x;
521	EXIT_Y (dummy) = op->contr->bed_y;
522		507
523	op->insert (dummy);	508	op->insert (dummy);
524		509
525	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");	510	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
526		511
…		…
565		550
566	int	551	int
567	perceive_self (object *op)	552	perceive_self (object *op)
568	{	553	{
569	const char *cp = describe_item (op, op);	554	const char *cp = describe_item (op, op);
570	archetype *at = archetype::find (ARCH_DEPLETION);	555	archetype *at = archetype::find (shstr_depletion);
571		556
572	dynbuf_text &buf = msg_dynbuf; buf.clear ();	557	dynbuf_text &buf = msg_dynbuf; buf.clear ();
573		558
574	if (!op->is_player ())	559	if (!op->is_player ())
575	return 0;	560	return 0;
…		…
594	for (int i = 0; i < NUM_STATS; i++)	579	for (int i = 0; i < NUM_STATS; i++)
595	if (tmp->stats.stat (i) < 0)	580	if (tmp->stats.stat (i) < 0)
596	buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));	581	buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
597	}	582	}
598		583
599	if (is_dragon_pl (op))	584	if (op->is_dragon ())
600	/* now grab the 'dragon_ability'-force from the player's inventory */	585	/* now grab the 'dragon_ability'-force from the player's inventory */
601	for (tmp = op->inv; tmp; tmp = tmp->below)	586	for (tmp = op->inv; tmp; tmp = tmp->below)
602	{	587	{
603	if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)	588	if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
604	{	589	{
…		…
635	x = op->x;	620	x = op->x;
636	y = op->y;	621	y = op->y;
637	}	622	}
638	else	623	else
639	{	624	{
640	x = op->x + freearr_x[dir];	625	x = op->x + DIRX (dir);
641	y = op->y + freearr_y[dir];	626	y = op->y + DIRY (dir);
642	}	627	}
643		628
644	m = op->map;	629	m = op->map;
645		630
646	if ((spell_ob->move_block || x != op->x || y != op->y) &&	631	if ((spell_ob->move_block || x != op->x || y != op->y) &&
647	(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) ||	632	(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) ||
648	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))	633	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))
649	{	634	{
650	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	635	op->failmsg ("Something is in the way.");
651	return 0;	636	return 0;
652	}	637	}
653		638
654	if (spell_ob->other_arch)	639	if (spell_ob->other_arch)
655	tmp = arch_to_object (spell_ob->other_arch);	640	tmp = spell_ob->other_arch->instance ();
656	else if (spell_ob->race)	641	else if (spell_ob->race)
657	{	642	{
658	char buf1[MAX_BUF];	643	char buf1[MAX_BUF];
659		644
660	sprintf (buf1, spell_ob->race, dir);	645	sprintf (buf1, spell_ob->race, dir);
…		…
664	LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);	649	LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
665	new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");	650	new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
666	return 0;	651	return 0;
667	}	652	}
668		653
669	tmp = arch_to_object (at);	654	tmp = at->instance ();
670	}	655	}
671	else	656	else
672	{	657	{
673	LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);	658	LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
674	return 0;	659	return 0;
…		…
679	tmp->attacktype = spell_ob->attacktype;	664	tmp->attacktype = spell_ob->attacktype;
680	tmp->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	665	tmp->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
681	tmp->stats.dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);	666	tmp->stats.dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
682	tmp->range = 0;	667	tmp->range = 0;
683	}	668	}
684	else if (QUERY_FLAG (tmp, FLAG_ALIVE))	669	else if (tmp->flag [FLAG_ALIVE])
685	{	670	{
686	tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	671	tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
687	tmp->stats.maxhp = tmp->stats.hp;	672	tmp->stats.maxhp = tmp->stats.hp;
688	}	673	}
689		674
690	if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP))	675	if (spell_ob->flag [FLAG_IS_USED_UP] || tmp->flag [FLAG_IS_USED_UP])
691	{	676	{
692	tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	677	tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
693	SET_FLAG (tmp, FLAG_IS_USED_UP);	678	tmp->set_flag (FLAG_IS_USED_UP);
694	}	679	}
695		680
696	if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN))	681	if (spell_ob->flag [FLAG_TEAR_DOWN])
697	{	682	{
698	tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);	683	tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
699	tmp->stats.maxhp = tmp->stats.hp;	684	tmp->stats.maxhp = tmp->stats.hp;
700	SET_FLAG (tmp, FLAG_TEAR_DOWN);	685	tmp->set_flag (FLAG_TEAR_DOWN);
701	SET_FLAG (tmp, FLAG_ALIVE);	686	tmp->set_flag (FLAG_ALIVE);
702	}	687	}
703		688
704	/* This can't really hurt - if the object doesn't kill anything,	689	/* This can't really hurt - if the object doesn't kill anything,
705	* these fields just won't be used. Do not set the owner for	690	* these fields just won't be used. Do not set the owner for
706	* earthwalls, though, so they survive restarts.	691	* earthwalls, though, so they survive restarts.
…		…
718	return 0;	703	return 0;
719	}	704	}
720		705
721	/* If this is a spellcasting wall, need to insert the spell object */	706	/* If this is a spellcasting wall, need to insert the spell object */
722	if (tmp->other_arch && tmp->other_arch->type == SPELL)	707	if (tmp->other_arch && tmp->other_arch->type == SPELL)
723	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);	708	insert_ob_in_ob (tmp->other_arch->instance (), tmp);
724		709
725	/* This code causes the wall to extend some distance in	710	/* This code causes the wall to extend some distance in
726	* each direction, or until an obstruction is encountered.	711	* each direction, or until an obstruction is encountered.
727	* posblocked and negblocked help determine how far the	712	* posblocked and negblocked help determine how far the
728	* created wall can extend, it won't go extend through	713	* created wall can extend, it won't go extend through
729	* blocked spaces.	714	* blocked spaces.
730	*/	715	*/
731	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	716	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
…		…
736	{	721	{
737	int dir2;	722	int dir2;
738		723
739	dir2 = (dir < 4) ? (dir + 2) : dir - 2;	724	dir2 = (dir < 4) ? (dir + 2) : dir - 2;
740		725
741	x = tmp->x + i * freearr_x[dir2];	726	x = tmp->x + i * DIRX (dir2);
742	y = tmp->y + i * freearr_y[dir2];	727	y = tmp->y + i * DIRY (dir2);
743	m = tmp->map;	728	m = tmp->map;
744		729
745	if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&	730	if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
746	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)	731	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)
747	{	732	{
748	object *tmp2 = tmp->clone ();	733	object *tmp2 = tmp->clone ();
749	m->insert (tmp2, x, y, op);	734	m->insert (tmp2, x, y, op);
750		735
751	/* If this is a spellcasting wall, need to insert the spell object */	736	/* If this is a spellcasting wall, need to insert the spell object */
752	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)	737	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
753	tmp2->insert (arch_to_object (tmp2->other_arch));	738	tmp2->insert (tmp2->other_arch->instance ());
754		739
755	}	740	}
756	else	741	else
757	posblocked = 1;	742	posblocked = 1;
758		743
759	x = tmp->x - i * freearr_x[dir2];	744	x = tmp->x - i * DIRX (dir2);
760	y = tmp->y - i * freearr_y[dir2];	745	y = tmp->y - i * DIRY (dir2);
761	m = tmp->map;	746	m = tmp->map;
762		747
763	if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&	748	if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
764	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)	749	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
765	{	750	{
766	object *tmp2 = tmp->clone ();	751	object *tmp2 = tmp->clone ();
767	m->insert (tmp2, x, y, op);	752	m->insert (tmp2, x, y, op);
768		753
769	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)	754	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
770	tmp2->insert (arch_to_object (tmp2->other_arch));	755	tmp2->insert (tmp2->other_arch->instance ());
771	}	756	}
772	else	757	else
773	negblocked = 1;	758	negblocked = 1;
774	}	759	}
775		760
776	if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW))	761	if (tmp->flag [FLAG_BLOCKSVIEW])
777	update_all_los (op->map, op->x, op->y);	762	update_all_los (op->map, op->x, op->y);
778		763
779	return 1;	764	return 1;
780	}	765	}
781		766
…		…
790	if (op->type != PLAYER)	775	if (op->type != PLAYER)
791	return 0;	776	return 0;
792		777
793	if (!dir)	778	if (!dir)
794	{	779	{
795	new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");	780	op->failmsg ("In what direction?");
796	return 0;	781	return 0;
797	}	782	}
798		783
799	/* Given the new outdoor maps, can't let players dimension door for	784	/* Given the new outdoor maps, can't let players dimension door for
800	* ever, so put limits in.	785	* ever, so put limits in.
…		…
805	{	790	{
806	int count = atoi (spellparam);	791	int count = atoi (spellparam);
807		792
808	if (count > maxdist)	793	if (count > maxdist)
809	{	794	{
810	new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!");	795	op->failmsg ("You can't dimension door that far!");
811	return 0;	796	return 0;
812	}	797	}
813		798
814	for (dist = 0; dist < count; dist++)	799	for (dist = 0; dist < count; dist++)
815	{	800	{
816	mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);	801	mflags = get_map_flags (op->map, &m, op->x + DIRX (dir) * (dist + 1), op->y + DIRY (dir) * (dist + 1), &sx, &sy);
817		802
818	if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))	803	if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
819	break;	804	break;
820		805
821	if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))	806	if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
…		…
834	* by such squares). Also, there are probably treasure rooms and	819	* by such squares). Also, there are probably treasure rooms and
835	* lots of other maps that protect areas with no magic, but the	820	* lots of other maps that protect areas with no magic, but the
836	* areas themselves don't contain no magic spaces.	821	* areas themselves don't contain no magic spaces.
837	*/	822	*/
838	/* This call here is really just to normalize the coordinates */	823	/* This call here is really just to normalize the coordinates */
839	mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, &sx, &sy);	824	mflags = get_map_flags (op->map, &m, op->x + DIRX (dir) * dist, op->y + DIRY (dir) * dist, &sx, &sy);
840	if (mflags & P_IS_ALIVE || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))	825	if (mflags & P_IS_ALIVE || OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
841	{	826	{
842	new_draw_info (NDI_UNIQUE, 0, op, "You cast your spell, but nothing happens.\n");	827	new_draw_info (NDI_UNIQUE, 0, op, "You cast your spell, but nothing happens.\n");
843	return 1; /* Maybe the penalty should be more severe... */	828	return 1; /* Maybe the penalty should be more severe... */
844	}	829	}
…		…
850	* spaces that blocked the players view.	835	* spaces that blocked the players view.
851	*/	836	*/
852		837
853	for (dist = 0; dist < maxdist; dist++)	838	for (dist = 0; dist < maxdist; dist++)
854	{	839	{
855	mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);	840	mflags = get_map_flags (op->map, &m, op->x + DIRX (dir) * (dist + 1), op->y + DIRY (dir) * (dist + 1), &sx, &sy);
856		841
857	if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))	842	if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
858	break;	843	break;
859		844
860	if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))	845	if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
…		…
865	/* If the destination is blocked, keep backing up until we	850	/* If the destination is blocked, keep backing up until we
866	* find a place for the player.	851	* find a place for the player.
867	*/	852	*/
868	for (; dist > 0; dist--)	853	for (; dist > 0; dist--)
869	{	854	{
870	if (get_map_flags (op->map, &m, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist,	855	if (get_map_flags (op->map, &m, op->x + DIRX (dir) * dist, op->y + DIRY (dir) * dist,
871	&sx, &sy) & (P_OUT_OF_MAP | P_IS_ALIVE))	856	&sx, &sy) & (P_OUT_OF_MAP | P_IS_ALIVE))
872	continue;	857	continue;
873		858
874		859
875	if (!OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))	860	if (!OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
876	break;	861	break;
877		862
878	}	863	}
879	if (!dist)	864	if (!dist)
880	{	865	{
881	new_draw_info (NDI_UNIQUE, 0, op, "Your spell failed!\n");	866	op->failmsg ("Your spell failed!\n");
882	return 0;	867	return 0;
883	}	868	}
884	}	869	}
885		870
886	/* Actually move the player now */	871	/* Actually move the player now */
887	if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))	872	if (!(op = op->map->insert (op, op->x + DIRX (dir) * dist, op->y + DIRY (dir) * dist, op)))
888	return 1;	873	return 1;
889		874
890	op->speed_left = -5. * fabs (op->speed); /* Freeze them for a short while */	875	op->speed_left = -5. * op->speed; /* Freeze them for a short while */
891		876
892	return 1;	877	return 1;
893	}	878	}
894		879
895	/* cast_heal: Heals something.	880	/* cast_heal: Heals something.
…		…
951	if (cure_disease (tmp, op, spell))	936	if (cure_disease (tmp, op, spell))
952	success = 1;	937	success = 1;
953		938
954	if (spell->attacktype & AT_POISON)	939	if (spell->attacktype & AT_POISON)
955	{	940	{
956	at = archetype::find ("poisoning");	941	at = archetype::find (shstr_poisoning);
957	poison = present_arch_in_ob (at, tmp);	942	poison = present_arch_in_ob (at, tmp);
958	if (poison)	943	if (poison)
959	{	944	{
960	success = 1;	945	success = 1;
961	new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");	946	new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
…		…
963	}	948	}
964	}	949	}
965		950
966	if (spell->attacktype & AT_CONFUSION)	951	if (spell->attacktype & AT_CONFUSION)
967	{	952	{
968	poison = present_in_ob_by_name (FORCE, "confusion", tmp);	953	poison = present_in_ob_by_name (FORCE, shstr_confusion, tmp);
969	if (poison)	954	if (poison)
970	{	955	{
971	success = 1;	956	success = 1;
972	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	957	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
973	poison->duration = 1;	958	poison->duration = 1;
974	}	959	}
975	}	960	}
976		961
977	if (spell->attacktype & AT_BLIND)	962	if (spell->attacktype & AT_BLIND)
978	{	963	{
979	at = archetype::find ("blindness");	964	at = archetype::find (shstr_blindness);
980	poison = present_arch_in_ob (at, tmp);	965	poison = present_arch_in_ob (at, tmp);
981	if (poison)	966	if (poison)
982	{	967	{
983	success = 1;	968	success = 1;
984	new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");	969	new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
…		…
1002	tmp->stats.grace = tmp->stats.maxgrace;	987	tmp->stats.grace = tmp->stats.maxgrace;
1003	success = 1;	988	success = 1;
1004	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");	989	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1005	}	990	}
1006		991
1007	if (spell->stats.food && tmp->stats.food < 999)	992	if (spell->stats.food && tmp->stats.food < MAX_FOOD)
1008	{	993	{
1009	tmp->stats.food += spell->stats.food;	994	tmp->stats.food += spell->stats.food;
1010		995	min_it (tmp->stats.food, MAX_FOOD);
1011	if (tmp->stats.food > 999)
1012	tmp->stats.food = 999;
1013		996
1014	success = 1;	997	success = 1;
1015	/* We could do something a bit better like the messages for healing above */	998	/* We could do something a bit better like the messages for healing above */
1016	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");	999	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1017	}	1000	}
…		…
1064	break;	1047	break;
1065	}	1048	}
1066	else if (spell_ob->race && spell_ob->race == tmp2->name)	1049	else if (spell_ob->race && spell_ob->race == tmp2->name)
1067	{	1050	{
1068	if (!silent)	1051	if (!silent)
1069	new_draw_info_format (NDI_UNIQUE, 0, op,
1070	"You can not cast %s while %s is in effect",	1052	op->failmsgf ("You can not cast %s while %s is in effect",
1071	&spell_ob->name, &tmp2->name_pl);	1053	&spell_ob->name, &tmp2->name_pl);
1072		1054
1073	return 0;	1055	return 0;
1074	}	1056	}
1075	}	1057	}
1076	}	1058	}
…		…
1092		1074
1093	new_draw_info_format (NDI_UNIQUE, 0, op,	1075	new_draw_info_format (NDI_UNIQUE, 0, op,
1094	"You create an aura of magical force. H<The effect will last for about %.10g seconds.>",	1076	"You create an aura of magical force. H<The effect will last for about %.10g seconds.>",
1095	TICK2TIME (duration));	1077	TICK2TIME (duration));
1096		1078
1097	force = get_archetype (FORCE_NAME);	1079	force = archetype::get (FORCE_NAME);
1098	force->subtype = FORCE_CHANGE_ABILITY;	1080	force->subtype = FORCE_CHANGE_ABILITY;
1099	force->duration = duration;	1081	force->duration = duration;
1100		1082
1101	if (spell_ob->race)	1083	if (spell_ob->race)
1102	force->name = spell_ob->race;	1084	force->name = spell_ob->race;
…		…
1105		1087
1106	force->name_pl = spell_ob->name;	1088	force->name_pl = spell_ob->name;
1107		1089
1108	force->speed = 1.0;	1090	force->speed = 1.0;
1109	force->speed_left = -1.0;	1091	force->speed_left = -1.0;
1110	SET_FLAG (force, FLAG_APPLIED);	1092	force->set_flag (FLAG_APPLIED);
1111		1093
1112	/* Now start processing the effects. First, protections */	1094	/* Now start processing the effects. First, protections */
1113	for (i = 0; i < NROFATTACKS; i++)	1095	for (i = 0; i < NROFATTACKS; i++)
1114	{
1115	if (spell_ob->resist[i])	1096	if (spell_ob->resist[i])
1116	{
1117	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);	1097	force->resist[i] = min (100, spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob));
1118	if (force->resist[i] > 100)
1119	force->resist[i] = 100;
1120	}
1121	}
1122		1098
1123	if (spell_ob->stats.hp)	1099	if (spell_ob->stats.hp)
1124	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);	1100	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
1125		1101
1126	if (tmp->type == PLAYER)	1102	if (tmp->type == PLAYER)
…		…
1145	}	1121	}
1146	}	1122	}
1147		1123
1148	force->move_type = spell_ob->move_type;	1124	force->move_type = spell_ob->move_type;
1149		1125
1150	if (QUERY_FLAG (spell_ob, FLAG_SEE_IN_DARK))	1126	if (spell_ob->flag [FLAG_SEE_IN_DARK])
1151	SET_FLAG (force, FLAG_SEE_IN_DARK);	1127	force->set_flag (FLAG_SEE_IN_DARK);
1152		1128
1153	if (QUERY_FLAG (spell_ob, FLAG_XRAYS))	1129	if (spell_ob->flag [FLAG_XRAYS])
1154	SET_FLAG (force, FLAG_XRAYS);	1130	force->set_flag (FLAG_XRAYS);
1155		1131
1156	/* Haste/bonus speed */	1132	/* Haste/bonus speed */
1157	if (spell_ob->stats.exp)	1133	if (spell_ob->stats.exp)
1158	{	1134	{
1159	if (op->speed > 0.5f)	1135	if (op->speed > 0.5f)
…		…
1212	}	1188	}
1213	}	1189	}
1214		1190
1215	if (force == NULL)	1191	if (force == NULL)
1216	{	1192	{
1217	force = get_archetype (FORCE_NAME);	1193	force = archetype::get (FORCE_NAME);
1218	force->subtype = FORCE_CHANGE_ABILITY;	1194	force->subtype = FORCE_CHANGE_ABILITY;
1219	if (spell_ob->race)	1195	if (spell_ob->race)
1220	force->name = spell_ob->race;	1196	force->name = spell_ob->race;
1221	else	1197	else
1222	force->name = spell_ob->name;	1198	force->name = spell_ob->name;
…		…
1237	{	1213	{
1238	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1214	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1239	}	1215	}
1240	return 0;	1216	return 0;
1241	}	1217	}
		1218
1242	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1219	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1243	force->speed = 1.0;	1220	force->speed = 1.0;
1244	force->speed_left = -1.0;	1221	force->speed_left = -1.0;
1245	SET_FLAG (force, FLAG_APPLIED);	1222	force->set_flag (FLAG_APPLIED);
1246		1223
1247	if (!god)	1224	if (!god)
1248	{	1225	{
1249	new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty.");	1226	new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty.");
1250	}	1227	}
1251	else	1228	else
1252	{	1229	{
1253	/* Only give out good benefits, and put a max on it */	1230	/* Only give out good benefits, and put a max on it */
1254	for (i = 0; i < NROFATTACKS; i++)	1231	for (i = 0; i < NROFATTACKS; i++)
1255	{
1256	if (god->resist[i] > 0)	1232	if (god->resist[i] > 0)
1257	{
1258	force->resist[i] = MIN (god->resist[i], spell_ob->resist[ATNR_GODPOWER]);	1233	force->resist[i] = min (god->resist[i], spell_ob->resist[ATNR_GODPOWER]);
1259	}	1234
1260	}
1261	force->path_attuned |= god->path_attuned;	1235	force->path_attuned |= god->path_attuned;
1262		1236
1263	if (spell_ob->attacktype)	1237	if (spell_ob->attacktype)
1264	force->slaying = god->slaying;	1238	force->slaying = god->slaying;
1265		1239
…		…
1285		1259
1286	/* Alchemy code by Mark Wedel	1260	/* Alchemy code by Mark Wedel
1287	*	1261	*
1288	* This code adds a new spell, called alchemy. Alchemy will turn	1262	* This code adds a new spell, called alchemy. Alchemy will turn
1289	* objects to pyrite ("false gold"), henceforth called gold nuggets.	1263	* objects to pyrite ("false gold"), henceforth called gold nuggets.
1290	*	1264	*
1291	* The value of the gold nuggets being about 90% of that of the item	1265	* The value of the gold nuggets being about 90% of that of the item
1292	* itself. It uses the value of the object before charisma adjustments,	1266	* itself. It uses the value of the object before charisma adjustments,
1293	* because the nuggets themselves will be will be adjusted by charisma	1267	* because the nuggets themselves will be will be adjusted by charisma
1294	* when sold.	1268	* when sold.
1295	*	1269	*
…		…
1307	* the nuggets, alchemy the gold from that, etc.	1281	* the nuggets, alchemy the gold from that, etc.
1308	* Otherwise, give 9 silver on the gold for other objects,	1282	* Otherwise, give 9 silver on the gold for other objects,
1309	* so that it would still be more affordable to haul	1283	* so that it would still be more affordable to haul
1310	* the stuff back to town.	1284	* the stuff back to town.
1311	*/	1285	*/
1312	if (QUERY_FLAG (obj, FLAG_UNPAID))	1286	if (obj->flag [FLAG_UNPAID])
1313	value = 0;	1287	value = 0;
1314	else if (obj->type == MONEY || obj->type == GEM)	1288	else if (obj->type == MONEY || obj->type == GEM)
1315	value /= 3;	1289	value /= 3;
1316	else	1290	else
1317	value = value * 9 / 10;	1291	value = value * 9 / 10;
…		…
1330	if (op->type != PLAYER)	1304	if (op->type != PLAYER)
1331	return 0;	1305	return 0;
1332		1306
1333	archetype *nugget[3];	1307	archetype *nugget[3];
1334		1308
1335	nugget[0] = archetype::find ("pyrite3");	1309	nugget[0] = archetype::find (shstr_pyrite3);
1336	nugget[1] = archetype::find ("pyrite2");	1310	nugget[1] = archetype::find (shstr_pyrite2);
1337	nugget[2] = archetype::find ("pyrite");	1311	nugget[2] = archetype::find (shstr_pyrite);
1338		1312
1339	/* Put a maximum weight of items that can be alchemised. Limits the power	1313	/* Put a maximum weight of items that can be alchemised. Limits the power
1340	* some, and also prevents people from alchemising every table/chair/clock	1314	* some, and also prevents people from alchemising every table/chair/clock
1341	* in sight	1315	* in sight
1342	*/	1316	*/
…		…
1371		1345
1372	for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)	1346	for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1373	{	1347	{
1374	next = tmp->above;	1348	next = tmp->above;
1375		1349
1376	if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&	1350	if (tmp->weight > 0 && !tmp->flag [FLAG_NO_PICK] &&
1377	!QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))	1351	!tmp->flag [FLAG_ALIVE] && !tmp->flag [FLAG_IS_CAULDRON])
1378	{	1352	{
1379	if (tmp->inv)	1353	if (tmp->inv)
1380	{	1354	{
1381	object *next1, *tmp1;	1355	object *next1, *tmp1;
1382		1356
1383	for (tmp1 = tmp->inv; tmp1; tmp1 = next1)	1357	for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1384	{	1358	{
1385	next1 = tmp1->below;	1359	next1 = tmp1->below;
1386	if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&	1360	if (tmp1->weight > 0 && !tmp1->flag [FLAG_NO_PICK] &&
1387	!QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))	1361	!tmp1->flag [FLAG_ALIVE] && !tmp1->flag [FLAG_IS_CAULDRON])
1388	alchemy_object (tmp1, value, weight);	1362	alchemy_object (tmp1, value, weight);
1389	}	1363	}
1390	}	1364	}
1391		1365
1392	alchemy_object (tmp, value, weight);	1366	alchemy_object (tmp, value, weight);
…		…
1397	}	1371	}
1398		1372
1399	value -= rndm (value >> 4);	1373	value -= rndm (value >> 4);
1400	value = min (value, value_max);	1374	value = min (value, value_max);
1401		1375
1402	for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)	1376	for (int i = 0; i < array_length (nugget); ++i)
1403	if (int nrof = value / nugget [i]->value)	1377	if (int nrof = value / nugget [i]->value)
1404	{	1378	{
1405	value -= nrof * nugget[i]->value;	1379	value -= nrof * nugget[i]->value;
1406		1380
1407	object *tmp = arch_to_object (nugget[i]);	1381	object *tmp = nugget[i]->instance ();
1408	tmp->nrof = nrof;	1382	tmp->nrof = nrof;
1409	tmp->flag [FLAG_IDENTIFIED] = true;	1383	tmp->flag [FLAG_IDENTIFIED] = true;
1410	op->map->insert (tmp, x, y, op, 0);	1384	op->map->insert (tmp, x, y, op, 0);
1411	}	1385	}
1412		1386
…		…
1425	int	1399	int
1426	remove_curse (object *op, object *caster, object *spell)	1400	remove_curse (object *op, object *caster, object *spell)
1427	{	1401	{
1428	int success = 0, was_one = 0;	1402	int success = 0, was_one = 0;
1429		1403
		1404	int num_uncurse = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
		1405
		1406	op->splay_marked ();
		1407
		1408	int typeflag = spell->last_sp ? FLAG_DAMNED : FLAG_CURSED;
		1409
1430	for (object *tmp = op->inv; tmp; tmp = tmp->below)	1410	for (object *tmp = op->inv; tmp && num_uncurse; tmp = tmp->below)
1431	if (QUERY_FLAG (tmp, FLAG_APPLIED) &&	1411	if (!tmp->invisible && tmp->flag [typeflag])
1432	((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1433	(QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1434	{	1412	{
1435	was_one++;	1413	++was_one;
1436		1414
1437	if (tmp->level <= casting_level (caster, spell))	1415	if (tmp->level <= casting_level (caster, spell))
1438	{	1416	{
1439	success++;	1417	++success;
1440	if (QUERY_FLAG (spell, FLAG_DAMNED))	1418	--num_uncurse;
1441	CLEAR_FLAG (tmp, FLAG_DAMNED);
1442		1419
1443	CLEAR_FLAG (tmp, FLAG_CURSED);	1420	tmp->clr_flag (typeflag);
1444	CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);	1421	tmp->clr_flag (FLAG_CURSED);
		1422	tmp->clr_flag (FLAG_KNOWN_CURSED);
1445	tmp->value = 0; /* Still can't sell it */	1423	tmp->value = 0; /* Still can't sell it */
1446		1424
1447	if (object *pl = tmp->visible_to ())	1425	if (object *pl = tmp->visible_to ())
1448	esrv_update_item (UPD_FLAGS, pl, tmp);	1426	esrv_update_item (UPD_FLAGS, pl, tmp);
1449	}	1427	}
1450	}	1428	}
1451		1429
1452	if (op->type == PLAYER)	1430	if (op->type == PLAYER)
1453	{	1431	{
1454	if (success)	1432	if (success)
1455	new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");	1433	new_draw_info (NDI_UNIQUE, 0, op, "You realise that some of your items look shinier now. H<You successfully removed some curses.>");
1456	else	1434	else
1457	{	1435	{
1458	if (was_one)	1436	if (was_one)
1459	new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");	1437	new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove any curse. H<The spell was not strong enough.>");
1460	else	1438	else
1461	new_draw_info (NDI_UNIQUE, 0, op, "You are not using any cursed items.");	1439	new_draw_info (NDI_UNIQUE, 0, op, "You are not having any cursed items. H<Epic fail.>");
1462	}	1440	}
1463	}	1441	}
1464		1442
1465	return success;	1443	return success;
1466	}	1444	}
1467		1445
1468	/* Identifies objects in the players inventory/on the ground */	1446	/* Identifies objects in the players inventory/on the ground */
1469	int	1447	int
1470	cast_identify (object *op, object *caster, object *spell)	1448	cast_identify (object *op, object *caster, object *spell)
1471	{	1449	{
1472	object *tmp;
1473	dynbuf_text &buf = msg_dynbuf; buf.clear ();	1450	dynbuf_text &buf = msg_dynbuf; buf.clear ();
1474		1451
1475	int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));	1452	int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1476		1453
		1454	op->splay_marked ();
		1455
1477	for (tmp = op->inv; tmp; tmp = tmp->below)	1456	for (object *tmp = op->inv; tmp; tmp = tmp->below)
1478	{	1457	{
1479	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))	1458	if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && tmp->need_identify ())
1480	{	1459	{
1481	identify (tmp);	1460	identify (tmp);
1482		1461
1483	if (op->type == PLAYER)	1462	if (op->type == PLAYER)
1484	{	1463	{
…		…
1497	* stuff on the floor. Only identify stuff on the floor if the spell	1476	* stuff on the floor. Only identify stuff on the floor if the spell
1498	* was not fully used.	1477	* was not fully used.
1499	*/	1478	*/
1500	if (num_ident)	1479	if (num_ident)
1501	{	1480	{
1502	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)	1481	for (object *tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1503	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))	1482	if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && tmp->need_identify ())
1504	{	1483	{
1505	identify (tmp);	1484	identify (tmp);
1506		1485
1507	if (object *pl = tmp->visible_to ())	1486	if (object *pl = tmp->visible_to ())
1508	{	1487	{
…		…
1534		1513
1535	int	1514	int
1536	cast_detection (object *op, object *caster, object *spell, object *skill)	1515	cast_detection (object *op, object *caster, object *spell, object *skill)
1537	{	1516	{
1538	object *tmp, *last, *god, *detect;	1517	object *tmp, *last, *god, *detect;
1539	int done_one, range, mflags, floor, level;	1518	int done_one, range, floor, level;
1540	sint16 x, y, nx, ny;	1519	sint16 x, y, nx, ny;
1541	maptile *m;	1520	maptile *m;
1542		1521
1543	/* We precompute some values here so that we don't have to keep	1522	/* We precompute some values here so that we don't have to keep
1544	* doing it over and over again.	1523	* doing it over and over again.
…		…
1548	range = spell->range + SP_level_range_adjust (caster, spell);	1527	range = spell->range + SP_level_range_adjust (caster, spell);
1549		1528
1550	if (!skill)	1529	if (!skill)
1551	skill = caster;	1530	skill = caster;
1552		1531
		1532	dynbuf buf;
1553	unordered_mapwalk (op, -range, -range, range, range)	1533	unordered_mapwalk (buf, op, -range, -range, range, range)
1554	{	1534	{
1555	/* For most of the detections, we only detect objects above the	1535	/* For most of the detections, we only detect objects above the
1556	* floor. But this is not true for show invisible.	1536	* floor. But this is not true for show invisible.
1557	* Basically, we just go and find the top object and work	1537	* Basically, we just go and find the top object and work
1558	* down - that is easier than working up.	1538	* down - that is easier than working up.
1559	*/	1539	*/
1560		1540
1561	for (last = NULL, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)	1541	for (last = 0, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1562	last = tmp;	1542	last = tmp;
1563		1543
1564	/* Shouldn't happen, but if there are no objects on a space, this	1544	/* Shouldn't happen, but if there are no objects on a space, this
1565	* would happen.	1545	* would happen.
1566	*/	1546	*/
1567	if (!last)	1547	if (!last)
1568	continue;	1548	continue;
1569		1549
1570	done_one = 0;	1550	done_one = 0;
1571	floor = 0;	1551	floor = 0;
1572	detect = NULL;	1552	detect = 0;
1573	for (tmp = last; tmp; tmp = tmp->below)	1553	for (tmp = last; tmp; tmp = tmp->below)
1574	{	1554	{
1575	/* show invisible */	1555	/* show invisible */
1576	if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&	1556	if (spell->flag [FLAG_MAKE_INVIS]
1577	/* Might there be other objects that we can make visible? */	1557	/* Might there be other objects that we can make visible? */
1578	(tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER)	1558	&& (tmp->invisible && (tmp->flag [FLAG_MONSTER]
1579	|| (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ))	1559	|| (tmp->type == PLAYER && !tmp->flag [FLAG_WIZ])
1580	|| tmp->type == T_HANDLE	1560	|| tmp->type == T_HANDLE
1581	|| tmp->type == TRAPDOOR	1561	|| tmp->type == TRAPDOOR
1582	|| tmp->type == EXIT	1562	|| tmp->type == EXIT
1583	|| tmp->type == HOLE	1563	|| tmp->type == HOLE
1584	|| tmp->type == BUTTON	1564	|| tmp->type == BUTTON
1585	|| tmp->type == TELEPORTER	1565	|| tmp->type == TELEPORTER
1586	|| tmp->type == GATE	1566	|| tmp->type == GATE
1587	|| tmp->type == LOCKED_DOOR	1567	|| tmp->type == LOCKED_DOOR
1588	|| tmp->type == WEAPON	1568	|| tmp->type == WEAPON
1589	|| tmp->type == ALTAR	1569	|| tmp->type == ALTAR
1590	|| tmp->type == SIGN	1570	|| (tmp->type == SIGN && tmp->face != magicmouth_face)
1591	|| tmp->type == TRIGGER_PEDESTAL	1571	|| tmp->type == TRIGGER_PEDESTAL
1592	|| tmp->type == SPECIAL_KEY	1572	|| tmp->type == SPECIAL_KEY
1593	|| tmp->type == TREASURE	1573	|| tmp->type == TREASURE
1594	|| tmp->type == BOOK	1574	|| tmp->type == BOOK
1595	|| tmp->type == HOLY_ALTAR	1575	|| tmp->type == HOLY_ALTAR
1596	|| tmp->type == CONTAINER)))	1576	|| tmp->type == CONTAINER)))
1597	{	1577	{
		1578	printf ("show inv %s\n", tmp->debug_desc());//D
1598	if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)	1579	if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1599	{	1580	{
1600	tmp->invisible = 0;	1581	tmp->invisible = 0;
1601	done_one = 1;	1582	done_one = 1;
1602	}	1583	}
1603	}	1584	}
1604		1585
1605	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1586	if (tmp->flag [FLAG_IS_FLOOR])
1606	floor = 1;	1587	floor = 1;
1607		1588
1608	/* All detections below this point don't descend beneath the floor,	1589	/* All detections below this point don't descend beneath the floor,
1609	* so just continue on. We could be clever and look at the type of	1590	* so just continue on. We could be clever and look at the type of
1610	* detection to completely break out if we don't care about objects beneath	1591	* detection to completely break out if we don't care about objects beneath
…		…
1619	* difficult to see what object is magical/cursed, so the	1600	* difficult to see what object is magical/cursed, so the
1620	* effect wouldn't be as apparent.	1601	* effect wouldn't be as apparent.
1621	*/	1602	*/
1622		1603
1623	/* detect magic */	1604	/* detect magic */
1624	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&	1605	if (spell->flag [FLAG_KNOWN_MAGICAL]
1625	!QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))	1606	&& !tmp->flag [FLAG_KNOWN_MAGICAL]
		1607	&& !tmp->flag [FLAG_IDENTIFIED]
		1608	&& tmp->need_identify ()
		1609	&& is_magical (tmp))
1626	{	1610	{
1627	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1611	tmp->set_flag (FLAG_KNOWN_MAGICAL);
1628	/* make runes more visibile */	1612	/* make runes more visible */
1629	if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)	1613	if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1630	tmp->stats.Cha /= 4;	1614	tmp->stats.Cha /= 4;
1631		1615
1632	done_one = 1;	1616	done_one = 1;
1633	}	1617	}
1634		1618
1635	/* detect monster */	1619	/* detect monster */
1636	if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))	1620	if (spell->flag [FLAG_MONSTER] && (tmp->flag [FLAG_MONSTER] || tmp->type == PLAYER))
1637	{	1621	{
1638	done_one = 2;	1622	done_one = 2;
1639		1623
1640	if (!detect)	1624	if (!detect)
1641	detect = tmp;	1625	detect = tmp;
…		…
1643		1627
1644	/* Basically, if race is set in the spell, then the creatures race must	1628	/* Basically, if race is set in the spell, then the creatures race must
1645	* match that. if the spell race is set to GOD, then the gods opposing	1629	* match that. if the spell race is set to GOD, then the gods opposing
1646	* race must match.	1630	* race must match.
1647	*/	1631	*/
1648	if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&	1632	if (spell->race && tmp->flag [FLAG_MONSTER] && tmp->race &&
1649	((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||	1633	((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||
1650	spell->race.contains (tmp->race)))	1634	spell->race.contains (tmp->race)))
1651	{	1635	{
1652	done_one = 2;	1636	done_one = 2;
1653		1637
1654	if (!detect)	1638	if (!detect)
1655	detect = tmp;	1639	detect = tmp;
1656	}	1640	}
1657		1641
1658	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1642	if (spell->flag [FLAG_KNOWN_CURSED]
1659	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))	1643	&& !tmp->flag [FLAG_KNOWN_CURSED]
		1644	&& tmp->need_identify ()
		1645	&& (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED]))
1660	{	1646	{
1661	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1647	tmp->set_flag (FLAG_KNOWN_CURSED);
1662	done_one = 1;	1648	done_one = 1;
		1649	}
		1650
		1651	// Do mining detection spell:
		1652	if (spell->last_sp == 1) // 1 - detect any vein
		1653	{
		1654	if (tmp->type == VEIN)
		1655	{
		1656	if (tmp->other_arch)
		1657	{
		1658	if (!detect)
		1659	detect = tmp->other_arch;
		1660	done_one = 2;
		1661	}
		1662	else
		1663	done_one = 1;
		1664	}
1663	}	1665	}
1664	} /* for stack of objects on this space */	1666	} /* for stack of objects on this space */
1665		1667
1666	/* Code here puts an effect of the spell on the space, so you can see	1668	/* Code here puts an effect of the spell on the space, so you can see
1667	* where the magic is.	1669	* where the magic is.
1668	*/	1670	*/
1669	if (done_one)	1671	if (done_one)
1670	{	1672	{
1671	object *detect_ob = arch_to_object (spell->other_arch);	1673	object *detect_ob = spell->other_arch->instance ();
1672		1674
1673	/* if this is set, we want to copy the face */	1675	/* if this is set, we want to copy the face */
1674	if (done_one == 2 && detect)	1676	if (done_one == 2 && detect)
1675	{	1677	{
1676	detect_ob->face = detect->face;	1678	detect_ob->face = detect->face;
1677	detect_ob->animation_id = detect->animation_id;	1679	detect_ob->animation_id = detect->animation_id;
1678	detect_ob->anim_speed = detect->anim_speed;	1680	detect_ob->anim_speed = detect->anim_speed;
1679	detect_ob->last_anim = 0;	1681	detect_ob->last_anim = 0;
1680	/* by default, the detect_ob is already animated */	1682	/* by default, the detect_ob is already animated */
1681	if (!QUERY_FLAG (detect, FLAG_ANIMATE))	1683	if (!detect->flag [FLAG_ANIMATE])
1682	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);	1684	detect_ob->clr_flag (FLAG_ANIMATE);
1683	}	1685	}
1684		1686
1685	m->insert (detect_ob, nx, ny, op);	1687	m->insert (detect_ob, nx, ny, op, INS_ON_TOP);
1686	}	1688	}
1687	} /* for processing the surrounding spaces */	1689	} /* for processing the surrounding spaces */
1688		1690
1689		1691
1690	/* Now process objects in the players inventory if detect curse or magic */	1692	/* Now process objects in the players inventory if detect curse or magic */
1691	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))	1693	if (spell->flag [FLAG_KNOWN_CURSED] || spell->flag [FLAG_KNOWN_MAGICAL])
1692	{	1694	{
1693	done_one = 0;	1695	done_one = 0;
1694		1696
1695	for (tmp = op->inv; tmp; tmp = tmp->below)	1697	for (tmp = op->inv; tmp; tmp = tmp->below)
1696	{	1698	{
1697	if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1699	if (!tmp->invisible && !tmp->flag [FLAG_IDENTIFIED])
1698	{	1700	{
1699	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))	1701	if (spell->flag [FLAG_KNOWN_MAGICAL] && is_magical (tmp) && !tmp->flag [FLAG_KNOWN_MAGICAL])
1700	{	1702	{
1701	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1703	tmp->set_flag (FLAG_KNOWN_MAGICAL);
1702		1704
1703	if (object *pl = tmp->visible_to ())	1705	if (object *pl = tmp->visible_to ())
1704	esrv_update_item (UPD_FLAGS, pl, tmp);	1706	esrv_update_item (UPD_FLAGS, pl, tmp);
1705	}	1707	}
1706		1708
1707	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1709	if (spell->flag [FLAG_KNOWN_CURSED] && !tmp->flag [FLAG_KNOWN_CURSED] &&
1708	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))	1710	(tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED]))
1709	{	1711	{
1710	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1712	tmp->set_flag (FLAG_KNOWN_CURSED);
1711		1713
1712	if (object *pl = tmp->visible_to ())	1714	if (object *pl = tmp->visible_to ())
1713	esrv_update_item (UPD_FLAGS, pl, tmp);	1715	esrv_update_item (UPD_FLAGS, pl, tmp);
1714	}	1716	}
1715	} /* if item is not identified */	1717	} /* if item is not identified */
…		…
1767	sint16 x, y;	1769	sint16 x, y;
1768	maptile *m;	1770	maptile *m;
1769	int mflags;	1771	int mflags;
1770		1772
1771	m = op->map;	1773	m = op->map;
1772	x = op->x + freearr_x[dir];	1774	x = op->x + DIRX (dir);
1773	y = op->y + freearr_y[dir];	1775	y = op->y + DIRY (dir);
1774		1776
1775	mflags = get_map_flags (m, &m, x, y, &x, &y);	1777	mflags = get_map_flags (m, &m, x, y, &x, &y);
1776		1778
1777	if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)	1779	if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
1778	{	1780	{
1779	for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)	1781	for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)
1780	if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))	1782	if (plyr != op && plyr->flag [FLAG_ALIVE])
1781	break;	1783	break;
1782	}	1784	}
1783		1785
1784		1786
1785	/* If we did not find a player in the specified direction, transfer	1787	/* If we did not find a player in the specified direction, transfer
1786	* to anyone on top of us. This is used for the rune of transference mostly.	1788	* to anyone on top of us. This is used for the rune of transference mostly.
1787	*/	1789	*/
1788	if (plyr == NULL)	1790	if (plyr == NULL)
1789	for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)	1791	for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)
1790	if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))	1792	if (plyr != op && plyr->flag [FLAG_ALIVE])
1791	break;	1793	break;
1792		1794
1793	if (!plyr)	1795	if (!plyr)
1794	{	1796	{
1795	new_draw_info (NDI_BLACK, 0, op, "There is no one there.");	1797	op->failmsg ("There is no one there.");
1796	return 0;	1798	return 0;
1797	}	1799	}
1798	/* give sp */	1800	/* give sp */
1799	if (spell->stats.dam > 0)	1801	if (spell->stats.dam > 0)
1800	{	1802	{
…		…
1812	if (rate > 95)	1814	if (rate > 95)
1813	rate = 95;	1815	rate = 95;
1814		1816
1815	sucked = (plyr->stats.sp * rate) / 100;	1817	sucked = (plyr->stats.sp * rate) / 100;
1816	plyr->stats.sp -= sucked;	1818	plyr->stats.sp -= sucked;
1817	if (QUERY_FLAG (op, FLAG_ALIVE))	1819	if (op->flag [FLAG_ALIVE])
1818	{	1820	{
1819	/* Player doesn't get full credit */	1821	/* Player doesn't get full credit */
1820	sucked = (sucked * rate) / 100;	1822	sucked = (sucked * rate) / 100;
1821	op->stats.sp += sucked;	1823	op->stats.sp += sucked;
1822	if (sucked > 0)	1824	if (sucked > 0)
…		…
1842	object *tmp, *head, *next;	1844	object *tmp, *head, *next;
1843	int mflags;	1845	int mflags;
1844	maptile *m;	1846	maptile *m;
1845	sint16 sx, sy;	1847	sint16 sx, sy;
1846		1848
1847	sx = op->x + freearr_x[dir];	1849	sx = op->x + DIRX (dir);
1848	sy = op->y + freearr_y[dir];	1850	sy = op->y + DIRY (dir);
1849	m = op->map;	1851	m = op->map;
1850	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);	1852	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
1851	if (mflags & P_OUT_OF_MAP)	1853	if (mflags & P_OUT_OF_MAP)
1852	return;	1854	return;
1853		1855
…		…
1866		1868
1867	/* don't attack our own spells */	1869	/* don't attack our own spells */
1868	if (tmp->owner && tmp->owner == op->owner)	1870	if (tmp->owner && tmp->owner == op->owner)
1869	continue;	1871	continue;
1870		1872
1871	/* Basically, if the object is magical and not counterspell,	1873	/* Basically, if the object is magical and not counterspell,
1872	* we will more or less remove the object. Don't counterspell	1874	* we will more or less remove the object. Don't counterspell
1873	* monsters either.	1875	* monsters either.
1874	*/	1876	*/
1875		1877
1876	if (head->attacktype & AT_MAGIC	1878	if (head->attacktype & AT_MAGIC
1877	&& !(head->attacktype & AT_COUNTERSPELL)	1879	&& !(head->attacktype & AT_COUNTERSPELL)
1878	&& !QUERY_FLAG (head, FLAG_MONSTER)	1880	&& !head->flag [FLAG_MONSTER]
1879	&& (op->level > head->level))	1881	&& (op->level > head->level))
1880	head->destroy ();	1882	head->destroy ();
1881	else	1883	else
1882	switch (head->type)	1884	switch (head->type)
1883	{	1885	{
1884	case SPELL_EFFECT:	1886	case SPELL_EFFECT:
1885	// XXX: Don't affect floor spelleffects. See also XXX comment	1887	// XXX: Don't affect floor spelleffects. See also XXX comment
1886	// about sanctuary in spell_util.C	1888	// about sanctuary in spell_util.C
1887	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1889	if (tmp->flag [FLAG_IS_FLOOR])
1888	continue;	1890	continue;
1889		1891
1890	if (op->level > head->level)	1892	if (op->level > head->level)
1891	head->destroy ();	1893	head->destroy ();
1892		1894
…		…
1915		1917
1916	object *tmp, *god = find_god (determine_god (op));	1918	object *tmp, *god = find_god (determine_god (op));
1917		1919
1918	if (!god)	1920	if (!god)
1919	{	1921	{
1920	new_draw_info (NDI_UNIQUE, 0, op, "You can't consecrate anything if you don't worship a god!");	1922	op->failmsg ("You can't consecrate anything if you don't worship a god!");
1921	return 0;	1923	return 0;
1922	}	1924	}
1923		1925
1924	for (tmp = op->below; tmp; tmp = tmp->below)	1926	for (tmp = op->below; tmp; tmp = tmp->below)
1925	{	1927	{
1926	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1928	if (tmp->flag [FLAG_IS_FLOOR])
1927	break;	1929	break;
1928	if (tmp->type == HOLY_ALTAR)	1930	if (tmp->type == HOLY_ALTAR)
1929	{	1931	{
1930		1932
1931	if (tmp->level > casting_level (caster, spell))	1933	if (tmp->level > casting_level (caster, spell))
1932	{	1934	{
1933	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);	1935	op->failmsgf ("You are not powerful enough to reconsecrate the %s", &tmp->name);
1934	return 0;	1936	return 0;
1935	}	1937	}
1936	else	1938	else
1937	{	1939	{
1938	/* If we got here, we are consecrating an altar */	1940	/* If we got here, we are consecrating an altar */
…		…
1947	new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);	1949	new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
1948	return 1;	1950	return 1;
1949	}	1951	}
1950	}	1952	}
1951	}	1953	}
1952	new_draw_info (NDI_UNIQUE, 0, op, "You are not standing over an altar!");	1954
		1955	op->failmsg ("You are not standing over an altar!");
1953	return 0;	1956	return 0;
1954	}	1957	}
1955		1958
1956	/* animate_weapon -	1959	/* animate_weapon -
1957	* Generalization of staff_to_snake. Makes a golem out of the caster's weapon.	1960	* Generalization of staff_to_snake. Makes a golem out of the caster's weapon.
1958	* The golem is based on the archetype specified, modified by the caster's level	1961	* The golem is based on the archetype specified, modified by the caster's level
1959	* and the attributes of the weapon. The weapon is inserted in the golem's	1962	* and the attributes of the weapon. The weapon is inserted in the golem's
1960	* inventory so that it falls to the ground when the golem dies.	1963	* inventory so that it falls to the ground when the golem dies.
1961	* This code was very odd - code early on would only let players use the spell,	1964	* This code was very odd - code early on would only let players use the spell,
1962	* yet the code wass full of player checks. I've presumed that the code	1965	* yet the code wass full of player checks. I've presumed that the code
1963	* that only let players use it was correct, and removed all the other	1966	* that only let players use it was correct, and removed all the other
1964	* player checks. MSW 2003-01-06	1967	* player checks. MSW 2003-01-06
1965	*/	1968	*/
1966	int	1969	int
1967	animate_weapon (object *op, object *caster, object *spell, int dir)	1970	animate_weapon (object *op, object *caster, object *spell, int dir)
1968	{	1971	{
1969	object *weapon, *tmp;
1970	char buf[MAX_BUF];	1972	char buf[MAX_BUF];
1971	int a, i;	1973	int a, i;
1972	sint16 x, y;	1974	sint16 x, y;
1973	maptile *m;	1975	maptile *m;
1974		1976
…		…
1992	/* if no direction specified, pick one */	1994	/* if no direction specified, pick one */
1993	if (!dir)	1995	if (!dir)
1994	dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);	1996	dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);
1995		1997
1996	m = op->map;	1998	m = op->map;
1997	x = op->x + freearr_x[dir];	1999	x = op->x + DIRX (dir);
1998	y = op->y + freearr_y[dir];	2000	y = op->y + DIRY (dir);
1999		2001
2000	/* if there's no place to put the golem, abort */	2002	/* if there's no place to put the golem, abort */
2001	if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)	2003	if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
2002	|| ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))	2004	|| ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2003	{	2005	{
2004	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	2006	op->failmsg ("There is something in the way.");
2005	return 0;	2007	return 0;
2006	}	2008	}
2007		2009
2008	/* Use the weapon marked by the player. */	2010	/* Use the weapon marked by the player. */
2009	weapon = find_marked_object (op);	2011	object *weapon = op->mark ();
2010		2012
2011	if (!weapon)	2013	if (!weapon)
2012	{	2014	{
2013	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");	2015	op->failmsg ("You must mark a weapon to use with this spell!");
2014	return 0;	2016	return 0;
2015	}	2017	}
2016		2018
2017	if (spell->race && weapon->arch->archname != spell->race)	2019	if (spell->race && weapon->arch->archname != spell->race)
2018	{	2020	{
2019	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");	2021	op->failmsg ("The spell fails to transform your weapon.");
2020	return 0;	2022	return 0;
2021	}	2023	}
2022		2024
2023	if (weapon->type != WEAPON)	2025	if (weapon->type != WEAPON)
2024	{	2026	{
2025	new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");	2027	op->failmsg ("You need to wield a weapon to animate it.");
2026	return 0;	2028	return 0;
2027	}	2029	}
2028		2030
2029	if (QUERY_FLAG (weapon, FLAG_APPLIED))	2031	if (weapon->flag [FLAG_APPLIED])
2030	{	2032	{
2031	new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));	2033	op->failmsgf ("You need to unequip %s before using it in this spell", query_name (weapon));
2032	return 0;	2034	return 0;
2033	}	2035	}
2034		2036
2035	weapon = weapon->split ();	2037	weapon = weapon->split ();
2036		2038
2037	/* create the golem object */	2039	/* create the golem object */
2038	tmp = arch_to_object (spell->other_arch);	2040	object *tmp = spell->other_arch->instance ();
2039		2041
2040	/* if animated by a player, give the player control of the golem */	2042	/* if animated by a player, give the player control of the golem */
2041	CLEAR_FLAG (tmp, FLAG_MONSTER);	2043	tmp->clr_flag (FLAG_MONSTER);
2042	tmp->stats.exp = 0;	2044	tmp->stats.exp = 0;
2043	add_friendly_object (tmp);	2045	add_friendly_object (tmp);
2044	tmp->type = GOLEM;	2046	tmp->type = GOLEM;
2045	tmp->set_owner (op);	2047	tmp->set_owner (op);
2046	op->contr->golem = tmp;	2048	op->contr->golem = tmp;
…		…
2048		2050
2049	/* Give the weapon to the golem now. A bit of a hack to check the	2051	/* Give the weapon to the golem now. A bit of a hack to check the
2050	* removed flag - it should only be set if weapon->split was	2052	* removed flag - it should only be set if weapon->split was
2051	* used above.	2053	* used above.
2052	*/	2054	*/
2053	if (!QUERY_FLAG (weapon, FLAG_REMOVED))	2055	if (!weapon->flag [FLAG_REMOVED])
2054	weapon->remove ();	2056	weapon->remove ();
2055		2057
2056	tmp->insert (weapon);	2058	tmp->insert (weapon);
2057		2059
2058	/* To do everything necessary to let a golem use the weapon is a pain,	2060	/* To do everything necessary to let a golem use the weapon is a pain,
2059	* so instead, just set it as equipped (otherwise, we need to update	2061	* so instead, just set it as equipped (otherwise, we need to update
2060	* body_info, skills, etc)	2062	* body_info, skills, etc)
2061	*/	2063	*/
2062	SET_FLAG (tmp, FLAG_USE_WEAPON);	2064	tmp->set_flag (FLAG_USE_WEAPON);
2063	SET_FLAG (weapon, FLAG_APPLIED);	2065	weapon->set_flag (FLAG_APPLIED);
2064	tmp->update_stats ();	2066	tmp->update_stats ();
2065		2067
2066	/* There used to be 'odd' code that basically seemed to take the absolute	2068	/* There used to be 'odd' code that basically seemed to take the absolute
2067	* value of the weapon->magic an use that. IMO, that doesn't make sense -	2069	* value of the weapon->magic an use that. IMO, that doesn't make sense -
2068	* if you're using a crappy weapon, it shouldn't be as good.	2070	* if you're using a crappy weapon, it shouldn't be as good.
…		…
2088		2090
2089	/* attacktype */	2091	/* attacktype */
2090	if (!tmp->attacktype)	2092	if (!tmp->attacktype)
2091	tmp->attacktype = AT_PHYSICAL;	2093	tmp->attacktype = AT_PHYSICAL;
2092		2094
2093	if (materialtype_t *mt = name_to_material (op->materialname))
2094	{
2095	for (i = 0; i < NROFATTACKS; i++)	2095	for (i = 0; i < NROFATTACKS; i++)
2096	tmp->resist[i] = 50 - (mt->save[i] * 5);	2096	tmp->resist[i] = 50 - (op->material->save[i] * 5);
2097	a = mt->save[0];	2097
2098	}	2098	a = op->material->save[0];
2099	else
2100	{
2101	for (i = 0; i < NROFATTACKS; i++)
2102	tmp->resist[i] = 5;
2103	a = 10;
2104	}
2105		2099
2106	/* Set weapon's immunity */	2100	/* Set weapon's immunity */
2107	tmp->resist[ATNR_CONFUSION] = 100;	2101	tmp->resist[ATNR_CONFUSION] = 100;
2108	tmp->resist[ATNR_POISON] = 100;	2102	tmp->resist[ATNR_POISON] = 100;
2109	tmp->resist[ATNR_SLOW] = 100;	2103	tmp->resist[ATNR_SLOW] = 100;
…		…
2117	/* Improve weapon's armour value according to best save vs. physical of its material */	2111	/* Improve weapon's armour value according to best save vs. physical of its material */
2118		2112
2119	if (a > 14)	2113	if (a > 14)
2120	a = 14;	2114	a = 14;
2121		2115
2122	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));	2116	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.f - (float) tmp->resist[ATNR_PHYSICAL]) / (30.f - 2.f * a));
2123		2117
2124	/* Determine golem's speed */	2118	/* Determine golem's speed */
2125	tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));	2119	tmp->set_speed (min (3.33f, 0.4f + 0.1f * SP_level_range_adjust (caster, spell)));
2126		2120
2127	if (!spell->race)	2121	if (!spell->race)
2128	{	2122	{
2129	sprintf (buf, "animated %s", &weapon->name);	2123	sprintf (buf, "animated %s", &weapon->name);
2130	tmp->name = buf;	2124	tmp->name = buf;
…		…
2136	tmp->state = weapon->state;	2130	tmp->state = weapon->state;
2137	tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];	2131	tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2138	}	2132	}
2139		2133
2140	/* make experience increase in proportion to the strength of the summoned creature. */	2134	/* make experience increase in proportion to the strength of the summoned creature. */
2141	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));	2135	tmp->stats.exp *= 1 + (max (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));
2142		2136
2143	tmp->speed_left = -1;	2137	tmp->speed_left = -1;
2144	tmp->direction = dir;	2138	tmp->direction = dir;
2145		2139
2146	m->insert (tmp, x, y, op);	2140	m->insert (tmp, x, y, op);
…		…
2163	success = op->map->change_map_light (spell->stats.dam);	2157	success = op->map->change_map_light (spell->stats.dam);
2164		2158
2165	if (!success)	2159	if (!success)
2166	{	2160	{
2167	if (spell->stats.dam < 0)	2161	if (spell->stats.dam < 0)
2168	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");	2162	op->failmsg ("It can be no brighter here.");
2169	else	2163	else
2170	new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");	2164	op->failmsg ("It can be no darker here.");
2171	}	2165	}
2172		2166
2173	return success;	2167	return success;
2174	}	2168	}
2175		2169
…		…
2185		2179
2186	new_aura = present_arch_in_ob (spell->other_arch, op);	2180	new_aura = present_arch_in_ob (spell->other_arch, op);
2187	if (new_aura)	2181	if (new_aura)
2188	refresh = 1;	2182	refresh = 1;
2189	else	2183	else
2190	new_aura = arch_to_object (spell->other_arch);	2184	new_aura = spell->other_arch->instance ();
2191		2185
2192	new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);	2186	new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2193		2187
2194	new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	2188	new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2195		2189
…		…
2211		2205
2212	/* move aura function. An aura is a part of someone's inventory,	2206	/* move aura function. An aura is a part of someone's inventory,
2213	* which he carries with him, but which acts on the map immediately	2207	* which he carries with him, but which acts on the map immediately
2214	* around him.	2208	* around him.
2215	* Aura parameters:	2209	* Aura parameters:
2216	* duration: duration counter.	2210	* duration: duration counter.
2217	* attacktype: aura's attacktype	2211	* attacktype: aura's attacktype
2218	* other_arch: archetype to drop where we attack	2212	* other_arch: archetype to drop where we attack
2219	*/	2213	*/
2220	void	2214	void
2221	move_aura (object *aura)	2215	move_aura (object *aura)
2222	{	2216	{
2223	/* auras belong in inventories */	2217	/* auras belong in inventories */
2224	object *env = aura->env;	2218	object *env = aura->env;
2225	object *owner = aura->owner;	2219	object *owner = aura->owner;
2226		2220
2227	/* no matter what we've gotta remove the aura...	2221	/* no matter what we've gotta remove the aura...
2228	* we'll put it back if its time isn't up.	2222	* we'll put it back if its time isn't up.
2229	*/	2223	*/
2230	aura->remove ();	2224	aura->remove ();
2231		2225
2232	/* exit if we're out of gas */	2226	/* exit if we're out of gas */
2233	if (aura->duration-- < 0)	2227	if (aura->duration-- < 0)
…		…
2242	aura->destroy ();	2236	aura->destroy ();
2243	return;	2237	return;
2244	}	2238	}
2245		2239
2246	/* we need to jump out of the inventory for a bit	2240	/* we need to jump out of the inventory for a bit
2247	* in order to hit the map conveniently.	2241	* in order to hit the map conveniently.
2248	*/	2242	*/
2249	aura->insert_at (env, aura);	2243	aura->insert_at (env, aura);
2250		2244
2251	for (int i = 1; i < 9; i++)	2245	for (int i = 1; i < 9; i++)
2252	{	2246	{
…		…
2260	if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))	2254	if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2261	{	2255	{
2262	hit_map (aura, i, aura->attacktype, 0);	2256	hit_map (aura, i, aura->attacktype, 0);
2263		2257
2264	if (aura->other_arch)	2258	if (aura->other_arch)
2265	pos.insert (arch_to_object (aura->other_arch), aura);	2259	pos.insert (aura->other_arch->instance (), aura);
2266	}	2260	}
2267	}	2261	}
2268		2262
2269	/* put the aura back in the player's inventory */	2263	/* put the aura back in the player's inventory */
2270	env->insert (aura);	2264	env->insert (aura);
…		…
2280	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)	2274	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
2281	{	2275	{
2282	int atk_lev, def_lev;	2276	int atk_lev, def_lev;
2283	object *victim = tmp->head_ ();	2277	object *victim = tmp->head_ ();
2284		2278
2285	if (!QUERY_FLAG (victim, FLAG_MONSTER))	2279	if (!victim->flag [FLAG_MONSTER])
2286	continue;	2280	continue;
2287		2281
2288	if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))	2282	if (victim->flag [FLAG_UNAGGRESSIVE])
2289	continue;	2283	continue;
2290		2284
2291	if (victim->stats.exp == 0)	2285	if (victim->stats.exp == 0)
2292	continue;	2286	continue;
2293		2287
2294	def_lev = MAX (1, victim->level);	2288	def_lev = max (1, victim->level);
2295	atk_lev = MAX (1, op->level);	2289	atk_lev = max (1, op->level);
2296		2290
2297	if (rndm (0, atk_lev - 1) > def_lev)	2291	if (rndm (0, atk_lev - 1) > def_lev)
2298	{	2292	{
2299	/* make this sucker peaceful. */	2293	/* make this sucker peaceful. */
2300		2294
…		…
2309	victim->stats.sp = 0;	2303	victim->stats.sp = 0;
2310	victim->stats.grace = 0;	2304	victim->stats.grace = 0;
2311	victim->stats.Pow = 0;	2305	victim->stats.Pow = 0;
2312	#endif	2306	#endif
2313	victim->attack_movement = RANDO2;	2307	victim->attack_movement = RANDO2;
2314	SET_FLAG (victim, FLAG_UNAGGRESSIVE);	2308	victim->set_flag (FLAG_UNAGGRESSIVE);
2315	SET_FLAG (victim, FLAG_RUN_AWAY);	2309	victim->set_flag (FLAG_RUN_AWAY);
2316	SET_FLAG (victim, FLAG_RANDOM_MOVE);	2310	victim->set_flag (FLAG_RANDOM_MOVE);
2317	CLEAR_FLAG (victim, FLAG_MONSTER);	2311	victim->clr_flag (FLAG_MONSTER);
2318		2312
2319	if (victim->name)	2313	if (victim->name)
2320	new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);	2314	new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2321	}	2315	}
2322	}	2316	}
…		…
2328	int	2322	int
2329	write_mark (object *op, object *spell, const char *msg)	2323	write_mark (object *op, object *spell, const char *msg)
2330	{	2324	{
2331	if (!msg || msg[0] == 0)	2325	if (!msg || msg[0] == 0)
2332	{	2326	{
2333	new_draw_info (NDI_UNIQUE, 0, op, "Write what?");	2327	op->failmsg ("Write what?");
2334	return 0;	2328	return 0;
2335	}	2329	}
2336		2330
2337	if (!msg_is_safe (msg))	2331	if (!msg_is_safe (msg))
2338	{	2332	{
2339	new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");	2333	op->failmsg ("Trying to cheat are we? H<@-signs are not allowed in marking runes.>");
2340	LOG (llevInfo, "write_mark: player %s tried to write bogus rune %s\n", &op->name, msg);	2334	LOG (llevInfo, "write_mark: player %s tried to write bogus rune %s\n", &op->name, msg);
2341	return 0;	2335	return 0;
2342	}	2336	}
2343		2337
2344	if (!spell->other_arch)	2338	if (!spell->other_arch)
2345	return 0;	2339	return 0;
2346		2340
2347	object *tmp = arch_to_object (spell->other_arch);	2341	object *tmp = spell->other_arch->instance ();
2348		2342
2349	tmp->race = op->name; /*Save the owner of the rune */	2343	tmp->race = op->name; /*Save the owner of the rune */
2350	tmp->msg = msg;	2344	tmp->msg = msg;
2351		2345
2352	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);	2346	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);

Diff Legend

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