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