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.10 by root, Thu Sep 14 21:16:13 2006 UTC vs.
Revision 1.39 by root, Wed Feb 7 23:43:01 2007 UTC

1
2/* 1/*
3 * static char *rcsid_spell_effect_c = 2 * CrossFire, A Multiplayer game for X-windows
4 * "$Id: spell_effect.C,v 1.10 2006/09/14 21:16:13 root Exp $"; 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team
6 * Copyright (C) 1992 Frank Tore Johansen
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 *
22 * The authors can be reached via e-mail at <crossfire@schmorp.de>
5 */ 23 */
6
7
8/*
9 CrossFire, A Multiplayer game for X-windows
10
11 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
12 Copyright (C) 1992 Frank Tore Johansen
13
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
18
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
23
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27
28 The authors can be reached via e-mail at crossfire-devel@real-time.com
29*/
30 24
31#include <global.h> 25#include <global.h>
32#include <object.h> 26#include <object.h>
33#include <living.h> 27#include <living.h>
34#ifndef __CEXTRACT__
35# include <sproto.h> 28#include <sproto.h>
36#endif
37#include <spells.h> 29#include <spells.h>
38#include <sounds.h> 30#include <sounds.h>
39 31
40/* cast_magic_storm: This is really used mostly for spell 32/* cast_magic_storm: This is really used mostly for spell
41 * fumbles at the like. tmp is the object to propogate. 33 * fumbles at the like. tmp is the object to propogate.
… …
44void 36void
45cast_magic_storm (object *op, object *tmp, int lvl) 37cast_magic_storm (object *op, object *tmp, int lvl)
46{ 38{
47 if (!tmp) 39 if (!tmp)
48 return; /* error */ 40 return; /* error */
41
49 tmp->level = op->level; 42 tmp->level = op->level;
50 tmp->x = op->x;
51 tmp->y = op->y;
52 tmp->range += lvl / 5; /* increase the area of destruction */ 43 tmp->range += lvl / 5; /* increase the area of destruction */
53 tmp->duration += lvl / 5; 44 tmp->duration += lvl / 5;
54 45
55 /* Put a cap on duration for this - if the player fails in their 46 /* Put a cap on duration for this - if the player fails in their
56 * apartment, don't want it to go on so long that it kills them 47 * apartment, don't want it to go on so long that it kills them
57 * multiple times. Also, damge already increases with level, 48 * multiple times. Also, damge already increases with level,
58 * so don't really need to increase the duration as much either. 49 * so don't really need to increase the duration as much either.
59 */ 50 */
60 if (tmp->duration >= 40) 51 if (tmp->duration >= 40)
61 tmp->duration = 40; 52 tmp->duration = 40;
53
62 tmp->stats.dam = lvl; /* nasty recoils! */ 54 tmp->stats.dam = lvl; /* nasty recoils! */
63 tmp->stats.maxhp = tmp->count; /* tract single parent */ 55 tmp->stats.maxhp = tmp->count; /* tract single parent */
64 insert_ob_in_map (tmp, op->map, op, 0);
65 56
57 tmp->insert_at (op, op);
66} 58}
67
68 59
69int 60int
70recharge (object *op, object *caster, object *spell_ob) 61recharge (object *op, object *caster, object *spell_ob)
71{ 62{
72 object *wand, *tmp; 63 object *wand, *tmp;
… …
81 if (!(random_roll (0, 3, op, PREFER_HIGH))) 72 if (!(random_roll (0, 3, op, PREFER_HIGH)))
82 { 73 {
83 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand)); 74 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));
84 play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE); 75 play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE);
85 esrv_del_item (op->contr, wand->count); 76 esrv_del_item (op->contr, wand->count);
86 remove_ob (wand); 77 wand->destroy ();
87 free_object (wand);
88 tmp = get_archetype ("fireball"); 78 tmp = get_archetype ("fireball");
89 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10; 79 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
80
90 if (!tmp->stats.dam) 81 if (!tmp->stats.dam)
91 tmp->stats.dam = 1; 82 tmp->stats.dam = 1;
83
92 tmp->stats.hp = tmp->stats.dam / 2; 84 tmp->stats.hp = tmp->stats.dam / 2;
85
93 if (tmp->stats.hp < 2) 86 if (tmp->stats.hp < 2)
94 tmp->stats.hp = 2; 87 tmp->stats.hp = 2;
95 tmp->x = op->x; 88
96 tmp->y = op->y; 89 tmp->insert_at (op);
97 insert_ob_in_map (tmp, op->map, NULL, 0);
98 return 1; 90 return 1;
99 } 91 }
100 92
101 ncharges = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)); 93 ncharges = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob));
94
102 if (wand->inv && wand->inv->level) 95 if (wand->inv && wand->inv->level)
103 ncharges /= wand->inv->level; 96 ncharges /= wand->inv->level;
104 else 97 else
105 { 98 {
106 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand)); 99 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand));
107 return 0; 100 return 0;
108 } 101 }
102
109 if (!ncharges) 103 if (!ncharges)
110 ncharges = 1; 104 ncharges = 1;
111 105
112 wand->stats.food += ncharges; 106 wand->stats.food += ncharges;
113 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand)); 107 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
108
114 if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE)) 109 if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE))
115 { 110 {
116 SET_FLAG (wand, FLAG_ANIMATE); 111 SET_FLAG (wand, FLAG_ANIMATE);
117 wand->speed = wand->arch->clone.speed; 112 wand->set_speed (wand->arch->clone.speed);
118 update_ob_speed (wand);
119 } 113 }
114
120 return 1; 115 return 1;
121} 116}
122 117
123/* Create a missile (nonmagic - magic +4). Will either create bolts or arrows 118/* Create a missile (nonmagic - magic +4). Will either create bolts or arrows
124 * based on whether a crossbow or bow is equiped. If neither, it defaults to 119 * based on whether a crossbow or bow is equiped. If neither, it defaults to
… …
135cast_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 *stringarg)
136{ 131{
137 int missile_plus = 0, bonus_plus = 0; 132 int missile_plus = 0, bonus_plus = 0;
138 const char *missile_name; 133 const char *missile_name;
139 object *tmp, *missile; 134 object *tmp, *missile;
140 tag_t tag;
141 135
142 missile_name = "arrow"; 136 missile_name = "arrow";
143 137
144 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 138 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
145 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED)) 139 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
146 {
147 missile_name = tmp->race; 140 missile_name = tmp->race;
148 }
149 141
150 missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell); 142 missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
151 143
152 if (archetype::find (missile_name) == NULL) 144 if (archetype::find (missile_name) == NULL)
153 { 145 {
154 LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name); 146 LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);
155 return 0; 147 return 0;
156 } 148 }
149
157 missile = get_archetype (missile_name); 150 missile = get_archetype (missile_name);
158 151
159 if (stringarg) 152 if (stringarg)
160 { 153 {
161 /* If it starts with a letter, presume it is a description */ 154 /* If it starts with a letter, presume it is a description */
… …
167 if (!strcasecmp (al->item->name, stringarg)) 160 if (!strcasecmp (al->item->name, stringarg))
168 break; 161 break;
169 162
170 if (!al) 163 if (!al)
171 { 164 {
172 free_object (missile); 165 missile->destroy ();
173 new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, stringarg); 166 new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, stringarg);
174 return 0; 167 return 0;
175 } 168 }
169
176 if (al->item->slaying) 170 if (al->item->slaying)
177 { 171 {
178 free_object (missile); 172 missile->destroy ();
179 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg); 173 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg);
180 return 0; 174 return 0;
181 } 175 }
176
182 give_artifact_abilities (missile, al->item); 177 give_artifact_abilities (missile, al->item);
183 /* These special arrows cost something extra. Don't have them also be magical - 178 /* These special arrows cost something extra. Don't have them also be magical -
184 * otherwise, in most cases, not enough will be created. I don't want to get into 179 * otherwise, in most cases, not enough will be created. I don't want to get into
185 * the parsing of having to do both plus and type. 180 * the parsing of having to do both plus and type.
186 */ 181 */
… …
188 missile_plus = 0; 183 missile_plus = 0;
189 } 184 }
190 else if (atoi (stringarg) < missile_plus) 185 else if (atoi (stringarg) < missile_plus)
191 missile_plus = atoi (stringarg); 186 missile_plus = atoi (stringarg);
192 } 187 }
188
193 if (missile_plus > 4) 189 if (missile_plus > 4)
194 missile_plus = 4; 190 missile_plus = 4;
195 else if (missile_plus < -4) 191 else if (missile_plus < -4)
196 missile_plus = -4; 192 missile_plus = -4;
197 193
198 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell); 194 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
199 missile->nrof -= 3 * (missile_plus + bonus_plus); 195 missile->nrof -= 3 * (missile_plus + bonus_plus);
196
200 if (missile->nrof < 1) 197 if (missile->nrof < 1)
201 missile->nrof = 1; 198 missile->nrof = 1;
202 199
203 missile->magic = missile_plus; 200 missile->magic = missile_plus;
204 /* Can't get any money for these objects */ 201 /* Can't get any money for these objects */
205 missile->value = 0; 202 missile->value = 0;
206 203
207 SET_FLAG (missile, FLAG_IDENTIFIED); 204 SET_FLAG (missile, FLAG_IDENTIFIED);
208 tag = missile->count;
209 205
210 if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !was_destroyed (missile, tag)) 206 if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !missile->destroyed ())
211 {
212 pick_up (op, missile); 207 pick_up (op, missile);
213 } 208
214 return 1; 209 return 1;
215} 210}
216 211
217 212
218/* allows the choice of what sort of food object to make. 213/* allows the choice of what sort of food object to make.
… …
284int 279int
285probe (object *op, object *caster, object *spell_ob, int dir) 280probe (object *op, object *caster, object *spell_ob, int dir)
286{ 281{
287 int r, mflags, maxrange; 282 int r, mflags, maxrange;
288 object *tmp; 283 object *tmp;
289 mapstruct *m; 284 maptile *m;
290 285
291 286
292 if (!dir) 287 if (!dir)
293 { 288 {
294 examine_monster (op, op); 289 examine_monster (op, op);
… …
310 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic."); 305 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
311 return 0; 306 return 0;
312 } 307 }
313 if (mflags & P_IS_ALIVE) 308 if (mflags & P_IS_ALIVE)
314 { 309 {
315 for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = tmp->above) 310 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above)
316 if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER))) 311 if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))
317 { 312 {
318 new_draw_info (NDI_UNIQUE, 0, op, "You detect something."); 313 new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
319 if (tmp->head != NULL) 314 if (tmp->head != NULL)
320 tmp = tmp->head; 315 tmp = tmp->head;
… …
415 update_object (op, UP_OBJ_FACE); 410 update_object (op, UP_OBJ_FACE);
416 411
417 /* Only search the active objects - only these should actually do 412 /* Only search the active objects - only these should actually do
418 * harm to the player. 413 * harm to the player.
419 */ 414 */
420 for (tmp = active_objects; tmp != NULL; tmp = tmp->active_next) 415 for_all_actives (tmp)
421 if (tmp->enemy == op) 416 if (tmp->enemy == op)
422 tmp->enemy = NULL; 417 tmp->enemy = 0;
418
423 return 1; 419 return 1;
424} 420}
425 421
426/* earth to dust spell. Basically destroys earthwalls in the area. 422/* earth to dust spell. Basically destroys earthwalls in the area.
427 */ 423 */
… …
429cast_earth_to_dust (object *op, object *caster, object *spell_ob) 425cast_earth_to_dust (object *op, object *caster, object *spell_ob)
430{ 426{
431 object *tmp, *next; 427 object *tmp, *next;
432 int range, i, j, mflags; 428 int range, i, j, mflags;
433 sint16 sx, sy; 429 sint16 sx, sy;
434 mapstruct *m; 430 maptile *m;
435 431
436 if (op->type != PLAYER) 432 if (op->type != PLAYER)
437 return 0; 433 return 0;
438 434
439 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 435 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
… …
448 444
449 if (mflags & P_OUT_OF_MAP) 445 if (mflags & P_OUT_OF_MAP)
450 continue; 446 continue;
451 447
452 // earth to dust tears down everything that can be teared down 448 // earth to dust tears down everything that can be teared down
453 for (tmp = get_map_ob (m, sx, sy); tmp != NULL; tmp = next) 449 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)
454 { 450 {
455 next = tmp->above; 451 next = tmp->above;
456 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN)) 452 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
457 hit_player (tmp, 9998, op, AT_PHYSICAL, 0); 453 hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
458 } 454 }
459 } 455 }
456
460 return 1; 457 return 1;
461} 458}
462
463 459
464void 460void
465execute_word_of_recall (object *op) 461execute_word_of_recall (object *op)
466{ 462{
467 object *wor = op; 463 if (object *pl = op->in_player ())
468
469 while (op != NULL && op->type != PLAYER)
470 op = op->env;
471
472 if (op != NULL && op->map)
473 { 464 {
474 if ((get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_CLERIC) && (!QUERY_FLAG (op, FLAG_WIZCAST))) 465 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
475 new_draw_info (NDI_UNIQUE, 0, op, "You feel something fizzle inside you."); 466 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
476 else 467 else
468 {
469 // remove first so we do not call update_stats
470 op->remove ();
477 enter_exit (op, wor); 471 pl->enter_exit (op);
472 }
478 } 473 }
479 remove_ob (wor); 474
480 free_object (wor); 475 op->destroy ();
481} 476}
482 477
483/* Word of recall causes the player to return 'home'. 478/* Word of recall causes the player to return 'home'.
484 * we put a force into the player object, so that there is a 479 * we put a force into the player object, so that there is a
485 * time delay effect. 480 * time delay effect.
… …
504 { 499 {
505 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 500 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
506 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n"); 501 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
507 return 0; 502 return 0;
508 } 503 }
504
509 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob); 505 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);
510 if (time < 1) 506 if (time < 1)
511 time = 1; 507 time = 1;
512 508
513 /* value of speed really doesn't make much difference, as long as it is 509 /* value of speed really doesn't make much difference, as long as it is
514 * positive. Lower value may be useful so that the problem doesn't 510 * positive. Lower value may be useful so that the problem doesn't
515 * do anything really odd if it say a -1000 or something. 511 * do anything really odd if it say a -1000 or something.
516 */ 512 */
517 dummy->speed = 0.002; 513 dummy->set_speed (0.002);
518 update_ob_speed (dummy);
519 dummy->speed_left = -dummy->speed * time; 514 dummy->speed_left = -dummy->speed * time;
520 dummy->type = SPELL_EFFECT; 515 dummy->type = SPELL_EFFECT;
521 dummy->subtype = SP_WORD_OF_RECALL; 516 dummy->subtype = SP_WORD_OF_RECALL;
522 517
523 /* If we could take advantage of enter_player_savebed() here, it would be 518 /* If we could take advantage of enter_player_savebed() here, it would be
524 * nice, but until the map load fails, we can't. 519 * nice, but until the map load fails, we can't.
525 */ 520 */
526 EXIT_PATH (dummy) = op->contr->savebed_map; 521 EXIT_PATH (dummy) = op->contr->savebed_map;
527 EXIT_X (dummy) = op->contr->bed_x; 522 EXIT_X (dummy) = op->contr->bed_x;
528 EXIT_Y (dummy) = op->contr->bed_y; 523 EXIT_Y (dummy) = op->contr->bed_y;
529 524
530 (void) insert_ob_in_ob (dummy, op); 525 op->insert (dummy);
526
531 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 527 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
528
532 return 1; 529 return 1;
533} 530}
534 531
535/* cast_wonder 532/* cast_wonder
536 * wonder is really just a spell that will likely cast another 533 * wonder is really just a spell that will likely cast another
… …
565 } 562 }
566 return cast_spell (op, caster, dir, newspell, NULL); 563 return cast_spell (op, caster, dir, newspell, NULL);
567 } 564 }
568 return 1; 565 return 1;
569} 566}
570
571 567
572int 568int
573perceive_self (object *op) 569perceive_self (object *op)
574{ 570{
575 char *cp = describe_item (op, op), buf[MAX_BUF]; 571 char *cp = describe_item (op, op), buf[MAX_BUF];
… …
609 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 605 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
610 { 606 {
611 if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force")) 607 if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force"))
612 { 608 {
613 if (tmp->stats.exp == 0) 609 if (tmp->stats.exp == 0)
614 {
615 sprintf (buf, "Your metabolism isn't focused on anything."); 610 sprintf (buf, "Your metabolism isn't focused on anything.");
616 }
617 else 611 else
618 {
619 sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]); 612 sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]);
620 } 613
621 new_draw_info (NDI_UNIQUE, 0, op, buf); 614 new_draw_info (NDI_UNIQUE, 0, op, buf);
622 break; 615 break;
623 } 616 }
624 } 617 }
625 } 618 }
619
626 return 1; 620 return 1;
627} 621}
628 622
629/* int cast_create_town_portal (object *op, object *caster, int dir) 623/* int cast_create_town_portal (object *op, object *caster, int dir)
630 * 624 *
… …
644 * Code by Tchize (david.delbecq@usa.net) 638 * Code by Tchize (david.delbecq@usa.net)
645 */ 639 */
646int 640int
647cast_create_town_portal (object *op, object *caster, object *spell, int dir) 641cast_create_town_portal (object *op, object *caster, object *spell, int dir)
648{ 642{
649 object *dummy, *force, *old_force, *tmp; 643 object *dummy, *force, *old_force;
650 archetype *perm_portal; 644 archetype *perm_portal;
651 char portal_name[1024], portal_message[1024]; 645 char portal_name[1024], portal_message[1024];
652 sint16 exitx, exity;
653 mapstruct *exitmap; 646 maptile *exitmap;
654 int op_level; 647 int op_level;
655
656 648
657 /* Check to see if the map the player is currently on is a per player unique 649 /* Check to see if the map the player is currently on is a per player unique
658 * map. This can be determined in that per player unique maps have the 650 * map. This can be determined in that per player unique maps have the
659 * full pathname listed. 651 * full pathname listed.
660 */ 652 */
… …
669 */ 661 */
670 dummy = arch_to_object (spell->other_arch); 662 dummy = arch_to_object (spell->other_arch);
671 if (dummy == NULL) 663 if (dummy == NULL)
672 { 664 {
673 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 665 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
674 LOG (llevError, "get_object failed (force in cast_create_town_portal for %s!\n", &op->name); 666 LOG (llevError, "object::create failed (force in cast_create_town_portal for %s!\n", &op->name);
675 return 0; 667 return 0;
676 } 668 }
669
677 force = check_inv_recursive (op, dummy); 670 force = check_inv_recursive (op, dummy);
678 671
679 if (force == NULL) 672 if (force == NULL)
680 { 673 {
681 /* Here we know there is no destination marked up. 674 /* Here we know there is no destination marked up.
… …
688 EXIT_Y (dummy) = op->y; 681 EXIT_Y (dummy) = op->y;
689 insert_ob_in_ob (dummy, op); 682 insert_ob_in_ob (dummy, op);
690 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."); 683 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.");
691 return 1; 684 return 1;
692 } 685 }
693 free_object (dummy); 686
687 dummy->destroy ();
694 688
695 /* Here we know where the town portal should go to 689 /* Here we know where the town portal should go to
696 * We should kill any existing portal associated with the player. 690 * We should kill any existing portal associated with the player.
697 * Than we should create the 2 portals. 691 * Than we should create the 2 portals.
698 * For each of them, we need: 692 * For each of them, we need:
… …
711 /* First step: killing existing town portals */ 705 /* First step: killing existing town portals */
712 dummy = get_archetype (spell->race); 706 dummy = get_archetype (spell->race);
713 if (dummy == NULL) 707 if (dummy == NULL)
714 { 708 {
715 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 709 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
716 LOG (llevError, "get_object failed (force) in cast_create_town_portal for %s!\n", &op->name); 710 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
717 return 0; 711 return 0;
718 } 712 }
713
719 perm_portal = archetype::find (spell->slaying); 714 perm_portal = archetype::find (spell->slaying);
720 715
721 /* To kill a town portal, we go trough the player's inventory, 716 /* To kill a town portal, we go trough the player's inventory,
722 * for each marked portal in player's inventory, 717 * for each marked portal in player's inventory,
723 * -We try load the associated map (if impossible, consider the portal destructed) 718 * -We try load the associated map (if impossible, consider the portal destructed)
… …
725 * If it has the good name, we destruct it. 720 * If it has the good name, we destruct it.
726 * -We destruct the force indicating that portal. 721 * -We destruct the force indicating that portal.
727 */ 722 */
728 while ((old_force = check_inv_recursive (op, dummy))) 723 while ((old_force = check_inv_recursive (op, dummy)))
729 { 724 {
730 exitx = EXIT_X (old_force); 725 exitmap = maptile::find_sync (old_force->race, op->map);
731 exity = EXIT_Y (old_force);
732 LOG (llevDebug, "Trying to kill a portal in %s (%d,%d)\n", &old_force->race, exitx, exity);
733
734 if (!strncmp (old_force->race, settings.localdir, strlen (settings.localdir)))
735 exitmap = ready_map_name (old_force->race, MAP_PLAYER_UNIQUE);
736 else
737 exitmap = ready_map_name (old_force->race, 0);
738 726
739 if (exitmap) 727 if (exitmap)
740 { 728 {
729 exitmap->load_sync ();
730
731 int exitx = EXIT_X (old_force);
732 int exity = EXIT_Y (old_force);
733
741 tmp = present_arch (perm_portal, exitmap, exitx, exity); 734 for (object *tmp = present_arch (perm_portal, exitmap, exitx, exity); tmp; tmp = tmp->above)
742 while (tmp)
743 { 735 {
744 if (tmp->name == old_force->name) 736 if (tmp->name == old_force->name)
745 { 737 {
746 remove_ob (tmp); 738 tmp->destroy ();
747 free_object (tmp);
748 break; 739 break;
749 } 740 }
750 else
751 {
752 tmp = tmp->above;
753 }
754 } 741 }
755 } 742 }
756 remove_ob (old_force); 743
757 free_object (old_force); 744 old_force->destroy ();
758 LOG (llevDebug, "\n");
759 } 745 }
760 free_object (dummy); 746
747 dummy->destroy ();
761 748
762 /* Creating the portals. 749 /* Creating the portals.
763 * The very first thing to do is to ensure 750 * The very first thing to do is to ensure
764 * access to the destination map. 751 * access to the destination map.
765 * If we can't, don't fizzle. Simply warn player. 752 * If we can't, don't fizzle. Simply warn player.
… …
768 * 'force' is the destination of the town portal, which we got 755 * 'force' is the destination of the town portal, which we got
769 * from the players inventory above. 756 * from the players inventory above.
770 */ 757 */
771 758
772 /* Ensure exit map is loaded */ 759 /* Ensure exit map is loaded */
773 if (!strncmp (force->name, settings.localdir, strlen (settings.localdir))) 760 exitmap = maptile::find_sync (force->name);
774 exitmap = ready_map_name (force->name, MAP_PLAYER_UNIQUE);
775 else
776 exitmap = ready_map_name (force->name, 0);
777 761
778 /* If we were unable to load (ex. random map deleted), warn player */ 762 /* If we were unable to load (ex. random map deleted), warn player */
779 if (exitmap == NULL) 763 if (!exitmap)
780 { 764 {
781 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens.\nYou can't remember where to go!?"); 765 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens.\nYou can't remember where to go!?");
782 remove_ob (force); 766 force->destroy ();
783 free_object (force);
784 return 1; 767 return 1;
785 } 768 }
769
770 exitmap->load_sync ();
786 771
787 op_level = caster_level (caster, spell); 772 op_level = caster_level (caster, spell);
788 if (op_level < 15) 773 if (op_level < 15)
789 snprintf (portal_message, 1024, 774 snprintf (portal_message, 1024,
790 "\nThe air moves around you and\na huge smell of ammonia\nsurounds you as you pass\nthrough %s's tiny portal\nPouah!\n", 775 "\nThe air moves around you and\na huge smell of ammonia\nsurounds you as you pass\nthrough %s's tiny portal\nPouah!\n",
… …
800 785
801 /* Create a portal in front of player 786 /* Create a portal in front of player
802 * dummy contain the portal and 787 * dummy contain the portal and
803 * force contain the track to kill it later 788 * force contain the track to kill it later
804 */ 789 */
805
806 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name); 790 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name);
807 dummy = get_archetype (spell->slaying); /*The portal */ 791 dummy = get_archetype (spell->slaying); /*The portal */
808 if (dummy == NULL) 792 if (dummy == NULL)
809 { 793 {
810 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 794 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
811 LOG (llevError, "get_object failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name); 795 LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
812 return 0; 796 return 0;
813 } 797 }
798
814 EXIT_PATH (dummy) = force->name; 799 EXIT_PATH (dummy) = force->name;
815 EXIT_X (dummy) = EXIT_X (force); 800 EXIT_X (dummy) = EXIT_X (force);
816 EXIT_Y (dummy) = EXIT_Y (force); 801 EXIT_Y (dummy) = EXIT_Y (force);
817 dummy->name = dummy->name_pl = portal_name; 802 dummy->name = dummy->name_pl = portal_name;
818 dummy->msg = portal_message; 803 dummy->msg = portal_message;
… …
821 806
822 /* Now we need to to create a town portal marker inside the player 807 /* Now we need to to create a town portal marker inside the player
823 * object, so on future castings, we can know that he has an active 808 * object, so on future castings, we can know that he has an active
824 * town portal. 809 * town portal.
825 */ 810 */
826 tmp = get_archetype (spell->race); 811 object *tmp = get_archetype (spell->race);
827 if (tmp == NULL) 812
813 if (!tmp)
828 { 814 {
829 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 815 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
830 LOG (llevError, "get_object failed (force) in cast_create_town_portal for %s!\n", &op->name); 816 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
831 return 0; 817 return 0;
832 } 818 }
819
833 tmp->race = op->map->path; 820 tmp->race = op->map->path;
834 tmp->name = portal_name; 821 tmp->name = portal_name;
835 EXIT_X (tmp) = dummy->x; 822 EXIT_X (tmp) = dummy->x;
836 EXIT_Y (tmp) = dummy->y; 823 EXIT_Y (tmp) = dummy->y;
837 insert_ob_in_ob (tmp, op); 824 op->insert (tmp);
838 825
839 /* Create a portal in the destination map 826 /* Create a portal in the destination map
840 * dummy contain the portal and 827 * dummy contain the portal and
841 * force the track to kill it later 828 * force the track to kill it later
842 * the 'force' variable still contains the 'reminder' of 829 * the 'force' variable still contains the 'reminder' of
843 * where this portal goes to. 830 * where this portal goes to.
844 */ 831 */
845 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, op->map->path); 832 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &op->map->path);
846 dummy = get_archetype (spell->slaying); /*The portal */ 833 dummy = get_archetype (spell->slaying); /*The portal */
847 if (dummy == NULL) 834 if (dummy == NULL)
848 { 835 {
849 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 836 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
850 LOG (llevError, "get_object failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name); 837 LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
851 return 0; 838 return 0;
852 } 839 }
840
853 EXIT_PATH (dummy) = op->map->path; 841 EXIT_PATH (dummy) = op->map->path;
854 EXIT_X (dummy) = op->x; 842 EXIT_X (dummy) = op->x;
855 EXIT_Y (dummy) = op->y; 843 EXIT_Y (dummy) = op->y;
856 dummy->name = dummy->name_pl = portal_name; 844 dummy->name = dummy->name_pl = portal_name;
857 dummy->msg = portal_message; 845 dummy->msg = portal_message;
858 dummy->x = EXIT_X (force);
859 dummy->y = EXIT_Y (force);
860 dummy->race = op->name; /*Save the owner of the portal */ 846 dummy->race = op->name; /*Save the owner of the portal */
861 insert_ob_in_map (dummy, exitmap, op, 0); 847 exitmap->insert (dummy, EXIT_X (force), EXIT_Y (force), op);
862 848
863 /* Now we create another town portal marker that 849 /* Now we create another town portal marker that
864 * points back to the one we just made 850 * points back to the one we just made
865 */ 851 */
866 tmp = get_archetype (spell->race); 852 tmp = get_archetype (spell->race);
867 if (tmp == NULL) 853 if (tmp == NULL)
868 { 854 {
869 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 855 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
870 LOG (llevError, "get_object failed (force) in cast_create_town_portal for %s!\n", &op->name); 856 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
871 return 0; 857 return 0;
872 } 858 }
859
873 tmp->race = force->name; 860 tmp->race = force->name;
874 tmp->name = portal_name; 861 tmp->name = portal_name;
875 EXIT_X (tmp) = dummy->x; 862 EXIT_X (tmp) = dummy->x;
876 EXIT_Y (tmp) = dummy->y; 863 EXIT_Y (tmp) = dummy->y;
877 insert_ob_in_ob (tmp, op); 864 insert_ob_in_ob (tmp, op);
878 865
879 /* Describe the player what happened 866 /* Describe the player what happened
880 */ 867 */
881 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You see air moving and showing you the way home."); 868 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You see air moving and showing you the way home.");
882 remove_ob (force); /* Delete the force inside the player */ 869 force->destroy ();
883 free_object (force); 870
884 return 1; 871 return 1;
885} 872}
886
887 873
888/* This creates magic walls. Really, it can create most any object, 874/* This creates magic walls. Really, it can create most any object,
889 * within some reason. 875 * within some reason.
890 */ 876 */
891
892int 877int
893magic_wall (object *op, object *caster, int dir, object *spell_ob) 878magic_wall (object *op, object *caster, int dir, object *spell_ob)
894{ 879{
895 object *tmp, *tmp2; 880 object *tmp;
896 int i, posblocked, negblocked, maxrange; 881 int i, posblocked, negblocked, maxrange;
897 sint16 x, y; 882 sint16 x, y;
898 mapstruct *m; 883 maptile *m;
899 const char *name; 884 const char *name;
900 archetype *at; 885 archetype *at;
901 886
902 if (!dir) 887 if (!dir)
903 { 888 {
… …
908 else 893 else
909 { 894 {
910 x = op->x + freearr_x[dir]; 895 x = op->x + freearr_x[dir];
911 y = op->y + freearr_y[dir]; 896 y = op->y + freearr_y[dir];
912 } 897 }
898
913 m = op->map; 899 m = op->map;
914 900
915 if ((spell_ob->move_block || x != op->x || y != op->y) && 901 if ((spell_ob->move_block || x != op->x || y != op->y) &&
916 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) || 902 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) ||
917 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block))) 903 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))
918 { 904 {
919 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 905 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
920 return 0; 906 return 0;
921 } 907 }
908
922 if (spell_ob->other_arch) 909 if (spell_ob->other_arch)
923 {
924 tmp = arch_to_object (spell_ob->other_arch); 910 tmp = arch_to_object (spell_ob->other_arch);
925 }
926 else if (spell_ob->race) 911 else if (spell_ob->race)
927 { 912 {
928 char buf1[MAX_BUF]; 913 char buf1[MAX_BUF];
929 914
930 sprintf (buf1, spell_ob->race, dir); 915 sprintf (buf1, spell_ob->race, dir);
… …
933 { 918 {
934 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1); 919 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
935 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken."); 920 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
936 return 0; 921 return 0;
937 } 922 }
923
938 tmp = arch_to_object (at); 924 tmp = arch_to_object (at);
939 } 925 }
940 else 926 else
941 { 927 {
942 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name); 928 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
… …
952 } 938 }
953 else if (QUERY_FLAG (tmp, FLAG_ALIVE)) 939 else if (QUERY_FLAG (tmp, FLAG_ALIVE))
954 { 940 {
955 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 941 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
956 tmp->stats.maxhp = tmp->stats.hp; 942 tmp->stats.maxhp = tmp->stats.hp;
957 set_owner (tmp, op);
958 set_spell_skill (op, caster, spell_ob, tmp);
959 } 943 }
944
960 if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP)) 945 if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP))
961 { 946 {
962 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 947 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
963 SET_FLAG (tmp, FLAG_IS_USED_UP); 948 SET_FLAG (tmp, FLAG_IS_USED_UP);
964 } 949 }
950
965 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN)) 951 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN))
966 { 952 {
967 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 953 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
968 tmp->stats.maxhp = tmp->stats.hp; 954 tmp->stats.maxhp = tmp->stats.hp;
969 SET_FLAG (tmp, FLAG_TEAR_DOWN); 955 SET_FLAG (tmp, FLAG_TEAR_DOWN);
970 SET_FLAG (tmp, FLAG_ALIVE); 956 SET_FLAG (tmp, FLAG_ALIVE);
971 } 957 }
972 958
973 /* This can't really hurt - if the object doesn't kill anything, 959 /* This can't really hurt - if the object doesn't kill anything,
974 * these fields just won't be used. 960 * these fields just won't be used. Do not set the owner for
961 * earthwalls, though, so they survive restarts.
975 */ 962 */
976 set_owner (tmp, op); 963 if (tmp->type != EARTHWALL) //TODO
964 tmp->set_owner (op);
965
977 set_spell_skill (op, caster, spell_ob, tmp); 966 set_spell_skill (op, caster, spell_ob, tmp);
978 tmp->x = x;
979 tmp->y = y;
980 tmp->level = caster_level (caster, spell_ob) / 2; 967 tmp->level = caster_level (caster, spell_ob) / 2;
981 968
982 name = tmp->name; 969 name = tmp->name;
983 if ((tmp = insert_ob_in_map (tmp, m, op, 0)) == NULL) 970 if (!(tmp = m->insert (tmp, x, y, op)))
984 { 971 {
985 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name); 972 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
986 return 0; 973 return 0;
987 } 974 }
975
988 /* If this is a spellcasting wall, need to insert the spell object */ 976 /* If this is a spellcasting wall, need to insert the spell object */
989 if (tmp->other_arch && tmp->other_arch->clone.type == SPELL) 977 if (tmp->other_arch && tmp->other_arch->clone.type == SPELL)
990 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp); 978 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
991 979
992 /* This code causes the wall to extend some distance in 980 /* This code causes the wall to extend some distance in
… …
1010 m = tmp->map; 998 m = tmp->map;
1011 999
1012 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) && 1000 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
1013 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked) 1001 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)
1014 { 1002 {
1015 tmp2 = get_object (); 1003 object *tmp2 = tmp->clone ();
1016 copy_object (tmp, tmp2); 1004 m->insert (tmp2, x, y, op);
1017 tmp2->x = x; 1005
1018 tmp2->y = y;
1019 insert_ob_in_map (tmp2, m, op, 0);
1020 /* If this is a spellcasting wall, need to insert the spell object */ 1006 /* If this is a spellcasting wall, need to insert the spell object */
1021 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 1007 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)
1022 insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2); 1008 tmp2->insert (arch_to_object (tmp2->other_arch));
1023 1009
1024 } 1010 }
1025 else 1011 else
1026 posblocked = 1; 1012 posblocked = 1;
1027 1013
… …
1030 m = tmp->map; 1016 m = tmp->map;
1031 1017
1032 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) && 1018 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
1033 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked) 1019 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
1034 { 1020 {
1035 tmp2 = get_object (); 1021 object *tmp2 = tmp->clone ();
1036 copy_object (tmp, tmp2); 1022 m->insert (tmp2, x, y, op);
1037 tmp2->x = x; 1023
1038 tmp2->y = y;
1039 insert_ob_in_map (tmp2, m, op, 0);
1040 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 1024 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)
1041 insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2); 1025 tmp2->insert (arch_to_object (tmp2->other_arch));
1042 } 1026 }
1043 else 1027 else
1044 negblocked = 1; 1028 negblocked = 1;
1045 } 1029 }
1046 1030
… …
1053int 1037int
1054dimension_door (object *op, object *caster, object *spob, int dir) 1038dimension_door (object *op, object *caster, object *spob, int dir)
1055{ 1039{
1056 uint32 dist, maxdist; 1040 uint32 dist, maxdist;
1057 int mflags; 1041 int mflags;
1058 mapstruct *m; 1042 maptile *m;
1059 sint16 sx, sy; 1043 sint16 sx, sy;
1060 1044
1061 if (op->type != PLAYER) 1045 if (op->type != PLAYER)
1062 return 0; 1046 return 0;
1063 1047
… …
1095 { 1079 {
1096 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n"); 1080 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
1097 op->contr->count = 0; 1081 op->contr->count = 0;
1098 return 0; 1082 return 0;
1099 } 1083 }
1084
1100 op->contr->count = 0; 1085 op->contr->count = 0;
1101 1086
1102 /* Remove code that puts player on random space on maps. IMO, 1087 /* Remove code that puts player on random space on maps. IMO,
1103 * a lot of maps probably have areas the player should not get to, 1088 * a lot of maps probably have areas the player should not get to,
1104 * but may not be marked as NO_MAGIC (as they may be bounded 1089 * but may not be marked as NO_MAGIC (as they may be bounded
… …
1153 return 0; 1138 return 0;
1154 } 1139 }
1155 } 1140 }
1156 1141
1157 /* Actually move the player now */ 1142 /* Actually move the player now */
1158 remove_ob (op); 1143 if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
1159 op->x += freearr_x[dir] * dist;
1160 op->y += freearr_y[dir] * dist;
1161 if ((op = insert_ob_in_map (op, op->map, op, 0)) == NULL)
1162 return 1; 1144 return 1;
1163 1145
1164 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 1146 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
1165 return 1; 1147 return 1;
1166} 1148}
… …
1310}; 1292};
1311 1293
1312int 1294int
1313cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent) 1295cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1314{ 1296{
1315 object *tmp, *tmp2 = NULL;
1316 object *force = NULL; 1297 object *force = NULL;
1317 int i; 1298 int i;
1318 1299
1319 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1300 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1320 if (dir != 0) 1301 object *tmp = dir
1321 {
1322 tmp = find_target_for_friendly_spell (op, dir); 1302 ? find_target_for_friendly_spell (op, dir)
1323 } 1303 : op;
1324 else
1325 {
1326 tmp = op;
1327 }
1328 1304
1329 if (tmp == NULL) 1305 if (!tmp)
1330 return 0; 1306 return 0;
1331 1307
1332 /* If we've already got a force of this type, don't add a new one. */ 1308 /* If we've already got a force of this type, don't add a new one. */
1333 for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) 1309 for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1334 { 1310 {
1335 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY) 1311 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1336 { 1312 {
1337 if (tmp2->name == spell_ob->name) 1313 if (tmp2->name == spell_ob->name)
1338 { 1314 {
… …
1440 force->stats.ac = spell_ob->stats.ac; 1416 force->stats.ac = spell_ob->stats.ac;
1441 force->attacktype = spell_ob->attacktype; 1417 force->attacktype = spell_ob->attacktype;
1442 1418
1443 insert_ob_in_ob (force, tmp); 1419 insert_ob_in_ob (force, tmp);
1444 change_abil (tmp, force); /* Mostly to display any messages */ 1420 change_abil (tmp, force); /* Mostly to display any messages */
1445 fix_player (tmp); 1421 tmp->update_stats ();
1446 return 1; 1422 return 1;
1447} 1423}
1448 1424
1449/* This used to be part of cast_change_ability, but it really didn't make 1425/* This used to be part of cast_change_ability, but it really didn't make
1450 * a lot of sense, since most of the values it derives are from the god 1426 * a lot of sense, since most of the values it derives are from the god
… …
1549 force->stats.wc = spell_ob->stats.wc; 1525 force->stats.wc = spell_ob->stats.wc;
1550 force->stats.ac = spell_ob->stats.ac; 1526 force->stats.ac = spell_ob->stats.ac;
1551 1527
1552 change_abil (tmp, force); /* Mostly to display any messages */ 1528 change_abil (tmp, force); /* Mostly to display any messages */
1553 insert_ob_in_ob (force, tmp); 1529 insert_ob_in_ob (force, tmp);
1554 fix_player (tmp); 1530 tmp->update_stats ();
1555 return 1; 1531 return 1;
1556} 1532}
1557
1558
1559 1533
1560/* Alchemy code by Mark Wedel 1534/* Alchemy code by Mark Wedel
1561 * 1535 *
1562 * This code adds a new spell, called alchemy. Alchemy will turn 1536 * This code adds a new spell, called alchemy. Alchemy will turn
1563 * objects to gold nuggets, the value of the gold nuggets being 1537 * objects to gold nuggets, the value of the gold nuggets being
… …
1573 * For example, if an item is worth 110 gold, you will get 1547 * For example, if an item is worth 110 gold, you will get
1574 * 4 large nuggets, and from 0-10 small nuggets. 1548 * 4 large nuggets, and from 0-10 small nuggets.
1575 * 1549 *
1576 * There is also a chance (1:30) that you will get nothing at all 1550 * There is also a chance (1:30) that you will get nothing at all
1577 * for the object. There is also a maximum weight that will be 1551 * for the object. There is also a maximum weight that will be
1578 * alchemied. 1552 * alchemised.
1579 */ 1553 */
1580
1581/* I didn't feel like passing these as arguements to the
1582 * two functions that need them. Real values are put in them
1583 * when the spell is cast, and these are freed when the spell
1584 * is finished.
1585 */
1586static object *small, *large;
1587
1588static void 1554static void
1589alchemy_object (object *obj, int *small_nuggets, int *large_nuggets, int *weight) 1555alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1590{ 1556{
1591 uint64 value = query_cost (obj, NULL, F_TRUE); 1557 uint64 value = query_cost (obj, NULL, F_TRUE);
1592 1558
1593 /* Give third price when we alchemy money (This should hopefully 1559 /* Give third price when we alchemy money (This should hopefully
1594 * make it so that it isn't worth it to alchemy money, sell 1560 * make it so that it isn't worth it to alchemy money, sell
1595 * the nuggets, alchemy the gold from that, etc. 1561 * the nuggets, alchemy the gold from that, etc.
1596 * Otherwise, give 9 silver on the gold for other objects, 1562 * Otherwise, give 9 silver on the gold for other objects,
1597 * so that it would still be more affordable to haul 1563 * so that it would still be more affordable to haul
1598 * the stuff back to town. 1564 * the stuff back to town.
1599 */ 1565 */
1600
1601 if (QUERY_FLAG (obj, FLAG_UNPAID)) 1566 if (QUERY_FLAG (obj, FLAG_UNPAID))
1602 value = 0; 1567 value = 0;
1603 else if (obj->type == MONEY || obj->type == GEM) 1568 else if (obj->type == MONEY || obj->type == GEM)
1604 value /= 3; 1569 value /= 3;
1605 else 1570 else
1606 value = (value * 9) / 10; 1571 value = value * 9 / 10;
1607 1572
1608 value /= 4; // fix by GHJ, don't understand, pcg
1609
1610 if ((obj->value > 0) && rndm (0, 29)) 1573 if (obj->value > 0 && rndm (0, 29))
1611 { 1574 total_value += value;
1612 int count;
1613 1575
1614 count = value / large->value;
1615 *large_nuggets += count;
1616 value -= (uint64) count *(uint64) large->value;
1617
1618 count = value / small->value;
1619 *small_nuggets += count;
1620 }
1621
1622 /* Turn 25 small nuggets into 1 large nugget. If the value
1623 * of large nuggets is not evenly divisable by the small nugget
1624 * value, take off an extra small_nugget (Assuming small_nuggets!=0)
1625 */
1626 if (*small_nuggets * small->value >= large->value)
1627 {
1628 (*large_nuggets)++;
1629 *small_nuggets -= large->value / small->value;
1630 if (*small_nuggets && large->value % small->value)
1631 (*small_nuggets)--;
1632 }
1633 weight += obj->weight; 1576 total_weight += obj->total_weight ();
1634 remove_ob (obj); 1577
1635 free_object (obj); 1578 obj->destroy ();
1636} 1579}
1637 1580
1638static void 1581static void
1639update_map (object *op, mapstruct *m, int small_nuggets, int large_nuggets, int x, int y) 1582update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1640{ 1583{
1641 object *tmp;
1642 int flag = 0; 1584 int flag = 0;
1643 1585
1644 /* Put any nuggets below the player, but we can only pass this 1586 /* Put any nuggets below the player, but we can only pass this
1645 * flag if we are on the same space as the player 1587 * flag if we are on the same space as the player
1646 */ 1588 */
1647 if (x == op->x && y == op->y && op->map == m) 1589 if (x == op->x && y == op->y && op->map == m)
1648 flag = INS_BELOW_ORIGINATOR; 1590 flag = INS_BELOW_ORIGINATOR;
1649 1591
1650 if (small_nuggets) 1592 if (small_nuggets)
1651 { 1593 {
1652 tmp = get_object (); 1594 object *tmp = small->clone ();
1653 copy_object (small, tmp);
1654 tmp->nrof = small_nuggets; 1595 tmp->nrof = small_nuggets;
1655 tmp->x = x;
1656 tmp->y = y;
1657 insert_ob_in_map (tmp, m, op, flag); 1596 m->insert (tmp, x, y, op, flag);
1658 } 1597 }
1598
1659 if (large_nuggets) 1599 if (large_nuggets)
1660 { 1600 {
1661 tmp = get_object (); 1601 object *tmp = large->clone ();
1662 copy_object (large, tmp);
1663 tmp->nrof = large_nuggets; 1602 tmp->nrof = large_nuggets;
1664 tmp->x = x;
1665 tmp->y = y;
1666 insert_ob_in_map (tmp, m, op, flag); 1603 m->insert (tmp, x, y, op, flag);
1667 } 1604 }
1605
1606 if (object *pl = m->at (x, y).player ())
1607 if (pl->contr->ns)
1608 pl->contr->ns->look_position = 0;
1668} 1609}
1669 1610
1670int 1611int
1671alchemy (object *op, object *caster, object *spell_ob) 1612alchemy (object *op, object *caster, object *spell_ob)
1672{ 1613{
1673 int x, y, weight = 0, weight_max, large_nuggets, small_nuggets, mflags;
1674 sint16 nx, ny;
1675 object *next, *tmp;
1676 mapstruct *mp;
1677
1678 if (op->type != PLAYER) 1614 if (op->type != PLAYER)
1679 return 0; 1615 return 0;
1680 1616
1617 object *large = get_archetype ("largenugget");
1618 object *small = get_archetype ("smallnugget");
1619
1681 /* Put a maximum weight of items that can be alchemied. Limits the power 1620 /* Put a maximum weight of items that can be alchemised. Limits the power
1682 * some, and also prevents people from alcheming every table/chair/clock 1621 * some, and also prevents people from alchemising every table/chair/clock
1683 * in sight 1622 * in sight
1684 */ 1623 */
1685 weight_max = spell_ob->duration + +SP_level_duration_adjust (caster, spell_ob); 1624 int duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1686 weight_max *= 1000; 1625 int weight_max = duration * 1000;
1687 small = get_archetype ("smallnugget"), large = get_archetype ("largenugget"); 1626 uint64 value_max = duration * 1000;
1688 1627
1628 int weight = 0;
1629
1689 for (y = op->y - 1; y <= op->y + 1; y++) 1630 for (int y = op->y - 1; y <= op->y + 1; y++)
1690 { 1631 {
1691 for (x = op->x - 1; x <= op->x + 1; x++) 1632 for (int x = op->x - 1; x <= op->x + 1; x++)
1692 { 1633 {
1634 uint64 value = 0;
1635
1693 nx = x; 1636 sint16 nx = x;
1694 ny = y; 1637 sint16 ny = y;
1695 1638
1696 mp = op->map; 1639 maptile *mp = op->map;
1697 1640
1698 mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny); 1641 int mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);
1699 1642
1700 if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC)) 1643 if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))
1701 continue; 1644 continue;
1702 1645
1703 /* Treat alchemy a little differently - most spell effects 1646 /* Treat alchemy a little differently - most spell effects
… …
1705 * ground level effect. 1648 * ground level effect.
1706 */ 1649 */
1707 if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK) 1650 if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)
1708 continue; 1651 continue;
1709 1652
1710 small_nuggets = 0; 1653 for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1711 large_nuggets = 0;
1712
1713 for (tmp = get_map_ob (mp, nx, ny); tmp != NULL; tmp = next)
1714 { 1654 {
1715 next = tmp->above; 1655 next = tmp->above;
1656
1716 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) && 1657 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&
1717 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON)) 1658 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))
1718 { 1659 {
1719
1720 if (tmp->inv) 1660 if (tmp->inv)
1721 { 1661 {
1722 object *next1, *tmp1; 1662 object *next1, *tmp1;
1723 1663
1724 for (tmp1 = tmp->inv; tmp1 != NULL; tmp1 = next1) 1664 for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1725 { 1665 {
1726 next1 = tmp1->below; 1666 next1 = tmp1->below;
1727 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) && 1667 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&
1728 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON)) 1668 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))
1729 alchemy_object (tmp1, &small_nuggets, &large_nuggets, &weight); 1669 alchemy_object (tmp1, value, weight);
1730 } 1670 }
1731 } 1671 }
1672
1732 alchemy_object (tmp, &small_nuggets, &large_nuggets, &weight); 1673 alchemy_object (tmp, value, weight);
1733 1674
1734 if (weight > weight_max) 1675 if (weight > weight_max)
1735 { 1676 break;
1736 update_map (op, mp, small_nuggets, large_nuggets, nx, ny);
1737 free_object (large);
1738 free_object (small);
1739 return 1;
1740 } 1677 }
1741 } /* is alchemable object */ 1678 }
1742 } /* process all objects on this space */ 1679
1680 value = min (value, value_max);
1681
1682 uint64 count = value / large->value;
1683 int large_nuggets = count;
1684 value -= count * large->value;
1685
1686 count = value / small->value;
1687 int small_nuggets = count;
1743 1688
1744 /* Insert all the nuggets at one time. This probably saves time, but 1689 /* Insert all the nuggets at one time. This probably saves time, but
1745 * it also prevents us from alcheming nuggets that were just created 1690 * it also prevents us from alcheming nuggets that were just created
1746 * with this spell. 1691 * with this spell.
1747 */ 1692 */
1748 update_map (op, mp, small_nuggets, large_nuggets, nx, ny); 1693 update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny);
1694
1695 if (weight > weight_max)
1696 goto bailout;
1749 } 1697 }
1750 } 1698 }
1751 free_object (large); 1699
1752 free_object (small); 1700bailout:
1753 /* reset this so that if player standing on a big pile of stuff, 1701 large->destroy ();
1754 * it is redrawn properly. 1702 small->destroy ();
1755 */
1756 op->contr->socket.look_position = 0;
1757 return 1; 1703 return 1;
1758} 1704}
1759 1705
1760 1706
1761/* This function removes the cursed/damned status on equipped 1707/* This function removes the cursed/damned status on equipped
… …
1770 for (tmp = op->inv; tmp; tmp = tmp->below) 1716 for (tmp = op->inv; tmp; tmp = tmp->below)
1771 if (QUERY_FLAG (tmp, FLAG_APPLIED) && 1717 if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
1772 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) || 1718 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1773 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED)))) 1719 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1774 { 1720 {
1775
1776 was_one++; 1721 was_one++;
1777 if (tmp->level <= caster_level (caster, spell)) 1722 if (tmp->level <= caster_level (caster, spell))
1778 { 1723 {
1779 success++; 1724 success++;
1780 if (QUERY_FLAG (spell, FLAG_DAMNED)) 1725 if (QUERY_FLAG (spell, FLAG_DAMNED))
… …
1789 } 1734 }
1790 1735
1791 if (op->type == PLAYER) 1736 if (op->type == PLAYER)
1792 { 1737 {
1793 if (success) 1738 if (success)
1794 {
1795 new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now."); 1739 new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");
1796 }
1797 else 1740 else
1798 { 1741 {
1799 if (was_one) 1742 if (was_one)
1800 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse."); 1743 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");
1801 else 1744 else
1802 new_draw_info (NDI_UNIQUE, 0, op, "You are not using any cursed items."); 1745 new_draw_info (NDI_UNIQUE, 0, op, "You are not using any cursed items.");
1803 } 1746 }
1804 } 1747 }
1748
1805 return success; 1749 return success;
1806} 1750}
1807 1751
1808/* Identifies objects in the players inventory/on the ground */ 1752/* Identifies objects in the players inventory/on the ground */
1809 1753
… …
1816 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1760 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1817 1761
1818 if (num_ident < 1) 1762 if (num_ident < 1)
1819 num_ident = 1; 1763 num_ident = 1;
1820 1764
1821
1822 for (tmp = op->inv; tmp; tmp = tmp->below) 1765 for (tmp = op->inv; tmp; tmp = tmp->below)
1823 { 1766 {
1824 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1767 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1825 { 1768 {
1826 identify (tmp); 1769 identify (tmp);
1770
1827 if (op->type == PLAYER) 1771 if (op->type == PLAYER)
1828 { 1772 {
1829 new_draw_info_format (NDI_UNIQUE, 0, op, "You have %s.", long_desc (tmp, op)); 1773 new_draw_info_format (NDI_UNIQUE, 0, op, "You have %s.", long_desc (tmp, op));
1774
1830 if (tmp->msg) 1775 if (tmp->msg)
1831 { 1776 {
1832 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:"); 1777 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1833 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg); 1778 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1834 } 1779 }
1835 } 1780 }
1781
1836 num_ident--; 1782 num_ident--;
1837 success = 1; 1783 success = 1;
1838 if (!num_ident) 1784 if (!num_ident)
1839 break; 1785 break;
1840 } 1786 }
1841 } 1787 }
1788
1842 /* If all the power of the spell has been used up, don't go and identify 1789 /* If all the power of the spell has been used up, don't go and identify
1843 * stuff on the floor. Only identify stuff on the floor if the spell 1790 * stuff on the floor. Only identify stuff on the floor if the spell
1844 * was not fully used. 1791 * was not fully used.
1845 */ 1792 */
1846 if (num_ident) 1793 if (num_ident)
1847 { 1794 {
1848 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 1795 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1849 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1796 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1850 { 1797 {
1851
1852 identify (tmp); 1798 identify (tmp);
1799
1853 if (op->type == PLAYER) 1800 if (op->type == PLAYER)
1854 { 1801 {
1855 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op)); 1802 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op));
1803
1856 if (tmp->msg) 1804 if (tmp->msg)
1857 { 1805 {
1858 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:"); 1806 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1859 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg); 1807 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1860 } 1808 }
1809
1861 esrv_send_item (op, tmp); 1810 esrv_send_item (op, tmp);
1862 } 1811 }
1812
1863 num_ident--; 1813 num_ident--;
1864 success = 1; 1814 success = 1;
1865 if (!num_ident) 1815 if (!num_ident)
1866 break; 1816 break;
1867 } 1817 }
1868 } 1818 }
1819
1869 if (!success) 1820 if (!success)
1870 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified."); 1821 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified.");
1871 else 1822 else
1872 {
1873 spell_effect (spell, op->x, op->y, op->map, op); 1823 spell_effect (spell, op->x, op->y, op->map, op);
1874 } 1824
1875 return success; 1825 return success;
1876} 1826}
1877
1878 1827
1879int 1828int
1880cast_detection (object *op, object *caster, object *spell, object *skill) 1829cast_detection (object *op, object *caster, object *spell, object *skill)
1881{ 1830{
1882 object *tmp, *last, *god, *detect; 1831 object *tmp, *last, *god, *detect;
1883 int done_one, range, mflags, floor, level; 1832 int done_one, range, mflags, floor, level;
1884 sint16 x, y, nx, ny; 1833 sint16 x, y, nx, ny;
1885 mapstruct *m; 1834 maptile *m;
1886 1835
1887 /* We precompute some values here so that we don't have to keep 1836 /* We precompute some values here so that we don't have to keep
1888 * doing it over and over again. 1837 * doing it over and over again.
1889 */ 1838 */
1890 god = find_god (determine_god (op)); 1839 god = find_god (determine_god (op));
… …
1895 skill = caster; 1844 skill = caster;
1896 1845
1897 for (x = op->x - range; x <= op->x + range; x++) 1846 for (x = op->x - range; x <= op->x + range; x++)
1898 for (y = op->y - range; y <= op->y + range; y++) 1847 for (y = op->y - range; y <= op->y + range; y++)
1899 { 1848 {
1900
1901 m = op->map; 1849 m = op->map;
1902 mflags = get_map_flags (m, &m, x, y, &nx, &ny); 1850 mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1903 if (mflags & P_OUT_OF_MAP) 1851 if (mflags & P_OUT_OF_MAP)
1904 continue; 1852 continue;
1905 1853
… …
1907 * floor. But this is not true for show invisible. 1855 * floor. But this is not true for show invisible.
1908 * Basically, we just go and find the top object and work 1856 * Basically, we just go and find the top object and work
1909 * down - that is easier than working up. 1857 * down - that is easier than working up.
1910 */ 1858 */
1911 1859
1912 for (last = NULL, tmp = get_map_ob (m, nx, ny); tmp; tmp = tmp->above) 1860 for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above)
1913 last = tmp; 1861 last = tmp;
1862
1914 /* Shouldn't happen, but if there are no objects on a space, this 1863 /* Shouldn't happen, but if there are no objects on a space, this
1915 * would happen. 1864 * would happen.
1916 */ 1865 */
1917 if (!last) 1866 if (!last)
1918 continue; 1867 continue;
… …
1920 done_one = 0; 1869 done_one = 0;
1921 floor = 0; 1870 floor = 0;
1922 detect = NULL; 1871 detect = NULL;
1923 for (tmp = last; tmp; tmp = tmp->below) 1872 for (tmp = last; tmp; tmp = tmp->below)
1924 { 1873 {
1925
1926 /* show invisible */ 1874 /* show invisible */
1927 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) && 1875 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&
1928 /* Might there be other objects that we can make visibile? */ 1876 /* Might there be other objects that we can make visible? */
1929 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) || 1877 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) ||
1930 (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) || 1878 (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) ||
1931 tmp->type == CF_HANDLE || 1879 tmp->type == CF_HANDLE ||
1932 tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE || 1880 tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE ||
1933 tmp->type == BUTTON || tmp->type == TELEPORTER || 1881 tmp->type == BUTTON || tmp->type == TELEPORTER ||
… …
1940 { 1888 {
1941 tmp->invisible = 0; 1889 tmp->invisible = 0;
1942 done_one = 1; 1890 done_one = 1;
1943 } 1891 }
1944 } 1892 }
1893
1945 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1894 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1946 floor = 1; 1895 floor = 1;
1947 1896
1948 /* All detections below this point don't descend beneath the floor, 1897 /* All detections below this point don't descend beneath the floor,
1949 * so just continue on. We could be clever and look at the type of 1898 * so just continue on. We could be clever and look at the type of
… …
2002 */ 1951 */
2003 if (done_one) 1952 if (done_one)
2004 { 1953 {
2005 object *detect_ob = arch_to_object (spell->other_arch); 1954 object *detect_ob = arch_to_object (spell->other_arch);
2006 1955
2007 detect_ob->x = nx;
2008 detect_ob->y = ny;
2009 /* if this is set, we want to copy the face */ 1956 /* if this is set, we want to copy the face */
2010 if (done_one == 2 && detect) 1957 if (done_one == 2 && detect)
2011 { 1958 {
2012 detect_ob->face = detect->face; 1959 detect_ob->face = detect->face;
2013 detect_ob->animation_id = detect->animation_id; 1960 detect_ob->animation_id = detect->animation_id;
… …
2015 detect_ob->last_anim = 0; 1962 detect_ob->last_anim = 0;
2016 /* by default, the detect_ob is already animated */ 1963 /* by default, the detect_ob is already animated */
2017 if (!QUERY_FLAG (detect, FLAG_ANIMATE)) 1964 if (!QUERY_FLAG (detect, FLAG_ANIMATE))
2018 CLEAR_FLAG (detect_ob, FLAG_ANIMATE); 1965 CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
2019 } 1966 }
1967
2020 insert_ob_in_map (detect_ob, m, op, 0); 1968 m->insert (detect_ob, nx, ny, op);
2021 } 1969 }
2022 } /* for processing the surrounding spaces */ 1970 } /* for processing the surrounding spaces */
2023 1971
2024 1972
2025 /* Now process objects in the players inventory if detect curse or magic */ 1973 /* Now process objects in the players inventory if detect curse or magic */
… …
2074 2022
2075 /* Explodes a fireball centered at player */ 2023 /* Explodes a fireball centered at player */
2076 tmp = get_archetype (EXPLODING_FIREBALL); 2024 tmp = get_archetype (EXPLODING_FIREBALL);
2077 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1; 2025 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
2078 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2; 2026 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
2079 tmp->x = victim->x; 2027
2080 tmp->y = victim->y; 2028 tmp->insert_at (victim);
2081 insert_ob_in_map (tmp, victim->map, NULL, 0);
2082 victim->stats.sp = 2 * victim->stats.maxsp; 2029 victim->stats.sp = 2 * victim->stats.maxsp;
2083 } 2030 }
2084 else if (victim->stats.sp >= victim->stats.maxsp * 1.88) 2031 else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
2085 {
2086 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode."); 2032 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode.");
2087 }
2088 else if (victim->stats.sp >= victim->stats.maxsp * 1.66) 2033 else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
2089 {
2090 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!"); 2034 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
2091 }
2092 else if (victim->stats.sp >= victim->stats.maxsp * 1.5) 2035 else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
2093 { 2036 {
2094 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world."); 2037 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
2095 confuse_player (victim, victim, 99); 2038 confuse_player (victim, victim, 99);
2096 } 2039 }
2097 else if (victim->stats.sp >= victim->stats.maxsp * 1.25) 2040 else if (victim->stats.sp >= victim->stats.maxsp * 1.25)
2098 {
2099 new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices."); 2041 new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");
2100 }
2101} 2042}
2102 2043
2103/* cast_transfer 2044/* cast_transfer
2104 * This spell transfers sp from the player to another person. 2045 * This spell transfers sp from the player to another person.
2105 * We let the target go above their normal maximum SP. 2046 * We let the target go above their normal maximum SP.
… …
2108int 2049int
2109cast_transfer (object *op, object *caster, object *spell, int dir) 2050cast_transfer (object *op, object *caster, object *spell, int dir)
2110{ 2051{
2111 object *plyr = NULL; 2052 object *plyr = NULL;
2112 sint16 x, y; 2053 sint16 x, y;
2113 mapstruct *m; 2054 maptile *m;
2114 int mflags; 2055 int mflags;
2115 2056
2116 m = op->map; 2057 m = op->map;
2117 x = op->x + freearr_x[dir]; 2058 x = op->x + freearr_x[dir];
2118 y = op->y + freearr_y[dir]; 2059 y = op->y + freearr_y[dir];
2119 2060
2120 mflags = get_map_flags (m, &m, x, y, &x, &y); 2061 mflags = get_map_flags (m, &m, x, y, &x, &y);
2121 2062
2122 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) 2063 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
2123 { 2064 {
2124 for (plyr = get_map_ob (m, x, y); plyr != NULL; plyr = plyr->above) 2065 for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)
2125 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 2066 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))
2126 break; 2067 break;
2127 } 2068 }
2128 2069
2129 2070
2130 /* If we did not find a player in the specified direction, transfer 2071 /* If we did not find a player in the specified direction, transfer
2131 * to anyone on top of us. This is used for the rune of transference mostly. 2072 * to anyone on top of us. This is used for the rune of transference mostly.
2132 */ 2073 */
2133 if (plyr == NULL) 2074 if (plyr == NULL)
2134 for (plyr = get_map_ob (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above) 2075 for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)
2135 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 2076 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))
2136 break; 2077 break;
2137 2078
2138 if (!plyr) 2079 if (!plyr)
2139 { 2080 {
… …
2184void 2125void
2185counterspell (object *op, int dir) 2126counterspell (object *op, int dir)
2186{ 2127{
2187 object *tmp, *head, *next; 2128 object *tmp, *head, *next;
2188 int mflags; 2129 int mflags;
2189 mapstruct *m; 2130 maptile *m;
2190 sint16 sx, sy; 2131 sint16 sx, sy;
2191 2132
2192 sx = op->x + freearr_x[dir]; 2133 sx = op->x + freearr_x[dir];
2193 sy = op->y + freearr_y[dir]; 2134 sy = op->y + freearr_y[dir];
2194 m = op->map; 2135 m = op->map;
2195 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy); 2136 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
2196 if (mflags & P_OUT_OF_MAP) 2137 if (mflags & P_OUT_OF_MAP)
2197 return; 2138 return;
2198 2139
2199 for (tmp = get_map_ob (m, sx, sy); tmp != NULL; tmp = next) 2140 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)
2200 { 2141 {
2201 next = tmp->above; 2142 next = tmp->above;
2202 2143
2203 /* Need to look at the head object - otherwise, if tmp 2144 /* Need to look at the head object - otherwise, if tmp
2204 * points to a monster, we don't have all the necessary 2145 * points to a monster, we don't have all the necessary
… …
2218 * monsters either. 2159 * monsters either.
2219 */ 2160 */
2220 2161
2221 if (head->attacktype & AT_MAGIC && 2162 if (head->attacktype & AT_MAGIC &&
2222 !(head->attacktype & AT_COUNTERSPELL) && !QUERY_FLAG (head, FLAG_MONSTER) && (op->level > head->level)) 2163 !(head->attacktype & AT_COUNTERSPELL) && !QUERY_FLAG (head, FLAG_MONSTER) && (op->level > head->level))
2223 { 2164 head->destroy ();
2224 remove_ob (head);
2225 free_object (head);
2226 }
2227 else 2165 else
2228 switch (head->type) 2166 switch (head->type)
2229 { 2167 {
2230 case SPELL_EFFECT: 2168 case SPELL_EFFECT:
2231 if (op->level > head->level) 2169 if (op->level > head->level)
2232 { 2170 head->destroy ();
2233 remove_ob (head); 2171
2234 free_object (head);
2235 }
2236 break; 2172 break;
2237 2173
2238 /* I really don't get this rune code that much - that 2174 /* I really don't get this rune code that much - that
2239 * random chance seems really low. 2175 * random chance seems really low.
2240 */ 2176 */
2241 case RUNE: 2177 case RUNE:
2242 if (rndm (0, 149) == 0) 2178 if (rndm (0, 149) == 0)
2243 { 2179 {
2244 head->stats.hp--; /* weaken the rune */ 2180 head->stats.hp--; /* weaken the rune */
2245 if (!head->stats.hp) 2181 if (!head->stats.hp)
2246 { 2182 head->destroy ();
2247 remove_ob (head);
2248 free_object (head);
2249 }
2250 } 2183 }
2251 break; 2184 break;
2252 } 2185 }
2253 } 2186 }
2254} 2187}
… …
2315{ 2248{
2316 object *weapon, *tmp; 2249 object *weapon, *tmp;
2317 char buf[MAX_BUF]; 2250 char buf[MAX_BUF];
2318 int a, i; 2251 int a, i;
2319 sint16 x, y; 2252 sint16 x, y;
2320 mapstruct *m; 2253 maptile *m;
2321 materialtype_t *mt; 2254 materialtype_t *mt;
2322 2255
2323 if (!spell->other_arch) 2256 if (!spell->other_arch)
2324 { 2257 {
2325 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 2258 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
… …
2329 /* exit if it's not a player using this spell. */ 2262 /* exit if it's not a player using this spell. */
2330 if (op->type != PLAYER) 2263 if (op->type != PLAYER)
2331 return 0; 2264 return 0;
2332 2265
2333 /* if player already has a golem, abort */ 2266 /* if player already has a golem, abort */
2334 if (op->contr->ranges[range_golem] != NULL && op->contr->golem_count == op->contr->ranges[range_golem]->count) 2267 if (op->contr->ranges[range_golem])
2335 { 2268 {
2336 control_golem (op->contr->ranges[range_golem], dir); 2269 control_golem (op->contr->ranges[range_golem], dir);
2337 return 0; 2270 return 0;
2338 } 2271 }
2339 2272
… …
2387 /* create the golem object */ 2320 /* create the golem object */
2388 tmp = arch_to_object (spell->other_arch); 2321 tmp = arch_to_object (spell->other_arch);
2389 2322
2390 /* if animated by a player, give the player control of the golem */ 2323 /* if animated by a player, give the player control of the golem */
2391 CLEAR_FLAG (tmp, FLAG_MONSTER); 2324 CLEAR_FLAG (tmp, FLAG_MONSTER);
2392 SET_FLAG (tmp, FLAG_FRIENDLY);
2393 tmp->stats.exp = 0; 2325 tmp->stats.exp = 0;
2394 add_friendly_object (tmp); 2326 add_friendly_object (tmp);
2395 tmp->type = GOLEM; 2327 tmp->type = GOLEM;
2396 set_owner (tmp, op); 2328 tmp->set_owner (op);
2397 set_spell_skill (op, caster, spell, tmp); 2329 set_spell_skill (op, caster, spell, tmp);
2398 op->contr->ranges[range_golem] = tmp; 2330 op->contr->ranges[range_golem] = tmp;
2399 op->contr->shoottype = range_golem; 2331 op->contr->shoottype = range_golem;
2400 op->contr->golem_count = tmp->count;
2401 2332
2402 /* Give the weapon to the golem now. A bit of a hack to check the 2333 /* Give the weapon to the golem now. A bit of a hack to check the
2403 * removed flag - it should only be set if get_split_object was 2334 * removed flag - it should only be set if get_split_object was
2404 * used above. 2335 * used above.
2405 */ 2336 */
2406 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2337 if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2407 remove_ob (weapon); 2338 weapon->remove ();
2408 insert_ob_in_ob (weapon, tmp); 2339 insert_ob_in_ob (weapon, tmp);
2409 esrv_send_item (op, weapon); 2340 esrv_send_item (op, weapon);
2410 /* To do everything necessary to let a golem use the weapon is a pain, 2341 /* To do everything necessary to let a golem use the weapon is a pain,
2411 * so instead, just set it as equipped (otherwise, we need to update 2342 * so instead, just set it as equipped (otherwise, we need to update
2412 * body_info, skills, etc) 2343 * body_info, skills, etc)
2413 */ 2344 */
2414 SET_FLAG (tmp, FLAG_USE_WEAPON); 2345 SET_FLAG (tmp, FLAG_USE_WEAPON);
2415 SET_FLAG (weapon, FLAG_APPLIED); 2346 SET_FLAG (weapon, FLAG_APPLIED);
2416 fix_player (tmp); 2347 tmp->update_stats ();
2417 2348
2418 /* There used to be 'odd' code that basically seemed to take the absolute 2349 /* There used to be 'odd' code that basically seemed to take the absolute
2419 * value of the weapon->magic an use that. IMO, that doesn't make sense - 2350 * value of the weapon->magic an use that. IMO, that doesn't make sense -
2420 * if you're using a crappy weapon, it shouldn't be as good. 2351 * if you're using a crappy weapon, it shouldn't be as good.
2421 */ 2352 */
… …
2473 if (a > 14) 2404 if (a > 14)
2474 a = 14; 2405 a = 14;
2475 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a)); 2406 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2476 2407
2477 /* Determine golem's speed */ 2408 /* Determine golem's speed */
2478 tmp->speed = 0.4 + 0.1 * SP_level_range_adjust (caster, spell); 2409 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2479
2480 if (tmp->speed > 3.33)
2481 tmp->speed = 3.33;
2482 2410
2483 if (!spell->race) 2411 if (!spell->race)
2484 { 2412 {
2485 sprintf (buf, "animated %s", &weapon->name); 2413 sprintf (buf, "animated %s", &weapon->name);
2486 tmp->name = buf; 2414 tmp->name = buf;
… …
2488 tmp->face = weapon->face; 2416 tmp->face = weapon->face;
2489 tmp->animation_id = weapon->animation_id; 2417 tmp->animation_id = weapon->animation_id;
2490 tmp->anim_speed = weapon->anim_speed; 2418 tmp->anim_speed = weapon->anim_speed;
2491 tmp->last_anim = weapon->last_anim; 2419 tmp->last_anim = weapon->last_anim;
2492 tmp->state = weapon->state; 2420 tmp->state = weapon->state;
2493 if (QUERY_FLAG (weapon, FLAG_ANIMATE)) 2421 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2494 {
2495 SET_FLAG (tmp, FLAG_ANIMATE);
2496 }
2497 else
2498 {
2499 CLEAR_FLAG (tmp, FLAG_ANIMATE);
2500 }
2501 update_ob_speed (tmp);
2502 } 2422 }
2503 2423
2504 /* make experience increase in proportion to the strength of the summoned creature. */ 2424 /* make experience increase in proportion to the strength of the summoned creature. */
2505 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell)); 2425 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));
2506 2426
2507 tmp->speed_left = -1; 2427 tmp->speed_left = -1;
2508 tmp->x = x;
2509 tmp->y = y;
2510 tmp->direction = dir; 2428 tmp->direction = dir;
2511 insert_ob_in_map (tmp, m, op, 0); 2429
2430 m->insert (tmp, x, y, op);
2512 return 1; 2431 return 1;
2513} 2432}
2514 2433
2515/* cast_daylight() - changes the map darkness level *lower* */ 2434/* cast_daylight() - changes the map darkness level *lower* */
2516 2435
… …
2524 int success; 2443 int success;
2525 2444
2526 if (!op->map) 2445 if (!op->map)
2527 return 0; /* shouldnt happen */ 2446 return 0; /* shouldnt happen */
2528 2447
2529 success = change_map_light (op->map, spell->stats.dam); 2448 success = op->map->change_map_light (spell->stats.dam);
2449
2530 if (!success) 2450 if (!success)
2531 { 2451 {
2532 if (spell->stats.dam < 0) 2452 if (spell->stats.dam < 0)
2533 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here."); 2453 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2534 else 2454 else
… …
2559 2479
2560 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2480 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2561 2481
2562 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2482 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2563 2483
2564 set_owner (new_aura, op); 2484 new_aura->set_owner (op);
2565 set_spell_skill (op, caster, spell, new_aura); 2485 set_spell_skill (op, caster, spell, new_aura);
2566 new_aura->attacktype = spell->attacktype; 2486 new_aura->attacktype = spell->attacktype;
2567 2487
2568 new_aura->level = caster_level (caster, spell); 2488 new_aura->level = caster_level (caster, spell);
2569 if (refresh) 2489 if (refresh)
… …
2587void 2507void
2588move_aura (object *aura) 2508move_aura (object *aura)
2589{ 2509{
2590 int i, mflags; 2510 int i, mflags;
2591 object *env; 2511 object *env;
2592 mapstruct *m; 2512 maptile *m;
2593 2513
2594 /* auras belong in inventories */ 2514 /* auras belong in inventories */
2595 env = aura->env; 2515 env = aura->env;
2596 2516
2597 /* no matter what we've gotta remove the aura... 2517 /* no matter what we've gotta remove the aura...
2598 * we'll put it back if its time isn't up. 2518 * we'll put it back if its time isn't up.
2599 */ 2519 */
2600 remove_ob (aura); 2520 aura->remove ();
2601 2521
2602 /* exit if we're out of gas */ 2522 /* exit if we're out of gas */
2603 if (aura->duration-- < 0) 2523 if (aura->duration-- < 0)
2604 { 2524 {
2605 free_object (aura); 2525 aura->destroy ();
2606 return; 2526 return;
2607 } 2527 }
2608 2528
2609 /* auras only exist in inventories */ 2529 /* auras only exist in inventories */
2610 if (env == NULL || env->map == NULL) 2530 if (env == NULL || env->map == NULL)
2611 { 2531 {
2612 free_object (aura); 2532 aura->destroy ();
2613 return; 2533 return;
2614 } 2534 }
2615 aura->x = env->x;
2616 aura->y = env->y;
2617 2535
2618 /* we need to jump out of the inventory for a bit 2536 /* we need to jump out of the inventory for a bit
2619 * in order to hit the map conveniently. 2537 * in order to hit the map conveniently.
2620 */ 2538 */
2621 insert_ob_in_map (aura, env->map, aura, 0); 2539 aura->insert_at (env, aura);
2622 2540
2623 for (i = 1; i < 9; i++) 2541 for (i = 1; i < 9; i++)
2624 { 2542 {
2625 sint16 nx, ny; 2543 sint16 nx, ny;
2626 2544
… …
2635 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny)))) 2553 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))
2636 { 2554 {
2637 hit_map (aura, i, aura->attacktype, 0); 2555 hit_map (aura, i, aura->attacktype, 0);
2638 2556
2639 if (aura->other_arch) 2557 if (aura->other_arch)
2640 { 2558 m->insert (arch_to_object (aura->other_arch), nx, ny, aura);
2641 object *new_ob;
2642
2643 new_ob = arch_to_object (aura->other_arch);
2644 new_ob->x = nx;
2645 new_ob->y = ny;
2646 insert_ob_in_map (new_ob, m, aura, 0);
2647 } 2559 }
2648 }
2649 } 2560 }
2561
2650 /* put the aura back in the player's inventory */ 2562 /* put the aura back in the player's inventory */
2651 remove_ob (aura); 2563 aura->remove ();
2652 insert_ob_in_ob (aura, env); 2564 insert_ob_in_ob (aura, env);
2653} 2565}
2654 2566
2655/* moves the peacemaker spell. 2567/* moves the peacemaker spell.
2656 * op is the piece object. 2568 * op is the piece object.
… …
2659void 2571void
2660move_peacemaker (object *op) 2572move_peacemaker (object *op)
2661{ 2573{
2662 object *tmp; 2574 object *tmp;
2663 2575
2664 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 2576 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2665 { 2577 {
2666 int atk_lev, def_lev; 2578 int atk_lev, def_lev;
2667 object *victim = tmp; 2579 object *victim = tmp;
2668 2580
2669 if (tmp->head) 2581 if (tmp->head)
… …
2680 2592
2681 if (rndm (0, atk_lev - 1) > def_lev) 2593 if (rndm (0, atk_lev - 1) > def_lev)
2682 { 2594 {
2683 /* make this sucker peaceful. */ 2595 /* make this sucker peaceful. */
2684 2596
2685 change_exp (get_owner (op), victim->stats.exp, op->skill, 0); 2597 change_exp (op->owner, victim->stats.exp, op->skill, 0);
2686 victim->stats.exp = 0; 2598 victim->stats.exp = 0;
2687#if 0 2599#if 0
2688 /* No idea why these were all set to zero - if something 2600 /* No idea why these were all set to zero - if something
2689 * makes this creature agressive, he should still do damage. 2601 * makes this creature agressive, he should still do damage.
2690 */ 2602 */
… …
2735 2647
2736 snprintf (rune, sizeof (rune), "%s\n", msg); 2648 snprintf (rune, sizeof (rune), "%s\n", msg);
2737 2649
2738 tmp->race = op->name; /*Save the owner of the rune */ 2650 tmp->race = op->name; /*Save the owner of the rune */
2739 tmp->msg = rune; 2651 tmp->msg = rune;
2740 tmp->x = op->x; 2652
2741 tmp->y = op->y; 2653 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2742 insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
2743 return 1; 2654 return 1;
2744} 2655}

Diff Legend

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