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.20 by root, Thu Dec 14 04:30:32 2006 UTC vs.
Revision 1.107 by elmex, Thu Sep 17 16:53:15 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 (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
4	Copyright (C) 2002 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
5	Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
6		7	*
7	This program is free software; you can redistribute it and/or modify	8	* Deliantra is free software: you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
9	the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
10	(at your option) any later version.	11	* (at your option) any later version.
11		12	*
12	This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.	16	* GNU General Public License for more details.
16		17	*
17	You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	*
20		21	* The authors can be reached via e-mail to <support@deliantra.net>
21	The authors can be reached via e-mail at <crossfire@schmorp.de>
22	*/	22	*/
23		23
24	#include <global.h>	24	#include <global.h>
25	#include <object.h>	25	#include <object.h>
26	#include <living.h>	26	#include <living.h>
27	#ifndef __CEXTRACT__
28	# include <sproto.h>	27	#include <sproto.h>
29	#endif
30	#include <spells.h>	28	#include <spells.h>
31	#include <sounds.h>	29	#include <sounds.h>
32		30
33	/* cast_magic_storm: This is really used mostly for spell	31	/* cast_magic_storm: This is really used mostly for spell
34	* fumbles at the like. tmp is the object to propogate.	32	* fumbles at the like. tmp is the object to propogate.
…		…
37	void	35	void
38	cast_magic_storm (object *op, object *tmp, int lvl)	36	cast_magic_storm (object *op, object *tmp, int lvl)
39	{	37	{
40	if (!tmp)	38	if (!tmp)
41	return; /* error */	39	return; /* error */
		40
42	tmp->level = op->level;	41	tmp->level = op->level;
43	tmp->x = op->x;
44	tmp->y = op->y;
45	tmp->range += lvl / 5; /* increase the area of destruction */	42	tmp->range += lvl / 5; /* increase the area of destruction */
46	tmp->duration += lvl / 5;	43	tmp->duration += lvl / 5;
47		44
48	/* Put a cap on duration for this - if the player fails in their	45	/* Put a cap on duration for this - if the player fails in their
49	* apartment, don't want it to go on so long that it kills them	46	* apartment, don't want it to go on so long that it kills them
50	* multiple times. Also, damge already increases with level,	47	* multiple times. Also, damge already increases with level,
51	* so don't really need to increase the duration as much either.	48	* so don't really need to increase the duration as much either.
52	*/	49	*/
53	if (tmp->duration >= 40)	50	if (tmp->duration >= 40)
54	tmp->duration = 40;	51	tmp->duration = 40;
		52
55	tmp->stats.dam = lvl; /* nasty recoils! */	53	tmp->stats.dam = lvl; /* nasty recoils! */
56	tmp->stats.maxhp = tmp->count; /* tract single parent */	54	tmp->stats.maxhp = tmp->count; /* tract single parent */
57	insert_ob_in_map (tmp, op->map, op, 0);
58		55
		56	tmp->insert_at (op, op);
59	}	57	}
60
61		58
62	int	59	int
63	recharge (object *op, object *caster, object *spell_ob)	60	recharge (object *op, object *caster, object *spell_ob)
64	{	61	{
65	object *wand, *tmp;	62	object *wand, *tmp;
66	int ncharges;	63	int ncharges;
67		64
68	wand = find_marked_object (op);	65	wand = find_marked_object (op);
69	if (wand == NULL || wand->type != WAND)	66	if (!wand || wand->type != WAND)
70	{	67	{
71	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");	68	new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");
72	return 0;	69	return 0;
73	}	70	}
74	if (!(random_roll (0, 3, op, PREFER_HIGH)))	71	if (!(random_roll (0, 3, op, PREFER_HIGH)))
75	{	72	{
76	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));	73	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));
77	play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE);	74	op->play_sound (sound_find ("ob_explode"));
78	esrv_del_item (op->contr, wand->count);
79	wand->destroy ();	75	wand->destroy ();
80	tmp = get_archetype ("fireball");	76	tmp = get_archetype ("fireball");
81	tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;	77	tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
		78
82	if (!tmp->stats.dam)	79	if (!tmp->stats.dam)
83	tmp->stats.dam = 1;	80	tmp->stats.dam = 1;
		81
84	tmp->stats.hp = tmp->stats.dam / 2;	82	tmp->stats.hp = tmp->stats.dam / 2;
		83
85	if (tmp->stats.hp < 2)	84	if (tmp->stats.hp < 2)
86	tmp->stats.hp = 2;	85	tmp->stats.hp = 2;
87	tmp->x = op->x;	86
88	tmp->y = op->y;	87	tmp->insert_at (op);
89	insert_ob_in_map (tmp, op->map, NULL, 0);
90	return 1;	88	return 1;
91	}	89	}
92		90
93	ncharges = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob));	91	ncharges = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob));
		92
94	if (wand->inv && wand->inv->level)	93	if (wand->inv && wand->inv->level)
95	ncharges /= wand->inv->level;	94	ncharges /= wand->inv->level;
96	else	95	else
97	{	96	{
98	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand));	97	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand));
99	return 0;	98	return 0;
100	}	99	}
		100
101	if (!ncharges)	101	if (!ncharges)
102	ncharges = 1;	102	ncharges = 1;
103		103
104	wand->stats.food += ncharges;	104	wand->stats.food += ncharges;
105	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));	105	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
		106
106	if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE))	107	if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE))
107	{	108	{
108	SET_FLAG (wand, FLAG_ANIMATE);	109	SET_FLAG (wand, FLAG_ANIMATE);
109	wand->speed = wand->arch->clone.speed;	110	wand->set_speed (wand->arch->speed);
110	update_ob_speed (wand);
111	}	111	}
		112
112	return 1;	113	return 1;
113	}	114	}
114		115
115	/* Create a missile (nonmagic - magic +4). Will either create bolts or arrows	116	/* Create a missile (nonmagic - magic +4). Will either create bolts or arrows
116	* based on whether a crossbow or bow is equiped. If neither, it defaults to	117	* based on whether a crossbow or bow is equiped. If neither, it defaults to
…		…
120	* great a plus, the default is used.	121	* great a plus, the default is used.
121	* The # of arrows created also goes up with level, so if a 30th level mage	122	* The # of arrows created also goes up with level, so if a 30th level mage
122	* wants LOTS of arrows, and doesn't care what the plus is he could	123	* wants LOTS of arrows, and doesn't care what the plus is he could
123	* create nonnmagic arrows, or even -1, etc...	124	* create nonnmagic arrows, or even -1, etc...
124	*/	125	*/
125
126	int	126	int
127	cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg)	127	cast_create_missile (object *op, object *caster, object *spell, int dir, const char *spellparam)
128	{	128	{
129	int missile_plus = 0, bonus_plus = 0;	129	int bonus_plus = 0;
130	const char *missile_name;	130	const char *missile_name = "arrow";
131	object *tmp, *missile;
132		131
133	missile_name = "arrow";
134
135	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	132	for (object *tmp = op->inv; tmp; tmp = tmp->below)
136	if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))	133	if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
137	missile_name = tmp->race;	134	missile_name = tmp->race;
138		135
139	missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);	136	int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
140		137
141	if (archetype::find (missile_name) == NULL)	138	archetype *missile_arch = archetype::find (missile_name);
		139
		140	if (!missile_arch)
142	{	141	{
143	LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);	142	LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);
144	return 0;	143	return 0;
145	}	144	}
146		145
147	missile = get_archetype (missile_name);	146	object *missile = missile_arch->instance ();
148		147
149	if (stringarg)	148	if (spellparam)
150	{	149	{
151	/* If it starts with a letter, presume it is a description */	150	/* If it starts with a letter, presume it is a description */
152	if (isalpha (*stringarg))	151	if (isalpha (*spellparam))
153	{	152	{
154	artifact *al = find_artifactlist (missile->type)->items;	153	artifact *al = find_artifactlist (missile->type)->items;
155		154
156	for (; al != NULL; al = al->next)	155	for (; al; al = al->next)
157	if (!strcasecmp (al->item->name, stringarg))	156	if (!strcasecmp (al->item->name, spellparam))
158	break;	157	break;
159		158
160	if (!al)	159	if (!al)
161	{	160	{
162	missile->destroy ();	161	missile->destroy ();
163	new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, stringarg);	162	new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, spellparam);
164	return 0;	163	return 0;
165	}	164	}
166		165
167	if (al->item->slaying)	166	if (al->item->slaying)
168	{	167	{
169	missile->destroy ();	168	missile->destroy ();
170	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg);	169	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, spellparam);
171	return 0;	170	return 0;
172	}	171	}
173		172
174	give_artifact_abilities (missile, al->item);	173	give_artifact_abilities (missile, al->item);
175	/* These special arrows cost something extra. Don't have them also be magical -	174	/* These special arrows cost something extra. Don't have them also be magical -
176	* otherwise, in most cases, not enough will be created. I don't want to get into	175	* otherwise, in most cases, not enough will be created. I don't want to get into
177	* the parsing of having to do both plus and type.	176	* the parsing of having to do both plus and type.
178	*/	177	*/
179	bonus_plus = 1 + (al->item->value / 5);	178	bonus_plus = 1 + (al->item->value / 5);
180	missile_plus = 0;	179	missile_plus = 0;
181	}	180	}
182	else if (atoi (stringarg) < missile_plus)	181	else if (atoi (spellparam) < missile_plus)
183	missile_plus = atoi (stringarg);	182	missile_plus = atoi (spellparam);
184	}	183	}
185		184
186	if (missile_plus > 4)	185	missile_plus = clamp (missile_plus, -4, 4);
187	missile_plus = 4;
188	else if (missile_plus < -4)
189	missile_plus = -4;
190		186
191	missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);	187	missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
192	missile->nrof -= 3 * (missile_plus + bonus_plus);	188	missile->nrof -= 3 * (missile_plus + bonus_plus);
193		189
194	if (missile->nrof < 1)	190	if (missile->nrof < 1)
…		…
206	return 1;	202	return 1;
207	}	203	}
208		204
209		205
210	/* allows the choice of what sort of food object to make.	206	/* allows the choice of what sort of food object to make.
211	* If stringarg is NULL, it will create food dependent on level --PeterM*/	207	* If spellparam is NULL, it will create food dependent on level --PeterM*/
212	int	208	int
213	cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *stringarg)	209	cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *spellparam)
214	{	210	{
215	int food_value;	211	int food_value;
216	archetype *at = NULL;	212	archetype *at = NULL;
217	object *new_op;	213	object *new_op;
218		214
219	food_value = spell_ob->stats.food + +50 * SP_level_duration_adjust (caster, spell_ob);	215	food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);
220		216
221	if (stringarg)	217	if (spellparam)
222	{	218	{
223	at = find_archetype_by_object_type_name (FOOD, stringarg);	219	at = find_archetype_by_object_type_name (FOOD, spellparam);
224	if (at == NULL)	220	if (at == NULL)
225	at = find_archetype_by_object_type_name (DRINK, stringarg);	221	at = find_archetype_by_object_type_name (DRINK, spellparam);
226	if (at == NULL || at->clone.stats.food > food_value)	222	if (at == NULL || at->stats.food > food_value)
227	stringarg = NULL;	223	spellparam = NULL;
228	}	224	}
229		225
230	if (!stringarg)	226	if (!spellparam)
231	{	227	{
232	archetype *at_tmp;	228	archetype *at_tmp;
233		229
234	/* We try to find the archetype with the maximum food value.	230	/* We try to find the archetype with the maximum food value.
235	* This removes the dependancy of hard coded food values in this	231	* This removes the dependancy of hard coded food values in this
…		…
237	* We don't use flesh types because the weight values of those need	233	* We don't use flesh types because the weight values of those need
238	* to be altered from the donor.	234	* to be altered from the donor.
239	*/	235	*/
240		236
241	/* We assume the food items don't have multiple parts */	237	/* We assume the food items don't have multiple parts */
242	for (at_tmp = first_archetype; at_tmp != NULL; at_tmp = at_tmp->next)	238	for_all_archetypes (at_tmp)
243	{	239	{
244	if (at_tmp->clone.type == FOOD || at_tmp->clone.type == DRINK)	240	if (at_tmp->type == FOOD || at_tmp->type == DRINK)
245	{	241	{
246	/* Basically, if the food value is something that is creatable	242	/* Basically, if the food value is something that is creatable
247	* under the limits of the spell and it is higher than	243	* under the limits of the spell and it is higher than
248	* the item we have now, take it instead.	244	* the item we have now, take it instead.
249	*/	245	*/
250	if (at_tmp->clone.stats.food <= food_value && (!at || at_tmp->clone.stats.food > at->clone.stats.food))	246	if (at_tmp->stats.food <= food_value
		247	&& (!at
		248	|| at_tmp->stats.food > at->stats.food
		249	|| (at_tmp->stats.food == at->stats.food
		250	&& at_tmp->weight < at->weight)))
251	at = at_tmp;	251	at = at_tmp;
252	}	252	}
253	}	253	}
254	}	254	}
		255
255	/* Pretty unlikely (there are some very low food items), but you never	256	/* Pretty unlikely (there are some very low food items), but you never
256	* know	257	* know
257	*/	258	*/
258	if (!at)	259	if (!at)
259	{	260	{
260	new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");	261	new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");
261	return 0;	262	return 0;
262	}	263	}
263		264
264	food_value /= at->clone.stats.food;	265	food_value /= at->stats.food;
265	new_op = arch_to_object (at);	266	new_op = arch_to_object (at);
266	new_op->nrof = food_value;	267	new_op->nrof = food_value;
267		268
268	new_op->value = 0;	269	new_op->value = 0;
269	if (new_op->nrof < 1)	270	if (new_op->nrof < 1)
…		…
278	{	279	{
279	int r, mflags, maxrange;	280	int r, mflags, maxrange;
280	object *tmp;	281	object *tmp;
281	maptile *m;	282	maptile *m;
282		283
283
284	if (!dir)	284	if (!dir)
285	{	285	{
286	examine_monster (op, op);	286	examine_monster (op, op);
287	return 1;	287	return 1;
288	}	288	}
		289
289	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	290	maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
290	for (r = 1; r < maxrange; r++)	291	for (r = 1; r < maxrange; r++)
291	{	292	{
292	sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];	293	sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];
293		294
…		…
300	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))	301	if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))
301	{	302	{
302	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");	303	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
303	return 0;	304	return 0;
304	}	305	}
		306
305	if (mflags & P_IS_ALIVE)	307	if (mflags & P_IS_ALIVE)
306	{	308	{
307	for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = tmp->above)	309	for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
308	if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))	310	if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))
309	{	311	{
310	new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");	312	new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
311	if (tmp->head != NULL)	313	if (tmp->head != NULL)
312	tmp = tmp->head;	314	tmp = tmp->head;
313	examine_monster (op, tmp);	315	examine_monster (op, tmp);
314	return 1;	316	return 1;
315	}	317	}
316	}	318	}
317	}	319	}
		320
318	new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");	321	new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");
319	return 1;	322	return 1;
320	}	323	}
321
322		324
323	/* This checks to see if 'pl' is invisible to 'mon'.	325	/* This checks to see if 'pl' is invisible to 'mon'.
324	* does race check, undead check, etc	326	* does race check, undead check, etc
325	* Returns TRUE if mon can't see pl, false	327	* Returns TRUE if mon can't see pl, false
326	* otherwise. This doesn't check range, walls, etc. It	328	* otherwise. This doesn't check range, walls, etc. It
…		…
328	* pl is invisible.	330	* pl is invisible.
329	*/	331	*/
330	int	332	int
331	makes_invisible_to (object *pl, object *mon)	333	makes_invisible_to (object *pl, object *mon)
332	{	334	{
333
334	if (!pl->invisible)	335	if (!pl->invisible)
335	return 0;	336	return 0;
		337
336	if (pl->type == PLAYER)	338	if (pl->type == PLAYER)
337	{	339	{
338	/* If race isn't set, then invisible unless it is undead */	340	/* If race isn't set, then invisible unless it is undead */
339	if (!pl->contr->invis_race)	341	if (!pl->contr->invis_race)
340	{	342	{
341	if (QUERY_FLAG (mon, FLAG_UNDEAD))	343	if (QUERY_FLAG (mon, FLAG_UNDEAD))
342	return 0;	344	return 0;
		345
343	return 1;	346	return 1;
344	}	347	}
		348
345	/* invis_race is set if we get here */	349	/* invis_race is set if we get here */
346	if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon))	350	if (pl->contr->invis_race == shstr_undead && is_true_undead (mon))
347	return 1;	351	return 1;
		352
348	/* No race, can't be invisible to it */	353	/* No race, can't be invisible to it */
349	if (!mon->race)	354	if (!mon->race)
350	return 0;	355	return 0;
		356
351	if (strstr (mon->race, pl->contr->invis_race))	357	if (mon->race.contains (pl->contr->invis_race))
352	return 1;	358	return 1;
		359
353	/* Nothing matched above, return 0 */	360	/* Nothing matched above, return 0 */
354	return 0;	361	return 0;
355	}	362	}
356	else	363	else
357	{	364	{
…		…
370	* normal applies.	377	* normal applies.
371	*/	378	*/
372	int	379	int
373	cast_invisible (object *op, object *caster, object *spell_ob)	380	cast_invisible (object *op, object *caster, object *spell_ob)
374	{	381	{
375	object *tmp;
376
377	if (op->invisible > 1000)	382	if (op->invisible > 1000)
378	{	383	{
379	new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");	384	new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");
380	return 0;	385	return 0;
381	}	386	}
…		…
397	else	402	else
398	op->contr->tmp_invis = 1;	403	op->contr->tmp_invis = 1;
399		404
400	op->contr->hidden = 0;	405	op->contr->hidden = 0;
401	}	406	}
		407
402	if (makes_invisible_to (op, op))	408	if (makes_invisible_to (op, op))
403	new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");	409	new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");
404	else	410	else
405	new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!");	411	new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!");
406		412
407	update_object (op, UP_OBJ_FACE);	413	update_object (op, UP_OBJ_CHANGE);
408		414
409	/* Only search the active objects - only these should actually do	415	/* Only search the active objects - only these should actually do
410	* harm to the player.	416	* harm to the player.
411	*/	417	*/
412	for (tmp = active_objects; tmp != NULL; tmp = tmp->active_next)	418	for_all_actives (tmp)
413	if (tmp->enemy == op)	419	if (tmp->enemy == op)
414	tmp->enemy = NULL;	420	tmp->enemy = 0;
		421
415	return 1;	422	return 1;
416	}	423	}
417		424
418	/* earth to dust spell. Basically destroys earthwalls in the area.	425	/* earth to dust spell. Basically destroys earthwalls in the area.
419	*/	426	*/
420	int	427	int
421	cast_earth_to_dust (object *op, object *caster, object *spell_ob)	428	cast_earth_to_dust (object *op, object *caster, object *spell_ob)
422	{	429	{
423	object *tmp, *next;
424	int range, i, j, mflags;	430	int range, i, j, mflags;
425	sint16 sx, sy;	431	sint16 sx, sy;
426	maptile *m;	432	maptile *m;
427
428	if (op->type != PLAYER)
429	return 0;
430		433
431	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);	434	range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
432		435
433	for (i = -range; i <= range; i++)	436	for (i = -range; i <= range; i++)
434	for (j = -range; j <= range; j++)	437	for (j = -range; j <= range; j++)
…		…
439	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);	442	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
440		443
441	if (mflags & P_OUT_OF_MAP)	444	if (mflags & P_OUT_OF_MAP)
442	continue;	445	continue;
443		446
444	// earth to dust tears down everything that can be teared down	447	// earth to dust tears down everything that can be torn down
445	for (tmp = get_map_ob (m, sx, sy); tmp != NULL; tmp = next)	448	for (object *next, *tmp = m->at (sx, sy).bot; tmp; tmp = next)
446	{	449	{
447	next = tmp->above;	450	next = tmp->above;
		451
448	if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))	452	if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
449	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);	453	hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
450	}	454	}
451	}	455	}
		456
452	return 1;	457	return 1;
453	}	458	}
454
455		459
456	void	460	void
457	execute_word_of_recall (object *op)	461	execute_word_of_recall (object *op)
458	{	462	{
459	object *wor = op;	463	if (object *pl = op->in_player ())
460		464	{
461	while (op != NULL && op->type != PLAYER)	465	if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
462	op = op->env;
463
464	if (op != NULL && op->map)
465	if ((get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_CLERIC) && (!QUERY_FLAG (op, FLAG_WIZCAST)))
466	new_draw_info (NDI_UNIQUE, 0, op, "You feel something fizzle inside you.");	466	new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
467	else	467	else
468	enter_exit (op, wor);	468	pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);
		469	}
469		470
470	wor->destroy ();	471	op->destroy ();
471	}	472	}
472		473
473	/* Word of recall causes the player to return 'home'.	474	/* Word of recall causes the player to return 'home'.
474	* we put a force into the player object, so that there is a	475	* we put a force into the player object, so that there is a
475	* time delay effect.	476	* time delay effect.
…		…
488	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");	489	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
489	return 1;	490	return 1;
490	}	491	}
491		492
492	dummy = get_archetype (FORCE_NAME);	493	dummy = get_archetype (FORCE_NAME);
493	if (dummy == NULL)	494
		495	if (!dummy)
494	{	496	{
495	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	497	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
496	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");	498	LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
497	return 0;	499	return 0;
498	}	500	}
		501
499	time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);	502	time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);
500	if (time < 1)	503	if (time < 1)
501	time = 1;	504	time = 1;
502		505
503	/* value of speed really doesn't make much difference, as long as it is	506	/* value of speed really doesn't make much difference, as long as it is
504	* positive. Lower value may be useful so that the problem doesn't	507	* positive. Lower value may be useful so that the problem doesn't
505	* do anything really odd if it say a -1000 or something.	508	* do anything really odd if it say a -1000 or something.
506	*/	509	*/
507	dummy->speed = 0.002;	510	dummy->set_speed (0.002);
508	update_ob_speed (dummy);
509	dummy->speed_left = -dummy->speed * time;	511	dummy->speed_left = -dummy->speed * time;
510	dummy->type = SPELL_EFFECT;	512	dummy->type = SPELL_EFFECT;
511	dummy->subtype = SP_WORD_OF_RECALL;	513	dummy->subtype = SP_WORD_OF_RECALL;
512		514
513	/* If we could take advantage of enter_player_savebed() here, it would be	515	/* If we could take advantage of enter_player_savebed() here, it would be
514	* nice, but until the map load fails, we can't.	516	* nice, but until the map load fails, we can't.
515	*/	517	*/
516	EXIT_PATH (dummy) = op->contr->savebed_map;	518	EXIT_PATH (dummy) = op->contr->savebed_map;
517	EXIT_X (dummy) = op->contr->bed_x;	519	EXIT_X (dummy) = op->contr->bed_x;
518	EXIT_Y (dummy) = op->contr->bed_y;	520	EXIT_Y (dummy) = op->contr->bed_y;
519		521
520	(void) insert_ob_in_ob (dummy, op);	522	op->insert (dummy);
		523
521	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");	524	new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
		525
522	return 1;	526	return 1;
523	}	527	}
524		528
525	/* cast_wonder	529	/* cast_wonder
526	* wonder is really just a spell that will likely cast another	530	* wonder is really just a spell that will likely cast another
…		…
556	return cast_spell (op, caster, dir, newspell, NULL);	560	return cast_spell (op, caster, dir, newspell, NULL);
557	}	561	}
558	return 1;	562	return 1;
559	}	563	}
560		564
561
562	int	565	int
563	perceive_self (object *op)	566	perceive_self (object *op)
564	{	567	{
565	char *cp = describe_item (op, op), buf[MAX_BUF];	568	const char *cp = describe_item (op, op);
566	archetype *at = archetype::find (ARCH_DEPLETION);	569	archetype *at = archetype::find (ARCH_DEPLETION);
567	object *tmp;
568	int i;
569		570
		571	dynbuf_text &buf = msg_dynbuf; buf.clear ();
		572
		573	if (!op->is_player ())
		574	return 0;
		575
		576	if (object *race = archetype::find (op->race))
		577	buf << " - You are a G<male|female> " << &race->name << ".\n";
		578
570	tmp = find_god (determine_god (op));	579	if (object *god = find_god (determine_god (op)))
571	if (tmp)	580	buf << " - You worship " << &god->name << ".\n";
572	new_draw_info_format (NDI_UNIQUE, 0, op, "You worship %s", &tmp->name);
573	else	581	else
574	new_draw_info (NDI_UNIQUE, 0, op, "You worship no god");	582	buf << " - You worship no god.\n";
575		583
576	tmp = present_arch_in_ob (at, op);	584	object *tmp = present_arch_in_ob (at, op);
577		585
578	if (*cp == '\0' && tmp == NULL)	586	if (*cp == '\0' && !tmp)
579	new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane");	587	buf << " - You feel very mundane. ";
580	else	588	else
581	{	589	{
582	new_draw_info (NDI_UNIQUE, 0, op, "You have:");	590	buf << " - You have: " << cp << ".\n";
583	new_draw_info (NDI_UNIQUE, 0, op, cp);	591
584	if (tmp != NULL)	592	if (tmp)
585	{
586	for (i = 0; i < NUM_STATS; i++)	593	for (int i = 0; i < NUM_STATS; i++)
587	{	594	if (tmp->stats.stat (i) < 0)
588	if (get_attr_value (&tmp->stats, i) < 0)	595	buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
589	{
590	new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is depleted by %d", statname[i], -(get_attr_value (&tmp->stats, i)));
591	}
592	}
593	}
594	}	596	}
595		597
596	if (is_dragon_pl (op))	598	if (is_dragon_pl (op))
597	{
598	/* now grab the 'dragon_ability'-force from the player's inventory */	599	/* now grab the 'dragon_ability'-force from the player's inventory */
599	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)	600	for (tmp = op->inv; tmp; tmp = tmp->below)
600	{	601	{
601	if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force"))	602	if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
602	{	603	{
603	if (tmp->stats.exp == 0)	604	if (tmp->stats.exp == 0)
604	{
605	sprintf (buf, "Your metabolism isn't focused on anything.");	605	buf << " - Your metabolism isn't focused on anything.\n";
606	}
607	else	606	else
608	{
609	sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]);	607	buf << " - Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
610	}	608
611	new_draw_info (NDI_UNIQUE, 0, op, buf);
612	break;	609	break;
613	}	610	}
614	}	611	}
615	}	612
		613	op->contr->infobox (MSG_CHANNEL ("perceiveself"), buf);
		614
616	return 1;	615	return 1;
617	}	616	}
618
619	/* int cast_create_town_portal (object *op, object *caster, int dir)
620	*
621	* This function cast the spell of town portal for op
622	*
623	* The spell operates in two passes. During the first one a place
624	* is marked as a destination for the portal. During the second one,
625	* 2 portals are created, one in the position the player cast it and
626	* one in the destination place. The portal are synchronized and 2 forces
627	* are inserted in the player to destruct the portal next time player
628	* creates a new portal pair.
629	* This spell has a side effect that it allows people to meet each other
630	* in a permanent, private, appartements by making a town portal from it
631	* to the town or another public place. So, check if the map is unique and if
632	* so return an error
633	*
634	* Code by Tchize (david.delbecq@usa.net)
635	*/
636	int
637	cast_create_town_portal (object *op, object *caster, object *spell, int dir)
638	{
639	object *dummy, *force, *old_force, *tmp;
640	archetype *perm_portal;
641	char portal_name[1024], portal_message[1024];
642	sint16 exitx, exity;
643	maptile *exitmap;
644	int op_level;
645
646
647	/* Check to see if the map the player is currently on is a per player unique
648	* map. This can be determined in that per player unique maps have the
649	* full pathname listed.
650	*/
651	if (!strncmp (op->map->path, settings.localdir, strlen (settings.localdir)) && settings.create_home_portals != TRUE)
652	{
653	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You can't cast that here.\n");
654	return 0;
655	}
656
657	/* The first thing to do is to check if we have a marked destination
658	* dummy is used to make a check inventory for the force
659	*/
660	dummy = arch_to_object (spell->other_arch);
661	if (dummy == NULL)
662	{
663	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
664	LOG (llevError, "object::create failed (force in cast_create_town_portal for %s!\n", &op->name);
665	return 0;
666	}
667
668	force = check_inv_recursive (op, dummy);
669
670	if (force == NULL)
671	{
672	/* Here we know there is no destination marked up.
673	* We have 2 things to do:
674	* 1. Mark the destination in the player inventory.
675	* 2. Let the player know it worked.
676	*/
677	dummy->name = op->map->path;
678	EXIT_X (dummy) = op->x;
679	EXIT_Y (dummy) = op->y;
680	insert_ob_in_ob (dummy, op);
681	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.");
682	return 1;
683	}
684
685	dummy->destroy ();
686
687	/* Here we know where the town portal should go to
688	* We should kill any existing portal associated with the player.
689	* Than we should create the 2 portals.
690	* For each of them, we need:
691	* - To create the portal with the name of the player+destination map
692	* - set the owner of the town portal
693	* - To mark the position of the portal in the player's inventory
694	* for easier destruction.
695	*
696	* The mark works has follow:
697	* slaying: Existing town portal
698	* hp, sp : x & y of the associated portal
699	* name : name of the portal
700	* race : map the portal is in
701	*/
702
703	/* First step: killing existing town portals */
704	dummy = get_archetype (spell->race);
705	if (dummy == NULL)
706	{
707	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
708	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
709	return 0;
710	}
711
712	perm_portal = archetype::find (spell->slaying);
713
714	/* To kill a town portal, we go trough the player's inventory,
715	* for each marked portal in player's inventory,
716	* -We try load the associated map (if impossible, consider the portal destructed)
717	* -We find any portal in the specified location.
718	* If it has the good name, we destruct it.
719	* -We destruct the force indicating that portal.
720	*/
721	while ((old_force = check_inv_recursive (op, dummy)))
722	{
723	exitx = EXIT_X (old_force);
724	exity = EXIT_Y (old_force);
725	LOG (llevDebug, "Trying to kill a portal in %s (%d,%d)\n", &old_force->race, exitx, exity);
726
727	if (!strncmp (old_force->race, settings.localdir, strlen (settings.localdir)))
728	exitmap = ready_map_name (old_force->race, MAP_PLAYER_UNIQUE);
729	else
730	exitmap = ready_map_name (old_force->race, 0);
731
732	if (exitmap)
733	{
734	tmp = present_arch (perm_portal, exitmap, exitx, exity);
735	while (tmp)
736	{
737	if (tmp->name == old_force->name)
738	{
739	tmp->destroy ();
740	break;
741	}
742
743	tmp = tmp->above;
744	}
745	}
746
747	old_force->destroy ();
748	LOG (llevDebug, "\n");
749	}
750
751	dummy->destroy ();
752
753	/* Creating the portals.
754	* The very first thing to do is to ensure
755	* access to the destination map.
756	* If we can't, don't fizzle. Simply warn player.
757	* This ensure player pays his mana for the spell
758	* because HE is responsible of forgotting.
759	* 'force' is the destination of the town portal, which we got
760	* from the players inventory above.
761	*/
762
763	/* Ensure exit map is loaded */
764	if (!strncmp (force->name, settings.localdir, strlen (settings.localdir)))
765	exitmap = ready_map_name (force->name, MAP_PLAYER_UNIQUE);
766	else
767	exitmap = ready_map_name (force->name, 0);
768
769	/* If we were unable to load (ex. random map deleted), warn player */
770	if (exitmap == NULL)
771	{
772	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens.\nYou can't remember where to go!?");
773	force->destroy ();
774	return 1;
775	}
776
777	op_level = caster_level (caster, spell);
778	if (op_level < 15)
779	snprintf (portal_message, 1024,
780	"\nThe air moves around you and\na huge smell of ammonia\nsurounds you as you pass\nthrough %s's tiny portal\nPouah!\n",
781	&op->name);
782	else if (op_level < 30)
783	snprintf (portal_message, 1024,
784	"\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);
785	else if (op_level < 60)
786	snprintf (portal_message, 1024, "\nA shining door opens in the air in front of you,\nshowing you the path to another place.\n");
787	else
788	snprintf (portal_message, 1024, "\nAs you walk through %s's portal, flowers come out\nfrom the ground around you.\nYou feel awed.\n",
789	&op->name);
790
791	/* Create a portal in front of player
792	* dummy contain the portal and
793	* force contain the track to kill it later
794	*/
795
796	snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name);
797	dummy = get_archetype (spell->slaying); /*The portal */
798	if (dummy == NULL)
799	{
800	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
801	LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
802	return 0;
803	}
804
805	EXIT_PATH (dummy) = force->name;
806	EXIT_X (dummy) = EXIT_X (force);
807	EXIT_Y (dummy) = EXIT_Y (force);
808	dummy->name = dummy->name_pl = portal_name;
809	dummy->msg = portal_message;
810	dummy->race = op->name; /*Save the owner of the portal */
811	cast_create_obj (op, caster, dummy, 0);
812
813	/* Now we need to to create a town portal marker inside the player
814	* object, so on future castings, we can know that he has an active
815	* town portal.
816	*/
817	tmp = get_archetype (spell->race);
818	if (tmp == NULL)
819	{
820	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
821	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
822	return 0;
823	}
824
825	tmp->race = op->map->path;
826	tmp->name = portal_name;
827	EXIT_X (tmp) = dummy->x;
828	EXIT_Y (tmp) = dummy->y;
829	insert_ob_in_ob (tmp, op);
830
831	/* Create a portal in the destination map
832	* dummy contain the portal and
833	* force the track to kill it later
834	* the 'force' variable still contains the 'reminder' of
835	* where this portal goes to.
836	*/
837	snprintf (portal_name, 1024, "%s's portal to %s", &op->name, op->map->path);
838	dummy = get_archetype (spell->slaying); /*The portal */
839	if (dummy == NULL)
840	{
841	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
842	LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
843	return 0;
844	}
845
846	EXIT_PATH (dummy) = op->map->path;
847	EXIT_X (dummy) = op->x;
848	EXIT_Y (dummy) = op->y;
849	dummy->name = dummy->name_pl = portal_name;
850	dummy->msg = portal_message;
851	dummy->x = EXIT_X (force);
852	dummy->y = EXIT_Y (force);
853	dummy->race = op->name; /*Save the owner of the portal */
854	insert_ob_in_map (dummy, exitmap, op, 0);
855
856	/* Now we create another town portal marker that
857	* points back to the one we just made
858	*/
859	tmp = get_archetype (spell->race);
860	if (tmp == NULL)
861	{
862	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
863	LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
864	return 0;
865	}
866
867	tmp->race = force->name;
868	tmp->name = portal_name;
869	EXIT_X (tmp) = dummy->x;
870	EXIT_Y (tmp) = dummy->y;
871	insert_ob_in_ob (tmp, op);
872
873	/* Describe the player what happened
874	*/
875	new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You see air moving and showing you the way home.");
876	force->destroy ();
877
878	return 1;
879	}
880
881		617
882	/* This creates magic walls. Really, it can create most any object,	618	/* This creates magic walls. Really, it can create most any object,
883	* within some reason.	619	* within some reason.
884	*/	620	*/
885
886	int	621	int
887	magic_wall (object *op, object *caster, int dir, object *spell_ob)	622	magic_wall (object *op, object *caster, int dir, object *spell_ob)
888	{	623	{
889	object *tmp, *tmp2;	624	object *tmp;
890	int i, posblocked, negblocked, maxrange;	625	int i, posblocked, negblocked, maxrange;
891	sint16 x, y;	626	sint16 x, y;
892	maptile *m;	627	maptile *m;
893	const char *name;	628	const char *name;
894	archetype *at;	629	archetype *at;
…		…
902	else	637	else
903	{	638	{
904	x = op->x + freearr_x[dir];	639	x = op->x + freearr_x[dir];
905	y = op->y + freearr_y[dir];	640	y = op->y + freearr_y[dir];
906	}	641	}
		642
907	m = op->map;	643	m = op->map;
908		644
909	if ((spell_ob->move_block || x != op->x || y != op->y) &&	645	if ((spell_ob->move_block || x != op->x || y != op->y) &&
910	(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) ||	646	(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) ||
911	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))	647	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))
912	{	648	{
913	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");	649	new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
914	return 0;	650	return 0;
915	}	651	}
		652
916	if (spell_ob->other_arch)	653	if (spell_ob->other_arch)
917	{
918	tmp = arch_to_object (spell_ob->other_arch);	654	tmp = arch_to_object (spell_ob->other_arch);
919	}
920	else if (spell_ob->race)	655	else if (spell_ob->race)
921	{	656	{
922	char buf1[MAX_BUF];	657	char buf1[MAX_BUF];
923		658
924	sprintf (buf1, spell_ob->race, dir);	659	sprintf (buf1, spell_ob->race, dir);
…		…
927	{	662	{
928	LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);	663	LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
929	new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");	664	new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
930	return 0;	665	return 0;
931	}	666	}
		667
932	tmp = arch_to_object (at);	668	tmp = arch_to_object (at);
933	}	669	}
934	else	670	else
935	{	671	{
936	LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);	672	LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
…		…
946	}	682	}
947	else if (QUERY_FLAG (tmp, FLAG_ALIVE))	683	else if (QUERY_FLAG (tmp, FLAG_ALIVE))
948	{	684	{
949	tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	685	tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
950	tmp->stats.maxhp = tmp->stats.hp;	686	tmp->stats.maxhp = tmp->stats.hp;
951	tmp->set_owner (op);
952	set_spell_skill (op, caster, spell_ob, tmp);
953	}	687	}
		688
954	if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP))	689	if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP))
955	{	690	{
956	tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);	691	tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
957	SET_FLAG (tmp, FLAG_IS_USED_UP);	692	SET_FLAG (tmp, FLAG_IS_USED_UP);
958	}	693	}
		694
959	if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN))	695	if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN))
960	{	696	{
961	tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);	697	tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
962	tmp->stats.maxhp = tmp->stats.hp;	698	tmp->stats.maxhp = tmp->stats.hp;
963	SET_FLAG (tmp, FLAG_TEAR_DOWN);	699	SET_FLAG (tmp, FLAG_TEAR_DOWN);
964	SET_FLAG (tmp, FLAG_ALIVE);	700	SET_FLAG (tmp, FLAG_ALIVE);
965	}	701	}
966		702
967	/* This can't really hurt - if the object doesn't kill anything,	703	/* This can't really hurt - if the object doesn't kill anything,
968	* these fields just won't be used.	704	* these fields just won't be used. Do not set the owner for
		705	* earthwalls, though, so they survive restarts.
969	*/	706	*/
		707	if (tmp->type != EARTHWALL) //TODO
970	tmp->set_owner (op);	708	tmp->set_owner (op);
		709
971	set_spell_skill (op, caster, spell_ob, tmp);	710	set_spell_skill (op, caster, spell_ob, tmp);
972	tmp->x = x;
973	tmp->y = y;
974	tmp->level = caster_level (caster, spell_ob) / 2;	711	tmp->level = casting_level (caster, spell_ob) / 2;
975		712
976	name = tmp->name;	713	name = tmp->name;
977	if ((tmp = insert_ob_in_map (tmp, m, op, 0)) == NULL)	714	if (!(tmp = m->insert (tmp, x, y, op)))
978	{	715	{
979	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);	716	new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
980	return 0;	717	return 0;
981	}	718	}
		719
982	/* If this is a spellcasting wall, need to insert the spell object */	720	/* If this is a spellcasting wall, need to insert the spell object */
983	if (tmp->other_arch && tmp->other_arch->clone.type == SPELL)	721	if (tmp->other_arch && tmp->other_arch->type == SPELL)
984	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);	722	insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
985		723
986	/* This code causes the wall to extend some distance in	724	/* This code causes the wall to extend some distance in
987	* each direction, or until an obstruction is encountered.	725	* each direction, or until an obstruction is encountered.
988	* posblocked and negblocked help determine how far the	726	* posblocked and negblocked help determine how far the
…		…
1004	m = tmp->map;	742	m = tmp->map;
1005		743
1006	if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&	744	if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
1007	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)	745	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)
1008	{	746	{
1009	tmp2 = tmp->clone ();	747	object *tmp2 = tmp->clone ();
1010	tmp2->x = x;	748	m->insert (tmp2, x, y, op);
1011	tmp2->y = y;	749
1012	insert_ob_in_map (tmp2, m, op, 0);
1013	/* If this is a spellcasting wall, need to insert the spell object */	750	/* If this is a spellcasting wall, need to insert the spell object */
1014	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	751	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1015	insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2);	752	tmp2->insert (arch_to_object (tmp2->other_arch));
1016		753
1017	}	754	}
1018	else	755	else
1019	posblocked = 1;	756	posblocked = 1;
1020		757
…		…
1023	m = tmp->map;	760	m = tmp->map;
1024		761
1025	if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&	762	if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
1026	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)	763	((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
1027	{	764	{
1028	tmp2 = tmp->clone ();	765	object *tmp2 = tmp->clone ();
1029	tmp2->x = x;	766	m->insert (tmp2, x, y, op);
1030	tmp2->y = y;	767
1031	insert_ob_in_map (tmp2, m, op, 0);
1032	if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)	768	if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1033	insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2);	769	tmp2->insert (arch_to_object (tmp2->other_arch));
1034	}	770	}
1035	else	771	else
1036	negblocked = 1;	772	negblocked = 1;
1037	}	773	}
1038		774
…		…
1041		777
1042	return 1;	778	return 1;
1043	}	779	}
1044		780
1045	int	781	int
1046	dimension_door (object *op, object *caster, object *spob, int dir)	782	dimension_door (object *op, object *caster, object *spob, int dir, const char *spellparam)
1047	{	783	{
1048	uint32 dist, maxdist;	784	uint32 dist, maxdist;
1049	int mflags;	785	int mflags;
1050	maptile *m;	786	maptile *m;
1051	sint16 sx, sy;	787	sint16 sx, sy;
…		…
1062	/* Given the new outdoor maps, can't let players dimension door for	798	/* Given the new outdoor maps, can't let players dimension door for
1063	* ever, so put limits in.	799	* ever, so put limits in.
1064	*/	800	*/
1065	maxdist = spob->range + SP_level_range_adjust (caster, spob);	801	maxdist = spob->range + SP_level_range_adjust (caster, spob);
1066		802
1067	if (op->contr->count)	803	if (spellparam)
1068	{	804	{
		805	int count = atoi (spellparam);
		806
1069	if (op->contr->count > maxdist)	807	if (count > maxdist)
1070	{	808	{
1071	new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!");	809	new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!");
1072	return 0;	810	return 0;
1073	}	811	}
1074		812
1075	for (dist = 0; dist < op->contr->count; dist++)	813	for (dist = 0; dist < count; dist++)
1076	{	814	{
1077	mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);	815	mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);
1078		816
1079	if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))	817	if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
1080	break;	818	break;
1081		819
1082	if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))	820	if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
1083	break;	821	break;
1084	}	822	}
1085		823
1086	if (dist < op->contr->count)	824	if (dist < count)
1087	{	825	{
1088	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");	826	new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
1089	op->contr->count = 0;
1090	return 0;	827	return 0;
1091	}	828	}
1092	op->contr->count = 0;
1093		829
1094	/* Remove code that puts player on random space on maps. IMO,	830	/* Remove code that puts player on random space on maps. IMO,
1095	* a lot of maps probably have areas the player should not get to,	831	* a lot of maps probably have areas the player should not get to,
1096	* but may not be marked as NO_MAGIC (as they may be bounded	832	* but may not be marked as NO_MAGIC (as they may be bounded
1097	* by such squares). Also, there are probably treasure rooms and	833	* by such squares). Also, there are probably treasure rooms and
…		…
1145	return 0;	881	return 0;
1146	}	882	}
1147	}	883	}
1148		884
1149	/* Actually move the player now */	885	/* Actually move the player now */
1150	op->remove ();	886	if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
1151	op->x += freearr_x[dir] * dist;
1152	op->y += freearr_y[dir] * dist;
1153	if ((op = insert_ob_in_map (op, op->map, op, 0)) == NULL)
1154	return 1;	887	return 1;
1155		888
1156	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */	889	op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
1157	return 1;	890	return 1;
1158	}	891	}
1159
1160		892
1161	/* cast_heal: Heals something.	893	/* cast_heal: Heals something.
1162	* op is the caster.	894	* op is the caster.
1163	* dir is the direction he is casting it in.	895	* dir is the direction he is casting it in.
1164	* spell is the spell object.	896	* spell is the spell object.
…		…
1171	object *poison;	903	object *poison;
1172	int heal = 0, success = 0;	904	int heal = 0, success = 0;
1173		905
1174	tmp = find_target_for_friendly_spell (op, dir);	906	tmp = find_target_for_friendly_spell (op, dir);
1175		907
1176	if (tmp == NULL)	908	if (!tmp)
1177	return 0;	909	return 0;
1178		910
1179	/* Figure out how many hp this spell might cure.	911	/* Figure out how many hp this spell might cure.
1180	* could be zero if this spell heals effects, not damage.	912	* could be zero if this spell heals effects, not damage.
1181	*/	913	*/
…		…
1184	heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp;	916	heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp;
1185		917
1186	if (heal)	918	if (heal)
1187	{	919	{
1188	if (tmp->stats.hp >= tmp->stats.maxhp)	920	if (tmp->stats.hp >= tmp->stats.maxhp)
1189	{
1190	new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed.");	921	new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed.");
1191	}
1192	else	922	else
1193	{	923	{
1194	/* See how many points we actually heal. Instead of messages	924	/* See how many points we actually heal. Instead of messages
1195	* based on type of spell, we instead do messages based	925	* based on type of spell, we instead do messages based
1196	* on amount of damage healed.	926	* on amount of damage healed.
1197	*/	927	*/
1198	if (heal > (tmp->stats.maxhp - tmp->stats.hp))	928	if (heal > tmp->stats.maxhp - tmp->stats.hp)
1199	heal = tmp->stats.maxhp - tmp->stats.hp;	929	heal = tmp->stats.maxhp - tmp->stats.hp;
		930
1200	tmp->stats.hp += heal;	931	tmp->stats.hp += heal;
1201		932
1202	if (tmp->stats.hp >= tmp->stats.maxhp)	933	if (tmp->stats.hp >= tmp->stats.maxhp)
1203	{
1204	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");	934	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
1205	}
1206	else if (heal > 50)	935	else if (heal > 50)
1207	{
1208	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");	936	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");
1209	}
1210	else if (heal > 25)	937	else if (heal > 25)
1211	{
1212	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");	938	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");
1213	}
1214	else if (heal > 10)	939	else if (heal > 10)
1215	{
1216	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade.");	940	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade.");
1217	}
1218	else	941	else
1219	{
1220	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close.");	942	new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close.");
1221	}	943
1222	success = 1;	944	success = 1;
1223	}	945	}
1224	}	946	}
		947
1225	if (spell->attacktype & AT_DISEASE)	948	if (spell->attacktype & AT_DISEASE)
1226	if (cure_disease (tmp, op))	949	if (cure_disease (tmp, op, spell))
1227	success = 1;	950	success = 1;
1228		951
1229	if (spell->attacktype & AT_POISON)	952	if (spell->attacktype & AT_POISON)
1230	{	953	{
1231	at = archetype::find ("poisoning");	954	at = archetype::find ("poisoning");
…		…
1235	success = 1;	958	success = 1;
1236	new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");	959	new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
1237	poison->stats.food = 1;	960	poison->stats.food = 1;
1238	}	961	}
1239	}	962	}
		963
1240	if (spell->attacktype & AT_CONFUSION)	964	if (spell->attacktype & AT_CONFUSION)
1241	{	965	{
1242	poison = present_in_ob_by_name (FORCE, "confusion", tmp);	966	poison = present_in_ob_by_name (FORCE, "confusion", tmp);
1243	if (poison)	967	if (poison)
1244	{	968	{
1245	success = 1;	969	success = 1;
1246	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");	970	new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
1247	poison->duration = 1;	971	poison->duration = 1;
1248	}	972	}
1249	}	973	}
		974
1250	if (spell->attacktype & AT_BLIND)	975	if (spell->attacktype & AT_BLIND)
1251	{	976	{
1252	at = archetype::find ("blindness");	977	at = archetype::find ("blindness");
1253	poison = present_arch_in_ob (at, tmp);	978	poison = present_arch_in_ob (at, tmp);
1254	if (poison)	979	if (poison)
…		…
1256	success = 1;	981	success = 1;
1257	new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");	982	new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
1258	poison->stats.food = 1;	983	poison->stats.food = 1;
1259	}	984	}
1260	}	985	}
		986
1261	if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)	987	if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)
1262	{	988	{
1263	tmp->stats.sp += spell->last_sp;	989	tmp->stats.sp += spell->last_sp;
1264	if (tmp->stats.sp > tmp->stats.maxsp)	990	if (tmp->stats.sp > tmp->stats.maxsp)
1265	tmp->stats.sp = tmp->stats.maxsp;	991	tmp->stats.sp = tmp->stats.maxsp;
1266	success = 1;	992	success = 1;
1267	new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!");	993	new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!");
1268	}	994	}
		995
1269	if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)	996	if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)
1270	{	997	{
1271	tmp->stats.grace += spell->last_grace;	998	tmp->stats.grace += spell->last_grace;
1272	if (tmp->stats.grace > tmp->stats.maxgrace)	999	if (tmp->stats.grace > tmp->stats.maxgrace)
1273	tmp->stats.grace = tmp->stats.maxgrace;	1000	tmp->stats.grace = tmp->stats.maxgrace;
1274	success = 1;	1001	success = 1;
1275	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");	1002	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1276	}	1003	}
		1004
1277	if (spell->stats.food && tmp->stats.food < 999)	1005	if (spell->stats.food && tmp->stats.food < 999)
1278	{	1006	{
1279	tmp->stats.food += spell->stats.food;	1007	tmp->stats.food += spell->stats.food;
		1008
1280	if (tmp->stats.food > 999)	1009	if (tmp->stats.food > 999)
1281	tmp->stats.food = 999;	1010	tmp->stats.food = 999;
		1011
1282	success = 1;	1012	success = 1;
1283	/* We could do something a bit better like the messages for healing above */	1013	/* We could do something a bit better like the messages for healing above */
1284	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");	1014	new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1285	}	1015	}
		1016
1286	return success;	1017	return success;
1287	}	1018	}
1288
1289		1019
1290	/* This is used for the spells that gain stats. There are no spells	1020	/* This is used for the spells that gain stats. There are no spells
1291	* right now that icnrease wis/int/pow on a temp basis, so no	1021	* right now that icnrease wis/int/pow on a temp basis, so no
1292	* good comments for those.	1022	* good comments for those.
1293	*/	1023	*/
1294	static const char *const no_gain_msgs[NUM_STATS] = {	1024	static const char *const no_gain_msgs[NUM_STATS] = {
1295	"You grow no stronger.",	1025	"You grow no stronger.",
1296	"You grow no more agile.",	1026	"You grow no more agile.",
1297	"You don't feel any healthier.",	1027	"You don't feel any healthier.",
1298	"no wis",	1028	"You didn't grow any more intelligent.",
		1029	"You do not feel any wiser.",
		1030	"You don't feel any more powerful."
1299	"You are no easier to look at.",	1031	"You are no easier to look at.",
1300	"no int",
1301	"no pow"
1302	};	1032	};
1303		1033
1304	int	1034	int
		1035	change_ability_duration (object *spell, object *caster)
		1036	{
		1037	return spell->duration + SP_level_duration_adjust (caster, spell) * 50;
		1038	}
		1039
		1040	int
1305	cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)	1041	cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1306	{	1042	{
1307	object *tmp, *tmp2 = NULL;
1308	object *force = NULL;	1043	object *force = 0;
1309	int i;	1044	int i;
1310		1045
1311	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */	1046	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1312	if (dir != 0)	1047	object *tmp = dir
1313	{
1314	tmp = find_target_for_friendly_spell (op, dir);	1048	? find_target_for_friendly_spell (op, dir)
1315	}	1049	: op;
1316	else
1317	{
1318	tmp = op;
1319	}
1320		1050
1321	if (tmp == NULL)	1051	if (!tmp)
1322	return 0;	1052	return 0;
1323		1053
1324	/* If we've already got a force of this type, don't add a new one. */	1054	/* If we've already got a force of this type, don't add a new one. */
1325	for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below)	1055	for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1326	{	1056	{
1327	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)	1057	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1328	{	1058	{
1329	if (tmp2->name == spell_ob->name)	1059	if (tmp2->name == spell_ob->name)
1330	{	1060	{
…		…
1333	}	1063	}
1334	else if (spell_ob->race && spell_ob->race == tmp2->name)	1064	else if (spell_ob->race && spell_ob->race == tmp2->name)
1335	{	1065	{
1336	if (!silent)	1066	if (!silent)
1337	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);	1067	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
1338	return 0;	1069	return 0;
1339	}	1070	}
1340	}	1071	}
1341	}	1072	}
1342	if (force == NULL)	1073
		1074	if (!force)
1343	{	1075	{
1344	force = get_archetype (FORCE_NAME);	1076	force = get_archetype (FORCE_NAME);
1345	force->subtype = FORCE_CHANGE_ABILITY;	1077	force->subtype = FORCE_CHANGE_ABILITY;
		1078
1346	if (spell_ob->race)	1079	if (spell_ob->race)
1347	force->name = spell_ob->race;	1080	force->name = spell_ob->race;
1348	else	1081	else
1349	force->name = spell_ob->name;	1082	force->name = spell_ob->name;
		1083
1350	force->name_pl = spell_ob->name;	1084	force->name_pl = spell_ob->name;
1351	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");	1085	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
1352		1086
1353	}	1087	}
1354	else	1088	else
1355	{	1089	{
1356	int duration;	1090	int duration = change_ability_duration (spell_ob, caster);
1357		1091
1358	duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1359	if (duration > force->duration)	1092	if (duration > force->duration)
1360	{	1093	{
1361	force->duration = duration;	1094	force->duration = duration;
1362	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	1095	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1363	}	1096	}
1364	else	1097	else
1365	{
1366	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");	1098	new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1367	}	1099
1368	return 1;	1100	return 1;
1369	}	1101	}
		1102
1370	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;	1103	force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1371	force->speed = 1.0;	1104	force->speed = 1.0;
1372	force->speed_left = -1.0;	1105	force->speed_left = -1.0;
1373	SET_FLAG (force, FLAG_APPLIED);	1106	SET_FLAG (force, FLAG_APPLIED);
1374		1107
…		…
1380	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);	1113	force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);
1381	if (force->resist[i] > 100)	1114	if (force->resist[i] > 100)
1382	force->resist[i] = 100;	1115	force->resist[i] = 100;
1383	}	1116	}
1384	}	1117	}
		1118
1385	if (spell_ob->stats.hp)	1119	if (spell_ob->stats.hp)
1386	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);	1120	force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
1387		1121
1388	if (tmp->type == PLAYER)	1122	if (tmp->type == PLAYER)
1389	{	1123	{
1390	/* Stat adjustment spells */	1124	/* Stat adjustment spells */
1391	for (i = 0; i < NUM_STATS; i++)	1125	for (i = 0; i < NUM_STATS; i++)
1392	{	1126	{
1393	sint8 stat = get_attr_value (&spell_ob->stats, i), k, sm;	1127	if (sint8 stat = spell_ob->stats.stat (i))
1394
1395	if (stat)
1396	{	1128	{
1397	sm = 0;	1129	sint8 sm = 0;
1398	for (k = 0; k < stat; k++)	1130	for (sint8 k = 0; k < stat; k++)
1399	sm += rndm (1, 3);	1131	sm += rndm (1, 3);
1400		1132
1401	if ((get_attr_value (&tmp->stats, i) + sm) > (15 + 5 * stat))	1133	if (tmp->stats.stat (i) + sm > 15 + 5 * stat)
1402	{	1134	sm = max (0, (15 + 5 * stat) - tmp->stats.stat (i));
1403	sm = (15 + 5 * stat) - get_attr_value (&tmp->stats, i);	1135
1404	if (sm < 0)	1136	force->stats.stat (i) = sm;
1405	sm = 0;	1137
1406	}
1407	set_attr_value (&force->stats, i, sm);
1408	if (!sm)	1138	if (!sm)
1409	new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);	1139	new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);
1410	}	1140	}
1411	}	1141	}
1412	}	1142	}
…		…
1432	force->stats.ac = spell_ob->stats.ac;	1162	force->stats.ac = spell_ob->stats.ac;
1433	force->attacktype = spell_ob->attacktype;	1163	force->attacktype = spell_ob->attacktype;
1434		1164
1435	insert_ob_in_ob (force, tmp);	1165	insert_ob_in_ob (force, tmp);
1436	change_abil (tmp, force); /* Mostly to display any messages */	1166	change_abil (tmp, force); /* Mostly to display any messages */
1437	fix_player (tmp);	1167	tmp->update_stats ();
		1168
1438	return 1;	1169	return 1;
1439	}	1170	}
1440		1171
1441	/* This used to be part of cast_change_ability, but it really didn't make	1172	/* This used to be part of cast_change_ability, but it really didn't make
1442	* a lot of sense, since most of the values it derives are from the god	1173	* a lot of sense, since most of the values it derives are from the god
1443	* of the caster.	1174	* of the caster.
1444	*/	1175	*/
1445
1446	int	1176	int
1447	cast_bless (object *op, object *caster, object *spell_ob, int dir)	1177	cast_bless (object *op, object *caster, object *spell_ob, int dir)
1448	{	1178	{
1449	int i;	1179	int i;
1450	object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;	1180	object *god = find_god (determine_god (op)), *force = NULL, *tmp;
1451		1181
1452	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */	1182	/* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1453	if (dir != 0)	1183	if (dir != 0)
1454	{	1184	{
1455	tmp = find_target_for_friendly_spell (op, dir);	1185	tmp = find_target_for_friendly_spell (op, dir);
		1186
		1187	if (!tmp)
		1188	return 0;
1456	}	1189	}
1457	else	1190	else
1458	{
1459	tmp = op;	1191	tmp = op;
1460	}
1461		1192
1462	/* If we've already got a force of this type, don't add a new one. */	1193	/* If we've already got a force of this type, don't add a new one. */
1463	for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below)	1194	for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1464	{	1195	{
1465	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)	1196	if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1466	{	1197	{
1467	if (tmp2->name == spell_ob->name)	1198	if (tmp2->name == spell_ob->name)
1468	{	1199	{
…		…
1474	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);	1205	new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
1475	return 0;	1206	return 0;
1476	}	1207	}
1477	}	1208	}
1478	}	1209	}
		1210
1479	if (force == NULL)	1211	if (force == NULL)
1480	{	1212	{
1481	force = get_archetype (FORCE_NAME);	1213	force = get_archetype (FORCE_NAME);
1482	force->subtype = FORCE_CHANGE_ABILITY;	1214	force->subtype = FORCE_CHANGE_ABILITY;
1483	if (spell_ob->race)	1215	if (spell_ob->race)
…		…
1541	force->stats.wc = spell_ob->stats.wc;	1273	force->stats.wc = spell_ob->stats.wc;
1542	force->stats.ac = spell_ob->stats.ac;	1274	force->stats.ac = spell_ob->stats.ac;
1543		1275
1544	change_abil (tmp, force); /* Mostly to display any messages */	1276	change_abil (tmp, force); /* Mostly to display any messages */
1545	insert_ob_in_ob (force, tmp);	1277	insert_ob_in_ob (force, tmp);
1546	fix_player (tmp);	1278	tmp->update_stats ();
1547	return 1;	1279	return 1;
1548	}	1280	}
1549
1550
1551		1281
1552	/* Alchemy code by Mark Wedel	1282	/* Alchemy code by Mark Wedel
1553	*	1283	*
1554	* This code adds a new spell, called alchemy. Alchemy will turn	1284	* This code adds a new spell, called alchemy. Alchemy will turn
1555	* objects to gold nuggets, the value of the gold nuggets being	1285	* objects to pyrite ("false gold"), henceforth called gold nuggets.
1556	* about 90% of that of the item itself. It uses the value of the
1557	* object before charisma adjustments, because the nuggets themselves
1558	* will be will be adjusted by charisma when sold.
1559	*	1286	*
1560	* Large nuggets are worth 25 gp each (base). You will always get	1287	* The value of the gold nuggets being about 90% of that of the item
1561	* the maximum number of large nuggets you could get.	1288	* itself. It uses the value of the object before charisma adjustments,
1562	* Small nuggets are worth 1 gp each (base). You will get from 0	1289	* because the nuggets themselves will be will be adjusted by charisma
1563	* to the max amount of small nuggets as you could get.	1290	* when sold.
1564	*
1565	* For example, if an item is worth 110 gold, you will get
1566	* 4 large nuggets, and from 0-10 small nuggets.
1567	*	1291	*
1568	* There is also a chance (1:30) that you will get nothing at all	1292	* There is also a chance (1:30) that you will get nothing at all
1569	* for the object. There is also a maximum weight that will be	1293	* for the object. There is also a maximum weight that will be
1570	* alchemied.	1294	* alchemised.
1571	*/	1295	*/
1572
1573	/* I didn't feel like passing these as arguements to the
1574	* two functions that need them. Real values are put in them
1575	* when the spell is cast, and these are freed when the spell
1576	* is finished.
1577	*/
1578	static object *small, *large;
1579
1580	static void	1296	static void
1581	alchemy_object (object *obj, int *small_nuggets, int *large_nuggets, int *weight)	1297	alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1582	{	1298	{
1583	uint64 value = query_cost (obj, NULL, F_TRUE);	1299	uint64 value = query_cost (obj, NULL, F_TRUE);
1584		1300
1585	/* Give third price when we alchemy money (This should hopefully	1301	/* Give third price when we alchemy money (this should hopefully
1586	* make it so that it isn't worth it to alchemy money, sell	1302	* make it so that it isn't worth it to alchemy money, sell
1587	* the nuggets, alchemy the gold from that, etc.	1303	* the nuggets, alchemy the gold from that, etc.
1588	* Otherwise, give 9 silver on the gold for other objects,	1304	* Otherwise, give 9 silver on the gold for other objects,
1589	* so that it would still be more affordable to haul	1305	* so that it would still be more affordable to haul
1590	* the stuff back to town.	1306	* the stuff back to town.
1591	*/	1307	*/
1592
1593	if (QUERY_FLAG (obj, FLAG_UNPAID))	1308	if (QUERY_FLAG (obj, FLAG_UNPAID))
1594	value = 0;	1309	value = 0;
1595	else if (obj->type == MONEY || obj->type == GEM)	1310	else if (obj->type == MONEY || obj->type == GEM)
1596	value /= 3;	1311	value /= 3;
1597	else	1312	else
1598	value = (value * 9) / 10;	1313	value = value * 9 / 10;
1599		1314
1600	value /= 4; // fix by GHJ, don't understand, pcg
1601
1602	if ((obj->value > 0) && rndm (0, 29))	1315	if (obj->value > 0 && rndm (0, 29))
1603	{	1316	total_value += value;
1604	int count;
1605		1317
1606	count = value / large->value;
1607	*large_nuggets += count;
1608	value -= (uint64) count *(uint64) large->value;
1609
1610	count = value / small->value;
1611	*small_nuggets += count;
1612	}
1613
1614	/* Turn 25 small nuggets into 1 large nugget. If the value
1615	* of large nuggets is not evenly divisable by the small nugget
1616	* value, take off an extra small_nugget (Assuming small_nuggets!=0)
1617	*/
1618	if (*small_nuggets * small->value >= large->value)
1619	{
1620	(*large_nuggets)++;
1621	*small_nuggets -= large->value / small->value;
1622	if (*small_nuggets && large->value % small->value)
1623	(*small_nuggets)--;
1624	}
1625	weight += obj->weight;	1318	total_weight += obj->total_weight ();
		1319
1626	obj->destroy ();	1320	obj->destroy ();
1627	}	1321	}
1628		1322
1629	static void
1630	update_map (object *op, maptile *m, int small_nuggets, int large_nuggets, int x, int y)
1631	{
1632	object *tmp;
1633	int flag = 0;
1634
1635	/* Put any nuggets below the player, but we can only pass this
1636	* flag if we are on the same space as the player
1637	*/
1638	if (x == op->x && y == op->y && op->map == m)
1639	flag = INS_BELOW_ORIGINATOR;
1640
1641	if (small_nuggets)
1642	{
1643	tmp = small->clone ();
1644	tmp->nrof = small_nuggets;
1645	tmp->x = x;
1646	tmp->y = y;
1647	insert_ob_in_map (tmp, m, op, flag);
1648	}
1649
1650	if (large_nuggets)
1651	{
1652	tmp = large->clone ();
1653	tmp->nrof = large_nuggets;
1654	tmp->x = x;
1655	tmp->y = y;
1656	insert_ob_in_map (tmp, m, op, flag);
1657	}
1658	}
1659
1660	int	1323	int
1661	alchemy (object *op, object *caster, object *spell_ob)	1324	alchemy (object *op, object *caster, object *spell_ob)
1662	{	1325	{
1663	int x, y, weight = 0, weight_max, large_nuggets, small_nuggets, mflags;
1664	sint16 nx, ny;
1665	object *next, *tmp;
1666	maptile *mp;
1667
1668	if (op->type != PLAYER)	1326	if (op->type != PLAYER)
1669	return 0;	1327	return 0;
1670		1328
		1329	archetype *nugget[3];
		1330
		1331	nugget[0] = archetype::find ("pyrite3");
		1332	nugget[1] = archetype::find ("pyrite2");
		1333	nugget[2] = archetype::find ("pyrite");
		1334
1671	/* Put a maximum weight of items that can be alchemied. Limits the power	1335	/* Put a maximum weight of items that can be alchemised. Limits the power
1672	* some, and also prevents people from alcheming every table/chair/clock	1336	* some, and also prevents people from alchemising every table/chair/clock
1673	* in sight	1337	* in sight
1674	*/	1338	*/
1675	weight_max = spell_ob->duration + +SP_level_duration_adjust (caster, spell_ob);	1339	int duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1676	weight_max *= 1000;	1340	int weight_max = duration * 1000;
1677	small = get_archetype ("smallnugget"), large = get_archetype ("largenugget");	1341	uint64 value_max = duration * 1000;
1678		1342
		1343	int weight = 0;
		1344
1679	for (y = op->y - 1; y <= op->y + 1; y++)	1345	for (int y = op->y - 1; y <= op->y + 1; y++)
1680	{	1346	{
1681	for (x = op->x - 1; x <= op->x + 1; x++)	1347	for (int x = op->x - 1; x <= op->x + 1; x++)
1682	{	1348	{
		1349	uint64 value = 0;
		1350
1683	nx = x;	1351	sint16 nx = x;
1684	ny = y;	1352	sint16 ny = y;
1685		1353
1686	mp = op->map;	1354	maptile *mp = op->map;
1687		1355
1688	mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);	1356	int mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);
1689		1357
1690	if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))	1358	if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))
1691	continue;	1359	continue;
1692		1360
1693	/* Treat alchemy a little differently - most spell effects	1361	/* Treat alchemy a little differently - most spell effects
…		…
1695	* ground level effect.	1363	* ground level effect.
1696	*/	1364	*/
1697	if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)	1365	if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)
1698	continue;	1366	continue;
1699		1367
1700	small_nuggets = 0;	1368	for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1701	large_nuggets = 0;
1702
1703	for (tmp = get_map_ob (mp, nx, ny); tmp != NULL; tmp = next)
1704	{	1369	{
1705	next = tmp->above;	1370	next = tmp->above;
		1371
1706	if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&	1372	if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&
1707	!QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))	1373	!QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))
1708	{	1374	{
1709
1710	if (tmp->inv)	1375	if (tmp->inv)
1711	{	1376	{
1712	object *next1, *tmp1;	1377	object *next1, *tmp1;
1713		1378
1714	for (tmp1 = tmp->inv; tmp1 != NULL; tmp1 = next1)	1379	for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1715	{	1380	{
1716	next1 = tmp1->below;	1381	next1 = tmp1->below;
1717	if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&	1382	if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&
1718	!QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))	1383	!QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))
1719	alchemy_object (tmp1, &small_nuggets, &large_nuggets, &weight);	1384	alchemy_object (tmp1, value, weight);
1720	}	1385	}
1721	}	1386	}
		1387
1722	alchemy_object (tmp, &small_nuggets, &large_nuggets, &weight);	1388	alchemy_object (tmp, value, weight);
1723		1389
1724	if (weight > weight_max)	1390	if (weight > weight_max)
1725	{	1391	break;
1726	update_map (op, mp, small_nuggets, large_nuggets, nx, ny);
1727	large->destroy ();
1728	small->destroy ();
1729	return 1;
1730	}	1392	}
1731	} /* is alchemable object */
1732	} /* process all objects on this space */
1733
1734	/* Insert all the nuggets at one time. This probably saves time, but
1735	* it also prevents us from alcheming nuggets that were just created
1736	* with this spell.
1737	*/	1393	}
1738	update_map (op, mp, small_nuggets, large_nuggets, nx, ny);	1394
		1395	value -= rndm (value >> 4);
		1396	value = min (value, value_max);
		1397
		1398	for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
		1399	if (int nrof = value / nugget [i]->value)
		1400	{
		1401	value -= nrof * nugget[i]->value;
		1402
		1403	object *tmp = arch_to_object (nugget[i]);
		1404	tmp->nrof = nrof;
		1405	tmp->flag [FLAG_IDENTIFIED] = true;
		1406	op->map->insert (tmp, x, y, op, 0);
1739	}	1407	}
1740	}
1741		1408
1742	large->destroy ();	1409	if (weight > weight_max)
1743	small->destroy ();	1410	goto bailout;
1744	/* reset this so that if player standing on a big pile of stuff,	1411	}
1745	* it is redrawn properly.	1412	}
1746	*/	1413
1747	op->contr->socket->look_position = 0;	1414	bailout:
1748	return 1;	1415	return 1;
1749	}	1416	}
1750
1751		1417
1752	/* This function removes the cursed/damned status on equipped	1418	/* This function removes the cursed/damned status on equipped
1753	* items.	1419	* items.
1754	*/	1420	*/
1755	int	1421	int
1756	remove_curse (object *op, object *caster, object *spell)	1422	remove_curse (object *op, object *caster, object *spell)
1757	{	1423	{
1758	object *tmp;
1759	int success = 0, was_one = 0;	1424	int success = 0, was_one = 0;
1760		1425
1761	for (tmp = op->inv; tmp; tmp = tmp->below)	1426	for (object *tmp = op->inv; tmp; tmp = tmp->below)
1762	if (QUERY_FLAG (tmp, FLAG_APPLIED) &&	1427	if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
1763	((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||	1428	((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1764	(QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))	1429	(QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1765	{	1430	{
1766
1767	was_one++;	1431	was_one++;
		1432
1768	if (tmp->level <= caster_level (caster, spell))	1433	if (tmp->level <= casting_level (caster, spell))
1769	{	1434	{
1770	success++;	1435	success++;
1771	if (QUERY_FLAG (spell, FLAG_DAMNED))	1436	if (QUERY_FLAG (spell, FLAG_DAMNED))
1772	CLEAR_FLAG (tmp, FLAG_DAMNED);	1437	CLEAR_FLAG (tmp, FLAG_DAMNED);
1773		1438
1774	CLEAR_FLAG (tmp, FLAG_CURSED);	1439	CLEAR_FLAG (tmp, FLAG_CURSED);
1775	CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);	1440	CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);
1776	tmp->value = 0; /* Still can't sell it */	1441	tmp->value = 0; /* Still can't sell it */
1777	if (op->type == PLAYER)	1442
		1443	if (object *pl = tmp->visible_to ())
1778	esrv_send_item (op, tmp);	1444	esrv_update_item (UPD_FLAGS, pl, tmp);
1779	}	1445	}
1780	}	1446	}
1781		1447
1782	if (op->type == PLAYER)	1448	if (op->type == PLAYER)
1783	{	1449	{
1784	if (success)	1450	if (success)
1785	{
1786	new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");	1451	new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");
1787	}
1788	else	1452	else
1789	{	1453	{
1790	if (was_one)	1454	if (was_one)
1791	new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");	1455	new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");
1792	else	1456	else
1793	new_draw_info (NDI_UNIQUE, 0, op, "You are not using any cursed items.");	1457	new_draw_info (NDI_UNIQUE, 0, op, "You are not using any cursed items.");
1794	}	1458	}
1795	}	1459	}
		1460
1796	return success;	1461	return success;
1797	}	1462	}
1798		1463
1799	/* Identifies objects in the players inventory/on the ground */	1464	/* Identifies objects in the players inventory/on the ground */
1800
1801	int	1465	int
1802	cast_identify (object *op, object *caster, object *spell)	1466	cast_identify (object *op, object *caster, object *spell)
1803	{	1467	{
1804	object *tmp;	1468	object *tmp;
1805	int success = 0, num_ident;	1469	dynbuf_text &buf = msg_dynbuf; buf.clear ();
1806		1470
1807	num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);	1471	int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1808
1809	if (num_ident < 1)
1810	num_ident = 1;
1811
1812		1472
1813	for (tmp = op->inv; tmp; tmp = tmp->below)	1473	for (tmp = op->inv; tmp; tmp = tmp->below)
1814	{	1474	{
1815	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))	1475	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1816	{	1476	{
1817	identify (tmp);	1477	identify (tmp);
		1478
1818	if (op->type == PLAYER)	1479	if (op->type == PLAYER)
1819	{	1480	{
1820	new_draw_info_format (NDI_UNIQUE, 0, op, "You have %s.", long_desc (tmp, op));	1481	buf.printf ("You identified: %s.\r", long_desc (tmp, op));
		1482
1821	if (tmp->msg)	1483	if (tmp->msg)
1822	{	1484	buf << "The item has a story:\r" << tmp->msg << "\n\n";
1823	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1824	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1825	}
1826	}	1485	}
1827	num_ident--;	1486
1828	success = 1;
1829	if (!num_ident)	1487	if (!--num_ident)
1830	break;	1488	break;
1831	}	1489	}
1832	}	1490	}
		1491
1833	/* If all the power of the spell has been used up, don't go and identify	1492	/* If all the power of the spell has been used up, don't go and identify
1834	* stuff on the floor. Only identify stuff on the floor if the spell	1493	* stuff on the floor. Only identify stuff on the floor if the spell
1835	* was not fully used.	1494	* was not fully used.
1836	*/	1495	*/
1837	if (num_ident)	1496	if (num_ident)
1838	{	1497	{
1839	for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)	1498	for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1840	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))	1499	if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1841	{	1500	{
1842
1843	identify (tmp);	1501	identify (tmp);
1844	if (op->type == PLAYER)	1502
		1503	if (object *pl = tmp->visible_to ())
1845	{	1504	{
1846	new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op));	1505	buf.printf ("On the ground you identified: %s.\r", long_desc (tmp, op));
		1506
1847	if (tmp->msg)	1507	if (tmp->msg)
1848	{	1508	buf << "The item has a story:\r" << tmp->msg << "\n\n";
1849	new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1850	new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1851	}
1852	esrv_send_item (op, tmp);
1853	}	1509	}
1854	num_ident--;	1510
1855	success = 1;
1856	if (!num_ident)	1511	if (!--num_ident)
1857	break;	1512	break;
1858	}	1513	}
1859	}	1514	}
1860	if (!success)	1515
1861	new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified.");	1516	if (buf.empty ())
		1517	{
		1518	op->failmsg ("You can't reach anything unidentified.");
		1519	return 0;
		1520	}
1862	else	1521	else
1863	{	1522	{
		1523	if (op->contr)
		1524	op->contr->infobox (MSG_CHANNEL ("identify"), buf);
		1525
1864	spell_effect (spell, op->x, op->y, op->map, op);	1526	spell_effect (spell, op->x, op->y, op->map, op);
		1527	return 1;
1865	}	1528	}
1866	return success;
1867	}	1529	}
1868
1869		1530
1870	int	1531	int
1871	cast_detection (object *op, object *caster, object *spell, object *skill)	1532	cast_detection (object *op, object *caster, object *spell, object *skill)
1872	{	1533	{
1873	object *tmp, *last, *god, *detect;	1534	object *tmp, *last, *god, *detect;
…		…
1877		1538
1878	/* We precompute some values here so that we don't have to keep	1539	/* We precompute some values here so that we don't have to keep
1879	* doing it over and over again.	1540	* doing it over and over again.
1880	*/	1541	*/
1881	god = find_god (determine_god (op));	1542	god = find_god (determine_god (op));
1882	level = caster_level (caster, spell);	1543	level = casting_level (caster, spell);
1883	range = spell->range + SP_level_range_adjust (caster, spell);	1544	range = spell->range + SP_level_range_adjust (caster, spell);
1884		1545
1885	if (!skill)	1546	if (!skill)
1886	skill = caster;	1547	skill = caster;
1887		1548
1888	for (x = op->x - range; x <= op->x + range; x++)	1549	unordered_mapwalk (op, -range, -range, range, range)
1889	for (y = op->y - range; y <= op->y + range; y++)
1890	{	1550	{
1891
1892	m = op->map;
1893	mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1894	if (mflags & P_OUT_OF_MAP)
1895	continue;
1896
1897	/* For most of the detections, we only detect objects above the	1551	/* For most of the detections, we only detect objects above the
1898	* floor. But this is not true for show invisible.	1552	* floor. But this is not true for show invisible.
1899	* Basically, we just go and find the top object and work	1553	* Basically, we just go and find the top object and work
1900	* down - that is easier than working up.	1554	* down - that is easier than working up.
1901	*/	1555	*/
1902		1556
1903	for (last = NULL, tmp = get_map_ob (m, nx, ny); tmp; tmp = tmp->above)	1557	for (last = NULL, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1904	last = tmp;	1558	last = tmp;
		1559
1905	/* Shouldn't happen, but if there are no objects on a space, this	1560	/* Shouldn't happen, but if there are no objects on a space, this
1906	* would happen.	1561	* would happen.
1907	*/	1562	*/
1908	if (!last)	1563	if (!last)
1909	continue;	1564	continue;
1910		1565
1911	done_one = 0;	1566	done_one = 0;
1912	floor = 0;	1567	floor = 0;
1913	detect = NULL;	1568	detect = NULL;
1914	for (tmp = last; tmp; tmp = tmp->below)	1569	for (tmp = last; tmp; tmp = tmp->below)
1915	{	1570	{
1916
1917	/* show invisible */	1571	/* show invisible */
1918	if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&	1572	if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&
1919	/* Might there be other objects that we can make visibile? */	1573	/* Might there be other objects that we can make visible? */
1920	(tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) ||	1574	(tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER)
1921	(tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) ||	1575	|| (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ))
1922	tmp->type == CF_HANDLE ||	1576	|| tmp->type == CF_HANDLE
1923	tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE ||	1577	|| tmp->type == TRAPDOOR
		1578	|| tmp->type == EXIT
		1579	|| tmp->type == HOLE
		1580	|| tmp->type == BUTTON
1924	tmp->type == BUTTON || tmp->type == TELEPORTER ||	1581	|| tmp->type == TELEPORTER
		1582	|| tmp->type == GATE
1925	tmp->type == GATE || tmp->type == LOCKED_DOOR ||	1583	|| tmp->type == LOCKED_DOOR
1926	tmp->type == WEAPON || tmp->type == ALTAR || tmp->type == SIGN ||	1584	|| tmp->type == WEAPON
		1585	|| tmp->type == ALTAR
		1586	|| tmp->type == SIGN
1927	tmp->type == TRIGGER_PEDESTAL || tmp->type == SPECIAL_KEY ||	1587	|| tmp->type == TRIGGER_PEDESTAL
1928	tmp->type == TREASURE || tmp->type == BOOK || tmp->type == HOLY_ALTAR)))	1588	|| tmp->type == SPECIAL_KEY
		1589	|| tmp->type == TREASURE
		1590	|| tmp->type == BOOK
		1591	|| tmp->type == HOLY_ALTAR
		1592	|| tmp->type == CONTAINER)))
1929	{	1593	{
1930	if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)	1594	if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1931	{	1595	{
1932	tmp->invisible = 0;	1596	tmp->invisible = 0;
1933	done_one = 1;	1597	done_one = 1;
1934	}	1598	}
1935	}	1599	}
		1600
1936	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1601	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1937	floor = 1;	1602	floor = 1;
1938		1603
1939	/* All detections below this point don't descend beneath the floor,	1604	/* All detections below this point don't descend beneath the floor,
1940	* so just continue on. We could be clever and look at the type of	1605	* so just continue on. We could be clever and look at the type of
1941	* detection to completely break out if we don't care about objects beneath	1606	* detection to completely break out if we don't care about objects beneath
1942	* the floor, but once we get to the floor, not likely a very big issue anyways.	1607	* the floor, but once we get to the floor, not likely a very big issue anyways.
1943	*/	1608	*/
1944	if (floor)	1609	if (floor)
1945	continue;	1610	continue;
1946		1611
1947	/* I had thought about making detect magic and detect curse	1612	/* I had thought about making detect magic and detect curse
1948	* show the flash the magic item like it does for detect monster.	1613	* show the flash the magic item like it does for detect monster.
1949	* however, if the object is within sight, this would then make it	1614	* however, if the object is within sight, this would then make it
1950	* difficult to see what object is magical/cursed, so the	1615	* difficult to see what object is magical/cursed, so the
1951	* effect wouldn't be as apparant.	1616	* effect wouldn't be as apparent.
1952	*/	1617	*/
1953		1618
1954	/* detect magic */	1619	/* detect magic */
1955	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&	1620	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&
1956	!QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))	1621	!QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))
1957	{	1622	{
1958	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1623	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1959	/* make runes more visibile */	1624	/* make runes more visibile */
1960	if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)	1625	if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1961	tmp->stats.Cha /= 4;	1626	tmp->stats.Cha /= 4;
		1627
1962	done_one = 1;	1628	done_one = 1;
1963	}	1629	}
		1630
1964	/* detect monster */	1631	/* detect monster */
1965	if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))	1632	if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))
1966	{	1633	{
1967	done_one = 2;	1634	done_one = 2;
		1635
1968	if (!detect)	1636	if (!detect)
1969	detect = tmp;	1637	detect = tmp;
1970	}	1638	}
		1639
1971	/* Basically, if race is set in the spell, then the creatures race must	1640	/* Basically, if race is set in the spell, then the creatures race must
1972	* match that. if the spell race is set to GOD, then the gods opposing	1641	* match that. if the spell race is set to GOD, then the gods opposing
1973	* race must match.	1642	* race must match.
1974	*/	1643	*/
1975	if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&	1644	if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&
1976	((!strcmp (spell->race, "GOD") && god && god->slaying && strstr (god->slaying, tmp->race)) ||	1645	((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||
1977	(strstr (spell->race, tmp->race))))	1646	spell->race.contains (tmp->race)))
1978	{	1647	{
1979	done_one = 2;	1648	done_one = 2;
		1649
1980	if (!detect)	1650	if (!detect)
1981	detect = tmp;	1651	detect = tmp;
1982	}	1652	}
		1653
1983	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1654	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1984	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))	1655	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1985	{	1656	{
1986	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1657	SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1987	done_one = 1;	1658	done_one = 1;
1988	}	1659	}
1989	} /* for stack of objects on this space */	1660	} /* for stack of objects on this space */
1990		1661
1991	/* Code here puts an effect of the spell on the space, so you can see	1662	/* Code here puts an effect of the spell on the space, so you can see
1992	* where the magic is.	1663	* where the magic is.
1993	*/	1664	*/
1994	if (done_one)	1665	if (done_one)
1995	{	1666	{
1996	object *detect_ob = arch_to_object (spell->other_arch);	1667	object *detect_ob = arch_to_object (spell->other_arch);
1997		1668
1998	detect_ob->x = nx;
1999	detect_ob->y = ny;
2000	/* if this is set, we want to copy the face */	1669	/* if this is set, we want to copy the face */
2001	if (done_one == 2 && detect)	1670	if (done_one == 2 && detect)
2002	{	1671	{
2003	detect_ob->face = detect->face;	1672	detect_ob->face = detect->face;
2004	detect_ob->animation_id = detect->animation_id;	1673	detect_ob->animation_id = detect->animation_id;
2005	detect_ob->anim_speed = detect->anim_speed;	1674	detect_ob->anim_speed = detect->anim_speed;
2006	detect_ob->last_anim = 0;	1675	detect_ob->last_anim = 0;
2007	/* by default, the detect_ob is already animated */	1676	/* by default, the detect_ob is already animated */
2008	if (!QUERY_FLAG (detect, FLAG_ANIMATE))	1677	if (!QUERY_FLAG (detect, FLAG_ANIMATE))
2009	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);	1678	CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
2010	}	1679	}
2011	insert_ob_in_map (detect_ob, m, op, 0);	1680
		1681	m->insert (detect_ob, nx, ny, op);
2012	}	1682	}
2013	} /* for processing the surrounding spaces */	1683	} /* for processing the surrounding spaces */
2014		1684
2015		1685
2016	/* Now process objects in the players inventory if detect curse or magic */	1686	/* Now process objects in the players inventory if detect curse or magic */
2017	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))	1687	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))
2018	{	1688	{
2019	done_one = 0;	1689	done_one = 0;
		1690
2020	for (tmp = op->inv; tmp; tmp = tmp->below)	1691	for (tmp = op->inv; tmp; tmp = tmp->below)
2021	{	1692	{
2022	if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))	1693	if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))
2023	{	1694	{
2024	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))	1695	if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))
2025	{	1696	{
2026	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);	1697	SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
2027	if (op->type == PLAYER)	1698
		1699	if (object *pl = tmp->visible_to ())
2028	esrv_send_item (op, tmp);	1700	esrv_update_item (UPD_FLAGS, pl, tmp);
2029	}	1701	}
		1702
2030	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&	1703	if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
2031	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))	1704	(QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
2032	{	1705	{
2033	SET_FLAG (tmp, FLAG_KNOWN_CURSED);	1706	SET_FLAG (tmp, FLAG_KNOWN_CURSED);
2034	if (op->type == PLAYER)	1707
		1708	if (object *pl = tmp->visible_to ())
2035	esrv_send_item (op, tmp);	1709	esrv_update_item (UPD_FLAGS, pl, tmp);
2036	}	1710	}
2037	} /* if item is not identified */	1711	} /* if item is not identified */
2038	} /* for the players inventory */	1712	} /* for the players inventory */
2039	} /* if detect magic/curse and object is a player */	1713	} /* if detect magic/curse and object is a player */
		1714
2040	return 1;	1715	return 1;
2041	}	1716	}
2042		1717
2043		1718
2044	/**	1719	/**
…		…
2057		1732
2058	new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");	1733	new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");
2059		1734
2060	if (victim->stats.sp >= victim->stats.maxsp * 2)	1735	if (victim->stats.sp >= victim->stats.maxsp * 2)
2061	{	1736	{
2062	object *tmp;
2063
2064	new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");	1737	new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");
2065
2066	/* Explodes a fireball centered at player */
2067	tmp = get_archetype (EXPLODING_FIREBALL);
2068	tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
2069	tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
2070	tmp->x = victim->x;
2071	tmp->y = victim->y;
2072	insert_ob_in_map (tmp, victim->map, NULL, 0);
2073	victim->stats.sp = 2 * victim->stats.maxsp;	1738	victim->stats.sp = 2 * victim->stats.maxsp;
		1739	create_exploding_ball_at (victim, caster_level);
2074	}	1740	}
2075	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)	1741	else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
2076	{
2077	new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode.");	1742	new_draw_info (NDI_UNIQUE | NDI_ORANGE, 0, victim, "You feel like your head is going to explode.");
2078	}
2079	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)	1743	else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
2080	{
2081	new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");	1744	new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
2082	}
2083	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)	1745	else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
2084	{	1746	{
2085	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");	1747	new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
2086	confuse_player (victim, victim, 99);	1748	confuse_player (victim, victim, 99);
2087	}	1749	}
2088	else if (victim->stats.sp >= victim->stats.maxsp * 1.25)	1750	else if (victim->stats.sp >= victim->stats.maxsp * 1.25)
2089	{
2090	new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");	1751	new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");
2091	}
2092	}	1752	}
2093		1753
2094	/* cast_transfer	1754	/* cast_transfer
2095	* This spell transfers sp from the player to another person.	1755	* This spell transfers sp from the player to another person.
2096	* We let the target go above their normal maximum SP.	1756	* We let the target go above their normal maximum SP.
…		…
2110		1770
2111	mflags = get_map_flags (m, &m, x, y, &x, &y);	1771	mflags = get_map_flags (m, &m, x, y, &x, &y);
2112		1772
2113	if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)	1773	if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
2114	{	1774	{
2115	for (plyr = get_map_ob (m, x, y); plyr != NULL; plyr = plyr->above)	1775	for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)
2116	if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))	1776	if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))
2117	break;	1777	break;
2118	}	1778	}
2119		1779
2120		1780
2121	/* If we did not find a player in the specified direction, transfer	1781	/* If we did not find a player in the specified direction, transfer
2122	* to anyone on top of us. This is used for the rune of transference mostly.	1782	* to anyone on top of us. This is used for the rune of transference mostly.
2123	*/	1783	*/
2124	if (plyr == NULL)	1784	if (plyr == NULL)
2125	for (plyr = get_map_ob (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)	1785	for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)
2126	if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))	1786	if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))
2127	break;	1787	break;
2128		1788
2129	if (!plyr)	1789	if (!plyr)
2130	{	1790	{
…		…
2133	}	1793	}
2134	/* give sp */	1794	/* give sp */
2135	if (spell->stats.dam > 0)	1795	if (spell->stats.dam > 0)
2136	{	1796	{
2137	plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);	1797	plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);
2138	charge_mana_effect (plyr, caster_level (caster, spell));	1798	charge_mana_effect (plyr, casting_level (caster, spell));
2139	return 1;	1799	return 1;
2140	}	1800	}
2141	/* suck sp away. Can't suck sp from yourself */	1801	/* suck sp away. Can't suck sp from yourself */
2142	else if (op != plyr)	1802	else if (op != plyr)
2143	{	1803	{
…		…
2155	/* Player doesn't get full credit */	1815	/* Player doesn't get full credit */
2156	sucked = (sucked * rate) / 100;	1816	sucked = (sucked * rate) / 100;
2157	op->stats.sp += sucked;	1817	op->stats.sp += sucked;
2158	if (sucked > 0)	1818	if (sucked > 0)
2159	{	1819	{
2160	charge_mana_effect (op, caster_level (caster, spell));	1820	charge_mana_effect (op, casting_level (caster, spell));
2161	}	1821	}
2162	}	1822	}
2163	return 1;	1823	return 1;
2164	}	1824	}
2165	return 0;	1825	return 0;
…		…
2185	m = op->map;	1845	m = op->map;
2186	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);	1846	mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
2187	if (mflags & P_OUT_OF_MAP)	1847	if (mflags & P_OUT_OF_MAP)
2188	return;	1848	return;
2189		1849
2190	for (tmp = get_map_ob (m, sx, sy); tmp != NULL; tmp = next)	1850	for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)
2191	{	1851	{
2192	next = tmp->above;	1852	next = tmp->above;
2193		1853
2194	/* Need to look at the head object - otherwise, if tmp	1854	/* Need to look at the head object - otherwise, if tmp
2195	* points to a monster, we don't have all the necessary	1855	* points to a monster, we don't have all the necessary
…		…
2207	/* Basically, if the object is magical and not counterspell,	1867	/* Basically, if the object is magical and not counterspell,
2208	* we will more or less remove the object. Don't counterspell	1868	* we will more or less remove the object. Don't counterspell
2209	* monsters either.	1869	* monsters either.
2210	*/	1870	*/
2211		1871
2212	if (head->attacktype & AT_MAGIC &&	1872	if (head->attacktype & AT_MAGIC
2213	!(head->attacktype & AT_COUNTERSPELL) && !QUERY_FLAG (head, FLAG_MONSTER) && (op->level > head->level))	1873	&& !(head->attacktype & AT_COUNTERSPELL)
		1874	&& !QUERY_FLAG (head, FLAG_MONSTER)
		1875	&& (op->level > head->level))
2214	head->destroy ();	1876	head->destroy ();
2215	else	1877	else
2216	switch (head->type)	1878	switch (head->type)
2217	{	1879	{
2218	case SPELL_EFFECT:	1880	case SPELL_EFFECT:
		1881	// XXX: Don't affect floor spelleffects. See also XXX comment
		1882	// about sanctuary in spell_util.C
		1883	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
		1884	continue;
		1885
2219	if (op->level > head->level)	1886	if (op->level > head->level)
2220	head->destroy ();	1887	head->destroy ();
2221		1888
2222	break;	1889	break;
2223		1890
…		…
2234	break;	1901	break;
2235	}	1902	}
2236	}	1903	}
2237	}	1904	}
2238		1905
2239
2240
2241	/* cast_consecrate() - a spell to make an altar your god's */	1906	/* cast_consecrate() - a spell to make an altar your god's */
2242	int	1907	int
2243	cast_consecrate (object *op, object *caster, object *spell)	1908	cast_consecrate (object *op, object *caster, object *spell)
2244	{	1909	{
2245	char buf[MAX_BUF];	1910	char buf[MAX_BUF];
…		…
2257	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1922	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2258	break;	1923	break;
2259	if (tmp->type == HOLY_ALTAR)	1924	if (tmp->type == HOLY_ALTAR)
2260	{	1925	{
2261		1926
2262	if (tmp->level > caster_level (caster, spell))	1927	if (tmp->level > casting_level (caster, spell))
2263	{	1928	{
2264	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);	1929	new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);
2265	return 0;	1930	return 0;
2266	}	1931	}
2267	else	1932	else
2268	{	1933	{
2269	/* If we got here, we are consecrating an altar */	1934	/* If we got here, we are consecrating an altar */
2270	sprintf (buf, "Altar of %s", &god->name);	1935	sprintf (buf, "Altar of %s", &god->name);
2271	tmp->name = buf;	1936	tmp->name = buf;
2272	tmp->level = caster_level (caster, spell);	1937	tmp->level = casting_level (caster, spell);
2273	tmp->other_arch = god->arch;	1938	tmp->other_arch = god->arch;
		1939
2274	if (op->type == PLAYER)	1940	if (op->type == PLAYER)
2275	esrv_update_item (UPD_NAME, op, tmp);	1941	esrv_update_item (UPD_NAME, op, tmp);
		1942
2276	new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);	1943	new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
2277	return 1;	1944	return 1;
2278	}	1945	}
2279	}	1946	}
2280	}	1947	}
…		…
2290	* This code was very odd - code early on would only let players use the spell,	1957	* This code was very odd - code early on would only let players use the spell,
2291	* yet the code wass full of player checks. I've presumed that the code	1958	* yet the code wass full of player checks. I've presumed that the code
2292	* that only let players use it was correct, and removed all the other	1959	* that only let players use it was correct, and removed all the other
2293	* player checks. MSW 2003-01-06	1960	* player checks. MSW 2003-01-06
2294	*/	1961	*/
2295
2296	int	1962	int
2297	animate_weapon (object *op, object *caster, object *spell, int dir)	1963	animate_weapon (object *op, object *caster, object *spell, int dir)
2298	{	1964	{
2299	object *weapon, *tmp;	1965	object *weapon, *tmp;
2300	char buf[MAX_BUF];	1966	char buf[MAX_BUF];
2301	int a, i;	1967	int a, i;
2302	sint16 x, y;	1968	sint16 x, y;
2303	maptile *m;	1969	maptile *m;
2304	materialtype_t *mt;
2305		1970
2306	if (!spell->other_arch)	1971	if (!spell->other_arch)
2307	{	1972	{
2308	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");	1973	new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
2309	LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);	1974	LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);
…		…
2312	/* exit if it's not a player using this spell. */	1977	/* exit if it's not a player using this spell. */
2313	if (op->type != PLAYER)	1978	if (op->type != PLAYER)
2314	return 0;	1979	return 0;
2315		1980
2316	/* if player already has a golem, abort */	1981	/* if player already has a golem, abort */
2317	if (op->contr->ranges[range_golem])	1982	if (object *golem = op->contr->golem)
2318	{	1983	{
2319	control_golem (op->contr->ranges[range_golem], dir);	1984	control_golem (golem, dir);
2320	return 0;	1985	return 0;
2321	}	1986	}
2322		1987
2323	/* if no direction specified, pick one */	1988	/* if no direction specified, pick one */
2324	if (!dir)	1989	if (!dir)
2325	dir = find_free_spot (NULL, op->map, op->x, op->y, 1, 9);	1990	dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);
2326		1991
2327	m = op->map;	1992	m = op->map;
2328	x = op->x + freearr_x[dir];	1993	x = op->x + freearr_x[dir];
2329	y = op->y + freearr_y[dir];	1994	y = op->y + freearr_y[dir];
2330		1995
2331	/* if there's no place to put the golem, abort */	1996	/* if there's no place to put the golem, abort */
2332	if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) ||	1997	if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
2333	((spell->other_arch->clone.move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->clone.move_type))	1998	|| ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2334	{	1999	{
2335	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");	2000	new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
2336	return 0;	2001	return 0;
2337	}	2002	}
2338		2003
…		…
2342	if (!weapon)	2007	if (!weapon)
2343	{	2008	{
2344	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");	2009	new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
2345	return 0;	2010	return 0;
2346	}	2011	}
		2012
2347	if (spell->race && strcmp (weapon->arch->name, spell->race))	2013	if (spell->race && weapon->arch->archname != spell->race)
2348	{	2014	{
2349	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");	2015	new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
2350	return 0;	2016	return 0;
2351	}	2017	}
		2018
2352	if (weapon->type != WEAPON)	2019	if (weapon->type != WEAPON)
2353	{	2020	{
2354	new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");	2021	new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");
2355	return 0;	2022	return 0;
2356	}	2023	}
		2024
2357	if (QUERY_FLAG (weapon, FLAG_APPLIED))	2025	if (QUERY_FLAG (weapon, FLAG_APPLIED))
2358	{	2026	{
2359	new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));	2027	new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));
2360	return 0;	2028	return 0;
2361	}	2029	}
2362		2030
2363	if (weapon->nrof > 1)	2031	weapon = weapon->split ();
2364	{
2365	tmp = get_split_ob (weapon, 1);
2366	esrv_send_item (op, weapon);
2367	weapon = tmp;
2368	}
2369		2032
2370	/* create the golem object */	2033	/* create the golem object */
2371	tmp = arch_to_object (spell->other_arch);	2034	tmp = arch_to_object (spell->other_arch);
2372		2035
2373	/* if animated by a player, give the player control of the golem */	2036	/* if animated by a player, give the player control of the golem */
2374	CLEAR_FLAG (tmp, FLAG_MONSTER);	2037	CLEAR_FLAG (tmp, FLAG_MONSTER);
2375	SET_FLAG (tmp, FLAG_FRIENDLY);
2376	tmp->stats.exp = 0;	2038	tmp->stats.exp = 0;
2377	add_friendly_object (tmp);	2039	add_friendly_object (tmp);
2378	tmp->type = GOLEM;	2040	tmp->type = GOLEM;
2379	tmp->set_owner (op);	2041	tmp->set_owner (op);
		2042	op->contr->golem = tmp;
2380	set_spell_skill (op, caster, spell, tmp);	2043	set_spell_skill (op, caster, spell, tmp);
2381	op->contr->ranges[range_golem] = tmp;
2382	op->contr->shoottype = range_golem;
2383		2044
2384	/* Give the weapon to the golem now. A bit of a hack to check the	2045	/* Give the weapon to the golem now. A bit of a hack to check the
2385	* removed flag - it should only be set if get_split_object was	2046	* removed flag - it should only be set if weapon->split was
2386	* used above.	2047	* used above.
2387	*/	2048	*/
2388	if (!QUERY_FLAG (weapon, FLAG_REMOVED))	2049	if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2389	weapon->remove ();	2050	weapon->remove ();
2390	insert_ob_in_ob (weapon, tmp);	2051
2391	esrv_send_item (op, weapon);	2052	tmp->insert (weapon);
		2053
2392	/* To do everything necessary to let a golem use the weapon is a pain,	2054	/* To do everything necessary to let a golem use the weapon is a pain,
2393	* so instead, just set it as equipped (otherwise, we need to update	2055	* so instead, just set it as equipped (otherwise, we need to update
2394	* body_info, skills, etc)	2056	* body_info, skills, etc)
2395	*/	2057	*/
2396	SET_FLAG (tmp, FLAG_USE_WEAPON);	2058	SET_FLAG (tmp, FLAG_USE_WEAPON);
2397	SET_FLAG (weapon, FLAG_APPLIED);	2059	SET_FLAG (weapon, FLAG_APPLIED);
2398	fix_player (tmp);	2060	tmp->update_stats ();
2399		2061
2400	/* There used to be 'odd' code that basically seemed to take the absolute	2062	/* There used to be 'odd' code that basically seemed to take the absolute
2401	* value of the weapon->magic an use that. IMO, that doesn't make sense -	2063	* value of the weapon->magic an use that. IMO, that doesn't make sense -
2402	* if you're using a crappy weapon, it shouldn't be as good.	2064	* if you're using a crappy weapon, it shouldn't be as good.
2403	*/	2065	*/
…		…
2422		2084
2423	/* attacktype */	2085	/* attacktype */
2424	if (!tmp->attacktype)	2086	if (!tmp->attacktype)
2425	tmp->attacktype = AT_PHYSICAL;	2087	tmp->attacktype = AT_PHYSICAL;
2426		2088
2427	mt = NULL;
2428	if (op->materialname != NULL)
2429	mt = name_to_material (op->materialname);	2089	if (materialtype_t *mt = name_to_material (op->materialname))
2430	if (mt != NULL)
2431	{	2090	{
2432	for (i = 0; i < NROFATTACKS; i++)	2091	for (i = 0; i < NROFATTACKS; i++)
2433	tmp->resist[i] = 50 - (mt->save[i] * 5);	2092	tmp->resist[i] = 50 - (mt->save[i] * 5);
2434	a = mt->save[0];	2093	a = mt->save[0];
2435	}	2094	}
…		…
2437	{	2096	{
2438	for (i = 0; i < NROFATTACKS; i++)	2097	for (i = 0; i < NROFATTACKS; i++)
2439	tmp->resist[i] = 5;	2098	tmp->resist[i] = 5;
2440	a = 10;	2099	a = 10;
2441	}	2100	}
		2101
2442	/* Set weapon's immunity */	2102	/* Set weapon's immunity */
2443	tmp->resist[ATNR_CONFUSION] = 100;	2103	tmp->resist[ATNR_CONFUSION] = 100;
2444	tmp->resist[ATNR_POISON] = 100;	2104	tmp->resist[ATNR_POISON] = 100;
2445	tmp->resist[ATNR_SLOW] = 100;	2105	tmp->resist[ATNR_SLOW] = 100;
2446	tmp->resist[ATNR_PARALYZE] = 100;	2106	tmp->resist[ATNR_PARALYZE] = 100;
…		…
2452		2112
2453	/* Improve weapon's armour value according to best save vs. physical of its material */	2113	/* Improve weapon's armour value according to best save vs. physical of its material */
2454		2114
2455	if (a > 14)	2115	if (a > 14)
2456	a = 14;	2116	a = 14;
		2117
2457	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));	2118	tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2458		2119
2459	/* Determine golem's speed */	2120	/* Determine golem's speed */
2460	tmp->speed = 0.4 + 0.1 * SP_level_range_adjust (caster, spell);	2121	tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2461
2462	if (tmp->speed > 3.33)
2463	tmp->speed = 3.33;
2464		2122
2465	if (!spell->race)	2123	if (!spell->race)
2466	{	2124	{
2467	sprintf (buf, "animated %s", &weapon->name);	2125	sprintf (buf, "animated %s", &weapon->name);
2468	tmp->name = buf;	2126	tmp->name = buf;
…		…
2470	tmp->face = weapon->face;	2128	tmp->face = weapon->face;
2471	tmp->animation_id = weapon->animation_id;	2129	tmp->animation_id = weapon->animation_id;
2472	tmp->anim_speed = weapon->anim_speed;	2130	tmp->anim_speed = weapon->anim_speed;
2473	tmp->last_anim = weapon->last_anim;	2131	tmp->last_anim = weapon->last_anim;
2474	tmp->state = weapon->state;	2132	tmp->state = weapon->state;
2475	if (QUERY_FLAG (weapon, FLAG_ANIMATE))	2133	tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2476	{
2477	SET_FLAG (tmp, FLAG_ANIMATE);
2478	}
2479	else
2480	{
2481	CLEAR_FLAG (tmp, FLAG_ANIMATE);
2482	}
2483	update_ob_speed (tmp);
2484	}	2134	}
2485		2135
2486	/* make experience increase in proportion to the strength of the summoned creature. */	2136	/* make experience increase in proportion to the strength of the summoned creature. */
2487	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));	2137	tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));
2488		2138
2489	tmp->speed_left = -1;	2139	tmp->speed_left = -1;
2490	tmp->x = x;
2491	tmp->y = y;
2492	tmp->direction = dir;	2140	tmp->direction = dir;
2493	insert_ob_in_map (tmp, m, op, 0);	2141
		2142	m->insert (tmp, x, y, op);
2494	return 1;	2143	return 1;
2495	}	2144	}
2496		2145
2497	/* cast_daylight() - changes the map darkness level *lower* */	2146	/* cast_daylight() - changes the map darkness level *lower* */
2498		2147
2499	/* cast_change_map_lightlevel: Was cast_daylight/nightfall.	2148	/* cast_change_map_lightlevel: Was cast_daylight/nightfall.
2500	* This changes the light level for the entire map.	2149	* This changes the light level for the entire map.
2501	*/	2150	*/
2502
2503	int	2151	int
2504	cast_change_map_lightlevel (object *op, object *caster, object *spell)	2152	cast_change_map_lightlevel (object *op, object *caster, object *spell)
2505	{	2153	{
2506	int success;	2154	int success;
2507		2155
2508	if (!op->map)	2156	if (!op->map)
2509	return 0; /* shouldnt happen */	2157	return 0; /* shouldnt happen */
2510		2158
2511	success = change_map_light (op->map, spell->stats.dam);	2159	success = op->map->change_map_light (spell->stats.dam);
		2160
2512	if (!success)	2161	if (!success)
2513	{	2162	{
2514	if (spell->stats.dam < 0)	2163	if (spell->stats.dam < 0)
2515	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");	2164	new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2516	else	2165	else
2517	new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");	2166	new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2518	}	2167	}
		2168
2519	return success;	2169	return success;
2520	}	2170	}
2521
2522
2523
2524
2525		2171
2526	/* create an aura spell object and put it in the player's inventory.	2172	/* create an aura spell object and put it in the player's inventory.
2527	* as usual, op is player, caster is the object casting the spell,	2173	* as usual, op is player, caster is the object casting the spell,
2528	* spell is the spell object itself.	2174	* spell is the spell object itself.
2529	*/	2175	*/
…		…
2541		2187
2542	new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);	2188	new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2543		2189
2544	new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);	2190	new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2545		2191
2546	new_aura->set_owner (op);
2547	set_spell_skill (op, caster, spell, new_aura);	2192	set_spell_skill (op, caster, spell, new_aura);
2548	new_aura->attacktype = spell->attacktype;	2193	new_aura->attacktype = spell->attacktype;
2549		2194
2550	new_aura->level = caster_level (caster, spell);	2195	new_aura->level = casting_level (caster, spell);
		2196
2551	if (refresh)	2197	if (refresh)
2552	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");	2198	new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2553	else	2199	else
2554	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");	2200	new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
		2201
2555	insert_ob_in_ob (new_aura, op);	2202	insert_ob_in_ob (new_aura, op);
		2203	new_aura->set_owner (op);
		2204
2556	return 1;	2205	return 1;
2557	}	2206	}
2558
2559		2207
2560	/* move aura function. An aura is a part of someone's inventory,	2208	/* move aura function. An aura is a part of someone's inventory,
2561	* which he carries with him, but which acts on the map immediately	2209	* which he carries with him, but which acts on the map immediately
2562	* around him.	2210	* around him.
2563	* Aura parameters:	2211	* Aura parameters:
2564	* duration: duration counter.	2212	* duration: duration counter.
2565	* attacktype: aura's attacktype	2213	* attacktype: aura's attacktype
2566	* other_arch: archetype to drop where we attack	2214	* other_arch: archetype to drop where we attack
2567	*/	2215	*/
2568
2569	void	2216	void
2570	move_aura (object *aura)	2217	move_aura (object *aura)
2571	{	2218	{
2572	int i, mflags;
2573	object *env;
2574	maptile *m;
2575
2576	/* auras belong in inventories */	2219	/* auras belong in inventories */
2577	env = aura->env;	2220	object *env = aura->env;
		2221	object *owner = aura->owner;
2578		2222
2579	/* no matter what we've gotta remove the aura...	2223	/* no matter what we've gotta remove the aura...
2580	* we'll put it back if its time isn't up.	2224	* we'll put it back if its time isn't up.
2581	*/	2225	*/
2582	aura->remove ();	2226	aura->remove ();
…		…
2587	aura->destroy ();	2231	aura->destroy ();
2588	return;	2232	return;
2589	}	2233	}
2590		2234
2591	/* auras only exist in inventories */	2235	/* auras only exist in inventories */
2592	if (env == NULL || env->map == NULL)	2236	if (!env || !env->map)
2593	{	2237	{
2594	aura->destroy ();	2238	aura->destroy ();
2595	return;	2239	return;
2596	}	2240	}
2597
2598	aura->x = env->x;
2599	aura->y = env->y;
2600		2241
2601	/* we need to jump out of the inventory for a bit	2242	/* we need to jump out of the inventory for a bit
2602	* in order to hit the map conveniently.	2243	* in order to hit the map conveniently.
2603	*/	2244	*/
2604	insert_ob_in_map (aura, env->map, aura, 0);	2245	aura->insert_at (env, aura);
2605		2246
2606	for (i = 1; i < 9; i++)	2247	for (int i = 1; i < 9; i++)
2607	{	2248	{
2608	sint16 nx, ny;	2249	mapxy pos (env);
		2250	pos.move (i);
2609		2251
2610	nx = aura->x + freearr_x[i];
2611	ny = aura->y + freearr_y[i];
2612	mflags = get_map_flags (env->map, &m, nx, ny, &nx, &ny);
2613
2614	/* Consider the movement tyep of the person with the aura as	2252	/* Consider the movement type of the person with the aura as
2615	* movement type of the aura. Eg, if the player is flying, the aura	2253	* movement type of the aura. Eg, if the player is flying, the aura
2616	* is flying also, if player is walking, it is on the ground, etc.	2254	* is flying also, if player is walking, it is on the ground, etc.
2617	*/	2255	*/
2618	if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))	2256	if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2619	{	2257	{
2620	hit_map (aura, i, aura->attacktype, 0);	2258	hit_map (aura, i, aura->attacktype, 0);
2621		2259
2622	if (aura->other_arch)	2260	if (aura->other_arch)
2623	{
2624	object *new_ob;
2625
2626	new_ob = arch_to_object (aura->other_arch);	2261	pos.insert (arch_to_object (aura->other_arch), aura);
2627	new_ob->x = nx;
2628	new_ob->y = ny;
2629	insert_ob_in_map (new_ob, m, aura, 0);
2630	}	2262	}
2631	}
2632	}	2263	}
		2264
2633	/* put the aura back in the player's inventory */	2265	/* put the aura back in the player's inventory */
2634	aura->remove ();	2266	env->insert (aura);
2635	insert_ob_in_ob (aura, env);	2267	aura->set_owner (owner);
2636	}	2268	}
2637		2269
2638	/* moves the peacemaker spell.	2270	/* moves the peacemaker spell.
2639	* op is the piece object.	2271	* op is the piece object.
2640	*/	2272	*/
2641
2642	void	2273	void
2643	move_peacemaker (object *op)	2274	move_peacemaker (object *op)
2644	{	2275	{
2645	object *tmp;	2276	for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
2646
2647	for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2648	{	2277	{
2649	int atk_lev, def_lev;	2278	int atk_lev, def_lev;
2650	object *victim = tmp;	2279	object *victim = tmp->head_ ();
2651		2280
2652	if (tmp->head)
2653	victim = tmp->head;
2654	if (!QUERY_FLAG (victim, FLAG_MONSTER))	2281	if (!QUERY_FLAG (victim, FLAG_MONSTER))
2655	continue;	2282	continue;
		2283
2656	if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))	2284	if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))
2657	continue;	2285	continue;
		2286
2658	if (victim->stats.exp == 0)	2287	if (victim->stats.exp == 0)
2659	continue;	2288	continue;
2660		2289
2661	def_lev = MAX (1, victim->level);	2290	def_lev = MAX (1, victim->level);
2662	atk_lev = MAX (1, op->level);	2291	atk_lev = MAX (1, op->level);
2663		2292
2664	if (rndm (0, atk_lev - 1) > def_lev)	2293	if (rndm (0, atk_lev - 1) > def_lev)
2665	{	2294	{
2666	/* make this sucker peaceful. */	2295	/* make this sucker peaceful. */
2667		2296
		2297	INVOKE_OBJECT (KILL, victim, ARG_OBJECT (op));
2668	change_exp (op->owner, victim->stats.exp, op->skill, 0);	2298	change_exp (op->owner, victim->stats.exp, op->skill, 0);
2669	victim->stats.exp = 0;	2299	victim->stats.exp = 0;
2670	#if 0	2300	#if 0
2671	/* No idea why these were all set to zero - if something	2301	/* No idea why these were all set to zero - if something
2672	* makes this creature agressive, he should still do damage.	2302	* makes this creature agressive, he should still do damage.
…		…
2679	victim->attack_movement = RANDO2;	2309	victim->attack_movement = RANDO2;
2680	SET_FLAG (victim, FLAG_UNAGGRESSIVE);	2310	SET_FLAG (victim, FLAG_UNAGGRESSIVE);
2681	SET_FLAG (victim, FLAG_RUN_AWAY);	2311	SET_FLAG (victim, FLAG_RUN_AWAY);
2682	SET_FLAG (victim, FLAG_RANDOM_MOVE);	2312	SET_FLAG (victim, FLAG_RANDOM_MOVE);
2683	CLEAR_FLAG (victim, FLAG_MONSTER);	2313	CLEAR_FLAG (victim, FLAG_MONSTER);
		2314
2684	if (victim->name)	2315	if (victim->name)
2685	{
2686	new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);	2316	new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2687	}	2317	}
2688	}
2689	}	2318	}
2690	}	2319	}
2691
2692		2320
2693	/* This writes a rune that contains the appropriate message.	2321	/* This writes a rune that contains the appropriate message.
2694	* There really isn't any adjustments we make.	2322	* There really isn't any adjustments we make.
2695	*/	2323	*/
2696
2697	int	2324	int
2698	write_mark (object *op, object *spell, const char *msg)	2325	write_mark (object *op, object *spell, const char *msg)
2699	{	2326	{
2700	char rune[HUGE_BUF];
2701	object *tmp;
2702
2703	if (!msg || msg[0] == 0)	2327	if (!msg || msg[0] == 0)
2704	{	2328	{
2705	new_draw_info (NDI_UNIQUE, 0, op, "Write what?");	2329	new_draw_info (NDI_UNIQUE, 0, op, "Write what?");
2706	return 0;	2330	return 0;
2707	}	2331	}
…		…
2710	{	2334	{
2711	new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");	2335	new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");
2712	LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg);	2336	LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg);
2713	return 0;	2337	return 0;
2714	}	2338	}
		2339
2715	if (!spell->other_arch)	2340	if (!spell->other_arch)
2716	return 0;	2341	return 0;
		2342
2717	tmp = arch_to_object (spell->other_arch);	2343	object *tmp = arch_to_object (spell->other_arch);
2718
2719	snprintf (rune, sizeof (rune), "%s\n", msg);
2720		2344
2721	tmp->race = op->name; /*Save the owner of the rune */	2345	tmp->race = op->name; /*Save the owner of the rune */
2722	tmp->msg = rune;	2346	tmp->msg = msg;
2723	tmp->x = op->x;	2347
2724	tmp->y = op->y;	2348	tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2725	insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);	2349
2726	return 1;	2350	return 1;
2727	}	2351	}
		2352

Diff Legend

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