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.21 by root, Tue Dec 19 05:41:22 2006 UTC vs.
Revision 1.112 by root, Wed Nov 4 18:17:58 2009 UTC

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

Diff Legend

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