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

Diff Legend

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