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.60 by root, Sun Jun 24 01:09:28 2007 UTC vs.
Revision 1.111 by root, Mon Oct 12 21:27:55 2009 UTC

1	/*	1	/*
2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team	4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* Crossfire TRT is free software; you can redistribute it and/or modify it	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* under the terms of the GNU General Public License as published by the Free	9	* the terms of the Affero GNU General Public License as published by the
10	* Software Foundation; either version 2 of the License, or (at your option)	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* any later version.	11	* option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful, but	13	* This program is distributed in the hope that it will be useful,
14	* WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* 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 along	18	* You should have received a copy of the Affero GNU General Public License
19	* with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51	19	* and the GNU General Public License along with this program. If not, see
20	* Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA	20	* <http://www.gnu.org/licenses/>.
21	*	21	*
22	* The authors can be reached via e-mail to <crossfire@schmorp.de>	22	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	23	*/
24		24
25	#include <global.h>	25	#include <global.h>
26	#include <object.h>	26	#include <object.h>
27	#include <living.h>	27	#include <living.h>
…		…
62	{	62	{
63	object *wand, *tmp;	63	object *wand, *tmp;
64	int ncharges;	64	int ncharges;
65		65
66	wand = find_marked_object (op);	66	wand = find_marked_object (op);
67	if (wand == NULL || wand->type != WAND)	67	if (!wand || wand->type != WAND)
68	{	68	{
69	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");	69	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");
70	return 0;	70	return 0;
71	}	71	}
72	if (!(random_roll (0, 3, op, PREFER_HIGH)))	72	if (!(random_roll (0, 3, op, PREFER_HIGH)))
73	{	73	{
74	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));	74	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));
75	play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE);	75	op->play_sound (sound_find ("ob_explode"));
76	esrv_del_item (op->contr, wand->count);
77	wand->destroy ();	76	wand->destroy ();
78	tmp = get_archetype ("fireball");	77	tmp = get_archetype ("fireball");
79	tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;	78	tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
80		79
81	if (!tmp->stats.dam)	80	if (!tmp->stats.dam)
…		…
123	* great a plus, the default is used.	122	* great a plus, the default is used.
124	* The # of arrows created also goes up with level, so if a 30th level mage	123	* The # of arrows created also goes up with level, so if a 30th level mage
125	* wants LOTS of arrows, and doesn't care what the plus is he could	124	* wants LOTS of arrows, and doesn't care what the plus is he could
126	* create nonnmagic arrows, or even -1, etc...	125	* create nonnmagic arrows, or even -1, etc...
127	*/	126	*/
128
129	int	127	int
130	cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg)	128	cast_create_missile (object *op, object *caster, object *spell, int dir, const char *spellparam)
131	{	129	{
132	int missile_plus = 0, bonus_plus = 0;	130	int bonus_plus = 0;
133	const char *missile_name;	131	const char *missile_name = "arrow";
134	object *tmp, *missile;
135		132
136	missile_name = "arrow";
137
138	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	133	for (object *tmp = op->inv; tmp; tmp = tmp->below)
139	if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))	134	if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
140	missile_name = tmp->race;	135	missile_name = tmp->race;
141		136
142	missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);	137	int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
143		138
144	if (archetype::find (missile_name) == NULL)	139	archetype *missile_arch = archetype::find (missile_name);
		140
		141	if (!missile_arch)
145	{	142	{
146	LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);	143	LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);
147	return 0;	144	return 0;
148	}	145	}
149		146
150	missile = get_archetype (missile_name);	147	object *missile = missile_arch->instance ();
151		148
152	if (stringarg)	149	if (spellparam)
153	{	150	{
154	/* If it starts with a letter, presume it is a description */	151	/* If it starts with a letter, presume it is a description */
155	if (isalpha (*stringarg))	152	if (isalpha (*spellparam))
156	{	153	{
157	artifact *al = find_artifactlist (missile->type)->items;	154	artifact *al = find_artifactlist (missile->type)->items;
158		155
159	for (; al; al = al->next)	156	for (; al; al = al->next)
160	if (!strcasecmp (al->item->name, stringarg))	157	if (!strcasecmp (al->item->name, spellparam))
161	break;	158	break;
162		159
163	if (!al)	160	if (!al)
164	{	161	{
165	missile->destroy ();	162	missile->destroy ();
166	new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, stringarg);	163	new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, spellparam);
167	return 0;	164	return 0;
168	}	165	}
169		166
170	if (al->item->slaying)	167	if (al->item->slaying)
171	{	168	{
172	missile->destroy ();	169	missile->destroy ();
173	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg);	170	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, spellparam);
174	return 0;	171	return 0;
175	}	172	}
176		173
177	give_artifact_abilities (missile, al->item);	174	give_artifact_abilities (missile, al->item);
178	/* These special arrows cost something extra. Don't have them also be magical -	175	/* These special arrows cost something extra. Don't have them also be magical -
179	* otherwise, in most cases, not enough will be created. I don't want to get into	176	* otherwise, in most cases, not enough will be created. I don't want to get into
180	* the parsing of having to do both plus and type.	177	* the parsing of having to do both plus and type.
181	*/	178	*/
182	bonus_plus = 1 + (al->item->value / 5);	179	bonus_plus = 1 + (al->item->value / 5);
183	missile_plus = 0;	180	missile_plus = 0;
184	}	181	}
185	else if (atoi (stringarg) < missile_plus)	182	else if (atoi (spellparam) < missile_plus)
186	missile_plus = atoi (stringarg);	183	missile_plus = atoi (spellparam);
187	}	184	}
188		185
189	if (missile_plus > 4)	186	missile_plus = clamp (missile_plus, -4, 4);
190	missile_plus = 4;
191	else if (missile_plus < -4)
192	missile_plus = -4;
193		187
194	missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);	188	missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
195	missile->nrof -= 3 * (missile_plus + bonus_plus);	189	missile->nrof -= 3 * (missile_plus + bonus_plus);
196		190
197	if (missile->nrof < 1)	191	if (missile->nrof < 1)
…		…
209	return 1;	203	return 1;
210	}	204	}
211		205
212		206
213	/* allows the choice of what sort of food object to make.	207	/* allows the choice of what sort of food object to make.
214	* If stringarg is NULL, it will create food dependent on level --PeterM*/	208	* If spellparam is NULL, it will create food dependent on level --PeterM*/
215	int	209	int
216	cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *stringarg)	210	cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *spellparam)
217	{	211	{
218	int food_value;	212	int food_value;
219	archetype *at = NULL;	213	archetype *at = NULL;
220	object *new_op;	214	object *new_op;
221		215
222	food_value = spell_ob->stats.food + +50 * SP_level_duration_adjust (caster, spell_ob);	216	food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);
223		217
224	if (stringarg)	218	if (spellparam)
225	{	219	{
226	at = find_archetype_by_object_type_name (FOOD, stringarg);	220	at = find_archetype_by_object_type_name (FOOD, spellparam);
227	if (at == NULL)	221	if (at == NULL)
228	at = find_archetype_by_object_type_name (DRINK, stringarg);	222	at = find_archetype_by_object_type_name (DRINK, spellparam);
229	if (at == NULL || at->stats.food > food_value)	223	if (at == NULL || at->stats.food > food_value)
230	stringarg = NULL;	224	spellparam = NULL;
231	}	225	}
232		226
233	if (!stringarg)	227	if (!spellparam)
234	{	228	{
235	archetype *at_tmp;	229	archetype *at_tmp;
236		230
237	/* We try to find the archetype with the maximum food value.	231	/* We try to find the archetype with the maximum food value.
238	* This removes the dependancy of hard coded food values in this	232	* This removes the dependancy of hard coded food values in this
…		…
257	&& at_tmp->weight < at->weight)))	251	&& at_tmp->weight < at->weight)))
258	at = at_tmp;	252	at = at_tmp;
259	}	253	}
260	}	254	}
261	}	255	}
		256
262	/* Pretty unlikely (there are some very low food items), but you never	257	/* Pretty unlikely (there are some very low food items), but you never
263	* know	258	* know
264	*/	259	*/
265	if (!at)	260	if (!at)
266	{	261	{
…		…
285	{	280	{
286	int r, mflags, maxrange;	281	int r, mflags, maxrange;
287	object *tmp;	282	object *tmp;
288	maptile *m;	283	maptile *m;
289		284
290
291	if (!dir)	285	if (!dir)
292	{	286	{
293	examine_monster (op, op);	287	examine_monster (op, op);
294	return 1;	288	return 1;
295	}	289	}
		290
296	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	291	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
297	for (r = 1; r < maxrange; r++)	292	for (r = 1; r < maxrange; r++)
298	{	293	{
299	sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];	294	sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];
300		295
…		…
307	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))	302	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))
308	{	303	{
309	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");	304	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
310	return 0;	305	return 0;
311	}	306	}
		307
312	if (mflags & P_IS_ALIVE)	308	if (mflags & P_IS_ALIVE)
313	{	309	{
314	for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)	310	for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
315	if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))	311	if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))
316	{	312	{
317	new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");	313	new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
318	if (tmp->head != NULL)	314	if (tmp->head != NULL)
319	tmp = tmp->head;	315	tmp = tmp->head;
320	examine_monster (op, tmp);	316	examine_monster (op, tmp);
321	return 1;	317	return 1;
322	}	318	}
323	}	319	}
324	}	320	}
		321
325	new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");	322	new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");
326	return 1;	323	return 1;
327	}	324	}
328
329		325
330	/* This checks to see if 'pl' is invisible to 'mon'.	326	/* This checks to see if 'pl' is invisible to 'mon'.
331	* does race check, undead check, etc	327	* does race check, undead check, etc
332	* Returns TRUE if mon can't see pl, false	328	* Returns TRUE if mon can't see pl, false
333	* otherwise. This doesn't check range, walls, etc. It	329	* otherwise. This doesn't check range, walls, etc. It
…		…
335	* pl is invisible.	331	* pl is invisible.
336	*/	332	*/
337	int	333	int
338	makes_invisible_to (object *pl, object *mon)	334	makes_invisible_to (object *pl, object *mon)
339	{	335	{
340
341	if (!pl->invisible)	336	if (!pl->invisible)
342	return 0;	337	return 0;
		338
343	if (pl->type == PLAYER)	339	if (pl->type == PLAYER)
344	{	340	{
345	/* If race isn't set, then invisible unless it is undead */	341	/* If race isn't set, then invisible unless it is undead */
346	if (!pl->contr->invis_race)	342	if (!pl->contr->invis_race)
347	{	343	{
348	if (QUERY_FLAG (mon, FLAG_UNDEAD))	344	if (QUERY_FLAG (mon, FLAG_UNDEAD))
349	return 0;	345	return 0;
		346
350	return 1;	347	return 1;
351	}	348	}
		349
352	/* invis_race is set if we get here */	350	/* invis_race is set if we get here */
353	if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon))	351	if (pl->contr->invis_race == shstr_undead && is_true_undead (mon))
354	return 1;	352	return 1;
		353
355	/* No race, can't be invisible to it */	354	/* No race, can't be invisible to it */
356	if (!mon->race)	355	if (!mon->race)
357	return 0;	356	return 0;
		357
358	if (strstr (mon->race, pl->contr->invis_race))	358	if (mon->race.contains (pl->contr->invis_race))
359	return 1;	359	return 1;
		360
360	/* Nothing matched above, return 0 */	361	/* Nothing matched above, return 0 */
361	return 0;	362	return 0;
362	}	363	}
363	else	364	else
364	{	365	{
…		…
425	/* earth to dust spell. Basically destroys earthwalls in the area.	426	/* earth to dust spell. Basically destroys earthwalls in the area.
426	*/	427	*/
427	int	428	int
428	cast_earth_to_dust (object *op, object *caster, object *spell_ob)	429	cast_earth_to_dust (object *op, object *caster, object *spell_ob)
429	{	430	{
430	object *tmp, *next;
431	int range, i, j, mflags;	431	int range, i, j, mflags;
432	sint16 sx, sy;	432	sint16 sx, sy;
433	maptile *m;	433	maptile *m;
434
435	if (op->type != PLAYER)
436	return 0;
437		434
438	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	435	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
439		436
440	for (i = -range; i <= range; i++)	437	for (i = -range; i <= range; i++)
441	for (j = -range; j <= range; j++)	438	for (j = -range; j <= range; j++)
…		…
446	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);	443	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
447		444
448	if (mflags & P_OUT_OF_MAP)	445	if (mflags & P_OUT_OF_MAP)
449	continue;	446	continue;
450		447
451	// earth to dust tears down everything that can be teared down	448	// earth to dust tears down everything that can be torn down
452	for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)	449	for (object *next, *tmp = m->at (sx, sy).bot; tmp; tmp = next)
453	{	450	{
454	next = tmp->above;	451	next = tmp->above;
		452
455	if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))	453	if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
456	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);	454	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
457	}	455	}
458	}	456	}
459		457
…		…
466	if (object *pl = op->in_player ())	464	if (object *pl = op->in_player ())
467	{	465	{
468	if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))	466	if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
469	new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");	467	new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
470	else	468	else
471	{	469	pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);
472	// remove first so we do not call update_stats
473	op->remove ();
474	pl->enter_exit (op);
475	}
476	}	470	}
477		471
478	op->destroy ();	472	op->destroy ();
479	}	473	}
480		474
…		…
496	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");	490	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
497	return 1;	491	return 1;
498	}	492	}
499		493
500	dummy = get_archetype (FORCE_NAME);	494	dummy = get_archetype (FORCE_NAME);
501	if (dummy == NULL)	495
		496	if (!dummy)
502	{	497	{
503	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	498	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
504	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");	499	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
505	return 0;	500	return 0;
506	}	501	}
…		…
572	perceive_self (object *op)	567	perceive_self (object *op)
573	{	568	{
574	const char *cp = describe_item (op, op);	569	const char *cp = describe_item (op, op);
575	archetype *at = archetype::find (ARCH_DEPLETION);	570	archetype *at = archetype::find (ARCH_DEPLETION);
576		571
577	dynbuf_text buf;	572	dynbuf_text &buf = msg_dynbuf; buf.clear ();
578		573
579	if (player *pl = op->contr)	574	if (!op->is_player ())
		575	return 0;
		576
580	if (object *race = archetype::find (op->race))	577	if (object *race = archetype::find (op->race))
581	buf << "You are a " << (pl->gender ? "female" : "male") << " " << &race->name << ".\n";	578	buf << " - You are a G<male|female> " << &race->name << ".\n";
582		579
583	if (object *god = find_god (determine_god (op)))	580	if (object *god = find_god (determine_god (op)))
584	buf << "You worship " << &god->name << ".\n";	581	buf << " - You worship " << &god->name << ".\n";
585	else	582	else
586	buf << "You worship no god.\n";	583	buf << " - You worship no god.\n";
587		584
588	object *tmp = present_arch_in_ob (at, op);	585	object *tmp = present_arch_in_ob (at, op);
589		586
590	if (*cp == '\0' && tmp == NULL)	587	if (*cp == '\0' && !tmp)
591	buf << "You feel very mundane. ";	588	buf << " - You feel very mundane. ";
592	else	589	else
593	{	590	{
594	buf << "You have: " << cp << ".\n";	591	buf << " - You have: " << cp << ".\n";
595		592
596	if (tmp)	593	if (tmp)
597	for (int i = 0; i < NUM_STATS; i++)	594	for (int i = 0; i < NUM_STATS; i++)
598	if (tmp->stats.stat (i) < 0)	595	if (tmp->stats.stat (i) < 0)
599	buf.printf ("Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));	596	buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
600	}	597	}
601		598
602	if (is_dragon_pl (op))	599	if (is_dragon_pl (op))
603	/* now grab the 'dragon_ability'-force from the player's inventory */	600	/* now grab the 'dragon_ability'-force from the player's inventory */
604	for (tmp = op->inv; tmp; tmp = tmp->below)	601	for (tmp = op->inv; tmp; tmp = tmp->below)
605	{	602	{
606	if (tmp->type == FORCE && !strcmp (tmp->arch->archname, "dragon_ability_force"))	603	if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
607	{	604	{
608	if (tmp->stats.exp == 0)	605	if (tmp->stats.exp == 0)
609	buf << "Your metabolism isn't focused on anything.\n";	606	buf << " - Your metabolism isn't focused on anything.\n";
610	else	607	else
611	buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";	608	buf << " - Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
612		609
613	break;	610	break;
614	}	611	}
615	}	612	}
616		613
617	new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ());	614	op->contr->infobox (MSG_CHANNEL ("perceiveself"), buf);
618		615
619	return 1;	616	return 1;
620	}	617	}
621		618
622	/* This creates magic walls. Really, it can create most any object,	619	/* This creates magic walls. Really, it can create most any object,
…		…
710	*/	707	*/
711	if (tmp->type != EARTHWALL) //TODO	708	if (tmp->type != EARTHWALL) //TODO
712	tmp->set_owner (op);	709	tmp->set_owner (op);
713		710
714	set_spell_skill (op, caster, spell_ob, tmp);	711	set_spell_skill (op, caster, spell_ob, tmp);
715	tmp->level = caster_level (caster, spell_ob) / 2;	712	tmp->level = casting_level (caster, spell_ob) / 2;
716		713
717	name = tmp->name;	714	name = tmp->name;
718	if (!(tmp = m->insert (tmp, x, y, op)))	715	if (!(tmp = m->insert (tmp, x, y, op)))
719	{	716	{
720	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);	717	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
…		…
781		778
782	return 1;	779	return 1;
783	}	780	}
784		781
785	int	782	int
786	dimension_door (object *op, object *caster, object *spob, int dir)	783	dimension_door (object *op, object *caster, object *spob, int dir, const char *spellparam)
787	{	784	{
788	uint32 dist, maxdist;	785	uint32 dist, maxdist;
789	int mflags;	786	int mflags;
790	maptile *m;	787	maptile *m;
791	sint16 sx, sy;	788	sint16 sx, sy;
…		…
802	/* Given the new outdoor maps, can't let players dimension door for	799	/* Given the new outdoor maps, can't let players dimension door for
803	* ever, so put limits in.	800	* ever, so put limits in.
804	*/	801	*/
805	maxdist = spob->range + SP_level_range_adjust (caster, spob);	802	maxdist = spob->range + SP_level_range_adjust (caster, spob);
806		803
807	if (op->contr->count)	804	if (spellparam)
808	{	805	{
		806	int count = atoi (spellparam);
		807
809	if (op->contr->count > maxdist)	808	if (count > maxdist)
810	{	809	{
811	new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!");	810	new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!");
812	return 0;	811	return 0;
813	}	812	}
814		813
815	for (dist = 0; dist < op->contr->count; dist++)	814	for (dist = 0; dist < count; dist++)
816	{	815	{
817	mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);	816	mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);
818		817
819	if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))	818	if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
820	break;	819	break;
821		820
822	if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))	821	if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
823	break;	822	break;
824	}	823	}
825		824
826	if (dist < op->contr->count)	825	if (dist < count)
827	{	826	{
828	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");	827	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
829	op->contr->count = 0;
830	return 0;	828	return 0;
831	}	829	}
832
833	op->contr->count = 0;
834		830
835	/* Remove code that puts player on random space on maps. IMO,	831	/* Remove code that puts player on random space on maps. IMO,
836	* a lot of maps probably have areas the player should not get to,	832	* a lot of maps probably have areas the player should not get to,
837	* but may not be marked as NO_MAGIC (as they may be bounded	833	* but may not be marked as NO_MAGIC (as they may be bounded
838	* by such squares). Also, there are probably treasure rooms and	834	* by such squares). Also, there are probably treasure rooms and
…		…
893		889
894	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */	890	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
895	return 1;	891	return 1;
896	}	892	}
897		893
898
899	/* cast_heal: Heals something.	894	/* cast_heal: Heals something.
900	* op is the caster.	895	* op is the caster.
901	* dir is the direction he is casting it in.	896	* dir is the direction he is casting it in.
902	* spell is the spell object.	897	* spell is the spell object.
903	*/	898	*/
…		…
929	{	924	{
930	/* See how many points we actually heal. Instead of messages	925	/* See how many points we actually heal. Instead of messages
931	* based on type of spell, we instead do messages based	926	* based on type of spell, we instead do messages based
932	* on amount of damage healed.	927	* on amount of damage healed.
933	*/	928	*/
934	if (heal > (tmp->stats.maxhp - tmp->stats.hp))	929	if (heal > tmp->stats.maxhp - tmp->stats.hp)
935	heal = tmp->stats.maxhp - tmp->stats.hp;	930	heal = tmp->stats.maxhp - tmp->stats.hp;
		931
936	tmp->stats.hp += heal;	932	tmp->stats.hp += heal;
937		933
938	if (tmp->stats.hp >= tmp->stats.maxhp)	934	if (tmp->stats.hp >= tmp->stats.maxhp)
939	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");	935	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
940	else if (heal > 50)	936	else if (heal > 50)
…		…
949	success = 1;	945	success = 1;
950	}	946	}
951	}	947	}
952		948
953	if (spell->attacktype & AT_DISEASE)	949	if (spell->attacktype & AT_DISEASE)
954	if (cure_disease (tmp, op))	950	if (cure_disease (tmp, op, spell))
955	success = 1;	951	success = 1;
956		952
957	if (spell->attacktype & AT_POISON)	953	if (spell->attacktype & AT_POISON)
958	{	954	{
959	at = archetype::find ("poisoning");	955	at = archetype::find ("poisoning");
…		…
1008	}	1004	}
1009		1005
1010	if (spell->stats.food && tmp->stats.food < 999)	1006	if (spell->stats.food && tmp->stats.food < 999)
1011	{	1007	{
1012	tmp->stats.food += spell->stats.food;	1008	tmp->stats.food += spell->stats.food;
		1009
1013	if (tmp->stats.food > 999)	1010	if (tmp->stats.food > 999)
1014	tmp->stats.food = 999;	1011	tmp->stats.food = 999;
		1012
1015	success = 1;	1013	success = 1;
1016	/* We could do something a bit better like the messages for healing above */	1014	/* We could do something a bit better like the messages for healing above */
1017	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");	1015	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1018	}	1016	}
1019		1017
…		…
1033	"You don't feel any more powerful."	1031	"You don't feel any more powerful."
1034	"You are no easier to look at.",	1032	"You are no easier to look at.",
1035	};	1033	};
1036		1034
1037	int	1035	int
		1036	change_ability_duration (object *spell, object *caster)
		1037	{
		1038	return spell->duration + SP_level_duration_adjust (caster, spell) * 50;
		1039	}
		1040
		1041	int
1038	cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)	1042	cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1039	{	1043	{
1040	object *force = NULL;	1044	object *force = 0;
1041	int i;	1045	int i;
1042		1046
1043	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */	1047	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1044	object *tmp = dir	1048	object *tmp = dir
1045	? find_target_for_friendly_spell (op, dir)	1049	? find_target_for_friendly_spell (op, dir)
1046	: op;	1050	: op;
1047		1051
1048	if (!tmp)	1052	if (!tmp)
1049	return 0;	1053	return 0;
1050		1054
1051	/* If we've already got a force of this type, don't add a new one. */	1055	/* If we've already got a force of this type, don't add a new one. */
…		…
1059	break;	1063	break;
1060	}	1064	}
1061	else if (spell_ob->race && spell_ob->race == tmp2->name)	1065	else if (spell_ob->race && spell_ob->race == tmp2->name)
1062	{	1066	{
1063	if (!silent)	1067	if (!silent)
1064	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	new_draw_info_format (NDI_UNIQUE, 0, op,
		1069	"You can not cast %s while %s is in effect",
		1070	&spell_ob->name, &tmp2->name_pl);
		1071
1065	return 0;	1072	return 0;
1066	}	1073	}
1067	}	1074	}
1068	}	1075	}
		1076
		1077	int duration = change_ability_duration (spell_ob, caster);
		1078
1069	if (force == NULL)	1079	if (force)
1070	{
1071	force = get_archetype (FORCE_NAME);
1072	force->subtype = FORCE_CHANGE_ABILITY;
1073	if (spell_ob->race)
1074	force->name = spell_ob->race;
1075	else
1076	force->name = spell_ob->name;
1077	force->name_pl = spell_ob->name;
1078	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
1079
1080	}	1080	{
1081	else
1082	{
1083	int duration;
1084
1085	duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1086	if (duration > force->duration)	1081	if (duration > force->duration)
1087	{	1082	{
1088	force->duration = duration;	1083	force->duration = duration;
1089	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	1084	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1090	}	1085	}
1091	else	1086	else
1092	{
1093	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1087	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1094	}
1095		1088
1096	return 1;	1089	return 1;
1097	}	1090	}
1098		1091
1099	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1092	new_draw_info_format (NDI_UNIQUE, 0, op,
		1093	"You create an aura of magical force. H<The effect will last for about %.10g seconds.>",
		1094	TICK2TIME (duration));
		1095
		1096	force = get_archetype (FORCE_NAME);
		1097	force->subtype = FORCE_CHANGE_ABILITY;
		1098	force->duration = duration;
		1099
		1100	if (spell_ob->race)
		1101	force->name = spell_ob->race;
		1102	else
		1103	force->name = spell_ob->name;
		1104
		1105	force->name_pl = spell_ob->name;
		1106
1100	force->speed = 1.0;	1107	force->speed = 1.0;
1101	force->speed_left = -1.0;	1108	force->speed_left = -1.0;
1102	SET_FLAG (force, FLAG_APPLIED);	1109	SET_FLAG (force, FLAG_APPLIED);
1103		1110
1104	/* Now start processing the effects. First, protections */	1111	/* Now start processing the effects. First, protections */
…		…
1171	*/	1178	*/
1172	int	1179	int
1173	cast_bless (object *op, object *caster, object *spell_ob, int dir)	1180	cast_bless (object *op, object *caster, object *spell_ob, int dir)
1174	{	1181	{
1175	int i;	1182	int i;
1176	object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;	1183	object *god = find_god (determine_god (op)), *force = NULL, *tmp;
1177		1184
1178	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */	1185	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1179	if (dir != 0)	1186	if (dir != 0)
1180	{	1187	{
1181	tmp = find_target_for_friendly_spell (op, dir);	1188	tmp = find_target_for_friendly_spell (op, dir);
		1189
		1190	if (!tmp)
		1191	return 0;
1182	}	1192	}
1183	else	1193	else
1184	{
1185	tmp = op;	1194	tmp = op;
1186	}
1187		1195
1188	/* If we've already got a force of this type, don't add a new one. */	1196	/* If we've already got a force of this type, don't add a new one. */
1189	for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below)	1197	for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1190	{	1198	{
1191	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)	1199	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1192	{	1200	{
1193	if (tmp2->name == spell_ob->name)	1201	if (tmp2->name == spell_ob->name)
1194	{	1202	{
…		…
1200	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);	1208	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
1201	return 0;	1209	return 0;
1202	}	1210	}
1203	}	1211	}
1204	}	1212	}
		1213
1205	if (force == NULL)	1214	if (force == NULL)
1206	{	1215	{
1207	force = get_archetype (FORCE_NAME);	1216	force = get_archetype (FORCE_NAME);
1208	force->subtype = FORCE_CHANGE_ABILITY;	1217	force->subtype = FORCE_CHANGE_ABILITY;
1209	if (spell_ob->race)	1218	if (spell_ob->race)
…		…
1274	}	1283	}
1275		1284
1276	/* Alchemy code by Mark Wedel	1285	/* Alchemy code by Mark Wedel
1277	*	1286	*
1278	* This code adds a new spell, called alchemy. Alchemy will turn	1287	* This code adds a new spell, called alchemy. Alchemy will turn
1279	* objects to gold nuggets, the value of the gold nuggets being	1288	* objects to pyrite ("false gold"), henceforth called gold nuggets.
1280	* about 90% of that of the item itself. It uses the value of the
1281	* object before charisma adjustments, because the nuggets themselves
1282	* will be will be adjusted by charisma when sold.
1283	*	1289	*
1284	* Large nuggets are worth 25 gp each (base). You will always get	1290	* The value of the gold nuggets being about 90% of that of the item
1285	* the maximum number of large nuggets you could get.	1291	* itself. It uses the value of the object before charisma adjustments,
1286	* Small nuggets are worth 1 gp each (base). You will get from 0	1292	* because the nuggets themselves will be will be adjusted by charisma
1287	* to the max amount of small nuggets as you could get.	1293	* when sold.
1288	*
1289	* For example, if an item is worth 110 gold, you will get
1290	* 4 large nuggets, and from 0-10 small nuggets.
1291	*	1294	*
1292	* There is also a chance (1:30) that you will get nothing at all	1295	* There is also a chance (1:30) that you will get nothing at all
1293	* for the object. There is also a maximum weight that will be	1296	* for the object. There is also a maximum weight that will be
1294	* alchemised.	1297	* alchemised.
1295	*/	1298	*/
1296	static void	1299	static void
1297	alchemy_object (object *obj, uint64 &total_value, int &total_weight)	1300	alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1298	{	1301	{
1299	uint64 value = query_cost (obj, NULL, F_TRUE);	1302	uint64 value = query_cost (obj, NULL, F_TRUE);
1300		1303
1301	/* Give third price when we alchemy money (This should hopefully	1304	/* Give third price when we alchemy money (this should hopefully
1302	* make it so that it isn't worth it to alchemy money, sell	1305	* make it so that it isn't worth it to alchemy money, sell
1303	* the nuggets, alchemy the gold from that, etc.	1306	* the nuggets, alchemy the gold from that, etc.
1304	* Otherwise, give 9 silver on the gold for other objects,	1307	* Otherwise, give 9 silver on the gold for other objects,
1305	* so that it would still be more affordable to haul	1308	* so that it would still be more affordable to haul
1306	* the stuff back to town.	1309	* the stuff back to town.
…		…
1318	total_weight += obj->total_weight ();	1321	total_weight += obj->total_weight ();
1319		1322
1320	obj->destroy ();	1323	obj->destroy ();
1321	}	1324	}
1322		1325
1323	static void
1324	update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1325	{
1326	int flag = 0;
1327
1328	/* Put any nuggets below the player, but we can only pass this
1329	* flag if we are on the same space as the player
1330	*/
1331	if (x == op->x && y == op->y && op->map == m)
1332	flag = INS_BELOW_ORIGINATOR;
1333
1334	if (small_nuggets)
1335	{
1336	object *tmp = small->clone ();
1337	tmp->nrof = small_nuggets;
1338	m->insert (tmp, x, y, op, flag);
1339	}
1340
1341	if (large_nuggets)
1342	{
1343	object *tmp = large->clone ();
1344	tmp->nrof = large_nuggets;
1345	m->insert (tmp, x, y, op, flag);
1346	}
1347
1348	if (object *pl = m->at (x, y).player ())
1349	if (pl->contr->ns)
1350	pl->contr->ns->look_position = 0;
1351	}
1352
1353	int	1326	int
1354	alchemy (object *op, object *caster, object *spell_ob)	1327	alchemy (object *op, object *caster, object *spell_ob)
1355	{	1328	{
1356	if (op->type != PLAYER)	1329	if (op->type != PLAYER)
1357	return 0;	1330	return 0;
1358		1331
1359	object *large = get_archetype ("largenugget");	1332	archetype *nugget[3];
1360	object *small = get_archetype ("smallnugget");	1333
		1334	nugget[0] = archetype::find ("pyrite3");
		1335	nugget[1] = archetype::find ("pyrite2");
		1336	nugget[2] = archetype::find ("pyrite");
1361		1337
1362	/* Put a maximum weight of items that can be alchemised. Limits the power	1338	/* Put a maximum weight of items that can be alchemised. Limits the power
1363	* some, and also prevents people from alchemising every table/chair/clock	1339	* some, and also prevents people from alchemising every table/chair/clock
1364	* in sight	1340	* in sight
1365	*/	1341	*/
…		…
1417	if (weight > weight_max)	1393	if (weight > weight_max)
1418	break;	1394	break;
1419	}	1395	}
1420	}	1396	}
1421		1397
		1398	value -= rndm (value >> 4);
1422	value = min (value, value_max);	1399	value = min (value, value_max);
1423		1400
1424	uint64 count = value / large->value;	1401	for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1425	int large_nuggets = count;	1402	if (int nrof = value / nugget [i]->value)
1426	value -= count * large->value;
1427
1428	count = value / small->value;
1429	int small_nuggets = count;
1430
1431	/* Insert all the nuggets at one time. This probably saves time, but
1432	* it also prevents us from alcheming nuggets that were just created
1433	* with this spell.
1434	*/	1403	{
1435	update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny);	1404	value -= nrof * nugget[i]->value;
		1405
		1406	object *tmp = arch_to_object (nugget[i]);
		1407	tmp->nrof = nrof;
		1408	tmp->flag [FLAG_IDENTIFIED] = true;
		1409	op->map->insert (tmp, x, y, op, 0);
		1410	}
1436		1411
1437	if (weight > weight_max)	1412	if (weight > weight_max)
1438	goto bailout;	1413	goto bailout;
1439	}	1414	}
1440	}	1415	}
1441		1416
1442	bailout:	1417	bailout:
1443	large->destroy ();
1444	small->destroy ();
1445	return 1;	1418	return 1;
1446	}	1419	}
1447
1448		1420
1449	/* This function removes the cursed/damned status on equipped	1421	/* This function removes the cursed/damned status on equipped
1450	* items.	1422	* items.
1451	*/	1423	*/
1452	int	1424	int
1453	remove_curse (object *op, object *caster, object *spell)	1425	remove_curse (object *op, object *caster, object *spell)
1454	{	1426	{
1455	object *tmp;
1456	int success = 0, was_one = 0;	1427	int success = 0, was_one = 0;
1457		1428
1458	for (tmp = op->inv; tmp; tmp = tmp->below)	1429	for (object *tmp = op->inv; tmp; tmp = tmp->below)
1459	if (QUERY_FLAG (tmp, FLAG_APPLIED) &&	1430	if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
1460	((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||	1431	((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1461	(QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))	1432	(QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1462	{	1433	{
1463	was_one++;	1434	was_one++;
		1435
1464	if (tmp->level <= caster_level (caster, spell))	1436	if (tmp->level <= casting_level (caster, spell))
1465	{	1437	{
1466	success++;	1438	success++;
1467	if (QUERY_FLAG (spell, FLAG_DAMNED))	1439	if (QUERY_FLAG (spell, FLAG_DAMNED))
1468	CLEAR_FLAG (tmp, FLAG_DAMNED);	1440	CLEAR_FLAG (tmp, FLAG_DAMNED);
1469		1441
1470	CLEAR_FLAG (tmp, FLAG_CURSED);	1442	CLEAR_FLAG (tmp, FLAG_CURSED);
1471	CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);	1443	CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);
1472	tmp->value = 0; /* Still can't sell it */	1444	tmp->value = 0; /* Still can't sell it */
1473	if (op->type == PLAYER)	1445
		1446	if (object *pl = tmp->visible_to ())
1474	esrv_send_item (op, tmp);	1447	esrv_update_item (UPD_FLAGS, pl, tmp);
1475	}	1448	}
1476	}	1449	}
1477		1450
1478	if (op->type == PLAYER)	1451	if (op->type == PLAYER)
1479	{	1452	{
…		…
1490		1463
1491	return success;	1464	return success;
1492	}	1465	}
1493		1466
1494	/* Identifies objects in the players inventory/on the ground */	1467	/* Identifies objects in the players inventory/on the ground */
1495
1496	int	1468	int
1497	cast_identify (object *op, object *caster, object *spell)	1469	cast_identify (object *op, object *caster, object *spell)
1498	{	1470	{
1499	object *tmp;	1471	object *tmp;
1500	int success = 0, num_ident;	1472	dynbuf_text &buf = msg_dynbuf; buf.clear ();
1501		1473
1502	num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1474	int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1503
1504	if (num_ident < 1)
1505	num_ident = 1;
1506		1475
1507	for (tmp = op->inv; tmp; tmp = tmp->below)	1476	for (tmp = op->inv; tmp; tmp = tmp->below)
1508	{	1477	{
1509	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))	1478	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1510	{	1479	{
1511	identify (tmp);	1480	identify (tmp);
1512		1481
1513	if (op->type == PLAYER)	1482	if (op->type == PLAYER)
1514	{	1483	{
1515	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));
1516		1485
1517	if (tmp->msg)	1486	if (tmp->msg)
1518	{	1487	buf << "The item has a story:\r" << tmp->msg << "\n\n";
1519	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1520	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1521	}
1522	}	1488	}
1523		1489
1524	num_ident--;
1525	success = 1;
1526	if (!num_ident)	1490	if (!--num_ident)
1527	break;	1491	break;
1528	}	1492	}
1529	}	1493	}
1530		1494
1531	/* If all the power of the spell has been used up, don't go and identify	1495	/* If all the power of the spell has been used up, don't go and identify
…		…
1537	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)	1501	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1538	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))	1502	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1539	{	1503	{
1540	identify (tmp);	1504	identify (tmp);
1541		1505
1542	if (op->type == PLAYER)	1506	if (object *pl = tmp->visible_to ())
1543	{	1507	{
1544	new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground you identified: %s.", long_desc (tmp, op));	1508	buf.printf ("On the ground you identified: %s.\r", long_desc (tmp, op));
1545		1509
1546	if (tmp->msg)	1510	if (tmp->msg)
1547	{	1511	buf << "The item has a story:\r" << tmp->msg << "\n\n";
1548	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1549	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1550	}
1551
1552	esrv_send_item (op, tmp);
1553	}	1512	}
1554		1513
1555	num_ident--;
1556	success = 1;
1557	if (!num_ident)	1514	if (!--num_ident)
1558	break;	1515	break;
1559	}	1516	}
1560	}	1517	}
1561		1518
1562	if (!success)	1519	if (buf.empty ())
1563	new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified.");	1520	{
		1521	op->failmsg ("You can't reach anything unidentified.");
		1522	return 0;
		1523	}
1564	else	1524	else
		1525	{
		1526	if (op->contr)
		1527	op->contr->infobox (MSG_CHANNEL ("identify"), buf);
		1528
1565	spell_effect (spell, op->x, op->y, op->map, op);	1529	spell_effect (spell, op->x, op->y, op->map, op);
1566		1530	return 1;
1567	return success;	1531	}
1568	}	1532	}
1569		1533
1570	int	1534	int
1571	cast_detection (object *op, object *caster, object *spell, object *skill)	1535	cast_detection (object *op, object *caster, object *spell, object *skill)
1572	{	1536	{
…		…
1577		1541
1578	/* We precompute some values here so that we don't have to keep	1542	/* We precompute some values here so that we don't have to keep
1579	* doing it over and over again.	1543	* doing it over and over again.
1580	*/	1544	*/
1581	god = find_god (determine_god (op));	1545	god = find_god (determine_god (op));
1582	level = caster_level (caster, spell);	1546	level = casting_level (caster, spell);
1583	range = spell->range + SP_level_range_adjust (caster, spell);	1547	range = spell->range + SP_level_range_adjust (caster, spell);
1584		1548
1585	if (!skill)	1549	if (!skill)
1586	skill = caster;	1550	skill = caster;
1587		1551
1588	for (x = op->x - range; x <= op->x + range; x++)	1552	unordered_mapwalk (op, -range, -range, range, range)
1589	for (y = op->y - range; y <= op->y + range; y++)
1590	{	1553	{
1591	m = op->map;
1592	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1593	if (mflags & P_OUT_OF_MAP)
1594	continue;
1595
1596	/* For most of the detections, we only detect objects above the	1554	/* For most of the detections, we only detect objects above the
1597	* floor. But this is not true for show invisible.	1555	* floor. But this is not true for show invisible.
1598	* Basically, we just go and find the top object and work	1556	* Basically, we just go and find the top object and work
1599	* down - that is easier than working up.	1557	* down - that is easier than working up.
1600	*/	1558	*/
1601		1559
1602	for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above)	1560	for (last = NULL, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1603	last = tmp;	1561	last = tmp;
1604		1562
1605	/* Shouldn't happen, but if there are no objects on a space, this	1563	/* Shouldn't happen, but if there are no objects on a space, this
1606	* would happen.	1564	* would happen.
1607	*/	1565	*/
1608	if (!last)	1566	if (!last)
1609	continue;	1567	continue;
1610		1568
1611	done_one = 0;	1569	done_one = 0;
1612	floor = 0;	1570	floor = 0;
1613	detect = NULL;	1571	detect = NULL;
1614	for (tmp = last; tmp; tmp = tmp->below)	1572	for (tmp = last; tmp; tmp = tmp->below)
1615	{	1573	{
1616	/* show invisible */	1574	/* show invisible */
1617	if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&	1575	if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&
1618	/* Might there be other objects that we can make visible? */	1576	/* Might there be other objects that we can make visible? */
1619	(tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) ||	1577	(tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER)
1620	(tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) ||	1578	|| (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ))
1621	tmp->type == CF_HANDLE ||	1579	|| tmp->type == T_HANDLE
1622	tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE ||	1580	|| tmp->type == TRAPDOOR
		1581	|| tmp->type == EXIT
		1582	|| tmp->type == HOLE
		1583	|| tmp->type == BUTTON
1623	tmp->type == BUTTON || tmp->type == TELEPORTER ||	1584	|| tmp->type == TELEPORTER
		1585	|| tmp->type == GATE
1624	tmp->type == GATE || tmp->type == LOCKED_DOOR ||	1586	|| tmp->type == LOCKED_DOOR
1625	tmp->type == WEAPON || tmp->type == ALTAR || tmp->type == SIGN ||	1587	|| tmp->type == WEAPON
		1588	|| tmp->type == ALTAR
		1589	|| tmp->type == SIGN
1626	tmp->type == TRIGGER_PEDESTAL || tmp->type == SPECIAL_KEY ||	1590	|| tmp->type == TRIGGER_PEDESTAL
1627	tmp->type == TREASURE || tmp->type == BOOK || tmp->type == HOLY_ALTAR)))	1591	|| tmp->type == SPECIAL_KEY
		1592	|| tmp->type == TREASURE
		1593	|| tmp->type == BOOK
		1594	|| tmp->type == HOLY_ALTAR
		1595	|| tmp->type == CONTAINER)))
1628	{	1596	{
1629	if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)	1597	if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1630	{	1598	{
1631	tmp->invisible = 0;	1599	tmp->invisible = 0;
1632	done_one = 1;	1600	done_one = 1;
1633	}	1601	}
1634	}	1602	}
1635		1603
1636	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1604	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1637	floor = 1;	1605	floor = 1;
1638		1606
1639	/* All detections below this point don't descend beneath the floor,	1607	/* All detections below this point don't descend beneath the floor,
1640	* so just continue on. We could be clever and look at the type of	1608	* so just continue on. We could be clever and look at the type of
1641	* detection to completely break out if we don't care about objects beneath	1609	* detection to completely break out if we don't care about objects beneath
1642	* the floor, but once we get to the floor, not likely a very big issue anyways.	1610	* the floor, but once we get to the floor, not likely a very big issue anyways.
1643	*/	1611	*/
1644	if (floor)	1612	if (floor)
1645	continue;	1613	continue;
1646		1614
1647	/* I had thought about making detect magic and detect curse	1615	/* I had thought about making detect magic and detect curse
1648	* show the flash the magic item like it does for detect monster.	1616	* show the flash the magic item like it does for detect monster.
1649	* however, if the object is within sight, this would then make it	1617	* however, if the object is within sight, this would then make it
1650	* difficult to see what object is magical/cursed, so the	1618	* difficult to see what object is magical/cursed, so the
1651	* effect wouldn't be as apparant.	1619	* effect wouldn't be as apparent.
1652	*/	1620	*/
1653		1621
1654	/* detect magic */	1622	/* detect magic */
1655	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&	1623	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&
1656	!QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))	1624	!QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))
1657	{	1625	{
1658	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1626	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1659	/* make runes more visibile */	1627	/* make runes more visibile */
1660	if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)	1628	if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1661	tmp->stats.Cha /= 4;	1629	tmp->stats.Cha /= 4;
		1630
1662	done_one = 1;	1631	done_one = 1;
1663	}	1632	}
		1633
1664	/* detect monster */	1634	/* detect monster */
1665	if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))	1635	if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))
1666	{	1636	{
1667	done_one = 2;	1637	done_one = 2;
		1638
1668	if (!detect)	1639	if (!detect)
1669	detect = tmp;	1640	detect = tmp;
1670	}	1641	}
		1642
1671	/* Basically, if race is set in the spell, then the creatures race must	1643	/* Basically, if race is set in the spell, then the creatures race must
1672	* match that. if the spell race is set to GOD, then the gods opposing	1644	* match that. if the spell race is set to GOD, then the gods opposing
1673	* race must match.	1645	* race must match.
1674	*/	1646	*/
1675	if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&	1647	if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&
1676	((!strcmp (spell->race, "GOD") && god && god->slaying && strstr (god->slaying, tmp->race)) ||	1648	((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||
1677	(strstr (spell->race, tmp->race))))	1649	spell->race.contains (tmp->race)))
1678	{	1650	{
1679	done_one = 2;	1651	done_one = 2;
		1652
1680	if (!detect)	1653	if (!detect)
1681	detect = tmp;	1654	detect = tmp;
1682	}	1655	}
		1656
1683	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1657	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1684	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))	1658	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1685	{	1659	{
1686	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1660	SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1687	done_one = 1;	1661	done_one = 1;
1688	}	1662	}
1689	} /* for stack of objects on this space */	1663	} /* for stack of objects on this space */
1690		1664
1691	/* Code here puts an effect of the spell on the space, so you can see	1665	/* Code here puts an effect of the spell on the space, so you can see
1692	* where the magic is.	1666	* where the magic is.
1693	*/	1667	*/
1694	if (done_one)	1668	if (done_one)
1695	{	1669	{
1696	object *detect_ob = arch_to_object (spell->other_arch);	1670	object *detect_ob = arch_to_object (spell->other_arch);
1697		1671
1698	/* if this is set, we want to copy the face */	1672	/* if this is set, we want to copy the face */
1699	if (done_one == 2 && detect)	1673	if (done_one == 2 && detect)
1700	{	1674	{
1701	detect_ob->face = detect->face;	1675	detect_ob->face = detect->face;
1702	detect_ob->animation_id = detect->animation_id;	1676	detect_ob->animation_id = detect->animation_id;
1703	detect_ob->anim_speed = detect->anim_speed;	1677	detect_ob->anim_speed = detect->anim_speed;
1704	detect_ob->last_anim = 0;	1678	detect_ob->last_anim = 0;
1705	/* by default, the detect_ob is already animated */	1679	/* by default, the detect_ob is already animated */
1706	if (!QUERY_FLAG (detect, FLAG_ANIMATE))	1680	if (!QUERY_FLAG (detect, FLAG_ANIMATE))
1707	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);	1681	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
1708	}	1682	}
1709		1683
1710	m->insert (detect_ob, nx, ny, op);	1684	m->insert (detect_ob, nx, ny, op);
1711	}	1685	}
1712	} /* for processing the surrounding spaces */	1686	} /* for processing the surrounding spaces */
1713		1687
1714		1688
1715	/* Now process objects in the players inventory if detect curse or magic */	1689	/* Now process objects in the players inventory if detect curse or magic */
1716	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))	1690	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))
1717	{	1691	{
1718	done_one = 0;	1692	done_one = 0;
		1693
1719	for (tmp = op->inv; tmp; tmp = tmp->below)	1694	for (tmp = op->inv; tmp; tmp = tmp->below)
1720	{	1695	{
1721	if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1696	if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1722	{	1697	{
1723	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))	1698	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))
1724	{	1699	{
1725	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1700	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1726	if (op->type == PLAYER)	1701
		1702	if (object *pl = tmp->visible_to ())
1727	esrv_send_item (op, tmp);	1703	esrv_update_item (UPD_FLAGS, pl, tmp);
1728	}	1704	}
		1705
1729	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1706	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1730	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))	1707	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1731	{	1708	{
1732	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1709	SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1733	if (op->type == PLAYER)	1710
		1711	if (object *pl = tmp->visible_to ())
1734	esrv_send_item (op, tmp);	1712	esrv_update_item (UPD_FLAGS, pl, tmp);
1735	}	1713	}
1736	} /* if item is not identified */	1714	} /* if item is not identified */
1737	} /* for the players inventory */	1715	} /* for the players inventory */
1738	} /* if detect magic/curse and object is a player */	1716	} /* if detect magic/curse and object is a player */
		1717
1739	return 1;	1718	return 1;
1740	}	1719	}
1741		1720
1742		1721
1743	/**	1722	/**
…		…
1756		1735
1757	new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");	1736	new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");
1758		1737
1759	if (victim->stats.sp >= victim->stats.maxsp * 2)	1738	if (victim->stats.sp >= victim->stats.maxsp * 2)
1760	{	1739	{
1761	object *tmp;
1762
1763	new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");	1740	new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");
1764
1765	/* Explodes a fireball centered at player */
1766	tmp = get_archetype (EXPLODING_FIREBALL);
1767	tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
1768	tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
1769
1770	tmp->insert_at (victim);
1771	victim->stats.sp = 2 * victim->stats.maxsp;	1741	victim->stats.sp = 2 * victim->stats.maxsp;
		1742	create_exploding_ball_at (victim, caster_level);
1772	}	1743	}
1773	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)	1744	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
1774	new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode.");	1745	new_draw_info (NDI_UNIQUE | NDI_ORANGE, 0, victim, "You feel like your head is going to explode.");
1775	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)	1746	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
1776	new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");	1747	new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
1777	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)	1748	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
1778	{	1749	{
1779	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");	1750	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
…		…
1825	}	1796	}
1826	/* give sp */	1797	/* give sp */
1827	if (spell->stats.dam > 0)	1798	if (spell->stats.dam > 0)
1828	{	1799	{
1829	plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);	1800	plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);
1830	charge_mana_effect (plyr, caster_level (caster, spell));	1801	charge_mana_effect (plyr, casting_level (caster, spell));
1831	return 1;	1802	return 1;
1832	}	1803	}
1833	/* suck sp away. Can't suck sp from yourself */	1804	/* suck sp away. Can't suck sp from yourself */
1834	else if (op != plyr)	1805	else if (op != plyr)
1835	{	1806	{
…		…
1847	/* Player doesn't get full credit */	1818	/* Player doesn't get full credit */
1848	sucked = (sucked * rate) / 100;	1819	sucked = (sucked * rate) / 100;
1849	op->stats.sp += sucked;	1820	op->stats.sp += sucked;
1850	if (sucked > 0)	1821	if (sucked > 0)
1851	{	1822	{
1852	charge_mana_effect (op, caster_level (caster, spell));	1823	charge_mana_effect (op, casting_level (caster, spell));
1853	}	1824	}
1854	}	1825	}
1855	return 1;	1826	return 1;
1856	}	1827	}
1857	return 0;	1828	return 0;
…		…
1933	break;	1904	break;
1934	}	1905	}
1935	}	1906	}
1936	}	1907	}
1937		1908
1938
1939
1940	/* cast_consecrate() - a spell to make an altar your god's */	1909	/* cast_consecrate() - a spell to make an altar your god's */
1941	int	1910	int
1942	cast_consecrate (object *op, object *caster, object *spell)	1911	cast_consecrate (object *op, object *caster, object *spell)
1943	{	1912	{
1944	char buf[MAX_BUF];	1913	char buf[MAX_BUF];
…		…
1956	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1925	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1957	break;	1926	break;
1958	if (tmp->type == HOLY_ALTAR)	1927	if (tmp->type == HOLY_ALTAR)
1959	{	1928	{
1960		1929
1961	if (tmp->level > caster_level (caster, spell))	1930	if (tmp->level > casting_level (caster, spell))
1962	{	1931	{
1963	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);	1932	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);
1964	return 0;	1933	return 0;
1965	}	1934	}
1966	else	1935	else
1967	{	1936	{
1968	/* If we got here, we are consecrating an altar */	1937	/* If we got here, we are consecrating an altar */
1969	sprintf (buf, "Altar of %s", &god->name);	1938	sprintf (buf, "Altar of %s", &god->name);
1970	tmp->name = buf;	1939	tmp->name = buf;
1971	tmp->level = caster_level (caster, spell);	1940	tmp->level = casting_level (caster, spell);
1972	tmp->other_arch = god->arch;	1941	tmp->other_arch = god->arch;
		1942
1973	if (op->type == PLAYER)	1943	if (op->type == PLAYER)
1974	esrv_update_item (UPD_NAME, op, tmp);	1944	esrv_update_item (UPD_NAME, op, tmp);
		1945
1975	new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);	1946	new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
1976	return 1;	1947	return 1;
1977	}	1948	}
1978	}	1949	}
1979	}	1950	}
…		…
1997	object *weapon, *tmp;	1968	object *weapon, *tmp;
1998	char buf[MAX_BUF];	1969	char buf[MAX_BUF];
1999	int a, i;	1970	int a, i;
2000	sint16 x, y;	1971	sint16 x, y;
2001	maptile *m;	1972	maptile *m;
2002	materialtype_t *mt;
2003		1973
2004	if (!spell->other_arch)	1974	if (!spell->other_arch)
2005	{	1975	{
2006	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	1976	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
2007	LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);	1977	LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);
…		…
2018	return 0;	1988	return 0;
2019	}	1989	}
2020		1990
2021	/* if no direction specified, pick one */	1991	/* if no direction specified, pick one */
2022	if (!dir)	1992	if (!dir)
2023	dir = find_free_spot (NULL, op->map, op->x, op->y, 1, 9);	1993	dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);
2024		1994
2025	m = op->map;	1995	m = op->map;
2026	x = op->x + freearr_x[dir];	1996	x = op->x + freearr_x[dir];
2027	y = op->y + freearr_y[dir];	1997	y = op->y + freearr_y[dir];
2028		1998
2029	/* if there's no place to put the golem, abort */	1999	/* if there's no place to put the golem, abort */
2030	if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) ||	2000	if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
2031	((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))	2001	|| ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2032	{	2002	{
2033	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	2003	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
2034	return 0;	2004	return 0;
2035	}	2005	}
2036		2006
…		…
2040	if (!weapon)	2010	if (!weapon)
2041	{	2011	{
2042	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");	2012	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
2043	return 0;	2013	return 0;
2044	}	2014	}
		2015
2045	if (spell->race && strcmp (weapon->arch->archname, spell->race))	2016	if (spell->race && weapon->arch->archname != spell->race)
2046	{	2017	{
2047	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");	2018	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
2048	return 0;	2019	return 0;
2049	}	2020	}
		2021
2050	if (weapon->type != WEAPON)	2022	if (weapon->type != WEAPON)
2051	{	2023	{
2052	new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");	2024	new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");
2053	return 0;	2025	return 0;
2054	}	2026	}
		2027
2055	if (QUERY_FLAG (weapon, FLAG_APPLIED))	2028	if (QUERY_FLAG (weapon, FLAG_APPLIED))
2056	{	2029	{
2057	new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));	2030	new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));
2058	return 0;	2031	return 0;
2059	}	2032	}
2060		2033
2061	if (weapon->nrof > 1)	2034	weapon = weapon->split ();
2062	{
2063	tmp = get_split_ob (weapon, 1);
2064	esrv_send_item (op, weapon);
2065	weapon = tmp;
2066	}
2067		2035
2068	/* create the golem object */	2036	/* create the golem object */
2069	tmp = arch_to_object (spell->other_arch);	2037	tmp = arch_to_object (spell->other_arch);
2070		2038
2071	/* if animated by a player, give the player control of the golem */	2039	/* if animated by a player, give the player control of the golem */
…		…
2076	tmp->set_owner (op);	2044	tmp->set_owner (op);
2077	op->contr->golem = tmp;	2045	op->contr->golem = tmp;
2078	set_spell_skill (op, caster, spell, tmp);	2046	set_spell_skill (op, caster, spell, tmp);
2079		2047
2080	/* Give the weapon to the golem now. A bit of a hack to check the	2048	/* Give the weapon to the golem now. A bit of a hack to check the
2081	* removed flag - it should only be set if get_split_object was	2049	* removed flag - it should only be set if weapon->split was
2082	* used above.	2050	* used above.
2083	*/	2051	*/
2084	if (!QUERY_FLAG (weapon, FLAG_REMOVED))	2052	if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2085	weapon->remove ();	2053	weapon->remove ();
2086		2054
2087	insert_ob_in_ob (weapon, tmp);	2055	tmp->insert (weapon);
2088	esrv_send_item (op, weapon);	2056
2089	/* To do everything necessary to let a golem use the weapon is a pain,	2057	/* To do everything necessary to let a golem use the weapon is a pain,
2090	* so instead, just set it as equipped (otherwise, we need to update	2058	* so instead, just set it as equipped (otherwise, we need to update
2091	* body_info, skills, etc)	2059	* body_info, skills, etc)
2092	*/	2060	*/
2093	SET_FLAG (tmp, FLAG_USE_WEAPON);	2061	SET_FLAG (tmp, FLAG_USE_WEAPON);
…		…
2119		2087
2120	/* attacktype */	2088	/* attacktype */
2121	if (!tmp->attacktype)	2089	if (!tmp->attacktype)
2122	tmp->attacktype = AT_PHYSICAL;	2090	tmp->attacktype = AT_PHYSICAL;
2123		2091
2124	mt = NULL;
2125	if (op->materialname != NULL)
2126	mt = name_to_material (op->materialname);	2092	if (materialtype_t *mt = name_to_material (op->materialname))
2127	if (mt != NULL)
2128	{	2093	{
2129	for (i = 0; i < NROFATTACKS; i++)	2094	for (i = 0; i < NROFATTACKS; i++)
2130	tmp->resist[i] = 50 - (mt->save[i] * 5);	2095	tmp->resist[i] = 50 - (mt->save[i] * 5);
2131	a = mt->save[0];	2096	a = mt->save[0];
2132	}	2097	}
…		…
2134	{	2099	{
2135	for (i = 0; i < NROFATTACKS; i++)	2100	for (i = 0; i < NROFATTACKS; i++)
2136	tmp->resist[i] = 5;	2101	tmp->resist[i] = 5;
2137	a = 10;	2102	a = 10;
2138	}	2103	}
		2104
2139	/* Set weapon's immunity */	2105	/* Set weapon's immunity */
2140	tmp->resist[ATNR_CONFUSION] = 100;	2106	tmp->resist[ATNR_CONFUSION] = 100;
2141	tmp->resist[ATNR_POISON] = 100;	2107	tmp->resist[ATNR_POISON] = 100;
2142	tmp->resist[ATNR_SLOW] = 100;	2108	tmp->resist[ATNR_SLOW] = 100;
2143	tmp->resist[ATNR_PARALYZE] = 100;	2109	tmp->resist[ATNR_PARALYZE] = 100;
…		…
2149		2115
2150	/* Improve weapon's armour value according to best save vs. physical of its material */	2116	/* Improve weapon's armour value according to best save vs. physical of its material */
2151		2117
2152	if (a > 14)	2118	if (a > 14)
2153	a = 14;	2119	a = 14;
		2120
2154	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));	2121	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2155		2122
2156	/* Determine golem's speed */	2123	/* Determine golem's speed */
2157	tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));	2124	tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2158		2125
…		…
2168	tmp->state = weapon->state;	2135	tmp->state = weapon->state;
2169	tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];	2136	tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2170	}	2137	}
2171		2138
2172	/* make experience increase in proportion to the strength of the summoned creature. */	2139	/* make experience increase in proportion to the strength of the summoned creature. */
2173	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));	2140	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));
2174		2141
2175	tmp->speed_left = -1;	2142	tmp->speed_left = -1;
2176	tmp->direction = dir;	2143	tmp->direction = dir;
2177		2144
2178	m->insert (tmp, x, y, op);	2145	m->insert (tmp, x, y, op);
…		…
2182	/* cast_daylight() - changes the map darkness level *lower* */	2149	/* cast_daylight() - changes the map darkness level *lower* */
2183		2150
2184	/* cast_change_map_lightlevel: Was cast_daylight/nightfall.	2151	/* cast_change_map_lightlevel: Was cast_daylight/nightfall.
2185	* This changes the light level for the entire map.	2152	* This changes the light level for the entire map.
2186	*/	2153	*/
2187
2188	int	2154	int
2189	cast_change_map_lightlevel (object *op, object *caster, object *spell)	2155	cast_change_map_lightlevel (object *op, object *caster, object *spell)
2190	{	2156	{
2191	int success;	2157	int success;
2192		2158
…		…
2200	if (spell->stats.dam < 0)	2166	if (spell->stats.dam < 0)
2201	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");	2167	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2202	else	2168	else
2203	new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");	2169	new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2204	}	2170	}
		2171
2205	return success;	2172	return success;
2206	}	2173	}
2207
2208
2209
2210
2211		2174
2212	/* create an aura spell object and put it in the player's inventory.	2175	/* create an aura spell object and put it in the player's inventory.
2213	* as usual, op is player, caster is the object casting the spell,	2176	* as usual, op is player, caster is the object casting the spell,
2214	* spell is the spell object itself.	2177	* spell is the spell object itself.
2215	*/	2178	*/
…		…
2227		2190
2228	new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);	2191	new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2229		2192
2230	new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	2193	new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2231		2194
2232	new_aura->set_owner (op);
2233	set_spell_skill (op, caster, spell, new_aura);	2195	set_spell_skill (op, caster, spell, new_aura);
2234	new_aura->attacktype = spell->attacktype;	2196	new_aura->attacktype = spell->attacktype;
2235		2197
2236	new_aura->level = caster_level (caster, spell);	2198	new_aura->level = casting_level (caster, spell);
		2199
2237	if (refresh)	2200	if (refresh)
2238	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	2201	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2239	else	2202	else
2240	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");	2203	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
		2204
2241	insert_ob_in_ob (new_aura, op);	2205	insert_ob_in_ob (new_aura, op);
		2206	new_aura->set_owner (op);
		2207
2242	return 1;	2208	return 1;
2243	}	2209	}
2244
2245		2210
2246	/* move aura function. An aura is a part of someone's inventory,	2211	/* move aura function. An aura is a part of someone's inventory,
2247	* which he carries with him, but which acts on the map immediately	2212	* which he carries with him, but which acts on the map immediately
2248	* around him.	2213	* around him.
2249	* Aura parameters:	2214	* Aura parameters:
2250	* duration: duration counter.	2215	* duration: duration counter.
2251	* attacktype: aura's attacktype	2216	* attacktype: aura's attacktype
2252	* other_arch: archetype to drop where we attack	2217	* other_arch: archetype to drop where we attack
2253	*/	2218	*/
2254
2255	void	2219	void
2256	move_aura (object *aura)	2220	move_aura (object *aura)
2257	{	2221	{
2258	int i, mflags;
2259	object *env;
2260	maptile *m;
2261
2262	/* auras belong in inventories */	2222	/* auras belong in inventories */
2263	env = aura->env;	2223	object *env = aura->env;
		2224	object *owner = aura->owner;
2264		2225
2265	/* no matter what we've gotta remove the aura...	2226	/* no matter what we've gotta remove the aura...
2266	* we'll put it back if its time isn't up.	2227	* we'll put it back if its time isn't up.
2267	*/	2228	*/
2268	aura->remove ();	2229	aura->remove ();
…		…
2273	aura->destroy ();	2234	aura->destroy ();
2274	return;	2235	return;
2275	}	2236	}
2276		2237
2277	/* auras only exist in inventories */	2238	/* auras only exist in inventories */
2278	if (env == NULL || env->map == NULL)	2239	if (!env || !env->map)
2279	{	2240	{
2280	aura->destroy ();	2241	aura->destroy ();
2281	return;	2242	return;
2282	}	2243	}
2283		2244
2284	/* we need to jump out of the inventory for a bit	2245	/* we need to jump out of the inventory for a bit
2285	* in order to hit the map conveniently.	2246	* in order to hit the map conveniently.
2286	*/	2247	*/
2287	aura->insert_at (env, aura);	2248	aura->insert_at (env, aura);
2288		2249
2289	for (i = 1; i < 9; i++)	2250	for (int i = 1; i < 9; i++)
2290	{	2251	{
2291	sint16 nx, ny;	2252	mapxy pos (env);
		2253	pos.move (i);
2292		2254
2293	nx = aura->x + freearr_x[i];
2294	ny = aura->y + freearr_y[i];
2295	mflags = get_map_flags (env->map, &m, nx, ny, &nx, &ny);
2296
2297	/* Consider the movement tyep of the person with the aura as	2255	/* Consider the movement type of the person with the aura as
2298	* movement type of the aura. Eg, if the player is flying, the aura	2256	* movement type of the aura. Eg, if the player is flying, the aura
2299	* is flying also, if player is walking, it is on the ground, etc.	2257	* is flying also, if player is walking, it is on the ground, etc.
2300	*/	2258	*/
2301	if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))	2259	if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2302	{	2260	{
2303	hit_map (aura, i, aura->attacktype, 0);	2261	hit_map (aura, i, aura->attacktype, 0);
2304		2262
2305	if (aura->other_arch)	2263	if (aura->other_arch)
2306	m->insert (arch_to_object (aura->other_arch), nx, ny, aura);	2264	pos.insert (arch_to_object (aura->other_arch), aura);
2307	}	2265	}
2308	}	2266	}
2309		2267
2310	/* put the aura back in the player's inventory */	2268	/* put the aura back in the player's inventory */
2311	aura->remove ();	2269	env->insert (aura);
2312	insert_ob_in_ob (aura, env);	2270	aura->set_owner (owner);
2313	}	2271	}
2314		2272
2315	/* moves the peacemaker spell.	2273	/* moves the peacemaker spell.
2316	* op is the piece object.	2274	* op is the piece object.
2317	*/	2275	*/
2318
2319	void	2276	void
2320	move_peacemaker (object *op)	2277	move_peacemaker (object *op)
2321	{	2278	{
2322	object *tmp;	2279	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
2323
2324	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2325	{	2280	{
2326	int atk_lev, def_lev;	2281	int atk_lev, def_lev;
2327	object *victim = tmp;	2282	object *victim = tmp->head_ ();
2328		2283
2329	if (tmp->head)
2330	victim = tmp->head;
2331	if (!QUERY_FLAG (victim, FLAG_MONSTER))	2284	if (!QUERY_FLAG (victim, FLAG_MONSTER))
2332	continue;	2285	continue;
		2286
2333	if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))	2287	if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))
2334	continue;	2288	continue;
		2289
2335	if (victim->stats.exp == 0)	2290	if (victim->stats.exp == 0)
2336	continue;	2291	continue;
2337		2292
2338	def_lev = MAX (1, victim->level);	2293	def_lev = MAX (1, victim->level);
2339	atk_lev = MAX (1, op->level);	2294	atk_lev = MAX (1, op->level);
2340		2295
2341	if (rndm (0, atk_lev - 1) > def_lev)	2296	if (rndm (0, atk_lev - 1) > def_lev)
2342	{	2297	{
2343	/* make this sucker peaceful. */	2298	/* make this sucker peaceful. */
2344		2299
		2300	INVOKE_OBJECT (KILL, victim, ARG_OBJECT (op));
2345	change_exp (op->owner, victim->stats.exp, op->skill, 0);	2301	change_exp (op->owner, victim->stats.exp, op->skill, 0);
2346	victim->stats.exp = 0;	2302	victim->stats.exp = 0;
2347	#if 0	2303	#if 0
2348	/* No idea why these were all set to zero - if something	2304	/* No idea why these were all set to zero - if something
2349	* makes this creature agressive, he should still do damage.	2305	* makes this creature agressive, he should still do damage.
…		…
2356	victim->attack_movement = RANDO2;	2312	victim->attack_movement = RANDO2;
2357	SET_FLAG (victim, FLAG_UNAGGRESSIVE);	2313	SET_FLAG (victim, FLAG_UNAGGRESSIVE);
2358	SET_FLAG (victim, FLAG_RUN_AWAY);	2314	SET_FLAG (victim, FLAG_RUN_AWAY);
2359	SET_FLAG (victim, FLAG_RANDOM_MOVE);	2315	SET_FLAG (victim, FLAG_RANDOM_MOVE);
2360	CLEAR_FLAG (victim, FLAG_MONSTER);	2316	CLEAR_FLAG (victim, FLAG_MONSTER);
		2317
2361	if (victim->name)	2318	if (victim->name)
2362	{
2363	new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);	2319	new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2364	}	2320	}
2365	}
2366	}	2321	}
2367	}	2322	}
2368
2369		2323
2370	/* This writes a rune that contains the appropriate message.	2324	/* This writes a rune that contains the appropriate message.
2371	* There really isn't any adjustments we make.	2325	* There really isn't any adjustments we make.
2372	*/	2326	*/
2373
2374	int	2327	int
2375	write_mark (object *op, object *spell, const char *msg)	2328	write_mark (object *op, object *spell, const char *msg)
2376	{	2329	{
2377	char rune[HUGE_BUF];
2378	object *tmp;
2379
2380	if (!msg || msg[0] == 0)	2330	if (!msg || msg[0] == 0)
2381	{	2331	{
2382	new_draw_info (NDI_UNIQUE, 0, op, "Write what?");	2332	new_draw_info (NDI_UNIQUE, 0, op, "Write what?");
2383	return 0;	2333	return 0;
2384	}	2334	}
2385		2335
2386	if (strcasestr_local (msg, "endmsg"))	2336	if (!msg_is_safe (msg))
2387	{	2337	{
2388	new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");	2338	new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");
2389	LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg);	2339	LOG (llevInfo, "write_mark: player %s tried to write bogus rune %s\n", &op->name, msg);
2390	return 0;	2340	return 0;
2391	}	2341	}
		2342
2392	if (!spell->other_arch)	2343	if (!spell->other_arch)
2393	return 0;	2344	return 0;
		2345
2394	tmp = arch_to_object (spell->other_arch);	2346	object *tmp = arch_to_object (spell->other_arch);
2395
2396	snprintf (rune, sizeof (rune), "%s\n", msg);
2397		2347
2398	tmp->race = op->name; /*Save the owner of the rune */	2348	tmp->race = op->name; /*Save the owner of the rune */
2399	tmp->msg = rune;	2349	tmp->msg = msg;
2400		2350
2401	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);	2351	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
		2352
2402	return 1;	2353	return 1;
2403	}	2354	}
		2355

Diff Legend

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