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.45 by root, Mon Apr 16 06:23:43 2007 UTC vs.
Revision 1.95 by root, Thu Jan 1 16:05:13 2009 UTC

1	/*	1	/*
2	* CrossFire, A Multiplayer game for X-windows	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team	4	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
9	* 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
10	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your option) any later version.	11	* (at your option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*	20	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	22	*/
24		23
25	#include <global.h>	24	#include <global.h>
26	#include <object.h>	25	#include <object.h>
27	#include <living.h>	26	#include <living.h>
…		…
62	{	61	{
63	object *wand, *tmp;	62	object *wand, *tmp;
64	int ncharges;	63	int ncharges;
65		64
66	wand = find_marked_object (op);	65	wand = find_marked_object (op);
67	if (wand == NULL || wand->type != WAND)	66	if (!wand || wand->type != WAND)
68	{	67	{
69	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");	68	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");
70	return 0;	69	return 0;
71	}	70	}
72	if (!(random_roll (0, 3, op, PREFER_HIGH)))	71	if (!(random_roll (0, 3, op, PREFER_HIGH)))
73	{	72	{
74	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));	73	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));
75	play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE);	74	op->play_sound (sound_find ("ob_explode"));
76	esrv_del_item (op->contr, wand->count);
77	wand->destroy ();	75	wand->destroy ();
78	tmp = get_archetype ("fireball");	76	tmp = get_archetype ("fireball");
79	tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;	77	tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
80		78
81	if (!tmp->stats.dam)	79	if (!tmp->stats.dam)
…		…
104	ncharges = 1;	102	ncharges = 1;
105		103
106	wand->stats.food += ncharges;	104	wand->stats.food += ncharges;
107	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));	105	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
108		106
109	if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE))	107	if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE))
110	{	108	{
111	SET_FLAG (wand, FLAG_ANIMATE);	109	SET_FLAG (wand, FLAG_ANIMATE);
112	wand->set_speed (wand->arch->clone.speed);	110	wand->set_speed (wand->arch->speed);
113	}	111	}
114		112
115	return 1;	113	return 1;
116	}	114	}
117		115
…		…
123	* great a plus, the default is used.	121	* great a plus, the default is used.
124	* The # of arrows created also goes up with level, so if a 30th level mage	122	* The # of arrows created also goes up with level, so if a 30th level mage
125	* wants LOTS of arrows, and doesn't care what the plus is he could	123	* wants LOTS of arrows, and doesn't care what the plus is he could
126	* create nonnmagic arrows, or even -1, etc...	124	* create nonnmagic arrows, or even -1, etc...
127	*/	125	*/
128
129	int	126	int
130	cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg)	127	cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg)
131	{	128	{
132	int missile_plus = 0, bonus_plus = 0;	129	int bonus_plus = 0;
133	const char *missile_name;	130	const char *missile_name = "arrow";
134	object *tmp, *missile;
135		131
136	missile_name = "arrow";
137
138	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	132	for (object *tmp = op->inv; tmp; tmp = tmp->below)
139	if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))	133	if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
140	missile_name = tmp->race;	134	missile_name = tmp->race;
141		135
142	missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);	136	int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
143		137
144	if (archetype::find (missile_name) == NULL)	138	archetype *missile_arch = archetype::find (missile_name);
		139
		140	if (!missile_arch)
145	{	141	{
146	LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);	142	LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);
147	return 0;	143	return 0;
148	}	144	}
149		145
150	missile = get_archetype (missile_name);	146	object *missile = missile_arch->instance ();
151		147
152	if (stringarg)	148	if (stringarg)
153	{	149	{
154	/* If it starts with a letter, presume it is a description */	150	/* If it starts with a letter, presume it is a description */
155	if (isalpha (*stringarg))	151	if (isalpha (*stringarg))
…		…
173	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg);	169	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg);
174	return 0;	170	return 0;
175	}	171	}
176		172
177	give_artifact_abilities (missile, al->item);	173	give_artifact_abilities (missile, al->item);
178	/* These special arrows cost something extra. Don't have them also be magical -	174	/* These special arrows cost something extra. Don't have them also be magical -
179	* otherwise, in most cases, not enough will be created. I don't want to get into	175	* otherwise, in most cases, not enough will be created. I don't want to get into
180	* the parsing of having to do both plus and type.	176	* the parsing of having to do both plus and type.
181	*/	177	*/
182	bonus_plus = 1 + (al->item->value / 5);	178	bonus_plus = 1 + (al->item->value / 5);
183	missile_plus = 0;	179	missile_plus = 0;
184	}	180	}
185	else if (atoi (stringarg) < missile_plus)	181	else if (atoi (stringarg) < missile_plus)
186	missile_plus = atoi (stringarg);	182	missile_plus = atoi (stringarg);
187	}	183	}
188		184
189	if (missile_plus > 4)	185	missile_plus = clamp (missile_plus, -4, 4);
190	missile_plus = 4;
191	else if (missile_plus < -4)
192	missile_plus = -4;
193		186
194	missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);	187	missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
195	missile->nrof -= 3 * (missile_plus + bonus_plus);	188	missile->nrof -= 3 * (missile_plus + bonus_plus);
196		189
197	if (missile->nrof < 1)	190	if (missile->nrof < 1)
…		…
217	{	210	{
218	int food_value;	211	int food_value;
219	archetype *at = NULL;	212	archetype *at = NULL;
220	object *new_op;	213	object *new_op;
221		214
222	food_value = spell_ob->stats.food + +50 * SP_level_duration_adjust (caster, spell_ob);	215	food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);
223		216
224	if (stringarg)	217	if (stringarg)
225	{	218	{
226	at = find_archetype_by_object_type_name (FOOD, stringarg);	219	at = find_archetype_by_object_type_name (FOOD, stringarg);
227	if (at == NULL)	220	if (at == NULL)
228	at = find_archetype_by_object_type_name (DRINK, stringarg);	221	at = find_archetype_by_object_type_name (DRINK, stringarg);
229	if (at == NULL || at->clone.stats.food > food_value)	222	if (at == NULL || at->stats.food > food_value)
230	stringarg = NULL;	223	stringarg = NULL;
231	}	224	}
232		225
233	if (!stringarg)	226	if (!stringarg)
234	{	227	{
…		…
240	* We don't use flesh types because the weight values of those need	233	* We don't use flesh types because the weight values of those need
241	* to be altered from the donor.	234	* to be altered from the donor.
242	*/	235	*/
243		236
244	/* We assume the food items don't have multiple parts */	237	/* We assume the food items don't have multiple parts */
245	for (at_tmp = first_archetype; at_tmp != NULL; at_tmp = at_tmp->next)	238	for_all_archetypes (at_tmp)
246	{	239	{
247	if (at_tmp->clone.type == FOOD || at_tmp->clone.type == DRINK)	240	if (at_tmp->type == FOOD || at_tmp->type == DRINK)
248	{	241	{
249	/* Basically, if the food value is something that is creatable	242	/* Basically, if the food value is something that is creatable
250	* under the limits of the spell and it is higher than	243	* under the limits of the spell and it is higher than
251	* the item we have now, take it instead.	244	* the item we have now, take it instead.
252	*/	245	*/
253	if (at_tmp->clone.stats.food <= food_value && (!at || at_tmp->clone.stats.food > at->clone.stats.food))	246	if (at_tmp->stats.food <= food_value
		247	&& (!at
		248	|| at_tmp->stats.food > at->stats.food
		249	|| (at_tmp->stats.food == at->stats.food
		250	&& at_tmp->weight < at->weight)))
254	at = at_tmp;	251	at = at_tmp;
255	}	252	}
256	}	253	}
257	}	254	}
		255
258	/* Pretty unlikely (there are some very low food items), but you never	256	/* Pretty unlikely (there are some very low food items), but you never
259	* know	257	* know
260	*/	258	*/
261	if (!at)	259	if (!at)
262	{	260	{
263	new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");	261	new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");
264	return 0;	262	return 0;
265	}	263	}
266		264
267	food_value /= at->clone.stats.food;	265	food_value /= at->stats.food;
268	new_op = arch_to_object (at);	266	new_op = arch_to_object (at);
269	new_op->nrof = food_value;	267	new_op->nrof = food_value;
270		268
271	new_op->value = 0;	269	new_op->value = 0;
272	if (new_op->nrof < 1)	270	if (new_op->nrof < 1)
…		…
281	{	279	{
282	int r, mflags, maxrange;	280	int r, mflags, maxrange;
283	object *tmp;	281	object *tmp;
284	maptile *m;	282	maptile *m;
285		283
286
287	if (!dir)	284	if (!dir)
288	{	285	{
289	examine_monster (op, op);	286	examine_monster (op, op);
290	return 1;	287	return 1;
291	}	288	}
		289
292	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	290	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
293	for (r = 1; r < maxrange; r++)	291	for (r = 1; r < maxrange; r++)
294	{	292	{
295	sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];	293	sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];
296		294
…		…
303	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))	301	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))
304	{	302	{
305	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");	303	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
306	return 0;	304	return 0;
307	}	305	}
		306
308	if (mflags & P_IS_ALIVE)	307	if (mflags & P_IS_ALIVE)
309	{	308	{
310	for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)	309	for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
311	if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))	310	if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))
312	{	311	{
313	new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");	312	new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
314	if (tmp->head != NULL)	313	if (tmp->head != NULL)
315	tmp = tmp->head;	314	tmp = tmp->head;
316	examine_monster (op, tmp);	315	examine_monster (op, tmp);
317	return 1;	316	return 1;
318	}	317	}
319	}	318	}
320	}	319	}
		320
321	new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");	321	new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");
322	return 1;	322	return 1;
323	}	323	}
324
325		324
326	/* This checks to see if 'pl' is invisible to 'mon'.	325	/* This checks to see if 'pl' is invisible to 'mon'.
327	* does race check, undead check, etc	326	* does race check, undead check, etc
328	* Returns TRUE if mon can't see pl, false	327	* Returns TRUE if mon can't see pl, false
329	* otherwise. This doesn't check range, walls, etc. It	328	* otherwise. This doesn't check range, walls, etc. It
…		…
331	* pl is invisible.	330	* pl is invisible.
332	*/	331	*/
333	int	332	int
334	makes_invisible_to (object *pl, object *mon)	333	makes_invisible_to (object *pl, object *mon)
335	{	334	{
336
337	if (!pl->invisible)	335	if (!pl->invisible)
338	return 0;	336	return 0;
		337
339	if (pl->type == PLAYER)	338	if (pl->type == PLAYER)
340	{	339	{
341	/* If race isn't set, then invisible unless it is undead */	340	/* If race isn't set, then invisible unless it is undead */
342	if (!pl->contr->invis_race)	341	if (!pl->contr->invis_race)
343	{	342	{
344	if (QUERY_FLAG (mon, FLAG_UNDEAD))	343	if (QUERY_FLAG (mon, FLAG_UNDEAD))
345	return 0;	344	return 0;
		345
346	return 1;	346	return 1;
347	}	347	}
		348
348	/* invis_race is set if we get here */	349	/* invis_race is set if we get here */
349	if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon))	350	if (pl->contr->invis_race == shstr_undead && is_true_undead (mon))
350	return 1;	351	return 1;
		352
351	/* No race, can't be invisible to it */	353	/* No race, can't be invisible to it */
352	if (!mon->race)	354	if (!mon->race)
353	return 0;	355	return 0;
		356
354	if (strstr (mon->race, pl->contr->invis_race))	357	if (mon->race.contains (pl->contr->invis_race))
355	return 1;	358	return 1;
		359
356	/* Nothing matched above, return 0 */	360	/* Nothing matched above, return 0 */
357	return 0;	361	return 0;
358	}	362	}
359	else	363	else
360	{	364	{
…		…
462	if (object *pl = op->in_player ())	466	if (object *pl = op->in_player ())
463	{	467	{
464	if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))	468	if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
465	new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");	469	new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
466	else	470	else
467	{	471	pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);
468	// remove first so we do not call update_stats
469	op->remove ();
470	pl->enter_exit (op);
471	}
472	}	472	}
473		473
474	op->destroy ();	474	op->destroy ();
475	}	475	}
476		476
…		…
492	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");	492	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
493	return 1;	493	return 1;
494	}	494	}
495		495
496	dummy = get_archetype (FORCE_NAME);	496	dummy = get_archetype (FORCE_NAME);
497	if (dummy == NULL)	497
		498	if (!dummy)
498	{	499	{
499	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	500	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
500	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");	501	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
501	return 0;	502	return 0;
502	}	503	}
…		…
565	}	566	}
566		567
567	int	568	int
568	perceive_self (object *op)	569	perceive_self (object *op)
569	{	570	{
570	char buf[MAX_BUF];
571	const char *cp = describe_item (op, op);	571	const char *cp = describe_item (op, op);
572	archetype *at = archetype::find (ARCH_DEPLETION);	572	archetype *at = archetype::find (ARCH_DEPLETION);
573	object *tmp;
574	int i;
575		573
		574	dynbuf_text buf;
		575
		576	if (player *pl = op->contr)
		577	if (object *race = archetype::find (op->race))
		578	buf << " - You are a G<male|female> " << &race->name << ".\n";
		579
576	tmp = find_god (determine_god (op));	580	if (object *god = find_god (determine_god (op)))
577	if (tmp)	581	buf << " - You worship " << &god->name << ".\n";
578	new_draw_info_format (NDI_UNIQUE, 0, op, "You worship %s", &tmp->name);
579	else	582	else
580	new_draw_info (NDI_UNIQUE, 0, op, "You worship no god");	583	buf << " - You worship no god.\n";
581		584
582	tmp = present_arch_in_ob (at, op);	585	object *tmp = present_arch_in_ob (at, op);
583		586
584	if (*cp == '\0' && tmp == NULL)	587	if (*cp == '\0' && !tmp)
585	new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane");	588	buf << " - You feel very mundane. ";
586	else	589	else
587	{	590	{
588	new_draw_info (NDI_UNIQUE, 0, op, "You have:");	591	buf << " - You have: " << cp << ".\n";
589	new_draw_info (NDI_UNIQUE, 0, op, cp);	592
590	if (tmp != NULL)	593	if (tmp)
591	{
592	for (i = 0; i < NUM_STATS; i++)	594	for (int i = 0; i < NUM_STATS; i++)
593	{	595	if (tmp->stats.stat (i) < 0)
594	if (get_attr_value (&tmp->stats, i) < 0)	596	buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
595	{
596	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is depleted by %d", statname[i], -(get_attr_value (&tmp->stats, i)));
597	}
598	}
599	}
600	}	597	}
601		598
602	if (is_dragon_pl (op))	599	if (is_dragon_pl (op))
603	{
604	/* now grab the 'dragon_ability'-force from the player's inventory */	600	/* now grab the 'dragon_ability'-force from the player's inventory */
605	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	601	for (tmp = op->inv; tmp; tmp = tmp->below)
606	{	602	{
607	if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force"))	603	if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
608	{	604	{
609	if (tmp->stats.exp == 0)	605	if (tmp->stats.exp == 0)
610	sprintf (buf, "Your metabolism isn't focused on anything.");	606	buf << " - Your metabolism isn't focused on anything.\n";
611	else	607	else
612	sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]);	608	buf << " - Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
613		609
614	new_draw_info (NDI_UNIQUE, 0, op, buf);
615	break;	610	break;
616	}	611	}
617	}	612	}
618	}
619		613
620	return 1;	614	buf << '\0'; // zero-terminate
621	}
622		615
623	/* int cast_create_town_portal (object *op, object *caster, int dir)	616	new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ());
624	*
625	* This function cast the spell of town portal for op
626	*
627	* The spell operates in two passes. During the first one a place
628	* is marked as a destination for the portal. During the second one,
629	* 2 portals are created, one in the position the player cast it and
630	* one in the destination place. The portal are synchronized and 2 forces
631	* are inserted in the player to destruct the portal next time player
632	* creates a new portal pair.
633	* This spell has a side effect that it allows people to meet each other
634	* in a permanent, private, appartements by making a town portal from it
635	* to the town or another public place. So, check if the map is unique and if
636	* so return an error
637	*
638	* Code by Tchize (david.delbecq@usa.net)
639	*/
640	int
641	cast_create_town_portal (object *op, object *caster, object *spell, int dir)
642	{
643	object *dummy, *force, *old_force;
644	archetype *perm_portal;
645	char portal_name[1024], portal_message[1024];
646	maptile *exitmap;
647	int op_level;
648
649	/* Check to see if the map the player is currently on is a per player unique
650	* map. This can be determined in that per player unique maps have the
651	* full pathname listed.
652	*/
653	if (!strncmp (op->map->path, settings.localdir, strlen (settings.localdir)) && settings.create_home_portals != TRUE)
654	{
655	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You can't cast that here.\n");
656	return 0;
657	}
658
659	/* The first thing to do is to check if we have a marked destination
660	* dummy is used to make a check inventory for the force
661	*/
662	dummy = arch_to_object (spell->other_arch);
663	if (dummy == NULL)
664	{
665	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
666	LOG (llevError, "object::create failed (force in cast_create_town_portal for %s!\n", &op->name);
667	return 0;
668	}
669
670	force = check_inv_recursive (op, dummy);
671
672	if (force == NULL)
673	{
674	/* Here we know there is no destination marked up.
675	* We have 2 things to do:
676	* 1. Mark the destination in the player inventory.
677	* 2. Let the player know it worked.
678	*/
679	dummy->name = op->map->path;
680	EXIT_X (dummy) = op->x;
681	EXIT_Y (dummy) = op->y;
682	insert_ob_in_ob (dummy, op);
683	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.");
684	return 1;
685	}
686
687	dummy->destroy ();
688
689	/* Here we know where the town portal should go to
690	* We should kill any existing portal associated with the player.
691	* Than we should create the 2 portals.
692	* For each of them, we need:
693	* - To create the portal with the name of the player+destination map
694	* - set the owner of the town portal
695	* - To mark the position of the portal in the player's inventory
696	* for easier destruction.
697	*
698	* The mark works has follow:
699	* slaying: Existing town portal
700	* hp, sp : x & y of the associated portal
701	* name : name of the portal
702	* race : map the portal is in
703	*/
704
705	/* First step: killing existing town portals */
706	dummy = get_archetype (spell->race);
707	if (dummy == NULL)
708	{
709	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
710	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
711	return 0;
712	}
713
714	perm_portal = archetype::find (spell->slaying);
715
716	/* To kill a town portal, we go trough the player's inventory,
717	* for each marked portal in player's inventory,
718	* -We try load the associated map (if impossible, consider the portal destructed)
719	* -We find any portal in the specified location.
720	* If it has the good name, we destruct it.
721	* -We destruct the force indicating that portal.
722	*/
723	while ((old_force = check_inv_recursive (op, dummy)))
724	{
725	exitmap = maptile::find_sync (old_force->race, op->map);
726
727	if (exitmap)
728	{
729	exitmap->load_sync ();
730
731	int exitx = EXIT_X (old_force);
732	int exity = EXIT_Y (old_force);
733
734	for (object *tmp = present_arch (perm_portal, exitmap, exitx, exity); tmp; tmp = tmp->above)
735	{
736	if (tmp->name == old_force->name)
737	{
738	tmp->destroy ();
739	break;
740	}
741	}
742	}
743
744	old_force->destroy ();
745	}
746
747	dummy->destroy ();
748
749	/* Creating the portals.
750	* The very first thing to do is to ensure
751	* access to the destination map.
752	* If we can't, don't fizzle. Simply warn player.
753	* This ensure player pays his mana for the spell
754	* because HE is responsible of forgotting.
755	* 'force' is the destination of the town portal, which we got
756	* from the players inventory above.
757	*/
758
759	/* Ensure exit map is loaded */
760	exitmap = maptile::find_sync (force->name);
761
762	/* If we were unable to load (ex. random map deleted), warn player */
763	if (!exitmap)
764	{
765	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens.\nYou can't remember where to go!?");
766	force->destroy ();
767	return 1;
768	}
769
770	exitmap->load_sync ();
771
772	op_level = caster_level (caster, spell);
773	if (op_level < 15)
774	snprintf (portal_message, 1024,
775	"\nThe air moves around you and\na huge smell of ammonia\nsurounds you as you pass\nthrough %s's tiny portal\nPouah!\n",
776	&op->name);
777	else if (op_level < 30)
778	snprintf (portal_message, 1024,
779	"\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);
780	else if (op_level < 60)
781	snprintf (portal_message, 1024, "\nA shining door opens in the air in front of you,\nshowing you the path to another place.\n");
782	else
783	snprintf (portal_message, 1024, "\nAs you walk through %s's portal, flowers come out\nfrom the ground around you.\nYou feel awed.\n",
784	&op->name);
785
786	/* Create a portal in front of player
787	* dummy contain the portal and
788	* force contain the track to kill it later
789	*/
790	snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name);
791	dummy = get_archetype (spell->slaying); /*The portal */
792	if (dummy == NULL)
793	{
794	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
795	LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
796	return 0;
797	}
798
799	EXIT_PATH (dummy) = force->name;
800	EXIT_X (dummy) = EXIT_X (force);
801	EXIT_Y (dummy) = EXIT_Y (force);
802	dummy->name = dummy->name_pl = portal_name;
803	dummy->msg = portal_message;
804	dummy->race = op->name; /*Save the owner of the portal */
805	cast_create_obj (op, caster, dummy, 0);
806
807	/* Now we need to to create a town portal marker inside the player
808	* object, so on future castings, we can know that he has an active
809	* town portal.
810	*/
811	object *tmp = get_archetype (spell->race);
812
813	if (!tmp)
814	{
815	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
816	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
817	return 0;
818	}
819
820	tmp->race = op->map->path;
821	tmp->name = portal_name;
822	EXIT_X (tmp) = dummy->x;
823	EXIT_Y (tmp) = dummy->y;
824	op->insert (tmp);
825
826	/* Create a portal in the destination map
827	* dummy contain the portal and
828	* force the track to kill it later
829	* the 'force' variable still contains the 'reminder' of
830	* where this portal goes to.
831	*/
832	snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &op->map->path);
833	dummy = get_archetype (spell->slaying); /*The portal */
834	if (dummy == NULL)
835	{
836	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
837	LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
838	return 0;
839	}
840
841	EXIT_PATH (dummy) = op->map->path;
842	EXIT_X (dummy) = op->x;
843	EXIT_Y (dummy) = op->y;
844	dummy->name = dummy->name_pl = portal_name;
845	dummy->msg = portal_message;
846	dummy->race = op->name; /*Save the owner of the portal */
847	exitmap->insert (dummy, EXIT_X (force), EXIT_Y (force), op);
848
849	/* Now we create another town portal marker that
850	* points back to the one we just made
851	*/
852	tmp = get_archetype (spell->race);
853	if (tmp == NULL)
854	{
855	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
856	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
857	return 0;
858	}
859
860	tmp->race = force->name;
861	tmp->name = portal_name;
862	EXIT_X (tmp) = dummy->x;
863	EXIT_Y (tmp) = dummy->y;
864	insert_ob_in_ob (tmp, op);
865
866	/* Describe the player what happened
867	*/
868	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You see air moving and showing you the way home.");
869	force->destroy ();
870		617
871	return 1;	618	return 1;
872	}	619	}
873		620
874	/* This creates magic walls. Really, it can create most any object,	621	/* This creates magic walls. Really, it can create most any object,
…		…
962	*/	709	*/
963	if (tmp->type != EARTHWALL) //TODO	710	if (tmp->type != EARTHWALL) //TODO
964	tmp->set_owner (op);	711	tmp->set_owner (op);
965		712
966	set_spell_skill (op, caster, spell_ob, tmp);	713	set_spell_skill (op, caster, spell_ob, tmp);
967	tmp->level = caster_level (caster, spell_ob) / 2;	714	tmp->level = casting_level (caster, spell_ob) / 2;
968		715
969	name = tmp->name;	716	name = tmp->name;
970	if (!(tmp = m->insert (tmp, x, y, op)))	717	if (!(tmp = m->insert (tmp, x, y, op)))
971	{	718	{
972	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);	719	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
973	return 0;	720	return 0;
974	}	721	}
975		722
976	/* If this is a spellcasting wall, need to insert the spell object */	723	/* If this is a spellcasting wall, need to insert the spell object */
977	if (tmp->other_arch && tmp->other_arch->clone.type == SPELL)	724	if (tmp->other_arch && tmp->other_arch->type == SPELL)
978	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);	725	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
979		726
980	/* This code causes the wall to extend some distance in	727	/* This code causes the wall to extend some distance in
981	* each direction, or until an obstruction is encountered.	728	* each direction, or until an obstruction is encountered.
982	* posblocked and negblocked help determine how far the	729	* posblocked and negblocked help determine how far the
…		…
1002	{	749	{
1003	object *tmp2 = tmp->clone ();	750	object *tmp2 = tmp->clone ();
1004	m->insert (tmp2, x, y, op);	751	m->insert (tmp2, x, y, op);
1005		752
1006	/* If this is a spellcasting wall, need to insert the spell object */	753	/* If this is a spellcasting wall, need to insert the spell object */
1007	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	754	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1008	tmp2->insert (arch_to_object (tmp2->other_arch));	755	tmp2->insert (arch_to_object (tmp2->other_arch));
1009		756
1010	}	757	}
1011	else	758	else
1012	posblocked = 1;	759	posblocked = 1;
…		…
1019	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)	766	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
1020	{	767	{
1021	object *tmp2 = tmp->clone ();	768	object *tmp2 = tmp->clone ();
1022	m->insert (tmp2, x, y, op);	769	m->insert (tmp2, x, y, op);
1023		770
1024	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	771	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1025	tmp2->insert (arch_to_object (tmp2->other_arch));	772	tmp2->insert (arch_to_object (tmp2->other_arch));
1026	}	773	}
1027	else	774	else
1028	negblocked = 1;	775	negblocked = 1;
1029	}	776	}
…		…
1145		892
1146	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */	893	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
1147	return 1;	894	return 1;
1148	}	895	}
1149		896
1150
1151	/* cast_heal: Heals something.	897	/* cast_heal: Heals something.
1152	* op is the caster.	898	* op is the caster.
1153	* dir is the direction he is casting it in.	899	* dir is the direction he is casting it in.
1154	* spell is the spell object.	900	* spell is the spell object.
1155	*/	901	*/
…		…
1181	{	927	{
1182	/* See how many points we actually heal. Instead of messages	928	/* See how many points we actually heal. Instead of messages
1183	* based on type of spell, we instead do messages based	929	* based on type of spell, we instead do messages based
1184	* on amount of damage healed.	930	* on amount of damage healed.
1185	*/	931	*/
1186	if (heal > (tmp->stats.maxhp - tmp->stats.hp))	932	if (heal > tmp->stats.maxhp - tmp->stats.hp)
1187	heal = tmp->stats.maxhp - tmp->stats.hp;	933	heal = tmp->stats.maxhp - tmp->stats.hp;
		934
1188	tmp->stats.hp += heal;	935	tmp->stats.hp += heal;
1189		936
1190	if (tmp->stats.hp >= tmp->stats.maxhp)	937	if (tmp->stats.hp >= tmp->stats.maxhp)
1191	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");	938	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
1192	else if (heal > 50)	939	else if (heal > 50)
…		…
1201	success = 1;	948	success = 1;
1202	}	949	}
1203	}	950	}
1204		951
1205	if (spell->attacktype & AT_DISEASE)	952	if (spell->attacktype & AT_DISEASE)
1206	if (cure_disease (tmp, op))	953	if (cure_disease (tmp, op, spell))
1207	success = 1;	954	success = 1;
1208		955
1209	if (spell->attacktype & AT_POISON)	956	if (spell->attacktype & AT_POISON)
1210	{	957	{
1211	at = archetype::find ("poisoning");	958	at = archetype::find ("poisoning");
…		…
1260	}	1007	}
1261		1008
1262	if (spell->stats.food && tmp->stats.food < 999)	1009	if (spell->stats.food && tmp->stats.food < 999)
1263	{	1010	{
1264	tmp->stats.food += spell->stats.food;	1011	tmp->stats.food += spell->stats.food;
		1012
1265	if (tmp->stats.food > 999)	1013	if (tmp->stats.food > 999)
1266	tmp->stats.food = 999;	1014	tmp->stats.food = 999;
		1015
1267	success = 1;	1016	success = 1;
1268	/* 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 */
1269	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");
1270	}	1019	}
1271		1020
1272	return success;	1021	return success;
1273	}	1022	}
1274
1275		1023
1276	/* 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
1277	* 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
1278	* good comments for those.	1026	* good comments for those.
1279	*/	1027	*/
1280	static const char *const no_gain_msgs[NUM_STATS] = {	1028	static const char *const no_gain_msgs[NUM_STATS] = {
1281	"You grow no stronger.",	1029	"You grow no stronger.",
1282	"You grow no more agile.",	1030	"You grow no more agile.",
1283	"You don't feel any healthier.",	1031	"You don't feel any healthier.",
1284	"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."
1285	"You are no easier to look at.",	1035	"You are no easier to look at.",
1286	"no int",
1287	"no pow"
1288	};	1036	};
1289		1037
1290	int	1038	int
1291	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)
1292	{	1040	{
1293	object *force = NULL;	1041	object *force = 0;
1294	int i;	1042	int i;
1295		1043
1296	/* 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. */
1297	object *tmp = dir	1045	object *tmp = dir
1298	? find_target_for_friendly_spell (op, dir)	1046	? find_target_for_friendly_spell (op, dir)
1299	: op;	1047	: op;
1300		1048
1301	if (!tmp)	1049	if (!tmp)
1302	return 0;	1050	return 0;
1303		1051
1304	/* 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. */
…		…
1313	}	1061	}
1314	else if (spell_ob->race && spell_ob->race == tmp2->name)	1062	else if (spell_ob->race && spell_ob->race == tmp2->name)
1315	{	1063	{
1316	if (!silent)	1064	if (!silent)
1317	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);	1065	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
		1066
1318	return 0;	1067	return 0;
1319	}	1068	}
1320	}	1069	}
1321	}	1070	}
1322	if (force == NULL)	1071
		1072	if (!force)
1323	{	1073	{
1324	force = get_archetype (FORCE_NAME);	1074	force = get_archetype (FORCE_NAME);
1325	force->subtype = FORCE_CHANGE_ABILITY;	1075	force->subtype = FORCE_CHANGE_ABILITY;
		1076
1326	if (spell_ob->race)	1077	if (spell_ob->race)
1327	force->name = spell_ob->race;	1078	force->name = spell_ob->race;
1328	else	1079	else
1329	force->name = spell_ob->name;	1080	force->name = spell_ob->name;
		1081
1330	force->name_pl = spell_ob->name;	1082	force->name_pl = spell_ob->name;
1331	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");	1083	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
1332		1084
1333	}	1085	}
1334	else	1086	else
…		…
1340	{	1092	{
1341	force->duration = duration;	1093	force->duration = duration;
1342	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	1094	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1343	}	1095	}
1344	else	1096	else
1345	{
1346	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1097	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1347	}	1098
1348	return 1;	1099	return 1;
1349	}	1100	}
		1101
1350	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1102	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1351	force->speed = 1.0;	1103	force->speed = 1.0;
1352	force->speed_left = -1.0;	1104	force->speed_left = -1.0;
1353	SET_FLAG (force, FLAG_APPLIED);	1105	SET_FLAG (force, FLAG_APPLIED);
1354		1106
…		…
1360	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);	1112	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);
1361	if (force->resist[i] > 100)	1113	if (force->resist[i] > 100)
1362	force->resist[i] = 100;	1114	force->resist[i] = 100;
1363	}	1115	}
1364	}	1116	}
		1117
1365	if (spell_ob->stats.hp)	1118	if (spell_ob->stats.hp)
1366	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);	1119	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
1367		1120
1368	if (tmp->type == PLAYER)	1121	if (tmp->type == PLAYER)
1369	{	1122	{
1370	/* Stat adjustment spells */	1123	/* Stat adjustment spells */
1371	for (i = 0; i < NUM_STATS; i++)	1124	for (i = 0; i < NUM_STATS; i++)
1372	{	1125	{
1373	sint8 stat = get_attr_value (&spell_ob->stats, i), k, sm;	1126	if (sint8 stat = spell_ob->stats.stat (i))
1374
1375	if (stat)
1376	{	1127	{
1377	sm = 0;	1128	sint8 sm = 0;
1378	for (k = 0; k < stat; k++)	1129	for (sint8 k = 0; k < stat; k++)
1379	sm += rndm (1, 3);	1130	sm += rndm (1, 3);
1380		1131
1381	if ((get_attr_value (&tmp->stats, i) + sm) > (15 + 5 * stat))	1132	if (tmp->stats.stat (i) + sm > 15 + 5 * stat)
1382	{	1133	sm = max (0, (15 + 5 * stat) - tmp->stats.stat (i));
1383	sm = (15 + 5 * stat) - get_attr_value (&tmp->stats, i);	1134
1384	if (sm < 0)	1135	force->stats.stat (i) = sm;
1385	sm = 0;	1136
1386	}
1387	set_attr_value (&force->stats, i, sm);
1388	if (!sm)	1137	if (!sm)
1389	new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);	1138	new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);
1390	}	1139	}
1391	}	1140	}
1392	}	1141	}
…		…
1413	force->attacktype = spell_ob->attacktype;	1162	force->attacktype = spell_ob->attacktype;
1414		1163
1415	insert_ob_in_ob (force, tmp);	1164	insert_ob_in_ob (force, tmp);
1416	change_abil (tmp, force); /* Mostly to display any messages */	1165	change_abil (tmp, force); /* Mostly to display any messages */
1417	tmp->update_stats ();	1166	tmp->update_stats ();
		1167
1418	return 1;	1168	return 1;
1419	}	1169	}
1420		1170
1421	/* This used to be part of cast_change_ability, but it really didn't make	1171	/* This used to be part of cast_change_ability, but it really didn't make
1422	* a lot of sense, since most of the values it derives are from the god	1172	* a lot of sense, since most of the values it derives are from the god
1423	* of the caster.	1173	* of the caster.
1424	*/	1174	*/
1425
1426	int	1175	int
1427	cast_bless (object *op, object *caster, object *spell_ob, int dir)	1176	cast_bless (object *op, object *caster, object *spell_ob, int dir)
1428	{	1177	{
1429	int i;	1178	int i;
1430	object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;	1179	object *god = find_god (determine_god (op)), *force = NULL, *tmp;
1431		1180
1432	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */	1181	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1433	if (dir != 0)	1182	if (dir != 0)
1434	{	1183	{
1435	tmp = find_target_for_friendly_spell (op, dir);	1184	tmp = find_target_for_friendly_spell (op, dir);
		1185
		1186	if (!tmp)
		1187	return 0;
1436	}	1188	}
1437	else	1189	else
1438	{
1439	tmp = op;	1190	tmp = op;
1440	}
1441		1191
1442	/* If we've already got a force of this type, don't add a new one. */	1192	/* If we've already got a force of this type, don't add a new one. */
1443	for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below)	1193	for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1444	{	1194	{
1445	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)	1195	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1446	{	1196	{
1447	if (tmp2->name == spell_ob->name)	1197	if (tmp2->name == spell_ob->name)
1448	{	1198	{
…		…
1454	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);	1204	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
1455	return 0;	1205	return 0;
1456	}	1206	}
1457	}	1207	}
1458	}	1208	}
		1209
1459	if (force == NULL)	1210	if (force == NULL)
1460	{	1211	{
1461	force = get_archetype (FORCE_NAME);	1212	force = get_archetype (FORCE_NAME);
1462	force->subtype = FORCE_CHANGE_ABILITY;	1213	force->subtype = FORCE_CHANGE_ABILITY;
1463	if (spell_ob->race)	1214	if (spell_ob->race)
…		…
1528	}	1279	}
1529		1280
1530	/* Alchemy code by Mark Wedel	1281	/* Alchemy code by Mark Wedel
1531	*	1282	*
1532	* This code adds a new spell, called alchemy. Alchemy will turn	1283	* This code adds a new spell, called alchemy. Alchemy will turn
1533	* objects to gold nuggets, the value of the gold nuggets being	1284	* objects to pyrite ("false gold"), henceforth called gold nuggets.
1534	* about 90% of that of the item itself. It uses the value of the
1535	* object before charisma adjustments, because the nuggets themselves
1536	* will be will be adjusted by charisma when sold.
1537	*	1285	*
1538	* Large nuggets are worth 25 gp each (base). You will always get	1286	* The value of the gold nuggets being about 90% of that of the item
1539	* the maximum number of large nuggets you could get.	1287	* itself. It uses the value of the object before charisma adjustments,
1540	* Small nuggets are worth 1 gp each (base). You will get from 0	1288	* because the nuggets themselves will be will be adjusted by charisma
1541	* to the max amount of small nuggets as you could get.	1289	* when sold.
1542	*
1543	* For example, if an item is worth 110 gold, you will get
1544	* 4 large nuggets, and from 0-10 small nuggets.
1545	*	1290	*
1546	* There is also a chance (1:30) that you will get nothing at all	1291	* There is also a chance (1:30) that you will get nothing at all
1547	* for the object. There is also a maximum weight that will be	1292	* for the object. There is also a maximum weight that will be
1548	* alchemised.	1293	* alchemised.
1549	*/	1294	*/
1550	static void	1295	static void
1551	alchemy_object (object *obj, uint64 &total_value, int &total_weight)	1296	alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1552	{	1297	{
1553	uint64 value = query_cost (obj, NULL, F_TRUE);	1298	uint64 value = query_cost (obj, NULL, F_TRUE);
1554		1299
1555	/* Give third price when we alchemy money (This should hopefully	1300	/* Give third price when we alchemy money (this should hopefully
1556	* make it so that it isn't worth it to alchemy money, sell	1301	* make it so that it isn't worth it to alchemy money, sell
1557	* the nuggets, alchemy the gold from that, etc.	1302	* the nuggets, alchemy the gold from that, etc.
1558	* Otherwise, give 9 silver on the gold for other objects,	1303	* Otherwise, give 9 silver on the gold for other objects,
1559	* so that it would still be more affordable to haul	1304	* so that it would still be more affordable to haul
1560	* the stuff back to town.	1305	* the stuff back to town.
…		…
1572	total_weight += obj->total_weight ();	1317	total_weight += obj->total_weight ();
1573		1318
1574	obj->destroy ();	1319	obj->destroy ();
1575	}	1320	}
1576		1321
1577	static void
1578	update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1579	{
1580	int flag = 0;
1581
1582	/* Put any nuggets below the player, but we can only pass this
1583	* flag if we are on the same space as the player
1584	*/
1585	if (x == op->x && y == op->y && op->map == m)
1586	flag = INS_BELOW_ORIGINATOR;
1587
1588	if (small_nuggets)
1589	{
1590	object *tmp = small->clone ();
1591	tmp->nrof = small_nuggets;
1592	m->insert (tmp, x, y, op, flag);
1593	}
1594
1595	if (large_nuggets)
1596	{
1597	object *tmp = large->clone ();
1598	tmp->nrof = large_nuggets;
1599	m->insert (tmp, x, y, op, flag);
1600	}
1601
1602	if (object *pl = m->at (x, y).player ())
1603	if (pl->contr->ns)
1604	pl->contr->ns->look_position = 0;
1605	}
1606
1607	int	1322	int
1608	alchemy (object *op, object *caster, object *spell_ob)	1323	alchemy (object *op, object *caster, object *spell_ob)
1609	{	1324	{
1610	if (op->type != PLAYER)	1325	if (op->type != PLAYER)
1611	return 0;	1326	return 0;
1612		1327
1613	object *large = get_archetype ("largenugget");	1328	archetype *nugget[3];
1614	object *small = get_archetype ("smallnugget");	1329
		1330	nugget[0] = archetype::find ("pyrite3");
		1331	nugget[1] = archetype::find ("pyrite2");
		1332	nugget[2] = archetype::find ("pyrite");
1615		1333
1616	/* Put a maximum weight of items that can be alchemised. Limits the power	1334	/* Put a maximum weight of items that can be alchemised. Limits the power
1617	* some, and also prevents people from alchemising every table/chair/clock	1335	* some, and also prevents people from alchemising every table/chair/clock
1618	* in sight	1336	* in sight
1619	*/	1337	*/
…		…
1671	if (weight > weight_max)	1389	if (weight > weight_max)
1672	break;	1390	break;
1673	}	1391	}
1674	}	1392	}
1675		1393
		1394	value -= rndm (value >> 4);
1676	value = min (value, value_max);	1395	value = min (value, value_max);
1677		1396
1678	uint64 count = value / large->value;	1397	for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1679	int large_nuggets = count;	1398	if (int nrof = value / nugget [i]->value)
1680	value -= count * large->value;
1681
1682	count = value / small->value;
1683	int small_nuggets = count;
1684
1685	/* Insert all the nuggets at one time. This probably saves time, but
1686	* it also prevents us from alcheming nuggets that were just created
1687	* with this spell.
1688	*/	1399	{
1689	update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny);	1400	value -= nrof * nugget[i]->value;
		1401
		1402	object *tmp = arch_to_object (nugget[i]);
		1403	tmp->nrof = nrof;
		1404	tmp->flag [FLAG_IDENTIFIED] = true;
		1405	op->map->insert (tmp, x, y, op, 0);
		1406	}
1690		1407
1691	if (weight > weight_max)	1408	if (weight > weight_max)
1692	goto bailout;	1409	goto bailout;
1693	}	1410	}
1694	}	1411	}
1695		1412
1696	bailout:	1413	bailout:
1697	large->destroy ();
1698	small->destroy ();
1699	return 1;	1414	return 1;
1700	}	1415	}
1701
1702		1416
1703	/* This function removes the cursed/damned status on equipped	1417	/* This function removes the cursed/damned status on equipped
1704	* items.	1418	* items.
1705	*/	1419	*/
1706	int	1420	int
…		…
1713	if (QUERY_FLAG (tmp, FLAG_APPLIED) &&	1427	if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
1714	((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||	1428	((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1715	(QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))	1429	(QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1716	{	1430	{
1717	was_one++;	1431	was_one++;
		1432
1718	if (tmp->level <= caster_level (caster, spell))	1433	if (tmp->level <= casting_level (caster, spell))
1719	{	1434	{
1720	success++;	1435	success++;
1721	if (QUERY_FLAG (spell, FLAG_DAMNED))	1436	if (QUERY_FLAG (spell, FLAG_DAMNED))
1722	CLEAR_FLAG (tmp, FLAG_DAMNED);	1437	CLEAR_FLAG (tmp, FLAG_DAMNED);
1723		1438
1724	CLEAR_FLAG (tmp, FLAG_CURSED);	1439	CLEAR_FLAG (tmp, FLAG_CURSED);
1725	CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);	1440	CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);
1726	tmp->value = 0; /* Still can't sell it */	1441	tmp->value = 0; /* Still can't sell it */
1727	if (op->type == PLAYER)	1442
		1443	if (object *pl = tmp->visible_to ())
1728	esrv_send_item (op, tmp);	1444	esrv_update_item (UPD_FLAGS, pl, tmp);
1729	}	1445	}
1730	}	1446	}
1731		1447
1732	if (op->type == PLAYER)	1448	if (op->type == PLAYER)
1733	{	1449	{
…		…
1744		1460
1745	return success;	1461	return success;
1746	}	1462	}
1747		1463
1748	/* Identifies objects in the players inventory/on the ground */	1464	/* Identifies objects in the players inventory/on the ground */
1749
1750	int	1465	int
1751	cast_identify (object *op, object *caster, object *spell)	1466	cast_identify (object *op, object *caster, object *spell)
1752	{	1467	{
		1468	dynbuf_text buf;
1753	object *tmp;	1469	object *tmp;
1754	int success = 0, num_ident;
1755		1470
1756	num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1471	int num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1757		1472
1758	if (num_ident < 1)	1473	if (num_ident < 1)
1759	num_ident = 1;	1474	num_ident = 1;
1760		1475
1761	for (tmp = op->inv; tmp; tmp = tmp->below)	1476	for (tmp = op->inv; tmp; tmp = tmp->below)
…		…
1764	{	1479	{
1765	identify (tmp);	1480	identify (tmp);
1766		1481
1767	if (op->type == PLAYER)	1482	if (op->type == PLAYER)
1768	{	1483	{
1769	new_draw_info_format (NDI_UNIQUE, 0, op, "You have %s.", long_desc (tmp, op));	1484	buf.printf ("You identified: %s.\r", long_desc (tmp, op));
1770		1485
1771	if (tmp->msg)	1486	if (tmp->msg)
1772	{	1487	buf << "The item has a story:\r" << tmp->msg << "\n\n";
1773	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1774	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1775	}
1776	}	1488	}
1777		1489
1778	num_ident--;	1490	num_ident--;
1779	success = 1;
1780	if (!num_ident)	1491	if (!num_ident)
1781	break;	1492	break;
1782	}	1493	}
1783	}	1494	}
1784		1495
…		…
1786	* stuff on the floor. Only identify stuff on the floor if the spell	1497	* stuff on the floor. Only identify stuff on the floor if the spell
1787	* was not fully used.	1498	* was not fully used.
1788	*/	1499	*/
1789	if (num_ident)	1500	if (num_ident)
1790	{	1501	{
1791	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	1502	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1792	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))	1503	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1793	{	1504	{
1794	identify (tmp);	1505	identify (tmp);
1795		1506
1796	if (op->type == PLAYER)	1507	if (object *pl = tmp->visible_to ())
1797	{	1508	{
1798	new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op));	1509	buf.printf ("On the ground you identified: %s.\r", long_desc (tmp, op));
1799		1510
1800	if (tmp->msg)	1511	if (tmp->msg)
1801	{	1512	buf << "The item has a story:\r" << tmp->msg << "\n\n";
1802	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1803	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1804	}
1805
1806	esrv_send_item (op, tmp);
1807	}	1513	}
1808		1514
1809	num_ident--;	1515	num_ident--;
1810	success = 1;
1811	if (!num_ident)	1516	if (!num_ident)
1812	break;	1517	break;
1813	}	1518	}
1814	}	1519	}
1815		1520
1816	if (!success)	1521	if (buf.empty ())
1817	new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified.");	1522	{
		1523	op->failmsg ("You can't reach anything unidentified.");
		1524	return 0;
		1525	}
1818	else	1526	else
		1527	{
		1528	if (op->contr)
		1529	op->contr->infobox (MSG_CHANNEL ("identify"), buf);
		1530
1819	spell_effect (spell, op->x, op->y, op->map, op);	1531	spell_effect (spell, op->x, op->y, op->map, op);
1820		1532	return 1;
1821	return success;	1533	}
1822	}	1534	}
1823		1535
1824	int	1536	int
1825	cast_detection (object *op, object *caster, object *spell, object *skill)	1537	cast_detection (object *op, object *caster, object *spell, object *skill)
1826	{	1538	{
…		…
1831		1543
1832	/* We precompute some values here so that we don't have to keep	1544	/* We precompute some values here so that we don't have to keep
1833	* doing it over and over again.	1545	* doing it over and over again.
1834	*/	1546	*/
1835	god = find_god (determine_god (op));	1547	god = find_god (determine_god (op));
1836	level = caster_level (caster, spell);	1548	level = casting_level (caster, spell);
1837	range = spell->range + SP_level_range_adjust (caster, spell);	1549	range = spell->range + SP_level_range_adjust (caster, spell);
1838		1550
1839	if (!skill)	1551	if (!skill)
1840	skill = caster;	1552	skill = caster;
1841		1553
…		…
1925	/* Basically, if race is set in the spell, then the creatures race must	1637	/* Basically, if race is set in the spell, then the creatures race must
1926	* match that. if the spell race is set to GOD, then the gods opposing	1638	* match that. if the spell race is set to GOD, then the gods opposing
1927	* race must match.	1639	* race must match.
1928	*/	1640	*/
1929	if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&	1641	if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&
1930	((!strcmp (spell->race, "GOD") && god && god->slaying && strstr (god->slaying, tmp->race)) ||	1642	((spell->race == shstr_GOD && god && god->slaying && god->slaying.contains (tmp->race)) ||
1931	(strstr (spell->race, tmp->race))))	1643	spell->race.contains (tmp->race)))
1932	{	1644	{
1933	done_one = 2;	1645	done_one = 2;
1934	if (!detect)	1646	if (!detect)
1935	detect = tmp;	1647	detect = tmp;
1936	}	1648	}
…		…
1968		1680
1969	/* Now process objects in the players inventory if detect curse or magic */	1681	/* Now process objects in the players inventory if detect curse or magic */
1970	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))	1682	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))
1971	{	1683	{
1972	done_one = 0;	1684	done_one = 0;
		1685
1973	for (tmp = op->inv; tmp; tmp = tmp->below)	1686	for (tmp = op->inv; tmp; tmp = tmp->below)
1974	{	1687	{
1975	if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1688	if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1976	{	1689	{
1977	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))	1690	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))
1978	{	1691	{
1979	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1692	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1980	if (op->type == PLAYER)	1693
		1694	if (object *pl = tmp->visible_to ())
1981	esrv_send_item (op, tmp);	1695	esrv_update_item (UPD_FLAGS, pl, tmp);
1982	}	1696	}
		1697
1983	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1698	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1984	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))	1699	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1985	{	1700	{
1986	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1701	SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1987	if (op->type == PLAYER)	1702
		1703	if (object *pl = tmp->visible_to ())
1988	esrv_send_item (op, tmp);	1704	esrv_update_item (UPD_FLAGS, pl, tmp);
1989	}	1705	}
1990	} /* if item is not identified */	1706	} /* if item is not identified */
1991	} /* for the players inventory */	1707	} /* for the players inventory */
1992	} /* if detect magic/curse and object is a player */	1708	} /* if detect magic/curse and object is a player */
		1709
1993	return 1;	1710	return 1;
1994	}	1711	}
1995		1712
1996		1713
1997	/**	1714	/**
…		…
2023		1740
2024	tmp->insert_at (victim);	1741	tmp->insert_at (victim);
2025	victim->stats.sp = 2 * victim->stats.maxsp;	1742	victim->stats.sp = 2 * victim->stats.maxsp;
2026	}	1743	}
2027	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)	1744	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
2028	new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode.");	1745	new_draw_info (NDI_UNIQUE | NDI_ORANGE, 0, victim, "You feel like your head is going to explode.");
2029	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)	1746	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
2030	new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");	1747	new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
2031	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)	1748	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
2032	{	1749	{
2033	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");	1750	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
…		…
2079	}	1796	}
2080	/* give sp */	1797	/* give sp */
2081	if (spell->stats.dam > 0)	1798	if (spell->stats.dam > 0)
2082	{	1799	{
2083	plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);	1800	plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);
2084	charge_mana_effect (plyr, caster_level (caster, spell));	1801	charge_mana_effect (plyr, casting_level (caster, spell));
2085	return 1;	1802	return 1;
2086	}	1803	}
2087	/* suck sp away. Can't suck sp from yourself */	1804	/* suck sp away. Can't suck sp from yourself */
2088	else if (op != plyr)	1805	else if (op != plyr)
2089	{	1806	{
…		…
2101	/* Player doesn't get full credit */	1818	/* Player doesn't get full credit */
2102	sucked = (sucked * rate) / 100;	1819	sucked = (sucked * rate) / 100;
2103	op->stats.sp += sucked;	1820	op->stats.sp += sucked;
2104	if (sucked > 0)	1821	if (sucked > 0)
2105	{	1822	{
2106	charge_mana_effect (op, caster_level (caster, spell));	1823	charge_mana_effect (op, casting_level (caster, spell));
2107	}	1824	}
2108	}	1825	}
2109	return 1;	1826	return 1;
2110	}	1827	}
2111	return 0;	1828	return 0;
…		…
2187	break;	1904	break;
2188	}	1905	}
2189	}	1906	}
2190	}	1907	}
2191		1908
2192
2193
2194	/* cast_consecrate() - a spell to make an altar your god's */	1909	/* cast_consecrate() - a spell to make an altar your god's */
2195	int	1910	int
2196	cast_consecrate (object *op, object *caster, object *spell)	1911	cast_consecrate (object *op, object *caster, object *spell)
2197	{	1912	{
2198	char buf[MAX_BUF];	1913	char buf[MAX_BUF];
…		…
2210	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1925	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2211	break;	1926	break;
2212	if (tmp->type == HOLY_ALTAR)	1927	if (tmp->type == HOLY_ALTAR)
2213	{	1928	{
2214		1929
2215	if (tmp->level > caster_level (caster, spell))	1930	if (tmp->level > casting_level (caster, spell))
2216	{	1931	{
2217	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);	1932	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);
2218	return 0;	1933	return 0;
2219	}	1934	}
2220	else	1935	else
2221	{	1936	{
2222	/* If we got here, we are consecrating an altar */	1937	/* If we got here, we are consecrating an altar */
2223	sprintf (buf, "Altar of %s", &god->name);	1938	sprintf (buf, "Altar of %s", &god->name);
2224	tmp->name = buf;	1939	tmp->name = buf;
2225	tmp->level = caster_level (caster, spell);	1940	tmp->level = casting_level (caster, spell);
2226	tmp->other_arch = god->arch;	1941	tmp->other_arch = god->arch;
		1942
2227	if (op->type == PLAYER)	1943	if (op->type == PLAYER)
2228	esrv_update_item (UPD_NAME, op, tmp);	1944	esrv_update_item (UPD_NAME, op, tmp);
		1945
2229	new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);	1946	new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
2230	return 1;	1947	return 1;
2231	}	1948	}
2232	}	1949	}
2233	}	1950	}
…		…
2243	* This code was very odd - code early on would only let players use the spell,	1960	* This code was very odd - code early on would only let players use the spell,
2244	* yet the code wass full of player checks. I've presumed that the code	1961	* yet the code wass full of player checks. I've presumed that the code
2245	* that only let players use it was correct, and removed all the other	1962	* that only let players use it was correct, and removed all the other
2246	* player checks. MSW 2003-01-06	1963	* player checks. MSW 2003-01-06
2247	*/	1964	*/
2248
2249	int	1965	int
2250	animate_weapon (object *op, object *caster, object *spell, int dir)	1966	animate_weapon (object *op, object *caster, object *spell, int dir)
2251	{	1967	{
2252	object *weapon, *tmp;	1968	object *weapon, *tmp;
2253	char buf[MAX_BUF];	1969	char buf[MAX_BUF];
2254	int a, i;	1970	int a, i;
2255	sint16 x, y;	1971	sint16 x, y;
2256	maptile *m;	1972	maptile *m;
2257	materialtype_t *mt;
2258		1973
2259	if (!spell->other_arch)	1974	if (!spell->other_arch)
2260	{	1975	{
2261	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	1976	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
2262	LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);	1977	LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);
…		…
2265	/* exit if it's not a player using this spell. */	1980	/* exit if it's not a player using this spell. */
2266	if (op->type != PLAYER)	1981	if (op->type != PLAYER)
2267	return 0;	1982	return 0;
2268		1983
2269	/* if player already has a golem, abort */	1984	/* if player already has a golem, abort */
2270	if (op->contr->ranges[range_golem])	1985	if (object *golem = op->contr->golem)
2271	{	1986	{
2272	control_golem (op->contr->ranges[range_golem], dir);	1987	control_golem (golem, dir);
2273	return 0;	1988	return 0;
2274	}	1989	}
2275		1990
2276	/* if no direction specified, pick one */	1991	/* if no direction specified, pick one */
2277	if (!dir)	1992	if (!dir)
2278	dir = find_free_spot (NULL, op->map, op->x, op->y, 1, 9);	1993	dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);
2279		1994
2280	m = op->map;	1995	m = op->map;
2281	x = op->x + freearr_x[dir];	1996	x = op->x + freearr_x[dir];
2282	y = op->y + freearr_y[dir];	1997	y = op->y + freearr_y[dir];
2283		1998
2284	/* if there's no place to put the golem, abort */	1999	/* if there's no place to put the golem, abort */
2285	if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) ||	2000	if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
2286	((spell->other_arch->clone.move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->clone.move_type))	2001	|| ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2287	{	2002	{
2288	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	2003	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
2289	return 0;	2004	return 0;
2290	}	2005	}
2291		2006
…		…
2295	if (!weapon)	2010	if (!weapon)
2296	{	2011	{
2297	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");	2012	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
2298	return 0;	2013	return 0;
2299	}	2014	}
		2015
2300	if (spell->race && strcmp (weapon->arch->name, spell->race))	2016	if (spell->race && weapon->arch->archname != spell->race)
2301	{	2017	{
2302	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");	2018	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
2303	return 0;	2019	return 0;
2304	}	2020	}
		2021
2305	if (weapon->type != WEAPON)	2022	if (weapon->type != WEAPON)
2306	{	2023	{
2307	new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");	2024	new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");
2308	return 0;	2025	return 0;
2309	}	2026	}
		2027
2310	if (QUERY_FLAG (weapon, FLAG_APPLIED))	2028	if (QUERY_FLAG (weapon, FLAG_APPLIED))
2311	{	2029	{
2312	new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));	2030	new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));
2313	return 0;	2031	return 0;
2314	}	2032	}
2315		2033
2316	if (weapon->nrof > 1)	2034	weapon = weapon->split ();
2317	{
2318	tmp = get_split_ob (weapon, 1);
2319	esrv_send_item (op, weapon);
2320	weapon = tmp;
2321	}
2322		2035
2323	/* create the golem object */	2036	/* create the golem object */
2324	tmp = arch_to_object (spell->other_arch);	2037	tmp = arch_to_object (spell->other_arch);
2325		2038
2326	/* if animated by a player, give the player control of the golem */	2039	/* if animated by a player, give the player control of the golem */
2327	CLEAR_FLAG (tmp, FLAG_MONSTER);	2040	CLEAR_FLAG (tmp, FLAG_MONSTER);
2328	tmp->stats.exp = 0;	2041	tmp->stats.exp = 0;
2329	add_friendly_object (tmp);	2042	add_friendly_object (tmp);
2330	tmp->type = GOLEM;	2043	tmp->type = GOLEM;
2331	tmp->set_owner (op);	2044	tmp->set_owner (op);
		2045	op->contr->golem = tmp;
2332	set_spell_skill (op, caster, spell, tmp);	2046	set_spell_skill (op, caster, spell, tmp);
2333	op->contr->ranges[range_golem] = tmp;
2334	op->contr->shoottype = range_golem;
2335		2047
2336	/* Give the weapon to the golem now. A bit of a hack to check the	2048	/* Give the weapon to the golem now. A bit of a hack to check the
2337	* removed flag - it should only be set if get_split_object was	2049	* removed flag - it should only be set if weapon->split was
2338	* used above.	2050	* used above.
2339	*/	2051	*/
2340	if (!QUERY_FLAG (weapon, FLAG_REMOVED))	2052	if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2341	weapon->remove ();	2053	weapon->remove ();
2342	insert_ob_in_ob (weapon, tmp);	2054
2343	esrv_send_item (op, weapon);	2055	tmp->insert (weapon);
		2056
2344	/* To do everything necessary to let a golem use the weapon is a pain,	2057	/* To do everything necessary to let a golem use the weapon is a pain,
2345	* so instead, just set it as equipped (otherwise, we need to update	2058	* so instead, just set it as equipped (otherwise, we need to update
2346	* body_info, skills, etc)	2059	* body_info, skills, etc)
2347	*/	2060	*/
2348	SET_FLAG (tmp, FLAG_USE_WEAPON);	2061	SET_FLAG (tmp, FLAG_USE_WEAPON);
…		…
2374		2087
2375	/* attacktype */	2088	/* attacktype */
2376	if (!tmp->attacktype)	2089	if (!tmp->attacktype)
2377	tmp->attacktype = AT_PHYSICAL;	2090	tmp->attacktype = AT_PHYSICAL;
2378		2091
2379	mt = NULL;
2380	if (op->materialname != NULL)
2381	mt = name_to_material (op->materialname);	2092	if (materialtype_t *mt = name_to_material (op->materialname))
2382	if (mt != NULL)
2383	{	2093	{
2384	for (i = 0; i < NROFATTACKS; i++)	2094	for (i = 0; i < NROFATTACKS; i++)
2385	tmp->resist[i] = 50 - (mt->save[i] * 5);	2095	tmp->resist[i] = 50 - (mt->save[i] * 5);
2386	a = mt->save[0];	2096	a = mt->save[0];
2387	}	2097	}
…		…
2389	{	2099	{
2390	for (i = 0; i < NROFATTACKS; i++)	2100	for (i = 0; i < NROFATTACKS; i++)
2391	tmp->resist[i] = 5;	2101	tmp->resist[i] = 5;
2392	a = 10;	2102	a = 10;
2393	}	2103	}
		2104
2394	/* Set weapon's immunity */	2105	/* Set weapon's immunity */
2395	tmp->resist[ATNR_CONFUSION] = 100;	2106	tmp->resist[ATNR_CONFUSION] = 100;
2396	tmp->resist[ATNR_POISON] = 100;	2107	tmp->resist[ATNR_POISON] = 100;
2397	tmp->resist[ATNR_SLOW] = 100;	2108	tmp->resist[ATNR_SLOW] = 100;
2398	tmp->resist[ATNR_PARALYZE] = 100;	2109	tmp->resist[ATNR_PARALYZE] = 100;
…		…
2404		2115
2405	/* Improve weapon's armour value according to best save vs. physical of its material */	2116	/* Improve weapon's armour value according to best save vs. physical of its material */
2406		2117
2407	if (a > 14)	2118	if (a > 14)
2408	a = 14;	2119	a = 14;
		2120
2409	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));	2121	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2410		2122
2411	/* Determine golem's speed */	2123	/* Determine golem's speed */
2412	tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));	2124	tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2413		2125
…		…
2423	tmp->state = weapon->state;	2135	tmp->state = weapon->state;
2424	tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];	2136	tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2425	}	2137	}
2426		2138
2427	/* make experience increase in proportion to the strength of the summoned creature. */	2139	/* make experience increase in proportion to the strength of the summoned creature. */
2428	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));	2140	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));
2429		2141
2430	tmp->speed_left = -1;	2142	tmp->speed_left = -1;
2431	tmp->direction = dir;	2143	tmp->direction = dir;
2432		2144
2433	m->insert (tmp, x, y, op);	2145	m->insert (tmp, x, y, op);
…		…
2437	/* cast_daylight() - changes the map darkness level *lower* */	2149	/* cast_daylight() - changes the map darkness level *lower* */
2438		2150
2439	/* cast_change_map_lightlevel: Was cast_daylight/nightfall.	2151	/* cast_change_map_lightlevel: Was cast_daylight/nightfall.
2440	* This changes the light level for the entire map.	2152	* This changes the light level for the entire map.
2441	*/	2153	*/
2442
2443	int	2154	int
2444	cast_change_map_lightlevel (object *op, object *caster, object *spell)	2155	cast_change_map_lightlevel (object *op, object *caster, object *spell)
2445	{	2156	{
2446	int success;	2157	int success;
2447		2158
…		…
2455	if (spell->stats.dam < 0)	2166	if (spell->stats.dam < 0)
2456	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");	2167	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2457	else	2168	else
2458	new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");	2169	new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2459	}	2170	}
		2171
2460	return success;	2172	return success;
2461	}	2173	}
2462
2463
2464
2465
2466		2174
2467	/* create an aura spell object and put it in the player's inventory.	2175	/* create an aura spell object and put it in the player's inventory.
2468	* as usual, op is player, caster is the object casting the spell,	2176	* as usual, op is player, caster is the object casting the spell,
2469	* spell is the spell object itself.	2177	* spell is the spell object itself.
2470	*/	2178	*/
…		…
2482		2190
2483	new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);	2191	new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2484		2192
2485	new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	2193	new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2486		2194
2487	new_aura->set_owner (op);
2488	set_spell_skill (op, caster, spell, new_aura);	2195	set_spell_skill (op, caster, spell, new_aura);
2489	new_aura->attacktype = spell->attacktype;	2196	new_aura->attacktype = spell->attacktype;
2490		2197
2491	new_aura->level = caster_level (caster, spell);	2198	new_aura->level = casting_level (caster, spell);
		2199
2492	if (refresh)	2200	if (refresh)
2493	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	2201	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2494	else	2202	else
2495	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");	2203	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
		2204
2496	insert_ob_in_ob (new_aura, op);	2205	insert_ob_in_ob (new_aura, op);
		2206	new_aura->set_owner (op);
		2207
2497	return 1;	2208	return 1;
2498	}	2209	}
2499
2500		2210
2501	/* move aura function. An aura is a part of someone's inventory,	2211	/* move aura function. An aura is a part of someone's inventory,
2502	* which he carries with him, but which acts on the map immediately	2212	* which he carries with him, but which acts on the map immediately
2503	* around him.	2213	* around him.
2504	* Aura parameters:	2214	* Aura parameters:
2505	* duration: duration counter.	2215	* duration: duration counter.
2506	* attacktype: aura's attacktype	2216	* attacktype: aura's attacktype
2507	* other_arch: archetype to drop where we attack	2217	* other_arch: archetype to drop where we attack
2508	*/	2218	*/
2509
2510	void	2219	void
2511	move_aura (object *aura)	2220	move_aura (object *aura)
2512	{	2221	{
2513	int i, mflags;
2514	object *env;
2515	maptile *m;
2516
2517	/* auras belong in inventories */	2222	/* auras belong in inventories */
2518	env = aura->env;	2223	object *env = aura->env;
		2224	object *owner = aura->owner;
2519		2225
2520	/* no matter what we've gotta remove the aura...	2226	/* no matter what we've gotta remove the aura...
2521	* we'll put it back if its time isn't up.	2227	* we'll put it back if its time isn't up.
2522	*/	2228	*/
2523	aura->remove ();	2229	aura->remove ();
…		…
2528	aura->destroy ();	2234	aura->destroy ();
2529	return;	2235	return;
2530	}	2236	}
2531		2237
2532	/* auras only exist in inventories */	2238	/* auras only exist in inventories */
2533	if (env == NULL || env->map == NULL)	2239	if (!env || !env->map)
2534	{	2240	{
2535	aura->destroy ();	2241	aura->destroy ();
2536	return;	2242	return;
2537	}	2243	}
2538		2244
2539	/* we need to jump out of the inventory for a bit	2245	/* we need to jump out of the inventory for a bit
2540	* in order to hit the map conveniently.	2246	* in order to hit the map conveniently.
2541	*/	2247	*/
2542	aura->insert_at (env, aura);	2248	aura->insert_at (env, aura);
2543		2249
2544	for (i = 1; i < 9; i++)	2250	for (int i = 1; i < 9; i++)
2545	{	2251	{
2546	sint16 nx, ny;	2252	mapxy pos (env);
		2253	pos.move (i);
2547		2254
2548	nx = aura->x + freearr_x[i];
2549	ny = aura->y + freearr_y[i];
2550	mflags = get_map_flags (env->map, &m, nx, ny, &nx, &ny);
2551
2552	/* Consider the movement tyep of the person with the aura as	2255	/* Consider the movement type of the person with the aura as
2553	* movement type of the aura. Eg, if the player is flying, the aura	2256	* movement type of the aura. Eg, if the player is flying, the aura
2554	* is flying also, if player is walking, it is on the ground, etc.	2257	* is flying also, if player is walking, it is on the ground, etc.
2555	*/	2258	*/
2556	if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))	2259	if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2557	{	2260	{
2558	hit_map (aura, i, aura->attacktype, 0);	2261	hit_map (aura, i, aura->attacktype, 0);
2559		2262
2560	if (aura->other_arch)	2263	if (aura->other_arch)
2561	m->insert (arch_to_object (aura->other_arch), nx, ny, aura);	2264	pos.insert (arch_to_object (aura->other_arch), aura);
2562	}	2265	}
2563	}	2266	}
2564		2267
2565	/* put the aura back in the player's inventory */	2268	/* put the aura back in the player's inventory */
2566	aura->remove ();	2269	env->insert (aura);
2567	insert_ob_in_ob (aura, env);	2270	aura->set_owner (owner);
2568	}	2271	}
2569		2272
2570	/* moves the peacemaker spell.	2273	/* moves the peacemaker spell.
2571	* op is the piece object.	2274	* op is the piece object.
2572	*/	2275	*/
2573
2574	void	2276	void
2575	move_peacemaker (object *op)	2277	move_peacemaker (object *op)
2576	{	2278	{
2577	object *tmp;	2279	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
2578
2579	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2580	{	2280	{
2581	int atk_lev, def_lev;	2281	int atk_lev, def_lev;
2582	object *victim = tmp;	2282	object *victim = tmp->head_ ();
2583		2283
2584	if (tmp->head)
2585	victim = tmp->head;
2586	if (!QUERY_FLAG (victim, FLAG_MONSTER))	2284	if (!QUERY_FLAG (victim, FLAG_MONSTER))
2587	continue;	2285	continue;
		2286
2588	if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))	2287	if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))
2589	continue;	2288	continue;
		2289
2590	if (victim->stats.exp == 0)	2290	if (victim->stats.exp == 0)
2591	continue;	2291	continue;
2592		2292
2593	def_lev = MAX (1, victim->level);	2293	def_lev = MAX (1, victim->level);
2594	atk_lev = MAX (1, op->level);	2294	atk_lev = MAX (1, op->level);
2595		2295
2596	if (rndm (0, atk_lev - 1) > def_lev)	2296	if (rndm (0, atk_lev - 1) > def_lev)
2597	{	2297	{
2598	/* make this sucker peaceful. */	2298	/* make this sucker peaceful. */
2599		2299
		2300	INVOKE_OBJECT (KILL, victim, ARG_OBJECT (op));
2600	change_exp (op->owner, victim->stats.exp, op->skill, 0);	2301	change_exp (op->owner, victim->stats.exp, op->skill, 0);
2601	victim->stats.exp = 0;	2302	victim->stats.exp = 0;
2602	#if 0	2303	#if 0
2603	/* No idea why these were all set to zero - if something	2304	/* No idea why these were all set to zero - if something
2604	* makes this creature agressive, he should still do damage.	2305	* makes this creature agressive, he should still do damage.
…		…
2611	victim->attack_movement = RANDO2;	2312	victim->attack_movement = RANDO2;
2612	SET_FLAG (victim, FLAG_UNAGGRESSIVE);	2313	SET_FLAG (victim, FLAG_UNAGGRESSIVE);
2613	SET_FLAG (victim, FLAG_RUN_AWAY);	2314	SET_FLAG (victim, FLAG_RUN_AWAY);
2614	SET_FLAG (victim, FLAG_RANDOM_MOVE);	2315	SET_FLAG (victim, FLAG_RANDOM_MOVE);
2615	CLEAR_FLAG (victim, FLAG_MONSTER);	2316	CLEAR_FLAG (victim, FLAG_MONSTER);
		2317
2616	if (victim->name)	2318	if (victim->name)
2617	{
2618	new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);	2319	new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2619	}	2320	}
2620	}
2621	}	2321	}
2622	}	2322	}
2623
2624		2323
2625	/* This writes a rune that contains the appropriate message.	2324	/* This writes a rune that contains the appropriate message.
2626	* There really isn't any adjustments we make.	2325	* There really isn't any adjustments we make.
2627	*/	2326	*/
2628
2629	int	2327	int
2630	write_mark (object *op, object *spell, const char *msg)	2328	write_mark (object *op, object *spell, const char *msg)
2631	{	2329	{
2632	char rune[HUGE_BUF];	2330	char rune[HUGE_BUF];
2633	object *tmp;	2331	object *tmp;

Diff Legend

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