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

Diff Legend

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