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.38 by root, Wed Feb 7 23:30:03 2007 UTC vs.
Revision 1.115 by root, Sun Nov 29 09:41:28 2009 UTC

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

Diff Legend

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