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

Diff Legend

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