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.28 by root, Sat Dec 30 10:16:11 2006 UTC vs.
Revision 1.111 by root, Mon Oct 12 21:27:55 2009 UTC

1	/*	1	/*
2	CrossFire, A Multiplayer game for X-windows	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 (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
6		7	*
7	This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify it under
8	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
9	the Free Software Foundation; either version 2 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
10	(at your option) any later version.	11	* option) any later version.
11		12	*
12	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,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	16	* GNU General Public License for more details.
16		17	*
17	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
18	along with this program; if not, write to the Free Software	19	* and the GNU General Public License along with this program. If not, see
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* <http://www.gnu.org/licenses/>.
20		21	*
21	The authors can be reached via e-mail at <crossfire@schmorp.de>	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>
25	#include <object.h>	26	#include <object.h>
26	#include <living.h>	27	#include <living.h>
27	#ifndef __CEXTRACT__
28	# include <sproto.h>	28	#include <sproto.h>
29	#endif
30	#include <spells.h>	29	#include <spells.h>
31	#include <sounds.h>	30	#include <sounds.h>
32		31
33	/* cast_magic_storm: This is really used mostly for spell	32	/* cast_magic_storm: This is really used mostly for spell
34	* fumbles at the like. tmp is the object to propogate.	33	* fumbles at the like. tmp is the object to propogate.
…		…
63	{	62	{
64	object *wand, *tmp;	63	object *wand, *tmp;
65	int ncharges;	64	int ncharges;
66		65
67	wand = find_marked_object (op);	66	wand = find_marked_object (op);
68	if (wand == NULL || wand->type != WAND)	67	if (!wand || wand->type != WAND)
69	{	68	{
70	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");	69	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");
71	return 0;	70	return 0;
72	}	71	}
73	if (!(random_roll (0, 3, op, PREFER_HIGH)))	72	if (!(random_roll (0, 3, op, PREFER_HIGH)))
74	{	73	{
75	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));	74	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));
76	play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE);	75	op->play_sound (sound_find ("ob_explode"));
77	esrv_del_item (op->contr, wand->count);
78	wand->destroy ();	76	wand->destroy ();
79	tmp = get_archetype ("fireball");	77	tmp = get_archetype ("fireball");
80	tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;	78	tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
81		79
82	if (!tmp->stats.dam)	80	if (!tmp->stats.dam)
…		…
105	ncharges = 1;	103	ncharges = 1;
106		104
107	wand->stats.food += ncharges;	105	wand->stats.food += ncharges;
108	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));	106	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
109		107
110	if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE))	108	if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE))
111	{	109	{
112	SET_FLAG (wand, FLAG_ANIMATE);	110	SET_FLAG (wand, FLAG_ANIMATE);
113	wand->set_speed (wand->arch->clone.speed);	111	wand->set_speed (wand->arch->speed);
114	}	112	}
115		113
116	return 1;	114	return 1;
117	}	115	}
118		116
…		…
124	* great a plus, the default is used.	122	* great a plus, the default is used.
125	* The # of arrows created also goes up with level, so if a 30th level mage	123	* The # of arrows created also goes up with level, so if a 30th level mage
126	* wants LOTS of arrows, and doesn't care what the plus is he could	124	* wants LOTS of arrows, and doesn't care what the plus is he could
127	* create nonnmagic arrows, or even -1, etc...	125	* create nonnmagic arrows, or even -1, etc...
128	*/	126	*/
129
130	int	127	int
131	cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg)	128	cast_create_missile (object *op, object *caster, object *spell, int dir, const char *spellparam)
132	{	129	{
133	int missile_plus = 0, bonus_plus = 0;	130	int bonus_plus = 0;
134	const char *missile_name;	131	const char *missile_name = "arrow";
135	object *tmp, *missile;
136		132
137	missile_name = "arrow";
138
139	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	133	for (object *tmp = op->inv; tmp; tmp = tmp->below)
140	if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))	134	if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
141	missile_name = tmp->race;	135	missile_name = tmp->race;
142		136
143	missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);	137	int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
144		138
145	if (archetype::find (missile_name) == NULL)	139	archetype *missile_arch = archetype::find (missile_name);
		140
		141	if (!missile_arch)
146	{	142	{
147	LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);	143	LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);
148	return 0;	144	return 0;
149	}	145	}
150		146
151	missile = get_archetype (missile_name);	147	object *missile = missile_arch->instance ();
152		148
153	if (stringarg)	149	if (spellparam)
154	{	150	{
155	/* If it starts with a letter, presume it is a description */	151	/* If it starts with a letter, presume it is a description */
156	if (isalpha (*stringarg))	152	if (isalpha (*spellparam))
157	{	153	{
158	artifact *al = find_artifactlist (missile->type)->items;	154	artifact *al = find_artifactlist (missile->type)->items;
159		155
160	for (; al != NULL; al = al->next)	156	for (; al; al = al->next)
161	if (!strcasecmp (al->item->name, stringarg))	157	if (!strcasecmp (al->item->name, spellparam))
162	break;	158	break;
163		159
164	if (!al)	160	if (!al)
165	{	161	{
166	missile->destroy ();	162	missile->destroy ();
167	new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, stringarg);	163	new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, spellparam);
168	return 0;	164	return 0;
169	}	165	}
170		166
171	if (al->item->slaying)	167	if (al->item->slaying)
172	{	168	{
173	missile->destroy ();	169	missile->destroy ();
174	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg);	170	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, spellparam);
175	return 0;	171	return 0;
176	}	172	}
177		173
178	give_artifact_abilities (missile, al->item);	174	give_artifact_abilities (missile, al->item);
179	/* These special arrows cost something extra. Don't have them also be magical -	175	/* These special arrows cost something extra. Don't have them also be magical -
180	* otherwise, in most cases, not enough will be created. I don't want to get into	176	* otherwise, in most cases, not enough will be created. I don't want to get into
181	* the parsing of having to do both plus and type.	177	* the parsing of having to do both plus and type.
182	*/	178	*/
183	bonus_plus = 1 + (al->item->value / 5);	179	bonus_plus = 1 + (al->item->value / 5);
184	missile_plus = 0;	180	missile_plus = 0;
185	}	181	}
186	else if (atoi (stringarg) < missile_plus)	182	else if (atoi (spellparam) < missile_plus)
187	missile_plus = atoi (stringarg);	183	missile_plus = atoi (spellparam);
188	}	184	}
189		185
190	if (missile_plus > 4)	186	missile_plus = clamp (missile_plus, -4, 4);
191	missile_plus = 4;
192	else if (missile_plus < -4)
193	missile_plus = -4;
194		187
195	missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);	188	missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
196	missile->nrof -= 3 * (missile_plus + bonus_plus);	189	missile->nrof -= 3 * (missile_plus + bonus_plus);
197		190
198	if (missile->nrof < 1)	191	if (missile->nrof < 1)
…		…
210	return 1;	203	return 1;
211	}	204	}
212		205
213		206
214	/* allows the choice of what sort of food object to make.	207	/* allows the choice of what sort of food object to make.
215	* If stringarg is NULL, it will create food dependent on level --PeterM*/	208	* If spellparam is NULL, it will create food dependent on level --PeterM*/
216	int	209	int
217	cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *stringarg)	210	cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *spellparam)
218	{	211	{
219	int food_value;	212	int food_value;
220	archetype *at = NULL;	213	archetype *at = NULL;
221	object *new_op;	214	object *new_op;
222		215
223	food_value = spell_ob->stats.food + +50 * SP_level_duration_adjust (caster, spell_ob);	216	food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);
224		217
225	if (stringarg)	218	if (spellparam)
226	{	219	{
227	at = find_archetype_by_object_type_name (FOOD, stringarg);	220	at = find_archetype_by_object_type_name (FOOD, spellparam);
228	if (at == NULL)	221	if (at == NULL)
229	at = find_archetype_by_object_type_name (DRINK, stringarg);	222	at = find_archetype_by_object_type_name (DRINK, spellparam);
230	if (at == NULL || at->clone.stats.food > food_value)	223	if (at == NULL || at->stats.food > food_value)
231	stringarg = NULL;	224	spellparam = NULL;
232	}	225	}
233		226
234	if (!stringarg)	227	if (!spellparam)
235	{	228	{
236	archetype *at_tmp;	229	archetype *at_tmp;
237		230
238	/* We try to find the archetype with the maximum food value.	231	/* We try to find the archetype with the maximum food value.
239	* This removes the dependancy of hard coded food values in this	232	* This removes the dependancy of hard coded food values in this
…		…
241	* We don't use flesh types because the weight values of those need	234	* We don't use flesh types because the weight values of those need
242	* to be altered from the donor.	235	* to be altered from the donor.
243	*/	236	*/
244		237
245	/* We assume the food items don't have multiple parts */	238	/* We assume the food items don't have multiple parts */
246	for (at_tmp = first_archetype; at_tmp != NULL; at_tmp = at_tmp->next)	239	for_all_archetypes (at_tmp)
247	{	240	{
248	if (at_tmp->clone.type == FOOD || at_tmp->clone.type == DRINK)	241	if (at_tmp->type == FOOD || at_tmp->type == DRINK)
249	{	242	{
250	/* Basically, if the food value is something that is creatable	243	/* Basically, if the food value is something that is creatable
251	* under the limits of the spell and it is higher than	244	* under the limits of the spell and it is higher than
252	* the item we have now, take it instead.	245	* the item we have now, take it instead.
253	*/	246	*/
254	if (at_tmp->clone.stats.food <= food_value && (!at || at_tmp->clone.stats.food > at->clone.stats.food))	247	if (at_tmp->stats.food <= food_value
		248	&& (!at
		249	|| at_tmp->stats.food > at->stats.food
		250	|| (at_tmp->stats.food == at->stats.food
		251	&& at_tmp->weight < at->weight)))
255	at = at_tmp;	252	at = at_tmp;
256	}	253	}
257	}	254	}
258	}	255	}
		256
259	/* Pretty unlikely (there are some very low food items), but you never	257	/* Pretty unlikely (there are some very low food items), but you never
260	* know	258	* know
261	*/	259	*/
262	if (!at)	260	if (!at)
263	{	261	{
264	new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");	262	new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");
265	return 0;	263	return 0;
266	}	264	}
267		265
268	food_value /= at->clone.stats.food;	266	food_value /= at->stats.food;
269	new_op = arch_to_object (at);	267	new_op = arch_to_object (at);
270	new_op->nrof = food_value;	268	new_op->nrof = food_value;
271		269
272	new_op->value = 0;	270	new_op->value = 0;
273	if (new_op->nrof < 1)	271	if (new_op->nrof < 1)
…		…
282	{	280	{
283	int r, mflags, maxrange;	281	int r, mflags, maxrange;
284	object *tmp;	282	object *tmp;
285	maptile *m;	283	maptile *m;
286		284
287
288	if (!dir)	285	if (!dir)
289	{	286	{
290	examine_monster (op, op);	287	examine_monster (op, op);
291	return 1;	288	return 1;
292	}	289	}
		290
293	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	291	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
294	for (r = 1; r < maxrange; r++)	292	for (r = 1; r < maxrange; r++)
295	{	293	{
296	sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];	294	sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];
297		295
…		…
304	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))	302	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))
305	{	303	{
306	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");	304	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
307	return 0;	305	return 0;
308	}	306	}
		307
309	if (mflags & P_IS_ALIVE)	308	if (mflags & P_IS_ALIVE)
310	{	309	{
311	for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)	310	for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
312	if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))	311	if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))
313	{	312	{
314	new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");	313	new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
315	if (tmp->head != NULL)	314	if (tmp->head != NULL)
316	tmp = tmp->head;	315	tmp = tmp->head;
317	examine_monster (op, tmp);	316	examine_monster (op, tmp);
318	return 1;	317	return 1;
319	}	318	}
320	}	319	}
321	}	320	}
		321
322	new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");	322	new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");
323	return 1;	323	return 1;
324	}	324	}
325
326		325
327	/* This checks to see if 'pl' is invisible to 'mon'.	326	/* This checks to see if 'pl' is invisible to 'mon'.
328	* does race check, undead check, etc	327	* does race check, undead check, etc
329	* Returns TRUE if mon can't see pl, false	328	* Returns TRUE if mon can't see pl, false
330	* otherwise. This doesn't check range, walls, etc. It	329	* otherwise. This doesn't check range, walls, etc. It
…		…
332	* pl is invisible.	331	* pl is invisible.
333	*/	332	*/
334	int	333	int
335	makes_invisible_to (object *pl, object *mon)	334	makes_invisible_to (object *pl, object *mon)
336	{	335	{
337
338	if (!pl->invisible)	336	if (!pl->invisible)
339	return 0;	337	return 0;
		338
340	if (pl->type == PLAYER)	339	if (pl->type == PLAYER)
341	{	340	{
342	/* If race isn't set, then invisible unless it is undead */	341	/* If race isn't set, then invisible unless it is undead */
343	if (!pl->contr->invis_race)	342	if (!pl->contr->invis_race)
344	{	343	{
345	if (QUERY_FLAG (mon, FLAG_UNDEAD))	344	if (QUERY_FLAG (mon, FLAG_UNDEAD))
346	return 0;	345	return 0;
		346
347	return 1;	347	return 1;
348	}	348	}
		349
349	/* invis_race is set if we get here */	350	/* invis_race is set if we get here */
350	if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon))	351	if (pl->contr->invis_race == shstr_undead && is_true_undead (mon))
351	return 1;	352	return 1;
		353
352	/* No race, can't be invisible to it */	354	/* No race, can't be invisible to it */
353	if (!mon->race)	355	if (!mon->race)
354	return 0;	356	return 0;
		357
355	if (strstr (mon->race, pl->contr->invis_race))	358	if (mon->race.contains (pl->contr->invis_race))
356	return 1;	359	return 1;
		360
357	/* Nothing matched above, return 0 */	361	/* Nothing matched above, return 0 */
358	return 0;	362	return 0;
359	}	363	}
360	else	364	else
361	{	365	{
…		…
374	* normal applies.	378	* normal applies.
375	*/	379	*/
376	int	380	int
377	cast_invisible (object *op, object *caster, object *spell_ob)	381	cast_invisible (object *op, object *caster, object *spell_ob)
378	{	382	{
379	object *tmp;
380
381	if (op->invisible > 1000)	383	if (op->invisible > 1000)
382	{	384	{
383	new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");	385	new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");
384	return 0;	386	return 0;
385	}	387	}
…		…
401	else	403	else
402	op->contr->tmp_invis = 1;	404	op->contr->tmp_invis = 1;
403		405
404	op->contr->hidden = 0;	406	op->contr->hidden = 0;
405	}	407	}
		408
406	if (makes_invisible_to (op, op))	409	if (makes_invisible_to (op, op))
407	new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");	410	new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");
408	else	411	else
409	new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!");	412	new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!");
410		413
411	update_object (op, UP_OBJ_FACE);	414	update_object (op, UP_OBJ_CHANGE);
412		415
413	/* Only search the active objects - only these should actually do	416	/* Only search the active objects - only these should actually do
414	* harm to the player.	417	* harm to the player.
415	*/	418	*/
416	for (tmp = active_objects; tmp != NULL; tmp = tmp->active_next)	419	for_all_actives (tmp)
417	if (tmp->enemy == op)	420	if (tmp->enemy == op)
418	tmp->enemy = NULL;	421	tmp->enemy = 0;
		422
419	return 1;	423	return 1;
420	}	424	}
421		425
422	/* earth to dust spell. Basically destroys earthwalls in the area.	426	/* earth to dust spell. Basically destroys earthwalls in the area.
423	*/	427	*/
424	int	428	int
425	cast_earth_to_dust (object *op, object *caster, object *spell_ob)	429	cast_earth_to_dust (object *op, object *caster, object *spell_ob)
426	{	430	{
427	object *tmp, *next;
428	int range, i, j, mflags;	431	int range, i, j, mflags;
429	sint16 sx, sy;	432	sint16 sx, sy;
430	maptile *m;	433	maptile *m;
431
432	if (op->type != PLAYER)
433	return 0;
434		434
435	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	435	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
436		436
437	for (i = -range; i <= range; i++)	437	for (i = -range; i <= range; i++)
438	for (j = -range; j <= range; j++)	438	for (j = -range; j <= range; j++)
…		…
443	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);	443	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
444		444
445	if (mflags & P_OUT_OF_MAP)	445	if (mflags & P_OUT_OF_MAP)
446	continue;	446	continue;
447		447
448	// earth to dust tears down everything that can be teared down	448	// earth to dust tears down everything that can be torn down
449	for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)	449	for (object *next, *tmp = m->at (sx, sy).bot; tmp; tmp = next)
450	{	450	{
451	next = tmp->above;	451	next = tmp->above;
		452
452	if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))	453	if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
453	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);	454	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
454	}	455	}
455	}	456	}
		457
456	return 1;	458	return 1;
457	}	459	}
458
459		460
460	void	461	void
461	execute_word_of_recall (object *op)	462	execute_word_of_recall (object *op)
462	{	463	{
463	object *wor = op;	464	if (object *pl = op->in_player ())
464		465	{
465	while (op != NULL && op->type != PLAYER)	466	if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
466	op = op->env;
467
468	if (op != NULL && op->map)
469	if ((get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_CLERIC) && (!QUERY_FLAG (op, FLAG_WIZCAST)))
470	new_draw_info (NDI_UNIQUE, 0, op, "You feel something fizzle inside you.");	467	new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
471	else	468	else
472	op->enter_exit (wor);	469	pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);
		470	}
473		471
474	wor->destroy ();	472	op->destroy ();
475	}	473	}
476		474
477	/* Word of recall causes the player to return 'home'.	475	/* Word of recall causes the player to return 'home'.
478	* we put a force into the player object, so that there is a	476	* we put a force into the player object, so that there is a
479	* time delay effect.	477	* time delay effect.
…		…
492	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");	490	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
493	return 1;	491	return 1;
494	}	492	}
495		493
496	dummy = get_archetype (FORCE_NAME);	494	dummy = get_archetype (FORCE_NAME);
497	if (dummy == NULL)	495
		496	if (!dummy)
498	{	497	{
499	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	498	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
500	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");	499	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
501	return 0;	500	return 0;
502	}	501	}
		502
503	time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);	503	time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);
504	if (time < 1)	504	if (time < 1)
505	time = 1;	505	time = 1;
506		506
507	/* value of speed really doesn't make much difference, as long as it is	507	/* value of speed really doesn't make much difference, as long as it is
…		…
515		515
516	/* If we could take advantage of enter_player_savebed() here, it would be	516	/* If we could take advantage of enter_player_savebed() here, it would be
517	* nice, but until the map load fails, we can't.	517	* nice, but until the map load fails, we can't.
518	*/	518	*/
519	EXIT_PATH (dummy) = op->contr->savebed_map;	519	EXIT_PATH (dummy) = op->contr->savebed_map;
520	EXIT_X (dummy) = op->contr->bed_x;	520	EXIT_X (dummy) = op->contr->bed_x;
521	EXIT_Y (dummy) = op->contr->bed_y;	521	EXIT_Y (dummy) = op->contr->bed_y;
522		522
523	(void) insert_ob_in_ob (dummy, op);	523	op->insert (dummy);
		524
524	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");	525	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
		526
525	return 1;	527	return 1;
526	}	528	}
527		529
528	/* cast_wonder	530	/* cast_wonder
529	* wonder is really just a spell that will likely cast another	531	* wonder is really just a spell that will likely cast another
…		…
562	}	564	}
563		565
564	int	566	int
565	perceive_self (object *op)	567	perceive_self (object *op)
566	{	568	{
567	char *cp = describe_item (op, op), buf[MAX_BUF];	569	const char *cp = describe_item (op, op);
568	archetype *at = archetype::find (ARCH_DEPLETION);	570	archetype *at = archetype::find (ARCH_DEPLETION);
569	object *tmp;
570	int i;
571		571
		572	dynbuf_text &buf = msg_dynbuf; buf.clear ();
		573
		574	if (!op->is_player ())
		575	return 0;
		576
		577	if (object *race = archetype::find (op->race))
		578	buf << " - You are a G<male|female> " << &race->name << ".\n";
		579
572	tmp = find_god (determine_god (op));	580	if (object *god = find_god (determine_god (op)))
573	if (tmp)	581	buf << " - You worship " << &god->name << ".\n";
574	new_draw_info_format (NDI_UNIQUE, 0, op, "You worship %s", &tmp->name);
575	else	582	else
576	new_draw_info (NDI_UNIQUE, 0, op, "You worship no god");	583	buf << " - You worship no god.\n";
577		584
578	tmp = present_arch_in_ob (at, op);	585	object *tmp = present_arch_in_ob (at, op);
579		586
580	if (*cp == '\0' && tmp == NULL)	587	if (*cp == '\0' && !tmp)
581	new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane");	588	buf << " - You feel very mundane. ";
582	else	589	else
583	{	590	{
584	new_draw_info (NDI_UNIQUE, 0, op, "You have:");	591	buf << " - You have: " << cp << ".\n";
585	new_draw_info (NDI_UNIQUE, 0, op, cp);	592
586	if (tmp != NULL)	593	if (tmp)
587	{
588	for (i = 0; i < NUM_STATS; i++)	594	for (int i = 0; i < NUM_STATS; i++)
589	{	595	if (tmp->stats.stat (i) < 0)
590	if (get_attr_value (&tmp->stats, i) < 0)	596	buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
591	{
592	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is depleted by %d", statname[i], -(get_attr_value (&tmp->stats, i)));
593	}
594	}
595	}
596	}	597	}
597		598
598	if (is_dragon_pl (op))	599	if (is_dragon_pl (op))
599	{
600	/* now grab the 'dragon_ability'-force from the player's inventory */	600	/* now grab the 'dragon_ability'-force from the player's inventory */
601	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	601	for (tmp = op->inv; tmp; tmp = tmp->below)
602	{	602	{
603	if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force"))	603	if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
604	{	604	{
605	if (tmp->stats.exp == 0)	605	if (tmp->stats.exp == 0)
606	{
607	sprintf (buf, "Your metabolism isn't focused on anything.");	606	buf << " - Your metabolism isn't focused on anything.\n";
608	}
609	else	607	else
610	{
611	sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]);	608	buf << " - Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
612	}	609
613	new_draw_info (NDI_UNIQUE, 0, op, buf);
614	break;	610	break;
615	}	611	}
616	}	612	}
617	}
618	return 1;
619	}
620		613
621	/* int cast_create_town_portal (object *op, object *caster, int dir)	614	op->contr->infobox (MSG_CHANNEL ("perceiveself"), buf);
622	*
623	* This function cast the spell of town portal for op
624	*
625	* The spell operates in two passes. During the first one a place
626	* is marked as a destination for the portal. During the second one,
627	* 2 portals are created, one in the position the player cast it and
628	* one in the destination place. The portal are synchronized and 2 forces
629	* are inserted in the player to destruct the portal next time player
630	* creates a new portal pair.
631	* This spell has a side effect that it allows people to meet each other
632	* in a permanent, private, appartements by making a town portal from it
633	* to the town or another public place. So, check if the map is unique and if
634	* so return an error
635	*
636	* Code by Tchize (david.delbecq@usa.net)
637	*/
638	int
639	cast_create_town_portal (object *op, object *caster, object *spell, int dir)
640	{
641	object *dummy, *force, *old_force, *tmp;
642	archetype *perm_portal;
643	char portal_name[1024], portal_message[1024];
644	maptile *exitmap;
645	int op_level;
646
647	/* Check to see if the map the player is currently on is a per player unique
648	* map. This can be determined in that per player unique maps have the
649	* full pathname listed.
650	*/
651	if (!strncmp (op->map->path, settings.localdir, strlen (settings.localdir)) && settings.create_home_portals != TRUE)
652	{
653	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You can't cast that here.\n");
654	return 0;
655	}
656
657	/* The first thing to do is to check if we have a marked destination
658	* dummy is used to make a check inventory for the force
659	*/
660	dummy = arch_to_object (spell->other_arch);
661	if (dummy == NULL)
662	{
663	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
664	LOG (llevError, "object::create failed (force in cast_create_town_portal for %s!\n", &op->name);
665	return 0;
666	}
667
668	force = check_inv_recursive (op, dummy);
669
670	if (force == NULL)
671	{
672	/* Here we know there is no destination marked up.
673	* We have 2 things to do:
674	* 1. Mark the destination in the player inventory.
675	* 2. Let the player know it worked.
676	*/
677	dummy->name = op->map->path;
678	EXIT_X (dummy) = op->x;
679	EXIT_Y (dummy) = op->y;
680	insert_ob_in_ob (dummy, op);
681	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You fix this place in your mind.\nYou feel you are able to come here from anywhere.");
682	return 1;
683	}
684
685	dummy->destroy ();
686
687	/* Here we know where the town portal should go to
688	* We should kill any existing portal associated with the player.
689	* Than we should create the 2 portals.
690	* For each of them, we need:
691	* - To create the portal with the name of the player+destination map
692	* - set the owner of the town portal
693	* - To mark the position of the portal in the player's inventory
694	* for easier destruction.
695	*
696	* The mark works has follow:
697	* slaying: Existing town portal
698	* hp, sp : x & y of the associated portal
699	* name : name of the portal
700	* race : map the portal is in
701	*/
702
703	/* First step: killing existing town portals */
704	dummy = get_archetype (spell->race);
705	if (dummy == NULL)
706	{
707	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
708	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
709	return 0;
710	}
711
712	perm_portal = archetype::find (spell->slaying);
713
714	/* To kill a town portal, we go trough the player's inventory,
715	* for each marked portal in player's inventory,
716	* -We try load the associated map (if impossible, consider the portal destructed)
717	* -We find any portal in the specified location.
718	* If it has the good name, we destruct it.
719	* -We destruct the force indicating that portal.
720	*/
721	while ((old_force = check_inv_recursive (op, dummy)))
722	{
723	exitmap = maptile::find_map (old_force->race, op->map);
724
725	if (exitmap)
726	{
727	int exitx = EXIT_X (old_force);
728	int exity = EXIT_Y (old_force);
729
730	tmp = present_arch (perm_portal, exitmap, exitx, exity);
731	while (tmp)
732	{
733	if (tmp->name == old_force->name)
734	{
735	tmp->destroy ();
736	break;
737	}
738
739	tmp = tmp->above;
740	}
741	}
742
743	old_force->destroy ();
744	}
745
746	dummy->destroy ();
747
748	/* Creating the portals.
749	* The very first thing to do is to ensure
750	* access to the destination map.
751	* If we can't, don't fizzle. Simply warn player.
752	* This ensure player pays his mana for the spell
753	* because HE is responsible of forgotting.
754	* 'force' is the destination of the town portal, which we got
755	* from the players inventory above.
756	*/
757
758	/* Ensure exit map is loaded */
759	exitmap = maptile::find_map (force->name, 0);
760
761	/* If we were unable to load (ex. random map deleted), warn player */
762	if (!exitmap)
763	{
764	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens.\nYou can't remember where to go!?");
765	force->destroy ();
766	return 1;
767	}
768
769	op_level = caster_level (caster, spell);
770	if (op_level < 15)
771	snprintf (portal_message, 1024,
772	"\nThe air moves around you and\na huge smell of ammonia\nsurounds you as you pass\nthrough %s's tiny portal\nPouah!\n",
773	&op->name);
774	else if (op_level < 30)
775	snprintf (portal_message, 1024,
776	"\n%s's portal smells of ozone.\nYou do a lot of movements and finally pass\nthrough the small hole in the air\n", &op->name);
777	else if (op_level < 60)
778	snprintf (portal_message, 1024, "\nA shining door opens in the air in front of you,\nshowing you the path to another place.\n");
779	else
780	snprintf (portal_message, 1024, "\nAs you walk through %s's portal, flowers come out\nfrom the ground around you.\nYou feel awed.\n",
781	&op->name);
782
783	/* Create a portal in front of player
784	* dummy contain the portal and
785	* force contain the track to kill it later
786	*/
787	snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name);
788	dummy = get_archetype (spell->slaying); /*The portal */
789	if (dummy == NULL)
790	{
791	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
792	LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
793	return 0;
794	}
795
796	EXIT_PATH (dummy) = force->name;
797	EXIT_X (dummy) = EXIT_X (force);
798	EXIT_Y (dummy) = EXIT_Y (force);
799	dummy->name = dummy->name_pl = portal_name;
800	dummy->msg = portal_message;
801	dummy->race = op->name; /*Save the owner of the portal */
802	cast_create_obj (op, caster, dummy, 0);
803
804	/* Now we need to to create a town portal marker inside the player
805	* object, so on future castings, we can know that he has an active
806	* town portal.
807	*/
808	tmp = get_archetype (spell->race);
809	if (tmp == NULL)
810	{
811	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
812	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
813	return 0;
814	}
815
816	tmp->race = op->map->path;
817	tmp->name = portal_name;
818	EXIT_X (tmp) = dummy->x;
819	EXIT_Y (tmp) = dummy->y;
820	op->insert (tmp);
821
822	/* Create a portal in the destination map
823	* dummy contain the portal and
824	* force the track to kill it later
825	* the 'force' variable still contains the 'reminder' of
826	* where this portal goes to.
827	*/
828	snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &op->map->path);
829	dummy = get_archetype (spell->slaying); /*The portal */
830	if (dummy == NULL)
831	{
832	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
833	LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
834	return 0;
835	}
836
837	EXIT_PATH (dummy) = op->map->path;
838	EXIT_X (dummy) = op->x;
839	EXIT_Y (dummy) = op->y;
840	dummy->name = dummy->name_pl = portal_name;
841	dummy->msg = portal_message;
842	dummy->race = op->name; /*Save the owner of the portal */
843	exitmap->insert (dummy, EXIT_X (force), EXIT_Y (force), op);
844
845	/* Now we create another town portal marker that
846	* points back to the one we just made
847	*/
848	tmp = get_archetype (spell->race);
849	if (tmp == NULL)
850	{
851	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
852	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
853	return 0;
854	}
855
856	tmp->race = force->name;
857	tmp->name = portal_name;
858	EXIT_X (tmp) = dummy->x;
859	EXIT_Y (tmp) = dummy->y;
860	insert_ob_in_ob (tmp, op);
861
862	/* Describe the player what happened
863	*/
864	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You see air moving and showing you the way home.");
865	force->destroy ();
866		615
867	return 1;	616	return 1;
868	}	617	}
869		618
870	/* This creates magic walls. Really, it can create most any object,	619	/* This creates magic walls. Really, it can create most any object,
…		…
958	*/	707	*/
959	if (tmp->type != EARTHWALL) //TODO	708	if (tmp->type != EARTHWALL) //TODO
960	tmp->set_owner (op);	709	tmp->set_owner (op);
961		710
962	set_spell_skill (op, caster, spell_ob, tmp);	711	set_spell_skill (op, caster, spell_ob, tmp);
963	tmp->level = caster_level (caster, spell_ob) / 2;	712	tmp->level = casting_level (caster, spell_ob) / 2;
964		713
965	name = tmp->name;	714	name = tmp->name;
966	if (!(tmp = m->insert (tmp, x, y, op)))	715	if (!(tmp = m->insert (tmp, x, y, op)))
967	{	716	{
968	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);	717	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
969	return 0;	718	return 0;
970	}	719	}
971		720
972	/* If this is a spellcasting wall, need to insert the spell object */	721	/* If this is a spellcasting wall, need to insert the spell object */
973	if (tmp->other_arch && tmp->other_arch->clone.type == SPELL)	722	if (tmp->other_arch && tmp->other_arch->type == SPELL)
974	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);	723	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
975		724
976	/* This code causes the wall to extend some distance in	725	/* This code causes the wall to extend some distance in
977	* each direction, or until an obstruction is encountered.	726	* each direction, or until an obstruction is encountered.
978	* posblocked and negblocked help determine how far the	727	* posblocked and negblocked help determine how far the
…		…
998	{	747	{
999	object *tmp2 = tmp->clone ();	748	object *tmp2 = tmp->clone ();
1000	m->insert (tmp2, x, y, op);	749	m->insert (tmp2, x, y, op);
1001		750
1002	/* If this is a spellcasting wall, need to insert the spell object */	751	/* If this is a spellcasting wall, need to insert the spell object */
1003	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	752	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1004	tmp2->insert (arch_to_object (tmp2->other_arch));	753	tmp2->insert (arch_to_object (tmp2->other_arch));
1005		754
1006	}	755	}
1007	else	756	else
1008	posblocked = 1;	757	posblocked = 1;
…		…
1015	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)	764	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
1016	{	765	{
1017	object *tmp2 = tmp->clone ();	766	object *tmp2 = tmp->clone ();
1018	m->insert (tmp2, x, y, op);	767	m->insert (tmp2, x, y, op);
1019		768
1020	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	769	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1021	tmp2->insert (arch_to_object (tmp2->other_arch));	770	tmp2->insert (arch_to_object (tmp2->other_arch));
1022	}	771	}
1023	else	772	else
1024	negblocked = 1;	773	negblocked = 1;
1025	}	774	}
…		…
1029		778
1030	return 1;	779	return 1;
1031	}	780	}
1032		781
1033	int	782	int
1034	dimension_door (object *op, object *caster, object *spob, int dir)	783	dimension_door (object *op, object *caster, object *spob, int dir, const char *spellparam)
1035	{	784	{
1036	uint32 dist, maxdist;	785	uint32 dist, maxdist;
1037	int mflags;	786	int mflags;
1038	maptile *m;	787	maptile *m;
1039	sint16 sx, sy;	788	sint16 sx, sy;
…		…
1050	/* Given the new outdoor maps, can't let players dimension door for	799	/* Given the new outdoor maps, can't let players dimension door for
1051	* ever, so put limits in.	800	* ever, so put limits in.
1052	*/	801	*/
1053	maxdist = spob->range + SP_level_range_adjust (caster, spob);	802	maxdist = spob->range + SP_level_range_adjust (caster, spob);
1054		803
1055	if (op->contr->count)	804	if (spellparam)
1056	{	805	{
		806	int count = atoi (spellparam);
		807
1057	if (op->contr->count > maxdist)	808	if (count > maxdist)
1058	{	809	{
1059	new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!");	810	new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!");
1060	return 0;	811	return 0;
1061	}	812	}
1062		813
1063	for (dist = 0; dist < op->contr->count; dist++)	814	for (dist = 0; dist < count; dist++)
1064	{	815	{
1065	mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);	816	mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);
1066		817
1067	if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))	818	if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
1068	break;	819	break;
1069		820
1070	if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))	821	if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
1071	break;	822	break;
1072	}	823	}
1073		824
1074	if (dist < op->contr->count)	825	if (dist < count)
1075	{	826	{
1076	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");	827	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
1077	op->contr->count = 0;
1078	return 0;	828	return 0;
1079	}	829	}
1080
1081	op->contr->count = 0;
1082		830
1083	/* Remove code that puts player on random space on maps. IMO,	831	/* Remove code that puts player on random space on maps. IMO,
1084	* a lot of maps probably have areas the player should not get to,	832	* a lot of maps probably have areas the player should not get to,
1085	* but may not be marked as NO_MAGIC (as they may be bounded	833	* but may not be marked as NO_MAGIC (as they may be bounded
1086	* by such squares). Also, there are probably treasure rooms and	834	* by such squares). Also, there are probably treasure rooms and
…		…
1141		889
1142	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */	890	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
1143	return 1;	891	return 1;
1144	}	892	}
1145		893
1146
1147	/* cast_heal: Heals something.	894	/* cast_heal: Heals something.
1148	* op is the caster.	895	* op is the caster.
1149	* dir is the direction he is casting it in.	896	* dir is the direction he is casting it in.
1150	* spell is the spell object.	897	* spell is the spell object.
1151	*/	898	*/
…		…
1157	object *poison;	904	object *poison;
1158	int heal = 0, success = 0;	905	int heal = 0, success = 0;
1159		906
1160	tmp = find_target_for_friendly_spell (op, dir);	907	tmp = find_target_for_friendly_spell (op, dir);
1161		908
1162	if (tmp == NULL)	909	if (!tmp)
1163	return 0;	910	return 0;
1164		911
1165	/* Figure out how many hp this spell might cure.	912	/* Figure out how many hp this spell might cure.
1166	* could be zero if this spell heals effects, not damage.	913	* could be zero if this spell heals effects, not damage.
1167	*/	914	*/
…		…
1170	heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp;	917	heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp;
1171		918
1172	if (heal)	919	if (heal)
1173	{	920	{
1174	if (tmp->stats.hp >= tmp->stats.maxhp)	921	if (tmp->stats.hp >= tmp->stats.maxhp)
1175	{
1176	new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed.");	922	new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed.");
1177	}
1178	else	923	else
1179	{	924	{
1180	/* See how many points we actually heal. Instead of messages	925	/* See how many points we actually heal. Instead of messages
1181	* based on type of spell, we instead do messages based	926	* based on type of spell, we instead do messages based
1182	* on amount of damage healed.	927	* on amount of damage healed.
1183	*/	928	*/
1184	if (heal > (tmp->stats.maxhp - tmp->stats.hp))	929	if (heal > tmp->stats.maxhp - tmp->stats.hp)
1185	heal = tmp->stats.maxhp - tmp->stats.hp;	930	heal = tmp->stats.maxhp - tmp->stats.hp;
		931
1186	tmp->stats.hp += heal;	932	tmp->stats.hp += heal;
1187		933
1188	if (tmp->stats.hp >= tmp->stats.maxhp)	934	if (tmp->stats.hp >= tmp->stats.maxhp)
1189	{
1190	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");	935	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
1191	}
1192	else if (heal > 50)	936	else if (heal > 50)
1193	{
1194	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");	937	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");
1195	}
1196	else if (heal > 25)	938	else if (heal > 25)
1197	{
1198	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");	939	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");
1199	}
1200	else if (heal > 10)	940	else if (heal > 10)
1201	{
1202	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade.");	941	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade.");
1203	}
1204	else	942	else
1205	{
1206	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close.");	943	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close.");
1207	}	944
1208	success = 1;	945	success = 1;
1209	}	946	}
1210	}	947	}
		948
1211	if (spell->attacktype & AT_DISEASE)	949	if (spell->attacktype & AT_DISEASE)
1212	if (cure_disease (tmp, op))	950	if (cure_disease (tmp, op, spell))
1213	success = 1;	951	success = 1;
1214		952
1215	if (spell->attacktype & AT_POISON)	953	if (spell->attacktype & AT_POISON)
1216	{	954	{
1217	at = archetype::find ("poisoning");	955	at = archetype::find ("poisoning");
…		…
1221	success = 1;	959	success = 1;
1222	new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");	960	new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
1223	poison->stats.food = 1;	961	poison->stats.food = 1;
1224	}	962	}
1225	}	963	}
		964
1226	if (spell->attacktype & AT_CONFUSION)	965	if (spell->attacktype & AT_CONFUSION)
1227	{	966	{
1228	poison = present_in_ob_by_name (FORCE, "confusion", tmp);	967	poison = present_in_ob_by_name (FORCE, "confusion", tmp);
1229	if (poison)	968	if (poison)
1230	{	969	{
1231	success = 1;	970	success = 1;
1232	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	971	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
1233	poison->duration = 1;	972	poison->duration = 1;
1234	}	973	}
1235	}	974	}
		975
1236	if (spell->attacktype & AT_BLIND)	976	if (spell->attacktype & AT_BLIND)
1237	{	977	{
1238	at = archetype::find ("blindness");	978	at = archetype::find ("blindness");
1239	poison = present_arch_in_ob (at, tmp);	979	poison = present_arch_in_ob (at, tmp);
1240	if (poison)	980	if (poison)
…		…
1242	success = 1;	982	success = 1;
1243	new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");	983	new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
1244	poison->stats.food = 1;	984	poison->stats.food = 1;
1245	}	985	}
1246	}	986	}
		987
1247	if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)	988	if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)
1248	{	989	{
1249	tmp->stats.sp += spell->last_sp;	990	tmp->stats.sp += spell->last_sp;
1250	if (tmp->stats.sp > tmp->stats.maxsp)	991	if (tmp->stats.sp > tmp->stats.maxsp)
1251	tmp->stats.sp = tmp->stats.maxsp;	992	tmp->stats.sp = tmp->stats.maxsp;
1252	success = 1;	993	success = 1;
1253	new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!");	994	new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!");
1254	}	995	}
		996
1255	if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)	997	if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)
1256	{	998	{
1257	tmp->stats.grace += spell->last_grace;	999	tmp->stats.grace += spell->last_grace;
1258	if (tmp->stats.grace > tmp->stats.maxgrace)	1000	if (tmp->stats.grace > tmp->stats.maxgrace)
1259	tmp->stats.grace = tmp->stats.maxgrace;	1001	tmp->stats.grace = tmp->stats.maxgrace;
1260	success = 1;	1002	success = 1;
1261	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");	1003	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1262	}	1004	}
		1005
1263	if (spell->stats.food && tmp->stats.food < 999)	1006	if (spell->stats.food && tmp->stats.food < 999)
1264	{	1007	{
1265	tmp->stats.food += spell->stats.food;	1008	tmp->stats.food += spell->stats.food;
		1009
1266	if (tmp->stats.food > 999)	1010	if (tmp->stats.food > 999)
1267	tmp->stats.food = 999;	1011	tmp->stats.food = 999;
		1012
1268	success = 1;	1013	success = 1;
1269	/* 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 */
1270	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");
1271	}	1016	}
		1017
1272	return success;	1018	return success;
1273	}	1019	}
1274
1275		1020
1276	/* This is used for the spells that gain stats. There are no spells	1021	/* This is used for the spells that gain stats. There are no spells
1277	* right now that icnrease wis/int/pow on a temp basis, so no	1022	* right now that icnrease wis/int/pow on a temp basis, so no
1278	* good comments for those.	1023	* good comments for those.
1279	*/	1024	*/
1280	static const char *const no_gain_msgs[NUM_STATS] = {	1025	static const char *const no_gain_msgs[NUM_STATS] = {
1281	"You grow no stronger.",	1026	"You grow no stronger.",
1282	"You grow no more agile.",	1027	"You grow no more agile.",
1283	"You don't feel any healthier.",	1028	"You don't feel any healthier.",
1284	"no wis",	1029	"You didn't grow any more intelligent.",
		1030	"You do not feel any wiser.",
		1031	"You don't feel any more powerful."
1285	"You are no easier to look at.",	1032	"You are no easier to look at.",
1286	"no int",
1287	"no pow"
1288	};	1033	};
1289		1034
1290	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
1291	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)
1292	{	1043	{
1293	object *force = NULL;	1044	object *force = 0;
1294	int i;	1045	int i;
1295		1046
1296	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */	1047	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1297	object *tmp = dir	1048	object *tmp = dir
1298	? find_target_for_friendly_spell (op, dir)	1049	? find_target_for_friendly_spell (op, dir)
1299	: op;	1050	: op;
1300		1051
1301	if (!tmp)	1052	if (!tmp)
1302	return 0;	1053	return 0;
1303		1054
1304	/* If we've already got a force of this type, don't add a new one. */	1055	/* If we've already got a force of this type, don't add a new one. */
…		…
1312	break;	1063	break;
1313	}	1064	}
1314	else if (spell_ob->race && spell_ob->race == tmp2->name)	1065	else if (spell_ob->race && spell_ob->race == tmp2->name)
1315	{	1066	{
1316	if (!silent)	1067	if (!silent)
1317	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	new_draw_info_format (NDI_UNIQUE, 0, op,
		1069	"You can not cast %s while %s is in effect",
		1070	&spell_ob->name, &tmp2->name_pl);
		1071
1318	return 0;	1072	return 0;
1319	}	1073	}
1320	}	1074	}
1321	}	1075	}
		1076
		1077	int duration = change_ability_duration (spell_ob, caster);
		1078
1322	if (force == NULL)	1079	if (force)
1323	{
1324	force = get_archetype (FORCE_NAME);
1325	force->subtype = FORCE_CHANGE_ABILITY;
1326	if (spell_ob->race)
1327	force->name = spell_ob->race;
1328	else
1329	force->name = spell_ob->name;
1330	force->name_pl = spell_ob->name;
1331	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
1332
1333	}	1080	{
1334	else
1335	{
1336	int duration;
1337
1338	duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1339	if (duration > force->duration)	1081	if (duration > force->duration)
1340	{	1082	{
1341	force->duration = duration;	1083	force->duration = duration;
1342	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	1084	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1343	}	1085	}
1344	else	1086	else
1345	{
1346	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1087	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1347	}	1088
1348	return 1;	1089	return 1;
1349	}	1090	}
1350	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1091
		1092	new_draw_info_format (NDI_UNIQUE, 0, op,
		1093	"You create an aura of magical force. H<The effect will last for about %.10g seconds.>",
		1094	TICK2TIME (duration));
		1095
		1096	force = get_archetype (FORCE_NAME);
		1097	force->subtype = FORCE_CHANGE_ABILITY;
		1098	force->duration = duration;
		1099
		1100	if (spell_ob->race)
		1101	force->name = spell_ob->race;
		1102	else
		1103	force->name = spell_ob->name;
		1104
		1105	force->name_pl = spell_ob->name;
		1106
1351	force->speed = 1.0;	1107	force->speed = 1.0;
1352	force->speed_left = -1.0;	1108	force->speed_left = -1.0;
1353	SET_FLAG (force, FLAG_APPLIED);	1109	SET_FLAG (force, FLAG_APPLIED);
1354		1110
1355	/* Now start processing the effects. First, protections */	1111	/* Now start processing the effects. First, protections */
…		…
1360	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);	1116	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);
1361	if (force->resist[i] > 100)	1117	if (force->resist[i] > 100)
1362	force->resist[i] = 100;	1118	force->resist[i] = 100;
1363	}	1119	}
1364	}	1120	}
		1121
1365	if (spell_ob->stats.hp)	1122	if (spell_ob->stats.hp)
1366	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);	1123	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
1367		1124
1368	if (tmp->type == PLAYER)	1125	if (tmp->type == PLAYER)
1369	{	1126	{
1370	/* Stat adjustment spells */	1127	/* Stat adjustment spells */
1371	for (i = 0; i < NUM_STATS; i++)	1128	for (i = 0; i < NUM_STATS; i++)
1372	{	1129	{
1373	sint8 stat = get_attr_value (&spell_ob->stats, i), k, sm;	1130	if (sint8 stat = spell_ob->stats.stat (i))
1374
1375	if (stat)
1376	{	1131	{
1377	sm = 0;	1132	sint8 sm = 0;
1378	for (k = 0; k < stat; k++)	1133	for (sint8 k = 0; k < stat; k++)
1379	sm += rndm (1, 3);	1134	sm += rndm (1, 3);
1380		1135
1381	if ((get_attr_value (&tmp->stats, i) + sm) > (15 + 5 * stat))	1136	if (tmp->stats.stat (i) + sm > 15 + 5 * stat)
1382	{	1137	sm = max (0, (15 + 5 * stat) - tmp->stats.stat (i));
1383	sm = (15 + 5 * stat) - get_attr_value (&tmp->stats, i);	1138
1384	if (sm < 0)	1139	force->stats.stat (i) = sm;
1385	sm = 0;	1140
1386	}
1387	set_attr_value (&force->stats, i, sm);
1388	if (!sm)	1141	if (!sm)
1389	new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);	1142	new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);
1390	}	1143	}
1391	}	1144	}
1392	}	1145	}
…		…
1413	force->attacktype = spell_ob->attacktype;	1166	force->attacktype = spell_ob->attacktype;
1414		1167
1415	insert_ob_in_ob (force, tmp);	1168	insert_ob_in_ob (force, tmp);
1416	change_abil (tmp, force); /* Mostly to display any messages */	1169	change_abil (tmp, force); /* Mostly to display any messages */
1417	tmp->update_stats ();	1170	tmp->update_stats ();
		1171
1418	return 1;	1172	return 1;
1419	}	1173	}
1420		1174
1421	/* This used to be part of cast_change_ability, but it really didn't make	1175	/* This used to be part of cast_change_ability, but it really didn't make
1422	* a lot of sense, since most of the values it derives are from the god	1176	* a lot of sense, since most of the values it derives are from the god
1423	* of the caster.	1177	* of the caster.
1424	*/	1178	*/
1425
1426	int	1179	int
1427	cast_bless (object *op, object *caster, object *spell_ob, int dir)	1180	cast_bless (object *op, object *caster, object *spell_ob, int dir)
1428	{	1181	{
1429	int i;	1182	int i;
1430	object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;	1183	object *god = find_god (determine_god (op)), *force = NULL, *tmp;
1431		1184
1432	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */	1185	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1433	if (dir != 0)	1186	if (dir != 0)
1434	{	1187	{
1435	tmp = find_target_for_friendly_spell (op, dir);	1188	tmp = find_target_for_friendly_spell (op, dir);
		1189
		1190	if (!tmp)
		1191	return 0;
1436	}	1192	}
1437	else	1193	else
1438	{
1439	tmp = op;	1194	tmp = op;
1440	}
1441		1195
1442	/* If we've already got a force of this type, don't add a new one. */	1196	/* If we've already got a force of this type, don't add a new one. */
1443	for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below)	1197	for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1444	{	1198	{
1445	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)	1199	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1446	{	1200	{
1447	if (tmp2->name == spell_ob->name)	1201	if (tmp2->name == spell_ob->name)
1448	{	1202	{
…		…
1454	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);	1208	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
1455	return 0;	1209	return 0;
1456	}	1210	}
1457	}	1211	}
1458	}	1212	}
		1213
1459	if (force == NULL)	1214	if (force == NULL)
1460	{	1215	{
1461	force = get_archetype (FORCE_NAME);	1216	force = get_archetype (FORCE_NAME);
1462	force->subtype = FORCE_CHANGE_ABILITY;	1217	force->subtype = FORCE_CHANGE_ABILITY;
1463	if (spell_ob->race)	1218	if (spell_ob->race)
…		…
1525	insert_ob_in_ob (force, tmp);	1280	insert_ob_in_ob (force, tmp);
1526	tmp->update_stats ();	1281	tmp->update_stats ();
1527	return 1;	1282	return 1;
1528	}	1283	}
1529		1284
1530
1531
1532	/* Alchemy code by Mark Wedel	1285	/* Alchemy code by Mark Wedel
1533	*	1286	*
1534	* This code adds a new spell, called alchemy. Alchemy will turn	1287	* This code adds a new spell, called alchemy. Alchemy will turn
1535	* objects to gold nuggets, the value of the gold nuggets being	1288	* objects to pyrite ("false gold"), henceforth called gold nuggets.
1536	* about 90% of that of the item itself. It uses the value of the
1537	* object before charisma adjustments, because the nuggets themselves
1538	* will be will be adjusted by charisma when sold.
1539	*	1289	*
1540	* Large nuggets are worth 25 gp each (base). You will always get	1290	* The value of the gold nuggets being about 90% of that of the item
1541	* the maximum number of large nuggets you could get.	1291	* itself. It uses the value of the object before charisma adjustments,
1542	* Small nuggets are worth 1 gp each (base). You will get from 0	1292	* because the nuggets themselves will be will be adjusted by charisma
1543	* to the max amount of small nuggets as you could get.	1293	* when sold.
1544	*
1545	* For example, if an item is worth 110 gold, you will get
1546	* 4 large nuggets, and from 0-10 small nuggets.
1547	*	1294	*
1548	* There is also a chance (1:30) that you will get nothing at all	1295	* There is also a chance (1:30) that you will get nothing at all
1549	* for the object. There is also a maximum weight that will be	1296	* for the object. There is also a maximum weight that will be
1550	* alchemied.	1297	* alchemised.
1551	*/	1298	*/
1552
1553	/* I didn't feel like passing these as arguements to the
1554	* two functions that need them. Real values are put in them
1555	* when the spell is cast, and these are freed when the spell
1556	* is finished.
1557	*/
1558	static object *small, *large;
1559
1560	static void	1299	static void
1561	alchemy_object (object *obj, int *small_nuggets, int *large_nuggets, int *weight)	1300	alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1562	{	1301	{
1563	uint64 value = query_cost (obj, NULL, F_TRUE);	1302	uint64 value = query_cost (obj, NULL, F_TRUE);
1564		1303
1565	/* Give third price when we alchemy money (This should hopefully	1304	/* Give third price when we alchemy money (this should hopefully
1566	* make it so that it isn't worth it to alchemy money, sell	1305	* make it so that it isn't worth it to alchemy money, sell
1567	* the nuggets, alchemy the gold from that, etc.	1306	* the nuggets, alchemy the gold from that, etc.
1568	* Otherwise, give 9 silver on the gold for other objects,	1307	* Otherwise, give 9 silver on the gold for other objects,
1569	* so that it would still be more affordable to haul	1308	* so that it would still be more affordable to haul
1570	* the stuff back to town.	1309	* the stuff back to town.
1571	*/	1310	*/
1572
1573	if (QUERY_FLAG (obj, FLAG_UNPAID))	1311	if (QUERY_FLAG (obj, FLAG_UNPAID))
1574	value = 0;	1312	value = 0;
1575	else if (obj->type == MONEY || obj->type == GEM)	1313	else if (obj->type == MONEY || obj->type == GEM)
1576	value /= 3;	1314	value /= 3;
1577	else	1315	else
1578	value = (value * 9) / 10;	1316	value = value * 9 / 10;
1579		1317
1580	value /= 4; // fix by GHJ, don't understand, pcg
1581
1582	if ((obj->value > 0) && rndm (0, 29))	1318	if (obj->value > 0 && rndm (0, 29))
1583	{	1319	total_value += value;
1584	int count;
1585		1320
1586	count = value / large->value;
1587	*large_nuggets += count;
1588	value -= (uint64) count *(uint64) large->value;
1589
1590	count = value / small->value;
1591	*small_nuggets += count;
1592	}
1593
1594	/* Turn 25 small nuggets into 1 large nugget. If the value
1595	* of large nuggets is not evenly divisable by the small nugget
1596	* value, take off an extra small_nugget (Assuming small_nuggets!=0)
1597	*/
1598	if (*small_nuggets * small->value >= large->value)
1599	{
1600	(*large_nuggets)++;
1601	*small_nuggets -= large->value / small->value;
1602	if (*small_nuggets && large->value % small->value)
1603	(*small_nuggets)--;
1604	}
1605	weight += obj->weight;	1321	total_weight += obj->total_weight ();
		1322
1606	obj->destroy ();	1323	obj->destroy ();
1607	}	1324	}
1608		1325
1609	static void
1610	update_map (object *op, maptile *m, int small_nuggets, int large_nuggets, int x, int y)
1611	{
1612	object *tmp;
1613	int flag = 0;
1614
1615	/* Put any nuggets below the player, but we can only pass this
1616	* flag if we are on the same space as the player
1617	*/
1618	if (x == op->x && y == op->y && op->map == m)
1619	flag = INS_BELOW_ORIGINATOR;
1620
1621	if (small_nuggets)
1622	{
1623	tmp = small->clone ();
1624	tmp->nrof = small_nuggets;
1625	m->insert (tmp, x, y, op, flag);
1626	}
1627
1628	if (large_nuggets)
1629	{
1630	tmp = large->clone ();
1631	tmp->nrof = large_nuggets;
1632	m->insert (tmp, x, y, op, flag);
1633	}
1634	}
1635
1636	int	1326	int
1637	alchemy (object *op, object *caster, object *spell_ob)	1327	alchemy (object *op, object *caster, object *spell_ob)
1638	{	1328	{
1639	int x, y, weight = 0, weight_max, large_nuggets, small_nuggets, mflags;
1640	sint16 nx, ny;
1641	object *next, *tmp;
1642	maptile *mp;
1643
1644	if (op->type != PLAYER)	1329	if (op->type != PLAYER)
1645	return 0;	1330	return 0;
1646		1331
		1332	archetype *nugget[3];
		1333
		1334	nugget[0] = archetype::find ("pyrite3");
		1335	nugget[1] = archetype::find ("pyrite2");
		1336	nugget[2] = archetype::find ("pyrite");
		1337
1647	/* Put a maximum weight of items that can be alchemied. Limits the power	1338	/* Put a maximum weight of items that can be alchemised. Limits the power
1648	* some, and also prevents people from alcheming every table/chair/clock	1339	* some, and also prevents people from alchemising every table/chair/clock
1649	* in sight	1340	* in sight
1650	*/	1341	*/
1651	weight_max = spell_ob->duration + +SP_level_duration_adjust (caster, spell_ob);	1342	int duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1652	weight_max *= 1000;	1343	int weight_max = duration * 1000;
1653	small = get_archetype ("smallnugget"), large = get_archetype ("largenugget");	1344	uint64 value_max = duration * 1000;
1654		1345
		1346	int weight = 0;
		1347
1655	for (y = op->y - 1; y <= op->y + 1; y++)	1348	for (int y = op->y - 1; y <= op->y + 1; y++)
1656	{	1349	{
1657	for (x = op->x - 1; x <= op->x + 1; x++)	1350	for (int x = op->x - 1; x <= op->x + 1; x++)
1658	{	1351	{
		1352	uint64 value = 0;
		1353
1659	nx = x;	1354	sint16 nx = x;
1660	ny = y;	1355	sint16 ny = y;
1661		1356
1662	mp = op->map;	1357	maptile *mp = op->map;
1663		1358
1664	mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);	1359	int mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);
1665		1360
1666	if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))	1361	if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))
1667	continue;	1362	continue;
1668		1363
1669	/* Treat alchemy a little differently - most spell effects	1364	/* Treat alchemy a little differently - most spell effects
…		…
1671	* ground level effect.	1366	* ground level effect.
1672	*/	1367	*/
1673	if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)	1368	if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)
1674	continue;	1369	continue;
1675		1370
1676	small_nuggets = 0;	1371	for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1677	large_nuggets = 0;
1678
1679	for (tmp = GET_MAP_OB (mp, nx, ny); tmp != NULL; tmp = next)
1680	{	1372	{
1681	next = tmp->above;	1373	next = tmp->above;
		1374
1682	if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&	1375	if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&
1683	!QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))	1376	!QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))
1684	{	1377	{
1685
1686	if (tmp->inv)	1378	if (tmp->inv)
1687	{	1379	{
1688	object *next1, *tmp1;	1380	object *next1, *tmp1;
1689		1381
1690	for (tmp1 = tmp->inv; tmp1 != NULL; tmp1 = next1)	1382	for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1691	{	1383	{
1692	next1 = tmp1->below;	1384	next1 = tmp1->below;
1693	if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&	1385	if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&
1694	!QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))	1386	!QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))
1695	alchemy_object (tmp1, &small_nuggets, &large_nuggets, &weight);	1387	alchemy_object (tmp1, value, weight);
1696	}	1388	}
1697	}	1389	}
		1390
1698	alchemy_object (tmp, &small_nuggets, &large_nuggets, &weight);	1391	alchemy_object (tmp, value, weight);
1699		1392
1700	if (weight > weight_max)	1393	if (weight > weight_max)
1701	{	1394	break;
1702	update_map (op, mp, small_nuggets, large_nuggets, nx, ny);
1703	large->destroy ();
1704	small->destroy ();
1705	return 1;
1706	}	1395	}
1707	} /* is alchemable object */
1708	} /* process all objects on this space */
1709
1710	/* Insert all the nuggets at one time. This probably saves time, but
1711	* it also prevents us from alcheming nuggets that were just created
1712	* with this spell.
1713	*/	1396	}
1714	update_map (op, mp, small_nuggets, large_nuggets, nx, ny);	1397
		1398	value -= rndm (value >> 4);
		1399	value = min (value, value_max);
		1400
		1401	for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
		1402	if (int nrof = value / nugget [i]->value)
		1403	{
		1404	value -= nrof * nugget[i]->value;
		1405
		1406	object *tmp = arch_to_object (nugget[i]);
		1407	tmp->nrof = nrof;
		1408	tmp->flag [FLAG_IDENTIFIED] = true;
		1409	op->map->insert (tmp, x, y, op, 0);
1715	}	1410	}
1716	}
1717		1411
1718	large->destroy ();	1412	if (weight > weight_max)
1719	small->destroy ();	1413	goto bailout;
1720	/* reset this so that if player standing on a big pile of stuff,	1414	}
1721	* it is redrawn properly.	1415	}
1722	*/	1416
1723	op->contr->ns->look_position = 0;	1417	bailout:
1724	return 1;	1418	return 1;
1725	}	1419	}
1726
1727		1420
1728	/* This function removes the cursed/damned status on equipped	1421	/* This function removes the cursed/damned status on equipped
1729	* items.	1422	* items.
1730	*/	1423	*/
1731	int	1424	int
1732	remove_curse (object *op, object *caster, object *spell)	1425	remove_curse (object *op, object *caster, object *spell)
1733	{	1426	{
1734	object *tmp;
1735	int success = 0, was_one = 0;	1427	int success = 0, was_one = 0;
1736		1428
1737	for (tmp = op->inv; tmp; tmp = tmp->below)	1429	for (object *tmp = op->inv; tmp; tmp = tmp->below)
1738	if (QUERY_FLAG (tmp, FLAG_APPLIED) &&	1430	if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
1739	((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||	1431	((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1740	(QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))	1432	(QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1741	{	1433	{
1742	was_one++;	1434	was_one++;
		1435
1743	if (tmp->level <= caster_level (caster, spell))	1436	if (tmp->level <= casting_level (caster, spell))
1744	{	1437	{
1745	success++;	1438	success++;
1746	if (QUERY_FLAG (spell, FLAG_DAMNED))	1439	if (QUERY_FLAG (spell, FLAG_DAMNED))
1747	CLEAR_FLAG (tmp, FLAG_DAMNED);	1440	CLEAR_FLAG (tmp, FLAG_DAMNED);
1748		1441
1749	CLEAR_FLAG (tmp, FLAG_CURSED);	1442	CLEAR_FLAG (tmp, FLAG_CURSED);
1750	CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);	1443	CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);
1751	tmp->value = 0; /* Still can't sell it */	1444	tmp->value = 0; /* Still can't sell it */
1752	if (op->type == PLAYER)	1445
		1446	if (object *pl = tmp->visible_to ())
1753	esrv_send_item (op, tmp);	1447	esrv_update_item (UPD_FLAGS, pl, tmp);
1754	}	1448	}
1755	}	1449	}
1756		1450
1757	if (op->type == PLAYER)	1451	if (op->type == PLAYER)
1758	{	1452	{
1759	if (success)	1453	if (success)
1760	{
1761	new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");	1454	new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");
1762	}
1763	else	1455	else
1764	{	1456	{
1765	if (was_one)	1457	if (was_one)
1766	new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");	1458	new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");
1767	else	1459	else
…		…
1771		1463
1772	return success;	1464	return success;
1773	}	1465	}
1774		1466
1775	/* Identifies objects in the players inventory/on the ground */	1467	/* Identifies objects in the players inventory/on the ground */
1776
1777	int	1468	int
1778	cast_identify (object *op, object *caster, object *spell)	1469	cast_identify (object *op, object *caster, object *spell)
1779	{	1470	{
1780	object *tmp;	1471	object *tmp;
1781	int success = 0, num_ident;	1472	dynbuf_text &buf = msg_dynbuf; buf.clear ();
1782		1473
1783	num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1474	int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1784
1785	if (num_ident < 1)
1786	num_ident = 1;
1787		1475
1788	for (tmp = op->inv; tmp; tmp = tmp->below)	1476	for (tmp = op->inv; tmp; tmp = tmp->below)
1789	{	1477	{
1790	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))	1478	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1791	{	1479	{
1792	identify (tmp);	1480	identify (tmp);
1793		1481
1794	if (op->type == PLAYER)	1482	if (op->type == PLAYER)
1795	{	1483	{
1796	new_draw_info_format (NDI_UNIQUE, 0, op, "You have %s.", long_desc (tmp, op));	1484	buf.printf ("You identified: %s.\r", long_desc (tmp, op));
1797		1485
1798	if (tmp->msg)	1486	if (tmp->msg)
1799	{	1487	buf << "The item has a story:\r" << tmp->msg << "\n\n";
1800	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1801	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1802	}
1803	}	1488	}
1804		1489
1805	num_ident--;
1806	success = 1;
1807	if (!num_ident)	1490	if (!--num_ident)
1808	break;	1491	break;
1809	}	1492	}
1810	}	1493	}
1811		1494
1812	/* If all the power of the spell has been used up, don't go and identify	1495	/* If all the power of the spell has been used up, don't go and identify
1813	* stuff on the floor. Only identify stuff on the floor if the spell	1496	* stuff on the floor. Only identify stuff on the floor if the spell
1814	* was not fully used.	1497	* was not fully used.
1815	*/	1498	*/
1816	if (num_ident)	1499	if (num_ident)
1817	{	1500	{
1818	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	1501	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1819	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))	1502	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1820	{	1503	{
1821	identify (tmp);	1504	identify (tmp);
1822		1505
1823	if (op->type == PLAYER)	1506	if (object *pl = tmp->visible_to ())
1824	{	1507	{
1825	new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op));	1508	buf.printf ("On the ground you identified: %s.\r", long_desc (tmp, op));
1826		1509
1827	if (tmp->msg)	1510	if (tmp->msg)
1828	{	1511	buf << "The item has a story:\r" << tmp->msg << "\n\n";
1829	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1830	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1831	}
1832
1833	esrv_send_item (op, tmp);
1834	}	1512	}
1835		1513
1836	num_ident--;
1837	success = 1;
1838	if (!num_ident)	1514	if (!--num_ident)
1839	break;	1515	break;
1840	}	1516	}
1841	}	1517	}
1842		1518
1843	if (!success)	1519	if (buf.empty ())
1844	new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified.");	1520	{
		1521	op->failmsg ("You can't reach anything unidentified.");
		1522	return 0;
		1523	}
1845	else	1524	else
		1525	{
		1526	if (op->contr)
		1527	op->contr->infobox (MSG_CHANNEL ("identify"), buf);
		1528
1846	spell_effect (spell, op->x, op->y, op->map, op);	1529	spell_effect (spell, op->x, op->y, op->map, op);
1847		1530	return 1;
1848	return success;	1531	}
1849	}	1532	}
1850		1533
1851	int	1534	int
1852	cast_detection (object *op, object *caster, object *spell, object *skill)	1535	cast_detection (object *op, object *caster, object *spell, object *skill)
1853	{	1536	{
…		…
1858		1541
1859	/* We precompute some values here so that we don't have to keep	1542	/* We precompute some values here so that we don't have to keep
1860	* doing it over and over again.	1543	* doing it over and over again.
1861	*/	1544	*/
1862	god = find_god (determine_god (op));	1545	god = find_god (determine_god (op));
1863	level = caster_level (caster, spell);	1546	level = casting_level (caster, spell);
1864	range = spell->range + SP_level_range_adjust (caster, spell);	1547	range = spell->range + SP_level_range_adjust (caster, spell);
1865		1548
1866	if (!skill)	1549	if (!skill)
1867	skill = caster;	1550	skill = caster;
1868		1551
1869	for (x = op->x - range; x <= op->x + range; x++)	1552	unordered_mapwalk (op, -range, -range, range, range)
1870	for (y = op->y - range; y <= op->y + range; y++)
1871	{	1553	{
1872	m = op->map;
1873	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1874	if (mflags & P_OUT_OF_MAP)
1875	continue;
1876
1877	/* For most of the detections, we only detect objects above the	1554	/* For most of the detections, we only detect objects above the
1878	* floor. But this is not true for show invisible.	1555	* floor. But this is not true for show invisible.
1879	* Basically, we just go and find the top object and work	1556	* Basically, we just go and find the top object and work
1880	* down - that is easier than working up.	1557	* down - that is easier than working up.
1881	*/	1558	*/
1882		1559
1883	for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above)	1560	for (last = NULL, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1884	last = tmp;	1561	last = tmp;
1885		1562
1886	/* Shouldn't happen, but if there are no objects on a space, this	1563	/* Shouldn't happen, but if there are no objects on a space, this
1887	* would happen.	1564	* would happen.
1888	*/	1565	*/
1889	if (!last)	1566	if (!last)
1890	continue;	1567	continue;
1891		1568
1892	done_one = 0;	1569	done_one = 0;
1893	floor = 0;	1570	floor = 0;
1894	detect = NULL;	1571	detect = NULL;
1895	for (tmp = last; tmp; tmp = tmp->below)	1572	for (tmp = last; tmp; tmp = tmp->below)
1896	{	1573	{
1897	/* show invisible */	1574	/* show invisible */
1898	if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&	1575	if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&
1899	/* Might there be other objects that we can make visible? */	1576	/* Might there be other objects that we can make visible? */
1900	(tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) ||	1577	(tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER)
1901	(tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) ||	1578	|| (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ))
1902	tmp->type == CF_HANDLE ||	1579	|| tmp->type == T_HANDLE
1903	tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE ||	1580	|| tmp->type == TRAPDOOR
		1581	|| tmp->type == EXIT
		1582	|| tmp->type == HOLE
		1583	|| tmp->type == BUTTON
1904	tmp->type == BUTTON || tmp->type == TELEPORTER ||	1584	|| tmp->type == TELEPORTER
		1585	|| tmp->type == GATE
1905	tmp->type == GATE || tmp->type == LOCKED_DOOR ||	1586	|| tmp->type == LOCKED_DOOR
1906	tmp->type == WEAPON || tmp->type == ALTAR || tmp->type == SIGN ||	1587	|| tmp->type == WEAPON
		1588	|| tmp->type == ALTAR
		1589	|| tmp->type == SIGN
1907	tmp->type == TRIGGER_PEDESTAL || tmp->type == SPECIAL_KEY ||	1590	|| tmp->type == TRIGGER_PEDESTAL
1908	tmp->type == TREASURE || tmp->type == BOOK || tmp->type == HOLY_ALTAR)))	1591	|| tmp->type == SPECIAL_KEY
		1592	|| tmp->type == TREASURE
		1593	|| tmp->type == BOOK
		1594	|| tmp->type == HOLY_ALTAR
		1595	|| tmp->type == CONTAINER)))
1909	{	1596	{
1910	if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)	1597	if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1911	{	1598	{
1912	tmp->invisible = 0;	1599	tmp->invisible = 0;
1913	done_one = 1;	1600	done_one = 1;
1914	}	1601	}
1915	}	1602	}
1916		1603
1917	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1604	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1918	floor = 1;	1605	floor = 1;
1919		1606
1920	/* All detections below this point don't descend beneath the floor,	1607	/* All detections below this point don't descend beneath the floor,
1921	* so just continue on. We could be clever and look at the type of	1608	* so just continue on. We could be clever and look at the type of
1922	* detection to completely break out if we don't care about objects beneath	1609	* detection to completely break out if we don't care about objects beneath
1923	* the floor, but once we get to the floor, not likely a very big issue anyways.	1610	* the floor, but once we get to the floor, not likely a very big issue anyways.
1924	*/	1611	*/
1925	if (floor)	1612	if (floor)
1926	continue;	1613	continue;
1927		1614
1928	/* I had thought about making detect magic and detect curse	1615	/* I had thought about making detect magic and detect curse
1929	* show the flash the magic item like it does for detect monster.	1616	* show the flash the magic item like it does for detect monster.
1930	* however, if the object is within sight, this would then make it	1617	* however, if the object is within sight, this would then make it
1931	* difficult to see what object is magical/cursed, so the	1618	* difficult to see what object is magical/cursed, so the
1932	* effect wouldn't be as apparant.	1619	* effect wouldn't be as apparent.
1933	*/	1620	*/
1934		1621
1935	/* detect magic */	1622	/* detect magic */
1936	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&	1623	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&
1937	!QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))	1624	!QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))
1938	{	1625	{
1939	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1626	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1940	/* make runes more visibile */	1627	/* make runes more visibile */
1941	if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)	1628	if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1942	tmp->stats.Cha /= 4;	1629	tmp->stats.Cha /= 4;
		1630
1943	done_one = 1;	1631	done_one = 1;
1944	}	1632	}
		1633
1945	/* detect monster */	1634	/* detect monster */
1946	if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))	1635	if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))
1947	{	1636	{
1948	done_one = 2;	1637	done_one = 2;
		1638
1949	if (!detect)	1639	if (!detect)
1950	detect = tmp;	1640	detect = tmp;
1951	}	1641	}
		1642
1952	/* Basically, if race is set in the spell, then the creatures race must	1643	/* Basically, if race is set in the spell, then the creatures race must
1953	* match that. if the spell race is set to GOD, then the gods opposing	1644	* match that. if the spell race is set to GOD, then the gods opposing
1954	* race must match.	1645	* race must match.
1955	*/	1646	*/
1956	if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&	1647	if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&
1957	((!strcmp (spell->race, "GOD") && god && god->slaying && strstr (god->slaying, tmp->race)) ||	1648	((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||
1958	(strstr (spell->race, tmp->race))))	1649	spell->race.contains (tmp->race)))
1959	{	1650	{
1960	done_one = 2;	1651	done_one = 2;
		1652
1961	if (!detect)	1653	if (!detect)
1962	detect = tmp;	1654	detect = tmp;
1963	}	1655	}
		1656
1964	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1657	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1965	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))	1658	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1966	{	1659	{
1967	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1660	SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1968	done_one = 1;	1661	done_one = 1;
1969	}	1662	}
1970	} /* for stack of objects on this space */	1663	} /* for stack of objects on this space */
1971		1664
1972	/* Code here puts an effect of the spell on the space, so you can see	1665	/* Code here puts an effect of the spell on the space, so you can see
1973	* where the magic is.	1666	* where the magic is.
1974	*/	1667	*/
1975	if (done_one)	1668	if (done_one)
1976	{	1669	{
1977	object *detect_ob = arch_to_object (spell->other_arch);	1670	object *detect_ob = arch_to_object (spell->other_arch);
1978		1671
1979	/* if this is set, we want to copy the face */	1672	/* if this is set, we want to copy the face */
1980	if (done_one == 2 && detect)	1673	if (done_one == 2 && detect)
1981	{	1674	{
1982	detect_ob->face = detect->face;	1675	detect_ob->face = detect->face;
1983	detect_ob->animation_id = detect->animation_id;	1676	detect_ob->animation_id = detect->animation_id;
1984	detect_ob->anim_speed = detect->anim_speed;	1677	detect_ob->anim_speed = detect->anim_speed;
1985	detect_ob->last_anim = 0;	1678	detect_ob->last_anim = 0;
1986	/* by default, the detect_ob is already animated */	1679	/* by default, the detect_ob is already animated */
1987	if (!QUERY_FLAG (detect, FLAG_ANIMATE))	1680	if (!QUERY_FLAG (detect, FLAG_ANIMATE))
1988	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);	1681	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
1989	}	1682	}
1990		1683
1991	m->insert (detect_ob, nx, ny, op);	1684	m->insert (detect_ob, nx, ny, op);
1992	}	1685	}
1993	} /* for processing the surrounding spaces */	1686	} /* for processing the surrounding spaces */
1994		1687
1995		1688
1996	/* Now process objects in the players inventory if detect curse or magic */	1689	/* Now process objects in the players inventory if detect curse or magic */
1997	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))	1690	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))
1998	{	1691	{
1999	done_one = 0;	1692	done_one = 0;
		1693
2000	for (tmp = op->inv; tmp; tmp = tmp->below)	1694	for (tmp = op->inv; tmp; tmp = tmp->below)
2001	{	1695	{
2002	if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1696	if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))
2003	{	1697	{
2004	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))	1698	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))
2005	{	1699	{
2006	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1700	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
2007	if (op->type == PLAYER)	1701
		1702	if (object *pl = tmp->visible_to ())
2008	esrv_send_item (op, tmp);	1703	esrv_update_item (UPD_FLAGS, pl, tmp);
2009	}	1704	}
		1705
2010	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1706	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
2011	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))	1707	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
2012	{	1708	{
2013	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1709	SET_FLAG (tmp, FLAG_KNOWN_CURSED);
2014	if (op->type == PLAYER)	1710
		1711	if (object *pl = tmp->visible_to ())
2015	esrv_send_item (op, tmp);	1712	esrv_update_item (UPD_FLAGS, pl, tmp);
2016	}	1713	}
2017	} /* if item is not identified */	1714	} /* if item is not identified */
2018	} /* for the players inventory */	1715	} /* for the players inventory */
2019	} /* if detect magic/curse and object is a player */	1716	} /* if detect magic/curse and object is a player */
		1717
2020	return 1;	1718	return 1;
2021	}	1719	}
2022		1720
2023		1721
2024	/**	1722	/**
…		…
2037		1735
2038	new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");	1736	new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");
2039		1737
2040	if (victim->stats.sp >= victim->stats.maxsp * 2)	1738	if (victim->stats.sp >= victim->stats.maxsp * 2)
2041	{	1739	{
2042	object *tmp;
2043
2044	new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");	1740	new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");
2045
2046	/* Explodes a fireball centered at player */
2047	tmp = get_archetype (EXPLODING_FIREBALL);
2048	tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
2049	tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
2050
2051	tmp->insert_at (victim);
2052	victim->stats.sp = 2 * victim->stats.maxsp;	1741	victim->stats.sp = 2 * victim->stats.maxsp;
		1742	create_exploding_ball_at (victim, caster_level);
2053	}	1743	}
2054	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)	1744	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
2055	new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode.");	1745	new_draw_info (NDI_UNIQUE | NDI_ORANGE, 0, victim, "You feel like your head is going to explode.");
2056	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)	1746	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
2057	new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");	1747	new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
2058	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)	1748	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
2059	{	1749	{
2060	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");	1750	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
…		…
2106	}	1796	}
2107	/* give sp */	1797	/* give sp */
2108	if (spell->stats.dam > 0)	1798	if (spell->stats.dam > 0)
2109	{	1799	{
2110	plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);	1800	plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);
2111	charge_mana_effect (plyr, caster_level (caster, spell));	1801	charge_mana_effect (plyr, casting_level (caster, spell));
2112	return 1;	1802	return 1;
2113	}	1803	}
2114	/* suck sp away. Can't suck sp from yourself */	1804	/* suck sp away. Can't suck sp from yourself */
2115	else if (op != plyr)	1805	else if (op != plyr)
2116	{	1806	{
…		…
2128	/* Player doesn't get full credit */	1818	/* Player doesn't get full credit */
2129	sucked = (sucked * rate) / 100;	1819	sucked = (sucked * rate) / 100;
2130	op->stats.sp += sucked;	1820	op->stats.sp += sucked;
2131	if (sucked > 0)	1821	if (sucked > 0)
2132	{	1822	{
2133	charge_mana_effect (op, caster_level (caster, spell));	1823	charge_mana_effect (op, casting_level (caster, spell));
2134	}	1824	}
2135	}	1825	}
2136	return 1;	1826	return 1;
2137	}	1827	}
2138	return 0;	1828	return 0;
…		…
2180	/* Basically, if the object is magical and not counterspell,	1870	/* Basically, if the object is magical and not counterspell,
2181	* we will more or less remove the object. Don't counterspell	1871	* we will more or less remove the object. Don't counterspell
2182	* monsters either.	1872	* monsters either.
2183	*/	1873	*/
2184		1874
2185	if (head->attacktype & AT_MAGIC &&	1875	if (head->attacktype & AT_MAGIC
2186	!(head->attacktype & AT_COUNTERSPELL) && !QUERY_FLAG (head, FLAG_MONSTER) && (op->level > head->level))	1876	&& !(head->attacktype & AT_COUNTERSPELL)
		1877	&& !QUERY_FLAG (head, FLAG_MONSTER)
		1878	&& (op->level > head->level))
2187	head->destroy ();	1879	head->destroy ();
2188	else	1880	else
2189	switch (head->type)	1881	switch (head->type)
2190	{	1882	{
2191	case SPELL_EFFECT:	1883	case SPELL_EFFECT:
		1884	// XXX: Don't affect floor spelleffects. See also XXX comment
		1885	// about sanctuary in spell_util.C
		1886	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
		1887	continue;
		1888
2192	if (op->level > head->level)	1889	if (op->level > head->level)
2193	head->destroy ();	1890	head->destroy ();
2194		1891
2195	break;	1892	break;
2196		1893
…		…
2207	break;	1904	break;
2208	}	1905	}
2209	}	1906	}
2210	}	1907	}
2211		1908
2212
2213
2214	/* cast_consecrate() - a spell to make an altar your god's */	1909	/* cast_consecrate() - a spell to make an altar your god's */
2215	int	1910	int
2216	cast_consecrate (object *op, object *caster, object *spell)	1911	cast_consecrate (object *op, object *caster, object *spell)
2217	{	1912	{
2218	char buf[MAX_BUF];	1913	char buf[MAX_BUF];
…		…
2230	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1925	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2231	break;	1926	break;
2232	if (tmp->type == HOLY_ALTAR)	1927	if (tmp->type == HOLY_ALTAR)
2233	{	1928	{
2234		1929
2235	if (tmp->level > caster_level (caster, spell))	1930	if (tmp->level > casting_level (caster, spell))
2236	{	1931	{
2237	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);	1932	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);
2238	return 0;	1933	return 0;
2239	}	1934	}
2240	else	1935	else
2241	{	1936	{
2242	/* If we got here, we are consecrating an altar */	1937	/* If we got here, we are consecrating an altar */
2243	sprintf (buf, "Altar of %s", &god->name);	1938	sprintf (buf, "Altar of %s", &god->name);
2244	tmp->name = buf;	1939	tmp->name = buf;
2245	tmp->level = caster_level (caster, spell);	1940	tmp->level = casting_level (caster, spell);
2246	tmp->other_arch = god->arch;	1941	tmp->other_arch = god->arch;
		1942
2247	if (op->type == PLAYER)	1943	if (op->type == PLAYER)
2248	esrv_update_item (UPD_NAME, op, tmp);	1944	esrv_update_item (UPD_NAME, op, tmp);
		1945
2249	new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);	1946	new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
2250	return 1;	1947	return 1;
2251	}	1948	}
2252	}	1949	}
2253	}	1950	}
…		…
2263	* This code was very odd - code early on would only let players use the spell,	1960	* This code was very odd - code early on would only let players use the spell,
2264	* yet the code wass full of player checks. I've presumed that the code	1961	* yet the code wass full of player checks. I've presumed that the code
2265	* that only let players use it was correct, and removed all the other	1962	* that only let players use it was correct, and removed all the other
2266	* player checks. MSW 2003-01-06	1963	* player checks. MSW 2003-01-06
2267	*/	1964	*/
2268
2269	int	1965	int
2270	animate_weapon (object *op, object *caster, object *spell, int dir)	1966	animate_weapon (object *op, object *caster, object *spell, int dir)
2271	{	1967	{
2272	object *weapon, *tmp;	1968	object *weapon, *tmp;
2273	char buf[MAX_BUF];	1969	char buf[MAX_BUF];
2274	int a, i;	1970	int a, i;
2275	sint16 x, y;	1971	sint16 x, y;
2276	maptile *m;	1972	maptile *m;
2277	materialtype_t *mt;
2278		1973
2279	if (!spell->other_arch)	1974	if (!spell->other_arch)
2280	{	1975	{
2281	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	1976	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
2282	LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);	1977	LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);
…		…
2285	/* exit if it's not a player using this spell. */	1980	/* exit if it's not a player using this spell. */
2286	if (op->type != PLAYER)	1981	if (op->type != PLAYER)
2287	return 0;	1982	return 0;
2288		1983
2289	/* if player already has a golem, abort */	1984	/* if player already has a golem, abort */
2290	if (op->contr->ranges[range_golem])	1985	if (object *golem = op->contr->golem)
2291	{	1986	{
2292	control_golem (op->contr->ranges[range_golem], dir);	1987	control_golem (golem, dir);
2293	return 0;	1988	return 0;
2294	}	1989	}
2295		1990
2296	/* if no direction specified, pick one */	1991	/* if no direction specified, pick one */
2297	if (!dir)	1992	if (!dir)
2298	dir = find_free_spot (NULL, op->map, op->x, op->y, 1, 9);	1993	dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);
2299		1994
2300	m = op->map;	1995	m = op->map;
2301	x = op->x + freearr_x[dir];	1996	x = op->x + freearr_x[dir];
2302	y = op->y + freearr_y[dir];	1997	y = op->y + freearr_y[dir];
2303		1998
2304	/* if there's no place to put the golem, abort */	1999	/* if there's no place to put the golem, abort */
2305	if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) ||	2000	if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
2306	((spell->other_arch->clone.move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->clone.move_type))	2001	|| ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2307	{	2002	{
2308	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	2003	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
2309	return 0;	2004	return 0;
2310	}	2005	}
2311		2006
…		…
2315	if (!weapon)	2010	if (!weapon)
2316	{	2011	{
2317	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");	2012	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
2318	return 0;	2013	return 0;
2319	}	2014	}
		2015
2320	if (spell->race && strcmp (weapon->arch->name, spell->race))	2016	if (spell->race && weapon->arch->archname != spell->race)
2321	{	2017	{
2322	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");	2018	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
2323	return 0;	2019	return 0;
2324	}	2020	}
		2021
2325	if (weapon->type != WEAPON)	2022	if (weapon->type != WEAPON)
2326	{	2023	{
2327	new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");	2024	new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");
2328	return 0;	2025	return 0;
2329	}	2026	}
		2027
2330	if (QUERY_FLAG (weapon, FLAG_APPLIED))	2028	if (QUERY_FLAG (weapon, FLAG_APPLIED))
2331	{	2029	{
2332	new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));	2030	new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));
2333	return 0;	2031	return 0;
2334	}	2032	}
2335		2033
2336	if (weapon->nrof > 1)	2034	weapon = weapon->split ();
2337	{
2338	tmp = get_split_ob (weapon, 1);
2339	esrv_send_item (op, weapon);
2340	weapon = tmp;
2341	}
2342		2035
2343	/* create the golem object */	2036	/* create the golem object */
2344	tmp = arch_to_object (spell->other_arch);	2037	tmp = arch_to_object (spell->other_arch);
2345		2038
2346	/* if animated by a player, give the player control of the golem */	2039	/* if animated by a player, give the player control of the golem */
2347	CLEAR_FLAG (tmp, FLAG_MONSTER);	2040	CLEAR_FLAG (tmp, FLAG_MONSTER);
2348	SET_FLAG (tmp, FLAG_FRIENDLY);
2349	tmp->stats.exp = 0;	2041	tmp->stats.exp = 0;
2350	add_friendly_object (tmp);	2042	add_friendly_object (tmp);
2351	tmp->type = GOLEM;	2043	tmp->type = GOLEM;
2352	tmp->set_owner (op);	2044	tmp->set_owner (op);
		2045	op->contr->golem = tmp;
2353	set_spell_skill (op, caster, spell, tmp);	2046	set_spell_skill (op, caster, spell, tmp);
2354	op->contr->ranges[range_golem] = tmp;
2355	op->contr->shoottype = range_golem;
2356		2047
2357	/* Give the weapon to the golem now. A bit of a hack to check the	2048	/* Give the weapon to the golem now. A bit of a hack to check the
2358	* removed flag - it should only be set if get_split_object was	2049	* removed flag - it should only be set if weapon->split was
2359	* used above.	2050	* used above.
2360	*/	2051	*/
2361	if (!QUERY_FLAG (weapon, FLAG_REMOVED))	2052	if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2362	weapon->remove ();	2053	weapon->remove ();
2363	insert_ob_in_ob (weapon, tmp);	2054
2364	esrv_send_item (op, weapon);	2055	tmp->insert (weapon);
		2056
2365	/* To do everything necessary to let a golem use the weapon is a pain,	2057	/* To do everything necessary to let a golem use the weapon is a pain,
2366	* so instead, just set it as equipped (otherwise, we need to update	2058	* so instead, just set it as equipped (otherwise, we need to update
2367	* body_info, skills, etc)	2059	* body_info, skills, etc)
2368	*/	2060	*/
2369	SET_FLAG (tmp, FLAG_USE_WEAPON);	2061	SET_FLAG (tmp, FLAG_USE_WEAPON);
…		…
2395		2087
2396	/* attacktype */	2088	/* attacktype */
2397	if (!tmp->attacktype)	2089	if (!tmp->attacktype)
2398	tmp->attacktype = AT_PHYSICAL;	2090	tmp->attacktype = AT_PHYSICAL;
2399		2091
2400	mt = NULL;
2401	if (op->materialname != NULL)
2402	mt = name_to_material (op->materialname);	2092	if (materialtype_t *mt = name_to_material (op->materialname))
2403	if (mt != NULL)
2404	{	2093	{
2405	for (i = 0; i < NROFATTACKS; i++)	2094	for (i = 0; i < NROFATTACKS; i++)
2406	tmp->resist[i] = 50 - (mt->save[i] * 5);	2095	tmp->resist[i] = 50 - (mt->save[i] * 5);
2407	a = mt->save[0];	2096	a = mt->save[0];
2408	}	2097	}
…		…
2410	{	2099	{
2411	for (i = 0; i < NROFATTACKS; i++)	2100	for (i = 0; i < NROFATTACKS; i++)
2412	tmp->resist[i] = 5;	2101	tmp->resist[i] = 5;
2413	a = 10;	2102	a = 10;
2414	}	2103	}
		2104
2415	/* Set weapon's immunity */	2105	/* Set weapon's immunity */
2416	tmp->resist[ATNR_CONFUSION] = 100;	2106	tmp->resist[ATNR_CONFUSION] = 100;
2417	tmp->resist[ATNR_POISON] = 100;	2107	tmp->resist[ATNR_POISON] = 100;
2418	tmp->resist[ATNR_SLOW] = 100;	2108	tmp->resist[ATNR_SLOW] = 100;
2419	tmp->resist[ATNR_PARALYZE] = 100;	2109	tmp->resist[ATNR_PARALYZE] = 100;
…		…
2425		2115
2426	/* Improve weapon's armour value according to best save vs. physical of its material */	2116	/* Improve weapon's armour value according to best save vs. physical of its material */
2427		2117
2428	if (a > 14)	2118	if (a > 14)
2429	a = 14;	2119	a = 14;
		2120
2430	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));	2121	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2431		2122
2432	/* Determine golem's speed */	2123	/* Determine golem's speed */
2433	tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));	2124	tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2434		2125
…		…
2444	tmp->state = weapon->state;	2135	tmp->state = weapon->state;
2445	tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];	2136	tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2446	}	2137	}
2447		2138
2448	/* make experience increase in proportion to the strength of the summoned creature. */	2139	/* make experience increase in proportion to the strength of the summoned creature. */
2449	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));	2140	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));
2450		2141
2451	tmp->speed_left = -1;	2142	tmp->speed_left = -1;
2452	tmp->direction = dir;	2143	tmp->direction = dir;
2453		2144
2454	m->insert (tmp, x, y, op);	2145	m->insert (tmp, x, y, op);
…		…
2458	/* cast_daylight() - changes the map darkness level *lower* */	2149	/* cast_daylight() - changes the map darkness level *lower* */
2459		2150
2460	/* cast_change_map_lightlevel: Was cast_daylight/nightfall.	2151	/* cast_change_map_lightlevel: Was cast_daylight/nightfall.
2461	* This changes the light level for the entire map.	2152	* This changes the light level for the entire map.
2462	*/	2153	*/
2463
2464	int	2154	int
2465	cast_change_map_lightlevel (object *op, object *caster, object *spell)	2155	cast_change_map_lightlevel (object *op, object *caster, object *spell)
2466	{	2156	{
2467	int success;	2157	int success;
2468		2158
…		…
2476	if (spell->stats.dam < 0)	2166	if (spell->stats.dam < 0)
2477	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");	2167	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2478	else	2168	else
2479	new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");	2169	new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2480	}	2170	}
		2171
2481	return success;	2172	return success;
2482	}	2173	}
2483
2484
2485
2486
2487		2174
2488	/* create an aura spell object and put it in the player's inventory.	2175	/* create an aura spell object and put it in the player's inventory.
2489	* as usual, op is player, caster is the object casting the spell,	2176	* as usual, op is player, caster is the object casting the spell,
2490	* spell is the spell object itself.	2177	* spell is the spell object itself.
2491	*/	2178	*/
…		…
2503		2190
2504	new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);	2191	new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2505		2192
2506	new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	2193	new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2507		2194
2508	new_aura->set_owner (op);
2509	set_spell_skill (op, caster, spell, new_aura);	2195	set_spell_skill (op, caster, spell, new_aura);
2510	new_aura->attacktype = spell->attacktype;	2196	new_aura->attacktype = spell->attacktype;
2511		2197
2512	new_aura->level = caster_level (caster, spell);	2198	new_aura->level = casting_level (caster, spell);
		2199
2513	if (refresh)	2200	if (refresh)
2514	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	2201	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2515	else	2202	else
2516	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");	2203	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
		2204
2517	insert_ob_in_ob (new_aura, op);	2205	insert_ob_in_ob (new_aura, op);
		2206	new_aura->set_owner (op);
		2207
2518	return 1;	2208	return 1;
2519	}	2209	}
2520
2521		2210
2522	/* move aura function. An aura is a part of someone's inventory,	2211	/* move aura function. An aura is a part of someone's inventory,
2523	* which he carries with him, but which acts on the map immediately	2212	* which he carries with him, but which acts on the map immediately
2524	* around him.	2213	* around him.
2525	* Aura parameters:	2214	* Aura parameters:
2526	* duration: duration counter.	2215	* duration: duration counter.
2527	* attacktype: aura's attacktype	2216	* attacktype: aura's attacktype
2528	* other_arch: archetype to drop where we attack	2217	* other_arch: archetype to drop where we attack
2529	*/	2218	*/
2530
2531	void	2219	void
2532	move_aura (object *aura)	2220	move_aura (object *aura)
2533	{	2221	{
2534	int i, mflags;
2535	object *env;
2536	maptile *m;
2537
2538	/* auras belong in inventories */	2222	/* auras belong in inventories */
2539	env = aura->env;	2223	object *env = aura->env;
		2224	object *owner = aura->owner;
2540		2225
2541	/* no matter what we've gotta remove the aura...	2226	/* no matter what we've gotta remove the aura...
2542	* we'll put it back if its time isn't up.	2227	* we'll put it back if its time isn't up.
2543	*/	2228	*/
2544	aura->remove ();	2229	aura->remove ();
…		…
2549	aura->destroy ();	2234	aura->destroy ();
2550	return;	2235	return;
2551	}	2236	}
2552		2237
2553	/* auras only exist in inventories */	2238	/* auras only exist in inventories */
2554	if (env == NULL || env->map == NULL)	2239	if (!env || !env->map)
2555	{	2240	{
2556	aura->destroy ();	2241	aura->destroy ();
2557	return;	2242	return;
2558	}	2243	}
2559		2244
2560	/* we need to jump out of the inventory for a bit	2245	/* we need to jump out of the inventory for a bit
2561	* in order to hit the map conveniently.	2246	* in order to hit the map conveniently.
2562	*/	2247	*/
2563	aura->insert_at (env, aura);	2248	aura->insert_at (env, aura);
2564		2249
2565	for (i = 1; i < 9; i++)	2250	for (int i = 1; i < 9; i++)
2566	{	2251	{
2567	sint16 nx, ny;	2252	mapxy pos (env);
		2253	pos.move (i);
2568		2254
2569	nx = aura->x + freearr_x[i];
2570	ny = aura->y + freearr_y[i];
2571	mflags = get_map_flags (env->map, &m, nx, ny, &nx, &ny);
2572
2573	/* Consider the movement tyep of the person with the aura as	2255	/* Consider the movement type of the person with the aura as
2574	* movement type of the aura. Eg, if the player is flying, the aura	2256	* movement type of the aura. Eg, if the player is flying, the aura
2575	* is flying also, if player is walking, it is on the ground, etc.	2257	* is flying also, if player is walking, it is on the ground, etc.
2576	*/	2258	*/
2577	if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))	2259	if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2578	{	2260	{
2579	hit_map (aura, i, aura->attacktype, 0);	2261	hit_map (aura, i, aura->attacktype, 0);
2580		2262
2581	if (aura->other_arch)	2263	if (aura->other_arch)
2582	m->insert (arch_to_object (aura->other_arch), nx, ny, aura);	2264	pos.insert (arch_to_object (aura->other_arch), aura);
2583	}	2265	}
2584	}	2266	}
2585		2267
2586	/* put the aura back in the player's inventory */	2268	/* put the aura back in the player's inventory */
2587	aura->remove ();	2269	env->insert (aura);
2588	insert_ob_in_ob (aura, env);	2270	aura->set_owner (owner);
2589	}	2271	}
2590		2272
2591	/* moves the peacemaker spell.	2273	/* moves the peacemaker spell.
2592	* op is the piece object.	2274	* op is the piece object.
2593	*/	2275	*/
2594
2595	void	2276	void
2596	move_peacemaker (object *op)	2277	move_peacemaker (object *op)
2597	{	2278	{
2598	object *tmp;	2279	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
2599
2600	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2601	{	2280	{
2602	int atk_lev, def_lev;	2281	int atk_lev, def_lev;
2603	object *victim = tmp;	2282	object *victim = tmp->head_ ();
2604		2283
2605	if (tmp->head)
2606	victim = tmp->head;
2607	if (!QUERY_FLAG (victim, FLAG_MONSTER))	2284	if (!QUERY_FLAG (victim, FLAG_MONSTER))
2608	continue;	2285	continue;
		2286
2609	if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))	2287	if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))
2610	continue;	2288	continue;
		2289
2611	if (victim->stats.exp == 0)	2290	if (victim->stats.exp == 0)
2612	continue;	2291	continue;
2613		2292
2614	def_lev = MAX (1, victim->level);	2293	def_lev = MAX (1, victim->level);
2615	atk_lev = MAX (1, op->level);	2294	atk_lev = MAX (1, op->level);
2616		2295
2617	if (rndm (0, atk_lev - 1) > def_lev)	2296	if (rndm (0, atk_lev - 1) > def_lev)
2618	{	2297	{
2619	/* make this sucker peaceful. */	2298	/* make this sucker peaceful. */
2620		2299
		2300	INVOKE_OBJECT (KILL, victim, ARG_OBJECT (op));
2621	change_exp (op->owner, victim->stats.exp, op->skill, 0);	2301	change_exp (op->owner, victim->stats.exp, op->skill, 0);
2622	victim->stats.exp = 0;	2302	victim->stats.exp = 0;
2623	#if 0	2303	#if 0
2624	/* No idea why these were all set to zero - if something	2304	/* No idea why these were all set to zero - if something
2625	* makes this creature agressive, he should still do damage.	2305	* makes this creature agressive, he should still do damage.
…		…
2632	victim->attack_movement = RANDO2;	2312	victim->attack_movement = RANDO2;
2633	SET_FLAG (victim, FLAG_UNAGGRESSIVE);	2313	SET_FLAG (victim, FLAG_UNAGGRESSIVE);
2634	SET_FLAG (victim, FLAG_RUN_AWAY);	2314	SET_FLAG (victim, FLAG_RUN_AWAY);
2635	SET_FLAG (victim, FLAG_RANDOM_MOVE);	2315	SET_FLAG (victim, FLAG_RANDOM_MOVE);
2636	CLEAR_FLAG (victim, FLAG_MONSTER);	2316	CLEAR_FLAG (victim, FLAG_MONSTER);
		2317
2637	if (victim->name)	2318	if (victim->name)
2638	{
2639	new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);	2319	new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2640	}	2320	}
2641	}
2642	}	2321	}
2643	}	2322	}
2644
2645		2323
2646	/* This writes a rune that contains the appropriate message.	2324	/* This writes a rune that contains the appropriate message.
2647	* There really isn't any adjustments we make.	2325	* There really isn't any adjustments we make.
2648	*/	2326	*/
2649
2650	int	2327	int
2651	write_mark (object *op, object *spell, const char *msg)	2328	write_mark (object *op, object *spell, const char *msg)
2652	{	2329	{
2653	char rune[HUGE_BUF];
2654	object *tmp;
2655
2656	if (!msg || msg[0] == 0)	2330	if (!msg || msg[0] == 0)
2657	{	2331	{
2658	new_draw_info (NDI_UNIQUE, 0, op, "Write what?");	2332	new_draw_info (NDI_UNIQUE, 0, op, "Write what?");
2659	return 0;	2333	return 0;
2660	}	2334	}
2661		2335
2662	if (strcasestr_local (msg, "endmsg"))	2336	if (!msg_is_safe (msg))
2663	{	2337	{
2664	new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");	2338	new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");
2665	LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg);	2339	LOG (llevInfo, "write_mark: player %s tried to write bogus rune %s\n", &op->name, msg);
2666	return 0;	2340	return 0;
2667	}	2341	}
		2342
2668	if (!spell->other_arch)	2343	if (!spell->other_arch)
2669	return 0;	2344	return 0;
		2345
2670	tmp = arch_to_object (spell->other_arch);	2346	object *tmp = arch_to_object (spell->other_arch);
2671
2672	snprintf (rune, sizeof (rune), "%s\n", msg);
2673		2347
2674	tmp->race = op->name; /*Save the owner of the rune */	2348	tmp->race = op->name; /*Save the owner of the rune */
2675	tmp->msg = rune;	2349	tmp->msg = msg;
2676		2350
2677	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);	2351	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
		2352
2678	return 1;	2353	return 1;
2679	}	2354	}
		2355

Diff Legend

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