ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/spell_effect.C
(Generate patch)

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:05 2006 UTC vs.
Revision 1.143 by root, Mon Nov 12 03:48:34 2012 UTC

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

Diff Legend

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