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.26 by root, Tue Dec 26 08:55:00 2006 UTC vs.
Revision 1.65 by root, Wed Aug 1 00:26:04 2007 UTC

1	/*	1	/*
2	CrossFire, A Multiplayer game for X-windows	2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3		3	*
		4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
4	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
6		7	*
7	This program is free software; you can redistribute it and/or modify	8	* Crossfire TRT is free software: you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
10	(at your option) any later version.	11	* (at your option) any later version.
11		12	*
12	This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	16	* GNU General Public License for more details.
16		17	*
17	You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	*
20
21	The authors can be reached via e-mail at <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <crossfire@schmorp.de>
22	*/	22	*/
23		23
24	#include <global.h>	24	#include <global.h>
25	#include <object.h>	25	#include <object.h>
26	#include <living.h>	26	#include <living.h>
27	#ifndef __CEXTRACT__
28	# include <sproto.h>	27	#include <sproto.h>
29	#endif
30	#include <spells.h>	28	#include <spells.h>
31	#include <sounds.h>	29	#include <sounds.h>
32		30
33	/* cast_magic_storm: This is really used mostly for spell	31	/* cast_magic_storm: This is really used mostly for spell
34	* fumbles at the like. tmp is the object to propogate.	32	* fumbles at the like. tmp is the object to propogate.
…		…
37	void	35	void
38	cast_magic_storm (object *op, object *tmp, int lvl)	36	cast_magic_storm (object *op, object *tmp, int lvl)
39	{	37	{
40	if (!tmp)	38	if (!tmp)
41	return; /* error */	39	return; /* error */
		40
42	tmp->level = op->level;	41	tmp->level = op->level;
43	tmp->x = op->x;
44	tmp->y = op->y;
45	tmp->range += lvl / 5; /* increase the area of destruction */	42	tmp->range += lvl / 5; /* increase the area of destruction */
46	tmp->duration += lvl / 5;	43	tmp->duration += lvl / 5;
47		44
48	/* Put a cap on duration for this - if the player fails in their	45	/* Put a cap on duration for this - if the player fails in their
49	* apartment, don't want it to go on so long that it kills them	46	* apartment, don't want it to go on so long that it kills them
50	* multiple times. Also, damge already increases with level,	47	* multiple times. Also, damge already increases with level,
51	* so don't really need to increase the duration as much either.	48	* so don't really need to increase the duration as much either.
52	*/	49	*/
53	if (tmp->duration >= 40)	50	if (tmp->duration >= 40)
54	tmp->duration = 40;	51	tmp->duration = 40;
		52
55	tmp->stats.dam = lvl; /* nasty recoils! */	53	tmp->stats.dam = lvl; /* nasty recoils! */
56	tmp->stats.maxhp = tmp->count; /* tract single parent */	54	tmp->stats.maxhp = tmp->count; /* tract single parent */
57	insert_ob_in_map (tmp, op->map, op, 0);
58		55
		56	tmp->insert_at (op, op);
59	}	57	}
60
61		58
62	int	59	int
63	recharge (object *op, object *caster, object *spell_ob)	60	recharge (object *op, object *caster, object *spell_ob)
64	{	61	{
65	object *wand, *tmp;	62	object *wand, *tmp;
…		…
72	return 0;	69	return 0;
73	}	70	}
74	if (!(random_roll (0, 3, op, PREFER_HIGH)))	71	if (!(random_roll (0, 3, op, PREFER_HIGH)))
75	{	72	{
76	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));
77	play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE);	74	op->play_sound (sound_find ("ob_explode"));
78	esrv_del_item (op->contr, wand->count);	75	esrv_del_item (op->contr, wand->count);
79	wand->destroy ();	76	wand->destroy ();
80	tmp = get_archetype ("fireball");	77	tmp = get_archetype ("fireball");
81	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;
		79
82	if (!tmp->stats.dam)	80	if (!tmp->stats.dam)
83	tmp->stats.dam = 1;	81	tmp->stats.dam = 1;
		82
84	tmp->stats.hp = tmp->stats.dam / 2;	83	tmp->stats.hp = tmp->stats.dam / 2;
		84
85	if (tmp->stats.hp < 2)	85	if (tmp->stats.hp < 2)
86	tmp->stats.hp = 2;	86	tmp->stats.hp = 2;
87	tmp->x = op->x;	87
88	tmp->y = op->y;	88	tmp->insert_at (op);
89	insert_ob_in_map (tmp, op->map, NULL, 0);
90	return 1;	89	return 1;
91	}	90	}
92		91
93	ncharges = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob));	92	ncharges = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob));
		93
94	if (wand->inv && wand->inv->level)	94	if (wand->inv && wand->inv->level)
95	ncharges /= wand->inv->level;	95	ncharges /= wand->inv->level;
96	else	96	else
97	{	97	{
98	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand));	98	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand));
99	return 0;	99	return 0;
100	}	100	}
		101
101	if (!ncharges)	102	if (!ncharges)
102	ncharges = 1;	103	ncharges = 1;
103		104
104	wand->stats.food += ncharges;	105	wand->stats.food += ncharges;
105	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));	106	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
		107
106	if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE))	108	if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE))
107	{	109	{
108	SET_FLAG (wand, FLAG_ANIMATE);	110	SET_FLAG (wand, FLAG_ANIMATE);
109	wand->set_speed (wand->arch->clone.speed);	111	wand->set_speed (wand->arch->speed);
110	}	112	}
111		113
112	return 1;	114	return 1;
113	}	115	}
114		116
…		…
120	* great a plus, the default is used.	122	* great a plus, the default is used.
121	* 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
122	* 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
123	* create nonnmagic arrows, or even -1, etc...	125	* create nonnmagic arrows, or even -1, etc...
124	*/	126	*/
125
126	int	127	int
127	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 *stringarg)
128	{	129	{
129	int missile_plus = 0, bonus_plus = 0;	130	int missile_plus = 0, bonus_plus = 0;
130	const char *missile_name;	131	const char *missile_name;
…		…
151	/* If it starts with a letter, presume it is a description */	152	/* If it starts with a letter, presume it is a description */
152	if (isalpha (*stringarg))	153	if (isalpha (*stringarg))
153	{	154	{
154	artifact *al = find_artifactlist (missile->type)->items;	155	artifact *al = find_artifactlist (missile->type)->items;
155		156
156	for (; al != NULL; al = al->next)	157	for (; al; al = al->next)
157	if (!strcasecmp (al->item->name, stringarg))	158	if (!strcasecmp (al->item->name, stringarg))
158	break;	159	break;
159		160
160	if (!al)	161	if (!al)
161	{	162	{
…		…
221	if (stringarg)	222	if (stringarg)
222	{	223	{
223	at = find_archetype_by_object_type_name (FOOD, stringarg);	224	at = find_archetype_by_object_type_name (FOOD, stringarg);
224	if (at == NULL)	225	if (at == NULL)
225	at = find_archetype_by_object_type_name (DRINK, stringarg);	226	at = find_archetype_by_object_type_name (DRINK, stringarg);
226	if (at == NULL || at->clone.stats.food > food_value)	227	if (at == NULL || at->stats.food > food_value)
227	stringarg = NULL;	228	stringarg = NULL;
228	}	229	}
229		230
230	if (!stringarg)	231	if (!stringarg)
231	{	232	{
…		…
237	* We don't use flesh types because the weight values of those need	238	* We don't use flesh types because the weight values of those need
238	* to be altered from the donor.	239	* to be altered from the donor.
239	*/	240	*/
240		241
241	/* We assume the food items don't have multiple parts */	242	/* We assume the food items don't have multiple parts */
242	for (at_tmp = first_archetype; at_tmp != NULL; at_tmp = at_tmp->next)	243	for_all_archetypes (at_tmp)
243	{	244	{
244	if (at_tmp->clone.type == FOOD || at_tmp->clone.type == DRINK)	245	if (at_tmp->type == FOOD || at_tmp->type == DRINK)
245	{	246	{
246	/* Basically, if the food value is something that is creatable	247	/* Basically, if the food value is something that is creatable
247	* under the limits of the spell and it is higher than	248	* under the limits of the spell and it is higher than
248	* the item we have now, take it instead.	249	* the item we have now, take it instead.
249	*/	250	*/
250	if (at_tmp->clone.stats.food <= food_value && (!at || at_tmp->clone.stats.food > at->clone.stats.food))	251	if (at_tmp->stats.food <= food_value
		252	&& (!at
		253	|| at_tmp->stats.food > at->stats.food
		254	|| (at_tmp->stats.food == at->stats.food
		255	&& at_tmp->weight < at->weight)))
251	at = at_tmp;	256	at = at_tmp;
252	}	257	}
253	}	258	}
254	}	259	}
		260
255	/* Pretty unlikely (there are some very low food items), but you never	261	/* Pretty unlikely (there are some very low food items), but you never
256	* know	262	* know
257	*/	263	*/
258	if (!at)	264	if (!at)
259	{	265	{
260	new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");	266	new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");
261	return 0;	267	return 0;
262	}	268	}
263		269
264	food_value /= at->clone.stats.food;	270	food_value /= at->stats.food;
265	new_op = arch_to_object (at);	271	new_op = arch_to_object (at);
266	new_op->nrof = food_value;	272	new_op->nrof = food_value;
267		273
268	new_op->value = 0;	274	new_op->value = 0;
269	if (new_op->nrof < 1)	275	if (new_op->nrof < 1)
…		…
284	if (!dir)	290	if (!dir)
285	{	291	{
286	examine_monster (op, op);	292	examine_monster (op, op);
287	return 1;	293	return 1;
288	}	294	}
		295
289	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	296	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
290	for (r = 1; r < maxrange; r++)	297	for (r = 1; r < maxrange; r++)
291	{	298	{
292	sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];	299	sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];
293		300
…		…
313	examine_monster (op, tmp);	320	examine_monster (op, tmp);
314	return 1;	321	return 1;
315	}	322	}
316	}	323	}
317	}	324	}
		325
318	new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");	326	new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");
319	return 1;	327	return 1;
320	}	328	}
321
322		329
323	/* This checks to see if 'pl' is invisible to 'mon'.	330	/* This checks to see if 'pl' is invisible to 'mon'.
324	* does race check, undead check, etc	331	* does race check, undead check, etc
325	* Returns TRUE if mon can't see pl, false	332	* Returns TRUE if mon can't see pl, false
326	* otherwise. This doesn't check range, walls, etc. It	333	* otherwise. This doesn't check range, walls, etc. It
…		…
370	* normal applies.	377	* normal applies.
371	*/	378	*/
372	int	379	int
373	cast_invisible (object *op, object *caster, object *spell_ob)	380	cast_invisible (object *op, object *caster, object *spell_ob)
374	{	381	{
375	object *tmp;
376
377	if (op->invisible > 1000)	382	if (op->invisible > 1000)
378	{	383	{
379	new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");	384	new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");
380	return 0;	385	return 0;
381	}	386	}
…		…
397	else	402	else
398	op->contr->tmp_invis = 1;	403	op->contr->tmp_invis = 1;
399		404
400	op->contr->hidden = 0;	405	op->contr->hidden = 0;
401	}	406	}
		407
402	if (makes_invisible_to (op, op))	408	if (makes_invisible_to (op, op))
403	new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");	409	new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");
404	else	410	else
405	new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!");	411	new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!");
406		412
407	update_object (op, UP_OBJ_FACE);	413	update_object (op, UP_OBJ_CHANGE);
408		414
409	/* Only search the active objects - only these should actually do	415	/* Only search the active objects - only these should actually do
410	* harm to the player.	416	* harm to the player.
411	*/	417	*/
412	for (tmp = active_objects; tmp != NULL; tmp = tmp->active_next)	418	for_all_actives (tmp)
413	if (tmp->enemy == op)	419	if (tmp->enemy == op)
414	tmp->enemy = NULL;	420	tmp->enemy = 0;
		421
415	return 1;	422	return 1;
416	}	423	}
417		424
418	/* earth to dust spell. Basically destroys earthwalls in the area.	425	/* earth to dust spell. Basically destroys earthwalls in the area.
419	*/	426	*/
…		…
447	next = tmp->above;	454	next = tmp->above;
448	if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))	455	if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
449	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);	456	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
450	}	457	}
451	}	458	}
		459
452	return 1;	460	return 1;
453	}	461	}
454
455		462
456	void	463	void
457	execute_word_of_recall (object *op)	464	execute_word_of_recall (object *op)
458	{	465	{
459	object *wor = op;	466	if (object *pl = op->in_player ())
460		467	{
461	while (op != NULL && op->type != PLAYER)	468	if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
462	op = op->env;
463
464	if (op != NULL && op->map)
465	if ((get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_CLERIC) && (!QUERY_FLAG (op, FLAG_WIZCAST)))
466	new_draw_info (NDI_UNIQUE, 0, op, "You feel something fizzle inside you.");	469	new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
467	else	470	else
		471	{
		472	// remove first so we do not call update_stats
		473	op->remove ();
468	enter_exit (op, wor);	474	pl->enter_exit (op);
		475	}
		476	}
469		477
470	wor->destroy ();	478	op->destroy ();
471	}	479	}
472		480
473	/* Word of recall causes the player to return 'home'.	481	/* Word of recall causes the player to return 'home'.
474	* we put a force into the player object, so that there is a	482	* we put a force into the player object, so that there is a
475	* time delay effect.	483	* time delay effect.
…		…
494	{	502	{
495	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	503	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
496	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");	504	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
497	return 0;	505	return 0;
498	}	506	}
		507
499	time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);	508	time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);
500	if (time < 1)	509	if (time < 1)
501	time = 1;	510	time = 1;
502		511
503	/* value of speed really doesn't make much difference, as long as it is	512	/* value of speed really doesn't make much difference, as long as it is
…		…
511		520
512	/* If we could take advantage of enter_player_savebed() here, it would be	521	/* If we could take advantage of enter_player_savebed() here, it would be
513	* nice, but until the map load fails, we can't.	522	* nice, but until the map load fails, we can't.
514	*/	523	*/
515	EXIT_PATH (dummy) = op->contr->savebed_map;	524	EXIT_PATH (dummy) = op->contr->savebed_map;
516	EXIT_X (dummy) = op->contr->bed_x;	525	EXIT_X (dummy) = op->contr->bed_x;
517	EXIT_Y (dummy) = op->contr->bed_y;	526	EXIT_Y (dummy) = op->contr->bed_y;
518		527
519	(void) insert_ob_in_ob (dummy, op);	528	op->insert (dummy);
		529
520	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");	530	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
		531
521	return 1;	532	return 1;
522	}	533	}
523		534
524	/* cast_wonder	535	/* cast_wonder
525	* wonder is really just a spell that will likely cast another	536	* wonder is really just a spell that will likely cast another
…		…
558	}	569	}
559		570
560	int	571	int
561	perceive_self (object *op)	572	perceive_self (object *op)
562	{	573	{
563	char *cp = describe_item (op, op), buf[MAX_BUF];	574	const char *cp = describe_item (op, op);
564	archetype *at = archetype::find (ARCH_DEPLETION);	575	archetype *at = archetype::find (ARCH_DEPLETION);
565	object *tmp;
566	int i;
567		576
		577	dynbuf_text buf;
		578
		579	if (player *pl = op->contr)
		580	if (object *race = archetype::find (op->race))
		581	buf << "You are a " << (pl->gender ? "female" : "male") << " " << &race->name << ".\n";
		582
568	tmp = find_god (determine_god (op));	583	if (object *god = find_god (determine_god (op)))
569	if (tmp)	584	buf << "You worship " << &god->name << ".\n";
570	new_draw_info_format (NDI_UNIQUE, 0, op, "You worship %s", &tmp->name);
571	else	585	else
572	new_draw_info (NDI_UNIQUE, 0, op, "You worship no god");	586	buf << "You worship no god.\n";
573		587
574	tmp = present_arch_in_ob (at, op);	588	object *tmp = present_arch_in_ob (at, op);
575		589
576	if (*cp == '\0' && tmp == NULL)	590	if (*cp == '\0' && tmp == NULL)
577	new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane");	591	buf << "You feel very mundane. ";
578	else	592	else
579	{	593	{
580	new_draw_info (NDI_UNIQUE, 0, op, "You have:");	594	buf << "You have: " << cp << ".\n";
581	new_draw_info (NDI_UNIQUE, 0, op, cp);	595
582	if (tmp != NULL)	596	if (tmp)
583	{
584	for (i = 0; i < NUM_STATS; i++)	597	for (int i = 0; i < NUM_STATS; i++)
585	{	598	if (tmp->stats.stat (i) < 0)
586	if (get_attr_value (&tmp->stats, i) < 0)	599	buf.printf ("Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
587	{
588	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is depleted by %d", statname[i], -(get_attr_value (&tmp->stats, i)));
589	}
590	}
591	}
592	}	600	}
593		601
594	if (is_dragon_pl (op))	602	if (is_dragon_pl (op))
595	{
596	/* now grab the 'dragon_ability'-force from the player's inventory */	603	/* now grab the 'dragon_ability'-force from the player's inventory */
597	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	604	for (tmp = op->inv; tmp; tmp = tmp->below)
598	{	605	{
599	if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force"))	606	if (tmp->type == FORCE && !strcmp (tmp->arch->archname, "dragon_ability_force"))
600	{	607	{
601	if (tmp->stats.exp == 0)	608	if (tmp->stats.exp == 0)
602	{
603	sprintf (buf, "Your metabolism isn't focused on anything.");	609	buf << "Your metabolism isn't focused on anything.\n";
604	}
605	else	610	else
606	{
607	sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]);	611	buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
608	}	612
609	new_draw_info (NDI_UNIQUE, 0, op, buf);
610	break;	613	break;
611	}	614	}
612	}	615	}
613	}
614	return 1;
615	}
616		616
617	/* int cast_create_town_portal (object *op, object *caster, int dir)	617	buf << '\0'; // zero-terminate
618	*
619	* This function cast the spell of town portal for op
620	*
621	* The spell operates in two passes. During the first one a place
622	* is marked as a destination for the portal. During the second one,
623	* 2 portals are created, one in the position the player cast it and
624	* one in the destination place. The portal are synchronized and 2 forces
625	* are inserted in the player to destruct the portal next time player
626	* creates a new portal pair.
627	* This spell has a side effect that it allows people to meet each other
628	* in a permanent, private, appartements by making a town portal from it
629	* to the town or another public place. So, check if the map is unique and if
630	* so return an error
631	*
632	* Code by Tchize (david.delbecq@usa.net)
633	*/
634	int
635	cast_create_town_portal (object *op, object *caster, object *spell, int dir)
636	{
637	object *dummy, *force, *old_force, *tmp;
638	archetype *perm_portal;
639	char portal_name[1024], portal_message[1024];
640	sint16 exitx, exity;
641	maptile *exitmap;
642	int op_level;
643		618
644	/* Check to see if the map the player is currently on is a per player unique	619	new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ());
645	* map. This can be determined in that per player unique maps have the
646	* full pathname listed.
647	*/
648	if (!strncmp (op->map->path, settings.localdir, strlen (settings.localdir)) && settings.create_home_portals != TRUE)
649	{
650	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You can't cast that here.\n");
651	return 0;
652	}
653
654	/* The first thing to do is to check if we have a marked destination
655	* dummy is used to make a check inventory for the force
656	*/
657	dummy = arch_to_object (spell->other_arch);
658	if (dummy == NULL)
659	{
660	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
661	LOG (llevError, "object::create failed (force in cast_create_town_portal for %s!\n", &op->name);
662	return 0;
663	}
664
665	force = check_inv_recursive (op, dummy);
666
667	if (force == NULL)
668	{
669	/* Here we know there is no destination marked up.
670	* We have 2 things to do:
671	* 1. Mark the destination in the player inventory.
672	* 2. Let the player know it worked.
673	*/
674	dummy->name = op->map->path;
675	EXIT_X (dummy) = op->x;
676	EXIT_Y (dummy) = op->y;
677	insert_ob_in_ob (dummy, op);
678	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You fix this place in your mind.\nYou feel you are able to come here from anywhere.");
679	return 1;
680	}
681
682	dummy->destroy ();
683
684	/* Here we know where the town portal should go to
685	* We should kill any existing portal associated with the player.
686	* Than we should create the 2 portals.
687	* For each of them, we need:
688	* - To create the portal with the name of the player+destination map
689	* - set the owner of the town portal
690	* - To mark the position of the portal in the player's inventory
691	* for easier destruction.
692	*
693	* The mark works has follow:
694	* slaying: Existing town portal
695	* hp, sp : x & y of the associated portal
696	* name : name of the portal
697	* race : map the portal is in
698	*/
699
700	/* First step: killing existing town portals */
701	dummy = get_archetype (spell->race);
702	if (dummy == NULL)
703	{
704	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
705	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
706	return 0;
707	}
708
709	perm_portal = archetype::find (spell->slaying);
710
711	/* To kill a town portal, we go trough the player's inventory,
712	* for each marked portal in player's inventory,
713	* -We try load the associated map (if impossible, consider the portal destructed)
714	* -We find any portal in the specified location.
715	* If it has the good name, we destruct it.
716	* -We destruct the force indicating that portal.
717	*/
718	while ((old_force = check_inv_recursive (op, dummy)))
719	{
720	exitx = EXIT_X (old_force);
721	exity = EXIT_Y (old_force);
722	LOG (llevDebug, "Trying to kill a portal in %s (%d,%d)\n", &old_force->race, exitx, exity);
723
724	if (!strncmp (old_force->race, settings.localdir, strlen (settings.localdir)))
725	exitmap = ready_map_name (old_force->race, MAP_PLAYER_UNIQUE);
726	else
727	exitmap = ready_map_name (old_force->race, 0);
728
729	if (exitmap)
730	{
731	tmp = present_arch (perm_portal, exitmap, exitx, exity);
732	while (tmp)
733	{
734	if (tmp->name == old_force->name)
735	{
736	tmp->destroy ();
737	break;
738	}
739
740	tmp = tmp->above;
741	}
742	}
743
744	old_force->destroy ();
745	LOG (llevDebug, "\n");
746	}
747
748	dummy->destroy ();
749
750	/* Creating the portals.
751	* The very first thing to do is to ensure
752	* access to the destination map.
753	* If we can't, don't fizzle. Simply warn player.
754	* This ensure player pays his mana for the spell
755	* because HE is responsible of forgotting.
756	* 'force' is the destination of the town portal, which we got
757	* from the players inventory above.
758	*/
759
760	/* Ensure exit map is loaded */
761	if (!strncmp (force->name, settings.localdir, strlen (settings.localdir)))
762	exitmap = ready_map_name (force->name, MAP_PLAYER_UNIQUE);
763	else
764	exitmap = ready_map_name (force->name, 0);
765
766	/* If we were unable to load (ex. random map deleted), warn player */
767	if (exitmap == NULL)
768	{
769	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens.\nYou can't remember where to go!?");
770	force->destroy ();
771	return 1;
772	}
773
774	op_level = caster_level (caster, spell);
775	if (op_level < 15)
776	snprintf (portal_message, 1024,
777	"\nThe air moves around you and\na huge smell of ammonia\nsurounds you as you pass\nthrough %s's tiny portal\nPouah!\n",
778	&op->name);
779	else if (op_level < 30)
780	snprintf (portal_message, 1024,
781	"\n%s's portal smells of ozone.\nYou do a lot of movements and finally pass\nthrough the small hole in the air\n", &op->name);
782	else if (op_level < 60)
783	snprintf (portal_message, 1024, "\nA shining door opens in the air in front of you,\nshowing you the path to another place.\n");
784	else
785	snprintf (portal_message, 1024, "\nAs you walk through %s's portal, flowers come out\nfrom the ground around you.\nYou feel awed.\n",
786	&op->name);
787
788	/* Create a portal in front of player
789	* dummy contain the portal and
790	* force contain the track to kill it later
791	*/
792
793	snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name);
794	dummy = get_archetype (spell->slaying); /*The portal */
795	if (dummy == NULL)
796	{
797	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
798	LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
799	return 0;
800	}
801
802	EXIT_PATH (dummy) = force->name;
803	EXIT_X (dummy) = EXIT_X (force);
804	EXIT_Y (dummy) = EXIT_Y (force);
805	dummy->name = dummy->name_pl = portal_name;
806	dummy->msg = portal_message;
807	dummy->race = op->name; /*Save the owner of the portal */
808	cast_create_obj (op, caster, dummy, 0);
809
810	/* Now we need to to create a town portal marker inside the player
811	* object, so on future castings, we can know that he has an active
812	* town portal.
813	*/
814	tmp = get_archetype (spell->race);
815	if (tmp == NULL)
816	{
817	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
818	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
819	return 0;
820	}
821
822	tmp->race = op->map->path;
823	tmp->name = portal_name;
824	EXIT_X (tmp) = dummy->x;
825	EXIT_Y (tmp) = dummy->y;
826	insert_ob_in_ob (tmp, op);
827
828	/* Create a portal in the destination map
829	* dummy contain the portal and
830	* force the track to kill it later
831	* the 'force' variable still contains the 'reminder' of
832	* where this portal goes to.
833	*/
834	snprintf (portal_name, 1024, "%s's portal to %s", &op->name, op->map->path);
835	dummy = get_archetype (spell->slaying); /*The portal */
836	if (dummy == NULL)
837	{
838	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
839	LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
840	return 0;
841	}
842
843	EXIT_PATH (dummy) = op->map->path;
844	EXIT_X (dummy) = op->x;
845	EXIT_Y (dummy) = op->y;
846	dummy->name = dummy->name_pl = portal_name;
847	dummy->msg = portal_message;
848	dummy->x = EXIT_X (force);
849	dummy->y = EXIT_Y (force);
850	dummy->race = op->name; /*Save the owner of the portal */
851	insert_ob_in_map (dummy, exitmap, op, 0);
852
853	/* Now we create another town portal marker that
854	* points back to the one we just made
855	*/
856	tmp = get_archetype (spell->race);
857	if (tmp == NULL)
858	{
859	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
860	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
861	return 0;
862	}
863
864	tmp->race = force->name;
865	tmp->name = portal_name;
866	EXIT_X (tmp) = dummy->x;
867	EXIT_Y (tmp) = dummy->y;
868	insert_ob_in_ob (tmp, op);
869
870	/* Describe the player what happened
871	*/
872	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You see air moving and showing you the way home.");
873	force->destroy ();
874		620
875	return 1;	621	return 1;
876	}	622	}
877		623
878	/* This creates magic walls. Really, it can create most any object,	624	/* This creates magic walls. Really, it can create most any object,
879	* within some reason.	625	* within some reason.
880	*/	626	*/
881	int	627	int
882	magic_wall (object *op, object *caster, int dir, object *spell_ob)	628	magic_wall (object *op, object *caster, int dir, object *spell_ob)
883	{	629	{
884	object *tmp, *tmp2;	630	object *tmp;
885	int i, posblocked, negblocked, maxrange;	631	int i, posblocked, negblocked, maxrange;
886	sint16 x, y;	632	sint16 x, y;
887	maptile *m;	633	maptile *m;
888	const char *name;	634	const char *name;
889	archetype *at;	635	archetype *at;
…		…
922	{	668	{
923	LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);	669	LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
924	new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");	670	new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
925	return 0;	671	return 0;
926	}	672	}
		673
927	tmp = arch_to_object (at);	674	tmp = arch_to_object (at);
928	}	675	}
929	else	676	else
930	{	677	{
931	LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);	678	LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
…		…
965	*/	712	*/
966	if (tmp->type != EARTHWALL) //TODO	713	if (tmp->type != EARTHWALL) //TODO
967	tmp->set_owner (op);	714	tmp->set_owner (op);
968		715
969	set_spell_skill (op, caster, spell_ob, tmp);	716	set_spell_skill (op, caster, spell_ob, tmp);
970	tmp->x = x;
971	tmp->y = y;
972	tmp->level = caster_level (caster, spell_ob) / 2;	717	tmp->level = caster_level (caster, spell_ob) / 2;
973		718
974	name = tmp->name;	719	name = tmp->name;
975	if ((tmp = insert_ob_in_map (tmp, m, op, 0)) == NULL)	720	if (!(tmp = m->insert (tmp, x, y, op)))
976	{	721	{
977	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);	722	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
978	return 0;	723	return 0;
979	}	724	}
980		725
981	/* If this is a spellcasting wall, need to insert the spell object */	726	/* If this is a spellcasting wall, need to insert the spell object */
982	if (tmp->other_arch && tmp->other_arch->clone.type == SPELL)	727	if (tmp->other_arch && tmp->other_arch->type == SPELL)
983	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);	728	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
984		729
985	/* This code causes the wall to extend some distance in	730	/* This code causes the wall to extend some distance in
986	* each direction, or until an obstruction is encountered.	731	* each direction, or until an obstruction is encountered.
987	* posblocked and negblocked help determine how far the	732	* posblocked and negblocked help determine how far the
…		…
1003	m = tmp->map;	748	m = tmp->map;
1004		749
1005	if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&	750	if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
1006	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)	751	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)
1007	{	752	{
1008	tmp2 = tmp->clone ();	753	object *tmp2 = tmp->clone ();
1009	tmp2->x = x;	754	m->insert (tmp2, x, y, op);
1010	tmp2->y = y;	755
1011	insert_ob_in_map (tmp2, m, op, 0);
1012	/* If this is a spellcasting wall, need to insert the spell object */	756	/* If this is a spellcasting wall, need to insert the spell object */
1013	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	757	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1014	insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2);	758	tmp2->insert (arch_to_object (tmp2->other_arch));
1015		759
1016	}	760	}
1017	else	761	else
1018	posblocked = 1;	762	posblocked = 1;
1019		763
…		…
1022	m = tmp->map;	766	m = tmp->map;
1023		767
1024	if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&	768	if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
1025	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)	769	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
1026	{	770	{
1027	tmp2 = tmp->clone ();	771	object *tmp2 = tmp->clone ();
1028	tmp2->x = x;	772	m->insert (tmp2, x, y, op);
1029	tmp2->y = y;	773
1030	insert_ob_in_map (tmp2, m, op, 0);
1031	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	774	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1032	insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2);	775	tmp2->insert (arch_to_object (tmp2->other_arch));
1033	}	776	}
1034	else	777	else
1035	negblocked = 1;	778	negblocked = 1;
1036	}	779	}
1037		780
…		…
1086	{	829	{
1087	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");	830	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
1088	op->contr->count = 0;	831	op->contr->count = 0;
1089	return 0;	832	return 0;
1090	}	833	}
		834
1091	op->contr->count = 0;	835	op->contr->count = 0;
1092		836
1093	/* Remove code that puts player on random space on maps. IMO,	837	/* Remove code that puts player on random space on maps. IMO,
1094	* a lot of maps probably have areas the player should not get to,	838	* a lot of maps probably have areas the player should not get to,
1095	* but may not be marked as NO_MAGIC (as they may be bounded	839	* but may not be marked as NO_MAGIC (as they may be bounded
…		…
1144	return 0;	888	return 0;
1145	}	889	}
1146	}	890	}
1147		891
1148	/* Actually move the player now */	892	/* Actually move the player now */
1149	op->remove ();	893	if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
1150	op->x += freearr_x[dir] * dist;
1151	op->y += freearr_y[dir] * dist;
1152	if ((op = insert_ob_in_map (op, op->map, op, 0)) == NULL)
1153	return 1;	894	return 1;
1154		895
1155	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */	896	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
1156	return 1;	897	return 1;
1157	}	898	}
…		…
1170	object *poison;	911	object *poison;
1171	int heal = 0, success = 0;	912	int heal = 0, success = 0;
1172		913
1173	tmp = find_target_for_friendly_spell (op, dir);	914	tmp = find_target_for_friendly_spell (op, dir);
1174		915
1175	if (tmp == NULL)	916	if (!tmp)
1176	return 0;	917	return 0;
1177		918
1178	/* Figure out how many hp this spell might cure.	919	/* Figure out how many hp this spell might cure.
1179	* could be zero if this spell heals effects, not damage.	920	* could be zero if this spell heals effects, not damage.
1180	*/	921	*/
…		…
1183	heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp;	924	heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp;
1184		925
1185	if (heal)	926	if (heal)
1186	{	927	{
1187	if (tmp->stats.hp >= tmp->stats.maxhp)	928	if (tmp->stats.hp >= tmp->stats.maxhp)
1188	{
1189	new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed.");	929	new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed.");
1190	}
1191	else	930	else
1192	{	931	{
1193	/* See how many points we actually heal. Instead of messages	932	/* See how many points we actually heal. Instead of messages
1194	* based on type of spell, we instead do messages based	933	* based on type of spell, we instead do messages based
1195	* on amount of damage healed.	934	* on amount of damage healed.
…		…
1197	if (heal > (tmp->stats.maxhp - tmp->stats.hp))	936	if (heal > (tmp->stats.maxhp - tmp->stats.hp))
1198	heal = tmp->stats.maxhp - tmp->stats.hp;	937	heal = tmp->stats.maxhp - tmp->stats.hp;
1199	tmp->stats.hp += heal;	938	tmp->stats.hp += heal;
1200		939
1201	if (tmp->stats.hp >= tmp->stats.maxhp)	940	if (tmp->stats.hp >= tmp->stats.maxhp)
1202	{
1203	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");	941	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
1204	}
1205	else if (heal > 50)	942	else if (heal > 50)
1206	{
1207	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");	943	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");
1208	}
1209	else if (heal > 25)	944	else if (heal > 25)
1210	{
1211	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");	945	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");
1212	}
1213	else if (heal > 10)	946	else if (heal > 10)
1214	{
1215	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade.");	947	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade.");
1216	}
1217	else	948	else
1218	{
1219	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close.");	949	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close.");
1220	}	950
1221	success = 1;	951	success = 1;
1222	}	952	}
1223	}	953	}
		954
1224	if (spell->attacktype & AT_DISEASE)	955	if (spell->attacktype & AT_DISEASE)
1225	if (cure_disease (tmp, op))	956	if (cure_disease (tmp, op))
1226	success = 1;	957	success = 1;
1227		958
1228	if (spell->attacktype & AT_POISON)	959	if (spell->attacktype & AT_POISON)
…		…
1234	success = 1;	965	success = 1;
1235	new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");	966	new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
1236	poison->stats.food = 1;	967	poison->stats.food = 1;
1237	}	968	}
1238	}	969	}
		970
1239	if (spell->attacktype & AT_CONFUSION)	971	if (spell->attacktype & AT_CONFUSION)
1240	{	972	{
1241	poison = present_in_ob_by_name (FORCE, "confusion", tmp);	973	poison = present_in_ob_by_name (FORCE, "confusion", tmp);
1242	if (poison)	974	if (poison)
1243	{	975	{
1244	success = 1;	976	success = 1;
1245	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	977	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
1246	poison->duration = 1;	978	poison->duration = 1;
1247	}	979	}
1248	}	980	}
		981
1249	if (spell->attacktype & AT_BLIND)	982	if (spell->attacktype & AT_BLIND)
1250	{	983	{
1251	at = archetype::find ("blindness");	984	at = archetype::find ("blindness");
1252	poison = present_arch_in_ob (at, tmp);	985	poison = present_arch_in_ob (at, tmp);
1253	if (poison)	986	if (poison)
…		…
1255	success = 1;	988	success = 1;
1256	new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");	989	new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
1257	poison->stats.food = 1;	990	poison->stats.food = 1;
1258	}	991	}
1259	}	992	}
		993
1260	if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)	994	if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)
1261	{	995	{
1262	tmp->stats.sp += spell->last_sp;	996	tmp->stats.sp += spell->last_sp;
1263	if (tmp->stats.sp > tmp->stats.maxsp)	997	if (tmp->stats.sp > tmp->stats.maxsp)
1264	tmp->stats.sp = tmp->stats.maxsp;	998	tmp->stats.sp = tmp->stats.maxsp;
1265	success = 1;	999	success = 1;
1266	new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!");	1000	new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!");
1267	}	1001	}
		1002
1268	if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)	1003	if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)
1269	{	1004	{
1270	tmp->stats.grace += spell->last_grace;	1005	tmp->stats.grace += spell->last_grace;
1271	if (tmp->stats.grace > tmp->stats.maxgrace)	1006	if (tmp->stats.grace > tmp->stats.maxgrace)
1272	tmp->stats.grace = tmp->stats.maxgrace;	1007	tmp->stats.grace = tmp->stats.maxgrace;
1273	success = 1;	1008	success = 1;
1274	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");	1009	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1275	}	1010	}
		1011
1276	if (spell->stats.food && tmp->stats.food < 999)	1012	if (spell->stats.food && tmp->stats.food < 999)
1277	{	1013	{
1278	tmp->stats.food += spell->stats.food;	1014	tmp->stats.food += spell->stats.food;
1279	if (tmp->stats.food > 999)	1015	if (tmp->stats.food > 999)
1280	tmp->stats.food = 999;	1016	tmp->stats.food = 999;
1281	success = 1;	1017	success = 1;
1282	/* We could do something a bit better like the messages for healing above */	1018	/* We could do something a bit better like the messages for healing above */
1283	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");	1019	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1284	}	1020	}
		1021
1285	return success;	1022	return success;
1286	}	1023	}
1287
1288		1024
1289	/* This is used for the spells that gain stats. There are no spells	1025	/* This is used for the spells that gain stats. There are no spells
1290	* right now that icnrease wis/int/pow on a temp basis, so no	1026	* right now that icnrease wis/int/pow on a temp basis, so no
1291	* good comments for those.	1027	* good comments for those.
1292	*/	1028	*/
1293	static const char *const no_gain_msgs[NUM_STATS] = {	1029	static const char *const no_gain_msgs[NUM_STATS] = {
1294	"You grow no stronger.",	1030	"You grow no stronger.",
1295	"You grow no more agile.",	1031	"You grow no more agile.",
1296	"You don't feel any healthier.",	1032	"You don't feel any healthier.",
1297	"no wis",	1033	"You didn't grow any more intelligent.",
		1034	"You do not feel any wiser.",
		1035	"You don't feel any more powerful."
1298	"You are no easier to look at.",	1036	"You are no easier to look at.",
1299	"no int",
1300	"no pow"
1301	};	1037	};
1302		1038
1303	int	1039	int
1304	cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)	1040	cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1305	{	1041	{
1306	object *tmp, *tmp2 = NULL;
1307	object *force = NULL;	1042	object *force = NULL;
1308	int i;	1043	int i;
1309		1044
1310	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */	1045	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1311	if (dir != 0)	1046	object *tmp = dir
1312	{
1313	tmp = find_target_for_friendly_spell (op, dir);	1047	? find_target_for_friendly_spell (op, dir)
1314	}	1048	: op;
1315	else
1316	{
1317	tmp = op;
1318	}
1319		1049
1320	if (tmp == NULL)	1050	if (!tmp)
1321	return 0;	1051	return 0;
1322		1052
1323	/* If we've already got a force of this type, don't add a new one. */	1053	/* If we've already got a force of this type, don't add a new one. */
1324	for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below)	1054	for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1325	{	1055	{
1326	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)	1056	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1327	{	1057	{
1328	if (tmp2->name == spell_ob->name)	1058	if (tmp2->name == spell_ob->name)
1329	{	1059	{
…		…
1362	}	1092	}
1363	else	1093	else
1364	{	1094	{
1365	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1095	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1366	}	1096	}
		1097
1367	return 1;	1098	return 1;
1368	}	1099	}
		1100
1369	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1101	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1370	force->speed = 1.0;	1102	force->speed = 1.0;
1371	force->speed_left = -1.0;	1103	force->speed_left = -1.0;
1372	SET_FLAG (force, FLAG_APPLIED);	1104	SET_FLAG (force, FLAG_APPLIED);
1373		1105
…		…
1379	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);	1111	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);
1380	if (force->resist[i] > 100)	1112	if (force->resist[i] > 100)
1381	force->resist[i] = 100;	1113	force->resist[i] = 100;
1382	}	1114	}
1383	}	1115	}
		1116
1384	if (spell_ob->stats.hp)	1117	if (spell_ob->stats.hp)
1385	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);	1118	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
1386		1119
1387	if (tmp->type == PLAYER)	1120	if (tmp->type == PLAYER)
1388	{	1121	{
1389	/* Stat adjustment spells */	1122	/* Stat adjustment spells */
1390	for (i = 0; i < NUM_STATS; i++)	1123	for (i = 0; i < NUM_STATS; i++)
1391	{	1124	{
1392	sint8 stat = get_attr_value (&spell_ob->stats, i), k, sm;	1125	if (sint8 stat = spell_ob->stats.stat (i))
1393
1394	if (stat)
1395	{	1126	{
1396	sm = 0;	1127	sint8 sm = 0;
1397	for (k = 0; k < stat; k++)	1128	for (sint8 k = 0; k < stat; k++)
1398	sm += rndm (1, 3);	1129	sm += rndm (1, 3);
1399		1130
1400	if ((get_attr_value (&tmp->stats, i) + sm) > (15 + 5 * stat))	1131	if (tmp->stats.stat (i) + sm > 15 + 5 * stat)
1401	{	1132	sm = max (0, (15 + 5 * stat) - tmp->stats.stat (i));
1402	sm = (15 + 5 * stat) - get_attr_value (&tmp->stats, i);	1133
1403	if (sm < 0)	1134	force->stats.stat (i) = sm;
1404	sm = 0;	1135
1405	}
1406	set_attr_value (&force->stats, i, sm);
1407	if (!sm)	1136	if (!sm)
1408	new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);	1137	new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);
1409	}	1138	}
1410	}	1139	}
1411	}	1140	}
…		…
1432	force->attacktype = spell_ob->attacktype;	1161	force->attacktype = spell_ob->attacktype;
1433		1162
1434	insert_ob_in_ob (force, tmp);	1163	insert_ob_in_ob (force, tmp);
1435	change_abil (tmp, force); /* Mostly to display any messages */	1164	change_abil (tmp, force); /* Mostly to display any messages */
1436	tmp->update_stats ();	1165	tmp->update_stats ();
		1166
1437	return 1;	1167	return 1;
1438	}	1168	}
1439		1169
1440	/* This used to be part of cast_change_ability, but it really didn't make	1170	/* This used to be part of cast_change_ability, but it really didn't make
1441	* a lot of sense, since most of the values it derives are from the god	1171	* a lot of sense, since most of the values it derives are from the god
1442	* of the caster.	1172	* of the caster.
1443	*/	1173	*/
1444
1445	int	1174	int
1446	cast_bless (object *op, object *caster, object *spell_ob, int dir)	1175	cast_bless (object *op, object *caster, object *spell_ob, int dir)
1447	{	1176	{
1448	int i;	1177	int i;
1449	object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;	1178	object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;
…		…
1543	change_abil (tmp, force); /* Mostly to display any messages */	1272	change_abil (tmp, force); /* Mostly to display any messages */
1544	insert_ob_in_ob (force, tmp);	1273	insert_ob_in_ob (force, tmp);
1545	tmp->update_stats ();	1274	tmp->update_stats ();
1546	return 1;	1275	return 1;
1547	}	1276	}
1548
1549
1550		1277
1551	/* Alchemy code by Mark Wedel	1278	/* Alchemy code by Mark Wedel
1552	*	1279	*
1553	* This code adds a new spell, called alchemy. Alchemy will turn	1280	* This code adds a new spell, called alchemy. Alchemy will turn
1554	* objects to gold nuggets, the value of the gold nuggets being	1281	* objects to gold nuggets, the value of the gold nuggets being
…		…
1564	* For example, if an item is worth 110 gold, you will get	1291	* For example, if an item is worth 110 gold, you will get
1565	* 4 large nuggets, and from 0-10 small nuggets.	1292	* 4 large nuggets, and from 0-10 small nuggets.
1566	*	1293	*
1567	* There is also a chance (1:30) that you will get nothing at all	1294	* There is also a chance (1:30) that you will get nothing at all
1568	* for the object. There is also a maximum weight that will be	1295	* for the object. There is also a maximum weight that will be
1569	* alchemied.	1296	* alchemised.
1570	*/	1297	*/
1571
1572	/* I didn't feel like passing these as arguements to the
1573	* two functions that need them. Real values are put in them
1574	* when the spell is cast, and these are freed when the spell
1575	* is finished.
1576	*/
1577	static object *small, *large;
1578
1579	static void	1298	static void
1580	alchemy_object (object *obj, int *small_nuggets, int *large_nuggets, int *weight)	1299	alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1581	{	1300	{
1582	uint64 value = query_cost (obj, NULL, F_TRUE);	1301	uint64 value = query_cost (obj, NULL, F_TRUE);
1583		1302
1584	/* Give third price when we alchemy money (This should hopefully	1303	/* Give third price when we alchemy money (This should hopefully
1585	* make it so that it isn't worth it to alchemy money, sell	1304	* make it so that it isn't worth it to alchemy money, sell
1586	* the nuggets, alchemy the gold from that, etc.	1305	* the nuggets, alchemy the gold from that, etc.
1587	* Otherwise, give 9 silver on the gold for other objects,	1306	* Otherwise, give 9 silver on the gold for other objects,
1588	* so that it would still be more affordable to haul	1307	* so that it would still be more affordable to haul
1589	* the stuff back to town.	1308	* the stuff back to town.
1590	*/	1309	*/
1591
1592	if (QUERY_FLAG (obj, FLAG_UNPAID))	1310	if (QUERY_FLAG (obj, FLAG_UNPAID))
1593	value = 0;	1311	value = 0;
1594	else if (obj->type == MONEY || obj->type == GEM)	1312	else if (obj->type == MONEY || obj->type == GEM)
1595	value /= 3;	1313	value /= 3;
1596	else	1314	else
1597	value = (value * 9) / 10;	1315	value = value * 9 / 10;
1598		1316
1599	value /= 4; // fix by GHJ, don't understand, pcg
1600
1601	if ((obj->value > 0) && rndm (0, 29))	1317	if (obj->value > 0 && rndm (0, 29))
1602	{	1318	total_value += value;
1603	int count;
1604		1319
1605	count = value / large->value;
1606	*large_nuggets += count;
1607	value -= (uint64) count *(uint64) large->value;
1608
1609	count = value / small->value;
1610	*small_nuggets += count;
1611	}
1612
1613	/* Turn 25 small nuggets into 1 large nugget. If the value
1614	* of large nuggets is not evenly divisable by the small nugget
1615	* value, take off an extra small_nugget (Assuming small_nuggets!=0)
1616	*/
1617	if (*small_nuggets * small->value >= large->value)
1618	{
1619	(*large_nuggets)++;
1620	*small_nuggets -= large->value / small->value;
1621	if (*small_nuggets && large->value % small->value)
1622	(*small_nuggets)--;
1623	}
1624	weight += obj->weight;	1320	total_weight += obj->total_weight ();
		1321
1625	obj->destroy ();	1322	obj->destroy ();
1626	}	1323	}
1627		1324
1628	static void	1325	static void
1629	update_map (object *op, maptile *m, int small_nuggets, int large_nuggets, int x, int y)	1326	update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1630	{	1327	{
1631	object *tmp;
1632	int flag = 0;	1328	int flag = 0;
1633		1329
1634	/* Put any nuggets below the player, but we can only pass this	1330	/* Put any nuggets below the player, but we can only pass this
1635	* flag if we are on the same space as the player	1331	* flag if we are on the same space as the player
1636	*/	1332	*/
1637	if (x == op->x && y == op->y && op->map == m)	1333	if (x == op->x && y == op->y && op->map == m)
1638	flag = INS_BELOW_ORIGINATOR;	1334	flag = INS_BELOW_ORIGINATOR;
1639		1335
1640	if (small_nuggets)	1336	if (small_nuggets)
1641	{	1337	{
1642	tmp = small->clone ();	1338	object *tmp = small->clone ();
1643	tmp->nrof = small_nuggets;	1339	tmp->nrof = small_nuggets;
1644	tmp->x = x;
1645	tmp->y = y;
1646	insert_ob_in_map (tmp, m, op, flag);	1340	m->insert (tmp, x, y, op, flag);
1647	}	1341	}
1648		1342
1649	if (large_nuggets)	1343	if (large_nuggets)
1650	{	1344	{
1651	tmp = large->clone ();	1345	object *tmp = large->clone ();
1652	tmp->nrof = large_nuggets;	1346	tmp->nrof = large_nuggets;
1653	tmp->x = x;
1654	tmp->y = y;
1655	insert_ob_in_map (tmp, m, op, flag);	1347	m->insert (tmp, x, y, op, flag);
1656	}	1348	}
		1349
		1350	if (object *pl = m->at (x, y).player ())
		1351	if (pl->contr->ns)
		1352	pl->contr->ns->look_position = 0;
1657	}	1353	}
1658		1354
1659	int	1355	int
1660	alchemy (object *op, object *caster, object *spell_ob)	1356	alchemy (object *op, object *caster, object *spell_ob)
1661	{	1357	{
1662	int x, y, weight = 0, weight_max, large_nuggets, small_nuggets, mflags;
1663	sint16 nx, ny;
1664	object *next, *tmp;
1665	maptile *mp;
1666
1667	if (op->type != PLAYER)	1358	if (op->type != PLAYER)
1668	return 0;	1359	return 0;
1669		1360
		1361	object *large = get_archetype ("largenugget");
		1362	object *small = get_archetype ("smallnugget");
		1363
1670	/* Put a maximum weight of items that can be alchemied. Limits the power	1364	/* Put a maximum weight of items that can be alchemised. Limits the power
1671	* some, and also prevents people from alcheming every table/chair/clock	1365	* some, and also prevents people from alchemising every table/chair/clock
1672	* in sight	1366	* in sight
1673	*/	1367	*/
1674	weight_max = spell_ob->duration + +SP_level_duration_adjust (caster, spell_ob);	1368	int duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1675	weight_max *= 1000;	1369	int weight_max = duration * 1000;
1676	small = get_archetype ("smallnugget"), large = get_archetype ("largenugget");	1370	uint64 value_max = duration * 1000;
1677		1371
		1372	int weight = 0;
		1373
1678	for (y = op->y - 1; y <= op->y + 1; y++)	1374	for (int y = op->y - 1; y <= op->y + 1; y++)
1679	{	1375	{
1680	for (x = op->x - 1; x <= op->x + 1; x++)	1376	for (int x = op->x - 1; x <= op->x + 1; x++)
1681	{	1377	{
		1378	uint64 value = 0;
		1379
1682	nx = x;	1380	sint16 nx = x;
1683	ny = y;	1381	sint16 ny = y;
1684		1382
1685	mp = op->map;	1383	maptile *mp = op->map;
1686		1384
1687	mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);	1385	int mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);
1688		1386
1689	if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))	1387	if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))
1690	continue;	1388	continue;
1691		1389
1692	/* Treat alchemy a little differently - most spell effects	1390	/* Treat alchemy a little differently - most spell effects
…		…
1694	* ground level effect.	1392	* ground level effect.
1695	*/	1393	*/
1696	if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)	1394	if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)
1697	continue;	1395	continue;
1698		1396
1699	small_nuggets = 0;	1397	for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1700	large_nuggets = 0;
1701
1702	for (tmp = GET_MAP_OB (mp, nx, ny); tmp != NULL; tmp = next)
1703	{	1398	{
1704	next = tmp->above;	1399	next = tmp->above;
		1400
1705	if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&	1401	if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&
1706	!QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))	1402	!QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))
1707	{	1403	{
1708
1709	if (tmp->inv)	1404	if (tmp->inv)
1710	{	1405	{
1711	object *next1, *tmp1;	1406	object *next1, *tmp1;
1712		1407
1713	for (tmp1 = tmp->inv; tmp1 != NULL; tmp1 = next1)	1408	for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1714	{	1409	{
1715	next1 = tmp1->below;	1410	next1 = tmp1->below;
1716	if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&	1411	if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&
1717	!QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))	1412	!QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))
1718	alchemy_object (tmp1, &small_nuggets, &large_nuggets, &weight);	1413	alchemy_object (tmp1, value, weight);
1719	}	1414	}
1720	}	1415	}
		1416
1721	alchemy_object (tmp, &small_nuggets, &large_nuggets, &weight);	1417	alchemy_object (tmp, value, weight);
1722		1418
1723	if (weight > weight_max)	1419	if (weight > weight_max)
1724	{	1420	break;
1725	update_map (op, mp, small_nuggets, large_nuggets, nx, ny);
1726	large->destroy ();
1727	small->destroy ();
1728	return 1;
1729	}	1421	}
1730	} /* is alchemable object */	1422	}
1731	} /* process all objects on this space */	1423
		1424	value = min (value, value_max);
		1425
		1426	uint64 count = value / large->value;
		1427	int large_nuggets = count;
		1428	value -= count * large->value;
		1429
		1430	count = value / small->value;
		1431	int small_nuggets = count;
1732		1432
1733	/* Insert all the nuggets at one time. This probably saves time, but	1433	/* Insert all the nuggets at one time. This probably saves time, but
1734	* it also prevents us from alcheming nuggets that were just created	1434	* it also prevents us from alcheming nuggets that were just created
1735	* with this spell.	1435	* with this spell.
1736	*/	1436	*/
1737	update_map (op, mp, small_nuggets, large_nuggets, nx, ny);	1437	update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny);
1738	}
1739	}
1740		1438
		1439	if (weight > weight_max)
		1440	goto bailout;
		1441	}
		1442	}
		1443
		1444	bailout:
1741	large->destroy ();	1445	large->destroy ();
1742	small->destroy ();	1446	small->destroy ();
1743	/* reset this so that if player standing on a big pile of stuff,
1744	* it is redrawn properly.
1745	*/
1746	op->contr->ns->look_position = 0;
1747	return 1;	1447	return 1;
1748	}	1448	}
1749		1449
1750		1450
1751	/* This function removes the cursed/damned status on equipped	1451	/* This function removes the cursed/damned status on equipped
…		…
1778	}	1478	}
1779		1479
1780	if (op->type == PLAYER)	1480	if (op->type == PLAYER)
1781	{	1481	{
1782	if (success)	1482	if (success)
1783	{
1784	new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");	1483	new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");
1785	}
1786	else	1484	else
1787	{	1485	{
1788	if (was_one)	1486	if (was_one)
1789	new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");	1487	new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");
1790	else	1488	else
…		…
1814	{	1512	{
1815	identify (tmp);	1513	identify (tmp);
1816		1514
1817	if (op->type == PLAYER)	1515	if (op->type == PLAYER)
1818	{	1516	{
1819	new_draw_info_format (NDI_UNIQUE, 0, op, "You have %s.", long_desc (tmp, op));	1517	new_draw_info_format (NDI_UNIQUE, 0, op, "You identified: %s.", long_desc (tmp, op));
1820		1518
1821	if (tmp->msg)	1519	if (tmp->msg)
1822	{	1520	{
1823	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");	1521	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1824	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);	1522	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
…		…
1836	* stuff on the floor. Only identify stuff on the floor if the spell	1534	* stuff on the floor. Only identify stuff on the floor if the spell
1837	* was not fully used.	1535	* was not fully used.
1838	*/	1536	*/
1839	if (num_ident)	1537	if (num_ident)
1840	{	1538	{
1841	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	1539	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1842	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))	1540	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1843	{	1541	{
1844	identify (tmp);	1542	identify (tmp);
1845		1543
1846	if (op->type == PLAYER)	1544	if (op->type == PLAYER)
1847	{	1545	{
1848	new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op));	1546	new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground you identified: %s.", long_desc (tmp, op));
1849		1547
1850	if (tmp->msg)	1548	if (tmp->msg)
1851	{	1549	{
1852	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");	1550	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1853	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);	1551	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
…		…
1997	*/	1695	*/
1998	if (done_one)	1696	if (done_one)
1999	{	1697	{
2000	object *detect_ob = arch_to_object (spell->other_arch);	1698	object *detect_ob = arch_to_object (spell->other_arch);
2001		1699
2002	detect_ob->x = nx;
2003	detect_ob->y = ny;
2004	/* if this is set, we want to copy the face */	1700	/* if this is set, we want to copy the face */
2005	if (done_one == 2 && detect)	1701	if (done_one == 2 && detect)
2006	{	1702	{
2007	detect_ob->face = detect->face;	1703	detect_ob->face = detect->face;
2008	detect_ob->animation_id = detect->animation_id;	1704	detect_ob->animation_id = detect->animation_id;
…		…
2010	detect_ob->last_anim = 0;	1706	detect_ob->last_anim = 0;
2011	/* by default, the detect_ob is already animated */	1707	/* by default, the detect_ob is already animated */
2012	if (!QUERY_FLAG (detect, FLAG_ANIMATE))	1708	if (!QUERY_FLAG (detect, FLAG_ANIMATE))
2013	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);	1709	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
2014	}	1710	}
		1711
2015	insert_ob_in_map (detect_ob, m, op, 0);	1712	m->insert (detect_ob, nx, ny, op);
2016	}	1713	}
2017	} /* for processing the surrounding spaces */	1714	} /* for processing the surrounding spaces */
2018		1715
2019		1716
2020	/* Now process objects in the players inventory if detect curse or magic */	1717	/* Now process objects in the players inventory if detect curse or magic */
…		…
2069		1766
2070	/* Explodes a fireball centered at player */	1767	/* Explodes a fireball centered at player */
2071	tmp = get_archetype (EXPLODING_FIREBALL);	1768	tmp = get_archetype (EXPLODING_FIREBALL);
2072	tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;	1769	tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
2073	tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;	1770	tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
2074	tmp->x = victim->x;	1771
2075	tmp->y = victim->y;	1772	tmp->insert_at (victim);
2076	insert_ob_in_map (tmp, victim->map, NULL, 0);
2077	victim->stats.sp = 2 * victim->stats.maxsp;	1773	victim->stats.sp = 2 * victim->stats.maxsp;
2078	}	1774	}
2079	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)	1775	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
2080	{
2081	new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode.");	1776	new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode.");
2082	}
2083	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)	1777	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
2084	{
2085	new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");	1778	new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
2086	}
2087	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)	1779	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
2088	{	1780	{
2089	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");	1781	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
2090	confuse_player (victim, victim, 99);	1782	confuse_player (victim, victim, 99);
2091	}	1783	}
2092	else if (victim->stats.sp >= victim->stats.maxsp * 1.25)	1784	else if (victim->stats.sp >= victim->stats.maxsp * 1.25)
2093	{
2094	new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");	1785	new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");
2095	}
2096	}	1786	}
2097		1787
2098	/* cast_transfer	1788	/* cast_transfer
2099	* This spell transfers sp from the player to another person.	1789	* This spell transfers sp from the player to another person.
2100	* We let the target go above their normal maximum SP.	1790	* We let the target go above their normal maximum SP.
…		…
2211	/* Basically, if the object is magical and not counterspell,	1901	/* Basically, if the object is magical and not counterspell,
2212	* we will more or less remove the object. Don't counterspell	1902	* we will more or less remove the object. Don't counterspell
2213	* monsters either.	1903	* monsters either.
2214	*/	1904	*/
2215		1905
2216	if (head->attacktype & AT_MAGIC &&	1906	if (head->attacktype & AT_MAGIC
2217	!(head->attacktype & AT_COUNTERSPELL) && !QUERY_FLAG (head, FLAG_MONSTER) && (op->level > head->level))	1907	&& !(head->attacktype & AT_COUNTERSPELL)
		1908	&& !QUERY_FLAG (head, FLAG_MONSTER)
		1909	&& (op->level > head->level))
2218	head->destroy ();	1910	head->destroy ();
2219	else	1911	else
2220	switch (head->type)	1912	switch (head->type)
2221	{	1913	{
2222	case SPELL_EFFECT:	1914	case SPELL_EFFECT:
		1915	// XXX: Don't affect floor spelleffects. See also XXX comment
		1916	// about sanctuary in spell_util.C
		1917	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
		1918	continue;
		1919
2223	if (op->level > head->level)	1920	if (op->level > head->level)
2224	head->destroy ();	1921	head->destroy ();
2225		1922
2226	break;	1923	break;
2227		1924
…		…
2294	* This code was very odd - code early on would only let players use the spell,	1991	* This code was very odd - code early on would only let players use the spell,
2295	* yet the code wass full of player checks. I've presumed that the code	1992	* yet the code wass full of player checks. I've presumed that the code
2296	* that only let players use it was correct, and removed all the other	1993	* that only let players use it was correct, and removed all the other
2297	* player checks. MSW 2003-01-06	1994	* player checks. MSW 2003-01-06
2298	*/	1995	*/
2299
2300	int	1996	int
2301	animate_weapon (object *op, object *caster, object *spell, int dir)	1997	animate_weapon (object *op, object *caster, object *spell, int dir)
2302	{	1998	{
2303	object *weapon, *tmp;	1999	object *weapon, *tmp;
2304	char buf[MAX_BUF];	2000	char buf[MAX_BUF];
2305	int a, i;	2001	int a, i;
2306	sint16 x, y;	2002	sint16 x, y;
2307	maptile *m;	2003	maptile *m;
2308	materialtype_t *mt;
2309		2004
2310	if (!spell->other_arch)	2005	if (!spell->other_arch)
2311	{	2006	{
2312	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	2007	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
2313	LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);	2008	LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);
…		…
2316	/* exit if it's not a player using this spell. */	2011	/* exit if it's not a player using this spell. */
2317	if (op->type != PLAYER)	2012	if (op->type != PLAYER)
2318	return 0;	2013	return 0;
2319		2014
2320	/* if player already has a golem, abort */	2015	/* if player already has a golem, abort */
2321	if (op->contr->ranges[range_golem])	2016	if (object *golem = op->contr->golem)
2322	{	2017	{
2323	control_golem (op->contr->ranges[range_golem], dir);	2018	control_golem (golem, dir);
2324	return 0;	2019	return 0;
2325	}	2020	}
2326		2021
2327	/* if no direction specified, pick one */	2022	/* if no direction specified, pick one */
2328	if (!dir)	2023	if (!dir)
…		…
2332	x = op->x + freearr_x[dir];	2027	x = op->x + freearr_x[dir];
2333	y = op->y + freearr_y[dir];	2028	y = op->y + freearr_y[dir];
2334		2029
2335	/* if there's no place to put the golem, abort */	2030	/* if there's no place to put the golem, abort */
2336	if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) ||	2031	if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) ||
2337	((spell->other_arch->clone.move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->clone.move_type))	2032	((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2338	{	2033	{
2339	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	2034	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
2340	return 0;	2035	return 0;
2341	}	2036	}
2342		2037
…		…
2346	if (!weapon)	2041	if (!weapon)
2347	{	2042	{
2348	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");	2043	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
2349	return 0;	2044	return 0;
2350	}	2045	}
2351	if (spell->race && strcmp (weapon->arch->name, spell->race))	2046	if (spell->race && strcmp (weapon->arch->archname, spell->race))
2352	{	2047	{
2353	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");	2048	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
2354	return 0;	2049	return 0;
2355	}	2050	}
2356	if (weapon->type != WEAPON)	2051	if (weapon->type != WEAPON)
…		…
2374	/* create the golem object */	2069	/* create the golem object */
2375	tmp = arch_to_object (spell->other_arch);	2070	tmp = arch_to_object (spell->other_arch);
2376		2071
2377	/* if animated by a player, give the player control of the golem */	2072	/* if animated by a player, give the player control of the golem */
2378	CLEAR_FLAG (tmp, FLAG_MONSTER);	2073	CLEAR_FLAG (tmp, FLAG_MONSTER);
2379	SET_FLAG (tmp, FLAG_FRIENDLY);
2380	tmp->stats.exp = 0;	2074	tmp->stats.exp = 0;
2381	add_friendly_object (tmp);	2075	add_friendly_object (tmp);
2382	tmp->type = GOLEM;	2076	tmp->type = GOLEM;
2383	tmp->set_owner (op);	2077	tmp->set_owner (op);
		2078	op->contr->golem = tmp;
2384	set_spell_skill (op, caster, spell, tmp);	2079	set_spell_skill (op, caster, spell, tmp);
2385	op->contr->ranges[range_golem] = tmp;
2386	op->contr->shoottype = range_golem;
2387		2080
2388	/* Give the weapon to the golem now. A bit of a hack to check the	2081	/* Give the weapon to the golem now. A bit of a hack to check the
2389	* removed flag - it should only be set if get_split_object was	2082	* removed flag - it should only be set if get_split_object was
2390	* used above.	2083	* used above.
2391	*/	2084	*/
2392	if (!QUERY_FLAG (weapon, FLAG_REMOVED))	2085	if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2393	weapon->remove ();	2086	weapon->remove ();
		2087
2394	insert_ob_in_ob (weapon, tmp);	2088	insert_ob_in_ob (weapon, tmp);
2395	esrv_send_item (op, weapon);	2089	esrv_send_item (op, weapon);
2396	/* To do everything necessary to let a golem use the weapon is a pain,	2090	/* To do everything necessary to let a golem use the weapon is a pain,
2397	* so instead, just set it as equipped (otherwise, we need to update	2091	* so instead, just set it as equipped (otherwise, we need to update
2398	* body_info, skills, etc)	2092	* body_info, skills, etc)
…		…
2426		2120
2427	/* attacktype */	2121	/* attacktype */
2428	if (!tmp->attacktype)	2122	if (!tmp->attacktype)
2429	tmp->attacktype = AT_PHYSICAL;	2123	tmp->attacktype = AT_PHYSICAL;
2430		2124
2431	mt = NULL;
2432	if (op->materialname != NULL)
2433	mt = name_to_material (op->materialname);	2125	if (materialtype_t *mt = name_to_material (op->materialname))
2434	if (mt != NULL)
2435	{	2126	{
2436	for (i = 0; i < NROFATTACKS; i++)	2127	for (i = 0; i < NROFATTACKS; i++)
2437	tmp->resist[i] = 50 - (mt->save[i] * 5);	2128	tmp->resist[i] = 50 - (mt->save[i] * 5);
2438	a = mt->save[0];	2129	a = mt->save[0];
2439	}	2130	}
…		…
2441	{	2132	{
2442	for (i = 0; i < NROFATTACKS; i++)	2133	for (i = 0; i < NROFATTACKS; i++)
2443	tmp->resist[i] = 5;	2134	tmp->resist[i] = 5;
2444	a = 10;	2135	a = 10;
2445	}	2136	}
		2137
2446	/* Set weapon's immunity */	2138	/* Set weapon's immunity */
2447	tmp->resist[ATNR_CONFUSION] = 100;	2139	tmp->resist[ATNR_CONFUSION] = 100;
2448	tmp->resist[ATNR_POISON] = 100;	2140	tmp->resist[ATNR_POISON] = 100;
2449	tmp->resist[ATNR_SLOW] = 100;	2141	tmp->resist[ATNR_SLOW] = 100;
2450	tmp->resist[ATNR_PARALYZE] = 100;	2142	tmp->resist[ATNR_PARALYZE] = 100;
…		…
2456		2148
2457	/* Improve weapon's armour value according to best save vs. physical of its material */	2149	/* Improve weapon's armour value according to best save vs. physical of its material */
2458		2150
2459	if (a > 14)	2151	if (a > 14)
2460	a = 14;	2152	a = 14;
		2153
2461	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));	2154	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2462		2155
2463	/* Determine golem's speed */	2156	/* Determine golem's speed */
2464	tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));	2157	tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2465		2158
…		…
2478		2171
2479	/* make experience increase in proportion to the strength of the summoned creature. */	2172	/* make experience increase in proportion to the strength of the summoned creature. */
2480	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));	2173	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));
2481		2174
2482	tmp->speed_left = -1;	2175	tmp->speed_left = -1;
2483	tmp->x = x;
2484	tmp->y = y;
2485	tmp->direction = dir;	2176	tmp->direction = dir;
2486	insert_ob_in_map (tmp, m, op, 0);	2177
		2178	m->insert (tmp, x, y, op);
2487	return 1;	2179	return 1;
2488	}	2180	}
2489		2181
2490	/* cast_daylight() - changes the map darkness level *lower* */	2182	/* cast_daylight() - changes the map darkness level *lower* */
2491		2183
…		…
2499	int success;	2191	int success;
2500		2192
2501	if (!op->map)	2193	if (!op->map)
2502	return 0; /* shouldnt happen */	2194	return 0; /* shouldnt happen */
2503		2195
2504	success = change_map_light (op->map, spell->stats.dam);	2196	success = op->map->change_map_light (spell->stats.dam);
		2197
2505	if (!success)	2198	if (!success)
2506	{	2199	{
2507	if (spell->stats.dam < 0)	2200	if (spell->stats.dam < 0)
2508	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");	2201	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2509	else	2202	else
…		…
2586	{	2279	{
2587	aura->destroy ();	2280	aura->destroy ();
2588	return;	2281	return;
2589	}	2282	}
2590		2283
2591	aura->x = env->x;
2592	aura->y = env->y;
2593
2594	/* we need to jump out of the inventory for a bit	2284	/* we need to jump out of the inventory for a bit
2595	* in order to hit the map conveniently.	2285	* in order to hit the map conveniently.
2596	*/	2286	*/
2597	insert_ob_in_map (aura, env->map, aura, 0);	2287	aura->insert_at (env, aura);
2598		2288
2599	for (i = 1; i < 9; i++)	2289	for (i = 1; i < 9; i++)
2600	{	2290	{
2601	sint16 nx, ny;	2291	sint16 nx, ny;
2602		2292
…		…
2611	if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))	2301	if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))
2612	{	2302	{
2613	hit_map (aura, i, aura->attacktype, 0);	2303	hit_map (aura, i, aura->attacktype, 0);
2614		2304
2615	if (aura->other_arch)	2305	if (aura->other_arch)
2616	{	2306	m->insert (arch_to_object (aura->other_arch), nx, ny, aura);
2617	object *new_ob;
2618
2619	new_ob = arch_to_object (aura->other_arch);
2620	new_ob->x = nx;
2621	new_ob->y = ny;
2622	insert_ob_in_map (new_ob, m, aura, 0);
2623	}	2307	}
2624	}
2625	}	2308	}
		2309
2626	/* put the aura back in the player's inventory */	2310	/* put the aura back in the player's inventory */
2627	aura->remove ();	2311	aura->remove ();
2628	insert_ob_in_ob (aura, env);	2312	insert_ob_in_ob (aura, env);
2629	}	2313	}
2630		2314
…		…
2711		2395
2712	snprintf (rune, sizeof (rune), "%s\n", msg);	2396	snprintf (rune, sizeof (rune), "%s\n", msg);
2713		2397
2714	tmp->race = op->name; /*Save the owner of the rune */	2398	tmp->race = op->name; /*Save the owner of the rune */
2715	tmp->msg = rune;	2399	tmp->msg = rune;
2716	tmp->x = op->x;	2400
2717	tmp->y = op->y;	2401	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2718	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
2719	return 1;	2402	return 1;
2720	}	2403	}

Diff Legend

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