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

Diff Legend

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