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.11 by root, Thu Sep 14 22:34:05 2006 UTC vs.
Revision 1.45 by root, Mon Apr 16 06:23:43 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * CrossFire, A Multiplayer game for X-windows
3 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (C) 1992 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * This program 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 2 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, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 21 *
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail at <crossfire@schmorp.de>
22*/ 23 */
23 24
24#include <global.h> 25#include <global.h>
25#include <object.h> 26#include <object.h>
26#include <living.h> 27#include <living.h>
27#ifndef __CEXTRACT__
28# include <sproto.h> 28#include <sproto.h>
29#endif
30#include <spells.h> 29#include <spells.h>
31#include <sounds.h> 30#include <sounds.h>
32 31
33/* cast_magic_storm: This is really used mostly for spell 32/* cast_magic_storm: This is really used mostly for spell
34 * fumbles at the like. tmp is the object to propogate. 33 * fumbles at the like. tmp is the object to propogate.
… …
37void 36void
38cast_magic_storm (object *op, object *tmp, int lvl) 37cast_magic_storm (object *op, object *tmp, int lvl)
39{ 38{
40 if (!tmp) 39 if (!tmp)
41 return; /* error */ 40 return; /* error */
41
42 tmp->level = op->level; 42 tmp->level = op->level;
43 tmp->x = op->x;
44 tmp->y = op->y;
45 tmp->range += lvl / 5; /* increase the area of destruction */ 43 tmp->range += lvl / 5; /* increase the area of destruction */
46 tmp->duration += lvl / 5; 44 tmp->duration += lvl / 5;
47 45
48 /* 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
49 * 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
50 * multiple times. Also, damge already increases with level, 48 * multiple times. Also, damge already increases with level,
51 * 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.
52 */ 50 */
53 if (tmp->duration >= 40) 51 if (tmp->duration >= 40)
54 tmp->duration = 40; 52 tmp->duration = 40;
53
55 tmp->stats.dam = lvl; /* nasty recoils! */ 54 tmp->stats.dam = lvl; /* nasty recoils! */
56 tmp->stats.maxhp = tmp->count; /* tract single parent */ 55 tmp->stats.maxhp = tmp->count; /* tract single parent */
57 insert_ob_in_map (tmp, op->map, op, 0);
58 56
57 tmp->insert_at (op, op);
59} 58}
60
61 59
62int 60int
63recharge (object *op, object *caster, object *spell_ob) 61recharge (object *op, object *caster, object *spell_ob)
64{ 62{
65 object *wand, *tmp; 63 object *wand, *tmp;
… …
74 if (!(random_roll (0, 3, op, PREFER_HIGH))) 72 if (!(random_roll (0, 3, op, PREFER_HIGH)))
75 { 73 {
76 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));
77 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);
78 esrv_del_item (op->contr, wand->count); 76 esrv_del_item (op->contr, wand->count);
79 remove_ob (wand); 77 wand->destroy ();
80 free_object (wand);
81 tmp = get_archetype ("fireball"); 78 tmp = get_archetype ("fireball");
82 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
83 if (!tmp->stats.dam) 81 if (!tmp->stats.dam)
84 tmp->stats.dam = 1; 82 tmp->stats.dam = 1;
83
85 tmp->stats.hp = tmp->stats.dam / 2; 84 tmp->stats.hp = tmp->stats.dam / 2;
85
86 if (tmp->stats.hp < 2) 86 if (tmp->stats.hp < 2)
87 tmp->stats.hp = 2; 87 tmp->stats.hp = 2;
88 tmp->x = op->x; 88
89 tmp->y = op->y; 89 tmp->insert_at (op);
90 insert_ob_in_map (tmp, op->map, NULL, 0);
91 return 1; 90 return 1;
92 } 91 }
93 92
94 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
95 if (wand->inv && wand->inv->level) 95 if (wand->inv && wand->inv->level)
96 ncharges /= wand->inv->level; 96 ncharges /= wand->inv->level;
97 else 97 else
98 { 98 {
99 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));
100 return 0; 100 return 0;
101 } 101 }
102
102 if (!ncharges) 103 if (!ncharges)
103 ncharges = 1; 104 ncharges = 1;
104 105
105 wand->stats.food += ncharges; 106 wand->stats.food += ncharges;
106 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
107 if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE)) 109 if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE))
108 { 110 {
109 SET_FLAG (wand, FLAG_ANIMATE); 111 SET_FLAG (wand, FLAG_ANIMATE);
110 wand->speed = wand->arch->clone.speed; 112 wand->set_speed (wand->arch->clone.speed);
111 update_ob_speed (wand);
112 } 113 }
114
113 return 1; 115 return 1;
114} 116}
115 117
116/* 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
117 * 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
… …
128cast_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)
129{ 131{
130 int missile_plus = 0, bonus_plus = 0; 132 int missile_plus = 0, bonus_plus = 0;
131 const char *missile_name; 133 const char *missile_name;
132 object *tmp, *missile; 134 object *tmp, *missile;
133 tag_t tag;
134 135
135 missile_name = "arrow"; 136 missile_name = "arrow";
136 137
137 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 138 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
138 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED)) 139 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
139 {
140 missile_name = tmp->race; 140 missile_name = tmp->race;
141 }
142 141
143 missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell); 142 missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
144 143
145 if (archetype::find (missile_name) == NULL) 144 if (archetype::find (missile_name) == NULL)
146 { 145 {
147 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);
148 return 0; 147 return 0;
149 } 148 }
149
150 missile = get_archetype (missile_name); 150 missile = get_archetype (missile_name);
151 151
152 if (stringarg) 152 if (stringarg)
153 { 153 {
154 /* If it starts with a letter, presume it is a description */ 154 /* If it starts with a letter, presume it is a description */
155 if (isalpha (*stringarg)) 155 if (isalpha (*stringarg))
156 { 156 {
157 artifact *al = find_artifactlist (missile->type)->items; 157 artifact *al = find_artifactlist (missile->type)->items;
158 158
159 for (; al != NULL; al = al->next) 159 for (; al; al = al->next)
160 if (!strcasecmp (al->item->name, stringarg)) 160 if (!strcasecmp (al->item->name, stringarg))
161 break; 161 break;
162 162
163 if (!al) 163 if (!al)
164 { 164 {
165 free_object (missile); 165 missile->destroy ();
166 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);
167 return 0; 167 return 0;
168 } 168 }
169
169 if (al->item->slaying) 170 if (al->item->slaying)
170 { 171 {
171 free_object (missile); 172 missile->destroy ();
172 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);
173 return 0; 174 return 0;
174 } 175 }
176
175 give_artifact_abilities (missile, al->item); 177 give_artifact_abilities (missile, al->item);
176 /* 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 -
177 * 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
178 * the parsing of having to do both plus and type. 180 * the parsing of having to do both plus and type.
179 */ 181 */
… …
181 missile_plus = 0; 183 missile_plus = 0;
182 } 184 }
183 else if (atoi (stringarg) < missile_plus) 185 else if (atoi (stringarg) < missile_plus)
184 missile_plus = atoi (stringarg); 186 missile_plus = atoi (stringarg);
185 } 187 }
188
186 if (missile_plus > 4) 189 if (missile_plus > 4)
187 missile_plus = 4; 190 missile_plus = 4;
188 else if (missile_plus < -4) 191 else if (missile_plus < -4)
189 missile_plus = -4; 192 missile_plus = -4;
190 193
191 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell); 194 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
192 missile->nrof -= 3 * (missile_plus + bonus_plus); 195 missile->nrof -= 3 * (missile_plus + bonus_plus);
196
193 if (missile->nrof < 1) 197 if (missile->nrof < 1)
194 missile->nrof = 1; 198 missile->nrof = 1;
195 199
196 missile->magic = missile_plus; 200 missile->magic = missile_plus;
197 /* Can't get any money for these objects */ 201 /* Can't get any money for these objects */
198 missile->value = 0; 202 missile->value = 0;
199 203
200 SET_FLAG (missile, FLAG_IDENTIFIED); 204 SET_FLAG (missile, FLAG_IDENTIFIED);
201 tag = missile->count;
202 205
203 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 ())
204 {
205 pick_up (op, missile); 207 pick_up (op, missile);
206 } 208
207 return 1; 209 return 1;
208} 210}
209 211
210 212
211/* allows the choice of what sort of food object to make. 213/* allows the choice of what sort of food object to make.
… …
277int 279int
278probe (object *op, object *caster, object *spell_ob, int dir) 280probe (object *op, object *caster, object *spell_ob, int dir)
279{ 281{
280 int r, mflags, maxrange; 282 int r, mflags, maxrange;
281 object *tmp; 283 object *tmp;
282 mapstruct *m; 284 maptile *m;
283 285
284 286
285 if (!dir) 287 if (!dir)
286 { 288 {
287 examine_monster (op, op); 289 examine_monster (op, op);
… …
303 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic."); 305 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
304 return 0; 306 return 0;
305 } 307 }
306 if (mflags & P_IS_ALIVE) 308 if (mflags & P_IS_ALIVE)
307 { 309 {
308 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)
309 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)))
310 { 312 {
311 new_draw_info (NDI_UNIQUE, 0, op, "You detect something."); 313 new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
312 if (tmp->head != NULL) 314 if (tmp->head != NULL)
313 tmp = tmp->head; 315 tmp = tmp->head;
… …
371 * normal applies. 373 * normal applies.
372 */ 374 */
373int 375int
374cast_invisible (object *op, object *caster, object *spell_ob) 376cast_invisible (object *op, object *caster, object *spell_ob)
375{ 377{
376 object *tmp;
377
378 if (op->invisible > 1000) 378 if (op->invisible > 1000)
379 { 379 {
380 new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further"); 380 new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");
381 return 0; 381 return 0;
382 } 382 }
… …
398 else 398 else
399 op->contr->tmp_invis = 1; 399 op->contr->tmp_invis = 1;
400 400
401 op->contr->hidden = 0; 401 op->contr->hidden = 0;
402 } 402 }
403
403 if (makes_invisible_to (op, op)) 404 if (makes_invisible_to (op, op))
404 new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!"); 405 new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");
405 else 406 else
406 new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!"); 407 new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!");
407 408
408 update_object (op, UP_OBJ_FACE); 409 update_object (op, UP_OBJ_CHANGE);
409 410
410 /* Only search the active objects - only these should actually do 411 /* Only search the active objects - only these should actually do
411 * harm to the player. 412 * harm to the player.
412 */ 413 */
413 for (tmp = active_objects; tmp != NULL; tmp = tmp->active_next) 414 for_all_actives (tmp)
414 if (tmp->enemy == op) 415 if (tmp->enemy == op)
415 tmp->enemy = NULL; 416 tmp->enemy = 0;
417
416 return 1; 418 return 1;
417} 419}
418 420
419/* earth to dust spell. Basically destroys earthwalls in the area. 421/* earth to dust spell. Basically destroys earthwalls in the area.
420 */ 422 */
… …
422cast_earth_to_dust (object *op, object *caster, object *spell_ob) 424cast_earth_to_dust (object *op, object *caster, object *spell_ob)
423{ 425{
424 object *tmp, *next; 426 object *tmp, *next;
425 int range, i, j, mflags; 427 int range, i, j, mflags;
426 sint16 sx, sy; 428 sint16 sx, sy;
427 mapstruct *m; 429 maptile *m;
428 430
429 if (op->type != PLAYER) 431 if (op->type != PLAYER)
430 return 0; 432 return 0;
431 433
432 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 434 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
… …
441 443
442 if (mflags & P_OUT_OF_MAP) 444 if (mflags & P_OUT_OF_MAP)
443 continue; 445 continue;
444 446
445 // earth to dust tears down everything that can be teared down 447 // earth to dust tears down everything that can be teared down
446 for (tmp = get_map_ob (m, sx, sy); tmp != NULL; tmp = next) 448 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)
447 { 449 {
448 next = tmp->above; 450 next = tmp->above;
449 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN)) 451 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
450 hit_player (tmp, 9998, op, AT_PHYSICAL, 0); 452 hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
451 } 453 }
452 } 454 }
455
453 return 1; 456 return 1;
454} 457}
455
456 458
457void 459void
458execute_word_of_recall (object *op) 460execute_word_of_recall (object *op)
459{ 461{
460 object *wor = op; 462 if (object *pl = op->in_player ())
461
462 while (op != NULL && op->type != PLAYER)
463 op = op->env;
464
465 if (op != NULL && op->map)
466 { 463 {
467 if ((get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_CLERIC) && (!QUERY_FLAG (op, FLAG_WIZCAST))) 464 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
468 new_draw_info (NDI_UNIQUE, 0, op, "You feel something fizzle inside you."); 465 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
469 else 466 else
467 {
468 // remove first so we do not call update_stats
469 op->remove ();
470 enter_exit (op, wor); 470 pl->enter_exit (op);
471 }
471 } 472 }
472 remove_ob (wor); 473
473 free_object (wor); 474 op->destroy ();
474} 475}
475 476
476/* Word of recall causes the player to return 'home'. 477/* Word of recall causes the player to return 'home'.
477 * we put a force into the player object, so that there is a 478 * we put a force into the player object, so that there is a
478 * time delay effect. 479 * time delay effect.
… …
497 { 498 {
498 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 499 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
499 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n"); 500 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
500 return 0; 501 return 0;
501 } 502 }
503
502 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob); 504 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);
503 if (time < 1) 505 if (time < 1)
504 time = 1; 506 time = 1;
505 507
506 /* value of speed really doesn't make much difference, as long as it is 508 /* value of speed really doesn't make much difference, as long as it is
507 * positive. Lower value may be useful so that the problem doesn't 509 * positive. Lower value may be useful so that the problem doesn't
508 * do anything really odd if it say a -1000 or something. 510 * do anything really odd if it say a -1000 or something.
509 */ 511 */
510 dummy->speed = 0.002; 512 dummy->set_speed (0.002);
511 update_ob_speed (dummy);
512 dummy->speed_left = -dummy->speed * time; 513 dummy->speed_left = -dummy->speed * time;
513 dummy->type = SPELL_EFFECT; 514 dummy->type = SPELL_EFFECT;
514 dummy->subtype = SP_WORD_OF_RECALL; 515 dummy->subtype = SP_WORD_OF_RECALL;
515 516
516 /* If we could take advantage of enter_player_savebed() here, it would be 517 /* If we could take advantage of enter_player_savebed() here, it would be
517 * nice, but until the map load fails, we can't. 518 * nice, but until the map load fails, we can't.
518 */ 519 */
519 EXIT_PATH (dummy) = op->contr->savebed_map; 520 EXIT_PATH (dummy) = op->contr->savebed_map;
520 EXIT_X (dummy) = op->contr->bed_x; 521 EXIT_X (dummy) = op->contr->bed_x;
521 EXIT_Y (dummy) = op->contr->bed_y; 522 EXIT_Y (dummy) = op->contr->bed_y;
522 523
523 (void) insert_ob_in_ob (dummy, op); 524 op->insert (dummy);
525
524 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 526 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
527
525 return 1; 528 return 1;
526} 529}
527 530
528/* cast_wonder 531/* cast_wonder
529 * wonder is really just a spell that will likely cast another 532 * wonder is really just a spell that will likely cast another
… …
559 return cast_spell (op, caster, dir, newspell, NULL); 562 return cast_spell (op, caster, dir, newspell, NULL);
560 } 563 }
561 return 1; 564 return 1;
562} 565}
563 566
564
565int 567int
566perceive_self (object *op) 568perceive_self (object *op)
567{ 569{
570 char buf[MAX_BUF];
568 char *cp = describe_item (op, op), buf[MAX_BUF]; 571 const char *cp = describe_item (op, op);
569 archetype *at = archetype::find (ARCH_DEPLETION); 572 archetype *at = archetype::find (ARCH_DEPLETION);
570 object *tmp; 573 object *tmp;
571 int i; 574 int i;
572 575
573 tmp = find_god (determine_god (op)); 576 tmp = find_god (determine_god (op));
… …
602 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 605 for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
603 { 606 {
604 if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force")) 607 if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force"))
605 { 608 {
606 if (tmp->stats.exp == 0) 609 if (tmp->stats.exp == 0)
607 {
608 sprintf (buf, "Your metabolism isn't focused on anything."); 610 sprintf (buf, "Your metabolism isn't focused on anything.");
609 }
610 else 611 else
611 {
612 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]);
613 } 613
614 new_draw_info (NDI_UNIQUE, 0, op, buf); 614 new_draw_info (NDI_UNIQUE, 0, op, buf);
615 break; 615 break;
616 } 616 }
617 } 617 }
618 } 618 }
619
619 return 1; 620 return 1;
620} 621}
621 622
622/* int cast_create_town_portal (object *op, object *caster, int dir) 623/* int cast_create_town_portal (object *op, object *caster, int dir)
623 * 624 *
… …
637 * Code by Tchize (david.delbecq@usa.net) 638 * Code by Tchize (david.delbecq@usa.net)
638 */ 639 */
639int 640int
640cast_create_town_portal (object *op, object *caster, object *spell, int dir) 641cast_create_town_portal (object *op, object *caster, object *spell, int dir)
641{ 642{
642 object *dummy, *force, *old_force, *tmp; 643 object *dummy, *force, *old_force;
643 archetype *perm_portal; 644 archetype *perm_portal;
644 char portal_name[1024], portal_message[1024]; 645 char portal_name[1024], portal_message[1024];
645 sint16 exitx, exity;
646 mapstruct *exitmap; 646 maptile *exitmap;
647 int op_level; 647 int op_level;
648
649 648
650 /* 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
651 * 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
652 * full pathname listed. 651 * full pathname listed.
653 */ 652 */
… …
662 */ 661 */
663 dummy = arch_to_object (spell->other_arch); 662 dummy = arch_to_object (spell->other_arch);
664 if (dummy == NULL) 663 if (dummy == NULL)
665 { 664 {
666 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 665 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
667 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);
668 return 0; 667 return 0;
669 } 668 }
669
670 force = check_inv_recursive (op, dummy); 670 force = check_inv_recursive (op, dummy);
671 671
672 if (force == NULL) 672 if (force == NULL)
673 { 673 {
674 /* Here we know there is no destination marked up. 674 /* Here we know there is no destination marked up.
… …
681 EXIT_Y (dummy) = op->y; 681 EXIT_Y (dummy) = op->y;
682 insert_ob_in_ob (dummy, op); 682 insert_ob_in_ob (dummy, op);
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."); 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.");
684 return 1; 684 return 1;
685 } 685 }
686 free_object (dummy); 686
687 dummy->destroy ();
687 688
688 /* Here we know where the town portal should go to 689 /* Here we know where the town portal should go to
689 * We should kill any existing portal associated with the player. 690 * We should kill any existing portal associated with the player.
690 * Than we should create the 2 portals. 691 * Than we should create the 2 portals.
691 * For each of them, we need: 692 * For each of them, we need:
… …
704 /* First step: killing existing town portals */ 705 /* First step: killing existing town portals */
705 dummy = get_archetype (spell->race); 706 dummy = get_archetype (spell->race);
706 if (dummy == NULL) 707 if (dummy == NULL)
707 { 708 {
708 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 709 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
709 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);
710 return 0; 711 return 0;
711 } 712 }
713
712 perm_portal = archetype::find (spell->slaying); 714 perm_portal = archetype::find (spell->slaying);
713 715
714 /* 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,
715 * for each marked portal in player's inventory, 717 * for each marked portal in player's inventory,
716 * -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)
… …
718 * If it has the good name, we destruct it. 720 * If it has the good name, we destruct it.
719 * -We destruct the force indicating that portal. 721 * -We destruct the force indicating that portal.
720 */ 722 */
721 while ((old_force = check_inv_recursive (op, dummy))) 723 while ((old_force = check_inv_recursive (op, dummy)))
722 { 724 {
723 exitx = EXIT_X (old_force); 725 exitmap = maptile::find_sync (old_force->race, op->map);
724 exity = EXIT_Y (old_force);
725 LOG (llevDebug, "Trying to kill a portal in %s (%d,%d)\n", &old_force->race, exitx, exity);
726
727 if (!strncmp (old_force->race, settings.localdir, strlen (settings.localdir)))
728 exitmap = ready_map_name (old_force->race, MAP_PLAYER_UNIQUE);
729 else
730 exitmap = ready_map_name (old_force->race, 0);
731 726
732 if (exitmap) 727 if (exitmap)
733 { 728 {
729 exitmap->load_sync ();
730
731 int exitx = EXIT_X (old_force);
732 int exity = EXIT_Y (old_force);
733
734 tmp = present_arch (perm_portal, exitmap, exitx, exity); 734 for (object *tmp = present_arch (perm_portal, exitmap, exitx, exity); tmp; tmp = tmp->above)
735 while (tmp)
736 { 735 {
737 if (tmp->name == old_force->name) 736 if (tmp->name == old_force->name)
738 { 737 {
739 remove_ob (tmp); 738 tmp->destroy ();
740 free_object (tmp);
741 break; 739 break;
742 } 740 }
743 else
744 {
745 tmp = tmp->above;
746 }
747 } 741 }
748 } 742 }
749 remove_ob (old_force); 743
750 free_object (old_force); 744 old_force->destroy ();
751 LOG (llevDebug, "\n");
752 } 745 }
753 free_object (dummy); 746
747 dummy->destroy ();
754 748
755 /* Creating the portals. 749 /* Creating the portals.
756 * The very first thing to do is to ensure 750 * The very first thing to do is to ensure
757 * access to the destination map. 751 * access to the destination map.
758 * If we can't, don't fizzle. Simply warn player. 752 * If we can't, don't fizzle. Simply warn player.
… …
761 * 'force' is the destination of the town portal, which we got 755 * 'force' is the destination of the town portal, which we got
762 * from the players inventory above. 756 * from the players inventory above.
763 */ 757 */
764 758
765 /* Ensure exit map is loaded */ 759 /* Ensure exit map is loaded */
766 if (!strncmp (force->name, settings.localdir, strlen (settings.localdir))) 760 exitmap = maptile::find_sync (force->name);
767 exitmap = ready_map_name (force->name, MAP_PLAYER_UNIQUE);
768 else
769 exitmap = ready_map_name (force->name, 0);
770 761
771 /* 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 */
772 if (exitmap == NULL) 763 if (!exitmap)
773 { 764 {
774 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!?");
775 remove_ob (force); 766 force->destroy ();
776 free_object (force);
777 return 1; 767 return 1;
778 } 768 }
769
770 exitmap->load_sync ();
779 771
780 op_level = caster_level (caster, spell); 772 op_level = caster_level (caster, spell);
781 if (op_level < 15) 773 if (op_level < 15)
782 snprintf (portal_message, 1024, 774 snprintf (portal_message, 1024,
783 "\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",
… …
793 785
794 /* Create a portal in front of player 786 /* Create a portal in front of player
795 * dummy contain the portal and 787 * dummy contain the portal and
796 * force contain the track to kill it later 788 * force contain the track to kill it later
797 */ 789 */
798
799 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);
800 dummy = get_archetype (spell->slaying); /*The portal */ 791 dummy = get_archetype (spell->slaying); /*The portal */
801 if (dummy == NULL) 792 if (dummy == NULL)
802 { 793 {
803 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 794 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
804 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);
805 return 0; 796 return 0;
806 } 797 }
798
807 EXIT_PATH (dummy) = force->name; 799 EXIT_PATH (dummy) = force->name;
808 EXIT_X (dummy) = EXIT_X (force); 800 EXIT_X (dummy) = EXIT_X (force);
809 EXIT_Y (dummy) = EXIT_Y (force); 801 EXIT_Y (dummy) = EXIT_Y (force);
810 dummy->name = dummy->name_pl = portal_name; 802 dummy->name = dummy->name_pl = portal_name;
811 dummy->msg = portal_message; 803 dummy->msg = portal_message;
… …
814 806
815 /* 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
816 * 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
817 * town portal. 809 * town portal.
818 */ 810 */
819 tmp = get_archetype (spell->race); 811 object *tmp = get_archetype (spell->race);
820 if (tmp == NULL) 812
813 if (!tmp)
821 { 814 {
822 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 815 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
823 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);
824 return 0; 817 return 0;
825 } 818 }
819
826 tmp->race = op->map->path; 820 tmp->race = op->map->path;
827 tmp->name = portal_name; 821 tmp->name = portal_name;
828 EXIT_X (tmp) = dummy->x; 822 EXIT_X (tmp) = dummy->x;
829 EXIT_Y (tmp) = dummy->y; 823 EXIT_Y (tmp) = dummy->y;
830 insert_ob_in_ob (tmp, op); 824 op->insert (tmp);
831 825
832 /* Create a portal in the destination map 826 /* Create a portal in the destination map
833 * dummy contain the portal and 827 * dummy contain the portal and
834 * force the track to kill it later 828 * force the track to kill it later
835 * the 'force' variable still contains the 'reminder' of 829 * the 'force' variable still contains the 'reminder' of
836 * where this portal goes to. 830 * where this portal goes to.
837 */ 831 */
838 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);
839 dummy = get_archetype (spell->slaying); /*The portal */ 833 dummy = get_archetype (spell->slaying); /*The portal */
840 if (dummy == NULL) 834 if (dummy == NULL)
841 { 835 {
842 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 836 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
843 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);
844 return 0; 838 return 0;
845 } 839 }
840
846 EXIT_PATH (dummy) = op->map->path; 841 EXIT_PATH (dummy) = op->map->path;
847 EXIT_X (dummy) = op->x; 842 EXIT_X (dummy) = op->x;
848 EXIT_Y (dummy) = op->y; 843 EXIT_Y (dummy) = op->y;
849 dummy->name = dummy->name_pl = portal_name; 844 dummy->name = dummy->name_pl = portal_name;
850 dummy->msg = portal_message; 845 dummy->msg = portal_message;
851 dummy->x = EXIT_X (force);
852 dummy->y = EXIT_Y (force);
853 dummy->race = op->name; /*Save the owner of the portal */ 846 dummy->race = op->name; /*Save the owner of the portal */
854 insert_ob_in_map (dummy, exitmap, op, 0); 847 exitmap->insert (dummy, EXIT_X (force), EXIT_Y (force), op);
855 848
856 /* Now we create another town portal marker that 849 /* Now we create another town portal marker that
857 * points back to the one we just made 850 * points back to the one we just made
858 */ 851 */
859 tmp = get_archetype (spell->race); 852 tmp = get_archetype (spell->race);
860 if (tmp == NULL) 853 if (tmp == NULL)
861 { 854 {
862 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 855 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
863 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);
864 return 0; 857 return 0;
865 } 858 }
859
866 tmp->race = force->name; 860 tmp->race = force->name;
867 tmp->name = portal_name; 861 tmp->name = portal_name;
868 EXIT_X (tmp) = dummy->x; 862 EXIT_X (tmp) = dummy->x;
869 EXIT_Y (tmp) = dummy->y; 863 EXIT_Y (tmp) = dummy->y;
870 insert_ob_in_ob (tmp, op); 864 insert_ob_in_ob (tmp, op);
871 865
872 /* Describe the player what happened 866 /* Describe the player what happened
873 */ 867 */
874 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.");
875 remove_ob (force); /* Delete the force inside the player */ 869 force->destroy ();
876 free_object (force); 870
877 return 1; 871 return 1;
878} 872}
879
880 873
881/* This creates magic walls. Really, it can create most any object, 874/* This creates magic walls. Really, it can create most any object,
882 * within some reason. 875 * within some reason.
883 */ 876 */
884
885int 877int
886magic_wall (object *op, object *caster, int dir, object *spell_ob) 878magic_wall (object *op, object *caster, int dir, object *spell_ob)
887{ 879{
888 object *tmp, *tmp2; 880 object *tmp;
889 int i, posblocked, negblocked, maxrange; 881 int i, posblocked, negblocked, maxrange;
890 sint16 x, y; 882 sint16 x, y;
891 mapstruct *m; 883 maptile *m;
892 const char *name; 884 const char *name;
893 archetype *at; 885 archetype *at;
894 886
895 if (!dir) 887 if (!dir)
896 { 888 {
… …
901 else 893 else
902 { 894 {
903 x = op->x + freearr_x[dir]; 895 x = op->x + freearr_x[dir];
904 y = op->y + freearr_y[dir]; 896 y = op->y + freearr_y[dir];
905 } 897 }
898
906 m = op->map; 899 m = op->map;
907 900
908 if ((spell_ob->move_block || x != op->x || y != op->y) && 901 if ((spell_ob->move_block || x != op->x || y != op->y) &&
909 (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) ||
910 ((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)))
911 { 904 {
912 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.");
913 return 0; 906 return 0;
914 } 907 }
908
915 if (spell_ob->other_arch) 909 if (spell_ob->other_arch)
916 {
917 tmp = arch_to_object (spell_ob->other_arch); 910 tmp = arch_to_object (spell_ob->other_arch);
918 }
919 else if (spell_ob->race) 911 else if (spell_ob->race)
920 { 912 {
921 char buf1[MAX_BUF]; 913 char buf1[MAX_BUF];
922 914
923 sprintf (buf1, spell_ob->race, dir); 915 sprintf (buf1, spell_ob->race, dir);
… …
926 { 918 {
927 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1); 919 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
928 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken."); 920 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
929 return 0; 921 return 0;
930 } 922 }
923
931 tmp = arch_to_object (at); 924 tmp = arch_to_object (at);
932 } 925 }
933 else 926 else
934 { 927 {
935 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);
… …
945 } 938 }
946 else if (QUERY_FLAG (tmp, FLAG_ALIVE)) 939 else if (QUERY_FLAG (tmp, FLAG_ALIVE))
947 { 940 {
948 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);
949 tmp->stats.maxhp = tmp->stats.hp; 942 tmp->stats.maxhp = tmp->stats.hp;
950 set_owner (tmp, op);
951 set_spell_skill (op, caster, spell_ob, tmp);
952 } 943 }
944
953 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))
954 { 946 {
955 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);
956 SET_FLAG (tmp, FLAG_IS_USED_UP); 948 SET_FLAG (tmp, FLAG_IS_USED_UP);
957 } 949 }
950
958 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN)) 951 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN))
959 { 952 {
960 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);
961 tmp->stats.maxhp = tmp->stats.hp; 954 tmp->stats.maxhp = tmp->stats.hp;
962 SET_FLAG (tmp, FLAG_TEAR_DOWN); 955 SET_FLAG (tmp, FLAG_TEAR_DOWN);
963 SET_FLAG (tmp, FLAG_ALIVE); 956 SET_FLAG (tmp, FLAG_ALIVE);
964 } 957 }
965 958
966 /* 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,
967 * 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.
968 */ 962 */
969 set_owner (tmp, op); 963 if (tmp->type != EARTHWALL) //TODO
964 tmp->set_owner (op);
965
970 set_spell_skill (op, caster, spell_ob, tmp); 966 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; 967 tmp->level = caster_level (caster, spell_ob) / 2;
974 968
975 name = tmp->name; 969 name = tmp->name;
976 if ((tmp = insert_ob_in_map (tmp, m, op, 0)) == NULL) 970 if (!(tmp = m->insert (tmp, x, y, op)))
977 { 971 {
978 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);
979 return 0; 973 return 0;
980 } 974 }
975
981 /* 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 */
982 if (tmp->other_arch && tmp->other_arch->clone.type == SPELL) 977 if (tmp->other_arch && tmp->other_arch->clone.type == SPELL)
983 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp); 978 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
984 979
985 /* This code causes the wall to extend some distance in 980 /* This code causes the wall to extend some distance in
… …
1003 m = tmp->map; 998 m = tmp->map;
1004 999
1005 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)) &&
1006 ((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)
1007 { 1002 {
1008 tmp2 = get_object (); 1003 object *tmp2 = tmp->clone ();
1009 copy_object (tmp, tmp2); 1004 m->insert (tmp2, x, y, op);
1010 tmp2->x = x; 1005
1011 tmp2->y = y;
1012 insert_ob_in_map (tmp2, m, op, 0);
1013 /* 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 */
1014 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 1007 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)
1015 insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2); 1008 tmp2->insert (arch_to_object (tmp2->other_arch));
1016 1009
1017 } 1010 }
1018 else 1011 else
1019 posblocked = 1; 1012 posblocked = 1;
1020 1013
… …
1023 m = tmp->map; 1016 m = tmp->map;
1024 1017
1025 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)) &&
1026 ((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)
1027 { 1020 {
1028 tmp2 = get_object (); 1021 object *tmp2 = tmp->clone ();
1029 copy_object (tmp, tmp2); 1022 m->insert (tmp2, x, y, op);
1030 tmp2->x = x; 1023
1031 tmp2->y = y;
1032 insert_ob_in_map (tmp2, m, op, 0);
1033 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 1024 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL)
1034 insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2); 1025 tmp2->insert (arch_to_object (tmp2->other_arch));
1035 } 1026 }
1036 else 1027 else
1037 negblocked = 1; 1028 negblocked = 1;
1038 } 1029 }
1039 1030
… …
1046int 1037int
1047dimension_door (object *op, object *caster, object *spob, int dir) 1038dimension_door (object *op, object *caster, object *spob, int dir)
1048{ 1039{
1049 uint32 dist, maxdist; 1040 uint32 dist, maxdist;
1050 int mflags; 1041 int mflags;
1051 mapstruct *m; 1042 maptile *m;
1052 sint16 sx, sy; 1043 sint16 sx, sy;
1053 1044
1054 if (op->type != PLAYER) 1045 if (op->type != PLAYER)
1055 return 0; 1046 return 0;
1056 1047
… …
1088 { 1079 {
1089 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");
1090 op->contr->count = 0; 1081 op->contr->count = 0;
1091 return 0; 1082 return 0;
1092 } 1083 }
1084
1093 op->contr->count = 0; 1085 op->contr->count = 0;
1094 1086
1095 /* Remove code that puts player on random space on maps. IMO, 1087 /* Remove code that puts player on random space on maps. IMO,
1096 * 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,
1097 * 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
… …
1146 return 0; 1138 return 0;
1147 } 1139 }
1148 } 1140 }
1149 1141
1150 /* Actually move the player now */ 1142 /* Actually move the player now */
1151 remove_ob (op); 1143 if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
1152 op->x += freearr_x[dir] * dist;
1153 op->y += freearr_y[dir] * dist;
1154 if ((op = insert_ob_in_map (op, op->map, op, 0)) == NULL)
1155 return 1; 1144 return 1;
1156 1145
1157 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 */
1158 return 1; 1147 return 1;
1159} 1148}
… …
1172 object *poison; 1161 object *poison;
1173 int heal = 0, success = 0; 1162 int heal = 0, success = 0;
1174 1163
1175 tmp = find_target_for_friendly_spell (op, dir); 1164 tmp = find_target_for_friendly_spell (op, dir);
1176 1165
1177 if (tmp == NULL) 1166 if (!tmp)
1178 return 0; 1167 return 0;
1179 1168
1180 /* Figure out how many hp this spell might cure. 1169 /* Figure out how many hp this spell might cure.
1181 * could be zero if this spell heals effects, not damage. 1170 * could be zero if this spell heals effects, not damage.
1182 */ 1171 */
… …
1185 heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp; 1174 heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp;
1186 1175
1187 if (heal) 1176 if (heal)
1188 { 1177 {
1189 if (tmp->stats.hp >= tmp->stats.maxhp) 1178 if (tmp->stats.hp >= tmp->stats.maxhp)
1190 {
1191 new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed."); 1179 new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed.");
1192 }
1193 else 1180 else
1194 { 1181 {
1195 /* See how many points we actually heal. Instead of messages 1182 /* See how many points we actually heal. Instead of messages
1196 * based on type of spell, we instead do messages based 1183 * based on type of spell, we instead do messages based
1197 * on amount of damage healed. 1184 * on amount of damage healed.
… …
1199 if (heal > (tmp->stats.maxhp - tmp->stats.hp)) 1186 if (heal > (tmp->stats.maxhp - tmp->stats.hp))
1200 heal = tmp->stats.maxhp - tmp->stats.hp; 1187 heal = tmp->stats.maxhp - tmp->stats.hp;
1201 tmp->stats.hp += heal; 1188 tmp->stats.hp += heal;
1202 1189
1203 if (tmp->stats.hp >= tmp->stats.maxhp) 1190 if (tmp->stats.hp >= tmp->stats.maxhp)
1204 {
1205 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!"); 1191 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
1206 }
1207 else if (heal > 50) 1192 else if (heal > 50)
1208 {
1209 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!"); 1193 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");
1210 }
1211 else if (heal > 25) 1194 else if (heal > 25)
1212 {
1213 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close."); 1195 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");
1214 }
1215 else if (heal > 10) 1196 else if (heal > 10)
1216 {
1217 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade."); 1197 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade.");
1218 }
1219 else 1198 else
1220 {
1221 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close."); 1199 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close.");
1222 } 1200
1223 success = 1; 1201 success = 1;
1224 } 1202 }
1225 } 1203 }
1204
1226 if (spell->attacktype & AT_DISEASE) 1205 if (spell->attacktype & AT_DISEASE)
1227 if (cure_disease (tmp, op)) 1206 if (cure_disease (tmp, op))
1228 success = 1; 1207 success = 1;
1229 1208
1230 if (spell->attacktype & AT_POISON) 1209 if (spell->attacktype & AT_POISON)
… …
1236 success = 1; 1215 success = 1;
1237 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed"); 1216 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
1238 poison->stats.food = 1; 1217 poison->stats.food = 1;
1239 } 1218 }
1240 } 1219 }
1220
1241 if (spell->attacktype & AT_CONFUSION) 1221 if (spell->attacktype & AT_CONFUSION)
1242 { 1222 {
1243 poison = present_in_ob_by_name (FORCE, "confusion", tmp); 1223 poison = present_in_ob_by_name (FORCE, "confusion", tmp);
1244 if (poison) 1224 if (poison)
1245 { 1225 {
1246 success = 1; 1226 success = 1;
1247 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 1227 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
1248 poison->duration = 1; 1228 poison->duration = 1;
1249 } 1229 }
1250 } 1230 }
1231
1251 if (spell->attacktype & AT_BLIND) 1232 if (spell->attacktype & AT_BLIND)
1252 { 1233 {
1253 at = archetype::find ("blindness"); 1234 at = archetype::find ("blindness");
1254 poison = present_arch_in_ob (at, tmp); 1235 poison = present_arch_in_ob (at, tmp);
1255 if (poison) 1236 if (poison)
… …
1257 success = 1; 1238 success = 1;
1258 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return."); 1239 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
1259 poison->stats.food = 1; 1240 poison->stats.food = 1;
1260 } 1241 }
1261 } 1242 }
1243
1262 if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp) 1244 if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)
1263 { 1245 {
1264 tmp->stats.sp += spell->last_sp; 1246 tmp->stats.sp += spell->last_sp;
1265 if (tmp->stats.sp > tmp->stats.maxsp) 1247 if (tmp->stats.sp > tmp->stats.maxsp)
1266 tmp->stats.sp = tmp->stats.maxsp; 1248 tmp->stats.sp = tmp->stats.maxsp;
1267 success = 1; 1249 success = 1;
1268 new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!"); 1250 new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!");
1269 } 1251 }
1252
1270 if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace) 1253 if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)
1271 { 1254 {
1272 tmp->stats.grace += spell->last_grace; 1255 tmp->stats.grace += spell->last_grace;
1273 if (tmp->stats.grace > tmp->stats.maxgrace) 1256 if (tmp->stats.grace > tmp->stats.maxgrace)
1274 tmp->stats.grace = tmp->stats.maxgrace; 1257 tmp->stats.grace = tmp->stats.maxgrace;
1275 success = 1; 1258 success = 1;
1276 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!"); 1259 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1277 } 1260 }
1261
1278 if (spell->stats.food && tmp->stats.food < 999) 1262 if (spell->stats.food && tmp->stats.food < 999)
1279 { 1263 {
1280 tmp->stats.food += spell->stats.food; 1264 tmp->stats.food += spell->stats.food;
1281 if (tmp->stats.food > 999) 1265 if (tmp->stats.food > 999)
1282 tmp->stats.food = 999; 1266 tmp->stats.food = 999;
1283 success = 1; 1267 success = 1;
1284 /* We could do something a bit better like the messages for healing above */ 1268 /* We could do something a bit better like the messages for healing above */
1285 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 1269 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1286 } 1270 }
1271
1287 return success; 1272 return success;
1288} 1273}
1289 1274
1290 1275
1291/* This is used for the spells that gain stats. There are no spells 1276/* This is used for the spells that gain stats. There are no spells
… …
1303}; 1288};
1304 1289
1305int 1290int
1306cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent) 1291cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1307{ 1292{
1308 object *tmp, *tmp2 = NULL;
1309 object *force = NULL; 1293 object *force = NULL;
1310 int i; 1294 int i;
1311 1295
1312 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1296 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1313 if (dir != 0) 1297 object *tmp = dir
1314 {
1315 tmp = find_target_for_friendly_spell (op, dir); 1298 ? find_target_for_friendly_spell (op, dir)
1316 } 1299 : op;
1317 else
1318 {
1319 tmp = op;
1320 }
1321 1300
1322 if (tmp == NULL) 1301 if (!tmp)
1323 return 0; 1302 return 0;
1324 1303
1325 /* If we've already got a force of this type, don't add a new one. */ 1304 /* If we've already got a force of this type, don't add a new one. */
1326 for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) 1305 for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1327 { 1306 {
1328 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY) 1307 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1329 { 1308 {
1330 if (tmp2->name == spell_ob->name) 1309 if (tmp2->name == spell_ob->name)
1331 { 1310 {
… …
1433 force->stats.ac = spell_ob->stats.ac; 1412 force->stats.ac = spell_ob->stats.ac;
1434 force->attacktype = spell_ob->attacktype; 1413 force->attacktype = spell_ob->attacktype;
1435 1414
1436 insert_ob_in_ob (force, tmp); 1415 insert_ob_in_ob (force, tmp);
1437 change_abil (tmp, force); /* Mostly to display any messages */ 1416 change_abil (tmp, force); /* Mostly to display any messages */
1438 fix_player (tmp); 1417 tmp->update_stats ();
1439 return 1; 1418 return 1;
1440} 1419}
1441 1420
1442/* This used to be part of cast_change_ability, but it really didn't make 1421/* This used to be part of cast_change_ability, but it really didn't make
1443 * a lot of sense, since most of the values it derives are from the god 1422 * a lot of sense, since most of the values it derives are from the god
… …
1542 force->stats.wc = spell_ob->stats.wc; 1521 force->stats.wc = spell_ob->stats.wc;
1543 force->stats.ac = spell_ob->stats.ac; 1522 force->stats.ac = spell_ob->stats.ac;
1544 1523
1545 change_abil (tmp, force); /* Mostly to display any messages */ 1524 change_abil (tmp, force); /* Mostly to display any messages */
1546 insert_ob_in_ob (force, tmp); 1525 insert_ob_in_ob (force, tmp);
1547 fix_player (tmp); 1526 tmp->update_stats ();
1548 return 1; 1527 return 1;
1549} 1528}
1550
1551
1552 1529
1553/* Alchemy code by Mark Wedel 1530/* Alchemy code by Mark Wedel
1554 * 1531 *
1555 * This code adds a new spell, called alchemy. Alchemy will turn 1532 * This code adds a new spell, called alchemy. Alchemy will turn
1556 * objects to gold nuggets, the value of the gold nuggets being 1533 * objects to gold nuggets, the value of the gold nuggets being
… …
1566 * For example, if an item is worth 110 gold, you will get 1543 * For example, if an item is worth 110 gold, you will get
1567 * 4 large nuggets, and from 0-10 small nuggets. 1544 * 4 large nuggets, and from 0-10 small nuggets.
1568 * 1545 *
1569 * There is also a chance (1:30) that you will get nothing at all 1546 * There is also a chance (1:30) that you will get nothing at all
1570 * for the object. There is also a maximum weight that will be 1547 * for the object. There is also a maximum weight that will be
1571 * alchemied. 1548 * alchemised.
1572 */ 1549 */
1573
1574/* I didn't feel like passing these as arguements to the
1575 * two functions that need them. Real values are put in them
1576 * when the spell is cast, and these are freed when the spell
1577 * is finished.
1578 */
1579static object *small, *large;
1580
1581static void 1550static void
1582alchemy_object (object *obj, int *small_nuggets, int *large_nuggets, int *weight) 1551alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1583{ 1552{
1584 uint64 value = query_cost (obj, NULL, F_TRUE); 1553 uint64 value = query_cost (obj, NULL, F_TRUE);
1585 1554
1586 /* Give third price when we alchemy money (This should hopefully 1555 /* Give third price when we alchemy money (This should hopefully
1587 * make it so that it isn't worth it to alchemy money, sell 1556 * make it so that it isn't worth it to alchemy money, sell
1588 * the nuggets, alchemy the gold from that, etc. 1557 * the nuggets, alchemy the gold from that, etc.
1589 * Otherwise, give 9 silver on the gold for other objects, 1558 * Otherwise, give 9 silver on the gold for other objects,
1590 * so that it would still be more affordable to haul 1559 * so that it would still be more affordable to haul
1591 * the stuff back to town. 1560 * the stuff back to town.
1592 */ 1561 */
1593
1594 if (QUERY_FLAG (obj, FLAG_UNPAID)) 1562 if (QUERY_FLAG (obj, FLAG_UNPAID))
1595 value = 0; 1563 value = 0;
1596 else if (obj->type == MONEY || obj->type == GEM) 1564 else if (obj->type == MONEY || obj->type == GEM)
1597 value /= 3; 1565 value /= 3;
1598 else 1566 else
1599 value = (value * 9) / 10; 1567 value = value * 9 / 10;
1600 1568
1601 value /= 4; // fix by GHJ, don't understand, pcg
1602
1603 if ((obj->value > 0) && rndm (0, 29)) 1569 if (obj->value > 0 && rndm (0, 29))
1604 { 1570 total_value += value;
1605 int count;
1606 1571
1607 count = value / large->value;
1608 *large_nuggets += count;
1609 value -= (uint64) count *(uint64) large->value;
1610
1611 count = value / small->value;
1612 *small_nuggets += count;
1613 }
1614
1615 /* Turn 25 small nuggets into 1 large nugget. If the value
1616 * of large nuggets is not evenly divisable by the small nugget
1617 * value, take off an extra small_nugget (Assuming small_nuggets!=0)
1618 */
1619 if (*small_nuggets * small->value >= large->value)
1620 {
1621 (*large_nuggets)++;
1622 *small_nuggets -= large->value / small->value;
1623 if (*small_nuggets && large->value % small->value)
1624 (*small_nuggets)--;
1625 }
1626 weight += obj->weight; 1572 total_weight += obj->total_weight ();
1627 remove_ob (obj); 1573
1628 free_object (obj); 1574 obj->destroy ();
1629} 1575}
1630 1576
1631static void 1577static void
1632update_map (object *op, mapstruct *m, int small_nuggets, int large_nuggets, int x, int y) 1578update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1633{ 1579{
1634 object *tmp;
1635 int flag = 0; 1580 int flag = 0;
1636 1581
1637 /* Put any nuggets below the player, but we can only pass this 1582 /* Put any nuggets below the player, but we can only pass this
1638 * flag if we are on the same space as the player 1583 * flag if we are on the same space as the player
1639 */ 1584 */
1640 if (x == op->x && y == op->y && op->map == m) 1585 if (x == op->x && y == op->y && op->map == m)
1641 flag = INS_BELOW_ORIGINATOR; 1586 flag = INS_BELOW_ORIGINATOR;
1642 1587
1643 if (small_nuggets) 1588 if (small_nuggets)
1644 { 1589 {
1645 tmp = get_object (); 1590 object *tmp = small->clone ();
1646 copy_object (small, tmp);
1647 tmp->nrof = small_nuggets; 1591 tmp->nrof = small_nuggets;
1648 tmp->x = x;
1649 tmp->y = y;
1650 insert_ob_in_map (tmp, m, op, flag); 1592 m->insert (tmp, x, y, op, flag);
1651 } 1593 }
1594
1652 if (large_nuggets) 1595 if (large_nuggets)
1653 { 1596 {
1654 tmp = get_object (); 1597 object *tmp = large->clone ();
1655 copy_object (large, tmp);
1656 tmp->nrof = large_nuggets; 1598 tmp->nrof = large_nuggets;
1657 tmp->x = x;
1658 tmp->y = y;
1659 insert_ob_in_map (tmp, m, op, flag); 1599 m->insert (tmp, x, y, op, flag);
1660 } 1600 }
1601
1602 if (object *pl = m->at (x, y).player ())
1603 if (pl->contr->ns)
1604 pl->contr->ns->look_position = 0;
1661} 1605}
1662 1606
1663int 1607int
1664alchemy (object *op, object *caster, object *spell_ob) 1608alchemy (object *op, object *caster, object *spell_ob)
1665{ 1609{
1666 int x, y, weight = 0, weight_max, large_nuggets, small_nuggets, mflags;
1667 sint16 nx, ny;
1668 object *next, *tmp;
1669 mapstruct *mp;
1670
1671 if (op->type != PLAYER) 1610 if (op->type != PLAYER)
1672 return 0; 1611 return 0;
1673 1612
1613 object *large = get_archetype ("largenugget");
1614 object *small = get_archetype ("smallnugget");
1615
1674 /* Put a maximum weight of items that can be alchemied. Limits the power 1616 /* Put a maximum weight of items that can be alchemised. Limits the power
1675 * some, and also prevents people from alcheming every table/chair/clock 1617 * some, and also prevents people from alchemising every table/chair/clock
1676 * in sight 1618 * in sight
1677 */ 1619 */
1678 weight_max = spell_ob->duration + +SP_level_duration_adjust (caster, spell_ob); 1620 int duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1679 weight_max *= 1000; 1621 int weight_max = duration * 1000;
1680 small = get_archetype ("smallnugget"), large = get_archetype ("largenugget"); 1622 uint64 value_max = duration * 1000;
1681 1623
1624 int weight = 0;
1625
1682 for (y = op->y - 1; y <= op->y + 1; y++) 1626 for (int y = op->y - 1; y <= op->y + 1; y++)
1683 { 1627 {
1684 for (x = op->x - 1; x <= op->x + 1; x++) 1628 for (int x = op->x - 1; x <= op->x + 1; x++)
1685 { 1629 {
1630 uint64 value = 0;
1631
1686 nx = x; 1632 sint16 nx = x;
1687 ny = y; 1633 sint16 ny = y;
1688 1634
1689 mp = op->map; 1635 maptile *mp = op->map;
1690 1636
1691 mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny); 1637 int mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);
1692 1638
1693 if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC)) 1639 if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))
1694 continue; 1640 continue;
1695 1641
1696 /* Treat alchemy a little differently - most spell effects 1642 /* Treat alchemy a little differently - most spell effects
… …
1698 * ground level effect. 1644 * ground level effect.
1699 */ 1645 */
1700 if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK) 1646 if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)
1701 continue; 1647 continue;
1702 1648
1703 small_nuggets = 0; 1649 for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1704 large_nuggets = 0;
1705
1706 for (tmp = get_map_ob (mp, nx, ny); tmp != NULL; tmp = next)
1707 { 1650 {
1708 next = tmp->above; 1651 next = tmp->above;
1652
1709 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) && 1653 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&
1710 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON)) 1654 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))
1711 { 1655 {
1712
1713 if (tmp->inv) 1656 if (tmp->inv)
1714 { 1657 {
1715 object *next1, *tmp1; 1658 object *next1, *tmp1;
1716 1659
1717 for (tmp1 = tmp->inv; tmp1 != NULL; tmp1 = next1) 1660 for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1718 { 1661 {
1719 next1 = tmp1->below; 1662 next1 = tmp1->below;
1720 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) && 1663 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&
1721 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON)) 1664 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))
1722 alchemy_object (tmp1, &small_nuggets, &large_nuggets, &weight); 1665 alchemy_object (tmp1, value, weight);
1723 } 1666 }
1724 } 1667 }
1668
1725 alchemy_object (tmp, &small_nuggets, &large_nuggets, &weight); 1669 alchemy_object (tmp, value, weight);
1726 1670
1727 if (weight > weight_max) 1671 if (weight > weight_max)
1728 { 1672 break;
1729 update_map (op, mp, small_nuggets, large_nuggets, nx, ny);
1730 free_object (large);
1731 free_object (small);
1732 return 1;
1733 } 1673 }
1734 } /* is alchemable object */ 1674 }
1735 } /* process all objects on this space */ 1675
1676 value = min (value, value_max);
1677
1678 uint64 count = value / large->value;
1679 int large_nuggets = count;
1680 value -= count * large->value;
1681
1682 count = value / small->value;
1683 int small_nuggets = count;
1736 1684
1737 /* Insert all the nuggets at one time. This probably saves time, but 1685 /* Insert all the nuggets at one time. This probably saves time, but
1738 * it also prevents us from alcheming nuggets that were just created 1686 * it also prevents us from alcheming nuggets that were just created
1739 * with this spell. 1687 * with this spell.
1740 */ 1688 */
1741 update_map (op, mp, small_nuggets, large_nuggets, nx, ny); 1689 update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny);
1690
1691 if (weight > weight_max)
1692 goto bailout;
1742 } 1693 }
1743 } 1694 }
1744 free_object (large); 1695
1745 free_object (small); 1696bailout:
1746 /* reset this so that if player standing on a big pile of stuff, 1697 large->destroy ();
1747 * it is redrawn properly. 1698 small->destroy ();
1748 */
1749 op->contr->socket.look_position = 0;
1750 return 1; 1699 return 1;
1751} 1700}
1752 1701
1753 1702
1754/* This function removes the cursed/damned status on equipped 1703/* This function removes the cursed/damned status on equipped
… …
1763 for (tmp = op->inv; tmp; tmp = tmp->below) 1712 for (tmp = op->inv; tmp; tmp = tmp->below)
1764 if (QUERY_FLAG (tmp, FLAG_APPLIED) && 1713 if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
1765 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) || 1714 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1766 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED)))) 1715 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1767 { 1716 {
1768
1769 was_one++; 1717 was_one++;
1770 if (tmp->level <= caster_level (caster, spell)) 1718 if (tmp->level <= caster_level (caster, spell))
1771 { 1719 {
1772 success++; 1720 success++;
1773 if (QUERY_FLAG (spell, FLAG_DAMNED)) 1721 if (QUERY_FLAG (spell, FLAG_DAMNED))
… …
1782 } 1730 }
1783 1731
1784 if (op->type == PLAYER) 1732 if (op->type == PLAYER)
1785 { 1733 {
1786 if (success) 1734 if (success)
1787 {
1788 new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now."); 1735 new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");
1789 }
1790 else 1736 else
1791 { 1737 {
1792 if (was_one) 1738 if (was_one)
1793 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse."); 1739 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");
1794 else 1740 else
1795 new_draw_info (NDI_UNIQUE, 0, op, "You are not using any cursed items."); 1741 new_draw_info (NDI_UNIQUE, 0, op, "You are not using any cursed items.");
1796 } 1742 }
1797 } 1743 }
1744
1798 return success; 1745 return success;
1799} 1746}
1800 1747
1801/* Identifies objects in the players inventory/on the ground */ 1748/* Identifies objects in the players inventory/on the ground */
1802 1749
… …
1809 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1756 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1810 1757
1811 if (num_ident < 1) 1758 if (num_ident < 1)
1812 num_ident = 1; 1759 num_ident = 1;
1813 1760
1814
1815 for (tmp = op->inv; tmp; tmp = tmp->below) 1761 for (tmp = op->inv; tmp; tmp = tmp->below)
1816 { 1762 {
1817 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1763 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1818 { 1764 {
1819 identify (tmp); 1765 identify (tmp);
1766
1820 if (op->type == PLAYER) 1767 if (op->type == PLAYER)
1821 { 1768 {
1822 new_draw_info_format (NDI_UNIQUE, 0, op, "You have %s.", long_desc (tmp, op)); 1769 new_draw_info_format (NDI_UNIQUE, 0, op, "You have %s.", long_desc (tmp, op));
1770
1823 if (tmp->msg) 1771 if (tmp->msg)
1824 { 1772 {
1825 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:"); 1773 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1826 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg); 1774 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1827 } 1775 }
1828 } 1776 }
1777
1829 num_ident--; 1778 num_ident--;
1830 success = 1; 1779 success = 1;
1831 if (!num_ident) 1780 if (!num_ident)
1832 break; 1781 break;
1833 } 1782 }
1834 } 1783 }
1784
1835 /* If all the power of the spell has been used up, don't go and identify 1785 /* If all the power of the spell has been used up, don't go and identify
1836 * stuff on the floor. Only identify stuff on the floor if the spell 1786 * stuff on the floor. Only identify stuff on the floor if the spell
1837 * was not fully used. 1787 * was not fully used.
1838 */ 1788 */
1839 if (num_ident) 1789 if (num_ident)
1840 { 1790 {
1841 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 1791 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
1842 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1792 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1843 { 1793 {
1844
1845 identify (tmp); 1794 identify (tmp);
1795
1846 if (op->type == PLAYER) 1796 if (op->type == PLAYER)
1847 { 1797 {
1848 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op)); 1798 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op));
1799
1849 if (tmp->msg) 1800 if (tmp->msg)
1850 { 1801 {
1851 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:"); 1802 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1852 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg); 1803 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1853 } 1804 }
1805
1854 esrv_send_item (op, tmp); 1806 esrv_send_item (op, tmp);
1855 } 1807 }
1808
1856 num_ident--; 1809 num_ident--;
1857 success = 1; 1810 success = 1;
1858 if (!num_ident) 1811 if (!num_ident)
1859 break; 1812 break;
1860 } 1813 }
1861 } 1814 }
1815
1862 if (!success) 1816 if (!success)
1863 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified."); 1817 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified.");
1864 else 1818 else
1865 {
1866 spell_effect (spell, op->x, op->y, op->map, op); 1819 spell_effect (spell, op->x, op->y, op->map, op);
1867 } 1820
1868 return success; 1821 return success;
1869} 1822}
1870
1871 1823
1872int 1824int
1873cast_detection (object *op, object *caster, object *spell, object *skill) 1825cast_detection (object *op, object *caster, object *spell, object *skill)
1874{ 1826{
1875 object *tmp, *last, *god, *detect; 1827 object *tmp, *last, *god, *detect;
1876 int done_one, range, mflags, floor, level; 1828 int done_one, range, mflags, floor, level;
1877 sint16 x, y, nx, ny; 1829 sint16 x, y, nx, ny;
1878 mapstruct *m; 1830 maptile *m;
1879 1831
1880 /* We precompute some values here so that we don't have to keep 1832 /* We precompute some values here so that we don't have to keep
1881 * doing it over and over again. 1833 * doing it over and over again.
1882 */ 1834 */
1883 god = find_god (determine_god (op)); 1835 god = find_god (determine_god (op));
… …
1888 skill = caster; 1840 skill = caster;
1889 1841
1890 for (x = op->x - range; x <= op->x + range; x++) 1842 for (x = op->x - range; x <= op->x + range; x++)
1891 for (y = op->y - range; y <= op->y + range; y++) 1843 for (y = op->y - range; y <= op->y + range; y++)
1892 { 1844 {
1893
1894 m = op->map; 1845 m = op->map;
1895 mflags = get_map_flags (m, &m, x, y, &nx, &ny); 1846 mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1896 if (mflags & P_OUT_OF_MAP) 1847 if (mflags & P_OUT_OF_MAP)
1897 continue; 1848 continue;
1898 1849
… …
1900 * floor. But this is not true for show invisible. 1851 * floor. But this is not true for show invisible.
1901 * Basically, we just go and find the top object and work 1852 * Basically, we just go and find the top object and work
1902 * down - that is easier than working up. 1853 * down - that is easier than working up.
1903 */ 1854 */
1904 1855
1905 for (last = NULL, tmp = get_map_ob (m, nx, ny); tmp; tmp = tmp->above) 1856 for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above)
1906 last = tmp; 1857 last = tmp;
1858
1907 /* Shouldn't happen, but if there are no objects on a space, this 1859 /* Shouldn't happen, but if there are no objects on a space, this
1908 * would happen. 1860 * would happen.
1909 */ 1861 */
1910 if (!last) 1862 if (!last)
1911 continue; 1863 continue;
… …
1913 done_one = 0; 1865 done_one = 0;
1914 floor = 0; 1866 floor = 0;
1915 detect = NULL; 1867 detect = NULL;
1916 for (tmp = last; tmp; tmp = tmp->below) 1868 for (tmp = last; tmp; tmp = tmp->below)
1917 { 1869 {
1918
1919 /* show invisible */ 1870 /* show invisible */
1920 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) && 1871 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&
1921 /* Might there be other objects that we can make visibile? */ 1872 /* Might there be other objects that we can make visible? */
1922 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) || 1873 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) ||
1923 (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) || 1874 (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) ||
1924 tmp->type == CF_HANDLE || 1875 tmp->type == CF_HANDLE ||
1925 tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE || 1876 tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE ||
1926 tmp->type == BUTTON || tmp->type == TELEPORTER || 1877 tmp->type == BUTTON || tmp->type == TELEPORTER ||
… …
1933 { 1884 {
1934 tmp->invisible = 0; 1885 tmp->invisible = 0;
1935 done_one = 1; 1886 done_one = 1;
1936 } 1887 }
1937 } 1888 }
1889
1938 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1890 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1939 floor = 1; 1891 floor = 1;
1940 1892
1941 /* All detections below this point don't descend beneath the floor, 1893 /* All detections below this point don't descend beneath the floor,
1942 * so just continue on. We could be clever and look at the type of 1894 * so just continue on. We could be clever and look at the type of
… …
1995 */ 1947 */
1996 if (done_one) 1948 if (done_one)
1997 { 1949 {
1998 object *detect_ob = arch_to_object (spell->other_arch); 1950 object *detect_ob = arch_to_object (spell->other_arch);
1999 1951
2000 detect_ob->x = nx;
2001 detect_ob->y = ny;
2002 /* if this is set, we want to copy the face */ 1952 /* if this is set, we want to copy the face */
2003 if (done_one == 2 && detect) 1953 if (done_one == 2 && detect)
2004 { 1954 {
2005 detect_ob->face = detect->face; 1955 detect_ob->face = detect->face;
2006 detect_ob->animation_id = detect->animation_id; 1956 detect_ob->animation_id = detect->animation_id;
… …
2008 detect_ob->last_anim = 0; 1958 detect_ob->last_anim = 0;
2009 /* by default, the detect_ob is already animated */ 1959 /* by default, the detect_ob is already animated */
2010 if (!QUERY_FLAG (detect, FLAG_ANIMATE)) 1960 if (!QUERY_FLAG (detect, FLAG_ANIMATE))
2011 CLEAR_FLAG (detect_ob, FLAG_ANIMATE); 1961 CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
2012 } 1962 }
1963
2013 insert_ob_in_map (detect_ob, m, op, 0); 1964 m->insert (detect_ob, nx, ny, op);
2014 } 1965 }
2015 } /* for processing the surrounding spaces */ 1966 } /* for processing the surrounding spaces */
2016 1967
2017 1968
2018 /* Now process objects in the players inventory if detect curse or magic */ 1969 /* Now process objects in the players inventory if detect curse or magic */
… …
2067 2018
2068 /* Explodes a fireball centered at player */ 2019 /* Explodes a fireball centered at player */
2069 tmp = get_archetype (EXPLODING_FIREBALL); 2020 tmp = get_archetype (EXPLODING_FIREBALL);
2070 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1; 2021 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
2071 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2; 2022 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
2072 tmp->x = victim->x; 2023
2073 tmp->y = victim->y; 2024 tmp->insert_at (victim);
2074 insert_ob_in_map (tmp, victim->map, NULL, 0);
2075 victim->stats.sp = 2 * victim->stats.maxsp; 2025 victim->stats.sp = 2 * victim->stats.maxsp;
2076 } 2026 }
2077 else if (victim->stats.sp >= victim->stats.maxsp * 1.88) 2027 else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
2078 {
2079 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode."); 2028 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode.");
2080 }
2081 else if (victim->stats.sp >= victim->stats.maxsp * 1.66) 2029 else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
2082 {
2083 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!"); 2030 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
2084 }
2085 else if (victim->stats.sp >= victim->stats.maxsp * 1.5) 2031 else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
2086 { 2032 {
2087 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world."); 2033 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
2088 confuse_player (victim, victim, 99); 2034 confuse_player (victim, victim, 99);
2089 } 2035 }
2090 else if (victim->stats.sp >= victim->stats.maxsp * 1.25) 2036 else if (victim->stats.sp >= victim->stats.maxsp * 1.25)
2091 {
2092 new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices."); 2037 new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");
2093 }
2094} 2038}
2095 2039
2096/* cast_transfer 2040/* cast_transfer
2097 * This spell transfers sp from the player to another person. 2041 * This spell transfers sp from the player to another person.
2098 * We let the target go above their normal maximum SP. 2042 * We let the target go above their normal maximum SP.
… …
2101int 2045int
2102cast_transfer (object *op, object *caster, object *spell, int dir) 2046cast_transfer (object *op, object *caster, object *spell, int dir)
2103{ 2047{
2104 object *plyr = NULL; 2048 object *plyr = NULL;
2105 sint16 x, y; 2049 sint16 x, y;
2106 mapstruct *m; 2050 maptile *m;
2107 int mflags; 2051 int mflags;
2108 2052
2109 m = op->map; 2053 m = op->map;
2110 x = op->x + freearr_x[dir]; 2054 x = op->x + freearr_x[dir];
2111 y = op->y + freearr_y[dir]; 2055 y = op->y + freearr_y[dir];
2112 2056
2113 mflags = get_map_flags (m, &m, x, y, &x, &y); 2057 mflags = get_map_flags (m, &m, x, y, &x, &y);
2114 2058
2115 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) 2059 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
2116 { 2060 {
2117 for (plyr = get_map_ob (m, x, y); plyr != NULL; plyr = plyr->above) 2061 for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)
2118 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 2062 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))
2119 break; 2063 break;
2120 } 2064 }
2121 2065
2122 2066
2123 /* If we did not find a player in the specified direction, transfer 2067 /* If we did not find a player in the specified direction, transfer
2124 * to anyone on top of us. This is used for the rune of transference mostly. 2068 * to anyone on top of us. This is used for the rune of transference mostly.
2125 */ 2069 */
2126 if (plyr == NULL) 2070 if (plyr == NULL)
2127 for (plyr = get_map_ob (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above) 2071 for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)
2128 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 2072 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE))
2129 break; 2073 break;
2130 2074
2131 if (!plyr) 2075 if (!plyr)
2132 { 2076 {
… …
2177void 2121void
2178counterspell (object *op, int dir) 2122counterspell (object *op, int dir)
2179{ 2123{
2180 object *tmp, *head, *next; 2124 object *tmp, *head, *next;
2181 int mflags; 2125 int mflags;
2182 mapstruct *m; 2126 maptile *m;
2183 sint16 sx, sy; 2127 sint16 sx, sy;
2184 2128
2185 sx = op->x + freearr_x[dir]; 2129 sx = op->x + freearr_x[dir];
2186 sy = op->y + freearr_y[dir]; 2130 sy = op->y + freearr_y[dir];
2187 m = op->map; 2131 m = op->map;
2188 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy); 2132 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
2189 if (mflags & P_OUT_OF_MAP) 2133 if (mflags & P_OUT_OF_MAP)
2190 return; 2134 return;
2191 2135
2192 for (tmp = get_map_ob (m, sx, sy); tmp != NULL; tmp = next) 2136 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next)
2193 { 2137 {
2194 next = tmp->above; 2138 next = tmp->above;
2195 2139
2196 /* Need to look at the head object - otherwise, if tmp 2140 /* Need to look at the head object - otherwise, if tmp
2197 * points to a monster, we don't have all the necessary 2141 * points to a monster, we don't have all the necessary
… …
2209 /* Basically, if the object is magical and not counterspell, 2153 /* Basically, if the object is magical and not counterspell,
2210 * we will more or less remove the object. Don't counterspell 2154 * we will more or less remove the object. Don't counterspell
2211 * monsters either. 2155 * monsters either.
2212 */ 2156 */
2213 2157
2214 if (head->attacktype & AT_MAGIC && 2158 if (head->attacktype & AT_MAGIC
2215 !(head->attacktype & AT_COUNTERSPELL) && !QUERY_FLAG (head, FLAG_MONSTER) && (op->level > head->level)) 2159 && !(head->attacktype & AT_COUNTERSPELL)
2216 { 2160 && !QUERY_FLAG (head, FLAG_MONSTER)
2217 remove_ob (head); 2161 && (op->level > head->level))
2218 free_object (head); 2162 head->destroy ();
2219 }
2220 else 2163 else
2221 switch (head->type) 2164 switch (head->type)
2222 { 2165 {
2223 case SPELL_EFFECT: 2166 case SPELL_EFFECT:
2167 // XXX: Don't affect floor spelleffects. See also XXX comment
2168 // about sanctuary in spell_util.C
2169 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2170 continue;
2171
2224 if (op->level > head->level) 2172 if (op->level > head->level)
2225 { 2173 head->destroy ();
2226 remove_ob (head); 2174
2227 free_object (head);
2228 }
2229 break; 2175 break;
2230 2176
2231 /* I really don't get this rune code that much - that 2177 /* I really don't get this rune code that much - that
2232 * random chance seems really low. 2178 * random chance seems really low.
2233 */ 2179 */
2234 case RUNE: 2180 case RUNE:
2235 if (rndm (0, 149) == 0) 2181 if (rndm (0, 149) == 0)
2236 { 2182 {
2237 head->stats.hp--; /* weaken the rune */ 2183 head->stats.hp--; /* weaken the rune */
2238 if (!head->stats.hp) 2184 if (!head->stats.hp)
2239 { 2185 head->destroy ();
2240 remove_ob (head);
2241 free_object (head);
2242 }
2243 } 2186 }
2244 break; 2187 break;
2245 } 2188 }
2246 } 2189 }
2247} 2190}
… …
2308{ 2251{
2309 object *weapon, *tmp; 2252 object *weapon, *tmp;
2310 char buf[MAX_BUF]; 2253 char buf[MAX_BUF];
2311 int a, i; 2254 int a, i;
2312 sint16 x, y; 2255 sint16 x, y;
2313 mapstruct *m; 2256 maptile *m;
2314 materialtype_t *mt; 2257 materialtype_t *mt;
2315 2258
2316 if (!spell->other_arch) 2259 if (!spell->other_arch)
2317 { 2260 {
2318 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 2261 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
… …
2322 /* exit if it's not a player using this spell. */ 2265 /* exit if it's not a player using this spell. */
2323 if (op->type != PLAYER) 2266 if (op->type != PLAYER)
2324 return 0; 2267 return 0;
2325 2268
2326 /* if player already has a golem, abort */ 2269 /* if player already has a golem, abort */
2327 if (op->contr->ranges[range_golem] != NULL && op->contr->golem_count == op->contr->ranges[range_golem]->count) 2270 if (op->contr->ranges[range_golem])
2328 { 2271 {
2329 control_golem (op->contr->ranges[range_golem], dir); 2272 control_golem (op->contr->ranges[range_golem], dir);
2330 return 0; 2273 return 0;
2331 } 2274 }
2332 2275
… …
2380 /* create the golem object */ 2323 /* create the golem object */
2381 tmp = arch_to_object (spell->other_arch); 2324 tmp = arch_to_object (spell->other_arch);
2382 2325
2383 /* if animated by a player, give the player control of the golem */ 2326 /* if animated by a player, give the player control of the golem */
2384 CLEAR_FLAG (tmp, FLAG_MONSTER); 2327 CLEAR_FLAG (tmp, FLAG_MONSTER);
2385 SET_FLAG (tmp, FLAG_FRIENDLY);
2386 tmp->stats.exp = 0; 2328 tmp->stats.exp = 0;
2387 add_friendly_object (tmp); 2329 add_friendly_object (tmp);
2388 tmp->type = GOLEM; 2330 tmp->type = GOLEM;
2389 set_owner (tmp, op); 2331 tmp->set_owner (op);
2390 set_spell_skill (op, caster, spell, tmp); 2332 set_spell_skill (op, caster, spell, tmp);
2391 op->contr->ranges[range_golem] = tmp; 2333 op->contr->ranges[range_golem] = tmp;
2392 op->contr->shoottype = range_golem; 2334 op->contr->shoottype = range_golem;
2393 op->contr->golem_count = tmp->count;
2394 2335
2395 /* Give the weapon to the golem now. A bit of a hack to check the 2336 /* Give the weapon to the golem now. A bit of a hack to check the
2396 * removed flag - it should only be set if get_split_object was 2337 * removed flag - it should only be set if get_split_object was
2397 * used above. 2338 * used above.
2398 */ 2339 */
2399 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2340 if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2400 remove_ob (weapon); 2341 weapon->remove ();
2401 insert_ob_in_ob (weapon, tmp); 2342 insert_ob_in_ob (weapon, tmp);
2402 esrv_send_item (op, weapon); 2343 esrv_send_item (op, weapon);
2403 /* To do everything necessary to let a golem use the weapon is a pain, 2344 /* To do everything necessary to let a golem use the weapon is a pain,
2404 * so instead, just set it as equipped (otherwise, we need to update 2345 * so instead, just set it as equipped (otherwise, we need to update
2405 * body_info, skills, etc) 2346 * body_info, skills, etc)
2406 */ 2347 */
2407 SET_FLAG (tmp, FLAG_USE_WEAPON); 2348 SET_FLAG (tmp, FLAG_USE_WEAPON);
2408 SET_FLAG (weapon, FLAG_APPLIED); 2349 SET_FLAG (weapon, FLAG_APPLIED);
2409 fix_player (tmp); 2350 tmp->update_stats ();
2410 2351
2411 /* There used to be 'odd' code that basically seemed to take the absolute 2352 /* There used to be 'odd' code that basically seemed to take the absolute
2412 * value of the weapon->magic an use that. IMO, that doesn't make sense - 2353 * value of the weapon->magic an use that. IMO, that doesn't make sense -
2413 * if you're using a crappy weapon, it shouldn't be as good. 2354 * if you're using a crappy weapon, it shouldn't be as good.
2414 */ 2355 */
… …
2466 if (a > 14) 2407 if (a > 14)
2467 a = 14; 2408 a = 14;
2468 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a)); 2409 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2469 2410
2470 /* Determine golem's speed */ 2411 /* Determine golem's speed */
2471 tmp->speed = 0.4 + 0.1 * SP_level_range_adjust (caster, spell); 2412 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2472
2473 if (tmp->speed > 3.33)
2474 tmp->speed = 3.33;
2475 2413
2476 if (!spell->race) 2414 if (!spell->race)
2477 { 2415 {
2478 sprintf (buf, "animated %s", &weapon->name); 2416 sprintf (buf, "animated %s", &weapon->name);
2479 tmp->name = buf; 2417 tmp->name = buf;
… …
2481 tmp->face = weapon->face; 2419 tmp->face = weapon->face;
2482 tmp->animation_id = weapon->animation_id; 2420 tmp->animation_id = weapon->animation_id;
2483 tmp->anim_speed = weapon->anim_speed; 2421 tmp->anim_speed = weapon->anim_speed;
2484 tmp->last_anim = weapon->last_anim; 2422 tmp->last_anim = weapon->last_anim;
2485 tmp->state = weapon->state; 2423 tmp->state = weapon->state;
2486 if (QUERY_FLAG (weapon, FLAG_ANIMATE)) 2424 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2487 {
2488 SET_FLAG (tmp, FLAG_ANIMATE);
2489 }
2490 else
2491 {
2492 CLEAR_FLAG (tmp, FLAG_ANIMATE);
2493 }
2494 update_ob_speed (tmp);
2495 } 2425 }
2496 2426
2497 /* make experience increase in proportion to the strength of the summoned creature. */ 2427 /* make experience increase in proportion to the strength of the summoned creature. */
2498 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell)); 2428 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));
2499 2429
2500 tmp->speed_left = -1; 2430 tmp->speed_left = -1;
2501 tmp->x = x;
2502 tmp->y = y;
2503 tmp->direction = dir; 2431 tmp->direction = dir;
2504 insert_ob_in_map (tmp, m, op, 0); 2432
2433 m->insert (tmp, x, y, op);
2505 return 1; 2434 return 1;
2506} 2435}
2507 2436
2508/* cast_daylight() - changes the map darkness level *lower* */ 2437/* cast_daylight() - changes the map darkness level *lower* */
2509 2438
… …
2517 int success; 2446 int success;
2518 2447
2519 if (!op->map) 2448 if (!op->map)
2520 return 0; /* shouldnt happen */ 2449 return 0; /* shouldnt happen */
2521 2450
2522 success = change_map_light (op->map, spell->stats.dam); 2451 success = op->map->change_map_light (spell->stats.dam);
2452
2523 if (!success) 2453 if (!success)
2524 { 2454 {
2525 if (spell->stats.dam < 0) 2455 if (spell->stats.dam < 0)
2526 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here."); 2456 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2527 else 2457 else
… …
2552 2482
2553 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2483 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2554 2484
2555 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2485 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2556 2486
2557 set_owner (new_aura, op); 2487 new_aura->set_owner (op);
2558 set_spell_skill (op, caster, spell, new_aura); 2488 set_spell_skill (op, caster, spell, new_aura);
2559 new_aura->attacktype = spell->attacktype; 2489 new_aura->attacktype = spell->attacktype;
2560 2490
2561 new_aura->level = caster_level (caster, spell); 2491 new_aura->level = caster_level (caster, spell);
2562 if (refresh) 2492 if (refresh)
… …
2580void 2510void
2581move_aura (object *aura) 2511move_aura (object *aura)
2582{ 2512{
2583 int i, mflags; 2513 int i, mflags;
2584 object *env; 2514 object *env;
2585 mapstruct *m; 2515 maptile *m;
2586 2516
2587 /* auras belong in inventories */ 2517 /* auras belong in inventories */
2588 env = aura->env; 2518 env = aura->env;
2589 2519
2590 /* no matter what we've gotta remove the aura... 2520 /* no matter what we've gotta remove the aura...
2591 * we'll put it back if its time isn't up. 2521 * we'll put it back if its time isn't up.
2592 */ 2522 */
2593 remove_ob (aura); 2523 aura->remove ();
2594 2524
2595 /* exit if we're out of gas */ 2525 /* exit if we're out of gas */
2596 if (aura->duration-- < 0) 2526 if (aura->duration-- < 0)
2597 { 2527 {
2598 free_object (aura); 2528 aura->destroy ();
2599 return; 2529 return;
2600 } 2530 }
2601 2531
2602 /* auras only exist in inventories */ 2532 /* auras only exist in inventories */
2603 if (env == NULL || env->map == NULL) 2533 if (env == NULL || env->map == NULL)
2604 { 2534 {
2605 free_object (aura); 2535 aura->destroy ();
2606 return; 2536 return;
2607 } 2537 }
2608 aura->x = env->x;
2609 aura->y = env->y;
2610 2538
2611 /* we need to jump out of the inventory for a bit 2539 /* we need to jump out of the inventory for a bit
2612 * in order to hit the map conveniently. 2540 * in order to hit the map conveniently.
2613 */ 2541 */
2614 insert_ob_in_map (aura, env->map, aura, 0); 2542 aura->insert_at (env, aura);
2615 2543
2616 for (i = 1; i < 9; i++) 2544 for (i = 1; i < 9; i++)
2617 { 2545 {
2618 sint16 nx, ny; 2546 sint16 nx, ny;
2619 2547
… …
2628 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny)))) 2556 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))
2629 { 2557 {
2630 hit_map (aura, i, aura->attacktype, 0); 2558 hit_map (aura, i, aura->attacktype, 0);
2631 2559
2632 if (aura->other_arch) 2560 if (aura->other_arch)
2633 { 2561 m->insert (arch_to_object (aura->other_arch), nx, ny, aura);
2634 object *new_ob;
2635
2636 new_ob = arch_to_object (aura->other_arch);
2637 new_ob->x = nx;
2638 new_ob->y = ny;
2639 insert_ob_in_map (new_ob, m, aura, 0);
2640 } 2562 }
2641 }
2642 } 2563 }
2564
2643 /* put the aura back in the player's inventory */ 2565 /* put the aura back in the player's inventory */
2644 remove_ob (aura); 2566 aura->remove ();
2645 insert_ob_in_ob (aura, env); 2567 insert_ob_in_ob (aura, env);
2646} 2568}
2647 2569
2648/* moves the peacemaker spell. 2570/* moves the peacemaker spell.
2649 * op is the piece object. 2571 * op is the piece object.
… …
2652void 2574void
2653move_peacemaker (object *op) 2575move_peacemaker (object *op)
2654{ 2576{
2655 object *tmp; 2577 object *tmp;
2656 2578
2657 for (tmp = get_map_ob (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 2579 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2658 { 2580 {
2659 int atk_lev, def_lev; 2581 int atk_lev, def_lev;
2660 object *victim = tmp; 2582 object *victim = tmp;
2661 2583
2662 if (tmp->head) 2584 if (tmp->head)
… …
2673 2595
2674 if (rndm (0, atk_lev - 1) > def_lev) 2596 if (rndm (0, atk_lev - 1) > def_lev)
2675 { 2597 {
2676 /* make this sucker peaceful. */ 2598 /* make this sucker peaceful. */
2677 2599
2678 change_exp (get_owner (op), victim->stats.exp, op->skill, 0); 2600 change_exp (op->owner, victim->stats.exp, op->skill, 0);
2679 victim->stats.exp = 0; 2601 victim->stats.exp = 0;
2680#if 0 2602#if 0
2681 /* No idea why these were all set to zero - if something 2603 /* No idea why these were all set to zero - if something
2682 * makes this creature agressive, he should still do damage. 2604 * makes this creature agressive, he should still do damage.
2683 */ 2605 */
… …
2728 2650
2729 snprintf (rune, sizeof (rune), "%s\n", msg); 2651 snprintf (rune, sizeof (rune), "%s\n", msg);
2730 2652
2731 tmp->race = op->name; /*Save the owner of the rune */ 2653 tmp->race = op->name; /*Save the owner of the rune */
2732 tmp->msg = rune; 2654 tmp->msg = rune;
2733 tmp->x = op->x; 2655
2734 tmp->y = op->y; 2656 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2735 insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
2736 return 1; 2657 return 1;
2737} 2658}

Diff Legend

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