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.22 by root, Wed Dec 20 09:14:22 2006 UTC vs.
Revision 1.60 by root, Sun Jun 24 01:09:28 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
4 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * Crossfire TRT is free software; you can redistribute it and/or modify it
8 it under the terms of the GNU General Public License as published by 9 * under the terms of the GNU General Public License as published by the Free
9 the Free Software Foundation; either version 2 of the License, or 10 * Software Foundation; either version 2 of the License, or (at your option)
10 (at your option) any later version. 11 * 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, but
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 GNU General Public License for more details. 16 * 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 along
18 along with this program; if not, write to the Free Software 19 * with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 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 to <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;
… …
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 wand->destroy (); 77 wand->destroy ();
80 tmp = get_archetype ("fireball"); 78 tmp = get_archetype ("fireball");
81 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
82 if (!tmp->stats.dam) 81 if (!tmp->stats.dam)
83 tmp->stats.dam = 1; 82 tmp->stats.dam = 1;
83
84 tmp->stats.hp = tmp->stats.dam / 2; 84 tmp->stats.hp = tmp->stats.dam / 2;
85
85 if (tmp->stats.hp < 2) 86 if (tmp->stats.hp < 2)
86 tmp->stats.hp = 2; 87 tmp->stats.hp = 2;
87 tmp->x = op->x; 88
88 tmp->y = op->y; 89 tmp->insert_at (op);
89 insert_ob_in_map (tmp, op->map, NULL, 0);
90 return 1; 90 return 1;
91 } 91 }
92 92
93 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
94 if (wand->inv && wand->inv->level) 95 if (wand->inv && wand->inv->level)
95 ncharges /= wand->inv->level; 96 ncharges /= wand->inv->level;
96 else 97 else
97 { 98 {
98 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));
99 return 0; 100 return 0;
100 } 101 }
102
101 if (!ncharges) 103 if (!ncharges)
102 ncharges = 1; 104 ncharges = 1;
103 105
104 wand->stats.food += ncharges; 106 wand->stats.food += ncharges;
105 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
106 if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE)) 109 if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE))
107 { 110 {
108 SET_FLAG (wand, FLAG_ANIMATE); 111 SET_FLAG (wand, FLAG_ANIMATE);
109 wand->speed = wand->arch->clone.speed; 112 wand->set_speed (wand->arch->speed);
110 update_ob_speed (wand);
111 } 113 }
114
112 return 1; 115 return 1;
113} 116}
114 117
115/* 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
116 * 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
… …
151 /* If it starts with a letter, presume it is a description */ 154 /* If it starts with a letter, presume it is a description */
152 if (isalpha (*stringarg)) 155 if (isalpha (*stringarg))
153 { 156 {
154 artifact *al = find_artifactlist (missile->type)->items; 157 artifact *al = find_artifactlist (missile->type)->items;
155 158
156 for (; al != NULL; al = al->next) 159 for (; al; al = al->next)
157 if (!strcasecmp (al->item->name, stringarg)) 160 if (!strcasecmp (al->item->name, stringarg))
158 break; 161 break;
159 162
160 if (!al) 163 if (!al)
161 { 164 {
… …
221 if (stringarg) 224 if (stringarg)
222 { 225 {
223 at = find_archetype_by_object_type_name (FOOD, stringarg); 226 at = find_archetype_by_object_type_name (FOOD, stringarg);
224 if (at == NULL) 227 if (at == NULL)
225 at = find_archetype_by_object_type_name (DRINK, stringarg); 228 at = find_archetype_by_object_type_name (DRINK, stringarg);
226 if (at == NULL || at->clone.stats.food > food_value) 229 if (at == NULL || at->stats.food > food_value)
227 stringarg = NULL; 230 stringarg = NULL;
228 } 231 }
229 232
230 if (!stringarg) 233 if (!stringarg)
231 { 234 {
… …
237 * We don't use flesh types because the weight values of those need 240 * We don't use flesh types because the weight values of those need
238 * to be altered from the donor. 241 * to be altered from the donor.
239 */ 242 */
240 243
241 /* We assume the food items don't have multiple parts */ 244 /* We assume the food items don't have multiple parts */
242 for (at_tmp = first_archetype; at_tmp != NULL; at_tmp = at_tmp->next) 245 for_all_archetypes (at_tmp)
243 { 246 {
244 if (at_tmp->clone.type == FOOD || at_tmp->clone.type == DRINK) 247 if (at_tmp->type == FOOD || at_tmp->type == DRINK)
245 { 248 {
246 /* Basically, if the food value is something that is creatable 249 /* Basically, if the food value is something that is creatable
247 * under the limits of the spell and it is higher than 250 * under the limits of the spell and it is higher than
248 * the item we have now, take it instead. 251 * the item we have now, take it instead.
249 */ 252 */
250 if (at_tmp->clone.stats.food <= food_value && (!at || at_tmp->clone.stats.food > at->clone.stats.food)) 253 if (at_tmp->stats.food <= food_value
254 && (!at
255 || at_tmp->stats.food > at->stats.food
256 || (at_tmp->stats.food == at->stats.food
257 && at_tmp->weight < at->weight)))
251 at = at_tmp; 258 at = at_tmp;
252 } 259 }
253 } 260 }
254 } 261 }
255 /* Pretty unlikely (there are some very low food items), but you never 262 /* Pretty unlikely (there are some very low food items), but you never
… …
259 { 266 {
260 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food."); 267 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");
261 return 0; 268 return 0;
262 } 269 }
263 270
264 food_value /= at->clone.stats.food; 271 food_value /= at->stats.food;
265 new_op = arch_to_object (at); 272 new_op = arch_to_object (at);
266 new_op->nrof = food_value; 273 new_op->nrof = food_value;
267 274
268 new_op->value = 0; 275 new_op->value = 0;
269 if (new_op->nrof < 1) 276 if (new_op->nrof < 1)
… …
370 * normal applies. 377 * normal applies.
371 */ 378 */
372int 379int
373cast_invisible (object *op, object *caster, object *spell_ob) 380cast_invisible (object *op, object *caster, object *spell_ob)
374{ 381{
375 object *tmp;
376
377 if (op->invisible > 1000) 382 if (op->invisible > 1000)
378 { 383 {
379 new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further"); 384 new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further");
380 return 0; 385 return 0;
381 } 386 }
… …
397 else 402 else
398 op->contr->tmp_invis = 1; 403 op->contr->tmp_invis = 1;
399 404
400 op->contr->hidden = 0; 405 op->contr->hidden = 0;
401 } 406 }
407
402 if (makes_invisible_to (op, op)) 408 if (makes_invisible_to (op, op))
403 new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!"); 409 new_draw_info (NDI_UNIQUE, 0, op, "You can't see your hands!");
404 else 410 else
405 new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!"); 411 new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!");
406 412
407 update_object (op, UP_OBJ_FACE); 413 update_object (op, UP_OBJ_CHANGE);
408 414
409 /* Only search the active objects - only these should actually do 415 /* Only search the active objects - only these should actually do
410 * harm to the player. 416 * harm to the player.
411 */ 417 */
412 for (tmp = active_objects; tmp != NULL; tmp = tmp->active_next) 418 for_all_actives (tmp)
413 if (tmp->enemy == op) 419 if (tmp->enemy == op)
414 tmp->enemy = NULL; 420 tmp->enemy = 0;
421
415 return 1; 422 return 1;
416} 423}
417 424
418/* earth to dust spell. Basically destroys earthwalls in the area. 425/* earth to dust spell. Basically destroys earthwalls in the area.
419 */ 426 */
… …
447 next = tmp->above; 454 next = tmp->above;
448 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN)) 455 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
449 hit_player (tmp, 9998, op, AT_PHYSICAL, 0); 456 hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
450 } 457 }
451 } 458 }
459
452 return 1; 460 return 1;
453} 461}
454
455 462
456void 463void
457execute_word_of_recall (object *op) 464execute_word_of_recall (object *op)
458{ 465{
459 object *wor = op; 466 if (object *pl = op->in_player ())
460 467 {
461 while (op != NULL && op->type != PLAYER) 468 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
462 op = op->env;
463
464 if (op != NULL && op->map)
465 if ((get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_CLERIC) && (!QUERY_FLAG (op, FLAG_WIZCAST)))
466 new_draw_info (NDI_UNIQUE, 0, op, "You feel something fizzle inside you."); 469 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
467 else 470 else
471 {
472 // remove first so we do not call update_stats
473 op->remove ();
468 enter_exit (op, wor); 474 pl->enter_exit (op);
475 }
476 }
469 477
470 wor->destroy (); 478 op->destroy ();
471} 479}
472 480
473/* Word of recall causes the player to return 'home'. 481/* Word of recall causes the player to return 'home'.
474 * we put a force into the player object, so that there is a 482 * we put a force into the player object, so that there is a
475 * time delay effect. 483 * time delay effect.
… …
494 { 502 {
495 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 503 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
496 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n"); 504 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
497 return 0; 505 return 0;
498 } 506 }
507
499 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob); 508 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);
500 if (time < 1) 509 if (time < 1)
501 time = 1; 510 time = 1;
502 511
503 /* value of speed really doesn't make much difference, as long as it is 512 /* value of speed really doesn't make much difference, as long as it is
504 * positive. Lower value may be useful so that the problem doesn't 513 * positive. Lower value may be useful so that the problem doesn't
505 * do anything really odd if it say a -1000 or something. 514 * do anything really odd if it say a -1000 or something.
506 */ 515 */
507 dummy->speed = 0.002; 516 dummy->set_speed (0.002);
508 update_ob_speed (dummy);
509 dummy->speed_left = -dummy->speed * time; 517 dummy->speed_left = -dummy->speed * time;
510 dummy->type = SPELL_EFFECT; 518 dummy->type = SPELL_EFFECT;
511 dummy->subtype = SP_WORD_OF_RECALL; 519 dummy->subtype = SP_WORD_OF_RECALL;
512 520
513 /* If we could take advantage of enter_player_savebed() here, it would be 521 /* If we could take advantage of enter_player_savebed() here, it would be
514 * nice, but until the map load fails, we can't. 522 * nice, but until the map load fails, we can't.
515 */ 523 */
516 EXIT_PATH (dummy) = op->contr->savebed_map; 524 EXIT_PATH (dummy) = op->contr->savebed_map;
517 EXIT_X (dummy) = op->contr->bed_x; 525 EXIT_X (dummy) = op->contr->bed_x;
518 EXIT_Y (dummy) = op->contr->bed_y; 526 EXIT_Y (dummy) = op->contr->bed_y;
519 527
520 (void) insert_ob_in_ob (dummy, op); 528 op->insert (dummy);
529
521 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 530 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
531
522 return 1; 532 return 1;
523} 533}
524 534
525/* cast_wonder 535/* cast_wonder
526 * wonder is really just a spell that will likely cast another 536 * wonder is really just a spell that will likely cast another
… …
556 return cast_spell (op, caster, dir, newspell, NULL); 566 return cast_spell (op, caster, dir, newspell, NULL);
557 } 567 }
558 return 1; 568 return 1;
559} 569}
560 570
561
562int 571int
563perceive_self (object *op) 572perceive_self (object *op)
564{ 573{
565 char *cp = describe_item (op, op), buf[MAX_BUF]; 574 const char *cp = describe_item (op, op);
566 archetype *at = archetype::find (ARCH_DEPLETION); 575 archetype *at = archetype::find (ARCH_DEPLETION);
567 object *tmp;
568 int i;
569 576
577 dynbuf_text buf;
578
579 if (player *pl = op->contr)
580 if (object *race = archetype::find (op->race))
581 buf << "You are a " << (pl->gender ? "female" : "male") << " " << &race->name << ".\n";
582
570 tmp = find_god (determine_god (op)); 583 if (object *god = find_god (determine_god (op)))
571 if (tmp) 584 buf << "You worship " << &god->name << ".\n";
572 new_draw_info_format (NDI_UNIQUE, 0, op, "You worship %s", &tmp->name);
573 else 585 else
574 new_draw_info (NDI_UNIQUE, 0, op, "You worship no god"); 586 buf << "You worship no god.\n";
575 587
576 tmp = present_arch_in_ob (at, op); 588 object *tmp = present_arch_in_ob (at, op);
577 589
578 if (*cp == '\0' && tmp == NULL) 590 if (*cp == '\0' && tmp == NULL)
579 new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane"); 591 buf << "You feel very mundane. ";
580 else 592 else
581 { 593 {
582 new_draw_info (NDI_UNIQUE, 0, op, "You have:"); 594 buf << "You have: " << cp << ".\n";
583 new_draw_info (NDI_UNIQUE, 0, op, cp); 595
584 if (tmp != NULL) 596 if (tmp)
585 {
586 for (i = 0; i < NUM_STATS; i++) 597 for (int i = 0; i < NUM_STATS; i++)
587 { 598 if (tmp->stats.stat (i) < 0)
588 if (get_attr_value (&tmp->stats, i) < 0) 599 buf.printf ("Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
589 {
590 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is depleted by %d", statname[i], -(get_attr_value (&tmp->stats, i)));
591 }
592 }
593 }
594 } 600 }
595 601
596 if (is_dragon_pl (op)) 602 if (is_dragon_pl (op))
597 {
598 /* now grab the 'dragon_ability'-force from the player's inventory */ 603 /* now grab the 'dragon_ability'-force from the player's inventory */
599 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 604 for (tmp = op->inv; tmp; tmp = tmp->below)
600 { 605 {
601 if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force")) 606 if (tmp->type == FORCE && !strcmp (tmp->arch->archname, "dragon_ability_force"))
602 { 607 {
603 if (tmp->stats.exp == 0) 608 if (tmp->stats.exp == 0)
604 {
605 sprintf (buf, "Your metabolism isn't focused on anything."); 609 buf << "Your metabolism isn't focused on anything.\n";
606 }
607 else 610 else
608 {
609 sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]); 611 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
610 } 612
611 new_draw_info (NDI_UNIQUE, 0, op, buf);
612 break; 613 break;
613 } 614 }
614 } 615 }
615 } 616
617 new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ());
618
616 return 1; 619 return 1;
617} 620}
618
619/* int cast_create_town_portal (object *op, object *caster, int dir)
620 *
621 * This function cast the spell of town portal for op
622 *
623 * The spell operates in two passes. During the first one a place
624 * is marked as a destination for the portal. During the second one,
625 * 2 portals are created, one in the position the player cast it and
626 * one in the destination place. The portal are synchronized and 2 forces
627 * are inserted in the player to destruct the portal next time player
628 * creates a new portal pair.
629 * This spell has a side effect that it allows people to meet each other
630 * in a permanent, private, appartements by making a town portal from it
631 * to the town or another public place. So, check if the map is unique and if
632 * so return an error
633 *
634 * Code by Tchize (david.delbecq@usa.net)
635 */
636int
637cast_create_town_portal (object *op, object *caster, object *spell, int dir)
638{
639 object *dummy, *force, *old_force, *tmp;
640 archetype *perm_portal;
641 char portal_name[1024], portal_message[1024];
642 sint16 exitx, exity;
643 maptile *exitmap;
644 int op_level;
645
646
647 /* Check to see if the map the player is currently on is a per player unique
648 * map. This can be determined in that per player unique maps have the
649 * full pathname listed.
650 */
651 if (!strncmp (op->map->path, settings.localdir, strlen (settings.localdir)) && settings.create_home_portals != TRUE)
652 {
653 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You can't cast that here.\n");
654 return 0;
655 }
656
657 /* The first thing to do is to check if we have a marked destination
658 * dummy is used to make a check inventory for the force
659 */
660 dummy = arch_to_object (spell->other_arch);
661 if (dummy == NULL)
662 {
663 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
664 LOG (llevError, "object::create failed (force in cast_create_town_portal for %s!\n", &op->name);
665 return 0;
666 }
667
668 force = check_inv_recursive (op, dummy);
669
670 if (force == NULL)
671 {
672 /* Here we know there is no destination marked up.
673 * We have 2 things to do:
674 * 1. Mark the destination in the player inventory.
675 * 2. Let the player know it worked.
676 */
677 dummy->name = op->map->path;
678 EXIT_X (dummy) = op->x;
679 EXIT_Y (dummy) = op->y;
680 insert_ob_in_ob (dummy, op);
681 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You fix this place in your mind.\nYou feel you are able to come here from anywhere.");
682 return 1;
683 }
684
685 dummy->destroy ();
686
687 /* Here we know where the town portal should go to
688 * We should kill any existing portal associated with the player.
689 * Than we should create the 2 portals.
690 * For each of them, we need:
691 * - To create the portal with the name of the player+destination map
692 * - set the owner of the town portal
693 * - To mark the position of the portal in the player's inventory
694 * for easier destruction.
695 *
696 * The mark works has follow:
697 * slaying: Existing town portal
698 * hp, sp : x & y of the associated portal
699 * name : name of the portal
700 * race : map the portal is in
701 */
702
703 /* First step: killing existing town portals */
704 dummy = get_archetype (spell->race);
705 if (dummy == NULL)
706 {
707 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
708 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
709 return 0;
710 }
711
712 perm_portal = archetype::find (spell->slaying);
713
714 /* To kill a town portal, we go trough the player's inventory,
715 * for each marked portal in player's inventory,
716 * -We try load the associated map (if impossible, consider the portal destructed)
717 * -We find any portal in the specified location.
718 * If it has the good name, we destruct it.
719 * -We destruct the force indicating that portal.
720 */
721 while ((old_force = check_inv_recursive (op, dummy)))
722 {
723 exitx = EXIT_X (old_force);
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
732 if (exitmap)
733 {
734 tmp = present_arch (perm_portal, exitmap, exitx, exity);
735 while (tmp)
736 {
737 if (tmp->name == old_force->name)
738 {
739 tmp->destroy ();
740 break;
741 }
742
743 tmp = tmp->above;
744 }
745 }
746
747 old_force->destroy ();
748 LOG (llevDebug, "\n");
749 }
750
751 dummy->destroy ();
752
753 /* Creating the portals.
754 * The very first thing to do is to ensure
755 * access to the destination map.
756 * If we can't, don't fizzle. Simply warn player.
757 * This ensure player pays his mana for the spell
758 * because HE is responsible of forgotting.
759 * 'force' is the destination of the town portal, which we got
760 * from the players inventory above.
761 */
762
763 /* Ensure exit map is loaded */
764 if (!strncmp (force->name, settings.localdir, strlen (settings.localdir)))
765 exitmap = ready_map_name (force->name, MAP_PLAYER_UNIQUE);
766 else
767 exitmap = ready_map_name (force->name, 0);
768
769 /* If we were unable to load (ex. random map deleted), warn player */
770 if (exitmap == NULL)
771 {
772 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens.\nYou can't remember where to go!?");
773 force->destroy ();
774 return 1;
775 }
776
777 op_level = caster_level (caster, spell);
778 if (op_level < 15)
779 snprintf (portal_message, 1024,
780 "\nThe air moves around you and\na huge smell of ammonia\nsurounds you as you pass\nthrough %s's tiny portal\nPouah!\n",
781 &op->name);
782 else if (op_level < 30)
783 snprintf (portal_message, 1024,
784 "\n%s's portal smells of ozone.\nYou do a lot of movements and finally pass\nthrough the small hole in the air\n", &op->name);
785 else if (op_level < 60)
786 snprintf (portal_message, 1024, "\nA shining door opens in the air in front of you,\nshowing you the path to another place.\n");
787 else
788 snprintf (portal_message, 1024, "\nAs you walk through %s's portal, flowers come out\nfrom the ground around you.\nYou feel awed.\n",
789 &op->name);
790
791 /* Create a portal in front of player
792 * dummy contain the portal and
793 * force contain the track to kill it later
794 */
795
796 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name);
797 dummy = get_archetype (spell->slaying); /*The portal */
798 if (dummy == NULL)
799 {
800 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
801 LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
802 return 0;
803 }
804
805 EXIT_PATH (dummy) = force->name;
806 EXIT_X (dummy) = EXIT_X (force);
807 EXIT_Y (dummy) = EXIT_Y (force);
808 dummy->name = dummy->name_pl = portal_name;
809 dummy->msg = portal_message;
810 dummy->race = op->name; /*Save the owner of the portal */
811 cast_create_obj (op, caster, dummy, 0);
812
813 /* Now we need to to create a town portal marker inside the player
814 * object, so on future castings, we can know that he has an active
815 * town portal.
816 */
817 tmp = get_archetype (spell->race);
818 if (tmp == NULL)
819 {
820 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
821 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
822 return 0;
823 }
824
825 tmp->race = op->map->path;
826 tmp->name = portal_name;
827 EXIT_X (tmp) = dummy->x;
828 EXIT_Y (tmp) = dummy->y;
829 insert_ob_in_ob (tmp, op);
830
831 /* Create a portal in the destination map
832 * dummy contain the portal and
833 * force the track to kill it later
834 * the 'force' variable still contains the 'reminder' of
835 * where this portal goes to.
836 */
837 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, op->map->path);
838 dummy = get_archetype (spell->slaying); /*The portal */
839 if (dummy == NULL)
840 {
841 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
842 LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
843 return 0;
844 }
845
846 EXIT_PATH (dummy) = op->map->path;
847 EXIT_X (dummy) = op->x;
848 EXIT_Y (dummy) = op->y;
849 dummy->name = dummy->name_pl = portal_name;
850 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 */
854 insert_ob_in_map (dummy, exitmap, op, 0);
855
856 /* Now we create another town portal marker that
857 * points back to the one we just made
858 */
859 tmp = get_archetype (spell->race);
860 if (tmp == NULL)
861 {
862 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
863 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
864 return 0;
865 }
866
867 tmp->race = force->name;
868 tmp->name = portal_name;
869 EXIT_X (tmp) = dummy->x;
870 EXIT_Y (tmp) = dummy->y;
871 insert_ob_in_ob (tmp, op);
872
873 /* Describe the player what happened
874 */
875 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You see air moving and showing you the way home.");
876 force->destroy ();
877
878 return 1;
879}
880
881 621
882/* This creates magic walls. Really, it can create most any object, 622/* This creates magic walls. Really, it can create most any object,
883 * within some reason. 623 * within some reason.
884 */ 624 */
885
886int 625int
887magic_wall (object *op, object *caster, int dir, object *spell_ob) 626magic_wall (object *op, object *caster, int dir, object *spell_ob)
888{ 627{
889 object *tmp, *tmp2; 628 object *tmp;
890 int i, posblocked, negblocked, maxrange; 629 int i, posblocked, negblocked, maxrange;
891 sint16 x, y; 630 sint16 x, y;
892 maptile *m; 631 maptile *m;
893 const char *name; 632 const char *name;
894 archetype *at; 633 archetype *at;
… …
902 else 641 else
903 { 642 {
904 x = op->x + freearr_x[dir]; 643 x = op->x + freearr_x[dir];
905 y = op->y + freearr_y[dir]; 644 y = op->y + freearr_y[dir];
906 } 645 }
646
907 m = op->map; 647 m = op->map;
908 648
909 if ((spell_ob->move_block || x != op->x || y != op->y) && 649 if ((spell_ob->move_block || x != op->x || y != op->y) &&
910 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) || 650 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) ||
911 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block))) 651 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))
912 { 652 {
913 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 653 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way.");
914 return 0; 654 return 0;
915 } 655 }
656
916 if (spell_ob->other_arch) 657 if (spell_ob->other_arch)
917 {
918 tmp = arch_to_object (spell_ob->other_arch); 658 tmp = arch_to_object (spell_ob->other_arch);
919 }
920 else if (spell_ob->race) 659 else if (spell_ob->race)
921 { 660 {
922 char buf1[MAX_BUF]; 661 char buf1[MAX_BUF];
923 662
924 sprintf (buf1, spell_ob->race, dir); 663 sprintf (buf1, spell_ob->race, dir);
… …
927 { 666 {
928 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1); 667 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
929 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken."); 668 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
930 return 0; 669 return 0;
931 } 670 }
671
932 tmp = arch_to_object (at); 672 tmp = arch_to_object (at);
933 } 673 }
934 else 674 else
935 { 675 {
936 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name); 676 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
… …
946 } 686 }
947 else if (QUERY_FLAG (tmp, FLAG_ALIVE)) 687 else if (QUERY_FLAG (tmp, FLAG_ALIVE))
948 { 688 {
949 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 689 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
950 tmp->stats.maxhp = tmp->stats.hp; 690 tmp->stats.maxhp = tmp->stats.hp;
951 tmp->set_owner (op);
952 set_spell_skill (op, caster, spell_ob, tmp);
953 } 691 }
692
954 if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP)) 693 if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP))
955 { 694 {
956 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 695 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
957 SET_FLAG (tmp, FLAG_IS_USED_UP); 696 SET_FLAG (tmp, FLAG_IS_USED_UP);
958 } 697 }
698
959 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN)) 699 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN))
960 { 700 {
961 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 701 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
962 tmp->stats.maxhp = tmp->stats.hp; 702 tmp->stats.maxhp = tmp->stats.hp;
963 SET_FLAG (tmp, FLAG_TEAR_DOWN); 703 SET_FLAG (tmp, FLAG_TEAR_DOWN);
964 SET_FLAG (tmp, FLAG_ALIVE); 704 SET_FLAG (tmp, FLAG_ALIVE);
965 } 705 }
966 706
967 /* This can't really hurt - if the object doesn't kill anything, 707 /* This can't really hurt - if the object doesn't kill anything,
968 * these fields just won't be used. 708 * these fields just won't be used. Do not set the owner for
709 * earthwalls, though, so they survive restarts.
969 */ 710 */
711 if (tmp->type != EARTHWALL) //TODO
970 tmp->set_owner (op); 712 tmp->set_owner (op);
713
971 set_spell_skill (op, caster, spell_ob, tmp); 714 set_spell_skill (op, caster, spell_ob, tmp);
972 tmp->x = x;
973 tmp->y = y;
974 tmp->level = caster_level (caster, spell_ob) / 2; 715 tmp->level = caster_level (caster, spell_ob) / 2;
975 716
976 name = tmp->name; 717 name = tmp->name;
977 if ((tmp = insert_ob_in_map (tmp, m, op, 0)) == NULL) 718 if (!(tmp = m->insert (tmp, x, y, op)))
978 { 719 {
979 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name); 720 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
980 return 0; 721 return 0;
981 } 722 }
723
982 /* If this is a spellcasting wall, need to insert the spell object */ 724 /* If this is a spellcasting wall, need to insert the spell object */
983 if (tmp->other_arch && tmp->other_arch->clone.type == SPELL) 725 if (tmp->other_arch && tmp->other_arch->type == SPELL)
984 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp); 726 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
985 727
986 /* This code causes the wall to extend some distance in 728 /* This code causes the wall to extend some distance in
987 * each direction, or until an obstruction is encountered. 729 * each direction, or until an obstruction is encountered.
988 * posblocked and negblocked help determine how far the 730 * posblocked and negblocked help determine how far the
… …
1004 m = tmp->map; 746 m = tmp->map;
1005 747
1006 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) && 748 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) &&
1007 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked) 749 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !posblocked)
1008 { 750 {
1009 tmp2 = tmp->clone (); 751 object *tmp2 = tmp->clone ();
1010 tmp2->x = x; 752 m->insert (tmp2, x, y, op);
1011 tmp2->y = y; 753
1012 insert_ob_in_map (tmp2, m, op, 0);
1013 /* If this is a spellcasting wall, need to insert the spell object */ 754 /* If this is a spellcasting wall, need to insert the spell object */
1014 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 755 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1015 insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2); 756 tmp2->insert (arch_to_object (tmp2->other_arch));
1016 757
1017 } 758 }
1018 else 759 else
1019 posblocked = 1; 760 posblocked = 1;
1020 761
… …
1023 m = tmp->map; 764 m = tmp->map;
1024 765
1025 if (!(get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE)) && 766 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) 767 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
1027 { 768 {
1028 tmp2 = tmp->clone (); 769 object *tmp2 = tmp->clone ();
1029 tmp2->x = x; 770 m->insert (tmp2, x, y, op);
1030 tmp2->y = y; 771
1031 insert_ob_in_map (tmp2, m, op, 0);
1032 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 772 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1033 insert_ob_in_ob (arch_to_object (tmp2->other_arch), tmp2); 773 tmp2->insert (arch_to_object (tmp2->other_arch));
1034 } 774 }
1035 else 775 else
1036 negblocked = 1; 776 negblocked = 1;
1037 } 777 }
1038 778
… …
1087 { 827 {
1088 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n"); 828 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
1089 op->contr->count = 0; 829 op->contr->count = 0;
1090 return 0; 830 return 0;
1091 } 831 }
832
1092 op->contr->count = 0; 833 op->contr->count = 0;
1093 834
1094 /* Remove code that puts player on random space on maps. IMO, 835 /* Remove code that puts player on random space on maps. IMO,
1095 * a lot of maps probably have areas the player should not get to, 836 * a lot of maps probably have areas the player should not get to,
1096 * but may not be marked as NO_MAGIC (as they may be bounded 837 * but may not be marked as NO_MAGIC (as they may be bounded
… …
1145 return 0; 886 return 0;
1146 } 887 }
1147 } 888 }
1148 889
1149 /* Actually move the player now */ 890 /* Actually move the player now */
1150 op->remove (); 891 if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
1151 op->x += freearr_x[dir] * dist;
1152 op->y += freearr_y[dir] * dist;
1153 if ((op = insert_ob_in_map (op, op->map, op, 0)) == NULL)
1154 return 1; 892 return 1;
1155 893
1156 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 894 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
1157 return 1; 895 return 1;
1158} 896}
… …
1171 object *poison; 909 object *poison;
1172 int heal = 0, success = 0; 910 int heal = 0, success = 0;
1173 911
1174 tmp = find_target_for_friendly_spell (op, dir); 912 tmp = find_target_for_friendly_spell (op, dir);
1175 913
1176 if (tmp == NULL) 914 if (!tmp)
1177 return 0; 915 return 0;
1178 916
1179 /* Figure out how many hp this spell might cure. 917 /* Figure out how many hp this spell might cure.
1180 * could be zero if this spell heals effects, not damage. 918 * could be zero if this spell heals effects, not damage.
1181 */ 919 */
… …
1184 heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp; 922 heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp;
1185 923
1186 if (heal) 924 if (heal)
1187 { 925 {
1188 if (tmp->stats.hp >= tmp->stats.maxhp) 926 if (tmp->stats.hp >= tmp->stats.maxhp)
1189 {
1190 new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed."); 927 new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed.");
1191 }
1192 else 928 else
1193 { 929 {
1194 /* See how many points we actually heal. Instead of messages 930 /* See how many points we actually heal. Instead of messages
1195 * based on type of spell, we instead do messages based 931 * based on type of spell, we instead do messages based
1196 * on amount of damage healed. 932 * on amount of damage healed.
… …
1198 if (heal > (tmp->stats.maxhp - tmp->stats.hp)) 934 if (heal > (tmp->stats.maxhp - tmp->stats.hp))
1199 heal = tmp->stats.maxhp - tmp->stats.hp; 935 heal = tmp->stats.maxhp - tmp->stats.hp;
1200 tmp->stats.hp += heal; 936 tmp->stats.hp += heal;
1201 937
1202 if (tmp->stats.hp >= tmp->stats.maxhp) 938 if (tmp->stats.hp >= tmp->stats.maxhp)
1203 {
1204 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!"); 939 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
1205 }
1206 else if (heal > 50) 940 else if (heal > 50)
1207 {
1208 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!"); 941 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");
1209 }
1210 else if (heal > 25) 942 else if (heal > 25)
1211 {
1212 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close."); 943 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");
1213 }
1214 else if (heal > 10) 944 else if (heal > 10)
1215 {
1216 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade."); 945 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade.");
1217 }
1218 else 946 else
1219 {
1220 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close."); 947 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close.");
1221 } 948
1222 success = 1; 949 success = 1;
1223 } 950 }
1224 } 951 }
952
1225 if (spell->attacktype & AT_DISEASE) 953 if (spell->attacktype & AT_DISEASE)
1226 if (cure_disease (tmp, op)) 954 if (cure_disease (tmp, op))
1227 success = 1; 955 success = 1;
1228 956
1229 if (spell->attacktype & AT_POISON) 957 if (spell->attacktype & AT_POISON)
… …
1235 success = 1; 963 success = 1;
1236 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed"); 964 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
1237 poison->stats.food = 1; 965 poison->stats.food = 1;
1238 } 966 }
1239 } 967 }
968
1240 if (spell->attacktype & AT_CONFUSION) 969 if (spell->attacktype & AT_CONFUSION)
1241 { 970 {
1242 poison = present_in_ob_by_name (FORCE, "confusion", tmp); 971 poison = present_in_ob_by_name (FORCE, "confusion", tmp);
1243 if (poison) 972 if (poison)
1244 { 973 {
1245 success = 1; 974 success = 1;
1246 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 975 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
1247 poison->duration = 1; 976 poison->duration = 1;
1248 } 977 }
1249 } 978 }
979
1250 if (spell->attacktype & AT_BLIND) 980 if (spell->attacktype & AT_BLIND)
1251 { 981 {
1252 at = archetype::find ("blindness"); 982 at = archetype::find ("blindness");
1253 poison = present_arch_in_ob (at, tmp); 983 poison = present_arch_in_ob (at, tmp);
1254 if (poison) 984 if (poison)
… …
1256 success = 1; 986 success = 1;
1257 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return."); 987 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
1258 poison->stats.food = 1; 988 poison->stats.food = 1;
1259 } 989 }
1260 } 990 }
991
1261 if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp) 992 if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)
1262 { 993 {
1263 tmp->stats.sp += spell->last_sp; 994 tmp->stats.sp += spell->last_sp;
1264 if (tmp->stats.sp > tmp->stats.maxsp) 995 if (tmp->stats.sp > tmp->stats.maxsp)
1265 tmp->stats.sp = tmp->stats.maxsp; 996 tmp->stats.sp = tmp->stats.maxsp;
1266 success = 1; 997 success = 1;
1267 new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!"); 998 new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!");
1268 } 999 }
1000
1269 if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace) 1001 if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)
1270 { 1002 {
1271 tmp->stats.grace += spell->last_grace; 1003 tmp->stats.grace += spell->last_grace;
1272 if (tmp->stats.grace > tmp->stats.maxgrace) 1004 if (tmp->stats.grace > tmp->stats.maxgrace)
1273 tmp->stats.grace = tmp->stats.maxgrace; 1005 tmp->stats.grace = tmp->stats.maxgrace;
1274 success = 1; 1006 success = 1;
1275 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!"); 1007 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1276 } 1008 }
1009
1277 if (spell->stats.food && tmp->stats.food < 999) 1010 if (spell->stats.food && tmp->stats.food < 999)
1278 { 1011 {
1279 tmp->stats.food += spell->stats.food; 1012 tmp->stats.food += spell->stats.food;
1280 if (tmp->stats.food > 999) 1013 if (tmp->stats.food > 999)
1281 tmp->stats.food = 999; 1014 tmp->stats.food = 999;
1282 success = 1; 1015 success = 1;
1283 /* We could do something a bit better like the messages for healing above */ 1016 /* We could do something a bit better like the messages for healing above */
1284 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 1017 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1285 } 1018 }
1019
1286 return success; 1020 return success;
1287} 1021}
1288
1289 1022
1290/* This is used for the spells that gain stats. There are no spells 1023/* This is used for the spells that gain stats. There are no spells
1291 * right now that icnrease wis/int/pow on a temp basis, so no 1024 * right now that icnrease wis/int/pow on a temp basis, so no
1292 * good comments for those. 1025 * good comments for those.
1293 */ 1026 */
1294static const char *const no_gain_msgs[NUM_STATS] = { 1027static const char *const no_gain_msgs[NUM_STATS] = {
1295 "You grow no stronger.", 1028 "You grow no stronger.",
1296 "You grow no more agile.", 1029 "You grow no more agile.",
1297 "You don't feel any healthier.", 1030 "You don't feel any healthier.",
1298 "no wis", 1031 "You didn't grow any more intelligent.",
1032 "You do not feel any wiser.",
1033 "You don't feel any more powerful."
1299 "You are no easier to look at.", 1034 "You are no easier to look at.",
1300 "no int",
1301 "no pow"
1302}; 1035};
1303 1036
1304int 1037int
1305cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent) 1038cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1306{ 1039{
1307 object *tmp, *tmp2 = NULL;
1308 object *force = NULL; 1040 object *force = NULL;
1309 int i; 1041 int i;
1310 1042
1311 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1043 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1312 if (dir != 0) 1044 object *tmp = dir
1313 {
1314 tmp = find_target_for_friendly_spell (op, dir); 1045 ? find_target_for_friendly_spell (op, dir)
1315 } 1046 : op;
1316 else
1317 {
1318 tmp = op;
1319 }
1320 1047
1321 if (tmp == NULL) 1048 if (!tmp)
1322 return 0; 1049 return 0;
1323 1050
1324 /* If we've already got a force of this type, don't add a new one. */ 1051 /* If we've already got a force of this type, don't add a new one. */
1325 for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) 1052 for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1326 { 1053 {
1327 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY) 1054 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1328 { 1055 {
1329 if (tmp2->name == spell_ob->name) 1056 if (tmp2->name == spell_ob->name)
1330 { 1057 {
… …
1363 } 1090 }
1364 else 1091 else
1365 { 1092 {
1366 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect."); 1093 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1367 } 1094 }
1095
1368 return 1; 1096 return 1;
1369 } 1097 }
1098
1370 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1099 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1371 force->speed = 1.0; 1100 force->speed = 1.0;
1372 force->speed_left = -1.0; 1101 force->speed_left = -1.0;
1373 SET_FLAG (force, FLAG_APPLIED); 1102 SET_FLAG (force, FLAG_APPLIED);
1374 1103
… …
1380 force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob); 1109 force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);
1381 if (force->resist[i] > 100) 1110 if (force->resist[i] > 100)
1382 force->resist[i] = 100; 1111 force->resist[i] = 100;
1383 } 1112 }
1384 } 1113 }
1114
1385 if (spell_ob->stats.hp) 1115 if (spell_ob->stats.hp)
1386 force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob); 1116 force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
1387 1117
1388 if (tmp->type == PLAYER) 1118 if (tmp->type == PLAYER)
1389 { 1119 {
1390 /* Stat adjustment spells */ 1120 /* Stat adjustment spells */
1391 for (i = 0; i < NUM_STATS; i++) 1121 for (i = 0; i < NUM_STATS; i++)
1392 { 1122 {
1393 sint8 stat = get_attr_value (&spell_ob->stats, i), k, sm; 1123 if (sint8 stat = spell_ob->stats.stat (i))
1394
1395 if (stat)
1396 { 1124 {
1397 sm = 0; 1125 sint8 sm = 0;
1398 for (k = 0; k < stat; k++) 1126 for (sint8 k = 0; k < stat; k++)
1399 sm += rndm (1, 3); 1127 sm += rndm (1, 3);
1400 1128
1401 if ((get_attr_value (&tmp->stats, i) + sm) > (15 + 5 * stat)) 1129 if (tmp->stats.stat (i) + sm > 15 + 5 * stat)
1402 { 1130 sm = max (0, (15 + 5 * stat) - tmp->stats.stat (i));
1403 sm = (15 + 5 * stat) - get_attr_value (&tmp->stats, i); 1131
1404 if (sm < 0) 1132 force->stats.stat (i) = sm;
1405 sm = 0; 1133
1406 }
1407 set_attr_value (&force->stats, i, sm);
1408 if (!sm) 1134 if (!sm)
1409 new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]); 1135 new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);
1410 } 1136 }
1411 } 1137 }
1412 } 1138 }
… …
1432 force->stats.ac = spell_ob->stats.ac; 1158 force->stats.ac = spell_ob->stats.ac;
1433 force->attacktype = spell_ob->attacktype; 1159 force->attacktype = spell_ob->attacktype;
1434 1160
1435 insert_ob_in_ob (force, tmp); 1161 insert_ob_in_ob (force, tmp);
1436 change_abil (tmp, force); /* Mostly to display any messages */ 1162 change_abil (tmp, force); /* Mostly to display any messages */
1437 fix_player (tmp); 1163 tmp->update_stats ();
1164
1438 return 1; 1165 return 1;
1439} 1166}
1440 1167
1441/* This used to be part of cast_change_ability, but it really didn't make 1168/* This used to be part of cast_change_ability, but it really didn't make
1442 * a lot of sense, since most of the values it derives are from the god 1169 * a lot of sense, since most of the values it derives are from the god
1443 * of the caster. 1170 * of the caster.
1444 */ 1171 */
1445
1446int 1172int
1447cast_bless (object *op, object *caster, object *spell_ob, int dir) 1173cast_bless (object *op, object *caster, object *spell_ob, int dir)
1448{ 1174{
1449 int i; 1175 int i;
1450 object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp; 1176 object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;
… …
1541 force->stats.wc = spell_ob->stats.wc; 1267 force->stats.wc = spell_ob->stats.wc;
1542 force->stats.ac = spell_ob->stats.ac; 1268 force->stats.ac = spell_ob->stats.ac;
1543 1269
1544 change_abil (tmp, force); /* Mostly to display any messages */ 1270 change_abil (tmp, force); /* Mostly to display any messages */
1545 insert_ob_in_ob (force, tmp); 1271 insert_ob_in_ob (force, tmp);
1546 fix_player (tmp); 1272 tmp->update_stats ();
1547 return 1; 1273 return 1;
1548} 1274}
1549
1550
1551 1275
1552/* Alchemy code by Mark Wedel 1276/* Alchemy code by Mark Wedel
1553 * 1277 *
1554 * This code adds a new spell, called alchemy. Alchemy will turn 1278 * This code adds a new spell, called alchemy. Alchemy will turn
1555 * objects to gold nuggets, the value of the gold nuggets being 1279 * objects to gold nuggets, the value of the gold nuggets being
… …
1565 * For example, if an item is worth 110 gold, you will get 1289 * For example, if an item is worth 110 gold, you will get
1566 * 4 large nuggets, and from 0-10 small nuggets. 1290 * 4 large nuggets, and from 0-10 small nuggets.
1567 * 1291 *
1568 * There is also a chance (1:30) that you will get nothing at all 1292 * There is also a chance (1:30) that you will get nothing at all
1569 * for the object. There is also a maximum weight that will be 1293 * for the object. There is also a maximum weight that will be
1570 * alchemied. 1294 * alchemised.
1571 */ 1295 */
1572
1573/* I didn't feel like passing these as arguements to the
1574 * two functions that need them. Real values are put in them
1575 * when the spell is cast, and these are freed when the spell
1576 * is finished.
1577 */
1578static object *small, *large;
1579
1580static void 1296static void
1581alchemy_object (object *obj, int *small_nuggets, int *large_nuggets, int *weight) 1297alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1582{ 1298{
1583 uint64 value = query_cost (obj, NULL, F_TRUE); 1299 uint64 value = query_cost (obj, NULL, F_TRUE);
1584 1300
1585 /* Give third price when we alchemy money (This should hopefully 1301 /* Give third price when we alchemy money (This should hopefully
1586 * make it so that it isn't worth it to alchemy money, sell 1302 * make it so that it isn't worth it to alchemy money, sell
1587 * the nuggets, alchemy the gold from that, etc. 1303 * the nuggets, alchemy the gold from that, etc.
1588 * Otherwise, give 9 silver on the gold for other objects, 1304 * Otherwise, give 9 silver on the gold for other objects,
1589 * so that it would still be more affordable to haul 1305 * so that it would still be more affordable to haul
1590 * the stuff back to town. 1306 * the stuff back to town.
1591 */ 1307 */
1592
1593 if (QUERY_FLAG (obj, FLAG_UNPAID)) 1308 if (QUERY_FLAG (obj, FLAG_UNPAID))
1594 value = 0; 1309 value = 0;
1595 else if (obj->type == MONEY || obj->type == GEM) 1310 else if (obj->type == MONEY || obj->type == GEM)
1596 value /= 3; 1311 value /= 3;
1597 else 1312 else
1598 value = (value * 9) / 10; 1313 value = value * 9 / 10;
1599 1314
1600 value /= 4; // fix by GHJ, don't understand, pcg
1601
1602 if ((obj->value > 0) && rndm (0, 29)) 1315 if (obj->value > 0 && rndm (0, 29))
1603 { 1316 total_value += value;
1604 int count;
1605 1317
1606 count = value / large->value;
1607 *large_nuggets += count;
1608 value -= (uint64) count *(uint64) large->value;
1609
1610 count = value / small->value;
1611 *small_nuggets += count;
1612 }
1613
1614 /* Turn 25 small nuggets into 1 large nugget. If the value
1615 * of large nuggets is not evenly divisable by the small nugget
1616 * value, take off an extra small_nugget (Assuming small_nuggets!=0)
1617 */
1618 if (*small_nuggets * small->value >= large->value)
1619 {
1620 (*large_nuggets)++;
1621 *small_nuggets -= large->value / small->value;
1622 if (*small_nuggets && large->value % small->value)
1623 (*small_nuggets)--;
1624 }
1625 weight += obj->weight; 1318 total_weight += obj->total_weight ();
1319
1626 obj->destroy (); 1320 obj->destroy ();
1627} 1321}
1628 1322
1629static void 1323static void
1630update_map (object *op, maptile *m, int small_nuggets, int large_nuggets, int x, int y) 1324update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1631{ 1325{
1632 object *tmp;
1633 int flag = 0; 1326 int flag = 0;
1634 1327
1635 /* Put any nuggets below the player, but we can only pass this 1328 /* Put any nuggets below the player, but we can only pass this
1636 * flag if we are on the same space as the player 1329 * flag if we are on the same space as the player
1637 */ 1330 */
1638 if (x == op->x && y == op->y && op->map == m) 1331 if (x == op->x && y == op->y && op->map == m)
1639 flag = INS_BELOW_ORIGINATOR; 1332 flag = INS_BELOW_ORIGINATOR;
1640 1333
1641 if (small_nuggets) 1334 if (small_nuggets)
1642 { 1335 {
1643 tmp = small->clone (); 1336 object *tmp = small->clone ();
1644 tmp->nrof = small_nuggets; 1337 tmp->nrof = small_nuggets;
1645 tmp->x = x;
1646 tmp->y = y;
1647 insert_ob_in_map (tmp, m, op, flag); 1338 m->insert (tmp, x, y, op, flag);
1648 } 1339 }
1649 1340
1650 if (large_nuggets) 1341 if (large_nuggets)
1651 { 1342 {
1652 tmp = large->clone (); 1343 object *tmp = large->clone ();
1653 tmp->nrof = large_nuggets; 1344 tmp->nrof = large_nuggets;
1654 tmp->x = x;
1655 tmp->y = y;
1656 insert_ob_in_map (tmp, m, op, flag); 1345 m->insert (tmp, x, y, op, flag);
1657 } 1346 }
1347
1348 if (object *pl = m->at (x, y).player ())
1349 if (pl->contr->ns)
1350 pl->contr->ns->look_position = 0;
1658} 1351}
1659 1352
1660int 1353int
1661alchemy (object *op, object *caster, object *spell_ob) 1354alchemy (object *op, object *caster, object *spell_ob)
1662{ 1355{
1663 int x, y, weight = 0, weight_max, large_nuggets, small_nuggets, mflags;
1664 sint16 nx, ny;
1665 object *next, *tmp;
1666 maptile *mp;
1667
1668 if (op->type != PLAYER) 1356 if (op->type != PLAYER)
1669 return 0; 1357 return 0;
1670 1358
1359 object *large = get_archetype ("largenugget");
1360 object *small = get_archetype ("smallnugget");
1361
1671 /* Put a maximum weight of items that can be alchemied. Limits the power 1362 /* Put a maximum weight of items that can be alchemised. Limits the power
1672 * some, and also prevents people from alcheming every table/chair/clock 1363 * some, and also prevents people from alchemising every table/chair/clock
1673 * in sight 1364 * in sight
1674 */ 1365 */
1675 weight_max = spell_ob->duration + +SP_level_duration_adjust (caster, spell_ob); 1366 int duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1676 weight_max *= 1000; 1367 int weight_max = duration * 1000;
1677 small = get_archetype ("smallnugget"), large = get_archetype ("largenugget"); 1368 uint64 value_max = duration * 1000;
1678 1369
1370 int weight = 0;
1371
1679 for (y = op->y - 1; y <= op->y + 1; y++) 1372 for (int y = op->y - 1; y <= op->y + 1; y++)
1680 { 1373 {
1681 for (x = op->x - 1; x <= op->x + 1; x++) 1374 for (int x = op->x - 1; x <= op->x + 1; x++)
1682 { 1375 {
1376 uint64 value = 0;
1377
1683 nx = x; 1378 sint16 nx = x;
1684 ny = y; 1379 sint16 ny = y;
1685 1380
1686 mp = op->map; 1381 maptile *mp = op->map;
1687 1382
1688 mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny); 1383 int mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);
1689 1384
1690 if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC)) 1385 if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))
1691 continue; 1386 continue;
1692 1387
1693 /* Treat alchemy a little differently - most spell effects 1388 /* Treat alchemy a little differently - most spell effects
… …
1695 * ground level effect. 1390 * ground level effect.
1696 */ 1391 */
1697 if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK) 1392 if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)
1698 continue; 1393 continue;
1699 1394
1700 small_nuggets = 0; 1395 for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1701 large_nuggets = 0;
1702
1703 for (tmp = GET_MAP_OB (mp, nx, ny); tmp != NULL; tmp = next)
1704 { 1396 {
1705 next = tmp->above; 1397 next = tmp->above;
1398
1706 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) && 1399 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&
1707 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON)) 1400 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))
1708 { 1401 {
1709
1710 if (tmp->inv) 1402 if (tmp->inv)
1711 { 1403 {
1712 object *next1, *tmp1; 1404 object *next1, *tmp1;
1713 1405
1714 for (tmp1 = tmp->inv; tmp1 != NULL; tmp1 = next1) 1406 for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1715 { 1407 {
1716 next1 = tmp1->below; 1408 next1 = tmp1->below;
1717 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) && 1409 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&
1718 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON)) 1410 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))
1719 alchemy_object (tmp1, &small_nuggets, &large_nuggets, &weight); 1411 alchemy_object (tmp1, value, weight);
1720 } 1412 }
1721 } 1413 }
1414
1722 alchemy_object (tmp, &small_nuggets, &large_nuggets, &weight); 1415 alchemy_object (tmp, value, weight);
1723 1416
1724 if (weight > weight_max) 1417 if (weight > weight_max)
1725 { 1418 break;
1726 update_map (op, mp, small_nuggets, large_nuggets, nx, ny);
1727 large->destroy ();
1728 small->destroy ();
1729 return 1;
1730 } 1419 }
1731 } /* is alchemable object */ 1420 }
1732 } /* process all objects on this space */ 1421
1422 value = min (value, value_max);
1423
1424 uint64 count = value / large->value;
1425 int large_nuggets = count;
1426 value -= count * large->value;
1427
1428 count = value / small->value;
1429 int small_nuggets = count;
1733 1430
1734 /* Insert all the nuggets at one time. This probably saves time, but 1431 /* Insert all the nuggets at one time. This probably saves time, but
1735 * it also prevents us from alcheming nuggets that were just created 1432 * it also prevents us from alcheming nuggets that were just created
1736 * with this spell. 1433 * with this spell.
1737 */ 1434 */
1738 update_map (op, mp, small_nuggets, large_nuggets, nx, ny); 1435 update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny);
1739 }
1740 }
1741 1436
1437 if (weight > weight_max)
1438 goto bailout;
1439 }
1440 }
1441
1442bailout:
1742 large->destroy (); 1443 large->destroy ();
1743 small->destroy (); 1444 small->destroy ();
1744 /* reset this so that if player standing on a big pile of stuff,
1745 * it is redrawn properly.
1746 */
1747 op->contr->socket->look_position = 0;
1748 return 1; 1445 return 1;
1749} 1446}
1750 1447
1751 1448
1752/* This function removes the cursed/damned status on equipped 1449/* This function removes the cursed/damned status on equipped
… …
1779 } 1476 }
1780 1477
1781 if (op->type == PLAYER) 1478 if (op->type == PLAYER)
1782 { 1479 {
1783 if (success) 1480 if (success)
1784 {
1785 new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now."); 1481 new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");
1786 }
1787 else 1482 else
1788 { 1483 {
1789 if (was_one) 1484 if (was_one)
1790 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse."); 1485 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");
1791 else 1486 else
… …
1815 { 1510 {
1816 identify (tmp); 1511 identify (tmp);
1817 1512
1818 if (op->type == PLAYER) 1513 if (op->type == PLAYER)
1819 { 1514 {
1820 new_draw_info_format (NDI_UNIQUE, 0, op, "You have %s.", long_desc (tmp, op)); 1515 new_draw_info_format (NDI_UNIQUE, 0, op, "You identified: %s.", long_desc (tmp, op));
1821 1516
1822 if (tmp->msg) 1517 if (tmp->msg)
1823 { 1518 {
1824 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:"); 1519 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1825 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg); 1520 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
… …
1837 * stuff on the floor. Only identify stuff on the floor if the spell 1532 * stuff on the floor. Only identify stuff on the floor if the spell
1838 * was not fully used. 1533 * was not fully used.
1839 */ 1534 */
1840 if (num_ident) 1535 if (num_ident)
1841 { 1536 {
1842 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 1537 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1843 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1538 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1844 { 1539 {
1845 identify (tmp); 1540 identify (tmp);
1846 1541
1847 if (op->type == PLAYER) 1542 if (op->type == PLAYER)
1848 { 1543 {
1849 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op)); 1544 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground you identified: %s.", long_desc (tmp, op));
1850 1545
1851 if (tmp->msg) 1546 if (tmp->msg)
1852 { 1547 {
1853 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:"); 1548 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1854 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg); 1549 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
… …
1998 */ 1693 */
1999 if (done_one) 1694 if (done_one)
2000 { 1695 {
2001 object *detect_ob = arch_to_object (spell->other_arch); 1696 object *detect_ob = arch_to_object (spell->other_arch);
2002 1697
2003 detect_ob->x = nx;
2004 detect_ob->y = ny;
2005 /* if this is set, we want to copy the face */ 1698 /* if this is set, we want to copy the face */
2006 if (done_one == 2 && detect) 1699 if (done_one == 2 && detect)
2007 { 1700 {
2008 detect_ob->face = detect->face; 1701 detect_ob->face = detect->face;
2009 detect_ob->animation_id = detect->animation_id; 1702 detect_ob->animation_id = detect->animation_id;
… …
2011 detect_ob->last_anim = 0; 1704 detect_ob->last_anim = 0;
2012 /* by default, the detect_ob is already animated */ 1705 /* by default, the detect_ob is already animated */
2013 if (!QUERY_FLAG (detect, FLAG_ANIMATE)) 1706 if (!QUERY_FLAG (detect, FLAG_ANIMATE))
2014 CLEAR_FLAG (detect_ob, FLAG_ANIMATE); 1707 CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
2015 } 1708 }
1709
2016 insert_ob_in_map (detect_ob, m, op, 0); 1710 m->insert (detect_ob, nx, ny, op);
2017 } 1711 }
2018 } /* for processing the surrounding spaces */ 1712 } /* for processing the surrounding spaces */
2019 1713
2020 1714
2021 /* Now process objects in the players inventory if detect curse or magic */ 1715 /* Now process objects in the players inventory if detect curse or magic */
… …
2070 1764
2071 /* Explodes a fireball centered at player */ 1765 /* Explodes a fireball centered at player */
2072 tmp = get_archetype (EXPLODING_FIREBALL); 1766 tmp = get_archetype (EXPLODING_FIREBALL);
2073 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1; 1767 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
2074 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2; 1768 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
2075 tmp->x = victim->x; 1769
2076 tmp->y = victim->y; 1770 tmp->insert_at (victim);
2077 insert_ob_in_map (tmp, victim->map, NULL, 0);
2078 victim->stats.sp = 2 * victim->stats.maxsp; 1771 victim->stats.sp = 2 * victim->stats.maxsp;
2079 } 1772 }
2080 else if (victim->stats.sp >= victim->stats.maxsp * 1.88) 1773 else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
2081 {
2082 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode."); 1774 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode.");
2083 }
2084 else if (victim->stats.sp >= victim->stats.maxsp * 1.66) 1775 else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
2085 {
2086 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!"); 1776 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
2087 }
2088 else if (victim->stats.sp >= victim->stats.maxsp * 1.5) 1777 else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
2089 { 1778 {
2090 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world."); 1779 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
2091 confuse_player (victim, victim, 99); 1780 confuse_player (victim, victim, 99);
2092 } 1781 }
2093 else if (victim->stats.sp >= victim->stats.maxsp * 1.25) 1782 else if (victim->stats.sp >= victim->stats.maxsp * 1.25)
2094 {
2095 new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices."); 1783 new_draw_info (NDI_UNIQUE, 0, victim, "You start hearing voices.");
2096 }
2097} 1784}
2098 1785
2099/* cast_transfer 1786/* cast_transfer
2100 * This spell transfers sp from the player to another person. 1787 * This spell transfers sp from the player to another person.
2101 * We let the target go above their normal maximum SP. 1788 * We let the target go above their normal maximum SP.
… …
2212 /* Basically, if the object is magical and not counterspell, 1899 /* Basically, if the object is magical and not counterspell,
2213 * we will more or less remove the object. Don't counterspell 1900 * we will more or less remove the object. Don't counterspell
2214 * monsters either. 1901 * monsters either.
2215 */ 1902 */
2216 1903
2217 if (head->attacktype & AT_MAGIC && 1904 if (head->attacktype & AT_MAGIC
2218 !(head->attacktype & AT_COUNTERSPELL) && !QUERY_FLAG (head, FLAG_MONSTER) && (op->level > head->level)) 1905 && !(head->attacktype & AT_COUNTERSPELL)
1906 && !QUERY_FLAG (head, FLAG_MONSTER)
1907 && (op->level > head->level))
2219 head->destroy (); 1908 head->destroy ();
2220 else 1909 else
2221 switch (head->type) 1910 switch (head->type)
2222 { 1911 {
2223 case SPELL_EFFECT: 1912 case SPELL_EFFECT:
1913 // XXX: Don't affect floor spelleffects. See also XXX comment
1914 // about sanctuary in spell_util.C
1915 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1916 continue;
1917
2224 if (op->level > head->level) 1918 if (op->level > head->level)
2225 head->destroy (); 1919 head->destroy ();
2226 1920
2227 break; 1921 break;
2228 1922
… …
2295 * This code was very odd - code early on would only let players use the spell, 1989 * This code was very odd - code early on would only let players use the spell,
2296 * yet the code wass full of player checks. I've presumed that the code 1990 * yet the code wass full of player checks. I've presumed that the code
2297 * that only let players use it was correct, and removed all the other 1991 * that only let players use it was correct, and removed all the other
2298 * player checks. MSW 2003-01-06 1992 * player checks. MSW 2003-01-06
2299 */ 1993 */
2300
2301int 1994int
2302animate_weapon (object *op, object *caster, object *spell, int dir) 1995animate_weapon (object *op, object *caster, object *spell, int dir)
2303{ 1996{
2304 object *weapon, *tmp; 1997 object *weapon, *tmp;
2305 char buf[MAX_BUF]; 1998 char buf[MAX_BUF];
… …
2317 /* exit if it's not a player using this spell. */ 2010 /* exit if it's not a player using this spell. */
2318 if (op->type != PLAYER) 2011 if (op->type != PLAYER)
2319 return 0; 2012 return 0;
2320 2013
2321 /* if player already has a golem, abort */ 2014 /* if player already has a golem, abort */
2322 if (op->contr->ranges[range_golem]) 2015 if (object *golem = op->contr->golem)
2323 { 2016 {
2324 control_golem (op->contr->ranges[range_golem], dir); 2017 control_golem (golem, dir);
2325 return 0; 2018 return 0;
2326 } 2019 }
2327 2020
2328 /* if no direction specified, pick one */ 2021 /* if no direction specified, pick one */
2329 if (!dir) 2022 if (!dir)
… …
2333 x = op->x + freearr_x[dir]; 2026 x = op->x + freearr_x[dir];
2334 y = op->y + freearr_y[dir]; 2027 y = op->y + freearr_y[dir];
2335 2028
2336 /* if there's no place to put the golem, abort */ 2029 /* if there's no place to put the golem, abort */
2337 if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) || 2030 if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) ||
2338 ((spell->other_arch->clone.move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->clone.move_type)) 2031 ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2339 { 2032 {
2340 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 2033 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
2341 return 0; 2034 return 0;
2342 } 2035 }
2343 2036
… …
2347 if (!weapon) 2040 if (!weapon)
2348 { 2041 {
2349 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!"); 2042 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
2350 return 0; 2043 return 0;
2351 } 2044 }
2352 if (spell->race && strcmp (weapon->arch->name, spell->race)) 2045 if (spell->race && strcmp (weapon->arch->archname, spell->race))
2353 { 2046 {
2354 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon."); 2047 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
2355 return 0; 2048 return 0;
2356 } 2049 }
2357 if (weapon->type != WEAPON) 2050 if (weapon->type != WEAPON)
… …
2375 /* create the golem object */ 2068 /* create the golem object */
2376 tmp = arch_to_object (spell->other_arch); 2069 tmp = arch_to_object (spell->other_arch);
2377 2070
2378 /* if animated by a player, give the player control of the golem */ 2071 /* if animated by a player, give the player control of the golem */
2379 CLEAR_FLAG (tmp, FLAG_MONSTER); 2072 CLEAR_FLAG (tmp, FLAG_MONSTER);
2380 SET_FLAG (tmp, FLAG_FRIENDLY);
2381 tmp->stats.exp = 0; 2073 tmp->stats.exp = 0;
2382 add_friendly_object (tmp); 2074 add_friendly_object (tmp);
2383 tmp->type = GOLEM; 2075 tmp->type = GOLEM;
2384 tmp->set_owner (op); 2076 tmp->set_owner (op);
2077 op->contr->golem = tmp;
2385 set_spell_skill (op, caster, spell, tmp); 2078 set_spell_skill (op, caster, spell, tmp);
2386 op->contr->ranges[range_golem] = tmp;
2387 op->contr->shoottype = range_golem;
2388 2079
2389 /* Give the weapon to the golem now. A bit of a hack to check the 2080 /* Give the weapon to the golem now. A bit of a hack to check the
2390 * removed flag - it should only be set if get_split_object was 2081 * removed flag - it should only be set if get_split_object was
2391 * used above. 2082 * used above.
2392 */ 2083 */
2393 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2084 if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2394 weapon->remove (); 2085 weapon->remove ();
2086
2395 insert_ob_in_ob (weapon, tmp); 2087 insert_ob_in_ob (weapon, tmp);
2396 esrv_send_item (op, weapon); 2088 esrv_send_item (op, weapon);
2397 /* To do everything necessary to let a golem use the weapon is a pain, 2089 /* To do everything necessary to let a golem use the weapon is a pain,
2398 * so instead, just set it as equipped (otherwise, we need to update 2090 * so instead, just set it as equipped (otherwise, we need to update
2399 * body_info, skills, etc) 2091 * body_info, skills, etc)
2400 */ 2092 */
2401 SET_FLAG (tmp, FLAG_USE_WEAPON); 2093 SET_FLAG (tmp, FLAG_USE_WEAPON);
2402 SET_FLAG (weapon, FLAG_APPLIED); 2094 SET_FLAG (weapon, FLAG_APPLIED);
2403 fix_player (tmp); 2095 tmp->update_stats ();
2404 2096
2405 /* There used to be 'odd' code that basically seemed to take the absolute 2097 /* There used to be 'odd' code that basically seemed to take the absolute
2406 * value of the weapon->magic an use that. IMO, that doesn't make sense - 2098 * value of the weapon->magic an use that. IMO, that doesn't make sense -
2407 * if you're using a crappy weapon, it shouldn't be as good. 2099 * if you're using a crappy weapon, it shouldn't be as good.
2408 */ 2100 */
… …
2460 if (a > 14) 2152 if (a > 14)
2461 a = 14; 2153 a = 14;
2462 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a)); 2154 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2463 2155
2464 /* Determine golem's speed */ 2156 /* Determine golem's speed */
2465 tmp->speed = 0.4 + 0.1 * SP_level_range_adjust (caster, spell); 2157 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2466
2467 if (tmp->speed > 3.33)
2468 tmp->speed = 3.33;
2469 2158
2470 if (!spell->race) 2159 if (!spell->race)
2471 { 2160 {
2472 sprintf (buf, "animated %s", &weapon->name); 2161 sprintf (buf, "animated %s", &weapon->name);
2473 tmp->name = buf; 2162 tmp->name = buf;
… …
2475 tmp->face = weapon->face; 2164 tmp->face = weapon->face;
2476 tmp->animation_id = weapon->animation_id; 2165 tmp->animation_id = weapon->animation_id;
2477 tmp->anim_speed = weapon->anim_speed; 2166 tmp->anim_speed = weapon->anim_speed;
2478 tmp->last_anim = weapon->last_anim; 2167 tmp->last_anim = weapon->last_anim;
2479 tmp->state = weapon->state; 2168 tmp->state = weapon->state;
2480 if (QUERY_FLAG (weapon, FLAG_ANIMATE)) 2169 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2481 {
2482 SET_FLAG (tmp, FLAG_ANIMATE);
2483 }
2484 else
2485 {
2486 CLEAR_FLAG (tmp, FLAG_ANIMATE);
2487 }
2488 update_ob_speed (tmp);
2489 } 2170 }
2490 2171
2491 /* make experience increase in proportion to the strength of the summoned creature. */ 2172 /* make experience increase in proportion to the strength of the summoned creature. */
2492 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell)); 2173 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell));
2493 2174
2494 tmp->speed_left = -1; 2175 tmp->speed_left = -1;
2495 tmp->x = x;
2496 tmp->y = y;
2497 tmp->direction = dir; 2176 tmp->direction = dir;
2498 insert_ob_in_map (tmp, m, op, 0); 2177
2178 m->insert (tmp, x, y, op);
2499 return 1; 2179 return 1;
2500} 2180}
2501 2181
2502/* cast_daylight() - changes the map darkness level *lower* */ 2182/* cast_daylight() - changes the map darkness level *lower* */
2503 2183
… …
2511 int success; 2191 int success;
2512 2192
2513 if (!op->map) 2193 if (!op->map)
2514 return 0; /* shouldnt happen */ 2194 return 0; /* shouldnt happen */
2515 2195
2516 success = change_map_light (op->map, spell->stats.dam); 2196 success = op->map->change_map_light (spell->stats.dam);
2197
2517 if (!success) 2198 if (!success)
2518 { 2199 {
2519 if (spell->stats.dam < 0) 2200 if (spell->stats.dam < 0)
2520 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here."); 2201 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2521 else 2202 else
… …
2598 { 2279 {
2599 aura->destroy (); 2280 aura->destroy ();
2600 return; 2281 return;
2601 } 2282 }
2602 2283
2603 aura->x = env->x;
2604 aura->y = env->y;
2605
2606 /* we need to jump out of the inventory for a bit 2284 /* we need to jump out of the inventory for a bit
2607 * in order to hit the map conveniently. 2285 * in order to hit the map conveniently.
2608 */ 2286 */
2609 insert_ob_in_map (aura, env->map, aura, 0); 2287 aura->insert_at (env, aura);
2610 2288
2611 for (i = 1; i < 9; i++) 2289 for (i = 1; i < 9; i++)
2612 { 2290 {
2613 sint16 nx, ny; 2291 sint16 nx, ny;
2614 2292
… …
2623 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny)))) 2301 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny))))
2624 { 2302 {
2625 hit_map (aura, i, aura->attacktype, 0); 2303 hit_map (aura, i, aura->attacktype, 0);
2626 2304
2627 if (aura->other_arch) 2305 if (aura->other_arch)
2628 { 2306 m->insert (arch_to_object (aura->other_arch), nx, ny, aura);
2629 object *new_ob;
2630
2631 new_ob = arch_to_object (aura->other_arch);
2632 new_ob->x = nx;
2633 new_ob->y = ny;
2634 insert_ob_in_map (new_ob, m, aura, 0);
2635 } 2307 }
2636 }
2637 } 2308 }
2309
2638 /* put the aura back in the player's inventory */ 2310 /* put the aura back in the player's inventory */
2639 aura->remove (); 2311 aura->remove ();
2640 insert_ob_in_ob (aura, env); 2312 insert_ob_in_ob (aura, env);
2641} 2313}
2642 2314
… …
2723 2395
2724 snprintf (rune, sizeof (rune), "%s\n", msg); 2396 snprintf (rune, sizeof (rune), "%s\n", msg);
2725 2397
2726 tmp->race = op->name; /*Save the owner of the rune */ 2398 tmp->race = op->name; /*Save the owner of the rune */
2727 tmp->msg = rune; 2399 tmp->msg = rune;
2728 tmp->x = op->x; 2400
2729 tmp->y = op->y; 2401 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2730 insert_ob_in_map (tmp, op->map, op, INS_BELOW_ORIGINATOR);
2731 return 1; 2402 return 1;
2732} 2403}

Diff Legend

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