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

Diff Legend

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