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.25 by root, Sat Dec 23 09:58:23 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->speed = wand->arch->clone.speed;	111	wand->set_speed (wand->arch->speed);
110	update_ob_speed (wand);
111	}	112	}
		113
112	return 1;	114	return 1;
113	}	115	}
114		116
115	/* Create a missile (nonmagic - magic +4). Will either create bolts or arrows	117	/* Create a missile (nonmagic - magic +4). Will either create bolts or arrows
116	* based on whether a crossbow or bow is equiped. If neither, it defaults to	118	* based on whether a crossbow or bow is equiped. If neither, it defaults to
…		…
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
504	* positive. Lower value may be useful so that the problem doesn't	513	* positive. Lower value may be useful so that the problem doesn't
505	* do anything really odd if it say a -1000 or something.	514	* do anything really odd if it say a -1000 or something.
506	*/	515	*/
507	dummy->speed = 0.002;	516	dummy->set_speed (0.002);
508	update_ob_speed (dummy);
509	dummy->speed_left = -dummy->speed * time;	517	dummy->speed_left = -dummy->speed * time;
510	dummy->type = SPELL_EFFECT;	518	dummy->type = SPELL_EFFECT;
511	dummy->subtype = SP_WORD_OF_RECALL;	519	dummy->subtype = SP_WORD_OF_RECALL;
512		520
513	/* 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
514	* nice, but until the map load fails, we can't.	522	* nice, but until the map load fails, we can't.
515	*/	523	*/
516	EXIT_PATH (dummy) = op->contr->savebed_map;	524	EXIT_PATH (dummy) = op->contr->savebed_map;
517	EXIT_X (dummy) = op->contr->bed_x;	525	EXIT_X (dummy) = op->contr->bed_x;
518	EXIT_Y (dummy) = op->contr->bed_y;	526	EXIT_Y (dummy) = op->contr->bed_y;
519		527
520	(void) insert_ob_in_ob (dummy, op);	528	op->insert (dummy);
		529
521	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
522	return 1;	532	return 1;
523	}	533	}
524		534
525	/* cast_wonder	535	/* cast_wonder
526	* wonder is really just a spell that will likely cast another	536	* wonder is really just a spell that will likely cast another
…		…
559	}	569	}
560		570
561	int	571	int
562	perceive_self (object *op)	572	perceive_self (object *op)
563	{	573	{
564	char *cp = describe_item (op, op), buf[MAX_BUF];	574	const char *cp = describe_item (op, op);
565	archetype *at = archetype::find (ARCH_DEPLETION);	575	archetype *at = archetype::find (ARCH_DEPLETION);
566	object *tmp;
567	int i;
568		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
569	tmp = find_god (determine_god (op));	583	if (object *god = find_god (determine_god (op)))
570	if (tmp)	584	buf << "You worship " << &god->name << ".\n";
571	new_draw_info_format (NDI_UNIQUE, 0, op, "You worship %s", &tmp->name);
572	else	585	else
573	new_draw_info (NDI_UNIQUE, 0, op, "You worship no god");	586	buf << "You worship no god.\n";
574		587
575	tmp = present_arch_in_ob (at, op);	588	object *tmp = present_arch_in_ob (at, op);
576		589
577	if (*cp == '\0' && tmp == NULL)	590	if (*cp == '\0' && tmp == NULL)
578	new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane");	591	buf << "You feel very mundane. ";
579	else	592	else
580	{	593	{
581	new_draw_info (NDI_UNIQUE, 0, op, "You have:");	594	buf << "You have: " << cp << ".\n";
582	new_draw_info (NDI_UNIQUE, 0, op, cp);	595
583	if (tmp != NULL)	596	if (tmp)
584	{
585	for (i = 0; i < NUM_STATS; i++)	597	for (int i = 0; i < NUM_STATS; i++)
586	{	598	if (tmp->stats.stat (i) < 0)
587	if (get_attr_value (&tmp->stats, i) < 0)	599	buf.printf ("Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
588	{
589	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is depleted by %d", statname[i], -(get_attr_value (&tmp->stats, i)));
590	}
591	}
592	}
593	}	600	}
594		601
595	if (is_dragon_pl (op))	602	if (is_dragon_pl (op))
596	{
597	/* now grab the 'dragon_ability'-force from the player's inventory */	603	/* now grab the 'dragon_ability'-force from the player's inventory */
598	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	604	for (tmp = op->inv; tmp; tmp = tmp->below)
599	{	605	{
600	if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force"))	606	if (tmp->type == FORCE && !strcmp (tmp->arch->archname, "dragon_ability_force"))
601	{	607	{
602	if (tmp->stats.exp == 0)	608	if (tmp->stats.exp == 0)
603	{
604	sprintf (buf, "Your metabolism isn't focused on anything.");	609	buf << "Your metabolism isn't focused on anything.\n";
605	}
606	else	610	else
607	{
608	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";
609	}	612
610	new_draw_info (NDI_UNIQUE, 0, op, buf);
611	break;	613	break;
612	}	614	}
613	}	615	}
614	}
615	return 1;
616	}
617		616
618	/* int cast_create_town_portal (object *op, object *caster, int dir)	617	buf << '\0'; // zero-terminate
619	*
620	* This function cast the spell of town portal for op
621	*
622	* The spell operates in two passes. During the first one a place
623	* is marked as a destination for the portal. During the second one,
624	* 2 portals are created, one in the position the player cast it and
625	* one in the destination place. The portal are synchronized and 2 forces
626	* are inserted in the player to destruct the portal next time player
627	* creates a new portal pair.
628	* This spell has a side effect that it allows people to meet each other
629	* in a permanent, private, appartements by making a town portal from it
630	* to the town or another public place. So, check if the map is unique and if
631	* so return an error
632	*
633	* Code by Tchize (david.delbecq@usa.net)
634	*/
635	int
636	cast_create_town_portal (object *op, object *caster, object *spell, int dir)
637	{
638	object *dummy, *force, *old_force, *tmp;
639	archetype *perm_portal;
640	char portal_name[1024], portal_message[1024];
641	sint16 exitx, exity;
642	maptile *exitmap;
643	int op_level;
644		618
645	/* 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 ());
646	* map. This can be determined in that per player unique maps have the
647	* full pathname listed.
648	*/
649	if (!strncmp (op->map->path, settings.localdir, strlen (settings.localdir)) && settings.create_home_portals != TRUE)
650	{
651	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You can't cast that here.\n");
652	return 0;
653	}
654
655	/* The first thing to do is to check if we have a marked destination
656	* dummy is used to make a check inventory for the force
657	*/
658	dummy = arch_to_object (spell->other_arch);
659	if (dummy == NULL)
660	{
661	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
662	LOG (llevError, "object::create failed (force in cast_create_town_portal for %s!\n", &op->name);
663	return 0;
664	}
665
666	force = check_inv_recursive (op, dummy);
667
668	if (force == NULL)
669	{
670	/* Here we know there is no destination marked up.
671	* We have 2 things to do:
672	* 1. Mark the destination in the player inventory.
673	* 2. Let the player know it worked.
674	*/
675	dummy->name = op->map->path;
676	EXIT_X (dummy) = op->x;
677	EXIT_Y (dummy) = op->y;
678	insert_ob_in_ob (dummy, op);
679	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.");
680	return 1;
681	}
682
683	dummy->destroy ();
684
685	/* Here we know where the town portal should go to
686	* We should kill any existing portal associated with the player.
687	* Than we should create the 2 portals.
688	* For each of them, we need:
689	* - To create the portal with the name of the player+destination map
690	* - set the owner of the town portal
691	* - To mark the position of the portal in the player's inventory
692	* for easier destruction.
693	*
694	* The mark works has follow:
695	* slaying: Existing town portal
696	* hp, sp : x & y of the associated portal
697	* name : name of the portal
698	* race : map the portal is in
699	*/
700
701	/* First step: killing existing town portals */
702	dummy = get_archetype (spell->race);
703	if (dummy == NULL)
704	{
705	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
706	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
707	return 0;
708	}
709
710	perm_portal = archetype::find (spell->slaying);
711
712	/* To kill a town portal, we go trough the player's inventory,
713	* for each marked portal in player's inventory,
714	* -We try load the associated map (if impossible, consider the portal destructed)
715	* -We find any portal in the specified location.
716	* If it has the good name, we destruct it.
717	* -We destruct the force indicating that portal.
718	*/
719	while ((old_force = check_inv_recursive (op, dummy)))
720	{
721	exitx = EXIT_X (old_force);
722	exity = EXIT_Y (old_force);
723	LOG (llevDebug, "Trying to kill a portal in %s (%d,%d)\n", &old_force->race, exitx, exity);
724
725	if (!strncmp (old_force->race, settings.localdir, strlen (settings.localdir)))
726	exitmap = ready_map_name (old_force->race, MAP_PLAYER_UNIQUE);
727	else
728	exitmap = ready_map_name (old_force->race, 0);
729
730	if (exitmap)
731	{
732	tmp = present_arch (perm_portal, exitmap, exitx, exity);
733	while (tmp)
734	{
735	if (tmp->name == old_force->name)
736	{
737	tmp->destroy ();
738	break;
739	}
740
741	tmp = tmp->above;
742	}
743	}
744
745	old_force->destroy ();
746	LOG (llevDebug, "\n");
747	}
748
749	dummy->destroy ();
750
751	/* Creating the portals.
752	* The very first thing to do is to ensure
753	* access to the destination map.
754	* If we can't, don't fizzle. Simply warn player.
755	* This ensure player pays his mana for the spell
756	* because HE is responsible of forgotting.
757	* 'force' is the destination of the town portal, which we got
758	* from the players inventory above.
759	*/
760
761	/* Ensure exit map is loaded */
762	if (!strncmp (force->name, settings.localdir, strlen (settings.localdir)))
763	exitmap = ready_map_name (force->name, MAP_PLAYER_UNIQUE);
764	else
765	exitmap = ready_map_name (force->name, 0);
766
767	/* If we were unable to load (ex. random map deleted), warn player */
768	if (exitmap == NULL)
769	{
770	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens.\nYou can't remember where to go!?");
771	force->destroy ();
772	return 1;
773	}
774
775	op_level = caster_level (caster, spell);
776	if (op_level < 15)
777	snprintf (portal_message, 1024,
778	"\nThe air moves around you and\na huge smell of ammonia\nsurounds you as you pass\nthrough %s's tiny portal\nPouah!\n",
779	&op->name);
780	else if (op_level < 30)
781	snprintf (portal_message, 1024,
782	"\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);
783	else if (op_level < 60)
784	snprintf (portal_message, 1024, "\nA shining door opens in the air in front of you,\nshowing you the path to another place.\n");
785	else
786	snprintf (portal_message, 1024, "\nAs you walk through %s's portal, flowers come out\nfrom the ground around you.\nYou feel awed.\n",
787	&op->name);
788
789	/* Create a portal in front of player
790	* dummy contain the portal and
791	* force contain the track to kill it later
792	*/
793
794	snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name);
795	dummy = get_archetype (spell->slaying); /*The portal */
796	if (dummy == NULL)
797	{
798	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
799	LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
800	return 0;
801	}
802
803	EXIT_PATH (dummy) = force->name;
804	EXIT_X (dummy) = EXIT_X (force);
805	EXIT_Y (dummy) = EXIT_Y (force);
806	dummy->name = dummy->name_pl = portal_name;
807	dummy->msg = portal_message;
808	dummy->race = op->name; /*Save the owner of the portal */
809	cast_create_obj (op, caster, dummy, 0);
810
811	/* Now we need to to create a town portal marker inside the player
812	* object, so on future castings, we can know that he has an active
813	* town portal.
814	*/
815	tmp = get_archetype (spell->race);
816	if (tmp == NULL)
817	{
818	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
819	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
820	return 0;
821	}
822
823	tmp->race = op->map->path;
824	tmp->name = portal_name;
825	EXIT_X (tmp) = dummy->x;
826	EXIT_Y (tmp) = dummy->y;
827	insert_ob_in_ob (tmp, op);
828
829	/* Create a portal in the destination map
830	* dummy contain the portal and
831	* force the track to kill it later
832	* the 'force' variable still contains the 'reminder' of
833	* where this portal goes to.
834	*/
835	snprintf (portal_name, 1024, "%s's portal to %s", &op->name, op->map->path);
836	dummy = get_archetype (spell->slaying); /*The portal */
837	if (dummy == NULL)
838	{
839	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
840	LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
841	return 0;
842	}
843
844	EXIT_PATH (dummy) = op->map->path;
845	EXIT_X (dummy) = op->x;
846	EXIT_Y (dummy) = op->y;
847	dummy->name = dummy->name_pl = portal_name;
848	dummy->msg = portal_message;
849	dummy->x = EXIT_X (force);
850	dummy->y = EXIT_Y (force);
851	dummy->race = op->name; /*Save the owner of the portal */
852	insert_ob_in_map (dummy, exitmap, op, 0);
853
854	/* Now we create another town portal marker that
855	* points back to the one we just made
856	*/
857	tmp = get_archetype (spell->race);
858	if (tmp == NULL)
859	{
860	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
861	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
862	return 0;
863	}
864
865	tmp->race = force->name;
866	tmp->name = portal_name;
867	EXIT_X (tmp) = dummy->x;
868	EXIT_Y (tmp) = dummy->y;
869	insert_ob_in_ob (tmp, op);
870
871	/* Describe the player what happened
872	*/
873	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You see air moving and showing you the way home.");
874	force->destroy ();
875		620
876	return 1;	621	return 1;
877	}	622	}
878		623
879	/* This creates magic walls. Really, it can create most any object,	624	/* This creates magic walls. Really, it can create most any object,
880	* within some reason.	625	* within some reason.
881	*/	626	*/
882	int	627	int
883	magic_wall (object *op, object *caster, int dir, object *spell_ob)	628	magic_wall (object *op, object *caster, int dir, object *spell_ob)
884	{	629	{
885	object *tmp, *tmp2;	630	object *tmp;
886	int i, posblocked, negblocked, maxrange;	631	int i, posblocked, negblocked, maxrange;
887	sint16 x, y;	632	sint16 x, y;
888	maptile *m;	633	maptile *m;
889	const char *name;	634	const char *name;
890	archetype *at;	635	archetype *at;
…		…
923	{	668	{
924	LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);	669	LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
925	new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");	670	new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
926	return 0;	671	return 0;
927	}	672	}
		673
928	tmp = arch_to_object (at);	674	tmp = arch_to_object (at);
929	}	675	}
930	else	676	else
931	{	677	{
932	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);
…		…
966	*/	712	*/
967	if (tmp->type != EARTHWALL) //TODO	713	if (tmp->type != EARTHWALL) //TODO
968	tmp->set_owner (op);	714	tmp->set_owner (op);
969		715
970	set_spell_skill (op, caster, spell_ob, tmp);	716	set_spell_skill (op, caster, spell_ob, tmp);
971	tmp->x = x;
972	tmp->y = y;
973	tmp->level = caster_level (caster, spell_ob) / 2;	717	tmp->level = caster_level (caster, spell_ob) / 2;
974		718
975	name = tmp->name;	719	name = tmp->name;
976	if ((tmp = insert_ob_in_map (tmp, m, op, 0)) == NULL)	720	if (!(tmp = m->insert (tmp, x, y, op)))
977	{	721	{
978	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);
979	return 0;	723	return 0;
980	}	724	}
981		725
982	/* 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 */
983	if (tmp->other_arch && tmp->other_arch->clone.type == SPELL)	727	if (tmp->other_arch && tmp->other_arch->type == SPELL)
984	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);	728	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
985		729
986	/* This code causes the wall to extend some distance in	730	/* This code causes the wall to extend some distance in
987	* each direction, or until an obstruction is encountered.	731	* each direction, or until an obstruction is encountered.
988	* posblocked and negblocked help determine how far the	732	* posblocked and negblocked help determine how far the
…		…
1004	m = tmp->map;	748	m = tmp->map;
1005		749
1006	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)) &&
1007	((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)
1008	{	752	{
1009	tmp2 = tmp->clone ();	753	object *tmp2 = tmp->clone ();
1010	tmp2->x = x;	754	m->insert (tmp2, x, y, op);
1011	tmp2->y = y;	755
1012	insert_ob_in_map (tmp2, m, op, 0);
1013	/* 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 */
1014	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	757	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1015	insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2);	758	tmp2->insert (arch_to_object (tmp2->other_arch));
1016		759
1017	}	760	}
1018	else	761	else
1019	posblocked = 1;	762	posblocked = 1;
1020		763
…		…
1023	m = tmp->map;	766	m = tmp->map;
1024		767
1025	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)) &&
1026	((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)
1027	{	770	{
1028	tmp2 = tmp->clone ();	771	object *tmp2 = tmp->clone ();
1029	tmp2->x = x;	772	m->insert (tmp2, x, y, op);
1030	tmp2->y = y;	773
1031	insert_ob_in_map (tmp2, m, op, 0);
1032	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	774	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1033	insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2);	775	tmp2->insert (arch_to_object (tmp2->other_arch));
1034	}	776	}
1035	else	777	else
1036	negblocked = 1;	778	negblocked = 1;
1037	}	779	}
1038		780
…		…
1087	{	829	{
1088	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");
1089	op->contr->count = 0;	831	op->contr->count = 0;
1090	return 0;	832	return 0;
1091	}	833	}
		834
1092	op->contr->count = 0;	835	op->contr->count = 0;
1093		836
1094	/* Remove code that puts player on random space on maps. IMO,	837	/* Remove code that puts player on random space on maps. IMO,
1095	* 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,
1096	* 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
…		…
1145	return 0;	888	return 0;
1146	}	889	}
1147	}	890	}
1148		891
1149	/* Actually move the player now */	892	/* Actually move the player now */
1150	op->remove ();	893	if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
1151	op->x += freearr_x[dir] * dist;
1152	op->y += freearr_y[dir] * dist;
1153	if ((op = insert_ob_in_map (op, op->map, op, 0)) == NULL)
1154	return 1;	894	return 1;
1155		895
1156	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 */
1157	return 1;	897	return 1;
1158	}	898	}
…		…
1171	object *poison;	911	object *poison;
1172	int heal = 0, success = 0;	912	int heal = 0, success = 0;
1173		913
1174	tmp = find_target_for_friendly_spell (op, dir);	914	tmp = find_target_for_friendly_spell (op, dir);
1175		915
1176	if (tmp == NULL)	916	if (!tmp)
1177	return 0;	917	return 0;
1178		918
1179	/* Figure out how many hp this spell might cure.	919	/* Figure out how many hp this spell might cure.
1180	* could be zero if this spell heals effects, not damage.	920	* could be zero if this spell heals effects, not damage.
1181	*/	921	*/
…		…
1184	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;
1185		925
1186	if (heal)	926	if (heal)
1187	{	927	{
1188	if (tmp->stats.hp >= tmp->stats.maxhp)	928	if (tmp->stats.hp >= tmp->stats.maxhp)
1189	{
1190	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.");
1191	}
1192	else	930	else
1193	{	931	{
1194	/* See how many points we actually heal. Instead of messages	932	/* See how many points we actually heal. Instead of messages
1195	* based on type of spell, we instead do messages based	933	* based on type of spell, we instead do messages based
1196	* on amount of damage healed.	934	* on amount of damage healed.
…		…
1198	if (heal > (tmp->stats.maxhp - tmp->stats.hp))	936	if (heal > (tmp->stats.maxhp - tmp->stats.hp))
1199	heal = tmp->stats.maxhp - tmp->stats.hp;	937	heal = tmp->stats.maxhp - tmp->stats.hp;
1200	tmp->stats.hp += heal;	938	tmp->stats.hp += heal;
1201		939
1202	if (tmp->stats.hp >= tmp->stats.maxhp)	940	if (tmp->stats.hp >= tmp->stats.maxhp)
1203	{
1204	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");	941	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
1205	}
1206	else if (heal > 50)	942	else if (heal > 50)
1207	{
1208	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");	943	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");
1209	}
1210	else if (heal > 25)	944	else if (heal > 25)
1211	{
1212	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");	945	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");
1213	}
1214	else if (heal > 10)	946	else if (heal > 10)
1215	{
1216	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.");
1217	}
1218	else	948	else
1219	{
1220	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.");
1221	}	950
1222	success = 1;	951	success = 1;
1223	}	952	}
1224	}	953	}
		954
1225	if (spell->attacktype & AT_DISEASE)	955	if (spell->attacktype & AT_DISEASE)
1226	if (cure_disease (tmp, op))	956	if (cure_disease (tmp, op))
1227	success = 1;	957	success = 1;
1228		958
1229	if (spell->attacktype & AT_POISON)	959	if (spell->attacktype & AT_POISON)
…		…
1235	success = 1;	965	success = 1;
1236	new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");	966	new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
1237	poison->stats.food = 1;	967	poison->stats.food = 1;
1238	}	968	}
1239	}	969	}
		970
1240	if (spell->attacktype & AT_CONFUSION)	971	if (spell->attacktype & AT_CONFUSION)
1241	{	972	{
1242	poison = present_in_ob_by_name (FORCE, "confusion", tmp);	973	poison = present_in_ob_by_name (FORCE, "confusion", tmp);
1243	if (poison)	974	if (poison)
1244	{	975	{
1245	success = 1;	976	success = 1;
1246	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	977	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
1247	poison->duration = 1;	978	poison->duration = 1;
1248	}	979	}
1249	}	980	}
		981
1250	if (spell->attacktype & AT_BLIND)	982	if (spell->attacktype & AT_BLIND)
1251	{	983	{
1252	at = archetype::find ("blindness");	984	at = archetype::find ("blindness");
1253	poison = present_arch_in_ob (at, tmp);	985	poison = present_arch_in_ob (at, tmp);
1254	if (poison)	986	if (poison)
…		…
1256	success = 1;	988	success = 1;
1257	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.");
1258	poison->stats.food = 1;	990	poison->stats.food = 1;
1259	}	991	}
1260	}	992	}
		993
1261	if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)	994	if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)
1262	{	995	{
1263	tmp->stats.sp += spell->last_sp;	996	tmp->stats.sp += spell->last_sp;
1264	if (tmp->stats.sp > tmp->stats.maxsp)	997	if (tmp->stats.sp > tmp->stats.maxsp)
1265	tmp->stats.sp = tmp->stats.maxsp;	998	tmp->stats.sp = tmp->stats.maxsp;
1266	success = 1;	999	success = 1;
1267	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!");
1268	}	1001	}
		1002
1269	if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)	1003	if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)
1270	{	1004	{
1271	tmp->stats.grace += spell->last_grace;	1005	tmp->stats.grace += spell->last_grace;
1272	if (tmp->stats.grace > tmp->stats.maxgrace)	1006	if (tmp->stats.grace > tmp->stats.maxgrace)
1273	tmp->stats.grace = tmp->stats.maxgrace;	1007	tmp->stats.grace = tmp->stats.maxgrace;
1274	success = 1;	1008	success = 1;
1275	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!");
1276	}	1010	}
		1011
1277	if (spell->stats.food && tmp->stats.food < 999)	1012	if (spell->stats.food && tmp->stats.food < 999)
1278	{	1013	{
1279	tmp->stats.food += spell->stats.food;	1014	tmp->stats.food += spell->stats.food;
1280	if (tmp->stats.food > 999)	1015	if (tmp->stats.food > 999)
1281	tmp->stats.food = 999;	1016	tmp->stats.food = 999;
1282	success = 1;	1017	success = 1;
1283	/* 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 */
1284	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");
1285	}	1020	}
		1021
1286	return success;	1022	return success;
1287	}	1023	}
1288
1289		1024
1290	/* 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
1291	* 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
1292	* good comments for those.	1027	* good comments for those.
1293	*/	1028	*/
1294	static const char *const no_gain_msgs[NUM_STATS] = {	1029	static const char *const no_gain_msgs[NUM_STATS] = {
1295	"You grow no stronger.",	1030	"You grow no stronger.",
1296	"You grow no more agile.",	1031	"You grow no more agile.",
1297	"You don't feel any healthier.",	1032	"You don't feel any healthier.",
1298	"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."
1299	"You are no easier to look at.",	1036	"You are no easier to look at.",
1300	"no int",
1301	"no pow"
1302	};	1037	};
1303		1038
1304	int	1039	int
1305	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)
1306	{	1041	{
1307	object *tmp, *tmp2 = NULL;
1308	object *force = NULL;	1042	object *force = NULL;
1309	int i;	1043	int i;
1310		1044
1311	/* 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. */
1312	if (dir != 0)	1046	object *tmp = dir
1313	{
1314	tmp = find_target_for_friendly_spell (op, dir);	1047	? find_target_for_friendly_spell (op, dir)
1315	}	1048	: op;
1316	else
1317	{
1318	tmp = op;
1319	}
1320		1049
1321	if (tmp == NULL)	1050	if (!tmp)
1322	return 0;	1051	return 0;
1323		1052
1324	/* 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. */
1325	for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below)	1054	for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1326	{	1055	{
1327	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)	1056	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1328	{	1057	{
1329	if (tmp2->name == spell_ob->name)	1058	if (tmp2->name == spell_ob->name)
1330	{	1059	{
…		…
1363	}	1092	}
1364	else	1093	else
1365	{	1094	{
1366	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.");
1367	}	1096	}
		1097
1368	return 1;	1098	return 1;
1369	}	1099	}
		1100
1370	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;
1371	force->speed = 1.0;	1102	force->speed = 1.0;
1372	force->speed_left = -1.0;	1103	force->speed_left = -1.0;
1373	SET_FLAG (force, FLAG_APPLIED);	1104	SET_FLAG (force, FLAG_APPLIED);
1374		1105
…		…
1380	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);
1381	if (force->resist[i] > 100)	1112	if (force->resist[i] > 100)
1382	force->resist[i] = 100;	1113	force->resist[i] = 100;
1383	}	1114	}
1384	}	1115	}
		1116
1385	if (spell_ob->stats.hp)	1117	if (spell_ob->stats.hp)
1386	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);
1387		1119
1388	if (tmp->type == PLAYER)	1120	if (tmp->type == PLAYER)
1389	{	1121	{
1390	/* Stat adjustment spells */	1122	/* Stat adjustment spells */
1391	for (i = 0; i < NUM_STATS; i++)	1123	for (i = 0; i < NUM_STATS; i++)
1392	{	1124	{
1393	sint8 stat = get_attr_value (&spell_ob->stats, i), k, sm;	1125	if (sint8 stat = spell_ob->stats.stat (i))
1394
1395	if (stat)
1396	{	1126	{
1397	sm = 0;	1127	sint8 sm = 0;
1398	for (k = 0; k < stat; k++)	1128	for (sint8 k = 0; k < stat; k++)
1399	sm += rndm (1, 3);	1129	sm += rndm (1, 3);
1400		1130
1401	if ((get_attr_value (&tmp->stats, i) + sm) > (15 + 5 * stat))	1131	if (tmp->stats.stat (i) + sm > 15 + 5 * stat)
1402	{	1132	sm = max (0, (15 + 5 * stat) - tmp->stats.stat (i));
1403	sm = (15 + 5 * stat) - get_attr_value (&tmp->stats, i);	1133
1404	if (sm < 0)	1134	force->stats.stat (i) = sm;
1405	sm = 0;	1135
1406	}
1407	set_attr_value (&force->stats, i, sm);
1408	if (!sm)	1136	if (!sm)
1409	new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);	1137	new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);
1410	}	1138	}
1411	}	1139	}
1412	}	1140	}
…		…
1433	force->attacktype = spell_ob->attacktype;	1161	force->attacktype = spell_ob->attacktype;
1434		1162
1435	insert_ob_in_ob (force, tmp);	1163	insert_ob_in_ob (force, tmp);
1436	change_abil (tmp, force); /* Mostly to display any messages */	1164	change_abil (tmp, force); /* Mostly to display any messages */
1437	tmp->update_stats ();	1165	tmp->update_stats ();
		1166
1438	return 1;	1167	return 1;
1439	}	1168	}
1440		1169
1441	/* 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
1442	* 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
1443	* of the caster.	1172	* of the caster.
1444	*/	1173	*/
1445
1446	int	1174	int
1447	cast_bless (object *op, object *caster, object *spell_ob, int dir)	1175	cast_bless (object *op, object *caster, object *spell_ob, int dir)
1448	{	1176	{
1449	int i;	1177	int i;
1450	object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;	1178	object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;
…		…
1544	change_abil (tmp, force); /* Mostly to display any messages */	1272	change_abil (tmp, force); /* Mostly to display any messages */
1545	insert_ob_in_ob (force, tmp);	1273	insert_ob_in_ob (force, tmp);
1546	tmp->update_stats ();	1274	tmp->update_stats ();
1547	return 1;	1275	return 1;
1548	}	1276	}
1549
1550
1551		1277
1552	/* Alchemy code by Mark Wedel	1278	/* Alchemy code by Mark Wedel
1553	*	1279	*
1554	* This code adds a new spell, called alchemy. Alchemy will turn	1280	* This code adds a new spell, called alchemy. Alchemy will turn
1555	* objects to gold nuggets, the value of the gold nuggets being	1281	* objects to gold nuggets, the value of the gold nuggets being
…		…
1565	* 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
1566	* 4 large nuggets, and from 0-10 small nuggets.	1292	* 4 large nuggets, and from 0-10 small nuggets.
1567	*	1293	*
1568	* 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
1569	* 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
1570	* alchemied.	1296	* alchemised.
1571	*/	1297	*/
1572
1573	/* I didn't feel like passing these as arguements to the
1574	* two functions that need them. Real values are put in them
1575	* when the spell is cast, and these are freed when the spell
1576	* is finished.
1577	*/
1578	static object *small, *large;
1579
1580	static void	1298	static void
1581	alchemy_object (object *obj, int *small_nuggets, int *large_nuggets, int *weight)	1299	alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1582	{	1300	{
1583	uint64 value = query_cost (obj, NULL, F_TRUE);	1301	uint64 value = query_cost (obj, NULL, F_TRUE);
1584		1302
1585	/* Give third price when we alchemy money (This should hopefully	1303	/* Give third price when we alchemy money (This should hopefully
1586	* 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
1587	* the nuggets, alchemy the gold from that, etc.	1305	* the nuggets, alchemy the gold from that, etc.
1588	* Otherwise, give 9 silver on the gold for other objects,	1306	* Otherwise, give 9 silver on the gold for other objects,
1589	* so that it would still be more affordable to haul	1307	* so that it would still be more affordable to haul
1590	* the stuff back to town.	1308	* the stuff back to town.
1591	*/	1309	*/
1592
1593	if (QUERY_FLAG (obj, FLAG_UNPAID))	1310	if (QUERY_FLAG (obj, FLAG_UNPAID))
1594	value = 0;	1311	value = 0;
1595	else if (obj->type == MONEY || obj->type == GEM)	1312	else if (obj->type == MONEY || obj->type == GEM)
1596	value /= 3;	1313	value /= 3;
1597	else	1314	else
1598	value = (value * 9) / 10;	1315	value = value * 9 / 10;
1599		1316
1600	value /= 4; // fix by GHJ, don't understand, pcg
1601
1602	if ((obj->value > 0) && rndm (0, 29))	1317	if (obj->value > 0 && rndm (0, 29))
1603	{	1318	total_value += value;
1604	int count;
1605		1319
1606	count = value / large->value;
1607	*large_nuggets += count;
1608	value -= (uint64) count *(uint64) large->value;
1609
1610	count = value / small->value;
1611	*small_nuggets += count;
1612	}
1613
1614	/* Turn 25 small nuggets into 1 large nugget. If the value
1615	* of large nuggets is not evenly divisable by the small nugget
1616	* value, take off an extra small_nugget (Assuming small_nuggets!=0)
1617	*/
1618	if (*small_nuggets * small->value >= large->value)
1619	{
1620	(*large_nuggets)++;
1621	*small_nuggets -= large->value / small->value;
1622	if (*small_nuggets && large->value % small->value)
1623	(*small_nuggets)--;
1624	}
1625	weight += obj->weight;	1320	total_weight += obj->total_weight ();
		1321
1626	obj->destroy ();	1322	obj->destroy ();
1627	}	1323	}
1628		1324
1629	static void	1325	static void
1630	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)
1631	{	1327	{
1632	object *tmp;
1633	int flag = 0;	1328	int flag = 0;
1634		1329
1635	/* 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
1636	* flag if we are on the same space as the player	1331	* flag if we are on the same space as the player
1637	*/	1332	*/
1638	if (x == op->x && y == op->y && op->map == m)	1333	if (x == op->x && y == op->y && op->map == m)
1639	flag = INS_BELOW_ORIGINATOR;	1334	flag = INS_BELOW_ORIGINATOR;
1640		1335
1641	if (small_nuggets)	1336	if (small_nuggets)
1642	{	1337	{
1643	tmp = small->clone ();	1338	object *tmp = small->clone ();
1644	tmp->nrof = small_nuggets;	1339	tmp->nrof = small_nuggets;
1645	tmp->x = x;
1646	tmp->y = y;
1647	insert_ob_in_map (tmp, m, op, flag);	1340	m->insert (tmp, x, y, op, flag);
1648	}	1341	}
1649		1342
1650	if (large_nuggets)	1343	if (large_nuggets)
1651	{	1344	{
1652	tmp = large->clone ();	1345	object *tmp = large->clone ();
1653	tmp->nrof = large_nuggets;	1346	tmp->nrof = large_nuggets;
1654	tmp->x = x;
1655	tmp->y = y;
1656	insert_ob_in_map (tmp, m, op, flag);	1347	m->insert (tmp, x, y, op, flag);
1657	}	1348	}
		1349
		1350	if (object *pl = m->at (x, y).player ())
		1351	if (pl->contr->ns)
		1352	pl->contr->ns->look_position = 0;
1658	}	1353	}
1659		1354
1660	int	1355	int
1661	alchemy (object *op, object *caster, object *spell_ob)	1356	alchemy (object *op, object *caster, object *spell_ob)
1662	{	1357	{
1663	int x, y, weight = 0, weight_max, large_nuggets, small_nuggets, mflags;
1664	sint16 nx, ny;
1665	object *next, *tmp;
1666	maptile *mp;
1667
1668	if (op->type != PLAYER)	1358	if (op->type != PLAYER)
1669	return 0;	1359	return 0;
1670		1360
		1361	object *large = get_archetype ("largenugget");
		1362	object *small = get_archetype ("smallnugget");
		1363
1671	/* 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
1672	* some, and also prevents people from alcheming every table/chair/clock	1365	* some, and also prevents people from alchemising every table/chair/clock
1673	* in sight	1366	* in sight
1674	*/	1367	*/
1675	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);
1676	weight_max *= 1000;	1369	int weight_max = duration * 1000;
1677	small = get_archetype ("smallnugget"), large = get_archetype ("largenugget");	1370	uint64 value_max = duration * 1000;
1678		1371
		1372	int weight = 0;
		1373
1679	for (y = op->y - 1; y <= op->y + 1; y++)	1374	for (int y = op->y - 1; y <= op->y + 1; y++)
1680	{	1375	{
1681	for (x = op->x - 1; x <= op->x + 1; x++)	1376	for (int x = op->x - 1; x <= op->x + 1; x++)
1682	{	1377	{
		1378	uint64 value = 0;
		1379
1683	nx = x;	1380	sint16 nx = x;
1684	ny = y;	1381	sint16 ny = y;
1685		1382
1686	mp = op->map;	1383	maptile *mp = op->map;
1687		1384
1688	mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);	1385	int mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);
1689		1386
1690	if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))	1387	if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))
1691	continue;	1388	continue;
1692		1389
1693	/* Treat alchemy a little differently - most spell effects	1390	/* Treat alchemy a little differently - most spell effects
…		…
1695	* ground level effect.	1392	* ground level effect.
1696	*/	1393	*/
1697	if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)	1394	if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)
1698	continue;	1395	continue;
1699		1396
1700	small_nuggets = 0;	1397	for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1701	large_nuggets = 0;
1702
1703	for (tmp = GET_MAP_OB (mp, nx, ny); tmp != NULL; tmp = next)
1704	{	1398	{
1705	next = tmp->above;	1399	next = tmp->above;
		1400
1706	if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&	1401	if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&
1707	!QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))	1402	!QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))
1708	{	1403	{
1709
1710	if (tmp->inv)	1404	if (tmp->inv)
1711	{	1405	{
1712	object *next1, *tmp1;	1406	object *next1, *tmp1;
1713		1407
1714	for (tmp1 = tmp->inv; tmp1 != NULL; tmp1 = next1)	1408	for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1715	{	1409	{
1716	next1 = tmp1->below;	1410	next1 = tmp1->below;
1717	if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&	1411	if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&
1718	!QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))	1412	!QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))
1719	alchemy_object (tmp1, &small_nuggets, &large_nuggets, &weight);	1413	alchemy_object (tmp1, value, weight);
1720	}	1414	}
1721	}	1415	}
		1416
1722	alchemy_object (tmp, &small_nuggets, &large_nuggets, &weight);	1417	alchemy_object (tmp, value, weight);
1723		1418
1724	if (weight > weight_max)	1419	if (weight > weight_max)
1725	{	1420	break;
1726	update_map (op, mp, small_nuggets, large_nuggets, nx, ny);
1727	large->destroy ();
1728	small->destroy ();
1729	return 1;
1730	}	1421	}
1731	} /* is alchemable object */	1422	}
1732	} /* 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;
1733		1432
1734	/* 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
1735	* it also prevents us from alcheming nuggets that were just created	1434	* it also prevents us from alcheming nuggets that were just created
1736	* with this spell.	1435	* with this spell.
1737	*/	1436	*/
1738	update_map (op, mp, small_nuggets, large_nuggets, nx, ny);	1437	update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny);
1739	}
1740	}
1741		1438
		1439	if (weight > weight_max)
		1440	goto bailout;
		1441	}
		1442	}
		1443
		1444	bailout:
1742	large->destroy ();	1445	large->destroy ();
1743	small->destroy ();	1446	small->destroy ();
1744	/* reset this so that if player standing on a big pile of stuff,
1745	* it is redrawn properly.
1746	*/
1747	op->contr->ns->look_position = 0;
1748	return 1;	1447	return 1;
1749	}	1448	}
1750		1449
1751		1450
1752	/* This function removes the cursed/damned status on equipped	1451	/* This function removes the cursed/damned status on equipped
…		…
1779	}	1478	}
1780		1479
1781	if (op->type == PLAYER)	1480	if (op->type == PLAYER)
1782	{	1481	{
1783	if (success)	1482	if (success)
1784	{
1785	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.");
1786	}
1787	else	1484	else
1788	{	1485	{
1789	if (was_one)	1486	if (was_one)
1790	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.");
1791	else	1488	else
…		…
1815	{	1512	{
1816	identify (tmp);	1513	identify (tmp);
1817		1514
1818	if (op->type == PLAYER)	1515	if (op->type == PLAYER)
1819	{	1516	{
1820	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));
1821		1518
1822	if (tmp->msg)	1519	if (tmp->msg)
1823	{	1520	{
1824	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:");
1825	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);	1522	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
…		…
1837	* 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
1838	* was not fully used.	1535	* was not fully used.
1839	*/	1536	*/
1840	if (num_ident)	1537	if (num_ident)
1841	{	1538	{
1842	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)
1843	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))	1540	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1844	{	1541	{
1845	identify (tmp);	1542	identify (tmp);
1846		1543
1847	if (op->type == PLAYER)	1544	if (op->type == PLAYER)
1848	{	1545	{
1849	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));
1850		1547
1851	if (tmp->msg)	1548	if (tmp->msg)
1852	{	1549	{
1853	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:");
1854	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);	1551	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
…		…
1998	*/	1695	*/
1999	if (done_one)	1696	if (done_one)
2000	{	1697	{
2001	object *detect_ob = arch_to_object (spell->other_arch);	1698	object *detect_ob = arch_to_object (spell->other_arch);
2002		1699
2003	detect_ob->x = nx;
2004	detect_ob->y = ny;
2005	/* if this is set, we want to copy the face */	1700	/* if this is set, we want to copy the face */
2006	if (done_one == 2 && detect)	1701	if (done_one == 2 && detect)
2007	{	1702	{
2008	detect_ob->face = detect->face;	1703	detect_ob->face = detect->face;
2009	detect_ob->animation_id = detect->animation_id;	1704	detect_ob->animation_id = detect->animation_id;
…		…
2011	detect_ob->last_anim = 0;	1706	detect_ob->last_anim = 0;
2012	/* by default, the detect_ob is already animated */	1707	/* by default, the detect_ob is already animated */
2013	if (!QUERY_FLAG (detect, FLAG_ANIMATE))	1708	if (!QUERY_FLAG (detect, FLAG_ANIMATE))
2014	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);	1709	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
2015	}	1710	}
		1711
2016	insert_ob_in_map (detect_ob, m, op, 0);	1712	m->insert (detect_ob, nx, ny, op);
2017	}	1713	}
2018	} /* for processing the surrounding spaces */	1714	} /* for processing the surrounding spaces */
2019		1715
2020		1716
2021	/* 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 */
…		…
2070		1766
2071	/* Explodes a fireball centered at player */	1767	/* Explodes a fireball centered at player */
2072	tmp = get_archetype (EXPLODING_FIREBALL);	1768	tmp = get_archetype (EXPLODING_FIREBALL);
2073	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;
2074	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;
2075	tmp->x = victim->x;	1771
2076	tmp->y = victim->y;	1772	tmp->insert_at (victim);
2077	insert_ob_in_map (tmp, victim->map, NULL, 0);
2078	victim->stats.sp = 2 * victim->stats.maxsp;	1773	victim->stats.sp = 2 * victim->stats.maxsp;
2079	}	1774	}
2080	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)	1775	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
2081	{
2082	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.");
2083	}
2084	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)	1777	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
2085	{
2086	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!");
2087	}
2088	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)	1779	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
2089	{	1780	{
2090	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");	1781	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
2091	confuse_player (victim, victim, 99);	1782	confuse_player (victim, victim, 99);
2092	}	1783	}
2093	else if (victim->stats.sp >= victim->stats.maxsp * 1.25)	1784	else if (victim->stats.sp >= victim->stats.maxsp * 1.25)
2094	{
2095	new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");	1785	new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");
2096	}
2097	}	1786	}
2098		1787
2099	/* cast_transfer	1788	/* cast_transfer
2100	* This spell transfers sp from the player to another person.	1789	* This spell transfers sp from the player to another person.
2101	* We let the target go above their normal maximum SP.	1790	* We let the target go above their normal maximum SP.
…		…
2212	/* Basically, if the object is magical and not counterspell,	1901	/* Basically, if the object is magical and not counterspell,
2213	* we will more or less remove the object. Don't counterspell	1902	* we will more or less remove the object. Don't counterspell
2214	* monsters either.	1903	* monsters either.
2215	*/	1904	*/
2216		1905
2217	if (head->attacktype & AT_MAGIC &&	1906	if (head->attacktype & AT_MAGIC
2218	!(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))
2219	head->destroy ();	1910	head->destroy ();
2220	else	1911	else
2221	switch (head->type)	1912	switch (head->type)
2222	{	1913	{
2223	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
2224	if (op->level > head->level)	1920	if (op->level > head->level)
2225	head->destroy ();	1921	head->destroy ();
2226		1922
2227	break;	1923	break;
2228		1924
…		…
2295	* 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,
2296	* 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
2297	* 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
2298	* player checks. MSW 2003-01-06	1994	* player checks. MSW 2003-01-06
2299	*/	1995	*/
2300
2301	int	1996	int
2302	animate_weapon (object *op, object *caster, object *spell, int dir)	1997	animate_weapon (object *op, object *caster, object *spell, int dir)
2303	{	1998	{
2304	object *weapon, *tmp;	1999	object *weapon, *tmp;
2305	char buf[MAX_BUF];	2000	char buf[MAX_BUF];
2306	int a, i;	2001	int a, i;
2307	sint16 x, y;	2002	sint16 x, y;
2308	maptile *m;	2003	maptile *m;
2309	materialtype_t *mt;
2310		2004
2311	if (!spell->other_arch)	2005	if (!spell->other_arch)
2312	{	2006	{
2313	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	2007	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
2314	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);
…		…
2317	/* exit if it's not a player using this spell. */	2011	/* exit if it's not a player using this spell. */
2318	if (op->type != PLAYER)	2012	if (op->type != PLAYER)
2319	return 0;	2013	return 0;
2320		2014
2321	/* if player already has a golem, abort */	2015	/* if player already has a golem, abort */
2322	if (op->contr->ranges[range_golem])	2016	if (object *golem = op->contr->golem)
2323	{	2017	{
2324	control_golem (op->contr->ranges[range_golem], dir);	2018	control_golem (golem, dir);
2325	return 0;	2019	return 0;
2326	}	2020	}
2327		2021
2328	/* if no direction specified, pick one */	2022	/* if no direction specified, pick one */
2329	if (!dir)	2023	if (!dir)
…		…
2333	x = op->x + freearr_x[dir];	2027	x = op->x + freearr_x[dir];
2334	y = op->y + freearr_y[dir];	2028	y = op->y + freearr_y[dir];
2335		2029
2336	/* if there's no place to put the golem, abort */	2030	/* if there's no place to put the golem, abort */
2337	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) ||
2338	((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))
2339	{	2033	{
2340	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.");
2341	return 0;	2035	return 0;
2342	}	2036	}
2343		2037
…		…
2347	if (!weapon)	2041	if (!weapon)
2348	{	2042	{
2349	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!");
2350	return 0;	2044	return 0;
2351	}	2045	}
2352	if (spell->race && strcmp (weapon->arch->name, spell->race))	2046	if (spell->race && strcmp (weapon->arch->archname, spell->race))
2353	{	2047	{
2354	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.");
2355	return 0;	2049	return 0;
2356	}	2050	}
2357	if (weapon->type != WEAPON)	2051	if (weapon->type != WEAPON)
…		…
2375	/* create the golem object */	2069	/* create the golem object */
2376	tmp = arch_to_object (spell->other_arch);	2070	tmp = arch_to_object (spell->other_arch);
2377		2071
2378	/* 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 */
2379	CLEAR_FLAG (tmp, FLAG_MONSTER);	2073	CLEAR_FLAG (tmp, FLAG_MONSTER);
2380	SET_FLAG (tmp, FLAG_FRIENDLY);
2381	tmp->stats.exp = 0;	2074	tmp->stats.exp = 0;
2382	add_friendly_object (tmp);	2075	add_friendly_object (tmp);
2383	tmp->type = GOLEM;	2076	tmp->type = GOLEM;
2384	tmp->set_owner (op);	2077	tmp->set_owner (op);
		2078	op->contr->golem = tmp;
2385	set_spell_skill (op, caster, spell, tmp);	2079	set_spell_skill (op, caster, spell, tmp);
2386	op->contr->ranges[range_golem] = tmp;
2387	op->contr->shoottype = range_golem;
2388		2080
2389	/* 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
2390	* 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
2391	* used above.	2083	* used above.
2392	*/	2084	*/
2393	if (!QUERY_FLAG (weapon, FLAG_REMOVED))	2085	if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2394	weapon->remove ();	2086	weapon->remove ();
		2087
2395	insert_ob_in_ob (weapon, tmp);	2088	insert_ob_in_ob (weapon, tmp);
2396	esrv_send_item (op, weapon);	2089	esrv_send_item (op, weapon);
2397	/* 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,
2398	* 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
2399	* body_info, skills, etc)	2092	* body_info, skills, etc)
…		…
2427		2120
2428	/* attacktype */	2121	/* attacktype */
2429	if (!tmp->attacktype)	2122	if (!tmp->attacktype)
2430	tmp->attacktype = AT_PHYSICAL;	2123	tmp->attacktype = AT_PHYSICAL;
2431		2124
2432	mt = NULL;
2433	if (op->materialname != NULL)
2434	mt = name_to_material (op->materialname);	2125	if (materialtype_t *mt = name_to_material (op->materialname))
2435	if (mt != NULL)
2436	{	2126	{
2437	for (i = 0; i < NROFATTACKS; i++)	2127	for (i = 0; i < NROFATTACKS; i++)
2438	tmp->resist[i] = 50 - (mt->save[i] * 5);	2128	tmp->resist[i] = 50 - (mt->save[i] * 5);
2439	a = mt->save[0];	2129	a = mt->save[0];
2440	}	2130	}
…		…
2442	{	2132	{
2443	for (i = 0; i < NROFATTACKS; i++)	2133	for (i = 0; i < NROFATTACKS; i++)
2444	tmp->resist[i] = 5;	2134	tmp->resist[i] = 5;
2445	a = 10;	2135	a = 10;
2446	}	2136	}
		2137
2447	/* Set weapon's immunity */	2138	/* Set weapon's immunity */
2448	tmp->resist[ATNR_CONFUSION] = 100;	2139	tmp->resist[ATNR_CONFUSION] = 100;
2449	tmp->resist[ATNR_POISON] = 100;	2140	tmp->resist[ATNR_POISON] = 100;
2450	tmp->resist[ATNR_SLOW] = 100;	2141	tmp->resist[ATNR_SLOW] = 100;
2451	tmp->resist[ATNR_PARALYZE] = 100;	2142	tmp->resist[ATNR_PARALYZE] = 100;
…		…
2457		2148
2458	/* 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 */
2459		2150
2460	if (a > 14)	2151	if (a > 14)
2461	a = 14;	2152	a = 14;
		2153
2462	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));
2463		2155
2464	/* Determine golem's speed */	2156	/* Determine golem's speed */
2465	tmp->speed = 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)));
2466
2467	if (tmp->speed > 3.33)
2468	tmp->speed = 3.33;
2469		2158
2470	if (!spell->race)	2159	if (!spell->race)
2471	{	2160	{
2472	sprintf (buf, "animated %s", &weapon->name);	2161	sprintf (buf, "animated %s", &weapon->name);
2473	tmp->name = buf;	2162	tmp->name = buf;
…		…
2475	tmp->face = weapon->face;	2164	tmp->face = weapon->face;
2476	tmp->animation_id = weapon->animation_id;	2165	tmp->animation_id = weapon->animation_id;
2477	tmp->anim_speed = weapon->anim_speed;	2166	tmp->anim_speed = weapon->anim_speed;
2478	tmp->last_anim = weapon->last_anim;	2167	tmp->last_anim = weapon->last_anim;
2479	tmp->state = weapon->state;	2168	tmp->state = weapon->state;
2480	if (QUERY_FLAG (weapon, FLAG_ANIMATE))	2169	tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2481	{
2482	SET_FLAG (tmp, FLAG_ANIMATE);
2483	}
2484	else
2485	{
2486	CLEAR_FLAG (tmp, FLAG_ANIMATE);
2487	}
2488	update_ob_speed (tmp);
2489	}	2170	}
2490		2171
2491	/* 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. */
2492	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));
2493		2174
2494	tmp->speed_left = -1;	2175	tmp->speed_left = -1;
2495	tmp->x = x;
2496	tmp->y = y;
2497	tmp->direction = dir;	2176	tmp->direction = dir;
2498	insert_ob_in_map (tmp, m, op, 0);	2177
		2178	m->insert (tmp, x, y, op);
2499	return 1;	2179	return 1;
2500	}	2180	}
2501		2181
2502	/* cast_daylight() - changes the map darkness level *lower* */	2182	/* cast_daylight() - changes the map darkness level *lower* */
2503		2183
…		…
2511	int success;	2191	int success;
2512		2192
2513	if (!op->map)	2193	if (!op->map)
2514	return 0; /* shouldnt happen */	2194	return 0; /* shouldnt happen */
2515		2195
2516	success = change_map_light (op->map, spell->stats.dam);	2196	success = op->map->change_map_light (spell->stats.dam);
		2197
2517	if (!success)	2198	if (!success)
2518	{	2199	{
2519	if (spell->stats.dam < 0)	2200	if (spell->stats.dam < 0)
2520	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.");
2521	else	2202	else
…		…
2598	{	2279	{
2599	aura->destroy ();	2280	aura->destroy ();
2600	return;	2281	return;
2601	}	2282	}
2602		2283
2603	aura->x = env->x;
2604	aura->y = env->y;
2605
2606	/* we need to jump out of the inventory for a bit	2284	/* we need to jump out of the inventory for a bit
2607	* in order to hit the map conveniently.	2285	* in order to hit the map conveniently.
2608	*/	2286	*/
2609	insert_ob_in_map (aura, env->map, aura, 0);	2287	aura->insert_at (env, aura);
2610		2288
2611	for (i = 1; i < 9; i++)	2289	for (i = 1; i < 9; i++)
2612	{	2290	{
2613	sint16 nx, ny;	2291	sint16 nx, ny;
2614		2292
…		…
2623	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))))
2624	{	2302	{
2625	hit_map (aura, i, aura->attacktype, 0);	2303	hit_map (aura, i, aura->attacktype, 0);
2626		2304
2627	if (aura->other_arch)	2305	if (aura->other_arch)
2628	{	2306	m->insert (arch_to_object (aura->other_arch), nx, ny, aura);
2629	object *new_ob;
2630
2631	new_ob = arch_to_object (aura->other_arch);
2632	new_ob->x = nx;
2633	new_ob->y = ny;
2634	insert_ob_in_map (new_ob, m, aura, 0);
2635	}	2307	}
2636	}
2637	}	2308	}
		2309
2638	/* put the aura back in the player's inventory */	2310	/* put the aura back in the player's inventory */
2639	aura->remove ();	2311	aura->remove ();
2640	insert_ob_in_ob (aura, env);	2312	insert_ob_in_ob (aura, env);
2641	}	2313	}
2642		2314
…		…
2723		2395
2724	snprintf (rune, sizeof (rune), "%s\n", msg);	2396	snprintf (rune, sizeof (rune), "%s\n", msg);
2725		2397
2726	tmp->race = op->name; /*Save the owner of the rune */	2398	tmp->race = op->name; /*Save the owner of the rune */
2727	tmp->msg = rune;	2399	tmp->msg = rune;
2728	tmp->x = op->x;	2400
2729	tmp->y = op->y;	2401	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2730	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
2731	return 1;	2402	return 1;
2732	}	2403	}

Diff Legend

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