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.110 by root, Mon Oct 12 14:00:59 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 it under
9	* it under the terms of the GNU General Public License as published by	9	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation; either version 2 of the License, or	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	11	* 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 Affero GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* and the GNU General Public License along with this program. If not, see
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	* <http://www.gnu.org/licenses/>.
21	*	21	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>	22	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/	23	*/
24		24
25	#include <global.h>	25	#include <global.h>
26	#include <object.h>	26	#include <object.h>
27	#include <living.h>	27	#include <living.h>
…		…
62	{	62	{
63	object *wand, *tmp;	63	object *wand, *tmp;
64	int ncharges;	64	int ncharges;
65		65
66	wand = find_marked_object (op);	66	wand = find_marked_object (op);
67	if (wand == NULL || wand->type != WAND)	67	if (!wand || wand->type != WAND)
68	{	68	{
69	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");	69	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");
70	return 0;	70	return 0;
71	}	71	}
72	if (!(random_roll (0, 3, op, PREFER_HIGH)))	72	if (!(random_roll (0, 3, op, PREFER_HIGH)))
73	{	73	{
74	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));	74	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);	75	op->play_sound (sound_find ("ob_explode"));
76	esrv_del_item (op->contr, wand->count);
77	wand->destroy ();	76	wand->destroy ();
78	tmp = get_archetype ("fireball");	77	tmp = get_archetype ("fireball");
79	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;
80		79
81	if (!tmp->stats.dam)	80	if (!tmp->stats.dam)
…		…
104	ncharges = 1;	103	ncharges = 1;
105		104
106	wand->stats.food += ncharges;	105	wand->stats.food += ncharges;
107	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));
108		107
109	if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE))	108	if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE))
110	{	109	{
111	SET_FLAG (wand, FLAG_ANIMATE);	110	SET_FLAG (wand, FLAG_ANIMATE);
112	wand->set_speed (wand->arch->clone.speed);	111	wand->set_speed (wand->arch->speed);
113	}	112	}
114		113
115	return 1;	114	return 1;
116	}	115	}
117		116
…		…
123	* great a plus, the default is used.	122	* great a plus, the default is used.
124	* The # of arrows created also goes up with level, so if a 30th level mage	123	* The # of arrows created also goes up with level, so if a 30th level mage
125	* wants LOTS of arrows, and doesn't care what the plus is he could	124	* wants LOTS of arrows, and doesn't care what the plus is he could
126	* create nonnmagic arrows, or even -1, etc...	125	* create nonnmagic arrows, or even -1, etc...
127	*/	126	*/
128
129	int	127	int
130	cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg)	128	cast_create_missile (object *op, object *caster, object *spell, int dir, const char *spellparam)
131	{	129	{
132	int missile_plus = 0, bonus_plus = 0;	130	int bonus_plus = 0;
133	const char *missile_name;	131	const char *missile_name = "arrow";
134	object *tmp, *missile;
135		132
136	missile_name = "arrow";
137
138	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	133	for (object *tmp = op->inv; tmp; tmp = tmp->below)
139	if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))	134	if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
140	missile_name = tmp->race;	135	missile_name = tmp->race;
141		136
142	missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);	137	int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
143		138
144	if (archetype::find (missile_name) == NULL)	139	archetype *missile_arch = archetype::find (missile_name);
		140
		141	if (!missile_arch)
145	{	142	{
146	LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);	143	LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);
147	return 0;	144	return 0;
148	}	145	}
149		146
150	missile = get_archetype (missile_name);	147	object *missile = missile_arch->instance ();
151		148
152	if (stringarg)	149	if (spellparam)
153	{	150	{
154	/* If it starts with a letter, presume it is a description */	151	/* If it starts with a letter, presume it is a description */
155	if (isalpha (*stringarg))	152	if (isalpha (*spellparam))
156	{	153	{
157	artifact *al = find_artifactlist (missile->type)->items;	154	artifact *al = find_artifactlist (missile->type)->items;
158		155
159	for (; al; al = al->next)	156	for (; al; al = al->next)
160	if (!strcasecmp (al->item->name, stringarg))	157	if (!strcasecmp (al->item->name, spellparam))
161	break;	158	break;
162		159
163	if (!al)	160	if (!al)
164	{	161	{
165	missile->destroy ();	162	missile->destroy ();
166	new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, stringarg);	163	new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, spellparam);
167	return 0;	164	return 0;
168	}	165	}
169		166
170	if (al->item->slaying)	167	if (al->item->slaying)
171	{	168	{
172	missile->destroy ();	169	missile->destroy ();
173	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg);	170	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, spellparam);
174	return 0;	171	return 0;
175	}	172	}
176		173
177	give_artifact_abilities (missile, al->item);	174	give_artifact_abilities (missile, al->item);
178	/* These special arrows cost something extra. Don't have them also be magical -	175	/* 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	176	* 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.	177	* the parsing of having to do both plus and type.
181	*/	178	*/
182	bonus_plus = 1 + (al->item->value / 5);	179	bonus_plus = 1 + (al->item->value / 5);
183	missile_plus = 0;	180	missile_plus = 0;
184	}	181	}
185	else if (atoi (stringarg) < missile_plus)	182	else if (atoi (spellparam) < missile_plus)
186	missile_plus = atoi (stringarg);	183	missile_plus = atoi (spellparam);
187	}	184	}
188		185
189	if (missile_plus > 4)	186	missile_plus = clamp (missile_plus, -4, 4);
190	missile_plus = 4;
191	else if (missile_plus < -4)
192	missile_plus = -4;
193		187
194	missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);	188	missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
195	missile->nrof -= 3 * (missile_plus + bonus_plus);	189	missile->nrof -= 3 * (missile_plus + bonus_plus);
196		190
197	if (missile->nrof < 1)	191	if (missile->nrof < 1)
…		…
209	return 1;	203	return 1;
210	}	204	}
211		205
212		206
213	/* allows the choice of what sort of food object to make.	207	/* allows the choice of what sort of food object to make.
214	* If stringarg is NULL, it will create food dependent on level --PeterM*/	208	* If spellparam is NULL, it will create food dependent on level --PeterM*/
215	int	209	int
216	cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *stringarg)	210	cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *spellparam)
217	{	211	{
218	int food_value;	212	int food_value;
219	archetype *at = NULL;	213	archetype *at = NULL;
220	object *new_op;	214	object *new_op;
221		215
222	food_value = spell_ob->stats.food + +50 * SP_level_duration_adjust (caster, spell_ob);	216	food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);
223		217
224	if (stringarg)	218	if (spellparam)
225	{	219	{
226	at = find_archetype_by_object_type_name (FOOD, stringarg);	220	at = find_archetype_by_object_type_name (FOOD, spellparam);
227	if (at == NULL)	221	if (at == NULL)
228	at = find_archetype_by_object_type_name (DRINK, stringarg);	222	at = find_archetype_by_object_type_name (DRINK, spellparam);
229	if (at == NULL || at->clone.stats.food > food_value)	223	if (at == NULL || at->stats.food > food_value)
230	stringarg = NULL;	224	spellparam = NULL;
231	}	225	}
232		226
233	if (!stringarg)	227	if (!spellparam)
234	{	228	{
235	archetype *at_tmp;	229	archetype *at_tmp;
236		230
237	/* We try to find the archetype with the maximum food value.	231	/* We try to find the archetype with the maximum food value.
238	* This removes the dependancy of hard coded food values in this	232	* This removes the dependancy of hard coded food values in this
…		…
240	* We don't use flesh types because the weight values of those need	234	* We don't use flesh types because the weight values of those need
241	* to be altered from the donor.	235	* to be altered from the donor.
242	*/	236	*/
243		237
244	/* We assume the food items don't have multiple parts */	238	/* We assume the food items don't have multiple parts */
245	for (at_tmp = first_archetype; at_tmp != NULL; at_tmp = at_tmp->next)	239	for_all_archetypes (at_tmp)
246	{	240	{
247	if (at_tmp->clone.type == FOOD || at_tmp->clone.type == DRINK)	241	if (at_tmp->type == FOOD || at_tmp->type == DRINK)
248	{	242	{
249	/* Basically, if the food value is something that is creatable	243	/* Basically, if the food value is something that is creatable
250	* under the limits of the spell and it is higher than	244	* under the limits of the spell and it is higher than
251	* the item we have now, take it instead.	245	* the item we have now, take it instead.
252	*/	246	*/
253	if (at_tmp->clone.stats.food <= food_value && (!at || at_tmp->clone.stats.food > at->clone.stats.food))	247	if (at_tmp->stats.food <= food_value
		248	&& (!at
		249	|| at_tmp->stats.food > at->stats.food
		250	|| (at_tmp->stats.food == at->stats.food
		251	&& at_tmp->weight < at->weight)))
254	at = at_tmp;	252	at = at_tmp;
255	}	253	}
256	}	254	}
257	}	255	}
		256
258	/* Pretty unlikely (there are some very low food items), but you never	257	/* Pretty unlikely (there are some very low food items), but you never
259	* know	258	* know
260	*/	259	*/
261	if (!at)	260	if (!at)
262	{	261	{
263	new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");	262	new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");
264	return 0;	263	return 0;
265	}	264	}
266		265
267	food_value /= at->clone.stats.food;	266	food_value /= at->stats.food;
268	new_op = arch_to_object (at);	267	new_op = arch_to_object (at);
269	new_op->nrof = food_value;	268	new_op->nrof = food_value;
270		269
271	new_op->value = 0;	270	new_op->value = 0;
272	if (new_op->nrof < 1)	271	if (new_op->nrof < 1)
…		…
281	{	280	{
282	int r, mflags, maxrange;	281	int r, mflags, maxrange;
283	object *tmp;	282	object *tmp;
284	maptile *m;	283	maptile *m;
285		284
286
287	if (!dir)	285	if (!dir)
288	{	286	{
289	examine_monster (op, op);	287	examine_monster (op, op);
290	return 1;	288	return 1;
291	}	289	}
		290
292	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	291	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
293	for (r = 1; r < maxrange; r++)	292	for (r = 1; r < maxrange; r++)
294	{	293	{
295	sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];	294	sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];
296		295
…		…
303	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))	302	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))
304	{	303	{
305	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");	304	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
306	return 0;	305	return 0;
307	}	306	}
		307
308	if (mflags & P_IS_ALIVE)	308	if (mflags & P_IS_ALIVE)
309	{	309	{
310	for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)	310	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)))	311	if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))
312	{	312	{
313	new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");	313	new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
314	if (tmp->head != NULL)	314	if (tmp->head != NULL)
315	tmp = tmp->head;	315	tmp = tmp->head;
316	examine_monster (op, tmp);	316	examine_monster (op, tmp);
317	return 1;	317	return 1;
318	}	318	}
319	}	319	}
320	}	320	}
		321
321	new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");	322	new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");
322	return 1;	323	return 1;
323	}	324	}
324
325		325
326	/* This checks to see if 'pl' is invisible to 'mon'.	326	/* This checks to see if 'pl' is invisible to 'mon'.
327	* does race check, undead check, etc	327	* does race check, undead check, etc
328	* Returns TRUE if mon can't see pl, false	328	* Returns TRUE if mon can't see pl, false
329	* otherwise. This doesn't check range, walls, etc. It	329	* otherwise. This doesn't check range, walls, etc. It
…		…
331	* pl is invisible.	331	* pl is invisible.
332	*/	332	*/
333	int	333	int
334	makes_invisible_to (object *pl, object *mon)	334	makes_invisible_to (object *pl, object *mon)
335	{	335	{
336
337	if (!pl->invisible)	336	if (!pl->invisible)
338	return 0;	337	return 0;
		338
339	if (pl->type == PLAYER)	339	if (pl->type == PLAYER)
340	{	340	{
341	/* If race isn't set, then invisible unless it is undead */	341	/* If race isn't set, then invisible unless it is undead */
342	if (!pl->contr->invis_race)	342	if (!pl->contr->invis_race)
343	{	343	{
344	if (QUERY_FLAG (mon, FLAG_UNDEAD))	344	if (QUERY_FLAG (mon, FLAG_UNDEAD))
345	return 0;	345	return 0;
		346
346	return 1;	347	return 1;
347	}	348	}
		349
348	/* invis_race is set if we get here */	350	/* invis_race is set if we get here */
349	if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon))	351	if (pl->contr->invis_race == shstr_undead && is_true_undead (mon))
350	return 1;	352	return 1;
		353
351	/* No race, can't be invisible to it */	354	/* No race, can't be invisible to it */
352	if (!mon->race)	355	if (!mon->race)
353	return 0;	356	return 0;
		357
354	if (strstr (mon->race, pl->contr->invis_race))	358	if (mon->race.contains (pl->contr->invis_race))
355	return 1;	359	return 1;
		360
356	/* Nothing matched above, return 0 */	361	/* Nothing matched above, return 0 */
357	return 0;	362	return 0;
358	}	363	}
359	else	364	else
360	{	365	{
…		…
421	/* earth to dust spell. Basically destroys earthwalls in the area.	426	/* earth to dust spell. Basically destroys earthwalls in the area.
422	*/	427	*/
423	int	428	int
424	cast_earth_to_dust (object *op, object *caster, object *spell_ob)	429	cast_earth_to_dust (object *op, object *caster, object *spell_ob)
425	{	430	{
426	object *tmp, *next;
427	int range, i, j, mflags;	431	int range, i, j, mflags;
428	sint16 sx, sy;	432	sint16 sx, sy;
429	maptile *m;	433	maptile *m;
430
431	if (op->type != PLAYER)
432	return 0;
433		434
434	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	435	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
435		436
436	for (i = -range; i <= range; i++)	437	for (i = -range; i <= range; i++)
437	for (j = -range; j <= range; j++)	438	for (j = -range; j <= range; j++)
…		…
442	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);	443	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
443		444
444	if (mflags & P_OUT_OF_MAP)	445	if (mflags & P_OUT_OF_MAP)
445	continue;	446	continue;
446		447
447	// earth to dust tears down everything that can be teared down	448	// earth to dust tears down everything that can be torn down
448	for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)	449	for (object *next, *tmp = m->at (sx, sy).bot; tmp; tmp = next)
449	{	450	{
450	next = tmp->above;	451	next = tmp->above;
		452
451	if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))	453	if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
452	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);	454	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
453	}	455	}
454	}	456	}
455		457
…		…
462	if (object *pl = op->in_player ())	464	if (object *pl = op->in_player ())
463	{	465	{
464	if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))	466	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.");	467	new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
466	else	468	else
467	{	469	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	}	470	}
473		471
474	op->destroy ();	472	op->destroy ();
475	}	473	}
476		474
…		…
492	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");	490	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
493	return 1;	491	return 1;
494	}	492	}
495		493
496	dummy = get_archetype (FORCE_NAME);	494	dummy = get_archetype (FORCE_NAME);
497	if (dummy == NULL)	495
		496	if (!dummy)
498	{	497	{
499	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	498	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
500	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");	499	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
501	return 0;	500	return 0;
502	}	501	}
…		…
565	}	564	}
566		565
567	int	566	int
568	perceive_self (object *op)	567	perceive_self (object *op)
569	{	568	{
570	char buf[MAX_BUF];
571	const char *cp = describe_item (op, op);	569	const char *cp = describe_item (op, op);
572	archetype *at = archetype::find (ARCH_DEPLETION);	570	archetype *at = archetype::find (ARCH_DEPLETION);
573	object *tmp;
574	int i;
575		571
		572	dynbuf_text &buf = msg_dynbuf; buf.clear ();
		573
		574	if (!op->is_player ())
		575	return 0;
		576
		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	op->contr->infobox (MSG_CHANNEL ("perceiveself"), buf);
621	}
622
623	/* int cast_create_town_portal (object *op, object *caster, int dir)
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		615
871	return 1;	616	return 1;
872	}	617	}
873		618
874	/* This creates magic walls. Really, it can create most any object,	619	/* This creates magic walls. Really, it can create most any object,
…		…
962	*/	707	*/
963	if (tmp->type != EARTHWALL) //TODO	708	if (tmp->type != EARTHWALL) //TODO
964	tmp->set_owner (op);	709	tmp->set_owner (op);
965		710
966	set_spell_skill (op, caster, spell_ob, tmp);	711	set_spell_skill (op, caster, spell_ob, tmp);
967	tmp->level = caster_level (caster, spell_ob) / 2;	712	tmp->level = casting_level (caster, spell_ob) / 2;
968		713
969	name = tmp->name;	714	name = tmp->name;
970	if (!(tmp = m->insert (tmp, x, y, op)))	715	if (!(tmp = m->insert (tmp, x, y, op)))
971	{	716	{
972	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);	717	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
973	return 0;	718	return 0;
974	}	719	}
975		720
976	/* If this is a spellcasting wall, need to insert the spell object */	721	/* If this is a spellcasting wall, need to insert the spell object */
977	if (tmp->other_arch && tmp->other_arch->clone.type == SPELL)	722	if (tmp->other_arch && tmp->other_arch->type == SPELL)
978	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);	723	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
979		724
980	/* This code causes the wall to extend some distance in	725	/* This code causes the wall to extend some distance in
981	* each direction, or until an obstruction is encountered.	726	* each direction, or until an obstruction is encountered.
982	* posblocked and negblocked help determine how far the	727	* posblocked and negblocked help determine how far the
…		…
1002	{	747	{
1003	object *tmp2 = tmp->clone ();	748	object *tmp2 = tmp->clone ();
1004	m->insert (tmp2, x, y, op);	749	m->insert (tmp2, x, y, op);
1005		750
1006	/* If this is a spellcasting wall, need to insert the spell object */	751	/* If this is a spellcasting wall, need to insert the spell object */
1007	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	752	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1008	tmp2->insert (arch_to_object (tmp2->other_arch));	753	tmp2->insert (arch_to_object (tmp2->other_arch));
1009		754
1010	}	755	}
1011	else	756	else
1012	posblocked = 1;	757	posblocked = 1;
…		…
1019	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)	764	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
1020	{	765	{
1021	object *tmp2 = tmp->clone ();	766	object *tmp2 = tmp->clone ();
1022	m->insert (tmp2, x, y, op);	767	m->insert (tmp2, x, y, op);
1023		768
1024	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	769	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1025	tmp2->insert (arch_to_object (tmp2->other_arch));	770	tmp2->insert (arch_to_object (tmp2->other_arch));
1026	}	771	}
1027	else	772	else
1028	negblocked = 1;	773	negblocked = 1;
1029	}	774	}
…		…
1033		778
1034	return 1;	779	return 1;
1035	}	780	}
1036		781
1037	int	782	int
1038	dimension_door (object *op, object *caster, object *spob, int dir)	783	dimension_door (object *op, object *caster, object *spob, int dir, const char *spellparam)
1039	{	784	{
1040	uint32 dist, maxdist;	785	uint32 dist, maxdist;
1041	int mflags;	786	int mflags;
1042	maptile *m;	787	maptile *m;
1043	sint16 sx, sy;	788	sint16 sx, sy;
…		…
1054	/* Given the new outdoor maps, can't let players dimension door for	799	/* Given the new outdoor maps, can't let players dimension door for
1055	* ever, so put limits in.	800	* ever, so put limits in.
1056	*/	801	*/
1057	maxdist = spob->range + SP_level_range_adjust (caster, spob);	802	maxdist = spob->range + SP_level_range_adjust (caster, spob);
1058		803
1059	if (op->contr->count)	804	if (spellparam)
1060	{	805	{
		806	int count = atoi (spellparam);
		807
1061	if (op->contr->count > maxdist)	808	if (count > maxdist)
1062	{	809	{
1063	new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!");	810	new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!");
1064	return 0;	811	return 0;
1065	}	812	}
1066		813
1067	for (dist = 0; dist < op->contr->count; dist++)	814	for (dist = 0; dist < count; dist++)
1068	{	815	{
1069	mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);	816	mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);
1070		817
1071	if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))	818	if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
1072	break;	819	break;
1073		820
1074	if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))	821	if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
1075	break;	822	break;
1076	}	823	}
1077		824
1078	if (dist < op->contr->count)	825	if (dist < count)
1079	{	826	{
1080	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");	827	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
1081	op->contr->count = 0;
1082	return 0;	828	return 0;
1083	}	829	}
1084
1085	op->contr->count = 0;
1086		830
1087	/* Remove code that puts player on random space on maps. IMO,	831	/* Remove code that puts player on random space on maps. IMO,
1088	* a lot of maps probably have areas the player should not get to,	832	* a lot of maps probably have areas the player should not get to,
1089	* but may not be marked as NO_MAGIC (as they may be bounded	833	* but may not be marked as NO_MAGIC (as they may be bounded
1090	* by such squares). Also, there are probably treasure rooms and	834	* by such squares). Also, there are probably treasure rooms and
…		…
1145		889
1146	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */	890	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
1147	return 1;	891	return 1;
1148	}	892	}
1149		893
1150
1151	/* cast_heal: Heals something.	894	/* cast_heal: Heals something.
1152	* op is the caster.	895	* op is the caster.
1153	* dir is the direction he is casting it in.	896	* dir is the direction he is casting it in.
1154	* spell is the spell object.	897	* spell is the spell object.
1155	*/	898	*/
…		…
1181	{	924	{
1182	/* See how many points we actually heal. Instead of messages	925	/* See how many points we actually heal. Instead of messages
1183	* based on type of spell, we instead do messages based	926	* based on type of spell, we instead do messages based
1184	* on amount of damage healed.	927	* on amount of damage healed.
1185	*/	928	*/
1186	if (heal > (tmp->stats.maxhp - tmp->stats.hp))	929	if (heal > tmp->stats.maxhp - tmp->stats.hp)
1187	heal = tmp->stats.maxhp - tmp->stats.hp;	930	heal = tmp->stats.maxhp - tmp->stats.hp;
		931
1188	tmp->stats.hp += heal;	932	tmp->stats.hp += heal;
1189		933
1190	if (tmp->stats.hp >= tmp->stats.maxhp)	934	if (tmp->stats.hp >= tmp->stats.maxhp)
1191	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");	935	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
1192	else if (heal > 50)	936	else if (heal > 50)
…		…
1201	success = 1;	945	success = 1;
1202	}	946	}
1203	}	947	}
1204		948
1205	if (spell->attacktype & AT_DISEASE)	949	if (spell->attacktype & AT_DISEASE)
1206	if (cure_disease (tmp, op))	950	if (cure_disease (tmp, op, spell))
1207	success = 1;	951	success = 1;
1208		952
1209	if (spell->attacktype & AT_POISON)	953	if (spell->attacktype & AT_POISON)
1210	{	954	{
1211	at = archetype::find ("poisoning");	955	at = archetype::find ("poisoning");
…		…
1260	}	1004	}
1261		1005
1262	if (spell->stats.food && tmp->stats.food < 999)	1006	if (spell->stats.food && tmp->stats.food < 999)
1263	{	1007	{
1264	tmp->stats.food += spell->stats.food;	1008	tmp->stats.food += spell->stats.food;
		1009
1265	if (tmp->stats.food > 999)	1010	if (tmp->stats.food > 999)
1266	tmp->stats.food = 999;	1011	tmp->stats.food = 999;
		1012
1267	success = 1;	1013	success = 1;
1268	/* We could do something a bit better like the messages for healing above */	1014	/* 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");	1015	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1270	}	1016	}
1271		1017
1272	return success;	1018	return success;
1273	}	1019	}
1274
1275		1020
1276	/* This is used for the spells that gain stats. There are no spells	1021	/* 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	1022	* right now that icnrease wis/int/pow on a temp basis, so no
1278	* good comments for those.	1023	* good comments for those.
1279	*/	1024	*/
1280	static const char *const no_gain_msgs[NUM_STATS] = {	1025	static const char *const no_gain_msgs[NUM_STATS] = {
1281	"You grow no stronger.",	1026	"You grow no stronger.",
1282	"You grow no more agile.",	1027	"You grow no more agile.",
1283	"You don't feel any healthier.",	1028	"You don't feel any healthier.",
1284	"no wis",	1029	"You didn't grow any more intelligent.",
		1030	"You do not feel any wiser.",
		1031	"You don't feel any more powerful."
1285	"You are no easier to look at.",	1032	"You are no easier to look at.",
1286	"no int",
1287	"no pow"
1288	};	1033	};
1289		1034
1290	int	1035	int
		1036	change_ability_duration (object *spell, object *caster)
		1037	{
		1038	return spell->duration + SP_level_duration_adjust (caster, spell) * 50;
		1039	}
		1040
		1041	int
1291	cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)	1042	cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1292	{	1043	{
1293	object *force = NULL;	1044	object *force = 0;
1294	int i;	1045	int i;
1295		1046
1296	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */	1047	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1297	object *tmp = dir	1048	object *tmp = dir
1298	? find_target_for_friendly_spell (op, dir)	1049	? find_target_for_friendly_spell (op, dir)
1299	: op;	1050	: op;
1300		1051
1301	if (!tmp)	1052	if (!tmp)
1302	return 0;	1053	return 0;
1303		1054
1304	/* If we've already got a force of this type, don't add a new one. */	1055	/* If we've already got a force of this type, don't add a new one. */
…		…
1312	break;	1063	break;
1313	}	1064	}
1314	else if (spell_ob->race && spell_ob->race == tmp2->name)	1065	else if (spell_ob->race && spell_ob->race == tmp2->name)
1315	{	1066	{
1316	if (!silent)	1067	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);	1068	new_draw_info_format (NDI_UNIQUE, 0, op,
		1069	"You can not cast %s while %s is in effect",
		1070	&spell_ob->name, &tmp2->name_pl);
		1071
1318	return 0;	1072	return 0;
1319	}	1073	}
1320	}	1074	}
1321	}	1075	}
		1076
		1077	int duration = change_ability_duration (spell_ob, caster);
		1078
1322	if (force == NULL)	1079	if (force)
1323	{
1324	force = get_archetype (FORCE_NAME);
1325	force->subtype = FORCE_CHANGE_ABILITY;
1326	if (spell_ob->race)
1327	force->name = spell_ob->race;
1328	else
1329	force->name = spell_ob->name;
1330	force->name_pl = spell_ob->name;
1331	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
1332
1333	}	1080	{
1334	else
1335	{
1336	int duration;
1337
1338	duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1339	if (duration > force->duration)	1081	if (duration > force->duration)
1340	{	1082	{
1341	force->duration = duration;	1083	force->duration = duration;
1342	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	1084	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1343	}	1085	}
1344	else	1086	else
1345	{
1346	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1087	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1347	}	1088
1348	return 1;	1089	return 1;
1349	}	1090	}
1350	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1091
		1092	new_draw_info_format (NDI_UNIQUE, 0, op,
		1093	"You create an aura of magical force. H<The effect will last for about %.10g seconds.>",
		1094	TICK2TIME (duration));
		1095
		1096	force = get_archetype (FORCE_NAME);
		1097	force->subtype = FORCE_CHANGE_ABILITY;
		1098	force->duration = duration;
		1099
		1100	if (spell_ob->race)
		1101	force->name = spell_ob->race;
		1102	else
		1103	force->name = spell_ob->name;
		1104
		1105	force->name_pl = spell_ob->name;
		1106
1351	force->speed = 1.0;	1107	force->speed = 1.0;
1352	force->speed_left = -1.0;	1108	force->speed_left = -1.0;
1353	SET_FLAG (force, FLAG_APPLIED);	1109	SET_FLAG (force, FLAG_APPLIED);
1354		1110
1355	/* Now start processing the effects. First, protections */	1111	/* Now start processing the effects. First, protections */
…		…
1360	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);	1116	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);
1361	if (force->resist[i] > 100)	1117	if (force->resist[i] > 100)
1362	force->resist[i] = 100;	1118	force->resist[i] = 100;
1363	}	1119	}
1364	}	1120	}
		1121
1365	if (spell_ob->stats.hp)	1122	if (spell_ob->stats.hp)
1366	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);	1123	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
1367		1124
1368	if (tmp->type == PLAYER)	1125	if (tmp->type == PLAYER)
1369	{	1126	{
1370	/* Stat adjustment spells */	1127	/* Stat adjustment spells */
1371	for (i = 0; i < NUM_STATS; i++)	1128	for (i = 0; i < NUM_STATS; i++)
1372	{	1129	{
1373	sint8 stat = get_attr_value (&spell_ob->stats, i), k, sm;	1130	if (sint8 stat = spell_ob->stats.stat (i))
1374
1375	if (stat)
1376	{	1131	{
1377	sm = 0;	1132	sint8 sm = 0;
1378	for (k = 0; k < stat; k++)	1133	for (sint8 k = 0; k < stat; k++)
1379	sm += rndm (1, 3);	1134	sm += rndm (1, 3);
1380		1135
1381	if ((get_attr_value (&tmp->stats, i) + sm) > (15 + 5 * stat))	1136	if (tmp->stats.stat (i) + sm > 15 + 5 * stat)
1382	{	1137	sm = max (0, (15 + 5 * stat) - tmp->stats.stat (i));
1383	sm = (15 + 5 * stat) - get_attr_value (&tmp->stats, i);	1138
1384	if (sm < 0)	1139	force->stats.stat (i) = sm;
1385	sm = 0;	1140
1386	}
1387	set_attr_value (&force->stats, i, sm);
1388	if (!sm)	1141	if (!sm)
1389	new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);	1142	new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);
1390	}	1143	}
1391	}	1144	}
1392	}	1145	}
…		…
1413	force->attacktype = spell_ob->attacktype;	1166	force->attacktype = spell_ob->attacktype;
1414		1167
1415	insert_ob_in_ob (force, tmp);	1168	insert_ob_in_ob (force, tmp);
1416	change_abil (tmp, force); /* Mostly to display any messages */	1169	change_abil (tmp, force); /* Mostly to display any messages */
1417	tmp->update_stats ();	1170	tmp->update_stats ();
		1171
1418	return 1;	1172	return 1;
1419	}	1173	}
1420		1174
1421	/* This used to be part of cast_change_ability, but it really didn't make	1175	/* 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	1176	* a lot of sense, since most of the values it derives are from the god
1423	* of the caster.	1177	* of the caster.
1424	*/	1178	*/
1425
1426	int	1179	int
1427	cast_bless (object *op, object *caster, object *spell_ob, int dir)	1180	cast_bless (object *op, object *caster, object *spell_ob, int dir)
1428	{	1181	{
1429	int i;	1182	int i;
1430	object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;	1183	object *god = find_god (determine_god (op)), *force = NULL, *tmp;
1431		1184
1432	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */	1185	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1433	if (dir != 0)	1186	if (dir != 0)
1434	{	1187	{
1435	tmp = find_target_for_friendly_spell (op, dir);	1188	tmp = find_target_for_friendly_spell (op, dir);
		1189
		1190	if (!tmp)
		1191	return 0;
1436	}	1192	}
1437	else	1193	else
1438	{
1439	tmp = op;	1194	tmp = op;
1440	}
1441		1195
1442	/* If we've already got a force of this type, don't add a new one. */	1196	/* 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)	1197	for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1444	{	1198	{
1445	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)	1199	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1446	{	1200	{
1447	if (tmp2->name == spell_ob->name)	1201	if (tmp2->name == spell_ob->name)
1448	{	1202	{
…		…
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);	1208	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;	1209	return 0;
1456	}	1210	}
1457	}	1211	}
1458	}	1212	}
		1213
1459	if (force == NULL)	1214	if (force == NULL)
1460	{	1215	{
1461	force = get_archetype (FORCE_NAME);	1216	force = get_archetype (FORCE_NAME);
1462	force->subtype = FORCE_CHANGE_ABILITY;	1217	force->subtype = FORCE_CHANGE_ABILITY;
1463	if (spell_ob->race)	1218	if (spell_ob->race)
…		…
1528	}	1283	}
1529		1284
1530	/* Alchemy code by Mark Wedel	1285	/* Alchemy code by Mark Wedel
1531	*	1286	*
1532	* This code adds a new spell, called alchemy. Alchemy will turn	1287	* This code adds a new spell, called alchemy. Alchemy will turn
1533	* objects to gold nuggets, the value of the gold nuggets being	1288	* 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	*	1289	*
1538	* Large nuggets are worth 25 gp each (base). You will always get	1290	* The value of the gold nuggets being about 90% of that of the item
1539	* the maximum number of large nuggets you could get.	1291	* 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	1292	* because the nuggets themselves will be will be adjusted by charisma
1541	* to the max amount of small nuggets as you could get.	1293	* 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	*	1294	*
1546	* There is also a chance (1:30) that you will get nothing at all	1295	* 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	1296	* for the object. There is also a maximum weight that will be
1548	* alchemised.	1297	* alchemised.
1549	*/	1298	*/
1550	static void	1299	static void
1551	alchemy_object (object *obj, uint64 &total_value, int &total_weight)	1300	alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1552	{	1301	{
1553	uint64 value = query_cost (obj, NULL, F_TRUE);	1302	uint64 value = query_cost (obj, NULL, F_TRUE);
1554		1303
1555	/* Give third price when we alchemy money (This should hopefully	1304	/* Give third price when we alchemy money (this should hopefully
1556	* make it so that it isn't worth it to alchemy money, sell	1305	* make it so that it isn't worth it to alchemy money, sell
1557	* the nuggets, alchemy the gold from that, etc.	1306	* the nuggets, alchemy the gold from that, etc.
1558	* Otherwise, give 9 silver on the gold for other objects,	1307	* Otherwise, give 9 silver on the gold for other objects,
1559	* so that it would still be more affordable to haul	1308	* so that it would still be more affordable to haul
1560	* the stuff back to town.	1309	* the stuff back to town.
…		…
1572	total_weight += obj->total_weight ();	1321	total_weight += obj->total_weight ();
1573		1322
1574	obj->destroy ();	1323	obj->destroy ();
1575	}	1324	}
1576		1325
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	1326	int
1608	alchemy (object *op, object *caster, object *spell_ob)	1327	alchemy (object *op, object *caster, object *spell_ob)
1609	{	1328	{
1610	if (op->type != PLAYER)	1329	if (op->type != PLAYER)
1611	return 0;	1330	return 0;
1612		1331
1613	object *large = get_archetype ("largenugget");	1332	archetype *nugget[3];
1614	object *small = get_archetype ("smallnugget");	1333
		1334	nugget[0] = archetype::find ("pyrite3");
		1335	nugget[1] = archetype::find ("pyrite2");
		1336	nugget[2] = archetype::find ("pyrite");
1615		1337
1616	/* Put a maximum weight of items that can be alchemised. Limits the power	1338	/* 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	1339	* some, and also prevents people from alchemising every table/chair/clock
1618	* in sight	1340	* in sight
1619	*/	1341	*/
…		…
1671	if (weight > weight_max)	1393	if (weight > weight_max)
1672	break;	1394	break;
1673	}	1395	}
1674	}	1396	}
1675		1397
		1398	value -= rndm (value >> 4);
1676	value = min (value, value_max);	1399	value = min (value, value_max);
1677		1400
1678	uint64 count = value / large->value;	1401	for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1679	int large_nuggets = count;	1402	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	*/	1403	{
1689	update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny);	1404	value -= nrof * nugget[i]->value;
		1405
		1406	object *tmp = arch_to_object (nugget[i]);
		1407	tmp->nrof = nrof;
		1408	tmp->flag [FLAG_IDENTIFIED] = true;
		1409	op->map->insert (tmp, x, y, op, 0);
		1410	}
1690		1411
1691	if (weight > weight_max)	1412	if (weight > weight_max)
1692	goto bailout;	1413	goto bailout;
1693	}	1414	}
1694	}	1415	}
1695		1416
1696	bailout:	1417	bailout:
1697	large->destroy ();
1698	small->destroy ();
1699	return 1;	1418	return 1;
1700	}	1419	}
1701
1702		1420
1703	/* This function removes the cursed/damned status on equipped	1421	/* This function removes the cursed/damned status on equipped
1704	* items.	1422	* items.
1705	*/	1423	*/
1706	int	1424	int
1707	remove_curse (object *op, object *caster, object *spell)	1425	remove_curse (object *op, object *caster, object *spell)
1708	{	1426	{
1709	object *tmp;
1710	int success = 0, was_one = 0;	1427	int success = 0, was_one = 0;
1711		1428
1712	for (tmp = op->inv; tmp; tmp = tmp->below)	1429	for (object *tmp = op->inv; tmp; tmp = tmp->below)
1713	if (QUERY_FLAG (tmp, FLAG_APPLIED) &&	1430	if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
1714	((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||	1431	((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1715	(QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))	1432	(QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1716	{	1433	{
1717	was_one++;	1434	was_one++;
		1435
1718	if (tmp->level <= caster_level (caster, spell))	1436	if (tmp->level <= casting_level (caster, spell))
1719	{	1437	{
1720	success++;	1438	success++;
1721	if (QUERY_FLAG (spell, FLAG_DAMNED))	1439	if (QUERY_FLAG (spell, FLAG_DAMNED))
1722	CLEAR_FLAG (tmp, FLAG_DAMNED);	1440	CLEAR_FLAG (tmp, FLAG_DAMNED);
1723		1441
1724	CLEAR_FLAG (tmp, FLAG_CURSED);	1442	CLEAR_FLAG (tmp, FLAG_CURSED);
1725	CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);	1443	CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);
1726	tmp->value = 0; /* Still can't sell it */	1444	tmp->value = 0; /* Still can't sell it */
1727	if (op->type == PLAYER)	1445
		1446	if (object *pl = tmp->visible_to ())
1728	esrv_send_item (op, tmp);	1447	esrv_update_item (UPD_FLAGS, pl, tmp);
1729	}	1448	}
1730	}	1449	}
1731		1450
1732	if (op->type == PLAYER)	1451	if (op->type == PLAYER)
1733	{	1452	{
…		…
1744		1463
1745	return success;	1464	return success;
1746	}	1465	}
1747		1466
1748	/* Identifies objects in the players inventory/on the ground */	1467	/* Identifies objects in the players inventory/on the ground */
1749
1750	int	1468	int
1751	cast_identify (object *op, object *caster, object *spell)	1469	cast_identify (object *op, object *caster, object *spell)
1752	{	1470	{
1753	object *tmp;	1471	object *tmp;
1754	int success = 0, num_ident;	1472	dynbuf_text &buf = msg_dynbuf; buf.clear ();
1755		1473
1756	num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1474	int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1757
1758	if (num_ident < 1)
1759	num_ident = 1;
1760		1475
1761	for (tmp = op->inv; tmp; tmp = tmp->below)	1476	for (tmp = op->inv; tmp; tmp = tmp->below)
1762	{	1477	{
1763	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))	1478	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
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--;
1779	success = 1;
1780	if (!num_ident)	1490	if (!--num_ident)
1781	break;	1491	break;
1782	}	1492	}
1783	}	1493	}
1784		1494
1785	/* If all the power of the spell has been used up, don't go and identify	1495	/* If all the power of the spell has been used up, don't go and identify
1786	* stuff on the floor. Only identify stuff on the floor if the spell	1496	* stuff on the floor. Only identify stuff on the floor if the spell
1787	* was not fully used.	1497	* was not fully used.
1788	*/	1498	*/
1789	if (num_ident)	1499	if (num_ident)
1790	{	1500	{
1791	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	1501	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))	1502	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1793	{	1503	{
1794	identify (tmp);	1504	identify (tmp);
1795		1505
1796	if (op->type == PLAYER)	1506	if (object *pl = tmp->visible_to ())
1797	{	1507	{
1798	new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op));	1508	buf.printf ("On the ground you identified: %s.\r", long_desc (tmp, op));
1799		1509
1800	if (tmp->msg)	1510	if (tmp->msg)
1801	{	1511	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	}	1512	}
1808		1513
1809	num_ident--;
1810	success = 1;
1811	if (!num_ident)	1514	if (!--num_ident)
1812	break;	1515	break;
1813	}	1516	}
1814	}	1517	}
1815		1518
1816	if (!success)	1519	if (buf.empty ())
1817	new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified.");	1520	{
		1521	op->failmsg ("You can't reach anything unidentified.");
		1522	return 0;
		1523	}
1818	else	1524	else
		1525	{
		1526	if (op->contr)
		1527	op->contr->infobox (MSG_CHANNEL ("identify"), buf);
		1528
1819	spell_effect (spell, op->x, op->y, op->map, op);	1529	spell_effect (spell, op->x, op->y, op->map, op);
1820		1530	return 1;
1821	return success;	1531	}
1822	}	1532	}
1823		1533
1824	int	1534	int
1825	cast_detection (object *op, object *caster, object *spell, object *skill)	1535	cast_detection (object *op, object *caster, object *spell, object *skill)
1826	{	1536	{
…		…
1831		1541
1832	/* We precompute some values here so that we don't have to keep	1542	/* We precompute some values here so that we don't have to keep
1833	* doing it over and over again.	1543	* doing it over and over again.
1834	*/	1544	*/
1835	god = find_god (determine_god (op));	1545	god = find_god (determine_god (op));
1836	level = caster_level (caster, spell);	1546	level = casting_level (caster, spell);
1837	range = spell->range + SP_level_range_adjust (caster, spell);	1547	range = spell->range + SP_level_range_adjust (caster, spell);
1838		1548
1839	if (!skill)	1549	if (!skill)
1840	skill = caster;	1550	skill = caster;
1841		1551
1842	for (x = op->x - range; x <= op->x + range; x++)	1552	unordered_mapwalk (op, -range, -range, range, range)
1843	for (y = op->y - range; y <= op->y + range; y++)
1844	{	1553	{
1845	m = op->map;
1846	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1847	if (mflags & P_OUT_OF_MAP)
1848	continue;
1849
1850	/* For most of the detections, we only detect objects above the	1554	/* For most of the detections, we only detect objects above the
1851	* floor. But this is not true for show invisible.	1555	* floor. But this is not true for show invisible.
1852	* Basically, we just go and find the top object and work	1556	* Basically, we just go and find the top object and work
1853	* down - that is easier than working up.	1557	* down - that is easier than working up.
1854	*/	1558	*/
1855		1559
1856	for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above)	1560	for (last = NULL, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1857	last = tmp;	1561	last = tmp;
1858		1562
1859	/* Shouldn't happen, but if there are no objects on a space, this	1563	/* Shouldn't happen, but if there are no objects on a space, this
1860	* would happen.	1564	* would happen.
1861	*/	1565	*/
1862	if (!last)	1566	if (!last)
1863	continue;	1567	continue;
1864		1568
1865	done_one = 0;	1569	done_one = 0;
1866	floor = 0;	1570	floor = 0;
1867	detect = NULL;	1571	detect = NULL;
1868	for (tmp = last; tmp; tmp = tmp->below)	1572	for (tmp = last; tmp; tmp = tmp->below)
1869	{	1573	{
1870	/* show invisible */	1574	/* show invisible */
1871	if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&	1575	if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&
1872	/* Might there be other objects that we can make visible? */	1576	/* Might there be other objects that we can make visible? */
1873	(tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) ||	1577	(tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER)
1874	(tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) ||	1578	|| (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ))
1875	tmp->type == CF_HANDLE ||	1579	|| tmp->type == CF_HANDLE
1876	tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE ||	1580	|| tmp->type == TRAPDOOR
		1581	|| tmp->type == EXIT
		1582	|| tmp->type == HOLE
		1583	|| tmp->type == BUTTON
1877	tmp->type == BUTTON || tmp->type == TELEPORTER ||	1584	|| tmp->type == TELEPORTER
		1585	|| tmp->type == GATE
1878	tmp->type == GATE || tmp->type == LOCKED_DOOR ||	1586	|| tmp->type == LOCKED_DOOR
1879	tmp->type == WEAPON || tmp->type == ALTAR || tmp->type == SIGN ||	1587	|| tmp->type == WEAPON
		1588	|| tmp->type == ALTAR
		1589	|| tmp->type == SIGN
1880	tmp->type == TRIGGER_PEDESTAL || tmp->type == SPECIAL_KEY ||	1590	|| tmp->type == TRIGGER_PEDESTAL
1881	tmp->type == TREASURE || tmp->type == BOOK || tmp->type == HOLY_ALTAR)))	1591	|| tmp->type == SPECIAL_KEY
		1592	|| tmp->type == TREASURE
		1593	|| tmp->type == BOOK
		1594	|| tmp->type == HOLY_ALTAR
		1595	|| tmp->type == CONTAINER)))
1882	{	1596	{
1883	if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)	1597	if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1884	{	1598	{
1885	tmp->invisible = 0;	1599	tmp->invisible = 0;
1886	done_one = 1;	1600	done_one = 1;
1887	}	1601	}
1888	}	1602	}
1889		1603
1890	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1604	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1891	floor = 1;	1605	floor = 1;
1892		1606
1893	/* All detections below this point don't descend beneath the floor,	1607	/* All detections below this point don't descend beneath the floor,
1894	* so just continue on. We could be clever and look at the type of	1608	* so just continue on. We could be clever and look at the type of
1895	* detection to completely break out if we don't care about objects beneath	1609	* detection to completely break out if we don't care about objects beneath
1896	* the floor, but once we get to the floor, not likely a very big issue anyways.	1610	* the floor, but once we get to the floor, not likely a very big issue anyways.
1897	*/	1611	*/
1898	if (floor)	1612	if (floor)
1899	continue;	1613	continue;
1900		1614
1901	/* I had thought about making detect magic and detect curse	1615	/* I had thought about making detect magic and detect curse
1902	* show the flash the magic item like it does for detect monster.	1616	* show the flash the magic item like it does for detect monster.
1903	* however, if the object is within sight, this would then make it	1617	* however, if the object is within sight, this would then make it
1904	* difficult to see what object is magical/cursed, so the	1618	* difficult to see what object is magical/cursed, so the
1905	* effect wouldn't be as apparant.	1619	* effect wouldn't be as apparent.
1906	*/	1620	*/
1907		1621
1908	/* detect magic */	1622	/* detect magic */
1909	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&	1623	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&
1910	!QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))	1624	!QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))
1911	{	1625	{
1912	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1626	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1913	/* make runes more visibile */	1627	/* make runes more visibile */
1914	if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)	1628	if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1915	tmp->stats.Cha /= 4;	1629	tmp->stats.Cha /= 4;
		1630
1916	done_one = 1;	1631	done_one = 1;
1917	}	1632	}
		1633
1918	/* detect monster */	1634	/* detect monster */
1919	if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))	1635	if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))
1920	{	1636	{
1921	done_one = 2;	1637	done_one = 2;
		1638
1922	if (!detect)	1639	if (!detect)
1923	detect = tmp;	1640	detect = tmp;
1924	}	1641	}
		1642
1925	/* Basically, if race is set in the spell, then the creatures race must	1643	/* 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	1644	* match that. if the spell race is set to GOD, then the gods opposing
1927	* race must match.	1645	* race must match.
1928	*/	1646	*/
1929	if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&	1647	if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&
1930	((!strcmp (spell->race, "GOD") && god && god->slaying && strstr (god->slaying, tmp->race)) ||	1648	((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||
1931	(strstr (spell->race, tmp->race))))	1649	spell->race.contains (tmp->race)))
1932	{	1650	{
1933	done_one = 2;	1651	done_one = 2;
		1652
1934	if (!detect)	1653	if (!detect)
1935	detect = tmp;	1654	detect = tmp;
1936	}	1655	}
		1656
1937	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1657	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1938	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))	1658	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1939	{	1659	{
1940	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1660	SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1941	done_one = 1;	1661	done_one = 1;
1942	}	1662	}
1943	} /* for stack of objects on this space */	1663	} /* for stack of objects on this space */
1944		1664
1945	/* Code here puts an effect of the spell on the space, so you can see	1665	/* Code here puts an effect of the spell on the space, so you can see
1946	* where the magic is.	1666	* where the magic is.
1947	*/	1667	*/
1948	if (done_one)	1668	if (done_one)
1949	{	1669	{
1950	object *detect_ob = arch_to_object (spell->other_arch);	1670	object *detect_ob = arch_to_object (spell->other_arch);
1951		1671
1952	/* if this is set, we want to copy the face */	1672	/* if this is set, we want to copy the face */
1953	if (done_one == 2 && detect)	1673	if (done_one == 2 && detect)
1954	{	1674	{
1955	detect_ob->face = detect->face;	1675	detect_ob->face = detect->face;
1956	detect_ob->animation_id = detect->animation_id;	1676	detect_ob->animation_id = detect->animation_id;
1957	detect_ob->anim_speed = detect->anim_speed;	1677	detect_ob->anim_speed = detect->anim_speed;
1958	detect_ob->last_anim = 0;	1678	detect_ob->last_anim = 0;
1959	/* by default, the detect_ob is already animated */	1679	/* by default, the detect_ob is already animated */
1960	if (!QUERY_FLAG (detect, FLAG_ANIMATE))	1680	if (!QUERY_FLAG (detect, FLAG_ANIMATE))
1961	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);	1681	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
1962	}	1682	}
1963		1683
1964	m->insert (detect_ob, nx, ny, op);	1684	m->insert (detect_ob, nx, ny, op);
1965	}	1685	}
1966	} /* for processing the surrounding spaces */	1686	} /* for processing the surrounding spaces */
1967		1687
1968		1688
1969	/* Now process objects in the players inventory if detect curse or magic */	1689	/* 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))	1690	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))
1971	{	1691	{
1972	done_one = 0;	1692	done_one = 0;
		1693
1973	for (tmp = op->inv; tmp; tmp = tmp->below)	1694	for (tmp = op->inv; tmp; tmp = tmp->below)
1974	{	1695	{
1975	if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1696	if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1976	{	1697	{
1977	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))	1698	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))
1978	{	1699	{
1979	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1700	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1980	if (op->type == PLAYER)	1701
		1702	if (object *pl = tmp->visible_to ())
1981	esrv_send_item (op, tmp);	1703	esrv_update_item (UPD_FLAGS, pl, tmp);
1982	}	1704	}
		1705
1983	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1706	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1984	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))	1707	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1985	{	1708	{
1986	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1709	SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1987	if (op->type == PLAYER)	1710
		1711	if (object *pl = tmp->visible_to ())
1988	esrv_send_item (op, tmp);	1712	esrv_update_item (UPD_FLAGS, pl, tmp);
1989	}	1713	}
1990	} /* if item is not identified */	1714	} /* if item is not identified */
1991	} /* for the players inventory */	1715	} /* for the players inventory */
1992	} /* if detect magic/curse and object is a player */	1716	} /* if detect magic/curse and object is a player */
		1717
1993	return 1;	1718	return 1;
1994	}	1719	}
1995		1720
1996		1721
1997	/**	1722	/**
…		…
2010		1735
2011	new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");	1736	new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");
2012		1737
2013	if (victim->stats.sp >= victim->stats.maxsp * 2)	1738	if (victim->stats.sp >= victim->stats.maxsp * 2)
2014	{	1739	{
2015	object *tmp;
2016
2017	new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");	1740	new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");
2018
2019	/* Explodes a fireball centered at player */
2020	tmp = get_archetype (EXPLODING_FIREBALL);
2021	tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
2022	tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
2023
2024	tmp->insert_at (victim);
2025	victim->stats.sp = 2 * victim->stats.maxsp;	1741	victim->stats.sp = 2 * victim->stats.maxsp;
		1742	create_exploding_ball_at (victim, caster_level);
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];
2633	object *tmp;
2634
2635	if (!msg || msg[0] == 0)	2330	if (!msg || msg[0] == 0)
2636	{	2331	{
2637	new_draw_info (NDI_UNIQUE, 0, op, "Write what?");	2332	new_draw_info (NDI_UNIQUE, 0, op, "Write what?");
2638	return 0;	2333	return 0;
2639	}	2334	}
2640		2335
2641	if (strcasestr_local (msg, "endmsg"))	2336	if (!msg_is_safe (msg))
2642	{	2337	{
2643	new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");	2338	new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");
2644	LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg);	2339	LOG (llevInfo, "write_mark: player %s tried to write bogus rune %s\n", &op->name, msg);
2645	return 0;	2340	return 0;
2646	}	2341	}
		2342
2647	if (!spell->other_arch)	2343	if (!spell->other_arch)
2648	return 0;	2344	return 0;
		2345
2649	tmp = arch_to_object (spell->other_arch);	2346	object *tmp = arch_to_object (spell->other_arch);
2650
2651	snprintf (rune, sizeof (rune), "%s\n", msg);
2652		2347
2653	tmp->race = op->name; /*Save the owner of the rune */	2348	tmp->race = op->name; /*Save the owner of the rune */
2654	tmp->msg = rune;	2349	tmp->msg = msg;
2655		2350
2656	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);	2351	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
		2352
2657	return 1;	2353	return 1;
2658	}	2354	}
		2355

Diff Legend

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