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.52 by root, Thu May 17 14:14:55 2007 UTC vs.
Revision 1.107 by elmex, Thu Sep 17 16:53:15 2009 UTC

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

Diff Legend

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