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

Comparing deliantra/server/server/spell_effect.C (file contents):
Revision 1.2 by root, Thu Aug 17 20:23:32 2006 UTC vs.
Revision 1.148 by root, Sat Nov 17 23:40:04 2018 UTC

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

Diff Legend

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