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.2 by root, Thu Aug 17 20:23:32 2006 UTC vs.
Revision 1.28 by root, Sat Dec 30 10:16:11 2006 UTC

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

Diff Legend

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