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

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:05 2006 UTC vs.
Revision 1.16 by root, Tue Dec 12 20:53:03 2006 UTC

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

Diff Legend

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