[ViewVC] Diff of: cvs/deliantra/server/server/spell

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.99 by elmex, Tue Jan 13 13:29:57 2009 UTC vs.
Revision 1.130 by root, Wed Apr 21 05:48:35 2010 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 (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
7	*	7	*
8	* Deliantra is free software: you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation, either version 3 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	11	* option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the Affero GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	19	* and the GNU General Public License along with this program. If not, see
		20	* <http://www.gnu.org/licenses/>.
20	*	21	*
21	* The authors can be reached via e-mail to <support@deliantra.net>	22	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	23	*/
23		24
24	#include <global.h>	25	#include <global.h>
57	}	58	}
58		59
59	int	60	int
60	recharge (object op, object caster, object *spell_ob)	61	recharge (object op, object caster, object *spell_ob)
61	{	62	{
62	object wand, tmp;
63	int ncharges;	63	int ncharges;
64		64
65	wand = find_marked_object (op);	65	object *wand = op->mark ();
		66
66	if (!wand \|\| wand->type != WAND)	67	if (!wand \|\| wand->type != WAND)
67	{	68	{
68	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");	69	op->failmsg ("You need to mark the wand you want to recharge.");
69	return 0;	70	return 0;
70	}	71	}
		72
71	if (!(random_roll (0, 3, op, PREFER_HIGH)))	73	if (!(random_roll (0, 3, op, PREFER_HIGH)))
72	{	74	{
73	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));	75	op->failmsgf ("The %s vibrates violently, then explodes!", query_name (wand));
74	op->play_sound (sound_find ("ob_explode"));	76	op->play_sound (sound_find ("ob_explode"));
75	wand->destroy ();	77	wand->destroy ();
76	tmp = get_archetype ("fireball");	78	object *tmp = get_archetype (shstr_fireball);
77	tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;	79	tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
78		80
79	if (!tmp->stats.dam)	81	if (!tmp->stats.dam)
80	tmp->stats.dam = 1;	82	tmp->stats.dam = 1;
81		83
…		…
92		94
93	if (wand->inv && wand->inv->level)	95	if (wand->inv && wand->inv->level)
94	ncharges /= wand->inv->level;	96	ncharges /= wand->inv->level;
95	else	97	else
96	{	98	{
97	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand));	99	op->failmsgf ("Your %s is broken.", query_name (wand));
98	return 0;	100	return 0;
99	}	101	}
100		102
101	if (!ncharges)	103	if (!ncharges)
102	ncharges = 1;	104	ncharges = 1;
103		105
104	wand->stats.food += ncharges;	106	wand->stats.food += ncharges;
105	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));	107	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
106		108
107	if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE))	109	if (wand->arch && wand->arch->flag [FLAG_ANIMATE])
108	{	110	{
109	SET_FLAG (wand, FLAG_ANIMATE);	111	wand->set_flag (FLAG_ANIMATE);
110	wand->set_speed (wand->arch->speed);	112	wand->set_speed (wand->arch->speed);
111	}	113	}
112		114
113	return 1;	115	return 1;
114	}	116	}
…		…
122	* The # of arrows created also goes up with level, so if a 30th level mage	124	* The # of arrows created also goes up with level, so if a 30th level mage
123	* wants LOTS of arrows, and doesn't care what the plus is he could	125	* wants LOTS of arrows, and doesn't care what the plus is he could
124	* create nonnmagic arrows, or even -1, etc...	126	* create nonnmagic arrows, or even -1, etc...
125	*/	127	*/
126	int	128	int
127	cast_create_missile (object op, object caster, object spell, int dir, const char stringarg)	129	cast_create_missile (object op, object caster, object spell, int dir, const char spellparam)
128	{	130	{
129	int bonus_plus = 0;	131	int bonus_plus = 0;
130	const char *missile_name = "arrow";	132	const char *missile_name = "arrow";
131		133
132	for (object *tmp = op->inv; tmp; tmp = tmp->below)	134	for (object *tmp = op->inv; tmp; tmp = tmp->below)
133	if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))	135	if (tmp->type == BOW && tmp->flag [FLAG_APPLIED])
134	missile_name = tmp->race;	136	missile_name = tmp->race;
135		137
136	int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);	138	int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
137		139
138	archetype *missile_arch = archetype::find (missile_name);	140	archetype *missile_arch = archetype::find (missile_name);
…		…
143	return 0;	145	return 0;
144	}	146	}
145		147
146	object *missile = missile_arch->instance ();	148	object *missile = missile_arch->instance ();
147		149
148	if (stringarg)	150	if (spellparam)
149	{	151	{
150	/* If it starts with a letter, presume it is a description */	152	/* If it starts with a letter, presume it is a description */
151	if (isalpha (*stringarg))	153	if (isalpha (*spellparam))
152	{	154	{
153	artifact *al = find_artifactlist (missile->type)->items;	155	artifact *al = find_artifactlist (missile->type)->items;
154		156
155	for (; al; al = al->next)	157	for (; al; al = al->next)
156	if (!strcasecmp (al->item->name, stringarg))	158	if (!strcasecmp (al->item->name, spellparam))
157	break;	159	break;
158		160
159	if (!al)	161	if (!al)
160	{	162	{
161	missile->destroy ();	163	missile->destroy ();
162	new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, stringarg);	164	op->failmsgf ("No such object %ss of %s", missile_name, spellparam);
163	return 0;	165	return 0;
164	}	166	}
165		167
166	if (al->item->slaying)	168	if (al->item->slaying)
167	{	169	{
168	missile->destroy ();	170	missile->destroy ();
169	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg);	171	op->failmsgf ("You are not allowed to create %ss of %s", missile_name, spellparam);
170	return 0;	172	return 0;
171	}	173	}
172		174
173	give_artifact_abilities (missile, al->item);	175	give_artifact_abilities (missile, al->item);
174	/* These special arrows cost something extra. Don't have them also be magical -	176	/* These special arrows cost something extra. Don't have them also be magical -
…		…
176	* the parsing of having to do both plus and type.	178	* the parsing of having to do both plus and type.
177	*/	179	*/
178	bonus_plus = 1 + (al->item->value / 5);	180	bonus_plus = 1 + (al->item->value / 5);
179	missile_plus = 0;	181	missile_plus = 0;
180	}	182	}
181	else if (atoi (stringarg) < missile_plus)	183	else if (atoi (spellparam) < missile_plus)
182	missile_plus = atoi (stringarg);	184	missile_plus = atoi (spellparam);
183	}	185	}
184		186
185	missile_plus = clamp (missile_plus, -4, 4);	187	missile_plus = clamp (missile_plus, -4, 4);
186		188
187	missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);	189	missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
…		…
192		194
193	missile->magic = missile_plus;	195	missile->magic = missile_plus;
194	/* Can't get any money for these objects */	196	/* Can't get any money for these objects */
195	missile->value = 0;	197	missile->value = 0;
196		198
197	SET_FLAG (missile, FLAG_IDENTIFIED);	199	missile->set_flag (FLAG_IDENTIFIED);
198		200
199	if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !missile->destroyed ())	201	if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !missile->destroyed ())
200	pick_up (op, missile);	202	pick_up (op, missile);
201		203
202	return 1;	204	return 1;
203	}	205	}
204		206
205		207
206	/* allows the choice of what sort of food object to make.	208	/* allows the choice of what sort of food object to make.
207	* If stringarg is NULL, it will create food dependent on level --PeterM*/	209	* If spellparam is NULL, it will create food dependent on level --PeterM*/
208	int	210	int
209	cast_create_food (object op, object caster, object spell_ob, int dir, const char stringarg)	211	cast_create_food (object op, object caster, object spell_ob, int dir, const char spellparam)
210	{	212	{
211	int food_value;	213	int food_value;
212	archetype *at = NULL;	214	archetype *at = NULL;
213	object *new_op;	215	object *new_op;
214		216
215	food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);	217	food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);
216		218
217	if (stringarg)	219	if (spellparam)
218	{	220	{
219	at = find_archetype_by_object_type_name (FOOD, stringarg);	221	at = find_archetype_by_object_type_name (FOOD, spellparam);
220	if (at == NULL)	222	if (at == NULL)
221	at = find_archetype_by_object_type_name (DRINK, stringarg);	223	at = find_archetype_by_object_type_name (DRINK, spellparam);
222	if (at == NULL \|\| at->stats.food > food_value)	224	if (at == NULL \|\| at->stats.food > food_value)
223	stringarg = NULL;	225	spellparam = NULL;
224	}	226	}
225		227
226	if (!stringarg)	228	if (!spellparam)
227	{	229	{
228	archetype *at_tmp;	230	archetype *at_tmp;
229		231
230	/* We try to find the archetype with the maximum food value.	232	/* We try to find the archetype with the maximum food value.
231	* This removes the dependancy of hard coded food values in this	233	* This removes the dependancy of hard coded food values in this
…		…
256	/* Pretty unlikely (there are some very low food items), but you never	258	/* Pretty unlikely (there are some very low food items), but you never
257	* know	259	* know
258	*/	260	*/
259	if (!at)	261	if (!at)
260	{	262	{
261	new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");	263	op->failmsgf ("You don't have enough experience to create any food.");
262	return 0;	264	return 0;
263	}	265	}
264		266
265	food_value /= at->stats.food;	267	food_value /= at->stats.food;
266	new_op = arch_to_object (at);	268	new_op = at->instance ();
267	new_op->nrof = food_value;	269	new_op->nrof = food_value;
268		270
269	new_op->value = 0;	271	new_op->value = 0;
270	if (new_op->nrof < 1)	272	if (new_op->nrof < 1)
271	new_op->nrof = 1;	273	new_op->nrof = 1;
…		…
296	mflags = get_map_flags (m, &m, x, y, &x, &y);	298	mflags = get_map_flags (m, &m, x, y, &x, &y);
297		299
298	if (mflags & P_OUT_OF_MAP)	300	if (mflags & P_OUT_OF_MAP)
299	break;	301	break;
300		302
301	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))	303	if (!op->flag [FLAG_WIZCAST] && (mflags & P_NO_MAGIC))
302	{	304	{
303	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");	305	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
304	return 0;	306	return 0;
305	}	307	}
306		308
307	if (mflags & P_IS_ALIVE)	309	if (mflags & P_IS_ALIVE)
308	{	310	{
309	for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)	311	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)))	312	if (tmp->flag [FLAG_ALIVE] && (tmp->type == PLAYER \|\| tmp->flag [FLAG_MONSTER]))
311	{	313	{
312	new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");	314	new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
313	if (tmp->head != NULL)	315	if (tmp->head != NULL)
314	tmp = tmp->head;	316	tmp = tmp->head;
315	examine_monster (op, tmp);	317	examine_monster (op, tmp);
…		…
338	if (pl->type == PLAYER)	340	if (pl->type == PLAYER)
339	{	341	{
340	/* If race isn't set, then invisible unless it is undead */	342	/* If race isn't set, then invisible unless it is undead */
341	if (!pl->contr->invis_race)	343	if (!pl->contr->invis_race)
342	{	344	{
343	if (QUERY_FLAG (mon, FLAG_UNDEAD))	345	if (mon->flag [FLAG_UNDEAD])
344	return 0;	346	return 0;
345		347
346	return 1;	348	return 1;
347	}	349	}
348		350
…		…
379	int	381	int
380	cast_invisible (object op, object caster, object *spell_ob)	382	cast_invisible (object op, object caster, object *spell_ob)
381	{	383	{
382	if (op->invisible > 1000)	384	if (op->invisible > 1000)
383	{	385	{
384	new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");	386	op->failmsg ("You can not extend the duration of your invisibility any further");
385	return 0;	387	return 0;
386	}	388	}
387		389
388	/* Remove the switch with 90% duplicate code - just handle the differences with	390	/* Remove the switch with 90% duplicate code - just handle the differences with
389	* and if statement or two.	391	* and if statement or two.
…		…
395		397
396	if (op->type == PLAYER)	398	if (op->type == PLAYER)
397	{	399	{
398	op->contr->invis_race = spell_ob->race;	400	op->contr->invis_race = spell_ob->race;
399		401
400	if (QUERY_FLAG (spell_ob, FLAG_MAKE_INVIS))	402	if (spell_ob->flag [FLAG_MAKE_INVIS])
401	op->contr->tmp_invis = 0;	403	op->contr->tmp_invis = 0;
402	else	404	else
403	op->contr->tmp_invis = 1;	405	op->contr->tmp_invis = 1;
404		406
405	op->contr->hidden = 0;	407	op->contr->hidden = 0;
…		…
425	/* earth to dust spell. Basically destroys earthwalls in the area.	427	/* earth to dust spell. Basically destroys earthwalls in the area.
426	*/	428	*/
427	int	429	int
428	cast_earth_to_dust (object op, object caster, object *spell_ob)	430	cast_earth_to_dust (object op, object caster, object *spell_ob)
429	{	431	{
430	object tmp, next;
431	int range, i, j, mflags;	432	int range, i, j, mflags;
432	sint16 sx, sy;	433	sint16 sx, sy;
433	maptile *m;	434	maptile *m;
434
435	if (op->type != PLAYER)
436	return 0;
437		435
438	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	436	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
439		437
440	for (i = -range; i <= range; i++)	438	for (i = -range; i <= range; i++)
441	for (j = -range; j <= range; j++)	439	for (j = -range; j <= range; j++)
…		…
446	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);	444	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
447		445
448	if (mflags & P_OUT_OF_MAP)	446	if (mflags & P_OUT_OF_MAP)
449	continue;	447	continue;
450		448
451	// earth to dust tears down everything that can be teared down	449	// earth to dust tears down everything that can be torn down
452	for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)	450	for (object next, tmp = m->at (sx, sy).bot; tmp; tmp = next)
453	{	451	{
454	next = tmp->above;	452	next = tmp->above;
455	if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))	453
		454	if (tmp->flag [FLAG_TEAR_DOWN])
456	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);	455	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
457	}	456	}
458	}	457	}
459		458
460	return 1;	459	return 1;
…		…
463	void	462	void
464	execute_word_of_recall (object *op)	463	execute_word_of_recall (object *op)
465	{	464	{
466	if (object *pl = op->in_player ())	465	if (object *pl = op->in_player ())
467	{	466	{
468	if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))	467	if (pl->ms ().flags () & P_NO_CLERIC && !pl->flag [FLAG_WIZCAST])
469	new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");	468	new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
470	else	469	else
471	pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);	470	pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);
472	}	471	}
473		472
…		…
567		566
568	int	567	int
569	perceive_self (object *op)	568	perceive_self (object *op)
570	{	569	{
571	const char *cp = describe_item (op, op);	570	const char *cp = describe_item (op, op);
572	archetype *at = archetype::find (ARCH_DEPLETION);	571	archetype *at = archetype::find (shstr_depletion);
573		572
574	dynbuf_text buf;	573	dynbuf_text &buf = msg_dynbuf; buf.clear ();
575		574
576	if (player *pl = op->contr)	575	if (!op->is_player ())
		576	return 0;
		577
577	if (object *race = archetype::find (op->race))	578	if (object *race = archetype::find (op->race))
578	buf << " - You are a G<male\|female> " << &race->name << ".\n";	579	buf << " - You are a G<male\|female> " << &race->name << ".\n";
579		580
580	if (object *god = find_god (determine_god (op)))	581	if (object *god = find_god (determine_god (op)))
581	buf << " - You worship " << &god->name << ".\n";	582	buf << " - You worship " << &god->name << ".\n";
582	else	583	else
583	buf << " - You worship no god.\n";	584	buf << " - You worship no god.\n";
…		…
594	for (int i = 0; i < NUM_STATS; i++)	595	for (int i = 0; i < NUM_STATS; i++)
595	if (tmp->stats.stat (i) < 0)	596	if (tmp->stats.stat (i) < 0)
596	buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));	597	buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
597	}	598	}
598		599
599	if (is_dragon_pl (op))	600	if (op->is_dragon ())
600	/* now grab the 'dragon_ability'-force from the player's inventory */	601	/* now grab the 'dragon_ability'-force from the player's inventory */
601	for (tmp = op->inv; tmp; tmp = tmp->below)	602	for (tmp = op->inv; tmp; tmp = tmp->below)
602	{	603	{
603	if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)	604	if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
604	{	605	{
…		…
609		610
610	break;	611	break;
611	}	612	}
612	}	613	}
613		614
614	buf << '\0'; // zero-terminate	615	op->contr->infobox (MSG_CHANNEL ("perceiveself"), buf);
615
616	new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ());
617		616
618	return 1;	617	return 1;
619	}	618	}
620		619
621	/* This creates magic walls. Really, it can create most any object,	620	/* This creates magic walls. Really, it can create most any object,
…		…
647		646
648	if ((spell_ob->move_block \|\| x != op->x \|\| y != op->y) &&	647	if ((spell_ob->move_block \|\| x != op->x \|\| y != op->y) &&
649	(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP \| P_IS_ALIVE) \|\|	648	(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP \| P_IS_ALIVE) \|\|
650	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))	649	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))
651	{	650	{
652	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	651	op->failmsg ("Something is in the way.");
653	return 0;	652	return 0;
654	}	653	}
655		654
656	if (spell_ob->other_arch)	655	if (spell_ob->other_arch)
657	tmp = arch_to_object (spell_ob->other_arch);	656	tmp = spell_ob->other_arch->instance ();
658	else if (spell_ob->race)	657	else if (spell_ob->race)
659	{	658	{
660	char buf1[MAX_BUF];	659	char buf1[MAX_BUF];
661		660
662	sprintf (buf1, spell_ob->race, dir);	661	sprintf (buf1, spell_ob->race, dir);
…		…
666	LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);	665	LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
667	new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");	666	new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
668	return 0;	667	return 0;
669	}	668	}
670		669
671	tmp = arch_to_object (at);	670	tmp = at->instance ();
672	}	671	}
673	else	672	else
674	{	673	{
675	LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);	674	LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
676	return 0;	675	return 0;
…		…
681	tmp->attacktype = spell_ob->attacktype;	680	tmp->attacktype = spell_ob->attacktype;
682	tmp->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	681	tmp->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
683	tmp->stats.dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);	682	tmp->stats.dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
684	tmp->range = 0;	683	tmp->range = 0;
685	}	684	}
686	else if (QUERY_FLAG (tmp, FLAG_ALIVE))	685	else if (tmp->flag [FLAG_ALIVE])
687	{	686	{
688	tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	687	tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
689	tmp->stats.maxhp = tmp->stats.hp;	688	tmp->stats.maxhp = tmp->stats.hp;
690	}	689	}
691		690
692	if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) \|\| QUERY_FLAG (tmp, FLAG_IS_USED_UP))	691	if (spell_ob->flag [FLAG_IS_USED_UP] \|\| tmp->flag [FLAG_IS_USED_UP])
693	{	692	{
694	tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	693	tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
695	SET_FLAG (tmp, FLAG_IS_USED_UP);	694	tmp->set_flag (FLAG_IS_USED_UP);
696	}	695	}
697		696
698	if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN))	697	if (spell_ob->flag [FLAG_TEAR_DOWN])
699	{	698	{
700	tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);	699	tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
701	tmp->stats.maxhp = tmp->stats.hp;	700	tmp->stats.maxhp = tmp->stats.hp;
702	SET_FLAG (tmp, FLAG_TEAR_DOWN);	701	tmp->set_flag (FLAG_TEAR_DOWN);
703	SET_FLAG (tmp, FLAG_ALIVE);	702	tmp->set_flag (FLAG_ALIVE);
704	}	703	}
705		704
706	/* This can't really hurt - if the object doesn't kill anything,	705	/* This can't really hurt - if the object doesn't kill anything,
707	* these fields just won't be used. Do not set the owner for	706	* these fields just won't be used. Do not set the owner for
708	* earthwalls, though, so they survive restarts.	707	* earthwalls, though, so they survive restarts.
…		…
720	return 0;	719	return 0;
721	}	720	}
722		721
723	/* If this is a spellcasting wall, need to insert the spell object */	722	/* If this is a spellcasting wall, need to insert the spell object */
724	if (tmp->other_arch && tmp->other_arch->type == SPELL)	723	if (tmp->other_arch && tmp->other_arch->type == SPELL)
725	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);	724	insert_ob_in_ob (tmp->other_arch->instance (), tmp);
726		725
727	/* This code causes the wall to extend some distance in	726	/* This code causes the wall to extend some distance in
728	* each direction, or until an obstruction is encountered.	727	* each direction, or until an obstruction is encountered.
729	* posblocked and negblocked help determine how far the	728	* posblocked and negblocked help determine how far the
730	* created wall can extend, it won't go extend through	729	* created wall can extend, it won't go extend through
…		…
750	object *tmp2 = tmp->clone ();	749	object *tmp2 = tmp->clone ();
751	m->insert (tmp2, x, y, op);	750	m->insert (tmp2, x, y, op);
752		751
753	/* If this is a spellcasting wall, need to insert the spell object */	752	/* If this is a spellcasting wall, need to insert the spell object */
754	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)	753	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
755	tmp2->insert (arch_to_object (tmp2->other_arch));	754	tmp2->insert (tmp2->other_arch->instance ());
756		755
757	}	756	}
758	else	757	else
759	posblocked = 1;	758	posblocked = 1;
760		759
…		…
767	{	766	{
768	object *tmp2 = tmp->clone ();	767	object *tmp2 = tmp->clone ();
769	m->insert (tmp2, x, y, op);	768	m->insert (tmp2, x, y, op);
770		769
771	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)	770	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
772	tmp2->insert (arch_to_object (tmp2->other_arch));	771	tmp2->insert (tmp2->other_arch->instance ());
773	}	772	}
774	else	773	else
775	negblocked = 1;	774	negblocked = 1;
776	}	775	}
777		776
778	if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW))	777	if (tmp->flag [FLAG_BLOCKSVIEW])
779	update_all_los (op->map, op->x, op->y);	778	update_all_los (op->map, op->x, op->y);
780		779
781	return 1;	780	return 1;
782	}	781	}
783		782
784	int	783	int
785	dimension_door (object op, object caster, object *spob, int dir)	784	dimension_door (object op, object caster, object spob, int dir, const char spellparam)
786	{	785	{
787	uint32 dist, maxdist;	786	uint32 dist, maxdist;
788	int mflags;	787	int mflags;
789	maptile *m;	788	maptile *m;
790	sint16 sx, sy;	789	sint16 sx, sy;
…		…
792	if (op->type != PLAYER)	791	if (op->type != PLAYER)
793	return 0;	792	return 0;
794		793
795	if (!dir)	794	if (!dir)
796	{	795	{
797	new_draw_info (NDI_UNIQUE, 0, op, "In what direction?");	796	op->failmsg ("In what direction?");
798	return 0;	797	return 0;
799	}	798	}
800		799
801	/* Given the new outdoor maps, can't let players dimension door for	800	/* Given the new outdoor maps, can't let players dimension door for
802	* ever, so put limits in.	801	* ever, so put limits in.
803	*/	802	*/
804	maxdist = spob->range + SP_level_range_adjust (caster, spob);	803	maxdist = spob->range + SP_level_range_adjust (caster, spob);
805		804
806	if (op->contr->count)	805	if (spellparam)
807	{	806	{
		807	int count = atoi (spellparam);
		808
808	if (op->contr->count > maxdist)	809	if (count > maxdist)
809	{	810	{
810	new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!");	811	op->failmsg ("You can't dimension door that far!");
811	return 0;	812	return 0;
812	}	813	}
813		814
814	for (dist = 0; dist < op->contr->count; dist++)	815	for (dist = 0; dist < count; dist++)
815	{	816	{
816	mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);	817	mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);
817		818
818	if (mflags & (P_NO_MAGIC \| P_OUT_OF_MAP))	819	if (mflags & (P_NO_MAGIC \| P_OUT_OF_MAP))
819	break;	820	break;
820		821
821	if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))	822	if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
822	break;	823	break;
823	}	824	}
824		825
825	if (dist < op->contr->count)	826	if (dist < count)
826	{	827	{
827	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");	828	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
828	op->contr->count = 0;
829	return 0;	829	return 0;
830	}	830	}
831
832	op->contr->count = 0;
833		831
834	/* Remove code that puts player on random space on maps. IMO,	832	/* Remove code that puts player on random space on maps. IMO,
835	* a lot of maps probably have areas the player should not get to,	833	* a lot of maps probably have areas the player should not get to,
836	* but may not be marked as NO_MAGIC (as they may be bounded	834	* but may not be marked as NO_MAGIC (as they may be bounded
837	* by such squares). Also, there are probably treasure rooms and	835	* by such squares). Also, there are probably treasure rooms and
…		…
879	break;	877	break;
880		878
881	}	879	}
882	if (!dist)	880	if (!dist)
883	{	881	{
884	new_draw_info (NDI_UNIQUE, 0, op, "Your spell failed!\n");	882	op->failmsg ("Your spell failed!\n");
885	return 0;	883	return 0;
886	}	884	}
887	}	885	}
888		886
889	/* Actually move the player now */	887	/* Actually move the player now */
890	if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))	888	if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
891	return 1;	889	return 1;
892		890
893	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */	891	op->speed_left = -5. * op->speed; /* Freeze them for a short while */
		892
894	return 1;	893	return 1;
895	}	894	}
896		895
897	/* cast_heal: Heals something.	896	/* cast_heal: Heals something.
898	* op is the caster.	897	* op is the caster.
…		…
953	if (cure_disease (tmp, op, spell))	952	if (cure_disease (tmp, op, spell))
954	success = 1;	953	success = 1;
955		954
956	if (spell->attacktype & AT_POISON)	955	if (spell->attacktype & AT_POISON)
957	{	956	{
958	at = archetype::find ("poisoning");	957	at = archetype::find (shstr_poisoning);
959	poison = present_arch_in_ob (at, tmp);	958	poison = present_arch_in_ob (at, tmp);
960	if (poison)	959	if (poison)
961	{	960	{
962	success = 1;	961	success = 1;
963	new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");	962	new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
…		…
965	}	964	}
966	}	965	}
967		966
968	if (spell->attacktype & AT_CONFUSION)	967	if (spell->attacktype & AT_CONFUSION)
969	{	968	{
970	poison = present_in_ob_by_name (FORCE, "confusion", tmp);	969	poison = present_in_ob_by_name (FORCE, shstr_confusion, tmp);
971	if (poison)	970	if (poison)
972	{	971	{
973	success = 1;	972	success = 1;
974	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	973	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
975	poison->duration = 1;	974	poison->duration = 1;
976	}	975	}
977	}	976	}
978		977
979	if (spell->attacktype & AT_BLIND)	978	if (spell->attacktype & AT_BLIND)
980	{	979	{
981	at = archetype::find ("blindness");	980	at = archetype::find (shstr_blindness);
982	poison = present_arch_in_ob (at, tmp);	981	poison = present_arch_in_ob (at, tmp);
983	if (poison)	982	if (poison)
984	{	983	{
985	success = 1;	984	success = 1;
986	new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");	985	new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
…		…
1004	tmp->stats.grace = tmp->stats.maxgrace;	1003	tmp->stats.grace = tmp->stats.maxgrace;
1005	success = 1;	1004	success = 1;
1006	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");	1005	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1007	}	1006	}
1008		1007
1009	if (spell->stats.food && tmp->stats.food < 999)	1008	if (spell->stats.food && tmp->stats.food < MAX_FOOD)
1010	{	1009	{
1011	tmp->stats.food += spell->stats.food;	1010	tmp->stats.food += spell->stats.food;
1012		1011	min_it (tmp->stats.food, MAX_FOOD);
1013	if (tmp->stats.food > 999)
1014	tmp->stats.food = 999;
1015		1012
1016	success = 1;	1013	success = 1;
1017	/* We could do something a bit better like the messages for healing above */	1014	/* We could do something a bit better like the messages for healing above */
1018	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");	1015	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1019	}	1016	}
…		…
1034	"You don't feel any more powerful."	1031	"You don't feel any more powerful."
1035	"You are no easier to look at.",	1032	"You are no easier to look at.",
1036	};	1033	};
1037		1034
1038	int	1035	int
		1036	change_ability_duration (object spell, object caster)
		1037	{
		1038	return spell->duration + SP_level_duration_adjust (caster, spell) * 50;
		1039	}
		1040
		1041	int
1039	cast_change_ability (object op, object caster, object *spell_ob, int dir, int silent)	1042	cast_change_ability (object op, object caster, object *spell_ob, int dir, int silent)
1040	{	1043	{
1041	object *force = 0;	1044	object *force = 0;
1042	int i;	1045	int i;
1043		1046
…		…
1060	break;	1063	break;
1061	}	1064	}
1062	else if (spell_ob->race && spell_ob->race == tmp2->name)	1065	else if (spell_ob->race && spell_ob->race == tmp2->name)
1063	{	1066	{
1064	if (!silent)	1067	if (!silent)
1065	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);	1068	op->failmsgf ("You can not cast %s while %s is in effect",
		1069	&spell_ob->name, &tmp2->name_pl);
1066		1070
1067	return 0;	1071	return 0;
1068	}	1072	}
1069	}	1073	}
1070	}	1074	}
1071		1075
		1076	int duration = change_ability_duration (spell_ob, caster);
		1077
1072	if (!force)	1078	if (force)
1073	{
1074	force = get_archetype (FORCE_NAME);
1075	force->subtype = FORCE_CHANGE_ABILITY;
1076
1077	if (spell_ob->race)
1078	force->name = spell_ob->race;
1079	else
1080	force->name = spell_ob->name;
1081
1082	force->name_pl = spell_ob->name;
1083	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
1084
1085	}	1079	{
1086	else
1087	{
1088	int duration;
1089
1090	duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1091	if (duration > force->duration)	1080	if (duration > force->duration)
1092	{	1081	{
1093	force->duration = duration;	1082	force->duration = duration;
1094	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	1083	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1095	}	1084	}
…		…
1097	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1086	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1098		1087
1099	return 1;	1088	return 1;
1100	}	1089	}
1101		1090
1102	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1091	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.>",
		1093	TICK2TIME (duration));
		1094
		1095	force = get_archetype (FORCE_NAME);
		1096	force->subtype = FORCE_CHANGE_ABILITY;
		1097	force->duration = duration;
		1098
		1099	if (spell_ob->race)
		1100	force->name = spell_ob->race;
		1101	else
		1102	force->name = spell_ob->name;
		1103
		1104	force->name_pl = spell_ob->name;
		1105
1103	force->speed = 1.0;	1106	force->speed = 1.0;
1104	force->speed_left = -1.0;	1107	force->speed_left = -1.0;
1105	SET_FLAG (force, FLAG_APPLIED);	1108	force->set_flag (FLAG_APPLIED);
1106		1109
1107	/* Now start processing the effects. First, protections */	1110	/* Now start processing the effects. First, protections */
1108	for (i = 0; i < NROFATTACKS; i++)	1111	for (i = 0; i < NROFATTACKS; i++)
1109	{	1112	{
1110	if (spell_ob->resist[i])	1113	if (spell_ob->resist[i])
…		…
1140	}	1143	}
1141	}	1144	}
1142		1145
1143	force->move_type = spell_ob->move_type;	1146	force->move_type = spell_ob->move_type;
1144		1147
1145	if (QUERY_FLAG (spell_ob, FLAG_SEE_IN_DARK))	1148	if (spell_ob->flag [FLAG_SEE_IN_DARK])
1146	SET_FLAG (force, FLAG_SEE_IN_DARK);	1149	force->set_flag (FLAG_SEE_IN_DARK);
1147		1150
1148	if (QUERY_FLAG (spell_ob, FLAG_XRAYS))	1151	if (spell_ob->flag [FLAG_XRAYS])
1149	SET_FLAG (force, FLAG_XRAYS);	1152	force->set_flag (FLAG_XRAYS);
1150		1153
1151	/* Haste/bonus speed */	1154	/* Haste/bonus speed */
1152	if (spell_ob->stats.exp)	1155	if (spell_ob->stats.exp)
1153	{	1156	{
1154	if (op->speed > 0.5f)	1157	if (op->speed > 0.5f)
…		…
1235	return 0;	1238	return 0;
1236	}	1239	}
1237	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1240	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1238	force->speed = 1.0;	1241	force->speed = 1.0;
1239	force->speed_left = -1.0;	1242	force->speed_left = -1.0;
1240	SET_FLAG (force, FLAG_APPLIED);	1243	force->set_flag (FLAG_APPLIED);
1241		1244
1242	if (!god)	1245	if (!god)
1243	{	1246	{
1244	new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty.");	1247	new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty.");
1245	}	1248	}
1246	else	1249	else
1247	{	1250	{
1248	/* Only give out good benefits, and put a max on it */	1251	/* Only give out good benefits, and put a max on it */
1249	for (i = 0; i < NROFATTACKS; i++)	1252	for (i = 0; i < NROFATTACKS; i++)
1250	{
1251	if (god->resist[i] > 0)	1253	if (god->resist[i] > 0)
1252	{
1253	force->resist[i] = MIN (god->resist[i], spell_ob->resist[ATNR_GODPOWER]);	1254	force->resist[i] = min (god->resist[i], spell_ob->resist[ATNR_GODPOWER]);
1254	}	1255
1255	}
1256	force->path_attuned \|= god->path_attuned;	1256	force->path_attuned \|= god->path_attuned;
1257		1257
1258	if (spell_ob->attacktype)	1258	if (spell_ob->attacktype)
1259	force->slaying = god->slaying;	1259	force->slaying = god->slaying;
1260		1260
…		…
1302	* the nuggets, alchemy the gold from that, etc.	1302	* the nuggets, alchemy the gold from that, etc.
1303	* Otherwise, give 9 silver on the gold for other objects,	1303	* Otherwise, give 9 silver on the gold for other objects,
1304	* so that it would still be more affordable to haul	1304	* so that it would still be more affordable to haul
1305	* the stuff back to town.	1305	* the stuff back to town.
1306	*/	1306	*/
1307	if (QUERY_FLAG (obj, FLAG_UNPAID))	1307	if (obj->flag [FLAG_UNPAID])
1308	value = 0;	1308	value = 0;
1309	else if (obj->type == MONEY \|\| obj->type == GEM)	1309	else if (obj->type == MONEY \|\| obj->type == GEM)
1310	value /= 3;	1310	value /= 3;
1311	else	1311	else
1312	value = value * 9 / 10;	1312	value = value * 9 / 10;
…		…
1325	if (op->type != PLAYER)	1325	if (op->type != PLAYER)
1326	return 0;	1326	return 0;
1327		1327
1328	archetype *nugget[3];	1328	archetype *nugget[3];
1329		1329
1330	nugget[0] = archetype::find ("pyrite3");	1330	nugget[0] = archetype::find (shstr_pyrite3);
1331	nugget[1] = archetype::find ("pyrite2");	1331	nugget[1] = archetype::find (shstr_pyrite2);
1332	nugget[2] = archetype::find ("pyrite");	1332	nugget[2] = archetype::find (shstr_pyrite);
1333		1333
1334	/* Put a maximum weight of items that can be alchemised. Limits the power	1334	/* Put a maximum weight of items that can be alchemised. Limits the power
1335	* some, and also prevents people from alchemising every table/chair/clock	1335	* some, and also prevents people from alchemising every table/chair/clock
1336	* in sight	1336	* in sight
1337	*/	1337	*/
…		…
1366		1366
1367	for (object next, tmp = mp->at (nx, ny).bot; tmp; tmp = next)	1367	for (object next, tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1368	{	1368	{
1369	next = tmp->above;	1369	next = tmp->above;
1370		1370
1371	if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&	1371	if (tmp->weight > 0 && !tmp->flag [FLAG_NO_PICK] &&
1372	!QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))	1372	!tmp->flag [FLAG_ALIVE] && !tmp->flag [FLAG_IS_CAULDRON])
1373	{	1373	{
1374	if (tmp->inv)	1374	if (tmp->inv)
1375	{	1375	{
1376	object next1, tmp1;	1376	object next1, tmp1;
1377		1377
1378	for (tmp1 = tmp->inv; tmp1; tmp1 = next1)	1378	for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1379	{	1379	{
1380	next1 = tmp1->below;	1380	next1 = tmp1->below;
1381	if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&	1381	if (tmp1->weight > 0 && !tmp1->flag [FLAG_NO_PICK] &&
1382	!QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))	1382	!tmp1->flag [FLAG_ALIVE] && !tmp1->flag [FLAG_IS_CAULDRON])
1383	alchemy_object (tmp1, value, weight);	1383	alchemy_object (tmp1, value, weight);
1384	}	1384	}
1385	}	1385	}
1386		1386
1387	alchemy_object (tmp, value, weight);	1387	alchemy_object (tmp, value, weight);
…		…
1397	for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)	1397	for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1398	if (int nrof = value / nugget [i]->value)	1398	if (int nrof = value / nugget [i]->value)
1399	{	1399	{
1400	value -= nrof * nugget[i]->value;	1400	value -= nrof * nugget[i]->value;
1401		1401
1402	object *tmp = arch_to_object (nugget[i]);	1402	object *tmp = nugget[i]->instance ();
1403	tmp->nrof = nrof;	1403	tmp->nrof = nrof;
1404	tmp->flag [FLAG_IDENTIFIED] = true;	1404	tmp->flag [FLAG_IDENTIFIED] = true;
1405	op->map->insert (tmp, x, y, op, 0);	1405	op->map->insert (tmp, x, y, op, 0);
1406	}	1406	}
1407		1407
…		…
1418	* items.	1418	* items.
1419	*/	1419	*/
1420	int	1420	int
1421	remove_curse (object op, object caster, object *spell)	1421	remove_curse (object op, object caster, object *spell)
1422	{	1422	{
1423	object *tmp;
1424	int success = 0, was_one = 0;	1423	int success = 0, was_one = 0;
1425		1424
1426	for (tmp = op->inv; tmp; tmp = tmp->below)	1425	for (object *tmp = op->inv; tmp; tmp = tmp->below)
1427	if (QUERY_FLAG (tmp, FLAG_APPLIED) &&	1426	if (tmp->flag [FLAG_APPLIED] &&
1428	((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) \|\|	1427	((tmp->flag [FLAG_CURSED] && spell->flag [FLAG_CURSED]) \|\|
1429	(QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))	1428	(tmp->flag [FLAG_DAMNED] && spell->flag [FLAG_DAMNED])))
1430	{	1429	{
1431	was_one++;	1430	was_one++;
1432		1431
1433	if (tmp->level <= casting_level (caster, spell))	1432	if (tmp->level <= casting_level (caster, spell))
1434	{	1433	{
1435	success++;	1434	success++;
1436	if (QUERY_FLAG (spell, FLAG_DAMNED))	1435	if (spell->flag [FLAG_DAMNED])
1437	CLEAR_FLAG (tmp, FLAG_DAMNED);	1436	tmp->clr_flag (FLAG_DAMNED);
1438		1437
1439	CLEAR_FLAG (tmp, FLAG_CURSED);	1438	tmp->clr_flag (FLAG_CURSED);
1440	CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);	1439	tmp->clr_flag (FLAG_KNOWN_CURSED);
1441	tmp->value = 0; /* Still can't sell it */	1440	tmp->value = 0; /* Still can't sell it */
1442		1441
1443	if (object *pl = tmp->visible_to ())	1442	if (object *pl = tmp->visible_to ())
1444	esrv_update_item (UPD_FLAGS, pl, tmp);	1443	esrv_update_item (UPD_FLAGS, pl, tmp);
1445	}	1444	}
…		…
1463		1462
1464	/* Identifies objects in the players inventory/on the ground */	1463	/* Identifies objects in the players inventory/on the ground */
1465	int	1464	int
1466	cast_identify (object op, object caster, object *spell)	1465	cast_identify (object op, object caster, object *spell)
1467	{	1466	{
1468	dynbuf_text buf;
1469	object *tmp;	1467	object *tmp;
		1468	dynbuf_text &buf = msg_dynbuf; buf.clear ();
1470		1469
1471	int num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1470	int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1472
1473	if (num_ident < 1)
1474	num_ident = 1;
1475		1471
1476	for (tmp = op->inv; tmp; tmp = tmp->below)	1472	for (tmp = op->inv; tmp; tmp = tmp->below)
1477	{	1473	{
1478	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))	1474	if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && tmp->need_identify ())
1479	{	1475	{
1480	identify (tmp);	1476	identify (tmp);
1481		1477
1482	if (op->type == PLAYER)	1478	if (op->type == PLAYER)
1483	{	1479	{
…		…
1485		1481
1486	if (tmp->msg)	1482	if (tmp->msg)
1487	buf << "The item has a story:\r" << tmp->msg << "\n\n";	1483	buf << "The item has a story:\r" << tmp->msg << "\n\n";
1488	}	1484	}
1489		1485
1490	num_ident--;
1491	if (!num_ident)	1486	if (!--num_ident)
1492	break;	1487	break;
1493	}	1488	}
1494	}	1489	}
1495		1490
1496	/* If all the power of the spell has been used up, don't go and identify	1491	/* If all the power of the spell has been used up, don't go and identify
…		…
1498	* was not fully used.	1493	* was not fully used.
1499	*/	1494	*/
1500	if (num_ident)	1495	if (num_ident)
1501	{	1496	{
1502	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)	1497	for (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))	1498	if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && tmp->need_identify ())
1504	{	1499	{
1505	identify (tmp);	1500	identify (tmp);
1506		1501
1507	if (object *pl = tmp->visible_to ())	1502	if (object *pl = tmp->visible_to ())
1508	{	1503	{
…		…
1510		1505
1511	if (tmp->msg)	1506	if (tmp->msg)
1512	buf << "The item has a story:\r" << tmp->msg << "\n\n";	1507	buf << "The item has a story:\r" << tmp->msg << "\n\n";
1513	}	1508	}
1514		1509
1515	num_ident--;
1516	if (!num_ident)	1510	if (!--num_ident)
1517	break;	1511	break;
1518	}	1512	}
1519	}	1513	}
1520		1514
1521	if (buf.empty ())	1515	if (buf.empty ())
…		…
1549	range = spell->range + SP_level_range_adjust (caster, spell);	1543	range = spell->range + SP_level_range_adjust (caster, spell);
1550		1544
1551	if (!skill)	1545	if (!skill)
1552	skill = caster;	1546	skill = caster;
1553		1547
		1548	dynbuf buf;
1554	unordered_mapwalk (op, -range, -range, range, range)	1549	unordered_mapwalk (buf, op, -range, -range, range, range)
1555	{	1550	{
1556	/* For most of the detections, we only detect objects above the	1551	/* For most of the detections, we only detect objects above the
1557	* floor. But this is not true for show invisible.	1552	* floor. But this is not true for show invisible.
1558	* Basically, we just go and find the top object and work	1553	* Basically, we just go and find the top object and work
1559	* down - that is easier than working up.	1554	* down - that is easier than working up.
1560	*/	1555	*/
1561		1556
1562	for (last = NULL, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)	1557	for (last = 0, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1563	last = tmp;	1558	last = tmp;
1564		1559
1565	/* Shouldn't happen, but if there are no objects on a space, this	1560	/* Shouldn't happen, but if there are no objects on a space, this
1566	* would happen.	1561	* would happen.
1567	*/	1562	*/
1568	if (!last)	1563	if (!last)
1569	continue;	1564	continue;
1570		1565
1571	done_one = 0;	1566	done_one = 0;
1572	floor = 0;	1567	floor = 0;
1573	detect = NULL;	1568	detect = 0;
1574	for (tmp = last; tmp; tmp = tmp->below)	1569	for (tmp = last; tmp; tmp = tmp->below)
1575	{	1570	{
1576	/* show invisible */	1571	/* show invisible */
1577	if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&	1572	if (spell->flag [FLAG_MAKE_INVIS]
1578	/* Might there be other objects that we can make visible? */	1573	/* Might there be other objects that we can make visible? */
1579	(tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) \|\|	1574	&& (tmp->invisible && (tmp->flag [FLAG_MONSTER]
1580	(tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ))	1575	\|\| (tmp->type == PLAYER && !tmp->flag [FLAG_WIZ])
1581	\|\| tmp->type == CF_HANDLE	1576	\|\| tmp->type == T_HANDLE
1582	\|\| tmp->type == TRAPDOOR \|\| tmp->type == EXIT \|\| tmp->type == HOLE	1577	\|\| tmp->type == TRAPDOOR
		1578	\|\| tmp->type == EXIT
		1579	\|\| tmp->type == HOLE
		1580	\|\| tmp->type == BUTTON
1583	\|\| tmp->type == BUTTON \|\| tmp->type == TELEPORTER	1581	\|\| tmp->type == TELEPORTER
		1582	\|\| tmp->type == GATE
1584	\|\| tmp->type == GATE \|\| tmp->type == LOCKED_DOOR	1583	\|\| tmp->type == LOCKED_DOOR
1585	\|\| tmp->type == WEAPON \|\| tmp->type == ALTAR \|\| tmp->type == SIGN	1584	\|\| tmp->type == WEAPON
		1585	\|\| tmp->type == ALTAR
		1586	\|\| (tmp->type == SIGN && tmp->face != magicmouth_face)
1586	\|\| tmp->type == TRIGGER_PEDESTAL \|\| tmp->type == SPECIAL_KEY	1587	\|\| tmp->type == TRIGGER_PEDESTAL
1587	\|\| tmp->type == TREASURE \|\| tmp->type == BOOK \|\| tmp->type == HOLY_ALTAR)))	1588	\|\| tmp->type == SPECIAL_KEY
		1589	\|\| tmp->type == TREASURE
		1590	\|\| tmp->type == BOOK
		1591	\|\| tmp->type == HOLY_ALTAR
		1592	\|\| tmp->type == CONTAINER)))
1588	{	1593	{
		1594	printf ("show inv %s\n", tmp->debug_desc());//D
1589	if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)	1595	if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1590	{	1596	{
1591	tmp->invisible = 0;	1597	tmp->invisible = 0;
1592	done_one = 1;	1598	done_one = 1;
1593	}	1599	}
1594	}	1600	}
1595		1601
1596	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1602	if (tmp->flag [FLAG_IS_FLOOR])
1597	floor = 1;	1603	floor = 1;
1598		1604
1599	/* All detections below this point don't descend beneath the floor,	1605	/* All detections below this point don't descend beneath the floor,
1600	* so just continue on. We could be clever and look at the type of	1606	* so just continue on. We could be clever and look at the type of
1601	* detection to completely break out if we don't care about objects beneath	1607	* detection to completely break out if we don't care about objects beneath
…		…
1610	* difficult to see what object is magical/cursed, so the	1616	* difficult to see what object is magical/cursed, so the
1611	* effect wouldn't be as apparent.	1617	* effect wouldn't be as apparent.
1612	*/	1618	*/
1613		1619
1614	/* detect magic */	1620	/* detect magic */
1615	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&	1621	if (spell->flag [FLAG_KNOWN_MAGICAL]
1616	!QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))	1622	&& !tmp->flag [FLAG_KNOWN_MAGICAL]
		1623	&& !tmp->flag [FLAG_IDENTIFIED]
		1624	&& tmp->need_identify ()
		1625	&& is_magical (tmp))
1617	{	1626	{
1618	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1627	tmp->set_flag (FLAG_KNOWN_MAGICAL);
1619	/* make runes more visibile */	1628	/* make runes more visible */
1620	if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)	1629	if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1621	tmp->stats.Cha /= 4;	1630	tmp->stats.Cha /= 4;
1622		1631
1623	done_one = 1;	1632	done_one = 1;
1624	}	1633	}
1625		1634
1626	/* detect monster */	1635	/* detect monster */
1627	if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) \|\| tmp->type == PLAYER))	1636	if (spell->flag [FLAG_MONSTER] && (tmp->flag [FLAG_MONSTER] \|\| tmp->type == PLAYER))
1628	{	1637	{
1629	done_one = 2;	1638	done_one = 2;
1630		1639
1631	if (!detect)	1640	if (!detect)
1632	detect = tmp;	1641	detect = tmp;
…		…
1634		1643
1635	/* Basically, if race is set in the spell, then the creatures race must	1644	/* Basically, if race is set in the spell, then the creatures race must
1636	* match that. if the spell race is set to GOD, then the gods opposing	1645	* match that. if the spell race is set to GOD, then the gods opposing
1637	* race must match.	1646	* race must match.
1638	*/	1647	*/
1639	if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&	1648	if (spell->race && tmp->flag [FLAG_MONSTER] && tmp->race &&
1640	((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) \|\|	1649	((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) \|\|
1641	spell->race.contains (tmp->race)))	1650	spell->race.contains (tmp->race)))
1642	{	1651	{
1643	done_one = 2;	1652	done_one = 2;
1644		1653
1645	if (!detect)	1654	if (!detect)
1646	detect = tmp;	1655	detect = tmp;
1647	}	1656	}
1648		1657
1649	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1658	if (spell->flag [FLAG_KNOWN_CURSED]
1650	(QUERY_FLAG (tmp, FLAG_CURSED) \|\| QUERY_FLAG (tmp, FLAG_DAMNED)))	1659	&& !tmp->flag [FLAG_KNOWN_CURSED]
		1660	&& tmp->need_identify ()
		1661	&& (tmp->flag [FLAG_CURSED] \|\| tmp->flag [FLAG_DAMNED]))
1651	{	1662	{
1652	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1663	tmp->set_flag (FLAG_KNOWN_CURSED);
1653	done_one = 1;	1664	done_one = 1;
		1665	}
		1666
		1667	// Do mining detection spell:
		1668	if (spell->last_sp == 1) // 1 - detect any vein
		1669	{
		1670	if (tmp->type == VEIN)
		1671	{
		1672	if (tmp->other_arch)
		1673	{
		1674	if (!detect)
		1675	detect = tmp->other_arch;
		1676	done_one = 2;
		1677	}
		1678	else
		1679	done_one = 1;
		1680	}
1654	}	1681	}
1655	} /* for stack of objects on this space */	1682	} /* for stack of objects on this space */
1656		1683
1657	/* Code here puts an effect of the spell on the space, so you can see	1684	/* Code here puts an effect of the spell on the space, so you can see
1658	* where the magic is.	1685	* where the magic is.
1659	*/	1686	*/
1660	if (done_one)	1687	if (done_one)
1661	{	1688	{
1662	object *detect_ob = arch_to_object (spell->other_arch);	1689	object *detect_ob = spell->other_arch->instance ();
1663		1690
1664	/* if this is set, we want to copy the face */	1691	/* if this is set, we want to copy the face */
1665	if (done_one == 2 && detect)	1692	if (done_one == 2 && detect)
1666	{	1693	{
1667	detect_ob->face = detect->face;	1694	detect_ob->face = detect->face;
1668	detect_ob->animation_id = detect->animation_id;	1695	detect_ob->animation_id = detect->animation_id;
1669	detect_ob->anim_speed = detect->anim_speed;	1696	detect_ob->anim_speed = detect->anim_speed;
1670	detect_ob->last_anim = 0;	1697	detect_ob->last_anim = 0;
1671	/* by default, the detect_ob is already animated */	1698	/* by default, the detect_ob is already animated */
1672	if (!QUERY_FLAG (detect, FLAG_ANIMATE))	1699	if (!detect->flag [FLAG_ANIMATE])
1673	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);	1700	detect_ob->clr_flag (FLAG_ANIMATE);
1674	}	1701	}
1675		1702
1676	m->insert (detect_ob, nx, ny, op);	1703	m->insert (detect_ob, nx, ny, op, INS_ON_TOP);
1677	}	1704	}
1678	} /* for processing the surrounding spaces */	1705	} /* for processing the surrounding spaces */
1679		1706
1680		1707
1681	/* Now process objects in the players inventory if detect curse or magic */	1708	/* Now process objects in the players inventory if detect curse or magic */
1682	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) \|\| QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))	1709	if (spell->flag [FLAG_KNOWN_CURSED] \|\| spell->flag [FLAG_KNOWN_MAGICAL])
1683	{	1710	{
1684	done_one = 0;	1711	done_one = 0;
1685		1712
1686	for (tmp = op->inv; tmp; tmp = tmp->below)	1713	for (tmp = op->inv; tmp; tmp = tmp->below)
1687	{	1714	{
1688	if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1715	if (!tmp->invisible && !tmp->flag [FLAG_IDENTIFIED])
1689	{	1716	{
1690	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))	1717	if (spell->flag [FLAG_KNOWN_MAGICAL] && is_magical (tmp) && !tmp->flag [FLAG_KNOWN_MAGICAL])
1691	{	1718	{
1692	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1719	tmp->set_flag (FLAG_KNOWN_MAGICAL);
1693		1720
1694	if (object *pl = tmp->visible_to ())	1721	if (object *pl = tmp->visible_to ())
1695	esrv_update_item (UPD_FLAGS, pl, tmp);	1722	esrv_update_item (UPD_FLAGS, pl, tmp);
1696	}	1723	}
1697		1724
1698	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1725	if (spell->flag [FLAG_KNOWN_CURSED] && !tmp->flag [FLAG_KNOWN_CURSED] &&
1699	(QUERY_FLAG (tmp, FLAG_CURSED) \|\| QUERY_FLAG (tmp, FLAG_DAMNED)))	1726	(tmp->flag [FLAG_CURSED] \|\| tmp->flag [FLAG_DAMNED]))
1700	{	1727	{
1701	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1728	tmp->set_flag (FLAG_KNOWN_CURSED);
1702		1729
1703	if (object *pl = tmp->visible_to ())	1730	if (object *pl = tmp->visible_to ())
1704	esrv_update_item (UPD_FLAGS, pl, tmp);	1731	esrv_update_item (UPD_FLAGS, pl, tmp);
1705	}	1732	}
1706	} /* if item is not identified */	1733	} /* if item is not identified */
…		…
1766	mflags = get_map_flags (m, &m, x, y, &x, &y);	1793	mflags = get_map_flags (m, &m, x, y, &x, &y);
1767		1794
1768	if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)	1795	if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
1769	{	1796	{
1770	for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)	1797	for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)
1771	if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))	1798	if (plyr != op && plyr->flag [FLAG_ALIVE])
1772	break;	1799	break;
1773	}	1800	}
1774		1801
1775		1802
1776	/* If we did not find a player in the specified direction, transfer	1803	/* If we did not find a player in the specified direction, transfer
1777	* to anyone on top of us. This is used for the rune of transference mostly.	1804	* to anyone on top of us. This is used for the rune of transference mostly.
1778	*/	1805	*/
1779	if (plyr == NULL)	1806	if (plyr == NULL)
1780	for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)	1807	for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)
1781	if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))	1808	if (plyr != op && plyr->flag [FLAG_ALIVE])
1782	break;	1809	break;
1783		1810
1784	if (!plyr)	1811	if (!plyr)
1785	{	1812	{
1786	new_draw_info (NDI_BLACK, 0, op, "There is no one there.");	1813	op->failmsg ("There is no one there.");
1787	return 0;	1814	return 0;
1788	}	1815	}
1789	/* give sp */	1816	/* give sp */
1790	if (spell->stats.dam > 0)	1817	if (spell->stats.dam > 0)
1791	{	1818	{
…		…
1803	if (rate > 95)	1830	if (rate > 95)
1804	rate = 95;	1831	rate = 95;
1805		1832
1806	sucked = (plyr->stats.sp * rate) / 100;	1833	sucked = (plyr->stats.sp * rate) / 100;
1807	plyr->stats.sp -= sucked;	1834	plyr->stats.sp -= sucked;
1808	if (QUERY_FLAG (op, FLAG_ALIVE))	1835	if (op->flag [FLAG_ALIVE])
1809	{	1836	{
1810	/* Player doesn't get full credit */	1837	/* Player doesn't get full credit */
1811	sucked = (sucked * rate) / 100;	1838	sucked = (sucked * rate) / 100;
1812	op->stats.sp += sucked;	1839	op->stats.sp += sucked;
1813	if (sucked > 0)	1840	if (sucked > 0)
…		…
1864	* monsters either.	1891	* monsters either.
1865	*/	1892	*/
1866		1893
1867	if (head->attacktype & AT_MAGIC	1894	if (head->attacktype & AT_MAGIC
1868	&& !(head->attacktype & AT_COUNTERSPELL)	1895	&& !(head->attacktype & AT_COUNTERSPELL)
1869	&& !QUERY_FLAG (head, FLAG_MONSTER)	1896	&& !head->flag [FLAG_MONSTER]
1870	&& (op->level > head->level))	1897	&& (op->level > head->level))
1871	head->destroy ();	1898	head->destroy ();
1872	else	1899	else
1873	switch (head->type)	1900	switch (head->type)
1874	{	1901	{
1875	case SPELL_EFFECT:	1902	case SPELL_EFFECT:
1876	// XXX: Don't affect floor spelleffects. See also XXX comment	1903	// XXX: Don't affect floor spelleffects. See also XXX comment
1877	// about sanctuary in spell_util.C	1904	// about sanctuary in spell_util.C
1878	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1905	if (tmp->flag [FLAG_IS_FLOOR])
1879	continue;	1906	continue;
1880		1907
1881	if (op->level > head->level)	1908	if (op->level > head->level)
1882	head->destroy ();	1909	head->destroy ();
1883		1910
…		…
1906		1933
1907	object tmp, god = find_god (determine_god (op));	1934	object tmp, god = find_god (determine_god (op));
1908		1935
1909	if (!god)	1936	if (!god)
1910	{	1937	{
1911	new_draw_info (NDI_UNIQUE, 0, op, "You can't consecrate anything if you don't worship a god!");	1938	op->failmsg ("You can't consecrate anything if you don't worship a god!");
1912	return 0;	1939	return 0;
1913	}	1940	}
1914		1941
1915	for (tmp = op->below; tmp; tmp = tmp->below)	1942	for (tmp = op->below; tmp; tmp = tmp->below)
1916	{	1943	{
1917	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1944	if (tmp->flag [FLAG_IS_FLOOR])
1918	break;	1945	break;
1919	if (tmp->type == HOLY_ALTAR)	1946	if (tmp->type == HOLY_ALTAR)
1920	{	1947	{
1921		1948
1922	if (tmp->level > casting_level (caster, spell))	1949	if (tmp->level > casting_level (caster, spell))
1923	{	1950	{
1924	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);	1951	op->failmsgf ("You are not powerful enough to reconsecrate the %s", &tmp->name);
1925	return 0;	1952	return 0;
1926	}	1953	}
1927	else	1954	else
1928	{	1955	{
1929	/* If we got here, we are consecrating an altar */	1956	/* If we got here, we are consecrating an altar */
…		…
1938	new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);	1965	new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
1939	return 1;	1966	return 1;
1940	}	1967	}
1941	}	1968	}
1942	}	1969	}
1943	new_draw_info (NDI_UNIQUE, 0, op, "You are not standing over an altar!");	1970
		1971	op->failmsg ("You are not standing over an altar!");
1944	return 0;	1972	return 0;
1945	}	1973	}
1946		1974
1947	/* animate_weapon -	1975	/* animate_weapon -
1948	* Generalization of staff_to_snake. Makes a golem out of the caster's weapon.	1976	* Generalization of staff_to_snake. Makes a golem out of the caster's weapon.
…		…
1955	* player checks. MSW 2003-01-06	1983	* player checks. MSW 2003-01-06
1956	*/	1984	*/
1957	int	1985	int
1958	animate_weapon (object op, object caster, object *spell, int dir)	1986	animate_weapon (object op, object caster, object *spell, int dir)
1959	{	1987	{
1960	object weapon, tmp;
1961	char buf[MAX_BUF];	1988	char buf[MAX_BUF];
1962	int a, i;	1989	int a, i;
1963	sint16 x, y;	1990	sint16 x, y;
1964	maptile *m;	1991	maptile *m;
1965		1992
…		…
1990		2017
1991	/* if there's no place to put the golem, abort */	2018	/* if there's no place to put the golem, abort */
1992	if (dir < 0 \|\| (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)	2019	if (dir < 0 \|\| (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
1993	\|\| ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))	2020	\|\| ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
1994	{	2021	{
1995	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	2022	op->failmsg ("There is something in the way.");
1996	return 0;	2023	return 0;
1997	}	2024	}
1998		2025
1999	/* Use the weapon marked by the player. */	2026	/* Use the weapon marked by the player. */
2000	weapon = find_marked_object (op);	2027	object *weapon = op->mark ();
2001		2028
2002	if (!weapon)	2029	if (!weapon)
2003	{	2030	{
2004	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");	2031	op->failmsg ("You must mark a weapon to use with this spell!");
2005	return 0;	2032	return 0;
2006	}	2033	}
2007		2034
2008	if (spell->race && weapon->arch->archname != spell->race)	2035	if (spell->race && weapon->arch->archname != spell->race)
2009	{	2036	{
2010	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");	2037	op->failmsg ("The spell fails to transform your weapon.");
2011	return 0;	2038	return 0;
2012	}	2039	}
2013		2040
2014	if (weapon->type != WEAPON)	2041	if (weapon->type != WEAPON)
2015	{	2042	{
2016	new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");	2043	op->failmsg ("You need to wield a weapon to animate it.");
2017	return 0;	2044	return 0;
2018	}	2045	}
2019		2046
2020	if (QUERY_FLAG (weapon, FLAG_APPLIED))	2047	if (weapon->flag [FLAG_APPLIED])
2021	{	2048	{
2022	new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));	2049	op->failmsgf ("You need to unequip %s before using it in this spell", query_name (weapon));
2023	return 0;	2050	return 0;
2024	}	2051	}
2025		2052
2026	weapon = weapon->split ();	2053	weapon = weapon->split ();
2027		2054
2028	/* create the golem object */	2055	/* create the golem object */
2029	tmp = arch_to_object (spell->other_arch);	2056	object *tmp = spell->other_arch->instance ();
2030		2057
2031	/* if animated by a player, give the player control of the golem */	2058	/* if animated by a player, give the player control of the golem */
2032	CLEAR_FLAG (tmp, FLAG_MONSTER);	2059	tmp->clr_flag (FLAG_MONSTER);
2033	tmp->stats.exp = 0;	2060	tmp->stats.exp = 0;
2034	add_friendly_object (tmp);	2061	add_friendly_object (tmp);
2035	tmp->type = GOLEM;	2062	tmp->type = GOLEM;
2036	tmp->set_owner (op);	2063	tmp->set_owner (op);
2037	op->contr->golem = tmp;	2064	op->contr->golem = tmp;
…		…
2039		2066
2040	/* Give the weapon to the golem now. A bit of a hack to check the	2067	/* Give the weapon to the golem now. A bit of a hack to check the
2041	* removed flag - it should only be set if weapon->split was	2068	* removed flag - it should only be set if weapon->split was
2042	* used above.	2069	* used above.
2043	*/	2070	*/
2044	if (!QUERY_FLAG (weapon, FLAG_REMOVED))	2071	if (!weapon->flag [FLAG_REMOVED])
2045	weapon->remove ();	2072	weapon->remove ();
2046		2073
2047	tmp->insert (weapon);	2074	tmp->insert (weapon);
2048		2075
2049	/* To do everything necessary to let a golem use the weapon is a pain,	2076	/* To do everything necessary to let a golem use the weapon is a pain,
2050	* so instead, just set it as equipped (otherwise, we need to update	2077	* so instead, just set it as equipped (otherwise, we need to update
2051	* body_info, skills, etc)	2078	* body_info, skills, etc)
2052	*/	2079	*/
2053	SET_FLAG (tmp, FLAG_USE_WEAPON);	2080	tmp->set_flag (FLAG_USE_WEAPON);
2054	SET_FLAG (weapon, FLAG_APPLIED);	2081	weapon->set_flag (FLAG_APPLIED);
2055	tmp->update_stats ();	2082	tmp->update_stats ();
2056		2083
2057	/* There used to be 'odd' code that basically seemed to take the absolute	2084	/* There used to be 'odd' code that basically seemed to take the absolute
2058	* value of the weapon->magic an use that. IMO, that doesn't make sense -	2085	* value of the weapon->magic an use that. IMO, that doesn't make sense -
2059	* if you're using a crappy weapon, it shouldn't be as good.	2086	* if you're using a crappy weapon, it shouldn't be as good.
…		…
2079		2106
2080	/* attacktype */	2107	/* attacktype */
2081	if (!tmp->attacktype)	2108	if (!tmp->attacktype)
2082	tmp->attacktype = AT_PHYSICAL;	2109	tmp->attacktype = AT_PHYSICAL;
2083		2110
2084	if (materialtype_t *mt = name_to_material (op->materialname))
2085	{
2086	for (i = 0; i < NROFATTACKS; i++)	2111	for (i = 0; i < NROFATTACKS; i++)
2087	tmp->resist[i] = 50 - (mt->save[i] * 5);	2112	tmp->resist[i] = 50 - (op->material->save[i] * 5);
2088	a = mt->save[0];	2113
2089	}	2114	a = op->material->save[0];
2090	else
2091	{
2092	for (i = 0; i < NROFATTACKS; i++)
2093	tmp->resist[i] = 5;
2094	a = 10;
2095	}
2096		2115
2097	/* Set weapon's immunity */	2116	/* Set weapon's immunity */
2098	tmp->resist[ATNR_CONFUSION] = 100;	2117	tmp->resist[ATNR_CONFUSION] = 100;
2099	tmp->resist[ATNR_POISON] = 100;	2118	tmp->resist[ATNR_POISON] = 100;
2100	tmp->resist[ATNR_SLOW] = 100;	2119	tmp->resist[ATNR_SLOW] = 100;
…		…
2127	tmp->state = weapon->state;	2146	tmp->state = weapon->state;
2128	tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];	2147	tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2129	}	2148	}
2130		2149
2131	/* make experience increase in proportion to the strength of the summoned creature. */	2150	/* make experience increase in proportion to the strength of the summoned creature. */
2132	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));	2151	tmp->stats.exp *= 1 + (max (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));
2133		2152
2134	tmp->speed_left = -1;	2153	tmp->speed_left = -1;
2135	tmp->direction = dir;	2154	tmp->direction = dir;
2136		2155
2137	m->insert (tmp, x, y, op);	2156	m->insert (tmp, x, y, op);
…		…
2154	success = op->map->change_map_light (spell->stats.dam);	2173	success = op->map->change_map_light (spell->stats.dam);
2155		2174
2156	if (!success)	2175	if (!success)
2157	{	2176	{
2158	if (spell->stats.dam < 0)	2177	if (spell->stats.dam < 0)
2159	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");	2178	op->failmsg ("It can be no brighter here.");
2160	else	2179	else
2161	new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");	2180	op->failmsg ("It can be no darker here.");
2162	}	2181	}
2163		2182
2164	return success;	2183	return success;
2165	}	2184	}
2166		2185
…		…
2176		2195
2177	new_aura = present_arch_in_ob (spell->other_arch, op);	2196	new_aura = present_arch_in_ob (spell->other_arch, op);
2178	if (new_aura)	2197	if (new_aura)
2179	refresh = 1;	2198	refresh = 1;
2180	else	2199	else
2181	new_aura = arch_to_object (spell->other_arch);	2200	new_aura = spell->other_arch->instance ();
2182		2201
2183	new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);	2202	new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2184		2203
2185	new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	2204	new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2186		2205
…		…
2251	if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))	2270	if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2252	{	2271	{
2253	hit_map (aura, i, aura->attacktype, 0);	2272	hit_map (aura, i, aura->attacktype, 0);
2254		2273
2255	if (aura->other_arch)	2274	if (aura->other_arch)
2256	pos.insert (arch_to_object (aura->other_arch), aura);	2275	pos.insert (aura->other_arch->instance (), aura);
2257	}	2276	}
2258	}	2277	}
2259		2278
2260	/* put the aura back in the player's inventory */	2279	/* put the aura back in the player's inventory */
2261	env->insert (aura);	2280	env->insert (aura);
…		…
2271	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)	2290	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
2272	{	2291	{
2273	int atk_lev, def_lev;	2292	int atk_lev, def_lev;
2274	object *victim = tmp->head_ ();	2293	object *victim = tmp->head_ ();
2275		2294
2276	if (!QUERY_FLAG (victim, FLAG_MONSTER))	2295	if (!victim->flag [FLAG_MONSTER])
2277	continue;	2296	continue;
2278		2297
2279	if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))	2298	if (victim->flag [FLAG_UNAGGRESSIVE])
2280	continue;	2299	continue;
2281		2300
2282	if (victim->stats.exp == 0)	2301	if (victim->stats.exp == 0)
2283	continue;	2302	continue;
2284		2303
2285	def_lev = MAX (1, victim->level);	2304	def_lev = max (1, victim->level);
2286	atk_lev = MAX (1, op->level);	2305	atk_lev = max (1, op->level);
2287		2306
2288	if (rndm (0, atk_lev - 1) > def_lev)	2307	if (rndm (0, atk_lev - 1) > def_lev)
2289	{	2308	{
2290	/* make this sucker peaceful. */	2309	/* make this sucker peaceful. */
2291		2310
…		…
2300	victim->stats.sp = 0;	2319	victim->stats.sp = 0;
2301	victim->stats.grace = 0;	2320	victim->stats.grace = 0;
2302	victim->stats.Pow = 0;	2321	victim->stats.Pow = 0;
2303	#endif	2322	#endif
2304	victim->attack_movement = RANDO2;	2323	victim->attack_movement = RANDO2;
2305	SET_FLAG (victim, FLAG_UNAGGRESSIVE);	2324	victim->set_flag (FLAG_UNAGGRESSIVE);
2306	SET_FLAG (victim, FLAG_RUN_AWAY);	2325	victim->set_flag (FLAG_RUN_AWAY);
2307	SET_FLAG (victim, FLAG_RANDOM_MOVE);	2326	victim->set_flag (FLAG_RANDOM_MOVE);
2308	CLEAR_FLAG (victim, FLAG_MONSTER);	2327	victim->clr_flag (FLAG_MONSTER);
2309		2328
2310	if (victim->name)	2329	if (victim->name)
2311	new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);	2330	new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2312	}	2331	}
2313	}	2332	}
…		…
2319	int	2338	int
2320	write_mark (object op, object spell, const char *msg)	2339	write_mark (object op, object spell, const char *msg)
2321	{	2340	{
2322	if (!msg \|\| msg[0] == 0)	2341	if (!msg \|\| msg[0] == 0)
2323	{	2342	{
2324	new_draw_info (NDI_UNIQUE, 0, op, "Write what?");	2343	op->failmsg ("Write what?");
2325	return 0;	2344	return 0;
2326	}	2345	}
2327		2346
2328	if (strcasestr_local (msg, "endmsg"))	2347	if (!msg_is_safe (msg))
2329	{	2348	{
2330	new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");	2349	op->failmsg ("Trying to cheat are we? H<@-signs are not allowed in marking runes.>");
2331	LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg);	2350	LOG (llevInfo, "write_mark: player %s tried to write bogus rune %s\n", &op->name, msg);
2332	return 0;	2351	return 0;
2333	}	2352	}
2334		2353
2335	if (!spell->other_arch)	2354	if (!spell->other_arch)
2336	return 0;	2355	return 0;
2337		2356
2338	object *tmp = arch_to_object (spell->other_arch);	2357	object *tmp = spell->other_arch->instance ();
2339		2358
2340	tmp->race = op->name; /Save the owner of the rune /	2359	tmp->race = op->name; /Save the owner of the rune /
2341	tmp->msg = msg;	2360	tmp->msg = msg;
2342		2361
2343	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);	2362	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);

Diff Legend

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

Comparing deliantra/server/server/spell_effect.C (file contents): Revision 1.99 by elmex, Tue Jan 13 13:29:57 2009 UTC vs. Revision 1.130 by root, Wed Apr 21 05:48:35 2010 UTC

Diff Legend

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.99 by elmex, Tue Jan 13 13:29:57 2009 UTC vs.
Revision 1.130 by root, Wed Apr 21 05:48:35 2010 UTC