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.63 by root, Tue Jul 10 07:31:20 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;
…		…
77	play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE);	74	play_sound_map (op->map, op->x, op->y, SOUND_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
…		…
151	/* If it starts with a letter, presume it is a description */	153	/* If it starts with a letter, presume it is a description */
152	if (isalpha (*stringarg))	154	if (isalpha (*stringarg))
153	{	155	{
154	artifact *al = find_artifactlist (missile->type)->items;	156	artifact *al = find_artifactlist (missile->type)->items;
155		157
156	for (; al != NULL; al = al->next)	158	for (; al; al = al->next)
157	if (!strcasecmp (al->item->name, stringarg))	159	if (!strcasecmp (al->item->name, stringarg))
158	break;	160	break;
159		161
160	if (!al)	162	if (!al)
161	{	163	{
…		…
221	if (stringarg)	223	if (stringarg)
222	{	224	{
223	at = find_archetype_by_object_type_name (FOOD, stringarg);	225	at = find_archetype_by_object_type_name (FOOD, stringarg);
224	if (at == NULL)	226	if (at == NULL)
225	at = find_archetype_by_object_type_name (DRINK, stringarg);	227	at = find_archetype_by_object_type_name (DRINK, stringarg);
226	if (at == NULL || at->clone.stats.food > food_value)	228	if (at == NULL || at->stats.food > food_value)
227	stringarg = NULL;	229	stringarg = NULL;
228	}	230	}
229		231
230	if (!stringarg)	232	if (!stringarg)
231	{	233	{
…		…
237	* We don't use flesh types because the weight values of those need	239	* We don't use flesh types because the weight values of those need
238	* to be altered from the donor.	240	* to be altered from the donor.
239	*/	241	*/
240		242
241	/* We assume the food items don't have multiple parts */	243	/* We assume the food items don't have multiple parts */
242	for (at_tmp = first_archetype; at_tmp != NULL; at_tmp = at_tmp->next)	244	for_all_archetypes (at_tmp)
243	{	245	{
244	if (at_tmp->clone.type == FOOD || at_tmp->clone.type == DRINK)	246	if (at_tmp->type == FOOD || at_tmp->type == DRINK)
245	{	247	{
246	/* Basically, if the food value is something that is creatable	248	/* Basically, if the food value is something that is creatable
247	* under the limits of the spell and it is higher than	249	* under the limits of the spell and it is higher than
248	* the item we have now, take it instead.	250	* the item we have now, take it instead.
249	*/	251	*/
250	if (at_tmp->clone.stats.food <= food_value && (!at || at_tmp->clone.stats.food > at->clone.stats.food))	252	if (at_tmp->stats.food <= food_value
		253	&& (!at
		254	|| at_tmp->stats.food > at->stats.food
		255	|| (at_tmp->stats.food == at->stats.food
		256	&& at_tmp->weight < at->weight)))
251	at = at_tmp;	257	at = at_tmp;
252	}	258	}
253	}	259	}
254	}	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
…		…
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)
…		…
370	* normal applies.	376	* normal applies.
371	*/	377	*/
372	int	378	int
373	cast_invisible (object *op, object *caster, object *spell_ob)	379	cast_invisible (object *op, object *caster, object *spell_ob)
374	{	380	{
375	object *tmp;
376
377	if (op->invisible > 1000)	381	if (op->invisible > 1000)
378	{	382	{
379	new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");	383	new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");
380	return 0;	384	return 0;
381	}	385	}
…		…
397	else	401	else
398	op->contr->tmp_invis = 1;	402	op->contr->tmp_invis = 1;
399		403
400	op->contr->hidden = 0;	404	op->contr->hidden = 0;
401	}	405	}
		406
402	if (makes_invisible_to (op, op))	407	if (makes_invisible_to (op, op))
403	new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");	408	new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");
404	else	409	else
405	new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!");	410	new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!");
406		411
407	update_object (op, UP_OBJ_FACE);	412	update_object (op, UP_OBJ_CHANGE);
408		413
409	/* Only search the active objects - only these should actually do	414	/* Only search the active objects - only these should actually do
410	* harm to the player.	415	* harm to the player.
411	*/	416	*/
412	for (tmp = active_objects; tmp != NULL; tmp = tmp->active_next)	417	for_all_actives (tmp)
413	if (tmp->enemy == op)	418	if (tmp->enemy == op)
414	tmp->enemy = NULL;	419	tmp->enemy = 0;
		420
415	return 1;	421	return 1;
416	}	422	}
417		423
418	/* earth to dust spell. Basically destroys earthwalls in the area.	424	/* earth to dust spell. Basically destroys earthwalls in the area.
419	*/	425	*/
…		…
447	next = tmp->above;	453	next = tmp->above;
448	if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))	454	if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
449	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);	455	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
450	}	456	}
451	}	457	}
		458
452	return 1;	459	return 1;
453	}	460	}
454
455		461
456	void	462	void
457	execute_word_of_recall (object *op)	463	execute_word_of_recall (object *op)
458	{	464	{
459	object *wor = op;	465	if (object *pl = op->in_player ())
460		466	{
461	while (op != NULL && op->type != PLAYER)	467	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.");	468	new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
467	else	469	else
		470	{
		471	// remove first so we do not call update_stats
		472	op->remove ();
468	enter_exit (op, wor);	473	pl->enter_exit (op);
		474	}
		475	}
469		476
470	wor->destroy ();	477	op->destroy ();
471	}	478	}
472		479
473	/* Word of recall causes the player to return 'home'.	480	/* Word of recall causes the player to return 'home'.
474	* we put a force into the player object, so that there is a	481	* we put a force into the player object, so that there is a
475	* time delay effect.	482	* time delay effect.
…		…
494	{	501	{
495	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	502	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
496	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");	503	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
497	return 0;	504	return 0;
498	}	505	}
		506
499	time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);	507	time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);
500	if (time < 1)	508	if (time < 1)
501	time = 1;	509	time = 1;
502		510
503	/* value of speed really doesn't make much difference, as long as it is	511	/* 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	512	* positive. Lower value may be useful so that the problem doesn't
505	* do anything really odd if it say a -1000 or something.	513	* do anything really odd if it say a -1000 or something.
506	*/	514	*/
507	dummy->speed = 0.002;	515	dummy->set_speed (0.002);
508	update_ob_speed (dummy);
509	dummy->speed_left = -dummy->speed * time;	516	dummy->speed_left = -dummy->speed * time;
510	dummy->type = SPELL_EFFECT;	517	dummy->type = SPELL_EFFECT;
511	dummy->subtype = SP_WORD_OF_RECALL;	518	dummy->subtype = SP_WORD_OF_RECALL;
512		519
513	/* If we could take advantage of enter_player_savebed() here, it would be	520	/* If we could take advantage of enter_player_savebed() here, it would be
514	* nice, but until the map load fails, we can't.	521	* nice, but until the map load fails, we can't.
515	*/	522	*/
516	EXIT_PATH (dummy) = op->contr->savebed_map;	523	EXIT_PATH (dummy) = op->contr->savebed_map;
517	EXIT_X (dummy) = op->contr->bed_x;	524	EXIT_X (dummy) = op->contr->bed_x;
518	EXIT_Y (dummy) = op->contr->bed_y;	525	EXIT_Y (dummy) = op->contr->bed_y;
519		526
520	(void) insert_ob_in_ob (dummy, op);	527	op->insert (dummy);
		528
521	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");	529	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
		530
522	return 1;	531	return 1;
523	}	532	}
524		533
525	/* cast_wonder	534	/* cast_wonder
526	* wonder is really just a spell that will likely cast another	535	* wonder is really just a spell that will likely cast another
…		…
559	}	568	}
560		569
561	int	570	int
562	perceive_self (object *op)	571	perceive_self (object *op)
563	{	572	{
564	char *cp = describe_item (op, op), buf[MAX_BUF];	573	const char *cp = describe_item (op, op);
565	archetype *at = archetype::find (ARCH_DEPLETION);	574	archetype *at = archetype::find (ARCH_DEPLETION);
566	object *tmp;
567	int i;
568		575
		576	dynbuf_text buf;
		577
		578	if (player *pl = op->contr)
		579	if (object *race = archetype::find (op->race))
		580	buf << "You are a " << (pl->gender ? "female" : "male") << " " << &race->name << ".\n";
		581
569	tmp = find_god (determine_god (op));	582	if (object *god = find_god (determine_god (op)))
570	if (tmp)	583	buf << "You worship " << &god->name << ".\n";
571	new_draw_info_format (NDI_UNIQUE, 0, op, "You worship %s", &tmp->name);
572	else	584	else
573	new_draw_info (NDI_UNIQUE, 0, op, "You worship no god");	585	buf << "You worship no god.\n";
574		586
575	tmp = present_arch_in_ob (at, op);	587	object *tmp = present_arch_in_ob (at, op);
576		588
577	if (*cp == '\0' && tmp == NULL)	589	if (*cp == '\0' && tmp == NULL)
578	new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane");	590	buf << "You feel very mundane. ";
579	else	591	else
580	{	592	{
581	new_draw_info (NDI_UNIQUE, 0, op, "You have:");	593	buf << "You have: " << cp << ".\n";
582	new_draw_info (NDI_UNIQUE, 0, op, cp);	594
583	if (tmp != NULL)	595	if (tmp)
584	{
585	for (i = 0; i < NUM_STATS; i++)	596	for (int i = 0; i < NUM_STATS; i++)
586	{	597	if (tmp->stats.stat (i) < 0)
587	if (get_attr_value (&tmp->stats, i) < 0)	598	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	}	599	}
594		600
595	if (is_dragon_pl (op))	601	if (is_dragon_pl (op))
596	{
597	/* now grab the 'dragon_ability'-force from the player's inventory */	602	/* now grab the 'dragon_ability'-force from the player's inventory */
598	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	603	for (tmp = op->inv; tmp; tmp = tmp->below)
599	{	604	{
600	if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force"))	605	if (tmp->type == FORCE && !strcmp (tmp->arch->archname, "dragon_ability_force"))
601	{	606	{
602	if (tmp->stats.exp == 0)	607	if (tmp->stats.exp == 0)
603	{
604	sprintf (buf, "Your metabolism isn't focused on anything.");	608	buf << "Your metabolism isn't focused on anything.\n";
605	}
606	else	609	else
607	{
608	sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]);	610	buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
609	}	611
610	new_draw_info (NDI_UNIQUE, 0, op, buf);
611	break;	612	break;
612	}	613	}
613	}	614	}
614	}
615	return 1;
616	}
617		615
618	/* int cast_create_town_portal (object *op, object *caster, int dir)	616	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		617
645	/* Check to see if the map the player is currently on is a per player unique	618	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		619
876	return 1;	620	return 1;
877	}	621	}
878		622
879	/* This creates magic walls. Really, it can create most any object,	623	/* This creates magic walls. Really, it can create most any object,
880	* within some reason.	624	* within some reason.
881	*/	625	*/
882	int	626	int
883	magic_wall (object *op, object *caster, int dir, object *spell_ob)	627	magic_wall (object *op, object *caster, int dir, object *spell_ob)
884	{	628	{
885	object *tmp, *tmp2;	629	object *tmp;
886	int i, posblocked, negblocked, maxrange;	630	int i, posblocked, negblocked, maxrange;
887	sint16 x, y;	631	sint16 x, y;
888	maptile *m;	632	maptile *m;
889	const char *name;	633	const char *name;
890	archetype *at;	634	archetype *at;
…		…
923	{	667	{
924	LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);	668	LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
925	new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");	669	new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
926	return 0;	670	return 0;
927	}	671	}
		672
928	tmp = arch_to_object (at);	673	tmp = arch_to_object (at);
929	}	674	}
930	else	675	else
931	{	676	{
932	LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);	677	LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
…		…
966	*/	711	*/
967	if (tmp->type != EARTHWALL) //TODO	712	if (tmp->type != EARTHWALL) //TODO
968	tmp->set_owner (op);	713	tmp->set_owner (op);
969		714
970	set_spell_skill (op, caster, spell_ob, tmp);	715	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;	716	tmp->level = caster_level (caster, spell_ob) / 2;
974		717
975	name = tmp->name;	718	name = tmp->name;
976	if ((tmp = insert_ob_in_map (tmp, m, op, 0)) == NULL)	719	if (!(tmp = m->insert (tmp, x, y, op)))
977	{	720	{
978	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);	721	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
979	return 0;	722	return 0;
980	}	723	}
981		724
982	/* If this is a spellcasting wall, need to insert the spell object */	725	/* If this is a spellcasting wall, need to insert the spell object */
983	if (tmp->other_arch && tmp->other_arch->clone.type == SPELL)	726	if (tmp->other_arch && tmp->other_arch->type == SPELL)
984	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);	727	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
985		728
986	/* This code causes the wall to extend some distance in	729	/* This code causes the wall to extend some distance in
987	* each direction, or until an obstruction is encountered.	730	* each direction, or until an obstruction is encountered.
988	* posblocked and negblocked help determine how far the	731	* posblocked and negblocked help determine how far the
…		…
1004	m = tmp->map;	747	m = tmp->map;
1005		748
1006	if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&	749	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)	750	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)
1008	{	751	{
1009	tmp2 = tmp->clone ();	752	object *tmp2 = tmp->clone ();
1010	tmp2->x = x;	753	m->insert (tmp2, x, y, op);
1011	tmp2->y = y;	754
1012	insert_ob_in_map (tmp2, m, op, 0);
1013	/* If this is a spellcasting wall, need to insert the spell object */	755	/* If this is a spellcasting wall, need to insert the spell object */
1014	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	756	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1015	insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2);	757	tmp2->insert (arch_to_object (tmp2->other_arch));
1016		758
1017	}	759	}
1018	else	760	else
1019	posblocked = 1;	761	posblocked = 1;
1020		762
…		…
1023	m = tmp->map;	765	m = tmp->map;
1024		766
1025	if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&	767	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)	768	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
1027	{	769	{
1028	tmp2 = tmp->clone ();	770	object *tmp2 = tmp->clone ();
1029	tmp2->x = x;	771	m->insert (tmp2, x, y, op);
1030	tmp2->y = y;	772
1031	insert_ob_in_map (tmp2, m, op, 0);
1032	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	773	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1033	insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2);	774	tmp2->insert (arch_to_object (tmp2->other_arch));
1034	}	775	}
1035	else	776	else
1036	negblocked = 1;	777	negblocked = 1;
1037	}	778	}
1038		779
…		…
1087	{	828	{
1088	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");	829	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
1089	op->contr->count = 0;	830	op->contr->count = 0;
1090	return 0;	831	return 0;
1091	}	832	}
		833
1092	op->contr->count = 0;	834	op->contr->count = 0;
1093		835
1094	/* Remove code that puts player on random space on maps. IMO,	836	/* 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,	837	* 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	838	* but may not be marked as NO_MAGIC (as they may be bounded
…		…
1145	return 0;	887	return 0;
1146	}	888	}
1147	}	889	}
1148		890
1149	/* Actually move the player now */	891	/* Actually move the player now */
1150	op->remove ();	892	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;	893	return 1;
1155		894
1156	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */	895	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
1157	return 1;	896	return 1;
1158	}	897	}
…		…
1171	object *poison;	910	object *poison;
1172	int heal = 0, success = 0;	911	int heal = 0, success = 0;
1173		912
1174	tmp = find_target_for_friendly_spell (op, dir);	913	tmp = find_target_for_friendly_spell (op, dir);
1175		914
1176	if (tmp == NULL)	915	if (!tmp)
1177	return 0;	916	return 0;
1178		917
1179	/* Figure out how many hp this spell might cure.	918	/* Figure out how many hp this spell might cure.
1180	* could be zero if this spell heals effects, not damage.	919	* could be zero if this spell heals effects, not damage.
1181	*/	920	*/
…		…
1184	heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp;	923	heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp;
1185		924
1186	if (heal)	925	if (heal)
1187	{	926	{
1188	if (tmp->stats.hp >= tmp->stats.maxhp)	927	if (tmp->stats.hp >= tmp->stats.maxhp)
1189	{
1190	new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed.");	928	new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed.");
1191	}
1192	else	929	else
1193	{	930	{
1194	/* See how many points we actually heal. Instead of messages	931	/* See how many points we actually heal. Instead of messages
1195	* based on type of spell, we instead do messages based	932	* based on type of spell, we instead do messages based
1196	* on amount of damage healed.	933	* on amount of damage healed.
…		…
1198	if (heal > (tmp->stats.maxhp - tmp->stats.hp))	935	if (heal > (tmp->stats.maxhp - tmp->stats.hp))
1199	heal = tmp->stats.maxhp - tmp->stats.hp;	936	heal = tmp->stats.maxhp - tmp->stats.hp;
1200	tmp->stats.hp += heal;	937	tmp->stats.hp += heal;
1201		938
1202	if (tmp->stats.hp >= tmp->stats.maxhp)	939	if (tmp->stats.hp >= tmp->stats.maxhp)
1203	{
1204	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");	940	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
1205	}
1206	else if (heal > 50)	941	else if (heal > 50)
1207	{
1208	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");	942	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");
1209	}
1210	else if (heal > 25)	943	else if (heal > 25)
1211	{
1212	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");	944	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");
1213	}
1214	else if (heal > 10)	945	else if (heal > 10)
1215	{
1216	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade.");	946	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade.");
1217	}
1218	else	947	else
1219	{
1220	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close.");	948	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close.");
1221	}	949
1222	success = 1;	950	success = 1;
1223	}	951	}
1224	}	952	}
		953
1225	if (spell->attacktype & AT_DISEASE)	954	if (spell->attacktype & AT_DISEASE)
1226	if (cure_disease (tmp, op))	955	if (cure_disease (tmp, op))
1227	success = 1;	956	success = 1;
1228		957
1229	if (spell->attacktype & AT_POISON)	958	if (spell->attacktype & AT_POISON)
…		…
1235	success = 1;	964	success = 1;
1236	new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");	965	new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
1237	poison->stats.food = 1;	966	poison->stats.food = 1;
1238	}	967	}
1239	}	968	}
		969
1240	if (spell->attacktype & AT_CONFUSION)	970	if (spell->attacktype & AT_CONFUSION)
1241	{	971	{
1242	poison = present_in_ob_by_name (FORCE, "confusion", tmp);	972	poison = present_in_ob_by_name (FORCE, "confusion", tmp);
1243	if (poison)	973	if (poison)
1244	{	974	{
1245	success = 1;	975	success = 1;
1246	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	976	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
1247	poison->duration = 1;	977	poison->duration = 1;
1248	}	978	}
1249	}	979	}
		980
1250	if (spell->attacktype & AT_BLIND)	981	if (spell->attacktype & AT_BLIND)
1251	{	982	{
1252	at = archetype::find ("blindness");	983	at = archetype::find ("blindness");
1253	poison = present_arch_in_ob (at, tmp);	984	poison = present_arch_in_ob (at, tmp);
1254	if (poison)	985	if (poison)
…		…
1256	success = 1;	987	success = 1;
1257	new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");	988	new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
1258	poison->stats.food = 1;	989	poison->stats.food = 1;
1259	}	990	}
1260	}	991	}
		992
1261	if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)	993	if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)
1262	{	994	{
1263	tmp->stats.sp += spell->last_sp;	995	tmp->stats.sp += spell->last_sp;
1264	if (tmp->stats.sp > tmp->stats.maxsp)	996	if (tmp->stats.sp > tmp->stats.maxsp)
1265	tmp->stats.sp = tmp->stats.maxsp;	997	tmp->stats.sp = tmp->stats.maxsp;
1266	success = 1;	998	success = 1;
1267	new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!");	999	new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!");
1268	}	1000	}
		1001
1269	if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)	1002	if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)
1270	{	1003	{
1271	tmp->stats.grace += spell->last_grace;	1004	tmp->stats.grace += spell->last_grace;
1272	if (tmp->stats.grace > tmp->stats.maxgrace)	1005	if (tmp->stats.grace > tmp->stats.maxgrace)
1273	tmp->stats.grace = tmp->stats.maxgrace;	1006	tmp->stats.grace = tmp->stats.maxgrace;
1274	success = 1;	1007	success = 1;
1275	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");	1008	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1276	}	1009	}
		1010
1277	if (spell->stats.food && tmp->stats.food < 999)	1011	if (spell->stats.food && tmp->stats.food < 999)
1278	{	1012	{
1279	tmp->stats.food += spell->stats.food;	1013	tmp->stats.food += spell->stats.food;
1280	if (tmp->stats.food > 999)	1014	if (tmp->stats.food > 999)
1281	tmp->stats.food = 999;	1015	tmp->stats.food = 999;
1282	success = 1;	1016	success = 1;
1283	/* We could do something a bit better like the messages for healing above */	1017	/* We could do something a bit better like the messages for healing above */
1284	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");	1018	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1285	}	1019	}
		1020
1286	return success;	1021	return success;
1287	}	1022	}
1288
1289		1023
1290	/* This is used for the spells that gain stats. There are no spells	1024	/* This is used for the spells that gain stats. There are no spells
1291	* right now that icnrease wis/int/pow on a temp basis, so no	1025	* right now that icnrease wis/int/pow on a temp basis, so no
1292	* good comments for those.	1026	* good comments for those.
1293	*/	1027	*/
1294	static const char *const no_gain_msgs[NUM_STATS] = {	1028	static const char *const no_gain_msgs[NUM_STATS] = {
1295	"You grow no stronger.",	1029	"You grow no stronger.",
1296	"You grow no more agile.",	1030	"You grow no more agile.",
1297	"You don't feel any healthier.",	1031	"You don't feel any healthier.",
1298	"no wis",	1032	"You didn't grow any more intelligent.",
		1033	"You do not feel any wiser.",
		1034	"You don't feel any more powerful."
1299	"You are no easier to look at.",	1035	"You are no easier to look at.",
1300	"no int",
1301	"no pow"
1302	};	1036	};
1303		1037
1304	int	1038	int
1305	cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)	1039	cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1306	{	1040	{
1307	object *tmp, *tmp2 = NULL;
1308	object *force = NULL;	1041	object *force = NULL;
1309	int i;	1042	int i;
1310		1043
1311	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */	1044	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1312	if (dir != 0)	1045	object *tmp = dir
1313	{
1314	tmp = find_target_for_friendly_spell (op, dir);	1046	? find_target_for_friendly_spell (op, dir)
1315	}	1047	: op;
1316	else
1317	{
1318	tmp = op;
1319	}
1320		1048
1321	if (tmp == NULL)	1049	if (!tmp)
1322	return 0;	1050	return 0;
1323		1051
1324	/* If we've already got a force of this type, don't add a new one. */	1052	/* If we've already got a force of this type, don't add a new one. */
1325	for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below)	1053	for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1326	{	1054	{
1327	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)	1055	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1328	{	1056	{
1329	if (tmp2->name == spell_ob->name)	1057	if (tmp2->name == spell_ob->name)
1330	{	1058	{
…		…
1363	}	1091	}
1364	else	1092	else
1365	{	1093	{
1366	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1094	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1367	}	1095	}
		1096
1368	return 1;	1097	return 1;
1369	}	1098	}
		1099
1370	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1100	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1371	force->speed = 1.0;	1101	force->speed = 1.0;
1372	force->speed_left = -1.0;	1102	force->speed_left = -1.0;
1373	SET_FLAG (force, FLAG_APPLIED);	1103	SET_FLAG (force, FLAG_APPLIED);
1374		1104
…		…
1380	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);	1110	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);
1381	if (force->resist[i] > 100)	1111	if (force->resist[i] > 100)
1382	force->resist[i] = 100;	1112	force->resist[i] = 100;
1383	}	1113	}
1384	}	1114	}
		1115
1385	if (spell_ob->stats.hp)	1116	if (spell_ob->stats.hp)
1386	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);	1117	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
1387		1118
1388	if (tmp->type == PLAYER)	1119	if (tmp->type == PLAYER)
1389	{	1120	{
1390	/* Stat adjustment spells */	1121	/* Stat adjustment spells */
1391	for (i = 0; i < NUM_STATS; i++)	1122	for (i = 0; i < NUM_STATS; i++)
1392	{	1123	{
1393	sint8 stat = get_attr_value (&spell_ob->stats, i), k, sm;	1124	if (sint8 stat = spell_ob->stats.stat (i))
1394
1395	if (stat)
1396	{	1125	{
1397	sm = 0;	1126	sint8 sm = 0;
1398	for (k = 0; k < stat; k++)	1127	for (sint8 k = 0; k < stat; k++)
1399	sm += rndm (1, 3);	1128	sm += rndm (1, 3);
1400		1129
1401	if ((get_attr_value (&tmp->stats, i) + sm) > (15 + 5 * stat))	1130	if (tmp->stats.stat (i) + sm > 15 + 5 * stat)
1402	{	1131	sm = max (0, (15 + 5 * stat) - tmp->stats.stat (i));
1403	sm = (15 + 5 * stat) - get_attr_value (&tmp->stats, i);	1132
1404	if (sm < 0)	1133	force->stats.stat (i) = sm;
1405	sm = 0;	1134
1406	}
1407	set_attr_value (&force->stats, i, sm);
1408	if (!sm)	1135	if (!sm)
1409	new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);	1136	new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);
1410	}	1137	}
1411	}	1138	}
1412	}	1139	}
…		…
1433	force->attacktype = spell_ob->attacktype;	1160	force->attacktype = spell_ob->attacktype;
1434		1161
1435	insert_ob_in_ob (force, tmp);	1162	insert_ob_in_ob (force, tmp);
1436	change_abil (tmp, force); /* Mostly to display any messages */	1163	change_abil (tmp, force); /* Mostly to display any messages */
1437	tmp->update_stats ();	1164	tmp->update_stats ();
		1165
1438	return 1;	1166	return 1;
1439	}	1167	}
1440		1168
1441	/* This used to be part of cast_change_ability, but it really didn't make	1169	/* 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	1170	* a lot of sense, since most of the values it derives are from the god
1443	* of the caster.	1171	* of the caster.
1444	*/	1172	*/
1445
1446	int	1173	int
1447	cast_bless (object *op, object *caster, object *spell_ob, int dir)	1174	cast_bless (object *op, object *caster, object *spell_ob, int dir)
1448	{	1175	{
1449	int i;	1176	int i;
1450	object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;	1177	object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;
…		…
1544	change_abil (tmp, force); /* Mostly to display any messages */	1271	change_abil (tmp, force); /* Mostly to display any messages */
1545	insert_ob_in_ob (force, tmp);	1272	insert_ob_in_ob (force, tmp);
1546	tmp->update_stats ();	1273	tmp->update_stats ();
1547	return 1;	1274	return 1;
1548	}	1275	}
1549
1550
1551		1276
1552	/* Alchemy code by Mark Wedel	1277	/* Alchemy code by Mark Wedel
1553	*	1278	*
1554	* This code adds a new spell, called alchemy. Alchemy will turn	1279	* This code adds a new spell, called alchemy. Alchemy will turn
1555	* objects to gold nuggets, the value of the gold nuggets being	1280	* objects to gold nuggets, the value of the gold nuggets being
…		…
1565	* For example, if an item is worth 110 gold, you will get	1290	* For example, if an item is worth 110 gold, you will get
1566	* 4 large nuggets, and from 0-10 small nuggets.	1291	* 4 large nuggets, and from 0-10 small nuggets.
1567	*	1292	*
1568	* There is also a chance (1:30) that you will get nothing at all	1293	* 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	1294	* for the object. There is also a maximum weight that will be
1570	* alchemied.	1295	* alchemised.
1571	*/	1296	*/
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	1297	static void
1581	alchemy_object (object *obj, int *small_nuggets, int *large_nuggets, int *weight)	1298	alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1582	{	1299	{
1583	uint64 value = query_cost (obj, NULL, F_TRUE);	1300	uint64 value = query_cost (obj, NULL, F_TRUE);
1584		1301
1585	/* Give third price when we alchemy money (This should hopefully	1302	/* Give third price when we alchemy money (This should hopefully
1586	* make it so that it isn't worth it to alchemy money, sell	1303	* make it so that it isn't worth it to alchemy money, sell
1587	* the nuggets, alchemy the gold from that, etc.	1304	* the nuggets, alchemy the gold from that, etc.
1588	* Otherwise, give 9 silver on the gold for other objects,	1305	* Otherwise, give 9 silver on the gold for other objects,
1589	* so that it would still be more affordable to haul	1306	* so that it would still be more affordable to haul
1590	* the stuff back to town.	1307	* the stuff back to town.
1591	*/	1308	*/
1592
1593	if (QUERY_FLAG (obj, FLAG_UNPAID))	1309	if (QUERY_FLAG (obj, FLAG_UNPAID))
1594	value = 0;	1310	value = 0;
1595	else if (obj->type == MONEY || obj->type == GEM)	1311	else if (obj->type == MONEY || obj->type == GEM)
1596	value /= 3;	1312	value /= 3;
1597	else	1313	else
1598	value = (value * 9) / 10;	1314	value = value * 9 / 10;
1599		1315
1600	value /= 4; // fix by GHJ, don't understand, pcg
1601
1602	if ((obj->value > 0) && rndm (0, 29))	1316	if (obj->value > 0 && rndm (0, 29))
1603	{	1317	total_value += value;
1604	int count;
1605		1318
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;	1319	total_weight += obj->total_weight ();
		1320
1626	obj->destroy ();	1321	obj->destroy ();
1627	}	1322	}
1628		1323
1629	static void	1324	static void
1630	update_map (object *op, maptile *m, int small_nuggets, int large_nuggets, int x, int y)	1325	update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1631	{	1326	{
1632	object *tmp;
1633	int flag = 0;	1327	int flag = 0;
1634		1328
1635	/* Put any nuggets below the player, but we can only pass this	1329	/* Put any nuggets below the player, but we can only pass this
1636	* flag if we are on the same space as the player	1330	* flag if we are on the same space as the player
1637	*/	1331	*/
1638	if (x == op->x && y == op->y && op->map == m)	1332	if (x == op->x && y == op->y && op->map == m)
1639	flag = INS_BELOW_ORIGINATOR;	1333	flag = INS_BELOW_ORIGINATOR;
1640		1334
1641	if (small_nuggets)	1335	if (small_nuggets)
1642	{	1336	{
1643	tmp = small->clone ();	1337	object *tmp = small->clone ();
1644	tmp->nrof = small_nuggets;	1338	tmp->nrof = small_nuggets;
1645	tmp->x = x;
1646	tmp->y = y;
1647	insert_ob_in_map (tmp, m, op, flag);	1339	m->insert (tmp, x, y, op, flag);
1648	}	1340	}
1649		1341
1650	if (large_nuggets)	1342	if (large_nuggets)
1651	{	1343	{
1652	tmp = large->clone ();	1344	object *tmp = large->clone ();
1653	tmp->nrof = large_nuggets;	1345	tmp->nrof = large_nuggets;
1654	tmp->x = x;
1655	tmp->y = y;
1656	insert_ob_in_map (tmp, m, op, flag);	1346	m->insert (tmp, x, y, op, flag);
1657	}	1347	}
		1348
		1349	if (object *pl = m->at (x, y).player ())
		1350	if (pl->contr->ns)
		1351	pl->contr->ns->look_position = 0;
1658	}	1352	}
1659		1353
1660	int	1354	int
1661	alchemy (object *op, object *caster, object *spell_ob)	1355	alchemy (object *op, object *caster, object *spell_ob)
1662	{	1356	{
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)	1357	if (op->type != PLAYER)
1669	return 0;	1358	return 0;
1670		1359
		1360	object *large = get_archetype ("largenugget");
		1361	object *small = get_archetype ("smallnugget");
		1362
1671	/* Put a maximum weight of items that can be alchemied. Limits the power	1363	/* 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	1364	* some, and also prevents people from alchemising every table/chair/clock
1673	* in sight	1365	* in sight
1674	*/	1366	*/
1675	weight_max = spell_ob->duration + +SP_level_duration_adjust (caster, spell_ob);	1367	int duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1676	weight_max *= 1000;	1368	int weight_max = duration * 1000;
1677	small = get_archetype ("smallnugget"), large = get_archetype ("largenugget");	1369	uint64 value_max = duration * 1000;
1678		1370
		1371	int weight = 0;
		1372
1679	for (y = op->y - 1; y <= op->y + 1; y++)	1373	for (int y = op->y - 1; y <= op->y + 1; y++)
1680	{	1374	{
1681	for (x = op->x - 1; x <= op->x + 1; x++)	1375	for (int x = op->x - 1; x <= op->x + 1; x++)
1682	{	1376	{
		1377	uint64 value = 0;
		1378
1683	nx = x;	1379	sint16 nx = x;
1684	ny = y;	1380	sint16 ny = y;
1685		1381
1686	mp = op->map;	1382	maptile *mp = op->map;
1687		1383
1688	mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);	1384	int mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);
1689		1385
1690	if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))	1386	if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))
1691	continue;	1387	continue;
1692		1388
1693	/* Treat alchemy a little differently - most spell effects	1389	/* Treat alchemy a little differently - most spell effects
…		…
1695	* ground level effect.	1391	* ground level effect.
1696	*/	1392	*/
1697	if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)	1393	if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)
1698	continue;	1394	continue;
1699		1395
1700	small_nuggets = 0;	1396	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	{	1397	{
1705	next = tmp->above;	1398	next = tmp->above;
		1399
1706	if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&	1400	if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&
1707	!QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))	1401	!QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))
1708	{	1402	{
1709
1710	if (tmp->inv)	1403	if (tmp->inv)
1711	{	1404	{
1712	object *next1, *tmp1;	1405	object *next1, *tmp1;
1713		1406
1714	for (tmp1 = tmp->inv; tmp1 != NULL; tmp1 = next1)	1407	for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1715	{	1408	{
1716	next1 = tmp1->below;	1409	next1 = tmp1->below;
1717	if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&	1410	if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&
1718	!QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))	1411	!QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))
1719	alchemy_object (tmp1, &small_nuggets, &large_nuggets, &weight);	1412	alchemy_object (tmp1, value, weight);
1720	}	1413	}
1721	}	1414	}
		1415
1722	alchemy_object (tmp, &small_nuggets, &large_nuggets, &weight);	1416	alchemy_object (tmp, value, weight);
1723		1417
1724	if (weight > weight_max)	1418	if (weight > weight_max)
1725	{	1419	break;
1726	update_map (op, mp, small_nuggets, large_nuggets, nx, ny);
1727	large->destroy ();
1728	small->destroy ();
1729	return 1;
1730	}	1420	}
1731	} /* is alchemable object */	1421	}
1732	} /* process all objects on this space */	1422
		1423	value = min (value, value_max);
		1424
		1425	uint64 count = value / large->value;
		1426	int large_nuggets = count;
		1427	value -= count * large->value;
		1428
		1429	count = value / small->value;
		1430	int small_nuggets = count;
1733		1431
1734	/* Insert all the nuggets at one time. This probably saves time, but	1432	/* Insert all the nuggets at one time. This probably saves time, but
1735	* it also prevents us from alcheming nuggets that were just created	1433	* it also prevents us from alcheming nuggets that were just created
1736	* with this spell.	1434	* with this spell.
1737	*/	1435	*/
1738	update_map (op, mp, small_nuggets, large_nuggets, nx, ny);	1436	update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny);
1739	}
1740	}
1741		1437
		1438	if (weight > weight_max)
		1439	goto bailout;
		1440	}
		1441	}
		1442
		1443	bailout:
1742	large->destroy ();	1444	large->destroy ();
1743	small->destroy ();	1445	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;	1446	return 1;
1749	}	1447	}
1750		1448
1751		1449
1752	/* This function removes the cursed/damned status on equipped	1450	/* This function removes the cursed/damned status on equipped
…		…
1779	}	1477	}
1780		1478
1781	if (op->type == PLAYER)	1479	if (op->type == PLAYER)
1782	{	1480	{
1783	if (success)	1481	if (success)
1784	{
1785	new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");	1482	new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");
1786	}
1787	else	1483	else
1788	{	1484	{
1789	if (was_one)	1485	if (was_one)
1790	new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");	1486	new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");
1791	else	1487	else
…		…
1815	{	1511	{
1816	identify (tmp);	1512	identify (tmp);
1817		1513
1818	if (op->type == PLAYER)	1514	if (op->type == PLAYER)
1819	{	1515	{
1820	new_draw_info_format (NDI_UNIQUE, 0, op, "You have %s.", long_desc (tmp, op));	1516	new_draw_info_format (NDI_UNIQUE, 0, op, "You identified: %s.", long_desc (tmp, op));
1821		1517
1822	if (tmp->msg)	1518	if (tmp->msg)
1823	{	1519	{
1824	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");	1520	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1825	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);	1521	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
…		…
1837	* stuff on the floor. Only identify stuff on the floor if the spell	1533	* stuff on the floor. Only identify stuff on the floor if the spell
1838	* was not fully used.	1534	* was not fully used.
1839	*/	1535	*/
1840	if (num_ident)	1536	if (num_ident)
1841	{	1537	{
1842	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	1538	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))	1539	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1844	{	1540	{
1845	identify (tmp);	1541	identify (tmp);
1846		1542
1847	if (op->type == PLAYER)	1543	if (op->type == PLAYER)
1848	{	1544	{
1849	new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op));	1545	new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground you identified: %s.", long_desc (tmp, op));
1850		1546
1851	if (tmp->msg)	1547	if (tmp->msg)
1852	{	1548	{
1853	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");	1549	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1854	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);	1550	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
…		…
1998	*/	1694	*/
1999	if (done_one)	1695	if (done_one)
2000	{	1696	{
2001	object *detect_ob = arch_to_object (spell->other_arch);	1697	object *detect_ob = arch_to_object (spell->other_arch);
2002		1698
2003	detect_ob->x = nx;
2004	detect_ob->y = ny;
2005	/* if this is set, we want to copy the face */	1699	/* if this is set, we want to copy the face */
2006	if (done_one == 2 && detect)	1700	if (done_one == 2 && detect)
2007	{	1701	{
2008	detect_ob->face = detect->face;	1702	detect_ob->face = detect->face;
2009	detect_ob->animation_id = detect->animation_id;	1703	detect_ob->animation_id = detect->animation_id;
…		…
2011	detect_ob->last_anim = 0;	1705	detect_ob->last_anim = 0;
2012	/* by default, the detect_ob is already animated */	1706	/* by default, the detect_ob is already animated */
2013	if (!QUERY_FLAG (detect, FLAG_ANIMATE))	1707	if (!QUERY_FLAG (detect, FLAG_ANIMATE))
2014	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);	1708	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
2015	}	1709	}
		1710
2016	insert_ob_in_map (detect_ob, m, op, 0);	1711	m->insert (detect_ob, nx, ny, op);
2017	}	1712	}
2018	} /* for processing the surrounding spaces */	1713	} /* for processing the surrounding spaces */
2019		1714
2020		1715
2021	/* Now process objects in the players inventory if detect curse or magic */	1716	/* Now process objects in the players inventory if detect curse or magic */
…		…
2070		1765
2071	/* Explodes a fireball centered at player */	1766	/* Explodes a fireball centered at player */
2072	tmp = get_archetype (EXPLODING_FIREBALL);	1767	tmp = get_archetype (EXPLODING_FIREBALL);
2073	tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;	1768	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;	1769	tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
2075	tmp->x = victim->x;	1770
2076	tmp->y = victim->y;	1771	tmp->insert_at (victim);
2077	insert_ob_in_map (tmp, victim->map, NULL, 0);
2078	victim->stats.sp = 2 * victim->stats.maxsp;	1772	victim->stats.sp = 2 * victim->stats.maxsp;
2079	}	1773	}
2080	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)	1774	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.");	1775	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)	1776	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
2085	{
2086	new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");	1777	new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
2087	}
2088	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)	1778	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
2089	{	1779	{
2090	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");	1780	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
2091	confuse_player (victim, victim, 99);	1781	confuse_player (victim, victim, 99);
2092	}	1782	}
2093	else if (victim->stats.sp >= victim->stats.maxsp * 1.25)	1783	else if (victim->stats.sp >= victim->stats.maxsp * 1.25)
2094	{
2095	new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");	1784	new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");
2096	}
2097	}	1785	}
2098		1786
2099	/* cast_transfer	1787	/* cast_transfer
2100	* This spell transfers sp from the player to another person.	1788	* This spell transfers sp from the player to another person.
2101	* We let the target go above their normal maximum SP.	1789	* We let the target go above their normal maximum SP.
…		…
2212	/* Basically, if the object is magical and not counterspell,	1900	/* Basically, if the object is magical and not counterspell,
2213	* we will more or less remove the object. Don't counterspell	1901	* we will more or less remove the object. Don't counterspell
2214	* monsters either.	1902	* monsters either.
2215	*/	1903	*/
2216		1904
2217	if (head->attacktype & AT_MAGIC &&	1905	if (head->attacktype & AT_MAGIC
2218	!(head->attacktype & AT_COUNTERSPELL) && !QUERY_FLAG (head, FLAG_MONSTER) && (op->level > head->level))	1906	&& !(head->attacktype & AT_COUNTERSPELL)
		1907	&& !QUERY_FLAG (head, FLAG_MONSTER)
		1908	&& (op->level > head->level))
2219	head->destroy ();	1909	head->destroy ();
2220	else	1910	else
2221	switch (head->type)	1911	switch (head->type)
2222	{	1912	{
2223	case SPELL_EFFECT:	1913	case SPELL_EFFECT:
		1914	// XXX: Don't affect floor spelleffects. See also XXX comment
		1915	// about sanctuary in spell_util.C
		1916	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
		1917	continue;
		1918
2224	if (op->level > head->level)	1919	if (op->level > head->level)
2225	head->destroy ();	1920	head->destroy ();
2226		1921
2227	break;	1922	break;
2228		1923
…		…
2295	* This code was very odd - code early on would only let players use the spell,	1990	* 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	1991	* 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	1992	* that only let players use it was correct, and removed all the other
2298	* player checks. MSW 2003-01-06	1993	* player checks. MSW 2003-01-06
2299	*/	1994	*/
2300
2301	int	1995	int
2302	animate_weapon (object *op, object *caster, object *spell, int dir)	1996	animate_weapon (object *op, object *caster, object *spell, int dir)
2303	{	1997	{
2304	object *weapon, *tmp;	1998	object *weapon, *tmp;
2305	char buf[MAX_BUF];	1999	char buf[MAX_BUF];
2306	int a, i;	2000	int a, i;
2307	sint16 x, y;	2001	sint16 x, y;
2308	maptile *m;	2002	maptile *m;
2309	materialtype_t *mt;
2310		2003
2311	if (!spell->other_arch)	2004	if (!spell->other_arch)
2312	{	2005	{
2313	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	2006	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
2314	LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);	2007	LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);
…		…
2317	/* exit if it's not a player using this spell. */	2010	/* exit if it's not a player using this spell. */
2318	if (op->type != PLAYER)	2011	if (op->type != PLAYER)
2319	return 0;	2012	return 0;
2320		2013
2321	/* if player already has a golem, abort */	2014	/* if player already has a golem, abort */
2322	if (op->contr->ranges[range_golem])	2015	if (object *golem = op->contr->golem)
2323	{	2016	{
2324	control_golem (op->contr->ranges[range_golem], dir);	2017	control_golem (golem, dir);
2325	return 0;	2018	return 0;
2326	}	2019	}
2327		2020
2328	/* if no direction specified, pick one */	2021	/* if no direction specified, pick one */
2329	if (!dir)	2022	if (!dir)
…		…
2333	x = op->x + freearr_x[dir];	2026	x = op->x + freearr_x[dir];
2334	y = op->y + freearr_y[dir];	2027	y = op->y + freearr_y[dir];
2335		2028
2336	/* if there's no place to put the golem, abort */	2029	/* 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) ||	2030	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))	2031	((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2339	{	2032	{
2340	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	2033	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
2341	return 0;	2034	return 0;
2342	}	2035	}
2343		2036
…		…
2347	if (!weapon)	2040	if (!weapon)
2348	{	2041	{
2349	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");	2042	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
2350	return 0;	2043	return 0;
2351	}	2044	}
2352	if (spell->race && strcmp (weapon->arch->name, spell->race))	2045	if (spell->race && strcmp (weapon->arch->archname, spell->race))
2353	{	2046	{
2354	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");	2047	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
2355	return 0;	2048	return 0;
2356	}	2049	}
2357	if (weapon->type != WEAPON)	2050	if (weapon->type != WEAPON)
…		…
2375	/* create the golem object */	2068	/* create the golem object */
2376	tmp = arch_to_object (spell->other_arch);	2069	tmp = arch_to_object (spell->other_arch);
2377		2070
2378	/* if animated by a player, give the player control of the golem */	2071	/* if animated by a player, give the player control of the golem */
2379	CLEAR_FLAG (tmp, FLAG_MONSTER);	2072	CLEAR_FLAG (tmp, FLAG_MONSTER);
2380	SET_FLAG (tmp, FLAG_FRIENDLY);
2381	tmp->stats.exp = 0;	2073	tmp->stats.exp = 0;
2382	add_friendly_object (tmp);	2074	add_friendly_object (tmp);
2383	tmp->type = GOLEM;	2075	tmp->type = GOLEM;
2384	tmp->set_owner (op);	2076	tmp->set_owner (op);
		2077	op->contr->golem = tmp;
2385	set_spell_skill (op, caster, spell, tmp);	2078	set_spell_skill (op, caster, spell, tmp);
2386	op->contr->ranges[range_golem] = tmp;
2387	op->contr->shoottype = range_golem;
2388		2079
2389	/* Give the weapon to the golem now. A bit of a hack to check the	2080	/* 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	2081	* removed flag - it should only be set if get_split_object was
2391	* used above.	2082	* used above.
2392	*/	2083	*/
2393	if (!QUERY_FLAG (weapon, FLAG_REMOVED))	2084	if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2394	weapon->remove ();	2085	weapon->remove ();
		2086
2395	insert_ob_in_ob (weapon, tmp);	2087	insert_ob_in_ob (weapon, tmp);
2396	esrv_send_item (op, weapon);	2088	esrv_send_item (op, weapon);
2397	/* To do everything necessary to let a golem use the weapon is a pain,	2089	/* 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	2090	* so instead, just set it as equipped (otherwise, we need to update
2399	* body_info, skills, etc)	2091	* body_info, skills, etc)
…		…
2427		2119
2428	/* attacktype */	2120	/* attacktype */
2429	if (!tmp->attacktype)	2121	if (!tmp->attacktype)
2430	tmp->attacktype = AT_PHYSICAL;	2122	tmp->attacktype = AT_PHYSICAL;
2431		2123
2432	mt = NULL;
2433	if (op->materialname != NULL)
2434	mt = name_to_material (op->materialname);	2124	if (materialtype_t *mt = name_to_material (op->materialname))
2435	if (mt != NULL)
2436	{	2125	{
2437	for (i = 0; i < NROFATTACKS; i++)	2126	for (i = 0; i < NROFATTACKS; i++)
2438	tmp->resist[i] = 50 - (mt->save[i] * 5);	2127	tmp->resist[i] = 50 - (mt->save[i] * 5);
2439	a = mt->save[0];	2128	a = mt->save[0];
2440	}	2129	}
…		…
2442	{	2131	{
2443	for (i = 0; i < NROFATTACKS; i++)	2132	for (i = 0; i < NROFATTACKS; i++)
2444	tmp->resist[i] = 5;	2133	tmp->resist[i] = 5;
2445	a = 10;	2134	a = 10;
2446	}	2135	}
		2136
2447	/* Set weapon's immunity */	2137	/* Set weapon's immunity */
2448	tmp->resist[ATNR_CONFUSION] = 100;	2138	tmp->resist[ATNR_CONFUSION] = 100;
2449	tmp->resist[ATNR_POISON] = 100;	2139	tmp->resist[ATNR_POISON] = 100;
2450	tmp->resist[ATNR_SLOW] = 100;	2140	tmp->resist[ATNR_SLOW] = 100;
2451	tmp->resist[ATNR_PARALYZE] = 100;	2141	tmp->resist[ATNR_PARALYZE] = 100;
…		…
2457		2147
2458	/* Improve weapon's armour value according to best save vs. physical of its material */	2148	/* Improve weapon's armour value according to best save vs. physical of its material */
2459		2149
2460	if (a > 14)	2150	if (a > 14)
2461	a = 14;	2151	a = 14;
		2152
2462	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));	2153	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2463		2154
2464	/* Determine golem's speed */	2155	/* Determine golem's speed */
2465	tmp->speed = 0.4 + 0.1 * SP_level_range_adjust (caster, spell);	2156	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		2157
2470	if (!spell->race)	2158	if (!spell->race)
2471	{	2159	{
2472	sprintf (buf, "animated %s", &weapon->name);	2160	sprintf (buf, "animated %s", &weapon->name);
2473	tmp->name = buf;	2161	tmp->name = buf;
…		…
2475	tmp->face = weapon->face;	2163	tmp->face = weapon->face;
2476	tmp->animation_id = weapon->animation_id;	2164	tmp->animation_id = weapon->animation_id;
2477	tmp->anim_speed = weapon->anim_speed;	2165	tmp->anim_speed = weapon->anim_speed;
2478	tmp->last_anim = weapon->last_anim;	2166	tmp->last_anim = weapon->last_anim;
2479	tmp->state = weapon->state;	2167	tmp->state = weapon->state;
2480	if (QUERY_FLAG (weapon, FLAG_ANIMATE))	2168	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	}	2169	}
2490		2170
2491	/* make experience increase in proportion to the strength of the summoned creature. */	2171	/* 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));	2172	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));
2493		2173
2494	tmp->speed_left = -1;	2174	tmp->speed_left = -1;
2495	tmp->x = x;
2496	tmp->y = y;
2497	tmp->direction = dir;	2175	tmp->direction = dir;
2498	insert_ob_in_map (tmp, m, op, 0);	2176
		2177	m->insert (tmp, x, y, op);
2499	return 1;	2178	return 1;
2500	}	2179	}
2501		2180
2502	/* cast_daylight() - changes the map darkness level *lower* */	2181	/* cast_daylight() - changes the map darkness level *lower* */
2503		2182
…		…
2511	int success;	2190	int success;
2512		2191
2513	if (!op->map)	2192	if (!op->map)
2514	return 0; /* shouldnt happen */	2193	return 0; /* shouldnt happen */
2515		2194
2516	success = change_map_light (op->map, spell->stats.dam);	2195	success = op->map->change_map_light (spell->stats.dam);
		2196
2517	if (!success)	2197	if (!success)
2518	{	2198	{
2519	if (spell->stats.dam < 0)	2199	if (spell->stats.dam < 0)
2520	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");	2200	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2521	else	2201	else
…		…
2598	{	2278	{
2599	aura->destroy ();	2279	aura->destroy ();
2600	return;	2280	return;
2601	}	2281	}
2602		2282
2603	aura->x = env->x;
2604	aura->y = env->y;
2605
2606	/* we need to jump out of the inventory for a bit	2283	/* we need to jump out of the inventory for a bit
2607	* in order to hit the map conveniently.	2284	* in order to hit the map conveniently.
2608	*/	2285	*/
2609	insert_ob_in_map (aura, env->map, aura, 0);	2286	aura->insert_at (env, aura);
2610		2287
2611	for (i = 1; i < 9; i++)	2288	for (i = 1; i < 9; i++)
2612	{	2289	{
2613	sint16 nx, ny;	2290	sint16 nx, ny;
2614		2291
…		…
2623	if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))	2300	if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))
2624	{	2301	{
2625	hit_map (aura, i, aura->attacktype, 0);	2302	hit_map (aura, i, aura->attacktype, 0);
2626		2303
2627	if (aura->other_arch)	2304	if (aura->other_arch)
2628	{	2305	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	}	2306	}
2636	}
2637	}	2307	}
		2308
2638	/* put the aura back in the player's inventory */	2309	/* put the aura back in the player's inventory */
2639	aura->remove ();	2310	aura->remove ();
2640	insert_ob_in_ob (aura, env);	2311	insert_ob_in_ob (aura, env);
2641	}	2312	}
2642		2313
…		…
2723		2394
2724	snprintf (rune, sizeof (rune), "%s\n", msg);	2395	snprintf (rune, sizeof (rune), "%s\n", msg);
2725		2396
2726	tmp->race = op->name; /*Save the owner of the rune */	2397	tmp->race = op->name; /*Save the owner of the rune */
2727	tmp->msg = rune;	2398	tmp->msg = rune;
2728	tmp->x = op->x;	2399
2729	tmp->y = op->y;	2400	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2730	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
2731	return 1;	2401	return 1;
2732	}	2402	}

Diff Legend

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