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

Diff Legend

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