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.25 by root, Sat Dec 23 09:58:23 2006 UTC vs.
Revision 1.78 by root, Tue Jan 15 12:02:24 2008 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version. 11 * (at your option) any later version.
11 12 *
12 This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 16 * GNU General Public License for more details.
16 17 *
17 You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 *
20 21 * The authors can be reached via e-mail to <support@deliantra.net>
21 The authors can be reached via e-mail at <crossfire@schmorp.de>
22*/ 22 */
23 23
24#include <global.h> 24#include <global.h>
25#include <object.h> 25#include <object.h>
26#include <living.h> 26#include <living.h>
27#ifndef __CEXTRACT__
28# include <sproto.h> 27#include <sproto.h>
29#endif
30#include <spells.h> 28#include <spells.h>
31#include <sounds.h> 29#include <sounds.h>
32 30
33/* cast_magic_storm: This is really used mostly for spell 31/* cast_magic_storm: This is really used mostly for spell
34 * fumbles at the like. tmp is the object to propogate. 32 * fumbles at the like. tmp is the object to propogate.
… …
37void 35void
38cast_magic_storm (object *op, object *tmp, int lvl) 36cast_magic_storm (object *op, object *tmp, int lvl)
39{ 37{
40 if (!tmp) 38 if (!tmp)
41 return; /* error */ 39 return; /* error */
40
42 tmp->level = op->level; 41 tmp->level = op->level;
43 tmp->x = op->x;
44 tmp->y = op->y;
45 tmp->range += lvl / 5; /* increase the area of destruction */ 42 tmp->range += lvl / 5; /* increase the area of destruction */
46 tmp->duration += lvl / 5; 43 tmp->duration += lvl / 5;
47 44
48 /* Put a cap on duration for this - if the player fails in their 45 /* Put a cap on duration for this - if the player fails in their
49 * apartment, don't want it to go on so long that it kills them 46 * apartment, don't want it to go on so long that it kills them
50 * multiple times. Also, damge already increases with level, 47 * multiple times. Also, damge already increases with level,
51 * so don't really need to increase the duration as much either. 48 * so don't really need to increase the duration as much either.
52 */ 49 */
53 if (tmp->duration >= 40) 50 if (tmp->duration >= 40)
54 tmp->duration = 40; 51 tmp->duration = 40;
52
55 tmp->stats.dam = lvl; /* nasty recoils! */ 53 tmp->stats.dam = lvl; /* nasty recoils! */
56 tmp->stats.maxhp = tmp->count; /* tract single parent */ 54 tmp->stats.maxhp = tmp->count; /* tract single parent */
57 insert_ob_in_map (tmp, op->map, op, 0);
58 55
56 tmp->insert_at (op, op);
59} 57}
60
61 58
62int 59int
63recharge (object *op, object *caster, object *spell_ob) 60recharge (object *op, object *caster, object *spell_ob)
64{ 61{
65 object *wand, *tmp; 62 object *wand, *tmp;
… …
72 return 0; 69 return 0;
73 } 70 }
74 if (!(random_roll (0, 3, op, PREFER_HIGH))) 71 if (!(random_roll (0, 3, op, PREFER_HIGH)))
75 { 72 {
76 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand)); 73 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));
77 play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE); 74 op->play_sound (sound_find ("ob_explode"));
78 esrv_del_item (op->contr, wand->count); 75 esrv_del_item (op->contr, wand->count);
79 wand->destroy (); 76 wand->destroy ();
80 tmp = get_archetype ("fireball"); 77 tmp = get_archetype ("fireball");
81 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10; 78 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
79
82 if (!tmp->stats.dam) 80 if (!tmp->stats.dam)
83 tmp->stats.dam = 1; 81 tmp->stats.dam = 1;
82
84 tmp->stats.hp = tmp->stats.dam / 2; 83 tmp->stats.hp = tmp->stats.dam / 2;
84
85 if (tmp->stats.hp < 2) 85 if (tmp->stats.hp < 2)
86 tmp->stats.hp = 2; 86 tmp->stats.hp = 2;
87 tmp->x = op->x; 87
88 tmp->y = op->y; 88 tmp->insert_at (op);
89 insert_ob_in_map (tmp, op->map, NULL, 0);
90 return 1; 89 return 1;
91 } 90 }
92 91
93 ncharges = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)); 92 ncharges = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob));
93
94 if (wand->inv && wand->inv->level) 94 if (wand->inv && wand->inv->level)
95 ncharges /= wand->inv->level; 95 ncharges /= wand->inv->level;
96 else 96 else
97 { 97 {
98 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand)); 98 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand));
99 return 0; 99 return 0;
100 } 100 }
101
101 if (!ncharges) 102 if (!ncharges)
102 ncharges = 1; 103 ncharges = 1;
103 104
104 wand->stats.food += ncharges; 105 wand->stats.food += ncharges;
105 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand)); 106 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
107
106 if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE)) 108 if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE))
107 { 109 {
108 SET_FLAG (wand, FLAG_ANIMATE); 110 SET_FLAG (wand, FLAG_ANIMATE);
109 wand->speed = wand->arch->clone.speed; 111 wand->set_speed (wand->arch->speed);
110 update_ob_speed (wand);
111 } 112 }
113
112 return 1; 114 return 1;
113} 115}
114 116
115/* Create a missile (nonmagic - magic +4). Will either create bolts or arrows 117/* Create a missile (nonmagic - magic +4). Will either create bolts or arrows
116 * based on whether a crossbow or bow is equiped. If neither, it defaults to 118 * based on whether a crossbow or bow is equiped. If neither, it defaults to
… …
120 * great a plus, the default is used. 122 * great a plus, the default is used.
121 * The # of arrows created also goes up with level, so if a 30th level mage 123 * The # of arrows created also goes up with level, so if a 30th level mage
122 * wants LOTS of arrows, and doesn't care what the plus is he could 124 * wants LOTS of arrows, and doesn't care what the plus is he could
123 * create nonnmagic arrows, or even -1, etc... 125 * create nonnmagic arrows, or even -1, etc...
124 */ 126 */
125
126int 127int
127cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg) 128cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg)
128{ 129{
129 int missile_plus = 0, bonus_plus = 0; 130 int bonus_plus = 0;
130 const char *missile_name; 131 const char *missile_name = "arrow";
131 object *tmp, *missile;
132 132
133 missile_name = "arrow";
134
135 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 133 for (object *tmp = op->inv; tmp; tmp = tmp->below)
136 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED)) 134 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
137 missile_name = tmp->race; 135 missile_name = tmp->race;
138 136
139 missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell); 137 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
140 138
141 if (archetype::find (missile_name) == NULL) 139 archetype *missile_arch = archetype::find (missile_name);
140
141 if (!missile_arch)
142 { 142 {
143 LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name); 143 LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);
144 return 0; 144 return 0;
145 } 145 }
146 146
147 missile = get_archetype (missile_name); 147 object *missile = missile_arch->instance ();
148 148
149 if (stringarg) 149 if (stringarg)
150 { 150 {
151 /* If it starts with a letter, presume it is a description */ 151 /* If it starts with a letter, presume it is a description */
152 if (isalpha (*stringarg)) 152 if (isalpha (*stringarg))
153 { 153 {
154 artifact *al = find_artifactlist (missile->type)->items; 154 artifact *al = find_artifactlist (missile->type)->items;
155 155
156 for (; al != NULL; al = al->next) 156 for (; al; al = al->next)
157 if (!strcasecmp (al->item->name, stringarg)) 157 if (!strcasecmp (al->item->name, stringarg))
158 break; 158 break;
159 159
160 if (!al) 160 if (!al)
161 { 161 {
… …
170 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg); 170 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg);
171 return 0; 171 return 0;
172 } 172 }
173 173
174 give_artifact_abilities (missile, al->item); 174 give_artifact_abilities (missile, al->item);
175 /* These special arrows cost something extra. Don't have them also be magical - 175 /* These special arrows cost something extra. Don't have them also be magical -
176 * otherwise, in most cases, not enough will be created. I don't want to get into 176 * otherwise, in most cases, not enough will be created. I don't want to get into
177 * the parsing of having to do both plus and type. 177 * the parsing of having to do both plus and type.
178 */ 178 */
179 bonus_plus = 1 + (al->item->value / 5); 179 bonus_plus = 1 + (al->item->value / 5);
180 missile_plus = 0; 180 missile_plus = 0;
181 } 181 }
182 else if (atoi (stringarg) < missile_plus) 182 else if (atoi (stringarg) < missile_plus)
183 missile_plus = atoi (stringarg); 183 missile_plus = atoi (stringarg);
184 } 184 }
185 185
186 if (missile_plus > 4) 186 missile_plus = clamp (missile_plus, -4, 4);
187 missile_plus = 4;
188 else if (missile_plus < -4)
189 missile_plus = -4;
190 187
191 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell); 188 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
192 missile->nrof -= 3 * (missile_plus + bonus_plus); 189 missile->nrof -= 3 * (missile_plus + bonus_plus);
193 190
194 if (missile->nrof < 1) 191 if (missile->nrof < 1)
… …
214{ 211{
215 int food_value; 212 int food_value;
216 archetype *at = NULL; 213 archetype *at = NULL;
217 object *new_op; 214 object *new_op;
218 215
219 food_value = spell_ob->stats.food + +50 * SP_level_duration_adjust (caster, spell_ob); 216 food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);
220 217
221 if (stringarg) 218 if (stringarg)
222 { 219 {
223 at = find_archetype_by_object_type_name (FOOD, stringarg); 220 at = find_archetype_by_object_type_name (FOOD, stringarg);
224 if (at == NULL) 221 if (at == NULL)
225 at = find_archetype_by_object_type_name (DRINK, stringarg); 222 at = find_archetype_by_object_type_name (DRINK, stringarg);
226 if (at == NULL || at->clone.stats.food > food_value) 223 if (at == NULL || at->stats.food > food_value)
227 stringarg = NULL; 224 stringarg = NULL;
228 } 225 }
229 226
230 if (!stringarg) 227 if (!stringarg)
231 { 228 {
… …
237 * We don't use flesh types because the weight values of those need 234 * We don't use flesh types because the weight values of those need
238 * to be altered from the donor. 235 * to be altered from the donor.
239 */ 236 */
240 237
241 /* We assume the food items don't have multiple parts */ 238 /* We assume the food items don't have multiple parts */
242 for (at_tmp = first_archetype; at_tmp != NULL; at_tmp = at_tmp->next) 239 for_all_archetypes (at_tmp)
243 { 240 {
244 if (at_tmp->clone.type == FOOD || at_tmp->clone.type == DRINK) 241 if (at_tmp->type == FOOD || at_tmp->type == DRINK)
245 { 242 {
246 /* Basically, if the food value is something that is creatable 243 /* Basically, if the food value is something that is creatable
247 * under the limits of the spell and it is higher than 244 * under the limits of the spell and it is higher than
248 * the item we have now, take it instead. 245 * the item we have now, take it instead.
249 */ 246 */
250 if (at_tmp->clone.stats.food <= food_value && (!at || at_tmp->clone.stats.food > at->clone.stats.food)) 247 if (at_tmp->stats.food <= food_value
248 && (!at
249 || at_tmp->stats.food > at->stats.food
250 || (at_tmp->stats.food == at->stats.food
251 && at_tmp->weight < at->weight)))
251 at = at_tmp; 252 at = at_tmp;
252 } 253 }
253 } 254 }
254 } 255 }
256
255 /* Pretty unlikely (there are some very low food items), but you never 257 /* Pretty unlikely (there are some very low food items), but you never
256 * know 258 * know
257 */ 259 */
258 if (!at) 260 if (!at)
259 { 261 {
260 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food."); 262 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");
261 return 0; 263 return 0;
262 } 264 }
263 265
264 food_value /= at->clone.stats.food; 266 food_value /= at->stats.food;
265 new_op = arch_to_object (at); 267 new_op = arch_to_object (at);
266 new_op->nrof = food_value; 268 new_op->nrof = food_value;
267 269
268 new_op->value = 0; 270 new_op->value = 0;
269 if (new_op->nrof < 1) 271 if (new_op->nrof < 1)
… …
278{ 280{
279 int r, mflags, maxrange; 281 int r, mflags, maxrange;
280 object *tmp; 282 object *tmp;
281 maptile *m; 283 maptile *m;
282 284
283
284 if (!dir) 285 if (!dir)
285 { 286 {
286 examine_monster (op, op); 287 examine_monster (op, op);
287 return 1; 288 return 1;
288 } 289 }
290
289 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 291 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
290 for (r = 1; r < maxrange; r++) 292 for (r = 1; r < maxrange; r++)
291 { 293 {
292 sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir]; 294 sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];
293 295
… …
313 examine_monster (op, tmp); 315 examine_monster (op, tmp);
314 return 1; 316 return 1;
315 } 317 }
316 } 318 }
317 } 319 }
320
318 new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing."); 321 new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");
319 return 1; 322 return 1;
320} 323}
321
322 324
323/* This checks to see if 'pl' is invisible to 'mon'. 325/* This checks to see if 'pl' is invisible to 'mon'.
324 * does race check, undead check, etc 326 * does race check, undead check, etc
325 * Returns TRUE if mon can't see pl, false 327 * Returns TRUE if mon can't see pl, false
326 * otherwise. This doesn't check range, walls, etc. It 328 * otherwise. This doesn't check range, walls, etc. It
… …
328 * pl is invisible. 330 * pl is invisible.
329 */ 331 */
330int 332int
331makes_invisible_to (object *pl, object *mon) 333makes_invisible_to (object *pl, object *mon)
332{ 334{
333
334 if (!pl->invisible) 335 if (!pl->invisible)
335 return 0; 336 return 0;
337
336 if (pl->type == PLAYER) 338 if (pl->type == PLAYER)
337 { 339 {
338 /* If race isn't set, then invisible unless it is undead */ 340 /* If race isn't set, then invisible unless it is undead */
339 if (!pl->contr->invis_race) 341 if (!pl->contr->invis_race)
340 { 342 {
341 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 343 if (QUERY_FLAG (mon, FLAG_UNDEAD))
342 return 0; 344 return 0;
345
343 return 1; 346 return 1;
344 } 347 }
348
345 /* invis_race is set if we get here */ 349 /* invis_race is set if we get here */
346 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon)) 350 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon))
347 return 1; 351 return 1;
352
348 /* No race, can't be invisible to it */ 353 /* No race, can't be invisible to it */
349 if (!mon->race) 354 if (!mon->race)
350 return 0; 355 return 0;
356
351 if (strstr (mon->race, pl->contr->invis_race)) 357 if (strstr (mon->race, pl->contr->invis_race))
352 return 1; 358 return 1;
359
353 /* Nothing matched above, return 0 */ 360 /* Nothing matched above, return 0 */
354 return 0; 361 return 0;
355 } 362 }
356 else 363 else
357 { 364 {
… …
370 * normal applies. 377 * normal applies.
371 */ 378 */
372int 379int
373cast_invisible (object *op, object *caster, object *spell_ob) 380cast_invisible (object *op, object *caster, object *spell_ob)
374{ 381{
375 object *tmp;
376
377 if (op->invisible > 1000) 382 if (op->invisible > 1000)
378 { 383 {
379 new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further"); 384 new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");
380 return 0; 385 return 0;
381 } 386 }
… …
397 else 402 else
398 op->contr->tmp_invis = 1; 403 op->contr->tmp_invis = 1;
399 404
400 op->contr->hidden = 0; 405 op->contr->hidden = 0;
401 } 406 }
407
402 if (makes_invisible_to (op, op)) 408 if (makes_invisible_to (op, op))
403 new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!"); 409 new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");
404 else 410 else
405 new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!"); 411 new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!");
406 412
407 update_object (op, UP_OBJ_FACE); 413 update_object (op, UP_OBJ_CHANGE);
408 414
409 /* Only search the active objects - only these should actually do 415 /* Only search the active objects - only these should actually do
410 * harm to the player. 416 * harm to the player.
411 */ 417 */
412 for (tmp = active_objects; tmp != NULL; tmp = tmp->active_next) 418 for_all_actives (tmp)
413 if (tmp->enemy == op) 419 if (tmp->enemy == op)
414 tmp->enemy = NULL; 420 tmp->enemy = 0;
421
415 return 1; 422 return 1;
416} 423}
417 424
418/* earth to dust spell. Basically destroys earthwalls in the area. 425/* earth to dust spell. Basically destroys earthwalls in the area.
419 */ 426 */
… …
447 next = tmp->above; 454 next = tmp->above;
448 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN)) 455 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
449 hit_player (tmp, 9998, op, AT_PHYSICAL, 0); 456 hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
450 } 457 }
451 } 458 }
459
452 return 1; 460 return 1;
453} 461}
454
455 462
456void 463void
457execute_word_of_recall (object *op) 464execute_word_of_recall (object *op)
458{ 465{
459 object *wor = op; 466 if (object *pl = op->in_player ())
460 467 {
461 while (op != NULL && op->type != PLAYER) 468 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
462 op = op->env;
463
464 if (op != NULL && op->map)
465 if ((get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_CLERIC) && (!QUERY_FLAG (op, FLAG_WIZCAST)))
466 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.");
467 else 470 else
471 {
472 // remove first so we do not call update_stats
473 op->remove ();
468 enter_exit (op, wor); 474 pl->enter_exit (op);
475 }
476 }
469 477
470 wor->destroy (); 478 op->destroy ();
471} 479}
472 480
473/* Word of recall causes the player to return 'home'. 481/* Word of recall causes the player to return 'home'.
474 * we put a force into the player object, so that there is a 482 * we put a force into the player object, so that there is a
475 * time delay effect. 483 * time delay effect.
… …
494 { 502 {
495 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 503 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
496 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n"); 504 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
497 return 0; 505 return 0;
498 } 506 }
507
499 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob); 508 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);
500 if (time < 1) 509 if (time < 1)
501 time = 1; 510 time = 1;
502 511
503 /* value of speed really doesn't make much difference, as long as it is 512 /* value of speed really doesn't make much difference, as long as it is
504 * positive. Lower value may be useful so that the problem doesn't 513 * positive. Lower value may be useful so that the problem doesn't
505 * do anything really odd if it say a -1000 or something. 514 * do anything really odd if it say a -1000 or something.
506 */ 515 */
507 dummy->speed = 0.002; 516 dummy->set_speed (0.002);
508 update_ob_speed (dummy);
509 dummy->speed_left = -dummy->speed * time; 517 dummy->speed_left = -dummy->speed * time;
510 dummy->type = SPELL_EFFECT; 518 dummy->type = SPELL_EFFECT;
511 dummy->subtype = SP_WORD_OF_RECALL; 519 dummy->subtype = SP_WORD_OF_RECALL;
512 520
513 /* If we could take advantage of enter_player_savebed() here, it would be 521 /* If we could take advantage of enter_player_savebed() here, it would be
514 * nice, but until the map load fails, we can't. 522 * nice, but until the map load fails, we can't.
515 */ 523 */
516 EXIT_PATH (dummy) = op->contr->savebed_map; 524 EXIT_PATH (dummy) = op->contr->savebed_map;
517 EXIT_X (dummy) = op->contr->bed_x; 525 EXIT_X (dummy) = op->contr->bed_x;
518 EXIT_Y (dummy) = op->contr->bed_y; 526 EXIT_Y (dummy) = op->contr->bed_y;
519 527
520 (void) insert_ob_in_ob (dummy, op); 528 op->insert (dummy);
529
521 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 530 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
531
522 return 1; 532 return 1;
523} 533}
524 534
525/* cast_wonder 535/* cast_wonder
526 * wonder is really just a spell that will likely cast another 536 * wonder is really just a spell that will likely cast another
… …
559} 569}
560 570
561int 571int
562perceive_self (object *op) 572perceive_self (object *op)
563{ 573{
564 char *cp = describe_item (op, op), buf[MAX_BUF]; 574 const char *cp = describe_item (op, op);
565 archetype *at = archetype::find (ARCH_DEPLETION); 575 archetype *at = archetype::find (ARCH_DEPLETION);
566 object *tmp;
567 int i;
568 576
577 dynbuf_text buf;
578
579 if (player *pl = op->contr)
580 if (object *race = archetype::find (op->race))
581 buf << "You are a " << (pl->gender ? "female" : "male") << " " << &race->name << ".\n";
582
569 tmp = find_god (determine_god (op)); 583 if (object *god = find_god (determine_god (op)))
570 if (tmp) 584 buf << "You worship " << &god->name << ".\n";
571 new_draw_info_format (NDI_UNIQUE, 0, op, "You worship %s", &tmp->name);
572 else 585 else
573 new_draw_info (NDI_UNIQUE, 0, op, "You worship no god"); 586 buf << "You worship no god.\n";
574 587
575 tmp = present_arch_in_ob (at, op); 588 object *tmp = present_arch_in_ob (at, op);
576 589
577 if (*cp == '\0' && tmp == NULL) 590 if (*cp == '\0' && tmp == NULL)
578 new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane"); 591 buf << "You feel very mundane. ";
579 else 592 else
580 { 593 {
581 new_draw_info (NDI_UNIQUE, 0, op, "You have:"); 594 buf << "You have: " << cp << ".\n";
582 new_draw_info (NDI_UNIQUE, 0, op, cp); 595
583 if (tmp != NULL) 596 if (tmp)
584 {
585 for (i = 0; i < NUM_STATS; i++) 597 for (int i = 0; i < NUM_STATS; i++)
586 { 598 if (tmp->stats.stat (i) < 0)
587 if (get_attr_value (&tmp->stats, i) < 0) 599 buf.printf ("Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
588 {
589 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is depleted by %d", statname[i], -(get_attr_value (&tmp->stats, i)));
590 }
591 }
592 }
593 } 600 }
594 601
595 if (is_dragon_pl (op)) 602 if (is_dragon_pl (op))
596 {
597 /* now grab the 'dragon_ability'-force from the player's inventory */ 603 /* now grab the 'dragon_ability'-force from the player's inventory */
598 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 604 for (tmp = op->inv; tmp; tmp = tmp->below)
599 { 605 {
600 if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force")) 606 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
601 { 607 {
602 if (tmp->stats.exp == 0) 608 if (tmp->stats.exp == 0)
603 {
604 sprintf (buf, "Your metabolism isn't focused on anything."); 609 buf << "Your metabolism isn't focused on anything.\n";
605 }
606 else 610 else
607 {
608 sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]); 611 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
609 } 612
610 new_draw_info (NDI_UNIQUE, 0, op, buf);
611 break; 613 break;
612 } 614 }
613 } 615 }
614 }
615 return 1;
616}
617 616
618/* int cast_create_town_portal (object *op, object *caster, int dir) 617 buf << '\0'; // zero-terminate
619 *
620 * This function cast the spell of town portal for op
621 *
622 * The spell operates in two passes. During the first one a place
623 * is marked as a destination for the portal. During the second one,
624 * 2 portals are created, one in the position the player cast it and
625 * one in the destination place. The portal are synchronized and 2 forces
626 * are inserted in the player to destruct the portal next time player
627 * creates a new portal pair.
628 * This spell has a side effect that it allows people to meet each other
629 * in a permanent, private, appartements by making a town portal from it
630 * to the town or another public place. So, check if the map is unique and if
631 * so return an error
632 *
633 * Code by Tchize (david.delbecq@usa.net)
634 */
635int
636cast_create_town_portal (object *op, object *caster, object *spell, int dir)
637{
638 object *dummy, *force, *old_force, *tmp;
639 archetype *perm_portal;
640 char portal_name[1024], portal_message[1024];
641 sint16 exitx, exity;
642 maptile *exitmap;
643 int op_level;
644 618
645 /* Check to see if the map the player is currently on is a per player unique 619 new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ());
646 * map. This can be determined in that per player unique maps have the
647 * full pathname listed.
648 */
649 if (!strncmp (op->map->path, settings.localdir, strlen (settings.localdir)) && settings.create_home_portals != TRUE)
650 {
651 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You can't cast that here.\n");
652 return 0;
653 }
654
655 /* The first thing to do is to check if we have a marked destination
656 * dummy is used to make a check inventory for the force
657 */
658 dummy = arch_to_object (spell->other_arch);
659 if (dummy == NULL)
660 {
661 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
662 LOG (llevError, "object::create failed (force in cast_create_town_portal for %s!\n", &op->name);
663 return 0;
664 }
665
666 force = check_inv_recursive (op, dummy);
667
668 if (force == NULL)
669 {
670 /* Here we know there is no destination marked up.
671 * We have 2 things to do:
672 * 1. Mark the destination in the player inventory.
673 * 2. Let the player know it worked.
674 */
675 dummy->name = op->map->path;
676 EXIT_X (dummy) = op->x;
677 EXIT_Y (dummy) = op->y;
678 insert_ob_in_ob (dummy, op);
679 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.");
680 return 1;
681 }
682
683 dummy->destroy ();
684
685 /* Here we know where the town portal should go to
686 * We should kill any existing portal associated with the player.
687 * Than we should create the 2 portals.
688 * For each of them, we need:
689 * - To create the portal with the name of the player+destination map
690 * - set the owner of the town portal
691 * - To mark the position of the portal in the player's inventory
692 * for easier destruction.
693 *
694 * The mark works has follow:
695 * slaying: Existing town portal
696 * hp, sp : x & y of the associated portal
697 * name : name of the portal
698 * race : map the portal is in
699 */
700
701 /* First step: killing existing town portals */
702 dummy = get_archetype (spell->race);
703 if (dummy == NULL)
704 {
705 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
706 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
707 return 0;
708 }
709
710 perm_portal = archetype::find (spell->slaying);
711
712 /* To kill a town portal, we go trough the player's inventory,
713 * for each marked portal in player's inventory,
714 * -We try load the associated map (if impossible, consider the portal destructed)
715 * -We find any portal in the specified location.
716 * If it has the good name, we destruct it.
717 * -We destruct the force indicating that portal.
718 */
719 while ((old_force = check_inv_recursive (op, dummy)))
720 {
721 exitx = EXIT_X (old_force);
722 exity = EXIT_Y (old_force);
723 LOG (llevDebug, "Trying to kill a portal in %s (%d,%d)\n", &old_force->race, exitx, exity);
724
725 if (!strncmp (old_force->race, settings.localdir, strlen (settings.localdir)))
726 exitmap = ready_map_name (old_force->race, MAP_PLAYER_UNIQUE);
727 else
728 exitmap = ready_map_name (old_force->race, 0);
729
730 if (exitmap)
731 {
732 tmp = present_arch (perm_portal, exitmap, exitx, exity);
733 while (tmp)
734 {
735 if (tmp->name == old_force->name)
736 {
737 tmp->destroy ();
738 break;
739 }
740
741 tmp = tmp->above;
742 }
743 }
744
745 old_force->destroy ();
746 LOG (llevDebug, "\n");
747 }
748
749 dummy->destroy ();
750
751 /* Creating the portals.
752 * The very first thing to do is to ensure
753 * access to the destination map.
754 * If we can't, don't fizzle. Simply warn player.
755 * This ensure player pays his mana for the spell
756 * because HE is responsible of forgotting.
757 * 'force' is the destination of the town portal, which we got
758 * from the players inventory above.
759 */
760
761 /* Ensure exit map is loaded */
762 if (!strncmp (force->name, settings.localdir, strlen (settings.localdir)))
763 exitmap = ready_map_name (force->name, MAP_PLAYER_UNIQUE);
764 else
765 exitmap = ready_map_name (force->name, 0);
766
767 /* If we were unable to load (ex. random map deleted), warn player */
768 if (exitmap == NULL)
769 {
770 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens.\nYou can't remember where to go!?");
771 force->destroy ();
772 return 1;
773 }
774
775 op_level = caster_level (caster, spell);
776 if (op_level < 15)
777 snprintf (portal_message, 1024,
778 "\nThe air moves around you and\na huge smell of ammonia\nsurounds you as you pass\nthrough %s's tiny portal\nPouah!\n",
779 &op->name);
780 else if (op_level < 30)
781 snprintf (portal_message, 1024,
782 "\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);
783 else if (op_level < 60)
784 snprintf (portal_message, 1024, "\nA shining door opens in the air in front of you,\nshowing you the path to another place.\n");
785 else
786 snprintf (portal_message, 1024, "\nAs you walk through %s's portal, flowers come out\nfrom the ground around you.\nYou feel awed.\n",
787 &op->name);
788
789 /* Create a portal in front of player
790 * dummy contain the portal and
791 * force contain the track to kill it later
792 */
793
794 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name);
795 dummy = get_archetype (spell->slaying); /*The portal */
796 if (dummy == NULL)
797 {
798 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
799 LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
800 return 0;
801 }
802
803 EXIT_PATH (dummy) = force->name;
804 EXIT_X (dummy) = EXIT_X (force);
805 EXIT_Y (dummy) = EXIT_Y (force);
806 dummy->name = dummy->name_pl = portal_name;
807 dummy->msg = portal_message;
808 dummy->race = op->name; /*Save the owner of the portal */
809 cast_create_obj (op, caster, dummy, 0);
810
811 /* Now we need to to create a town portal marker inside the player
812 * object, so on future castings, we can know that he has an active
813 * town portal.
814 */
815 tmp = get_archetype (spell->race);
816 if (tmp == NULL)
817 {
818 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
819 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
820 return 0;
821 }
822
823 tmp->race = op->map->path;
824 tmp->name = portal_name;
825 EXIT_X (tmp) = dummy->x;
826 EXIT_Y (tmp) = dummy->y;
827 insert_ob_in_ob (tmp, op);
828
829 /* Create a portal in the destination map
830 * dummy contain the portal and
831 * force the track to kill it later
832 * the 'force' variable still contains the 'reminder' of
833 * where this portal goes to.
834 */
835 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, op->map->path);
836 dummy = get_archetype (spell->slaying); /*The portal */
837 if (dummy == NULL)
838 {
839 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
840 LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
841 return 0;
842 }
843
844 EXIT_PATH (dummy) = op->map->path;
845 EXIT_X (dummy) = op->x;
846 EXIT_Y (dummy) = op->y;
847 dummy->name = dummy->name_pl = portal_name;
848 dummy->msg = portal_message;
849 dummy->x = EXIT_X (force);
850 dummy->y = EXIT_Y (force);
851 dummy->race = op->name; /*Save the owner of the portal */
852 insert_ob_in_map (dummy, exitmap, op, 0);
853
854 /* Now we create another town portal marker that
855 * points back to the one we just made
856 */
857 tmp = get_archetype (spell->race);
858 if (tmp == NULL)
859 {
860 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
861 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
862 return 0;
863 }
864
865 tmp->race = force->name;
866 tmp->name = portal_name;
867 EXIT_X (tmp) = dummy->x;
868 EXIT_Y (tmp) = dummy->y;
869 insert_ob_in_ob (tmp, op);
870
871 /* Describe the player what happened
872 */
873 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You see air moving and showing you the way home.");
874 force->destroy ();
875 620
876 return 1; 621 return 1;
877} 622}
878 623
879/* This creates magic walls. Really, it can create most any object, 624/* This creates magic walls. Really, it can create most any object,
880 * within some reason. 625 * within some reason.
881 */ 626 */
882int 627int
883magic_wall (object *op, object *caster, int dir, object *spell_ob) 628magic_wall (object *op, object *caster, int dir, object *spell_ob)
884{ 629{
885 object *tmp, *tmp2; 630 object *tmp;
886 int i, posblocked, negblocked, maxrange; 631 int i, posblocked, negblocked, maxrange;
887 sint16 x, y; 632 sint16 x, y;
888 maptile *m; 633 maptile *m;
889 const char *name; 634 const char *name;
890 archetype *at; 635 archetype *at;
… …
923 { 668 {
924 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1); 669 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
925 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken."); 670 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
926 return 0; 671 return 0;
927 } 672 }
673
928 tmp = arch_to_object (at); 674 tmp = arch_to_object (at);
929 } 675 }
930 else 676 else
931 { 677 {
932 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name); 678 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
… …
966 */ 712 */
967 if (tmp->type != EARTHWALL) //TODO 713 if (tmp->type != EARTHWALL) //TODO
968 tmp->set_owner (op); 714 tmp->set_owner (op);
969 715
970 set_spell_skill (op, caster, spell_ob, tmp); 716 set_spell_skill (op, caster, spell_ob, tmp);
971 tmp->x = x;
972 tmp->y = y;
973 tmp->level = caster_level (caster, spell_ob) / 2; 717 tmp->level = caster_level (caster, spell_ob) / 2;
974 718
975 name = tmp->name; 719 name = tmp->name;
976 if ((tmp = insert_ob_in_map (tmp, m, op, 0)) == NULL) 720 if (!(tmp = m->insert (tmp, x, y, op)))
977 { 721 {
978 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name); 722 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
979 return 0; 723 return 0;
980 } 724 }
981 725
982 /* If this is a spellcasting wall, need to insert the spell object */ 726 /* If this is a spellcasting wall, need to insert the spell object */
983 if (tmp->other_arch && tmp->other_arch->clone.type == SPELL) 727 if (tmp->other_arch && tmp->other_arch->type == SPELL)
984 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp); 728 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
985 729
986 /* This code causes the wall to extend some distance in 730 /* This code causes the wall to extend some distance in
987 * each direction, or until an obstruction is encountered. 731 * each direction, or until an obstruction is encountered.
988 * posblocked and negblocked help determine how far the 732 * posblocked and negblocked help determine how far the
… …
1004 m = tmp->map; 748 m = tmp->map;
1005 749
1006 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) && 750 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
1007 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked) 751 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)
1008 { 752 {
1009 tmp2 = tmp->clone (); 753 object *tmp2 = tmp->clone ();
1010 tmp2->x = x; 754 m->insert (tmp2, x, y, op);
1011 tmp2->y = y; 755
1012 insert_ob_in_map (tmp2, m, op, 0);
1013 /* If this is a spellcasting wall, need to insert the spell object */ 756 /* If this is a spellcasting wall, need to insert the spell object */
1014 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 757 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1015 insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2); 758 tmp2->insert (arch_to_object (tmp2->other_arch));
1016 759
1017 } 760 }
1018 else 761 else
1019 posblocked = 1; 762 posblocked = 1;
1020 763
… …
1023 m = tmp->map; 766 m = tmp->map;
1024 767
1025 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) && 768 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
1026 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked) 769 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
1027 { 770 {
1028 tmp2 = tmp->clone (); 771 object *tmp2 = tmp->clone ();
1029 tmp2->x = x; 772 m->insert (tmp2, x, y, op);
1030 tmp2->y = y; 773
1031 insert_ob_in_map (tmp2, m, op, 0);
1032 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 774 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1033 insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2); 775 tmp2->insert (arch_to_object (tmp2->other_arch));
1034 } 776 }
1035 else 777 else
1036 negblocked = 1; 778 negblocked = 1;
1037 } 779 }
1038 780
… …
1087 { 829 {
1088 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n"); 830 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
1089 op->contr->count = 0; 831 op->contr->count = 0;
1090 return 0; 832 return 0;
1091 } 833 }
834
1092 op->contr->count = 0; 835 op->contr->count = 0;
1093 836
1094 /* Remove code that puts player on random space on maps. IMO, 837 /* Remove code that puts player on random space on maps. IMO,
1095 * a lot of maps probably have areas the player should not get to, 838 * a lot of maps probably have areas the player should not get to,
1096 * but may not be marked as NO_MAGIC (as they may be bounded 839 * but may not be marked as NO_MAGIC (as they may be bounded
… …
1145 return 0; 888 return 0;
1146 } 889 }
1147 } 890 }
1148 891
1149 /* Actually move the player now */ 892 /* Actually move the player now */
1150 op->remove (); 893 if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
1151 op->x += freearr_x[dir] * dist;
1152 op->y += freearr_y[dir] * dist;
1153 if ((op = insert_ob_in_map (op, op->map, op, 0)) == NULL)
1154 return 1; 894 return 1;
1155 895
1156 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 896 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
1157 return 1; 897 return 1;
1158} 898}
1159
1160 899
1161/* cast_heal: Heals something. 900/* cast_heal: Heals something.
1162 * op is the caster. 901 * op is the caster.
1163 * dir is the direction he is casting it in. 902 * dir is the direction he is casting it in.
1164 * spell is the spell object. 903 * spell is the spell object.
… …
1171 object *poison; 910 object *poison;
1172 int heal = 0, success = 0; 911 int heal = 0, success = 0;
1173 912
1174 tmp = find_target_for_friendly_spell (op, dir); 913 tmp = find_target_for_friendly_spell (op, dir);
1175 914
1176 if (tmp == NULL) 915 if (!tmp)
1177 return 0; 916 return 0;
1178 917
1179 /* Figure out how many hp this spell might cure. 918 /* Figure out how many hp this spell might cure.
1180 * could be zero if this spell heals effects, not damage. 919 * could be zero if this spell heals effects, not damage.
1181 */ 920 */
… …
1184 heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp; 923 heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp;
1185 924
1186 if (heal) 925 if (heal)
1187 { 926 {
1188 if (tmp->stats.hp >= tmp->stats.maxhp) 927 if (tmp->stats.hp >= tmp->stats.maxhp)
1189 {
1190 new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed."); 928 new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed.");
1191 }
1192 else 929 else
1193 { 930 {
1194 /* See how many points we actually heal. Instead of messages 931 /* See how many points we actually heal. Instead of messages
1195 * based on type of spell, we instead do messages based 932 * based on type of spell, we instead do messages based
1196 * on amount of damage healed. 933 * on amount of damage healed.
1197 */ 934 */
1198 if (heal > (tmp->stats.maxhp - tmp->stats.hp)) 935 if (heal > tmp->stats.maxhp - tmp->stats.hp)
1199 heal = tmp->stats.maxhp - tmp->stats.hp; 936 heal = tmp->stats.maxhp - tmp->stats.hp;
937
1200 tmp->stats.hp += heal; 938 tmp->stats.hp += heal;
1201 939
1202 if (tmp->stats.hp >= tmp->stats.maxhp) 940 if (tmp->stats.hp >= tmp->stats.maxhp)
1203 {
1204 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!"); 941 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
1205 }
1206 else if (heal > 50) 942 else if (heal > 50)
1207 {
1208 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!"); 943 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");
1209 }
1210 else if (heal > 25) 944 else if (heal > 25)
1211 {
1212 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close."); 945 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");
1213 }
1214 else if (heal > 10) 946 else if (heal > 10)
1215 {
1216 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade."); 947 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade.");
1217 }
1218 else 948 else
1219 {
1220 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close."); 949 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close.");
1221 } 950
1222 success = 1; 951 success = 1;
1223 } 952 }
1224 } 953 }
954
1225 if (spell->attacktype & AT_DISEASE) 955 if (spell->attacktype & AT_DISEASE)
1226 if (cure_disease (tmp, op)) 956 if (cure_disease (tmp, op, spell))
1227 success = 1; 957 success = 1;
1228 958
1229 if (spell->attacktype & AT_POISON) 959 if (spell->attacktype & AT_POISON)
1230 { 960 {
1231 at = archetype::find ("poisoning"); 961 at = archetype::find ("poisoning");
… …
1235 success = 1; 965 success = 1;
1236 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed"); 966 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
1237 poison->stats.food = 1; 967 poison->stats.food = 1;
1238 } 968 }
1239 } 969 }
970
1240 if (spell->attacktype & AT_CONFUSION) 971 if (spell->attacktype & AT_CONFUSION)
1241 { 972 {
1242 poison = present_in_ob_by_name (FORCE, "confusion", tmp); 973 poison = present_in_ob_by_name (FORCE, "confusion", tmp);
1243 if (poison) 974 if (poison)
1244 { 975 {
1245 success = 1; 976 success = 1;
1246 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 977 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
1247 poison->duration = 1; 978 poison->duration = 1;
1248 } 979 }
1249 } 980 }
981
1250 if (spell->attacktype & AT_BLIND) 982 if (spell->attacktype & AT_BLIND)
1251 { 983 {
1252 at = archetype::find ("blindness"); 984 at = archetype::find ("blindness");
1253 poison = present_arch_in_ob (at, tmp); 985 poison = present_arch_in_ob (at, tmp);
1254 if (poison) 986 if (poison)
… …
1256 success = 1; 988 success = 1;
1257 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return."); 989 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
1258 poison->stats.food = 1; 990 poison->stats.food = 1;
1259 } 991 }
1260 } 992 }
993
1261 if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp) 994 if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)
1262 { 995 {
1263 tmp->stats.sp += spell->last_sp; 996 tmp->stats.sp += spell->last_sp;
1264 if (tmp->stats.sp > tmp->stats.maxsp) 997 if (tmp->stats.sp > tmp->stats.maxsp)
1265 tmp->stats.sp = tmp->stats.maxsp; 998 tmp->stats.sp = tmp->stats.maxsp;
1266 success = 1; 999 success = 1;
1267 new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!"); 1000 new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!");
1268 } 1001 }
1002
1269 if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace) 1003 if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)
1270 { 1004 {
1271 tmp->stats.grace += spell->last_grace; 1005 tmp->stats.grace += spell->last_grace;
1272 if (tmp->stats.grace > tmp->stats.maxgrace) 1006 if (tmp->stats.grace > tmp->stats.maxgrace)
1273 tmp->stats.grace = tmp->stats.maxgrace; 1007 tmp->stats.grace = tmp->stats.maxgrace;
1274 success = 1; 1008 success = 1;
1275 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!"); 1009 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1276 } 1010 }
1011
1277 if (spell->stats.food && tmp->stats.food < 999) 1012 if (spell->stats.food && tmp->stats.food < 999)
1278 { 1013 {
1279 tmp->stats.food += spell->stats.food; 1014 tmp->stats.food += spell->stats.food;
1015
1280 if (tmp->stats.food > 999) 1016 if (tmp->stats.food > 999)
1281 tmp->stats.food = 999; 1017 tmp->stats.food = 999;
1018
1282 success = 1; 1019 success = 1;
1283 /* We could do something a bit better like the messages for healing above */ 1020 /* We could do something a bit better like the messages for healing above */
1284 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 1021 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1285 } 1022 }
1023
1286 return success; 1024 return success;
1287} 1025}
1288
1289 1026
1290/* This is used for the spells that gain stats. There are no spells 1027/* This is used for the spells that gain stats. There are no spells
1291 * right now that icnrease wis/int/pow on a temp basis, so no 1028 * right now that icnrease wis/int/pow on a temp basis, so no
1292 * good comments for those. 1029 * good comments for those.
1293 */ 1030 */
1294static const char *const no_gain_msgs[NUM_STATS] = { 1031static const char *const no_gain_msgs[NUM_STATS] = {
1295 "You grow no stronger.", 1032 "You grow no stronger.",
1296 "You grow no more agile.", 1033 "You grow no more agile.",
1297 "You don't feel any healthier.", 1034 "You don't feel any healthier.",
1298 "no wis", 1035 "You didn't grow any more intelligent.",
1036 "You do not feel any wiser.",
1037 "You don't feel any more powerful."
1299 "You are no easier to look at.", 1038 "You are no easier to look at.",
1300 "no int",
1301 "no pow"
1302}; 1039};
1303 1040
1304int 1041int
1305cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent) 1042cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1306{ 1043{
1307 object *tmp, *tmp2 = NULL;
1308 object *force = NULL; 1044 object *force = NULL;
1309 int i; 1045 int i;
1310 1046
1311 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1047 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1312 if (dir != 0) 1048 object *tmp = dir
1313 {
1314 tmp = find_target_for_friendly_spell (op, dir); 1049 ? find_target_for_friendly_spell (op, dir)
1315 } 1050 : op;
1316 else
1317 {
1318 tmp = op;
1319 }
1320 1051
1321 if (tmp == NULL) 1052 if (!tmp)
1322 return 0; 1053 return 0;
1323 1054
1324 /* If we've already got a force of this type, don't add a new one. */ 1055 /* If we've already got a force of this type, don't add a new one. */
1325 for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) 1056 for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1326 { 1057 {
1327 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY) 1058 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1328 { 1059 {
1329 if (tmp2->name == spell_ob->name) 1060 if (tmp2->name == spell_ob->name)
1330 { 1061 {
… …
1363 } 1094 }
1364 else 1095 else
1365 { 1096 {
1366 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect."); 1097 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1367 } 1098 }
1099
1368 return 1; 1100 return 1;
1369 } 1101 }
1102
1370 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1103 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1371 force->speed = 1.0; 1104 force->speed = 1.0;
1372 force->speed_left = -1.0; 1105 force->speed_left = -1.0;
1373 SET_FLAG (force, FLAG_APPLIED); 1106 SET_FLAG (force, FLAG_APPLIED);
1374 1107
… …
1380 force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob); 1113 force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);
1381 if (force->resist[i] > 100) 1114 if (force->resist[i] > 100)
1382 force->resist[i] = 100; 1115 force->resist[i] = 100;
1383 } 1116 }
1384 } 1117 }
1118
1385 if (spell_ob->stats.hp) 1119 if (spell_ob->stats.hp)
1386 force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob); 1120 force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
1387 1121
1388 if (tmp->type == PLAYER) 1122 if (tmp->type == PLAYER)
1389 { 1123 {
1390 /* Stat adjustment spells */ 1124 /* Stat adjustment spells */
1391 for (i = 0; i < NUM_STATS; i++) 1125 for (i = 0; i < NUM_STATS; i++)
1392 { 1126 {
1393 sint8 stat = get_attr_value (&spell_ob->stats, i), k, sm; 1127 if (sint8 stat = spell_ob->stats.stat (i))
1394
1395 if (stat)
1396 { 1128 {
1397 sm = 0; 1129 sint8 sm = 0;
1398 for (k = 0; k < stat; k++) 1130 for (sint8 k = 0; k < stat; k++)
1399 sm += rndm (1, 3); 1131 sm += rndm (1, 3);
1400 1132
1401 if ((get_attr_value (&tmp->stats, i) + sm) > (15 + 5 * stat)) 1133 if (tmp->stats.stat (i) + sm > 15 + 5 * stat)
1402 { 1134 sm = max (0, (15 + 5 * stat) - tmp->stats.stat (i));
1403 sm = (15 + 5 * stat) - get_attr_value (&tmp->stats, i); 1135
1404 if (sm < 0) 1136 force->stats.stat (i) = sm;
1405 sm = 0; 1137
1406 }
1407 set_attr_value (&force->stats, i, sm);
1408 if (!sm) 1138 if (!sm)
1409 new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]); 1139 new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);
1410 } 1140 }
1411 } 1141 }
1412 } 1142 }
… …
1433 force->attacktype = spell_ob->attacktype; 1163 force->attacktype = spell_ob->attacktype;
1434 1164
1435 insert_ob_in_ob (force, tmp); 1165 insert_ob_in_ob (force, tmp);
1436 change_abil (tmp, force); /* Mostly to display any messages */ 1166 change_abil (tmp, force); /* Mostly to display any messages */
1437 tmp->update_stats (); 1167 tmp->update_stats ();
1168
1438 return 1; 1169 return 1;
1439} 1170}
1440 1171
1441/* This used to be part of cast_change_ability, but it really didn't make 1172/* This used to be part of cast_change_ability, but it really didn't make
1442 * a lot of sense, since most of the values it derives are from the god 1173 * a lot of sense, since most of the values it derives are from the god
1443 * of the caster. 1174 * of the caster.
1444 */ 1175 */
1445
1446int 1176int
1447cast_bless (object *op, object *caster, object *spell_ob, int dir) 1177cast_bless (object *op, object *caster, object *spell_ob, int dir)
1448{ 1178{
1449 int i; 1179 int i;
1450 object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp; 1180 object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;
… …
1545 insert_ob_in_ob (force, tmp); 1275 insert_ob_in_ob (force, tmp);
1546 tmp->update_stats (); 1276 tmp->update_stats ();
1547 return 1; 1277 return 1;
1548} 1278}
1549 1279
1550
1551
1552/* Alchemy code by Mark Wedel 1280/* Alchemy code by Mark Wedel
1553 * 1281 *
1554 * This code adds a new spell, called alchemy. Alchemy will turn 1282 * This code adds a new spell, called alchemy. Alchemy will turn
1555 * objects to gold nuggets, the value of the gold nuggets being 1283 * objects to pyrite ("false gold"), henceforth called gold nuggets.
1556 * about 90% of that of the item itself. It uses the value of the
1557 * object before charisma adjustments, because the nuggets themselves
1558 * will be will be adjusted by charisma when sold.
1559 * 1284 *
1560 * Large nuggets are worth 25 gp each (base). You will always get 1285 * The value of the gold nuggets being about 90% of that of the item
1561 * the maximum number of large nuggets you could get. 1286 * itself. It uses the value of the object before charisma adjustments,
1562 * Small nuggets are worth 1 gp each (base). You will get from 0 1287 * because the nuggets themselves will be will be adjusted by charisma
1563 * to the max amount of small nuggets as you could get. 1288 * when sold.
1564 *
1565 * For example, if an item is worth 110 gold, you will get
1566 * 4 large nuggets, and from 0-10 small nuggets.
1567 * 1289 *
1568 * There is also a chance (1:30) that you will get nothing at all 1290 * There is also a chance (1:30) that you will get nothing at all
1569 * for the object. There is also a maximum weight that will be 1291 * for the object. There is also a maximum weight that will be
1570 * alchemied. 1292 * alchemised.
1571 */ 1293 */
1572
1573/* I didn't feel like passing these as arguements to the
1574 * two functions that need them. Real values are put in them
1575 * when the spell is cast, and these are freed when the spell
1576 * is finished.
1577 */
1578static object *small, *large;
1579
1580static void 1294static void
1581alchemy_object (object *obj, int *small_nuggets, int *large_nuggets, int *weight) 1295alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1582{ 1296{
1583 uint64 value = query_cost (obj, NULL, F_TRUE); 1297 uint64 value = query_cost (obj, NULL, F_TRUE);
1584 1298
1585 /* Give third price when we alchemy money (This should hopefully 1299 /* Give third price when we alchemy money (this should hopefully
1586 * make it so that it isn't worth it to alchemy money, sell 1300 * make it so that it isn't worth it to alchemy money, sell
1587 * the nuggets, alchemy the gold from that, etc. 1301 * the nuggets, alchemy the gold from that, etc.
1588 * Otherwise, give 9 silver on the gold for other objects, 1302 * Otherwise, give 9 silver on the gold for other objects,
1589 * so that it would still be more affordable to haul 1303 * so that it would still be more affordable to haul
1590 * the stuff back to town. 1304 * the stuff back to town.
1591 */ 1305 */
1592
1593 if (QUERY_FLAG (obj, FLAG_UNPAID)) 1306 if (QUERY_FLAG (obj, FLAG_UNPAID))
1594 value = 0; 1307 value = 0;
1595 else if (obj->type == MONEY || obj->type == GEM) 1308 else if (obj->type == MONEY || obj->type == GEM)
1596 value /= 3; 1309 value /= 3;
1597 else 1310 else
1598 value = (value * 9) / 10; 1311 value = value * 9 / 10;
1599 1312
1600 value /= 4; // fix by GHJ, don't understand, pcg
1601
1602 if ((obj->value > 0) && rndm (0, 29)) 1313 if (obj->value > 0 && rndm (0, 29))
1603 { 1314 total_value += value;
1604 int count;
1605 1315
1606 count = value / large->value;
1607 *large_nuggets += count;
1608 value -= (uint64) count *(uint64) large->value;
1609
1610 count = value / small->value;
1611 *small_nuggets += count;
1612 }
1613
1614 /* Turn 25 small nuggets into 1 large nugget. If the value
1615 * of large nuggets is not evenly divisable by the small nugget
1616 * value, take off an extra small_nugget (Assuming small_nuggets!=0)
1617 */
1618 if (*small_nuggets * small->value >= large->value)
1619 {
1620 (*large_nuggets)++;
1621 *small_nuggets -= large->value / small->value;
1622 if (*small_nuggets && large->value % small->value)
1623 (*small_nuggets)--;
1624 }
1625 weight += obj->weight; 1316 total_weight += obj->total_weight ();
1317
1626 obj->destroy (); 1318 obj->destroy ();
1627} 1319}
1628 1320
1629static void
1630update_map (object *op, maptile *m, int small_nuggets, int large_nuggets, int x, int y)
1631{
1632 object *tmp;
1633 int flag = 0;
1634
1635 /* Put any nuggets below the player, but we can only pass this
1636 * flag if we are on the same space as the player
1637 */
1638 if (x == op->x && y == op->y && op->map == m)
1639 flag = INS_BELOW_ORIGINATOR;
1640
1641 if (small_nuggets)
1642 {
1643 tmp = small->clone ();
1644 tmp->nrof = small_nuggets;
1645 tmp->x = x;
1646 tmp->y = y;
1647 insert_ob_in_map (tmp, m, op, flag);
1648 }
1649
1650 if (large_nuggets)
1651 {
1652 tmp = large->clone ();
1653 tmp->nrof = large_nuggets;
1654 tmp->x = x;
1655 tmp->y = y;
1656 insert_ob_in_map (tmp, m, op, flag);
1657 }
1658}
1659
1660int 1321int
1661alchemy (object *op, object *caster, object *spell_ob) 1322alchemy (object *op, object *caster, object *spell_ob)
1662{ 1323{
1663 int x, y, weight = 0, weight_max, large_nuggets, small_nuggets, mflags;
1664 sint16 nx, ny;
1665 object *next, *tmp;
1666 maptile *mp;
1667
1668 if (op->type != PLAYER) 1324 if (op->type != PLAYER)
1669 return 0; 1325 return 0;
1670 1326
1327 archetype *nugget[3];
1328
1329 nugget[0] = archetype::find ("pyrite3");
1330 nugget[1] = archetype::find ("pyrite2");
1331 nugget[2] = archetype::find ("pyrite");
1332
1671 /* Put a maximum weight of items that can be alchemied. Limits the power 1333 /* Put a maximum weight of items that can be alchemised. Limits the power
1672 * some, and also prevents people from alcheming every table/chair/clock 1334 * some, and also prevents people from alchemising every table/chair/clock
1673 * in sight 1335 * in sight
1674 */ 1336 */
1675 weight_max = spell_ob->duration + +SP_level_duration_adjust (caster, spell_ob); 1337 int duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1676 weight_max *= 1000; 1338 int weight_max = duration * 1000;
1677 small = get_archetype ("smallnugget"), large = get_archetype ("largenugget"); 1339 uint64 value_max = duration * 1000;
1678 1340
1341 int weight = 0;
1342
1679 for (y = op->y - 1; y <= op->y + 1; y++) 1343 for (int y = op->y - 1; y <= op->y + 1; y++)
1680 { 1344 {
1681 for (x = op->x - 1; x <= op->x + 1; x++) 1345 for (int x = op->x - 1; x <= op->x + 1; x++)
1682 { 1346 {
1347 uint64 value = 0;
1348
1683 nx = x; 1349 sint16 nx = x;
1684 ny = y; 1350 sint16 ny = y;
1685 1351
1686 mp = op->map; 1352 maptile *mp = op->map;
1687 1353
1688 mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny); 1354 int mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);
1689 1355
1690 if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC)) 1356 if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))
1691 continue; 1357 continue;
1692 1358
1693 /* Treat alchemy a little differently - most spell effects 1359 /* Treat alchemy a little differently - most spell effects
… …
1695 * ground level effect. 1361 * ground level effect.
1696 */ 1362 */
1697 if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK) 1363 if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)
1698 continue; 1364 continue;
1699 1365
1700 small_nuggets = 0; 1366 for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1701 large_nuggets = 0;
1702
1703 for (tmp = GET_MAP_OB (mp, nx, ny); tmp != NULL; tmp = next)
1704 { 1367 {
1705 next = tmp->above; 1368 next = tmp->above;
1369
1706 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) && 1370 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&
1707 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON)) 1371 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))
1708 { 1372 {
1709
1710 if (tmp->inv) 1373 if (tmp->inv)
1711 { 1374 {
1712 object *next1, *tmp1; 1375 object *next1, *tmp1;
1713 1376
1714 for (tmp1 = tmp->inv; tmp1 != NULL; tmp1 = next1) 1377 for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1715 { 1378 {
1716 next1 = tmp1->below; 1379 next1 = tmp1->below;
1717 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) && 1380 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&
1718 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON)) 1381 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))
1719 alchemy_object (tmp1, &small_nuggets, &large_nuggets, &weight); 1382 alchemy_object (tmp1, value, weight);
1720 } 1383 }
1721 } 1384 }
1385
1722 alchemy_object (tmp, &small_nuggets, &large_nuggets, &weight); 1386 alchemy_object (tmp, value, weight);
1723 1387
1724 if (weight > weight_max) 1388 if (weight > weight_max)
1725 { 1389 break;
1726 update_map (op, mp, small_nuggets, large_nuggets, nx, ny);
1727 large->destroy ();
1728 small->destroy ();
1729 return 1;
1730 } 1390 }
1731 } /* is alchemable object */
1732 } /* process all objects on this space */
1733
1734 /* Insert all the nuggets at one time. This probably saves time, but
1735 * it also prevents us from alcheming nuggets that were just created
1736 * with this spell.
1737 */ 1391 }
1738 update_map (op, mp, small_nuggets, large_nuggets, nx, ny); 1392
1393 value -= rndm (value >> 4);
1394 value = min (value, value_max);
1395
1396 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1397 if (int nrof = value / nugget [i]->value)
1398 {
1399 value -= nrof * nugget[i]->value;
1400
1401 object *tmp = arch_to_object (nugget[i]);
1402 tmp->nrof = nrof;
1403 tmp->flag [FLAG_IDENTIFIED] = true;
1404 op->map->insert (tmp, x, y, op, 0);
1739 } 1405 }
1740 }
1741 1406
1742 large->destroy (); 1407 if (weight > weight_max)
1743 small->destroy (); 1408 goto bailout;
1744 /* reset this so that if player standing on a big pile of stuff, 1409 }
1745 * it is redrawn properly. 1410 }
1746 */ 1411
1747 op->contr->ns->look_position = 0; 1412bailout:
1748 return 1; 1413 return 1;
1749} 1414}
1750 1415
1751 1416
1752/* This function removes the cursed/damned status on equipped 1417/* This function removes the cursed/damned status on equipped
… …
1779 } 1444 }
1780 1445
1781 if (op->type == PLAYER) 1446 if (op->type == PLAYER)
1782 { 1447 {
1783 if (success) 1448 if (success)
1784 {
1785 new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now."); 1449 new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");
1786 }
1787 else 1450 else
1788 { 1451 {
1789 if (was_one) 1452 if (was_one)
1790 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse."); 1453 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");
1791 else 1454 else
… …
1795 1458
1796 return success; 1459 return success;
1797} 1460}
1798 1461
1799/* Identifies objects in the players inventory/on the ground */ 1462/* Identifies objects in the players inventory/on the ground */
1800
1801int 1463int
1802cast_identify (object *op, object *caster, object *spell) 1464cast_identify (object *op, object *caster, object *spell)
1803{ 1465{
1466 dynbuf_text buf;
1804 object *tmp; 1467 object *tmp;
1805 int success = 0, num_ident;
1806 1468
1807 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1469 int num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1808 1470
1809 if (num_ident < 1) 1471 if (num_ident < 1)
1810 num_ident = 1; 1472 num_ident = 1;
1811 1473
1812 for (tmp = op->inv; tmp; tmp = tmp->below) 1474 for (tmp = op->inv; tmp; tmp = tmp->below)
… …
1815 { 1477 {
1816 identify (tmp); 1478 identify (tmp);
1817 1479
1818 if (op->type == PLAYER) 1480 if (op->type == PLAYER)
1819 { 1481 {
1820 new_draw_info_format (NDI_UNIQUE, 0, op, "You have %s.", long_desc (tmp, op)); 1482 buf.printf ("You identified: %s.\n\n", long_desc (tmp, op));
1821 1483
1822 if (tmp->msg) 1484 if (tmp->msg)
1823 { 1485 buf << "The item has a story:\n\n" << tmp->msg << "\n\n";
1824 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1825 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1826 }
1827 } 1486 }
1828 1487
1829 num_ident--; 1488 num_ident--;
1830 success = 1;
1831 if (!num_ident) 1489 if (!num_ident)
1832 break; 1490 break;
1833 } 1491 }
1834 } 1492 }
1835 1493
… …
1837 * stuff on the floor. Only identify stuff on the floor if the spell 1495 * stuff on the floor. Only identify stuff on the floor if the spell
1838 * was not fully used. 1496 * was not fully used.
1839 */ 1497 */
1840 if (num_ident) 1498 if (num_ident)
1841 { 1499 {
1842 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 1500 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1843 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1501 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1844 { 1502 {
1845 identify (tmp); 1503 identify (tmp);
1846 1504
1847 if (op->type == PLAYER) 1505 if (op->type == PLAYER)
1848 { 1506 {
1849 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op)); 1507 buf.printf ("On the ground you identified: %s.\n\n", long_desc (tmp, op));
1850 1508
1851 if (tmp->msg) 1509 if (tmp->msg)
1852 { 1510 buf << "The item has a story:\n\n" << tmp->msg << "\n\n";
1853 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1854 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1855 }
1856 1511
1857 esrv_send_item (op, tmp); 1512 esrv_send_item (op, tmp);
1858 } 1513 }
1859 1514
1860 num_ident--; 1515 num_ident--;
1861 success = 1;
1862 if (!num_ident) 1516 if (!num_ident)
1863 break; 1517 break;
1864 } 1518 }
1865 } 1519 }
1866 1520
1867 if (!success) 1521 if (buf.empty ())
1868 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified."); 1522 {
1523 op->failmsg ("You can't reach anything unidentified.");
1524 return 0;
1525 }
1869 else 1526 else
1527 {
1528 if (op->contr)
1529 op->contr->infobox (MSG_CHANNEL ("identify"), buf);
1530
1870 spell_effect (spell, op->x, op->y, op->map, op); 1531 spell_effect (spell, op->x, op->y, op->map, op);
1871 1532 return 1;
1872 return success; 1533 }
1873} 1534}
1874 1535
1875int 1536int
1876cast_detection (object *op, object *caster, object *spell, object *skill) 1537cast_detection (object *op, object *caster, object *spell, object *skill)
1877{ 1538{
… …
1998 */ 1659 */
1999 if (done_one) 1660 if (done_one)
2000 { 1661 {
2001 object *detect_ob = arch_to_object (spell->other_arch); 1662 object *detect_ob = arch_to_object (spell->other_arch);
2002 1663
2003 detect_ob->x = nx;
2004 detect_ob->y = ny;
2005 /* if this is set, we want to copy the face */ 1664 /* if this is set, we want to copy the face */
2006 if (done_one == 2 && detect) 1665 if (done_one == 2 && detect)
2007 { 1666 {
2008 detect_ob->face = detect->face; 1667 detect_ob->face = detect->face;
2009 detect_ob->animation_id = detect->animation_id; 1668 detect_ob->animation_id = detect->animation_id;
… …
2011 detect_ob->last_anim = 0; 1670 detect_ob->last_anim = 0;
2012 /* by default, the detect_ob is already animated */ 1671 /* by default, the detect_ob is already animated */
2013 if (!QUERY_FLAG (detect, FLAG_ANIMATE)) 1672 if (!QUERY_FLAG (detect, FLAG_ANIMATE))
2014 CLEAR_FLAG (detect_ob, FLAG_ANIMATE); 1673 CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
2015 } 1674 }
1675
2016 insert_ob_in_map (detect_ob, m, op, 0); 1676 m->insert (detect_ob, nx, ny, op);
2017 } 1677 }
2018 } /* for processing the surrounding spaces */ 1678 } /* for processing the surrounding spaces */
2019 1679
2020 1680
2021 /* Now process objects in the players inventory if detect curse or magic */ 1681 /* Now process objects in the players inventory if detect curse or magic */
… …
2070 1730
2071 /* Explodes a fireball centered at player */ 1731 /* Explodes a fireball centered at player */
2072 tmp = get_archetype (EXPLODING_FIREBALL); 1732 tmp = get_archetype (EXPLODING_FIREBALL);
2073 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1; 1733 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
2074 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2; 1734 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
2075 tmp->x = victim->x; 1735
2076 tmp->y = victim->y; 1736 tmp->insert_at (victim);
2077 insert_ob_in_map (tmp, victim->map, NULL, 0);
2078 victim->stats.sp = 2 * victim->stats.maxsp; 1737 victim->stats.sp = 2 * victim->stats.maxsp;
2079 } 1738 }
2080 else if (victim->stats.sp >= victim->stats.maxsp * 1.88) 1739 else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
2081 {
2082 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode."); 1740 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode.");
2083 }
2084 else if (victim->stats.sp >= victim->stats.maxsp * 1.66) 1741 else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
2085 {
2086 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!"); 1742 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
2087 }
2088 else if (victim->stats.sp >= victim->stats.maxsp * 1.5) 1743 else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
2089 { 1744 {
2090 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world."); 1745 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
2091 confuse_player (victim, victim, 99); 1746 confuse_player (victim, victim, 99);
2092 } 1747 }
2093 else if (victim->stats.sp >= victim->stats.maxsp * 1.25) 1748 else if (victim->stats.sp >= victim->stats.maxsp * 1.25)
2094 {
2095 new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices."); 1749 new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");
2096 }
2097} 1750}
2098 1751
2099/* cast_transfer 1752/* cast_transfer
2100 * This spell transfers sp from the player to another person. 1753 * This spell transfers sp from the player to another person.
2101 * We let the target go above their normal maximum SP. 1754 * We let the target go above their normal maximum SP.
… …
2212 /* Basically, if the object is magical and not counterspell, 1865 /* Basically, if the object is magical and not counterspell,
2213 * we will more or less remove the object. Don't counterspell 1866 * we will more or less remove the object. Don't counterspell
2214 * monsters either. 1867 * monsters either.
2215 */ 1868 */
2216 1869
2217 if (head->attacktype & AT_MAGIC && 1870 if (head->attacktype & AT_MAGIC
2218 !(head->attacktype & AT_COUNTERSPELL) && !QUERY_FLAG (head, FLAG_MONSTER) && (op->level > head->level)) 1871 && !(head->attacktype & AT_COUNTERSPELL)
1872 && !QUERY_FLAG (head, FLAG_MONSTER)
1873 && (op->level > head->level))
2219 head->destroy (); 1874 head->destroy ();
2220 else 1875 else
2221 switch (head->type) 1876 switch (head->type)
2222 { 1877 {
2223 case SPELL_EFFECT: 1878 case SPELL_EFFECT:
1879 // XXX: Don't affect floor spelleffects. See also XXX comment
1880 // about sanctuary in spell_util.C
1881 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1882 continue;
1883
2224 if (op->level > head->level) 1884 if (op->level > head->level)
2225 head->destroy (); 1885 head->destroy ();
2226 1886
2227 break; 1887 break;
2228 1888
… …
2295 * This code was very odd - code early on would only let players use the spell, 1955 * This code was very odd - code early on would only let players use the spell,
2296 * yet the code wass full of player checks. I've presumed that the code 1956 * yet the code wass full of player checks. I've presumed that the code
2297 * that only let players use it was correct, and removed all the other 1957 * that only let players use it was correct, and removed all the other
2298 * player checks. MSW 2003-01-06 1958 * player checks. MSW 2003-01-06
2299 */ 1959 */
2300
2301int 1960int
2302animate_weapon (object *op, object *caster, object *spell, int dir) 1961animate_weapon (object *op, object *caster, object *spell, int dir)
2303{ 1962{
2304 object *weapon, *tmp; 1963 object *weapon, *tmp;
2305 char buf[MAX_BUF]; 1964 char buf[MAX_BUF];
2306 int a, i; 1965 int a, i;
2307 sint16 x, y; 1966 sint16 x, y;
2308 maptile *m; 1967 maptile *m;
2309 materialtype_t *mt;
2310 1968
2311 if (!spell->other_arch) 1969 if (!spell->other_arch)
2312 { 1970 {
2313 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 1971 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
2314 LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name); 1972 LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);
… …
2317 /* exit if it's not a player using this spell. */ 1975 /* exit if it's not a player using this spell. */
2318 if (op->type != PLAYER) 1976 if (op->type != PLAYER)
2319 return 0; 1977 return 0;
2320 1978
2321 /* if player already has a golem, abort */ 1979 /* if player already has a golem, abort */
2322 if (op->contr->ranges[range_golem]) 1980 if (object *golem = op->contr->golem)
2323 { 1981 {
2324 control_golem (op->contr->ranges[range_golem], dir); 1982 control_golem (golem, dir);
2325 return 0; 1983 return 0;
2326 } 1984 }
2327 1985
2328 /* if no direction specified, pick one */ 1986 /* if no direction specified, pick one */
2329 if (!dir) 1987 if (!dir)
… …
2333 x = op->x + freearr_x[dir]; 1991 x = op->x + freearr_x[dir];
2334 y = op->y + freearr_y[dir]; 1992 y = op->y + freearr_y[dir];
2335 1993
2336 /* if there's no place to put the golem, abort */ 1994 /* if there's no place to put the golem, abort */
2337 if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) || 1995 if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) ||
2338 ((spell->other_arch->clone.move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->clone.move_type)) 1996 ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2339 { 1997 {
2340 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 1998 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
2341 return 0; 1999 return 0;
2342 } 2000 }
2343 2001
… …
2347 if (!weapon) 2005 if (!weapon)
2348 { 2006 {
2349 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!"); 2007 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
2350 return 0; 2008 return 0;
2351 } 2009 }
2352 if (spell->race && strcmp (weapon->arch->name, spell->race)) 2010 if (spell->race && strcmp (weapon->arch->archname, spell->race))
2353 { 2011 {
2354 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon."); 2012 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
2355 return 0; 2013 return 0;
2356 } 2014 }
2357 if (weapon->type != WEAPON) 2015 if (weapon->type != WEAPON)
… …
2375 /* create the golem object */ 2033 /* create the golem object */
2376 tmp = arch_to_object (spell->other_arch); 2034 tmp = arch_to_object (spell->other_arch);
2377 2035
2378 /* if animated by a player, give the player control of the golem */ 2036 /* if animated by a player, give the player control of the golem */
2379 CLEAR_FLAG (tmp, FLAG_MONSTER); 2037 CLEAR_FLAG (tmp, FLAG_MONSTER);
2380 SET_FLAG (tmp, FLAG_FRIENDLY);
2381 tmp->stats.exp = 0; 2038 tmp->stats.exp = 0;
2382 add_friendly_object (tmp); 2039 add_friendly_object (tmp);
2383 tmp->type = GOLEM; 2040 tmp->type = GOLEM;
2384 tmp->set_owner (op); 2041 tmp->set_owner (op);
2042 op->contr->golem = tmp;
2385 set_spell_skill (op, caster, spell, tmp); 2043 set_spell_skill (op, caster, spell, tmp);
2386 op->contr->ranges[range_golem] = tmp;
2387 op->contr->shoottype = range_golem;
2388 2044
2389 /* Give the weapon to the golem now. A bit of a hack to check the 2045 /* Give the weapon to the golem now. A bit of a hack to check the
2390 * removed flag - it should only be set if get_split_object was 2046 * removed flag - it should only be set if get_split_object was
2391 * used above. 2047 * used above.
2392 */ 2048 */
2393 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2049 if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2394 weapon->remove (); 2050 weapon->remove ();
2051
2395 insert_ob_in_ob (weapon, tmp); 2052 insert_ob_in_ob (weapon, tmp);
2396 esrv_send_item (op, weapon); 2053 esrv_send_item (op, weapon);
2397 /* To do everything necessary to let a golem use the weapon is a pain, 2054 /* To do everything necessary to let a golem use the weapon is a pain,
2398 * so instead, just set it as equipped (otherwise, we need to update 2055 * so instead, just set it as equipped (otherwise, we need to update
2399 * body_info, skills, etc) 2056 * body_info, skills, etc)
… …
2427 2084
2428 /* attacktype */ 2085 /* attacktype */
2429 if (!tmp->attacktype) 2086 if (!tmp->attacktype)
2430 tmp->attacktype = AT_PHYSICAL; 2087 tmp->attacktype = AT_PHYSICAL;
2431 2088
2432 mt = NULL;
2433 if (op->materialname != NULL)
2434 mt = name_to_material (op->materialname); 2089 if (materialtype_t *mt = name_to_material (op->materialname))
2435 if (mt != NULL)
2436 { 2090 {
2437 for (i = 0; i < NROFATTACKS; i++) 2091 for (i = 0; i < NROFATTACKS; i++)
2438 tmp->resist[i] = 50 - (mt->save[i] * 5); 2092 tmp->resist[i] = 50 - (mt->save[i] * 5);
2439 a = mt->save[0]; 2093 a = mt->save[0];
2440 } 2094 }
… …
2442 { 2096 {
2443 for (i = 0; i < NROFATTACKS; i++) 2097 for (i = 0; i < NROFATTACKS; i++)
2444 tmp->resist[i] = 5; 2098 tmp->resist[i] = 5;
2445 a = 10; 2099 a = 10;
2446 } 2100 }
2101
2447 /* Set weapon's immunity */ 2102 /* Set weapon's immunity */
2448 tmp->resist[ATNR_CONFUSION] = 100; 2103 tmp->resist[ATNR_CONFUSION] = 100;
2449 tmp->resist[ATNR_POISON] = 100; 2104 tmp->resist[ATNR_POISON] = 100;
2450 tmp->resist[ATNR_SLOW] = 100; 2105 tmp->resist[ATNR_SLOW] = 100;
2451 tmp->resist[ATNR_PARALYZE] = 100; 2106 tmp->resist[ATNR_PARALYZE] = 100;
… …
2457 2112
2458 /* Improve weapon's armour value according to best save vs. physical of its material */ 2113 /* Improve weapon's armour value according to best save vs. physical of its material */
2459 2114
2460 if (a > 14) 2115 if (a > 14)
2461 a = 14; 2116 a = 14;
2117
2462 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a)); 2118 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2463 2119
2464 /* Determine golem's speed */ 2120 /* Determine golem's speed */
2465 tmp->speed = 0.4 + 0.1 * SP_level_range_adjust (caster, spell); 2121 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2466
2467 if (tmp->speed > 3.33)
2468 tmp->speed = 3.33;
2469 2122
2470 if (!spell->race) 2123 if (!spell->race)
2471 { 2124 {
2472 sprintf (buf, "animated %s", &weapon->name); 2125 sprintf (buf, "animated %s", &weapon->name);
2473 tmp->name = buf; 2126 tmp->name = buf;
… …
2475 tmp->face = weapon->face; 2128 tmp->face = weapon->face;
2476 tmp->animation_id = weapon->animation_id; 2129 tmp->animation_id = weapon->animation_id;
2477 tmp->anim_speed = weapon->anim_speed; 2130 tmp->anim_speed = weapon->anim_speed;
2478 tmp->last_anim = weapon->last_anim; 2131 tmp->last_anim = weapon->last_anim;
2479 tmp->state = weapon->state; 2132 tmp->state = weapon->state;
2480 if (QUERY_FLAG (weapon, FLAG_ANIMATE)) 2133 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2481 {
2482 SET_FLAG (tmp, FLAG_ANIMATE);
2483 }
2484 else
2485 {
2486 CLEAR_FLAG (tmp, FLAG_ANIMATE);
2487 }
2488 update_ob_speed (tmp);
2489 } 2134 }
2490 2135
2491 /* make experience increase in proportion to the strength of the summoned creature. */ 2136 /* make experience increase in proportion to the strength of the summoned creature. */
2492 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell)); 2137 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));
2493 2138
2494 tmp->speed_left = -1; 2139 tmp->speed_left = -1;
2495 tmp->x = x;
2496 tmp->y = y;
2497 tmp->direction = dir; 2140 tmp->direction = dir;
2498 insert_ob_in_map (tmp, m, op, 0); 2141
2142 m->insert (tmp, x, y, op);
2499 return 1; 2143 return 1;
2500} 2144}
2501 2145
2502/* cast_daylight() - changes the map darkness level *lower* */ 2146/* cast_daylight() - changes the map darkness level *lower* */
2503 2147
… …
2511 int success; 2155 int success;
2512 2156
2513 if (!op->map) 2157 if (!op->map)
2514 return 0; /* shouldnt happen */ 2158 return 0; /* shouldnt happen */
2515 2159
2516 success = change_map_light (op->map, spell->stats.dam); 2160 success = op->map->change_map_light (spell->stats.dam);
2161
2517 if (!success) 2162 if (!success)
2518 { 2163 {
2519 if (spell->stats.dam < 0) 2164 if (spell->stats.dam < 0)
2520 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here."); 2165 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2521 else 2166 else
2522 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here."); 2167 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2523 } 2168 }
2524 return success; 2169 return success;
2525} 2170}
2526
2527
2528
2529
2530 2171
2531/* create an aura spell object and put it in the player's inventory. 2172/* create an aura spell object and put it in the player's inventory.
2532 * as usual, op is player, caster is the object casting the spell, 2173 * as usual, op is player, caster is the object casting the spell,
2533 * spell is the spell object itself. 2174 * spell is the spell object itself.
2534 */ 2175 */
… …
2546 2187
2547 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2188 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2548 2189
2549 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2190 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2550 2191
2551 new_aura->set_owner (op);
2552 set_spell_skill (op, caster, spell, new_aura); 2192 set_spell_skill (op, caster, spell, new_aura);
2553 new_aura->attacktype = spell->attacktype; 2193 new_aura->attacktype = spell->attacktype;
2554 2194
2555 new_aura->level = caster_level (caster, spell); 2195 new_aura->level = caster_level (caster, spell);
2196
2556 if (refresh) 2197 if (refresh)
2557 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 2198 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2558 else 2199 else
2559 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force."); 2200 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
2201
2560 insert_ob_in_ob (new_aura, op); 2202 insert_ob_in_ob (new_aura, op);
2203 new_aura->set_owner (op);
2204
2561 return 1; 2205 return 1;
2562} 2206}
2563
2564 2207
2565/* move aura function. An aura is a part of someone's inventory, 2208/* move aura function. An aura is a part of someone's inventory,
2566 * which he carries with him, but which acts on the map immediately 2209 * which he carries with him, but which acts on the map immediately
2567 * around him. 2210 * around him.
2568 * Aura parameters: 2211 * Aura parameters:
2569 * duration: duration counter. 2212 * duration: duration counter.
2570 * attacktype: aura's attacktype 2213 * attacktype: aura's attacktype
2571 * other_arch: archetype to drop where we attack 2214 * other_arch: archetype to drop where we attack
2572 */ 2215 */
2573
2574void 2216void
2575move_aura (object *aura) 2217move_aura (object *aura)
2576{ 2218{
2577 int i, mflags;
2578 object *env;
2579 maptile *m;
2580
2581 /* auras belong in inventories */ 2219 /* auras belong in inventories */
2582 env = aura->env; 2220 object *env = aura->env;
2221 object *owner = aura->owner;
2583 2222
2584 /* no matter what we've gotta remove the aura... 2223 /* no matter what we've gotta remove the aura...
2585 * we'll put it back if its time isn't up. 2224 * we'll put it back if its time isn't up.
2586 */ 2225 */
2587 aura->remove (); 2226 aura->remove ();
… …
2592 aura->destroy (); 2231 aura->destroy ();
2593 return; 2232 return;
2594 } 2233 }
2595 2234
2596 /* auras only exist in inventories */ 2235 /* auras only exist in inventories */
2597 if (env == NULL || env->map == NULL) 2236 if (!env || !env->map)
2598 { 2237 {
2599 aura->destroy (); 2238 aura->destroy ();
2600 return; 2239 return;
2601 } 2240 }
2602
2603 aura->x = env->x;
2604 aura->y = env->y;
2605 2241
2606 /* we need to jump out of the inventory for a bit 2242 /* we need to jump out of the inventory for a bit
2607 * in order to hit the map conveniently. 2243 * in order to hit the map conveniently.
2608 */ 2244 */
2609 insert_ob_in_map (aura, env->map, aura, 0); 2245 aura->insert_at (env, aura);
2610 2246
2611 for (i = 1; i < 9; i++) 2247 for (int i = 1; i < 9; i++)
2612 { 2248 {
2613 sint16 nx, ny; 2249 mapxy pos (env);
2250 pos.move (i);
2614 2251
2615 nx = aura->x + freearr_x[i];
2616 ny = aura->y + freearr_y[i];
2617 mflags = get_map_flags (env->map, &m, nx, ny, &nx, &ny);
2618
2619 /* Consider the movement tyep of the person with the aura as 2252 /* Consider the movement type of the person with the aura as
2620 * movement type of the aura. Eg, if the player is flying, the aura 2253 * movement type of the aura. Eg, if the player is flying, the aura
2621 * is flying also, if player is walking, it is on the ground, etc. 2254 * is flying also, if player is walking, it is on the ground, etc.
2622 */ 2255 */
2623 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny)))) 2256 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2624 { 2257 {
2625 hit_map (aura, i, aura->attacktype, 0); 2258 hit_map (aura, i, aura->attacktype, 0);
2626 2259
2627 if (aura->other_arch) 2260 if (aura->other_arch)
2628 {
2629 object *new_ob;
2630
2631 new_ob = arch_to_object (aura->other_arch); 2261 pos.insert (arch_to_object (aura->other_arch), aura);
2632 new_ob->x = nx;
2633 new_ob->y = ny;
2634 insert_ob_in_map (new_ob, m, aura, 0);
2635 } 2262 }
2636 }
2637 } 2263 }
2264
2638 /* put the aura back in the player's inventory */ 2265 /* put the aura back in the player's inventory */
2639 aura->remove (); 2266 env->insert (aura);
2640 insert_ob_in_ob (aura, env); 2267 aura->set_owner (owner);
2641} 2268}
2642 2269
2643/* moves the peacemaker spell. 2270/* moves the peacemaker spell.
2644 * op is the piece object. 2271 * op is the piece object.
2645 */ 2272 */
2646
2647void 2273void
2648move_peacemaker (object *op) 2274move_peacemaker (object *op)
2649{ 2275{
2650 object *tmp; 2276 object *tmp;
2651 2277
… …
2723 2349
2724 snprintf (rune, sizeof (rune), "%s\n", msg); 2350 snprintf (rune, sizeof (rune), "%s\n", msg);
2725 2351
2726 tmp->race = op->name; /*Save the owner of the rune */ 2352 tmp->race = op->name; /*Save the owner of the rune */
2727 tmp->msg = rune; 2353 tmp->msg = rune;
2728 tmp->x = op->x; 2354
2729 tmp->y = op->y; 2355 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2730 insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
2731 return 1; 2356 return 1;
2732} 2357}

Diff Legend

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