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.7 by root, Sun Sep 3 00:18:42 2006 UTC vs.
Revision 1.25 by root, Sat Dec 23 09:58:23 2006 UTC

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

Diff Legend

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