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.53 by root, Tue May 22 10:50:01 2007 UTC vs.
Revision 1.99 by elmex, Tue Jan 13 13:29:57 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 *stringarg)
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 (stringarg)
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 (*stringarg))
…		…
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, stringarg);
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 (stringarg) < missile_plus)
186	missile_plus = atoi (stringarg);	182	missile_plus = atoi (stringarg);
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)
…		…
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 (stringarg)
225	{	218	{
226	at = find_archetype_by_object_type_name (FOOD, stringarg);	219	at = find_archetype_by_object_type_name (FOOD, stringarg);
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, stringarg);
229	if (at == NULL || at->clone.stats.food > food_value)	222	if (at == NULL || at->stats.food > food_value)
230	stringarg = NULL;	223	stringarg = NULL;
231	}	224	}
232		225
233	if (!stringarg)	226	if (!stringarg)
234	{	227	{
…		…
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	{
…		…
462	if (object *pl = op->in_player ())	466	if (object *pl = op->in_player ())
463	{	467	{
464	if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))	468	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.");	469	new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
466	else	470	else
467	{	471	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	}	472	}
473		473
474	op->destroy ();	474	op->destroy ();
475	}	475	}
476		476
…		…
492	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");	492	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
493	return 1;	493	return 1;
494	}	494	}
495		495
496	dummy = get_archetype (FORCE_NAME);	496	dummy = get_archetype (FORCE_NAME);
497	if (dummy == NULL)	497
		498	if (!dummy)
498	{	499	{
499	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	500	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
500	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");	501	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
501	return 0;	502	return 0;
502	}	503	}
…		…
565	}	566	}
566		567
567	int	568	int
568	perceive_self (object *op)	569	perceive_self (object *op)
569	{	570	{
570	char buf[MAX_BUF];
571	const char *cp = describe_item (op, op);	571	const char *cp = describe_item (op, op);
572	archetype *at = archetype::find (ARCH_DEPLETION);	572	archetype *at = archetype::find (ARCH_DEPLETION);
573	object *tmp;
574	int i;
575		573
		574	dynbuf_text buf;
		575
		576	if (player *pl = op->contr)
		577	if (object *race = archetype::find (op->race))
		578	buf << " - You are a G<male|female> " << &race->name << ".\n";
		579
576	tmp = find_god (determine_god (op));	580	if (object *god = find_god (determine_god (op)))
577	if (tmp)	581	buf << " - You worship " << &god->name << ".\n";
578	new_draw_info_format (NDI_UNIQUE, 0, op, "You worship %s", &tmp->name);
579	else	582	else
580	new_draw_info (NDI_UNIQUE, 0, op, "You worship no god");	583	buf << " - You worship no god.\n";
581		584
582	tmp = present_arch_in_ob (at, op);	585	object *tmp = present_arch_in_ob (at, op);
583		586
584	if (*cp == '\0' && tmp == NULL)	587	if (*cp == '\0' && !tmp)
585	new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane");	588	buf << " - You feel very mundane. ";
586	else	589	else
587	{	590	{
588	new_draw_info (NDI_UNIQUE, 0, op, "You have:");	591	buf << " - You have: " << cp << ".\n";
589	new_draw_info (NDI_UNIQUE, 0, op, cp);
590		592
591	if (tmp)	593	if (tmp)
592	for (i = 0; i < NUM_STATS; i++)	594	for (int i = 0; i < NUM_STATS; i++)
593	if (tmp->stats.stat (i) < 0)	595	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));	596	buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
595	}	597	}
596		598
597	if (is_dragon_pl (op))	599	if (is_dragon_pl (op))
598	{
599	/* now grab the 'dragon_ability'-force from the player's inventory */	600	/* now grab the 'dragon_ability'-force from the player's inventory */
600	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	601	for (tmp = op->inv; tmp; tmp = tmp->below)
601	{	602	{
602	if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force"))	603	if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
603	{	604	{
604	if (tmp->stats.exp == 0)	605	if (tmp->stats.exp == 0)
605	sprintf (buf, "Your metabolism isn't focused on anything.");	606	buf << " - Your metabolism isn't focused on anything.\n";
606	else	607	else
607	sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]);	608	buf << " - Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
608		609
609	new_draw_info (NDI_UNIQUE, 0, op, buf);
610	break;	610	break;
611	}	611	}
612	}	612	}
613	}	613
		614	buf << '\0'; // zero-terminate
		615
		616	new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ());
614		617
615	return 1;	618	return 1;
616	}	619	}
617		620
618	/* This creates magic walls. Really, it can create most any object,	621	/* This creates magic walls. Really, it can create most any object,
…		…
706	*/	709	*/
707	if (tmp->type != EARTHWALL) //TODO	710	if (tmp->type != EARTHWALL) //TODO
708	tmp->set_owner (op);	711	tmp->set_owner (op);
709		712
710	set_spell_skill (op, caster, spell_ob, tmp);	713	set_spell_skill (op, caster, spell_ob, tmp);
711	tmp->level = caster_level (caster, spell_ob) / 2;	714	tmp->level = casting_level (caster, spell_ob) / 2;
712		715
713	name = tmp->name;	716	name = tmp->name;
714	if (!(tmp = m->insert (tmp, x, y, op)))	717	if (!(tmp = m->insert (tmp, x, y, op)))
715	{	718	{
716	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);	719	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
717	return 0;	720	return 0;
718	}	721	}
719		722
720	/* If this is a spellcasting wall, need to insert the spell object */	723	/* If this is a spellcasting wall, need to insert the spell object */
721	if (tmp->other_arch && tmp->other_arch->clone.type == SPELL)	724	if (tmp->other_arch && tmp->other_arch->type == SPELL)
722	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);	725	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
723		726
724	/* This code causes the wall to extend some distance in	727	/* This code causes the wall to extend some distance in
725	* each direction, or until an obstruction is encountered.	728	* each direction, or until an obstruction is encountered.
726	* posblocked and negblocked help determine how far the	729	* posblocked and negblocked help determine how far the
…		…
746	{	749	{
747	object *tmp2 = tmp->clone ();	750	object *tmp2 = tmp->clone ();
748	m->insert (tmp2, x, y, op);	751	m->insert (tmp2, x, y, op);
749		752
750	/* If this is a spellcasting wall, need to insert the spell object */	753	/* If this is a spellcasting wall, need to insert the spell object */
751	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	754	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
752	tmp2->insert (arch_to_object (tmp2->other_arch));	755	tmp2->insert (arch_to_object (tmp2->other_arch));
753		756
754	}	757	}
755	else	758	else
756	posblocked = 1;	759	posblocked = 1;
…		…
763	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)	766	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
764	{	767	{
765	object *tmp2 = tmp->clone ();	768	object *tmp2 = tmp->clone ();
766	m->insert (tmp2, x, y, op);	769	m->insert (tmp2, x, y, op);
767		770
768	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	771	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
769	tmp2->insert (arch_to_object (tmp2->other_arch));	772	tmp2->insert (arch_to_object (tmp2->other_arch));
770	}	773	}
771	else	774	else
772	negblocked = 1;	775	negblocked = 1;
773	}	776	}
…		…
889		892
890	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */	893	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
891	return 1;	894	return 1;
892	}	895	}
893		896
894
895	/* cast_heal: Heals something.	897	/* cast_heal: Heals something.
896	* op is the caster.	898	* op is the caster.
897	* dir is the direction he is casting it in.	899	* dir is the direction he is casting it in.
898	* spell is the spell object.	900	* spell is the spell object.
899	*/	901	*/
…		…
925	{	927	{
926	/* See how many points we actually heal. Instead of messages	928	/* See how many points we actually heal. Instead of messages
927	* based on type of spell, we instead do messages based	929	* based on type of spell, we instead do messages based
928	* on amount of damage healed.	930	* on amount of damage healed.
929	*/	931	*/
930	if (heal > (tmp->stats.maxhp - tmp->stats.hp))	932	if (heal > tmp->stats.maxhp - tmp->stats.hp)
931	heal = tmp->stats.maxhp - tmp->stats.hp;	933	heal = tmp->stats.maxhp - tmp->stats.hp;
		934
932	tmp->stats.hp += heal;	935	tmp->stats.hp += heal;
933		936
934	if (tmp->stats.hp >= tmp->stats.maxhp)	937	if (tmp->stats.hp >= tmp->stats.maxhp)
935	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");	938	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
936	else if (heal > 50)	939	else if (heal > 50)
…		…
945	success = 1;	948	success = 1;
946	}	949	}
947	}	950	}
948		951
949	if (spell->attacktype & AT_DISEASE)	952	if (spell->attacktype & AT_DISEASE)
950	if (cure_disease (tmp, op))	953	if (cure_disease (tmp, op, spell))
951	success = 1;	954	success = 1;
952		955
953	if (spell->attacktype & AT_POISON)	956	if (spell->attacktype & AT_POISON)
954	{	957	{
955	at = archetype::find ("poisoning");	958	at = archetype::find ("poisoning");
…		…
1004	}	1007	}
1005		1008
1006	if (spell->stats.food && tmp->stats.food < 999)	1009	if (spell->stats.food && tmp->stats.food < 999)
1007	{	1010	{
1008	tmp->stats.food += spell->stats.food;	1011	tmp->stats.food += spell->stats.food;
		1012
1009	if (tmp->stats.food > 999)	1013	if (tmp->stats.food > 999)
1010	tmp->stats.food = 999;	1014	tmp->stats.food = 999;
		1015
1011	success = 1;	1016	success = 1;
1012	/* We could do something a bit better like the messages for healing above */	1017	/* We could do something a bit better like the messages for healing above */
1013	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");	1018	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1014	}	1019	}
1015		1020
1016	return success;	1021	return success;
1017	}	1022	}
1018
1019		1023
1020	/* This is used for the spells that gain stats. There are no spells	1024	/* This is used for the spells that gain stats. There are no spells
1021	* right now that icnrease wis/int/pow on a temp basis, so no	1025	* right now that icnrease wis/int/pow on a temp basis, so no
1022	* good comments for those.	1026	* good comments for those.
1023	*/	1027	*/
1024	static const char *const no_gain_msgs[NUM_STATS] = {	1028	static const char *const no_gain_msgs[NUM_STATS] = {
1025	"You grow no stronger.",	1029	"You grow no stronger.",
1026	"You grow no more agile.",	1030	"You grow no more agile.",
1027	"You don't feel any healthier.",	1031	"You don't feel any healthier.",
1028	"no wis",	1032	"You didn't grow any more intelligent.",
		1033	"You do not feel any wiser.",
		1034	"You don't feel any more powerful."
1029	"You are no easier to look at.",	1035	"You are no easier to look at.",
1030	"no int",
1031	"no pow"
1032	};	1036	};
1033		1037
1034	int	1038	int
1035	cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)	1039	cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1036	{	1040	{
1037	object *force = NULL;	1041	object *force = 0;
1038	int i;	1042	int i;
1039		1043
1040	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */	1044	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1041	object *tmp = dir	1045	object *tmp = dir
1042	? find_target_for_friendly_spell (op, dir)	1046	? find_target_for_friendly_spell (op, dir)
1043	: op;	1047	: op;
1044		1048
1045	if (!tmp)	1049	if (!tmp)
1046	return 0;	1050	return 0;
1047		1051
1048	/* If we've already got a force of this type, don't add a new one. */	1052	/* If we've already got a force of this type, don't add a new one. */
…		…
1057	}	1061	}
1058	else if (spell_ob->race && spell_ob->race == tmp2->name)	1062	else if (spell_ob->race && spell_ob->race == tmp2->name)
1059	{	1063	{
1060	if (!silent)	1064	if (!silent)
1061	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);	1065	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
		1066
1062	return 0;	1067	return 0;
1063	}	1068	}
1064	}	1069	}
1065	}	1070	}
1066	if (force == NULL)	1071
		1072	if (!force)
1067	{	1073	{
1068	force = get_archetype (FORCE_NAME);	1074	force = get_archetype (FORCE_NAME);
1069	force->subtype = FORCE_CHANGE_ABILITY;	1075	force->subtype = FORCE_CHANGE_ABILITY;
		1076
1070	if (spell_ob->race)	1077	if (spell_ob->race)
1071	force->name = spell_ob->race;	1078	force->name = spell_ob->race;
1072	else	1079	else
1073	force->name = spell_ob->name;	1080	force->name = spell_ob->name;
		1081
1074	force->name_pl = spell_ob->name;	1082	force->name_pl = spell_ob->name;
1075	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");	1083	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
1076		1084
1077	}	1085	}
1078	else	1086	else
…		…
1084	{	1092	{
1085	force->duration = duration;	1093	force->duration = duration;
1086	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	1094	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1087	}	1095	}
1088	else	1096	else
1089	{
1090	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1097	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1091	}	1098
1092	return 1;	1099	return 1;
1093	}	1100	}
		1101
1094	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1102	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1095	force->speed = 1.0;	1103	force->speed = 1.0;
1096	force->speed_left = -1.0;	1104	force->speed_left = -1.0;
1097	SET_FLAG (force, FLAG_APPLIED);	1105	SET_FLAG (force, FLAG_APPLIED);
1098		1106
…		…
1104	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);	1112	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);
1105	if (force->resist[i] > 100)	1113	if (force->resist[i] > 100)
1106	force->resist[i] = 100;	1114	force->resist[i] = 100;
1107	}	1115	}
1108	}	1116	}
		1117
1109	if (spell_ob->stats.hp)	1118	if (spell_ob->stats.hp)
1110	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);	1119	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
1111		1120
1112	if (tmp->type == PLAYER)	1121	if (tmp->type == PLAYER)
1113	{	1122	{
…		…
1153	force->attacktype = spell_ob->attacktype;	1162	force->attacktype = spell_ob->attacktype;
1154		1163
1155	insert_ob_in_ob (force, tmp);	1164	insert_ob_in_ob (force, tmp);
1156	change_abil (tmp, force); /* Mostly to display any messages */	1165	change_abil (tmp, force); /* Mostly to display any messages */
1157	tmp->update_stats ();	1166	tmp->update_stats ();
		1167
1158	return 1;	1168	return 1;
1159	}	1169	}
1160		1170
1161	/* This used to be part of cast_change_ability, but it really didn't make	1171	/* This used to be part of cast_change_ability, but it really didn't make
1162	* a lot of sense, since most of the values it derives are from the god	1172	* a lot of sense, since most of the values it derives are from the god
1163	* of the caster.	1173	* of the caster.
1164	*/	1174	*/
1165
1166	int	1175	int
1167	cast_bless (object *op, object *caster, object *spell_ob, int dir)	1176	cast_bless (object *op, object *caster, object *spell_ob, int dir)
1168	{	1177	{
1169	int i;	1178	int i;
1170	object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;	1179	object *god = find_god (determine_god (op)), *force = NULL, *tmp;
1171		1180
1172	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */	1181	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1173	if (dir != 0)	1182	if (dir != 0)
1174	{	1183	{
1175	tmp = find_target_for_friendly_spell (op, dir);	1184	tmp = find_target_for_friendly_spell (op, dir);
		1185
		1186	if (!tmp)
		1187	return 0;
1176	}	1188	}
1177	else	1189	else
1178	{
1179	tmp = op;	1190	tmp = op;
1180	}
1181		1191
1182	/* If we've already got a force of this type, don't add a new one. */	1192	/* If we've already got a force of this type, don't add a new one. */
1183	for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below)	1193	for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1184	{	1194	{
1185	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)	1195	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1186	{	1196	{
1187	if (tmp2->name == spell_ob->name)	1197	if (tmp2->name == spell_ob->name)
1188	{	1198	{
…		…
1194	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);	1204	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
1195	return 0;	1205	return 0;
1196	}	1206	}
1197	}	1207	}
1198	}	1208	}
		1209
1199	if (force == NULL)	1210	if (force == NULL)
1200	{	1211	{
1201	force = get_archetype (FORCE_NAME);	1212	force = get_archetype (FORCE_NAME);
1202	force->subtype = FORCE_CHANGE_ABILITY;	1213	force->subtype = FORCE_CHANGE_ABILITY;
1203	if (spell_ob->race)	1214	if (spell_ob->race)
…		…
1268	}	1279	}
1269		1280
1270	/* Alchemy code by Mark Wedel	1281	/* Alchemy code by Mark Wedel
1271	*	1282	*
1272	* This code adds a new spell, called alchemy. Alchemy will turn	1283	* This code adds a new spell, called alchemy. Alchemy will turn
1273	* objects to gold nuggets, the value of the gold nuggets being	1284	* objects to pyrite ("false gold"), henceforth called gold nuggets.
1274	* about 90% of that of the item itself. It uses the value of the
1275	* object before charisma adjustments, because the nuggets themselves
1276	* will be will be adjusted by charisma when sold.
1277	*	1285	*
1278	* Large nuggets are worth 25 gp each (base). You will always get	1286	* The value of the gold nuggets being about 90% of that of the item
1279	* the maximum number of large nuggets you could get.	1287	* itself. It uses the value of the object before charisma adjustments,
1280	* Small nuggets are worth 1 gp each (base). You will get from 0	1288	* because the nuggets themselves will be will be adjusted by charisma
1281	* to the max amount of small nuggets as you could get.	1289	* when sold.
1282	*
1283	* For example, if an item is worth 110 gold, you will get
1284	* 4 large nuggets, and from 0-10 small nuggets.
1285	*	1290	*
1286	* There is also a chance (1:30) that you will get nothing at all	1291	* There is also a chance (1:30) that you will get nothing at all
1287	* for the object. There is also a maximum weight that will be	1292	* for the object. There is also a maximum weight that will be
1288	* alchemised.	1293	* alchemised.
1289	*/	1294	*/
1290	static void	1295	static void
1291	alchemy_object (object *obj, uint64 &total_value, int &total_weight)	1296	alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1292	{	1297	{
1293	uint64 value = query_cost (obj, NULL, F_TRUE);	1298	uint64 value = query_cost (obj, NULL, F_TRUE);
1294		1299
1295	/* Give third price when we alchemy money (This should hopefully	1300	/* Give third price when we alchemy money (this should hopefully
1296	* make it so that it isn't worth it to alchemy money, sell	1301	* make it so that it isn't worth it to alchemy money, sell
1297	* the nuggets, alchemy the gold from that, etc.	1302	* the nuggets, alchemy the gold from that, etc.
1298	* Otherwise, give 9 silver on the gold for other objects,	1303	* Otherwise, give 9 silver on the gold for other objects,
1299	* so that it would still be more affordable to haul	1304	* so that it would still be more affordable to haul
1300	* the stuff back to town.	1305	* the stuff back to town.
…		…
1312	total_weight += obj->total_weight ();	1317	total_weight += obj->total_weight ();
1313		1318
1314	obj->destroy ();	1319	obj->destroy ();
1315	}	1320	}
1316		1321
1317	static void
1318	update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1319	{
1320	int flag = 0;
1321
1322	/* Put any nuggets below the player, but we can only pass this
1323	* flag if we are on the same space as the player
1324	*/
1325	if (x == op->x && y == op->y && op->map == m)
1326	flag = INS_BELOW_ORIGINATOR;
1327
1328	if (small_nuggets)
1329	{
1330	object *tmp = small->clone ();
1331	tmp->nrof = small_nuggets;
1332	m->insert (tmp, x, y, op, flag);
1333	}
1334
1335	if (large_nuggets)
1336	{
1337	object *tmp = large->clone ();
1338	tmp->nrof = large_nuggets;
1339	m->insert (tmp, x, y, op, flag);
1340	}
1341
1342	if (object *pl = m->at (x, y).player ())
1343	if (pl->contr->ns)
1344	pl->contr->ns->look_position = 0;
1345	}
1346
1347	int	1322	int
1348	alchemy (object *op, object *caster, object *spell_ob)	1323	alchemy (object *op, object *caster, object *spell_ob)
1349	{	1324	{
1350	if (op->type != PLAYER)	1325	if (op->type != PLAYER)
1351	return 0;	1326	return 0;
1352		1327
1353	object *large = get_archetype ("largenugget");	1328	archetype *nugget[3];
1354	object *small = get_archetype ("smallnugget");	1329
		1330	nugget[0] = archetype::find ("pyrite3");
		1331	nugget[1] = archetype::find ("pyrite2");
		1332	nugget[2] = archetype::find ("pyrite");
1355		1333
1356	/* Put a maximum weight of items that can be alchemised. Limits the power	1334	/* Put a maximum weight of items that can be alchemised. Limits the power
1357	* some, and also prevents people from alchemising every table/chair/clock	1335	* some, and also prevents people from alchemising every table/chair/clock
1358	* in sight	1336	* in sight
1359	*/	1337	*/
…		…
1411	if (weight > weight_max)	1389	if (weight > weight_max)
1412	break;	1390	break;
1413	}	1391	}
1414	}	1392	}
1415		1393
		1394	value -= rndm (value >> 4);
1416	value = min (value, value_max);	1395	value = min (value, value_max);
1417		1396
1418	uint64 count = value / large->value;	1397	for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1419	int large_nuggets = count;	1398	if (int nrof = value / nugget [i]->value)
1420	value -= count * large->value;
1421
1422	count = value / small->value;
1423	int small_nuggets = count;
1424
1425	/* Insert all the nuggets at one time. This probably saves time, but
1426	* it also prevents us from alcheming nuggets that were just created
1427	* with this spell.
1428	*/	1399	{
1429	update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny);	1400	value -= nrof * nugget[i]->value;
		1401
		1402	object *tmp = arch_to_object (nugget[i]);
		1403	tmp->nrof = nrof;
		1404	tmp->flag [FLAG_IDENTIFIED] = true;
		1405	op->map->insert (tmp, x, y, op, 0);
		1406	}
1430		1407
1431	if (weight > weight_max)	1408	if (weight > weight_max)
1432	goto bailout;	1409	goto bailout;
1433	}	1410	}
1434	}	1411	}
1435		1412
1436	bailout:	1413	bailout:
1437	large->destroy ();
1438	small->destroy ();
1439	return 1;	1414	return 1;
1440	}	1415	}
1441
1442		1416
1443	/* This function removes the cursed/damned status on equipped	1417	/* This function removes the cursed/damned status on equipped
1444	* items.	1418	* items.
1445	*/	1419	*/
1446	int	1420	int
…		…
1453	if (QUERY_FLAG (tmp, FLAG_APPLIED) &&	1427	if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
1454	((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||	1428	((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1455	(QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))	1429	(QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1456	{	1430	{
1457	was_one++;	1431	was_one++;
		1432
1458	if (tmp->level <= caster_level (caster, spell))	1433	if (tmp->level <= casting_level (caster, spell))
1459	{	1434	{
1460	success++;	1435	success++;
1461	if (QUERY_FLAG (spell, FLAG_DAMNED))	1436	if (QUERY_FLAG (spell, FLAG_DAMNED))
1462	CLEAR_FLAG (tmp, FLAG_DAMNED);	1437	CLEAR_FLAG (tmp, FLAG_DAMNED);
1463		1438
1464	CLEAR_FLAG (tmp, FLAG_CURSED);	1439	CLEAR_FLAG (tmp, FLAG_CURSED);
1465	CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);	1440	CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);
1466	tmp->value = 0; /* Still can't sell it */	1441	tmp->value = 0; /* Still can't sell it */
1467	if (op->type == PLAYER)	1442
		1443	if (object *pl = tmp->visible_to ())
1468	esrv_send_item (op, tmp);	1444	esrv_update_item (UPD_FLAGS, pl, tmp);
1469	}	1445	}
1470	}	1446	}
1471		1447
1472	if (op->type == PLAYER)	1448	if (op->type == PLAYER)
1473	{	1449	{
…		…
1484		1460
1485	return success;	1461	return success;
1486	}	1462	}
1487		1463
1488	/* Identifies objects in the players inventory/on the ground */	1464	/* Identifies objects in the players inventory/on the ground */
1489
1490	int	1465	int
1491	cast_identify (object *op, object *caster, object *spell)	1466	cast_identify (object *op, object *caster, object *spell)
1492	{	1467	{
		1468	dynbuf_text buf;
1493	object *tmp;	1469	object *tmp;
1494	int success = 0, num_ident;
1495		1470
1496	num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1471	int num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1497		1472
1498	if (num_ident < 1)	1473	if (num_ident < 1)
1499	num_ident = 1;	1474	num_ident = 1;
1500		1475
1501	for (tmp = op->inv; tmp; tmp = tmp->below)	1476	for (tmp = op->inv; tmp; tmp = tmp->below)
…		…
1504	{	1479	{
1505	identify (tmp);	1480	identify (tmp);
1506		1481
1507	if (op->type == PLAYER)	1482	if (op->type == PLAYER)
1508	{	1483	{
1509	new_draw_info_format (NDI_UNIQUE, 0, op, "You identified: %s.", long_desc (tmp, op));	1484	buf.printf ("You identified: %s.\r", long_desc (tmp, op));
1510		1485
1511	if (tmp->msg)	1486	if (tmp->msg)
1512	{	1487	buf << "The item has a story:\r" << tmp->msg << "\n\n";
1513	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1514	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1515	}
1516	}	1488	}
1517		1489
1518	num_ident--;	1490	num_ident--;
1519	success = 1;
1520	if (!num_ident)	1491	if (!num_ident)
1521	break;	1492	break;
1522	}	1493	}
1523	}	1494	}
1524		1495
…		…
1531	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)	1502	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1532	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))	1503	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1533	{	1504	{
1534	identify (tmp);	1505	identify (tmp);
1535		1506
1536	if (op->type == PLAYER)	1507	if (object *pl = tmp->visible_to ())
1537	{	1508	{
1538	new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground you identified: %s.", long_desc (tmp, op));	1509	buf.printf ("On the ground you identified: %s.\r", long_desc (tmp, op));
1539		1510
1540	if (tmp->msg)	1511	if (tmp->msg)
1541	{	1512	buf << "The item has a story:\r" << tmp->msg << "\n\n";
1542	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1543	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1544	}
1545
1546	esrv_send_item (op, tmp);
1547	}	1513	}
1548		1514
1549	num_ident--;	1515	num_ident--;
1550	success = 1;
1551	if (!num_ident)	1516	if (!num_ident)
1552	break;	1517	break;
1553	}	1518	}
1554	}	1519	}
1555		1520
1556	if (!success)	1521	if (buf.empty ())
1557	new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified.");	1522	{
		1523	op->failmsg ("You can't reach anything unidentified.");
		1524	return 0;
		1525	}
1558	else	1526	else
		1527	{
		1528	if (op->contr)
		1529	op->contr->infobox (MSG_CHANNEL ("identify"), buf);
		1530
1559	spell_effect (spell, op->x, op->y, op->map, op);	1531	spell_effect (spell, op->x, op->y, op->map, op);
1560		1532	return 1;
1561	return success;	1533	}
1562	}	1534	}
1563		1535
1564	int	1536	int
1565	cast_detection (object *op, object *caster, object *spell, object *skill)	1537	cast_detection (object *op, object *caster, object *spell, object *skill)
1566	{	1538	{
…		…
1571		1543
1572	/* We precompute some values here so that we don't have to keep	1544	/* We precompute some values here so that we don't have to keep
1573	* doing it over and over again.	1545	* doing it over and over again.
1574	*/	1546	*/
1575	god = find_god (determine_god (op));	1547	god = find_god (determine_god (op));
1576	level = caster_level (caster, spell);	1548	level = casting_level (caster, spell);
1577	range = spell->range + SP_level_range_adjust (caster, spell);	1549	range = spell->range + SP_level_range_adjust (caster, spell);
1578		1550
1579	if (!skill)	1551	if (!skill)
1580	skill = caster;	1552	skill = caster;
1581		1553
1582	for (x = op->x - range; x <= op->x + range; x++)	1554	unordered_mapwalk (op, -range, -range, range, range)
1583	for (y = op->y - range; y <= op->y + range; y++)
1584	{	1555	{
1585	m = op->map;
1586	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1587	if (mflags & P_OUT_OF_MAP)
1588	continue;
1589
1590	/* For most of the detections, we only detect objects above the	1556	/* For most of the detections, we only detect objects above the
1591	* floor. But this is not true for show invisible.	1557	* floor. But this is not true for show invisible.
1592	* Basically, we just go and find the top object and work	1558	* Basically, we just go and find the top object and work
1593	* down - that is easier than working up.	1559	* down - that is easier than working up.
1594	*/	1560	*/
1595		1561
1596	for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above)	1562	for (last = NULL, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1597	last = tmp;	1563	last = tmp;
1598		1564
1599	/* Shouldn't happen, but if there are no objects on a space, this	1565	/* Shouldn't happen, but if there are no objects on a space, this
1600	* would happen.	1566	* would happen.
1601	*/	1567	*/
1602	if (!last)	1568	if (!last)
1603	continue;	1569	continue;
1604		1570
1605	done_one = 0;	1571	done_one = 0;
1606	floor = 0;	1572	floor = 0;
1607	detect = NULL;	1573	detect = NULL;
1608	for (tmp = last; tmp; tmp = tmp->below)	1574	for (tmp = last; tmp; tmp = tmp->below)
1609	{	1575	{
1610	/* show invisible */	1576	/* show invisible */
1611	if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&	1577	if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&
1612	/* Might there be other objects that we can make visible? */	1578	/* Might there be other objects that we can make visible? */
1613	(tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) ||	1579	(tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) ||
1614	(tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) ||	1580	(tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ))
1615	tmp->type == CF_HANDLE ||	1581	|| tmp->type == CF_HANDLE
1616	tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE ||	1582	|| tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE
1617	tmp->type == BUTTON || tmp->type == TELEPORTER ||	1583	|| tmp->type == BUTTON || tmp->type == TELEPORTER
1618	tmp->type == GATE || tmp->type == LOCKED_DOOR ||	1584	|| tmp->type == GATE || tmp->type == LOCKED_DOOR
1619	tmp->type == WEAPON || tmp->type == ALTAR || tmp->type == SIGN ||	1585	|| tmp->type == WEAPON || tmp->type == ALTAR || tmp->type == SIGN
1620	tmp->type == TRIGGER_PEDESTAL || tmp->type == SPECIAL_KEY ||	1586	|| tmp->type == TRIGGER_PEDESTAL || tmp->type == SPECIAL_KEY
1621	tmp->type == TREASURE || tmp->type == BOOK || tmp->type == HOLY_ALTAR)))	1587	|| tmp->type == TREASURE || tmp->type == BOOK || tmp->type == HOLY_ALTAR)))
1622	{	1588	{
1623	if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)	1589	if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1624	{	1590	{
1625	tmp->invisible = 0;	1591	tmp->invisible = 0;
1626	done_one = 1;	1592	done_one = 1;
1627	}	1593	}
1628	}	1594	}
1629		1595
1630	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1596	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1631	floor = 1;	1597	floor = 1;
1632		1598
1633	/* All detections below this point don't descend beneath the floor,	1599	/* All detections below this point don't descend beneath the floor,
1634	* so just continue on. We could be clever and look at the type of	1600	* so just continue on. We could be clever and look at the type of
1635	* detection to completely break out if we don't care about objects beneath	1601	* detection to completely break out if we don't care about objects beneath
1636	* the floor, but once we get to the floor, not likely a very big issue anyways.	1602	* the floor, but once we get to the floor, not likely a very big issue anyways.
1637	*/	1603	*/
1638	if (floor)	1604	if (floor)
1639	continue;	1605	continue;
1640		1606
1641	/* I had thought about making detect magic and detect curse	1607	/* I had thought about making detect magic and detect curse
1642	* show the flash the magic item like it does for detect monster.	1608	* show the flash the magic item like it does for detect monster.
1643	* however, if the object is within sight, this would then make it	1609	* however, if the object is within sight, this would then make it
1644	* difficult to see what object is magical/cursed, so the	1610	* difficult to see what object is magical/cursed, so the
1645	* effect wouldn't be as apparant.	1611	* effect wouldn't be as apparent.
1646	*/	1612	*/
1647		1613
1648	/* detect magic */	1614	/* detect magic */
1649	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&	1615	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&
1650	!QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))	1616	!QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))
1651	{	1617	{
1652	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1618	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1653	/* make runes more visibile */	1619	/* make runes more visibile */
1654	if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)	1620	if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1655	tmp->stats.Cha /= 4;	1621	tmp->stats.Cha /= 4;
		1622
1656	done_one = 1;	1623	done_one = 1;
1657	}	1624	}
		1625
1658	/* detect monster */	1626	/* detect monster */
1659	if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))	1627	if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))
1660	{	1628	{
1661	done_one = 2;	1629	done_one = 2;
		1630
1662	if (!detect)	1631	if (!detect)
1663	detect = tmp;	1632	detect = tmp;
1664	}	1633	}
		1634
1665	/* Basically, if race is set in the spell, then the creatures race must	1635	/* Basically, if race is set in the spell, then the creatures race must
1666	* match that. if the spell race is set to GOD, then the gods opposing	1636	* match that. if the spell race is set to GOD, then the gods opposing
1667	* race must match.	1637	* race must match.
1668	*/	1638	*/
1669	if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&	1639	if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&
1670	((!strcmp (spell->race, "GOD") && god && god->slaying && strstr (god->slaying, tmp->race)) ||	1640	((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||
1671	(strstr (spell->race, tmp->race))))	1641	spell->race.contains (tmp->race)))
1672	{	1642	{
1673	done_one = 2;	1643	done_one = 2;
		1644
1674	if (!detect)	1645	if (!detect)
1675	detect = tmp;	1646	detect = tmp;
1676	}	1647	}
		1648
1677	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1649	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1678	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))	1650	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1679	{	1651	{
1680	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1652	SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1681	done_one = 1;	1653	done_one = 1;
1682	}	1654	}
1683	} /* for stack of objects on this space */	1655	} /* for stack of objects on this space */
1684		1656
1685	/* Code here puts an effect of the spell on the space, so you can see	1657	/* Code here puts an effect of the spell on the space, so you can see
1686	* where the magic is.	1658	* where the magic is.
1687	*/	1659	*/
1688	if (done_one)	1660	if (done_one)
1689	{	1661	{
1690	object *detect_ob = arch_to_object (spell->other_arch);	1662	object *detect_ob = arch_to_object (spell->other_arch);
1691		1663
1692	/* if this is set, we want to copy the face */	1664	/* if this is set, we want to copy the face */
1693	if (done_one == 2 && detect)	1665	if (done_one == 2 && detect)
1694	{	1666	{
1695	detect_ob->face = detect->face;	1667	detect_ob->face = detect->face;
1696	detect_ob->animation_id = detect->animation_id;	1668	detect_ob->animation_id = detect->animation_id;
1697	detect_ob->anim_speed = detect->anim_speed;	1669	detect_ob->anim_speed = detect->anim_speed;
1698	detect_ob->last_anim = 0;	1670	detect_ob->last_anim = 0;
1699	/* by default, the detect_ob is already animated */	1671	/* by default, the detect_ob is already animated */
1700	if (!QUERY_FLAG (detect, FLAG_ANIMATE))	1672	if (!QUERY_FLAG (detect, FLAG_ANIMATE))
1701	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);	1673	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
1702	}	1674	}
1703		1675
1704	m->insert (detect_ob, nx, ny, op);	1676	m->insert (detect_ob, nx, ny, op);
1705	}	1677	}
1706	} /* for processing the surrounding spaces */	1678	} /* for processing the surrounding spaces */
1707		1679
1708		1680
1709	/* Now process objects in the players inventory if detect curse or magic */	1681	/* Now process objects in the players inventory if detect curse or magic */
1710	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))	1682	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))
1711	{	1683	{
1712	done_one = 0;	1684	done_one = 0;
		1685
1713	for (tmp = op->inv; tmp; tmp = tmp->below)	1686	for (tmp = op->inv; tmp; tmp = tmp->below)
1714	{	1687	{
1715	if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1688	if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1716	{	1689	{
1717	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))	1690	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))
1718	{	1691	{
1719	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1692	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1720	if (op->type == PLAYER)	1693
		1694	if (object *pl = tmp->visible_to ())
1721	esrv_send_item (op, tmp);	1695	esrv_update_item (UPD_FLAGS, pl, tmp);
1722	}	1696	}
		1697
1723	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1698	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1724	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))	1699	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1725	{	1700	{
1726	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1701	SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1727	if (op->type == PLAYER)	1702
		1703	if (object *pl = tmp->visible_to ())
1728	esrv_send_item (op, tmp);	1704	esrv_update_item (UPD_FLAGS, pl, tmp);
1729	}	1705	}
1730	} /* if item is not identified */	1706	} /* if item is not identified */
1731	} /* for the players inventory */	1707	} /* for the players inventory */
1732	} /* if detect magic/curse and object is a player */	1708	} /* if detect magic/curse and object is a player */
		1709
1733	return 1;	1710	return 1;
1734	}	1711	}
1735		1712
1736		1713
1737	/**	1714	/**
…		…
1750		1727
1751	new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");	1728	new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");
1752		1729
1753	if (victim->stats.sp >= victim->stats.maxsp * 2)	1730	if (victim->stats.sp >= victim->stats.maxsp * 2)
1754	{	1731	{
1755	object *tmp;
1756
1757	new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");	1732	new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");
1758
1759	/* Explodes a fireball centered at player */
1760	tmp = get_archetype (EXPLODING_FIREBALL);
1761	tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
1762	tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
1763
1764	tmp->insert_at (victim);
1765	victim->stats.sp = 2 * victim->stats.maxsp;	1733	victim->stats.sp = 2 * victim->stats.maxsp;
		1734	create_exploding_ball_at (victim, caster_level);
1766	}	1735	}
1767	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)	1736	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
1768	new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode.");	1737	new_draw_info (NDI_UNIQUE | NDI_ORANGE, 0, victim, "You feel like your head is going to explode.");
1769	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)	1738	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
1770	new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");	1739	new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
1771	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)	1740	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
1772	{	1741	{
1773	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");	1742	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
…		…
1819	}	1788	}
1820	/* give sp */	1789	/* give sp */
1821	if (spell->stats.dam > 0)	1790	if (spell->stats.dam > 0)
1822	{	1791	{
1823	plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);	1792	plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);
1824	charge_mana_effect (plyr, caster_level (caster, spell));	1793	charge_mana_effect (plyr, casting_level (caster, spell));
1825	return 1;	1794	return 1;
1826	}	1795	}
1827	/* suck sp away. Can't suck sp from yourself */	1796	/* suck sp away. Can't suck sp from yourself */
1828	else if (op != plyr)	1797	else if (op != plyr)
1829	{	1798	{
…		…
1841	/* Player doesn't get full credit */	1810	/* Player doesn't get full credit */
1842	sucked = (sucked * rate) / 100;	1811	sucked = (sucked * rate) / 100;
1843	op->stats.sp += sucked;	1812	op->stats.sp += sucked;
1844	if (sucked > 0)	1813	if (sucked > 0)
1845	{	1814	{
1846	charge_mana_effect (op, caster_level (caster, spell));	1815	charge_mana_effect (op, casting_level (caster, spell));
1847	}	1816	}
1848	}	1817	}
1849	return 1;	1818	return 1;
1850	}	1819	}
1851	return 0;	1820	return 0;
…		…
1927	break;	1896	break;
1928	}	1897	}
1929	}	1898	}
1930	}	1899	}
1931		1900
1932
1933
1934	/* cast_consecrate() - a spell to make an altar your god's */	1901	/* cast_consecrate() - a spell to make an altar your god's */
1935	int	1902	int
1936	cast_consecrate (object *op, object *caster, object *spell)	1903	cast_consecrate (object *op, object *caster, object *spell)
1937	{	1904	{
1938	char buf[MAX_BUF];	1905	char buf[MAX_BUF];
…		…
1950	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1917	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1951	break;	1918	break;
1952	if (tmp->type == HOLY_ALTAR)	1919	if (tmp->type == HOLY_ALTAR)
1953	{	1920	{
1954		1921
1955	if (tmp->level > caster_level (caster, spell))	1922	if (tmp->level > casting_level (caster, spell))
1956	{	1923	{
1957	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);	1924	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);
1958	return 0;	1925	return 0;
1959	}	1926	}
1960	else	1927	else
1961	{	1928	{
1962	/* If we got here, we are consecrating an altar */	1929	/* If we got here, we are consecrating an altar */
1963	sprintf (buf, "Altar of %s", &god->name);	1930	sprintf (buf, "Altar of %s", &god->name);
1964	tmp->name = buf;	1931	tmp->name = buf;
1965	tmp->level = caster_level (caster, spell);	1932	tmp->level = casting_level (caster, spell);
1966	tmp->other_arch = god->arch;	1933	tmp->other_arch = god->arch;
		1934
1967	if (op->type == PLAYER)	1935	if (op->type == PLAYER)
1968	esrv_update_item (UPD_NAME, op, tmp);	1936	esrv_update_item (UPD_NAME, op, tmp);
		1937
1969	new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);	1938	new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
1970	return 1;	1939	return 1;
1971	}	1940	}
1972	}	1941	}
1973	}	1942	}
…		…
1991	object *weapon, *tmp;	1960	object *weapon, *tmp;
1992	char buf[MAX_BUF];	1961	char buf[MAX_BUF];
1993	int a, i;	1962	int a, i;
1994	sint16 x, y;	1963	sint16 x, y;
1995	maptile *m;	1964	maptile *m;
1996	materialtype_t *mt;
1997		1965
1998	if (!spell->other_arch)	1966	if (!spell->other_arch)
1999	{	1967	{
2000	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	1968	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
2001	LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);	1969	LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);
…		…
2012	return 0;	1980	return 0;
2013	}	1981	}
2014		1982
2015	/* if no direction specified, pick one */	1983	/* if no direction specified, pick one */
2016	if (!dir)	1984	if (!dir)
2017	dir = find_free_spot (NULL, op->map, op->x, op->y, 1, 9);	1985	dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);
2018		1986
2019	m = op->map;	1987	m = op->map;
2020	x = op->x + freearr_x[dir];	1988	x = op->x + freearr_x[dir];
2021	y = op->y + freearr_y[dir];	1989	y = op->y + freearr_y[dir];
2022		1990
2023	/* if there's no place to put the golem, abort */	1991	/* if there's no place to put the golem, abort */
2024	if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) ||	1992	if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
2025	((spell->other_arch->clone.move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->clone.move_type))	1993	|| ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2026	{	1994	{
2027	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	1995	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
2028	return 0;	1996	return 0;
2029	}	1997	}
2030		1998
…		…
2034	if (!weapon)	2002	if (!weapon)
2035	{	2003	{
2036	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");	2004	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
2037	return 0;	2005	return 0;
2038	}	2006	}
		2007
2039	if (spell->race && strcmp (weapon->arch->name, spell->race))	2008	if (spell->race && weapon->arch->archname != spell->race)
2040	{	2009	{
2041	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");	2010	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
2042	return 0;	2011	return 0;
2043	}	2012	}
		2013
2044	if (weapon->type != WEAPON)	2014	if (weapon->type != WEAPON)
2045	{	2015	{
2046	new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");	2016	new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");
2047	return 0;	2017	return 0;
2048	}	2018	}
		2019
2049	if (QUERY_FLAG (weapon, FLAG_APPLIED))	2020	if (QUERY_FLAG (weapon, FLAG_APPLIED))
2050	{	2021	{
2051	new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));	2022	new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));
2052	return 0;	2023	return 0;
2053	}	2024	}
2054		2025
2055	if (weapon->nrof > 1)	2026	weapon = weapon->split ();
2056	{
2057	tmp = get_split_ob (weapon, 1);
2058	esrv_send_item (op, weapon);
2059	weapon = tmp;
2060	}
2061		2027
2062	/* create the golem object */	2028	/* create the golem object */
2063	tmp = arch_to_object (spell->other_arch);	2029	tmp = arch_to_object (spell->other_arch);
2064		2030
2065	/* if animated by a player, give the player control of the golem */	2031	/* if animated by a player, give the player control of the golem */
…		…
2070	tmp->set_owner (op);	2036	tmp->set_owner (op);
2071	op->contr->golem = tmp;	2037	op->contr->golem = tmp;
2072	set_spell_skill (op, caster, spell, tmp);	2038	set_spell_skill (op, caster, spell, tmp);
2073		2039
2074	/* Give the weapon to the golem now. A bit of a hack to check the	2040	/* Give the weapon to the golem now. A bit of a hack to check the
2075	* removed flag - it should only be set if get_split_object was	2041	* removed flag - it should only be set if weapon->split was
2076	* used above.	2042	* used above.
2077	*/	2043	*/
2078	if (!QUERY_FLAG (weapon, FLAG_REMOVED))	2044	if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2079	weapon->remove ();	2045	weapon->remove ();
2080		2046
2081	insert_ob_in_ob (weapon, tmp);	2047	tmp->insert (weapon);
2082	esrv_send_item (op, weapon);	2048
2083	/* To do everything necessary to let a golem use the weapon is a pain,	2049	/* To do everything necessary to let a golem use the weapon is a pain,
2084	* so instead, just set it as equipped (otherwise, we need to update	2050	* so instead, just set it as equipped (otherwise, we need to update
2085	* body_info, skills, etc)	2051	* body_info, skills, etc)
2086	*/	2052	*/
2087	SET_FLAG (tmp, FLAG_USE_WEAPON);	2053	SET_FLAG (tmp, FLAG_USE_WEAPON);
…		…
2113		2079
2114	/* attacktype */	2080	/* attacktype */
2115	if (!tmp->attacktype)	2081	if (!tmp->attacktype)
2116	tmp->attacktype = AT_PHYSICAL;	2082	tmp->attacktype = AT_PHYSICAL;
2117		2083
2118	mt = NULL;
2119	if (op->materialname != NULL)
2120	mt = name_to_material (op->materialname);	2084	if (materialtype_t *mt = name_to_material (op->materialname))
2121	if (mt != NULL)
2122	{	2085	{
2123	for (i = 0; i < NROFATTACKS; i++)	2086	for (i = 0; i < NROFATTACKS; i++)
2124	tmp->resist[i] = 50 - (mt->save[i] * 5);	2087	tmp->resist[i] = 50 - (mt->save[i] * 5);
2125	a = mt->save[0];	2088	a = mt->save[0];
2126	}	2089	}
…		…
2128	{	2091	{
2129	for (i = 0; i < NROFATTACKS; i++)	2092	for (i = 0; i < NROFATTACKS; i++)
2130	tmp->resist[i] = 5;	2093	tmp->resist[i] = 5;
2131	a = 10;	2094	a = 10;
2132	}	2095	}
		2096
2133	/* Set weapon's immunity */	2097	/* Set weapon's immunity */
2134	tmp->resist[ATNR_CONFUSION] = 100;	2098	tmp->resist[ATNR_CONFUSION] = 100;
2135	tmp->resist[ATNR_POISON] = 100;	2099	tmp->resist[ATNR_POISON] = 100;
2136	tmp->resist[ATNR_SLOW] = 100;	2100	tmp->resist[ATNR_SLOW] = 100;
2137	tmp->resist[ATNR_PARALYZE] = 100;	2101	tmp->resist[ATNR_PARALYZE] = 100;
…		…
2143		2107
2144	/* Improve weapon's armour value according to best save vs. physical of its material */	2108	/* Improve weapon's armour value according to best save vs. physical of its material */
2145		2109
2146	if (a > 14)	2110	if (a > 14)
2147	a = 14;	2111	a = 14;
		2112
2148	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));	2113	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2149		2114
2150	/* Determine golem's speed */	2115	/* Determine golem's speed */
2151	tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));	2116	tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2152		2117
…		…
2162	tmp->state = weapon->state;	2127	tmp->state = weapon->state;
2163	tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];	2128	tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2164	}	2129	}
2165		2130
2166	/* make experience increase in proportion to the strength of the summoned creature. */	2131	/* make experience increase in proportion to the strength of the summoned creature. */
2167	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));	2132	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));
2168		2133
2169	tmp->speed_left = -1;	2134	tmp->speed_left = -1;
2170	tmp->direction = dir;	2135	tmp->direction = dir;
2171		2136
2172	m->insert (tmp, x, y, op);	2137	m->insert (tmp, x, y, op);
…		…
2176	/* cast_daylight() - changes the map darkness level *lower* */	2141	/* cast_daylight() - changes the map darkness level *lower* */
2177		2142
2178	/* cast_change_map_lightlevel: Was cast_daylight/nightfall.	2143	/* cast_change_map_lightlevel: Was cast_daylight/nightfall.
2179	* This changes the light level for the entire map.	2144	* This changes the light level for the entire map.
2180	*/	2145	*/
2181
2182	int	2146	int
2183	cast_change_map_lightlevel (object *op, object *caster, object *spell)	2147	cast_change_map_lightlevel (object *op, object *caster, object *spell)
2184	{	2148	{
2185	int success;	2149	int success;
2186		2150
…		…
2194	if (spell->stats.dam < 0)	2158	if (spell->stats.dam < 0)
2195	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");	2159	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2196	else	2160	else
2197	new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");	2161	new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2198	}	2162	}
		2163
2199	return success;	2164	return success;
2200	}	2165	}
2201
2202
2203
2204
2205		2166
2206	/* create an aura spell object and put it in the player's inventory.	2167	/* create an aura spell object and put it in the player's inventory.
2207	* as usual, op is player, caster is the object casting the spell,	2168	* as usual, op is player, caster is the object casting the spell,
2208	* spell is the spell object itself.	2169	* spell is the spell object itself.
2209	*/	2170	*/
…		…
2221		2182
2222	new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);	2183	new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2223		2184
2224	new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	2185	new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2225		2186
2226	new_aura->set_owner (op);
2227	set_spell_skill (op, caster, spell, new_aura);	2187	set_spell_skill (op, caster, spell, new_aura);
2228	new_aura->attacktype = spell->attacktype;	2188	new_aura->attacktype = spell->attacktype;
2229		2189
2230	new_aura->level = caster_level (caster, spell);	2190	new_aura->level = casting_level (caster, spell);
		2191
2231	if (refresh)	2192	if (refresh)
2232	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	2193	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2233	else	2194	else
2234	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");	2195	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
		2196
2235	insert_ob_in_ob (new_aura, op);	2197	insert_ob_in_ob (new_aura, op);
		2198	new_aura->set_owner (op);
		2199
2236	return 1;	2200	return 1;
2237	}	2201	}
2238
2239		2202
2240	/* move aura function. An aura is a part of someone's inventory,	2203	/* move aura function. An aura is a part of someone's inventory,
2241	* which he carries with him, but which acts on the map immediately	2204	* which he carries with him, but which acts on the map immediately
2242	* around him.	2205	* around him.
2243	* Aura parameters:	2206	* Aura parameters:
2244	* duration: duration counter.	2207	* duration: duration counter.
2245	* attacktype: aura's attacktype	2208	* attacktype: aura's attacktype
2246	* other_arch: archetype to drop where we attack	2209	* other_arch: archetype to drop where we attack
2247	*/	2210	*/
2248
2249	void	2211	void
2250	move_aura (object *aura)	2212	move_aura (object *aura)
2251	{	2213	{
2252	int i, mflags;
2253	object *env;
2254	maptile *m;
2255
2256	/* auras belong in inventories */	2214	/* auras belong in inventories */
2257	env = aura->env;	2215	object *env = aura->env;
		2216	object *owner = aura->owner;
2258		2217
2259	/* no matter what we've gotta remove the aura...	2218	/* no matter what we've gotta remove the aura...
2260	* we'll put it back if its time isn't up.	2219	* we'll put it back if its time isn't up.
2261	*/	2220	*/
2262	aura->remove ();	2221	aura->remove ();
…		…
2267	aura->destroy ();	2226	aura->destroy ();
2268	return;	2227	return;
2269	}	2228	}
2270		2229
2271	/* auras only exist in inventories */	2230	/* auras only exist in inventories */
2272	if (env == NULL || env->map == NULL)	2231	if (!env || !env->map)
2273	{	2232	{
2274	aura->destroy ();	2233	aura->destroy ();
2275	return;	2234	return;
2276	}	2235	}
2277		2236
2278	/* we need to jump out of the inventory for a bit	2237	/* we need to jump out of the inventory for a bit
2279	* in order to hit the map conveniently.	2238	* in order to hit the map conveniently.
2280	*/	2239	*/
2281	aura->insert_at (env, aura);	2240	aura->insert_at (env, aura);
2282		2241
2283	for (i = 1; i < 9; i++)	2242	for (int i = 1; i < 9; i++)
2284	{	2243	{
2285	sint16 nx, ny;	2244	mapxy pos (env);
		2245	pos.move (i);
2286		2246
2287	nx = aura->x + freearr_x[i];
2288	ny = aura->y + freearr_y[i];
2289	mflags = get_map_flags (env->map, &m, nx, ny, &nx, &ny);
2290
2291	/* Consider the movement tyep of the person with the aura as	2247	/* Consider the movement type of the person with the aura as
2292	* movement type of the aura. Eg, if the player is flying, the aura	2248	* movement type of the aura. Eg, if the player is flying, the aura
2293	* is flying also, if player is walking, it is on the ground, etc.	2249	* is flying also, if player is walking, it is on the ground, etc.
2294	*/	2250	*/
2295	if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))	2251	if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2296	{	2252	{
2297	hit_map (aura, i, aura->attacktype, 0);	2253	hit_map (aura, i, aura->attacktype, 0);
2298		2254
2299	if (aura->other_arch)	2255	if (aura->other_arch)
2300	m->insert (arch_to_object (aura->other_arch), nx, ny, aura);	2256	pos.insert (arch_to_object (aura->other_arch), aura);
2301	}	2257	}
2302	}	2258	}
2303		2259
2304	/* put the aura back in the player's inventory */	2260	/* put the aura back in the player's inventory */
2305	aura->remove ();	2261	env->insert (aura);
2306	insert_ob_in_ob (aura, env);	2262	aura->set_owner (owner);
2307	}	2263	}
2308		2264
2309	/* moves the peacemaker spell.	2265	/* moves the peacemaker spell.
2310	* op is the piece object.	2266	* op is the piece object.
2311	*/	2267	*/
2312
2313	void	2268	void
2314	move_peacemaker (object *op)	2269	move_peacemaker (object *op)
2315	{	2270	{
2316	object *tmp;	2271	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
2317
2318	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2319	{	2272	{
2320	int atk_lev, def_lev;	2273	int atk_lev, def_lev;
2321	object *victim = tmp;	2274	object *victim = tmp->head_ ();
2322		2275
2323	if (tmp->head)
2324	victim = tmp->head;
2325	if (!QUERY_FLAG (victim, FLAG_MONSTER))	2276	if (!QUERY_FLAG (victim, FLAG_MONSTER))
2326	continue;	2277	continue;
		2278
2327	if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))	2279	if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))
2328	continue;	2280	continue;
		2281
2329	if (victim->stats.exp == 0)	2282	if (victim->stats.exp == 0)
2330	continue;	2283	continue;
2331		2284
2332	def_lev = MAX (1, victim->level);	2285	def_lev = MAX (1, victim->level);
2333	atk_lev = MAX (1, op->level);	2286	atk_lev = MAX (1, op->level);
2334		2287
2335	if (rndm (0, atk_lev - 1) > def_lev)	2288	if (rndm (0, atk_lev - 1) > def_lev)
2336	{	2289	{
2337	/* make this sucker peaceful. */	2290	/* make this sucker peaceful. */
2338		2291
		2292	INVOKE_OBJECT (KILL, victim, ARG_OBJECT (op));
2339	change_exp (op->owner, victim->stats.exp, op->skill, 0);	2293	change_exp (op->owner, victim->stats.exp, op->skill, 0);
2340	victim->stats.exp = 0;	2294	victim->stats.exp = 0;
2341	#if 0	2295	#if 0
2342	/* No idea why these were all set to zero - if something	2296	/* No idea why these were all set to zero - if something
2343	* makes this creature agressive, he should still do damage.	2297	* makes this creature agressive, he should still do damage.
…		…
2350	victim->attack_movement = RANDO2;	2304	victim->attack_movement = RANDO2;
2351	SET_FLAG (victim, FLAG_UNAGGRESSIVE);	2305	SET_FLAG (victim, FLAG_UNAGGRESSIVE);
2352	SET_FLAG (victim, FLAG_RUN_AWAY);	2306	SET_FLAG (victim, FLAG_RUN_AWAY);
2353	SET_FLAG (victim, FLAG_RANDOM_MOVE);	2307	SET_FLAG (victim, FLAG_RANDOM_MOVE);
2354	CLEAR_FLAG (victim, FLAG_MONSTER);	2308	CLEAR_FLAG (victim, FLAG_MONSTER);
		2309
2355	if (victim->name)	2310	if (victim->name)
2356	{
2357	new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);	2311	new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2358	}	2312	}
2359	}
2360	}	2313	}
2361	}	2314	}
2362
2363		2315
2364	/* This writes a rune that contains the appropriate message.	2316	/* This writes a rune that contains the appropriate message.
2365	* There really isn't any adjustments we make.	2317	* There really isn't any adjustments we make.
2366	*/	2318	*/
2367
2368	int	2319	int
2369	write_mark (object *op, object *spell, const char *msg)	2320	write_mark (object *op, object *spell, const char *msg)
2370	{	2321	{
2371	char rune[HUGE_BUF];
2372	object *tmp;
2373
2374	if (!msg || msg[0] == 0)	2322	if (!msg || msg[0] == 0)
2375	{	2323	{
2376	new_draw_info (NDI_UNIQUE, 0, op, "Write what?");	2324	new_draw_info (NDI_UNIQUE, 0, op, "Write what?");
2377	return 0;	2325	return 0;
2378	}	2326	}
…		…
2381	{	2329	{
2382	new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");	2330	new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");
2383	LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg);	2331	LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg);
2384	return 0;	2332	return 0;
2385	}	2333	}
		2334
2386	if (!spell->other_arch)	2335	if (!spell->other_arch)
2387	return 0;	2336	return 0;
		2337
2388	tmp = arch_to_object (spell->other_arch);	2338	object *tmp = arch_to_object (spell->other_arch);
2389
2390	snprintf (rune, sizeof (rune), "%s\n", msg);
2391		2339
2392	tmp->race = op->name; /*Save the owner of the rune */	2340	tmp->race = op->name; /*Save the owner of the rune */
2393	tmp->msg = rune;	2341	tmp->msg = msg;
2394		2342
2395	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);	2343	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
		2344
2396	return 1;	2345	return 1;
2397	}	2346	}
		2347

Diff Legend

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