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.28 by root, Sat Dec 30 10:16:11 2006 UTC vs.
Revision 1.66 by root, Fri Aug 10 01:47:53 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
8 it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version. 11 * (at your option) any later version.
11 12 *
12 This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 16 * GNU General Public License for more details.
16 17 *
17 You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 *
20
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <crossfire@schmorp.de>
22*/ 22 */
23 23
24#include <global.h> 24#include <global.h>
25#include <object.h> 25#include <object.h>
26#include <living.h> 26#include <living.h>
27#ifndef __CEXTRACT__
28# include <sproto.h> 27#include <sproto.h>
29#endif
30#include <spells.h> 28#include <spells.h>
31#include <sounds.h> 29#include <sounds.h>
32 30
33/* cast_magic_storm: This is really used mostly for spell 31/* cast_magic_storm: This is really used mostly for spell
34 * fumbles at the like. tmp is the object to propogate. 32 * fumbles at the like. tmp is the object to propogate.
… …
71 return 0; 69 return 0;
72 } 70 }
73 if (!(random_roll (0, 3, op, PREFER_HIGH))) 71 if (!(random_roll (0, 3, op, PREFER_HIGH)))
74 { 72 {
75 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand)); 73 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));
76 play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE); 74 op->play_sound (sound_find ("ob_explode"));
77 esrv_del_item (op->contr, wand->count); 75 esrv_del_item (op->contr, wand->count);
78 wand->destroy (); 76 wand->destroy ();
79 tmp = get_archetype ("fireball"); 77 tmp = get_archetype ("fireball");
80 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10; 78 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
81 79
… …
105 ncharges = 1; 103 ncharges = 1;
106 104
107 wand->stats.food += ncharges; 105 wand->stats.food += ncharges;
108 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand)); 106 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
109 107
110 if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE)) 108 if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE))
111 { 109 {
112 SET_FLAG (wand, FLAG_ANIMATE); 110 SET_FLAG (wand, FLAG_ANIMATE);
113 wand->set_speed (wand->arch->clone.speed); 111 wand->set_speed (wand->arch->speed);
114 } 112 }
115 113
116 return 1; 114 return 1;
117} 115}
118 116
… …
124 * great a plus, the default is used. 122 * great a plus, the default is used.
125 * The # of arrows created also goes up with level, so if a 30th level mage 123 * The # of arrows created also goes up with level, so if a 30th level mage
126 * wants LOTS of arrows, and doesn't care what the plus is he could 124 * wants LOTS of arrows, and doesn't care what the plus is he could
127 * create nonnmagic arrows, or even -1, etc... 125 * create nonnmagic arrows, or even -1, etc...
128 */ 126 */
129
130int 127int
131cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg) 128cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg)
132{ 129{
133 int missile_plus = 0, bonus_plus = 0; 130 int missile_plus = 0, bonus_plus = 0;
134 const char *missile_name; 131 const char *missile_name;
… …
155 /* If it starts with a letter, presume it is a description */ 152 /* If it starts with a letter, presume it is a description */
156 if (isalpha (*stringarg)) 153 if (isalpha (*stringarg))
157 { 154 {
158 artifact *al = find_artifactlist (missile->type)->items; 155 artifact *al = find_artifactlist (missile->type)->items;
159 156
160 for (; al != NULL; al = al->next) 157 for (; al; al = al->next)
161 if (!strcasecmp (al->item->name, stringarg)) 158 if (!strcasecmp (al->item->name, stringarg))
162 break; 159 break;
163 160
164 if (!al) 161 if (!al)
165 { 162 {
… …
225 if (stringarg) 222 if (stringarg)
226 { 223 {
227 at = find_archetype_by_object_type_name (FOOD, stringarg); 224 at = find_archetype_by_object_type_name (FOOD, stringarg);
228 if (at == NULL) 225 if (at == NULL)
229 at = find_archetype_by_object_type_name (DRINK, stringarg); 226 at = find_archetype_by_object_type_name (DRINK, stringarg);
230 if (at == NULL || at->clone.stats.food > food_value) 227 if (at == NULL || at->stats.food > food_value)
231 stringarg = NULL; 228 stringarg = NULL;
232 } 229 }
233 230
234 if (!stringarg) 231 if (!stringarg)
235 { 232 {
… …
241 * We don't use flesh types because the weight values of those need 238 * We don't use flesh types because the weight values of those need
242 * to be altered from the donor. 239 * to be altered from the donor.
243 */ 240 */
244 241
245 /* We assume the food items don't have multiple parts */ 242 /* We assume the food items don't have multiple parts */
246 for (at_tmp = first_archetype; at_tmp != NULL; at_tmp = at_tmp->next) 243 for_all_archetypes (at_tmp)
247 { 244 {
248 if (at_tmp->clone.type == FOOD || at_tmp->clone.type == DRINK) 245 if (at_tmp->type == FOOD || at_tmp->type == DRINK)
249 { 246 {
250 /* Basically, if the food value is something that is creatable 247 /* Basically, if the food value is something that is creatable
251 * under the limits of the spell and it is higher than 248 * under the limits of the spell and it is higher than
252 * the item we have now, take it instead. 249 * the item we have now, take it instead.
253 */ 250 */
254 if (at_tmp->clone.stats.food <= food_value && (!at || at_tmp->clone.stats.food > at->clone.stats.food)) 251 if (at_tmp->stats.food <= food_value
252 && (!at
253 || at_tmp->stats.food > at->stats.food
254 || (at_tmp->stats.food == at->stats.food
255 && at_tmp->weight < at->weight)))
255 at = at_tmp; 256 at = at_tmp;
256 } 257 }
257 } 258 }
258 } 259 }
260
259 /* Pretty unlikely (there are some very low food items), but you never 261 /* Pretty unlikely (there are some very low food items), but you never
260 * know 262 * know
261 */ 263 */
262 if (!at) 264 if (!at)
263 { 265 {
264 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food."); 266 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");
265 return 0; 267 return 0;
266 } 268 }
267 269
268 food_value /= at->clone.stats.food; 270 food_value /= at->stats.food;
269 new_op = arch_to_object (at); 271 new_op = arch_to_object (at);
270 new_op->nrof = food_value; 272 new_op->nrof = food_value;
271 273
272 new_op->value = 0; 274 new_op->value = 0;
273 if (new_op->nrof < 1) 275 if (new_op->nrof < 1)
… …
288 if (!dir) 290 if (!dir)
289 { 291 {
290 examine_monster (op, op); 292 examine_monster (op, op);
291 return 1; 293 return 1;
292 } 294 }
295
293 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 296 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
294 for (r = 1; r < maxrange; r++) 297 for (r = 1; r < maxrange; r++)
295 { 298 {
296 sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir]; 299 sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];
297 300
… …
317 examine_monster (op, tmp); 320 examine_monster (op, tmp);
318 return 1; 321 return 1;
319 } 322 }
320 } 323 }
321 } 324 }
325
322 new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing."); 326 new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");
323 return 1; 327 return 1;
324} 328}
325
326 329
327/* This checks to see if 'pl' is invisible to 'mon'. 330/* This checks to see if 'pl' is invisible to 'mon'.
328 * does race check, undead check, etc 331 * does race check, undead check, etc
329 * Returns TRUE if mon can't see pl, false 332 * Returns TRUE if mon can't see pl, false
330 * otherwise. This doesn't check range, walls, etc. It 333 * otherwise. This doesn't check range, walls, etc. It
… …
374 * normal applies. 377 * normal applies.
375 */ 378 */
376int 379int
377cast_invisible (object *op, object *caster, object *spell_ob) 380cast_invisible (object *op, object *caster, object *spell_ob)
378{ 381{
379 object *tmp;
380
381 if (op->invisible > 1000) 382 if (op->invisible > 1000)
382 { 383 {
383 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");
384 return 0; 385 return 0;
385 } 386 }
… …
401 else 402 else
402 op->contr->tmp_invis = 1; 403 op->contr->tmp_invis = 1;
403 404
404 op->contr->hidden = 0; 405 op->contr->hidden = 0;
405 } 406 }
407
406 if (makes_invisible_to (op, op)) 408 if (makes_invisible_to (op, op))
407 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!");
408 else 410 else
409 new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!"); 411 new_draw_info (NDI_UNIQUE, 0, op, "You feel more transparent!");
410 412
411 update_object (op, UP_OBJ_FACE); 413 update_object (op, UP_OBJ_CHANGE);
412 414
413 /* Only search the active objects - only these should actually do 415 /* Only search the active objects - only these should actually do
414 * harm to the player. 416 * harm to the player.
415 */ 417 */
416 for (tmp = active_objects; tmp != NULL; tmp = tmp->active_next) 418 for_all_actives (tmp)
417 if (tmp->enemy == op) 419 if (tmp->enemy == op)
418 tmp->enemy = NULL; 420 tmp->enemy = 0;
421
419 return 1; 422 return 1;
420} 423}
421 424
422/* earth to dust spell. Basically destroys earthwalls in the area. 425/* earth to dust spell. Basically destroys earthwalls in the area.
423 */ 426 */
… …
451 next = tmp->above; 454 next = tmp->above;
452 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN)) 455 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
453 hit_player (tmp, 9998, op, AT_PHYSICAL, 0); 456 hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
454 } 457 }
455 } 458 }
459
456 return 1; 460 return 1;
457} 461}
458
459 462
460void 463void
461execute_word_of_recall (object *op) 464execute_word_of_recall (object *op)
462{ 465{
463 object *wor = op; 466 if (object *pl = op->in_player ())
464 467 {
465 while (op != NULL && op->type != PLAYER) 468 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
466 op = op->env;
467
468 if (op != NULL && op->map)
469 if ((get_map_flags (op->map, NULL, op->x, op->y, NULL, NULL) & P_NO_CLERIC) && (!QUERY_FLAG (op, FLAG_WIZCAST)))
470 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.");
471 else 470 else
471 {
472 // remove first so we do not call update_stats
473 op->remove ();
472 op->enter_exit (wor); 474 pl->enter_exit (op);
475 }
476 }
473 477
474 wor->destroy (); 478 op->destroy ();
475} 479}
476 480
477/* Word of recall causes the player to return 'home'. 481/* Word of recall causes the player to return 'home'.
478 * 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
479 * time delay effect. 483 * time delay effect.
… …
498 { 502 {
499 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 503 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
500 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n"); 504 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
501 return 0; 505 return 0;
502 } 506 }
507
503 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob); 508 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob);
504 if (time < 1) 509 if (time < 1)
505 time = 1; 510 time = 1;
506 511
507 /* 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
… …
515 520
516 /* 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
517 * nice, but until the map load fails, we can't. 522 * nice, but until the map load fails, we can't.
518 */ 523 */
519 EXIT_PATH (dummy) = op->contr->savebed_map; 524 EXIT_PATH (dummy) = op->contr->savebed_map;
520 EXIT_X (dummy) = op->contr->bed_x; 525 EXIT_X (dummy) = op->contr->bed_x;
521 EXIT_Y (dummy) = op->contr->bed_y; 526 EXIT_Y (dummy) = op->contr->bed_y;
522 527
523 (void) insert_ob_in_ob (dummy, op); 528 op->insert (dummy);
529
524 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
525 return 1; 532 return 1;
526} 533}
527 534
528/* cast_wonder 535/* cast_wonder
529 * wonder is really just a spell that will likely cast another 536 * wonder is really just a spell that will likely cast another
… …
562} 569}
563 570
564int 571int
565perceive_self (object *op) 572perceive_self (object *op)
566{ 573{
567 char *cp = describe_item (op, op), buf[MAX_BUF]; 574 const char *cp = describe_item (op, op);
568 archetype *at = archetype::find (ARCH_DEPLETION); 575 archetype *at = archetype::find (ARCH_DEPLETION);
569 object *tmp;
570 int i;
571 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
572 tmp = find_god (determine_god (op)); 583 if (object *god = find_god (determine_god (op)))
573 if (tmp) 584 buf << "You worship " << &god->name << ".\n";
574 new_draw_info_format (NDI_UNIQUE, 0, op, "You worship %s", &tmp->name);
575 else 585 else
576 new_draw_info (NDI_UNIQUE, 0, op, "You worship no god"); 586 buf << "You worship no god.\n";
577 587
578 tmp = present_arch_in_ob (at, op); 588 object *tmp = present_arch_in_ob (at, op);
579 589
580 if (*cp == '\0' && tmp == NULL) 590 if (*cp == '\0' && tmp == NULL)
581 new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane"); 591 buf << "You feel very mundane. ";
582 else 592 else
583 { 593 {
584 new_draw_info (NDI_UNIQUE, 0, op, "You have:"); 594 buf << "You have: " << cp << ".\n";
585 new_draw_info (NDI_UNIQUE, 0, op, cp); 595
586 if (tmp != NULL) 596 if (tmp)
587 {
588 for (i = 0; i < NUM_STATS; i++) 597 for (int i = 0; i < NUM_STATS; i++)
589 { 598 if (tmp->stats.stat (i) < 0)
590 if (get_attr_value (&tmp->stats, i) < 0) 599 buf.printf ("Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
591 {
592 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is depleted by %d", statname[i], -(get_attr_value (&tmp->stats, i)));
593 }
594 }
595 }
596 } 600 }
597 601
598 if (is_dragon_pl (op)) 602 if (is_dragon_pl (op))
599 {
600 /* now grab the 'dragon_ability'-force from the player's inventory */ 603 /* now grab the 'dragon_ability'-force from the player's inventory */
601 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 604 for (tmp = op->inv; tmp; tmp = tmp->below)
602 { 605 {
603 if (tmp->type == FORCE && !strcmp (tmp->arch->name, "dragon_ability_force")) 606 if (tmp->type == FORCE && !strcmp (tmp->arch->archname, "dragon_ability_force"))
604 { 607 {
605 if (tmp->stats.exp == 0) 608 if (tmp->stats.exp == 0)
606 {
607 sprintf (buf, "Your metabolism isn't focused on anything."); 609 buf << "Your metabolism isn't focused on anything.\n";
608 }
609 else 610 else
610 {
611 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";
612 } 612
613 new_draw_info (NDI_UNIQUE, 0, op, buf);
614 break; 613 break;
615 } 614 }
616 } 615 }
617 }
618 return 1;
619}
620 616
621/* int cast_create_town_portal (object *op, object *caster, int dir) 617 buf << '\0'; // zero-terminate
622 *
623 * This function cast the spell of town portal for op
624 *
625 * The spell operates in two passes. During the first one a place
626 * is marked as a destination for the portal. During the second one,
627 * 2 portals are created, one in the position the player cast it and
628 * one in the destination place. The portal are synchronized and 2 forces
629 * are inserted in the player to destruct the portal next time player
630 * creates a new portal pair.
631 * This spell has a side effect that it allows people to meet each other
632 * in a permanent, private, appartements by making a town portal from it
633 * to the town or another public place. So, check if the map is unique and if
634 * so return an error
635 *
636 * Code by Tchize (david.delbecq@usa.net)
637 */
638int
639cast_create_town_portal (object *op, object *caster, object *spell, int dir)
640{
641 object *dummy, *force, *old_force, *tmp;
642 archetype *perm_portal;
643 char portal_name[1024], portal_message[1024];
644 maptile *exitmap;
645 int op_level;
646 618
647 /* Check to see if the map the player is currently on is a per player unique 619 new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ());
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 exitmap = maptile::find_map (old_force->race, op->map);
724
725 if (exitmap)
726 {
727 int exitx = EXIT_X (old_force);
728 int exity = EXIT_Y (old_force);
729
730 tmp = present_arch (perm_portal, exitmap, exitx, exity);
731 while (tmp)
732 {
733 if (tmp->name == old_force->name)
734 {
735 tmp->destroy ();
736 break;
737 }
738
739 tmp = tmp->above;
740 }
741 }
742
743 old_force->destroy ();
744 }
745
746 dummy->destroy ();
747
748 /* Creating the portals.
749 * The very first thing to do is to ensure
750 * access to the destination map.
751 * If we can't, don't fizzle. Simply warn player.
752 * This ensure player pays his mana for the spell
753 * because HE is responsible of forgotting.
754 * 'force' is the destination of the town portal, which we got
755 * from the players inventory above.
756 */
757
758 /* Ensure exit map is loaded */
759 exitmap = maptile::find_map (force->name, 0);
760
761 /* If we were unable to load (ex. random map deleted), warn player */
762 if (!exitmap)
763 {
764 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "Something strange happens.\nYou can't remember where to go!?");
765 force->destroy ();
766 return 1;
767 }
768
769 op_level = caster_level (caster, spell);
770 if (op_level < 15)
771 snprintf (portal_message, 1024,
772 "\nThe air moves around you and\na huge smell of ammonia\nsurounds you as you pass\nthrough %s's tiny portal\nPouah!\n",
773 &op->name);
774 else if (op_level < 30)
775 snprintf (portal_message, 1024,
776 "\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);
777 else if (op_level < 60)
778 snprintf (portal_message, 1024, "\nA shining door opens in the air in front of you,\nshowing you the path to another place.\n");
779 else
780 snprintf (portal_message, 1024, "\nAs you walk through %s's portal, flowers come out\nfrom the ground around you.\nYou feel awed.\n",
781 &op->name);
782
783 /* Create a portal in front of player
784 * dummy contain the portal and
785 * force contain the track to kill it later
786 */
787 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &force->name);
788 dummy = get_archetype (spell->slaying); /*The portal */
789 if (dummy == NULL)
790 {
791 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
792 LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
793 return 0;
794 }
795
796 EXIT_PATH (dummy) = force->name;
797 EXIT_X (dummy) = EXIT_X (force);
798 EXIT_Y (dummy) = EXIT_Y (force);
799 dummy->name = dummy->name_pl = portal_name;
800 dummy->msg = portal_message;
801 dummy->race = op->name; /*Save the owner of the portal */
802 cast_create_obj (op, caster, dummy, 0);
803
804 /* Now we need to to create a town portal marker inside the player
805 * object, so on future castings, we can know that he has an active
806 * town portal.
807 */
808 tmp = get_archetype (spell->race);
809 if (tmp == NULL)
810 {
811 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
812 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
813 return 0;
814 }
815
816 tmp->race = op->map->path;
817 tmp->name = portal_name;
818 EXIT_X (tmp) = dummy->x;
819 EXIT_Y (tmp) = dummy->y;
820 op->insert (tmp);
821
822 /* Create a portal in the destination map
823 * dummy contain the portal and
824 * force the track to kill it later
825 * the 'force' variable still contains the 'reminder' of
826 * where this portal goes to.
827 */
828 snprintf (portal_name, 1024, "%s's portal to %s", &op->name, &op->map->path);
829 dummy = get_archetype (spell->slaying); /*The portal */
830 if (dummy == NULL)
831 {
832 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
833 LOG (llevError, "object::create failed (perm_magic_portal) in cast_create_town_portal for %s!\n", &op->name);
834 return 0;
835 }
836
837 EXIT_PATH (dummy) = op->map->path;
838 EXIT_X (dummy) = op->x;
839 EXIT_Y (dummy) = op->y;
840 dummy->name = dummy->name_pl = portal_name;
841 dummy->msg = portal_message;
842 dummy->race = op->name; /*Save the owner of the portal */
843 exitmap->insert (dummy, EXIT_X (force), EXIT_Y (force), op);
844
845 /* Now we create another town portal marker that
846 * points back to the one we just made
847 */
848 tmp = get_archetype (spell->race);
849 if (tmp == NULL)
850 {
851 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
852 LOG (llevError, "object::create failed (force) in cast_create_town_portal for %s!\n", &op->name);
853 return 0;
854 }
855
856 tmp->race = force->name;
857 tmp->name = portal_name;
858 EXIT_X (tmp) = dummy->x;
859 EXIT_Y (tmp) = dummy->y;
860 insert_ob_in_ob (tmp, op);
861
862 /* Describe the player what happened
863 */
864 new_draw_info (NDI_UNIQUE | NDI_NAVY, 0, op, "You see air moving and showing you the way home.");
865 force->destroy ();
866 620
867 return 1; 621 return 1;
868} 622}
869 623
870/* This creates magic walls. Really, it can create most any object, 624/* This creates magic walls. Really, it can create most any object,
… …
968 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name); 722 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
969 return 0; 723 return 0;
970 } 724 }
971 725
972 /* If this is a spellcasting wall, need to insert the spell object */ 726 /* If this is a spellcasting wall, need to insert the spell object */
973 if (tmp->other_arch && tmp->other_arch->clone.type == SPELL) 727 if (tmp->other_arch && tmp->other_arch->type == SPELL)
974 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp); 728 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
975 729
976 /* This code causes the wall to extend some distance in 730 /* This code causes the wall to extend some distance in
977 * each direction, or until an obstruction is encountered. 731 * each direction, or until an obstruction is encountered.
978 * posblocked and negblocked help determine how far the 732 * posblocked and negblocked help determine how far the
… …
998 { 752 {
999 object *tmp2 = tmp->clone (); 753 object *tmp2 = tmp->clone ();
1000 m->insert (tmp2, x, y, op); 754 m->insert (tmp2, x, y, op);
1001 755
1002 /* If this is a spellcasting wall, need to insert the spell object */ 756 /* If this is a spellcasting wall, need to insert the spell object */
1003 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 757 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1004 tmp2->insert (arch_to_object (tmp2->other_arch)); 758 tmp2->insert (arch_to_object (tmp2->other_arch));
1005 759
1006 } 760 }
1007 else 761 else
1008 posblocked = 1; 762 posblocked = 1;
… …
1015 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked) 769 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
1016 { 770 {
1017 object *tmp2 = tmp->clone (); 771 object *tmp2 = tmp->clone ();
1018 m->insert (tmp2, x, y, op); 772 m->insert (tmp2, x, y, op);
1019 773
1020 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 774 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
1021 tmp2->insert (arch_to_object (tmp2->other_arch)); 775 tmp2->insert (arch_to_object (tmp2->other_arch));
1022 } 776 }
1023 else 777 else
1024 negblocked = 1; 778 negblocked = 1;
1025 } 779 }
… …
1157 object *poison; 911 object *poison;
1158 int heal = 0, success = 0; 912 int heal = 0, success = 0;
1159 913
1160 tmp = find_target_for_friendly_spell (op, dir); 914 tmp = find_target_for_friendly_spell (op, dir);
1161 915
1162 if (tmp == NULL) 916 if (!tmp)
1163 return 0; 917 return 0;
1164 918
1165 /* Figure out how many hp this spell might cure. 919 /* Figure out how many hp this spell might cure.
1166 * could be zero if this spell heals effects, not damage. 920 * could be zero if this spell heals effects, not damage.
1167 */ 921 */
… …
1170 heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp; 924 heal += random_roll (spell->stats.hp, 6, op, PREFER_HIGH) + spell->stats.hp;
1171 925
1172 if (heal) 926 if (heal)
1173 { 927 {
1174 if (tmp->stats.hp >= tmp->stats.maxhp) 928 if (tmp->stats.hp >= tmp->stats.maxhp)
1175 {
1176 new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed."); 929 new_draw_info (NDI_UNIQUE, 0, tmp, "You are already fully healed.");
1177 }
1178 else 930 else
1179 { 931 {
1180 /* See how many points we actually heal. Instead of messages 932 /* See how many points we actually heal. Instead of messages
1181 * based on type of spell, we instead do messages based 933 * based on type of spell, we instead do messages based
1182 * on amount of damage healed. 934 * on amount of damage healed.
… …
1184 if (heal > (tmp->stats.maxhp - tmp->stats.hp)) 936 if (heal > (tmp->stats.maxhp - tmp->stats.hp))
1185 heal = tmp->stats.maxhp - tmp->stats.hp; 937 heal = tmp->stats.maxhp - tmp->stats.hp;
1186 tmp->stats.hp += heal; 938 tmp->stats.hp += heal;
1187 939
1188 if (tmp->stats.hp >= tmp->stats.maxhp) 940 if (tmp->stats.hp >= tmp->stats.maxhp)
1189 {
1190 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!"); 941 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
1191 }
1192 else if (heal > 50) 942 else if (heal > 50)
1193 {
1194 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!"); 943 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds close!");
1195 }
1196 else if (heal > 25) 944 else if (heal > 25)
1197 {
1198 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close."); 945 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds mostly close.");
1199 }
1200 else if (heal > 10) 946 else if (heal > 10)
1201 {
1202 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade."); 947 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to fade.");
1203 }
1204 else 948 else
1205 {
1206 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close."); 949 new_draw_info (NDI_UNIQUE, 0, tmp, "Your wounds start to close.");
1207 } 950
1208 success = 1; 951 success = 1;
1209 } 952 }
1210 } 953 }
954
1211 if (spell->attacktype & AT_DISEASE) 955 if (spell->attacktype & AT_DISEASE)
1212 if (cure_disease (tmp, op)) 956 if (cure_disease (tmp, op))
1213 success = 1; 957 success = 1;
1214 958
1215 if (spell->attacktype & AT_POISON) 959 if (spell->attacktype & AT_POISON)
… …
1221 success = 1; 965 success = 1;
1222 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed"); 966 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
1223 poison->stats.food = 1; 967 poison->stats.food = 1;
1224 } 968 }
1225 } 969 }
970
1226 if (spell->attacktype & AT_CONFUSION) 971 if (spell->attacktype & AT_CONFUSION)
1227 { 972 {
1228 poison = present_in_ob_by_name (FORCE, "confusion", tmp); 973 poison = present_in_ob_by_name (FORCE, "confusion", tmp);
1229 if (poison) 974 if (poison)
1230 { 975 {
1231 success = 1; 976 success = 1;
1232 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 977 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
1233 poison->duration = 1; 978 poison->duration = 1;
1234 } 979 }
1235 } 980 }
981
1236 if (spell->attacktype & AT_BLIND) 982 if (spell->attacktype & AT_BLIND)
1237 { 983 {
1238 at = archetype::find ("blindness"); 984 at = archetype::find ("blindness");
1239 poison = present_arch_in_ob (at, tmp); 985 poison = present_arch_in_ob (at, tmp);
1240 if (poison) 986 if (poison)
… …
1242 success = 1; 988 success = 1;
1243 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return."); 989 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
1244 poison->stats.food = 1; 990 poison->stats.food = 1;
1245 } 991 }
1246 } 992 }
993
1247 if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp) 994 if (spell->last_sp && tmp->stats.sp < tmp->stats.maxsp)
1248 { 995 {
1249 tmp->stats.sp += spell->last_sp; 996 tmp->stats.sp += spell->last_sp;
1250 if (tmp->stats.sp > tmp->stats.maxsp) 997 if (tmp->stats.sp > tmp->stats.maxsp)
1251 tmp->stats.sp = tmp->stats.maxsp; 998 tmp->stats.sp = tmp->stats.maxsp;
1252 success = 1; 999 success = 1;
1253 new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!"); 1000 new_draw_info (NDI_UNIQUE, 0, tmp, "Magical energy surges through your body!");
1254 } 1001 }
1002
1255 if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace) 1003 if (spell->last_grace && tmp->stats.grace < tmp->stats.maxgrace)
1256 { 1004 {
1257 tmp->stats.grace += spell->last_grace; 1005 tmp->stats.grace += spell->last_grace;
1258 if (tmp->stats.grace > tmp->stats.maxgrace) 1006 if (tmp->stats.grace > tmp->stats.maxgrace)
1259 tmp->stats.grace = tmp->stats.maxgrace; 1007 tmp->stats.grace = tmp->stats.maxgrace;
1260 success = 1; 1008 success = 1;
1261 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!"); 1009 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1262 } 1010 }
1011
1263 if (spell->stats.food && tmp->stats.food < 999) 1012 if (spell->stats.food && tmp->stats.food < 999)
1264 { 1013 {
1265 tmp->stats.food += spell->stats.food; 1014 tmp->stats.food += spell->stats.food;
1266 if (tmp->stats.food > 999) 1015 if (tmp->stats.food > 999)
1267 tmp->stats.food = 999; 1016 tmp->stats.food = 999;
1268 success = 1; 1017 success = 1;
1269 /* We could do something a bit better like the messages for healing above */ 1018 /* We could do something a bit better like the messages for healing above */
1270 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 1019 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1271 } 1020 }
1021
1272 return success; 1022 return success;
1273} 1023}
1274
1275 1024
1276/* This is used for the spells that gain stats. There are no spells 1025/* This is used for the spells that gain stats. There are no spells
1277 * right now that icnrease wis/int/pow on a temp basis, so no 1026 * right now that icnrease wis/int/pow on a temp basis, so no
1278 * good comments for those. 1027 * good comments for those.
1279 */ 1028 */
1280static const char *const no_gain_msgs[NUM_STATS] = { 1029static const char *const no_gain_msgs[NUM_STATS] = {
1281 "You grow no stronger.", 1030 "You grow no stronger.",
1282 "You grow no more agile.", 1031 "You grow no more agile.",
1283 "You don't feel any healthier.", 1032 "You don't feel any healthier.",
1284 "no wis", 1033 "You didn't grow any more intelligent.",
1034 "You do not feel any wiser.",
1035 "You don't feel any more powerful."
1285 "You are no easier to look at.", 1036 "You are no easier to look at.",
1286 "no int",
1287 "no pow"
1288}; 1037};
1289 1038
1290int 1039int
1291cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent) 1040cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1292{ 1041{
… …
1343 } 1092 }
1344 else 1093 else
1345 { 1094 {
1346 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect."); 1095 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1347 } 1096 }
1097
1348 return 1; 1098 return 1;
1349 } 1099 }
1100
1350 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1101 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1351 force->speed = 1.0; 1102 force->speed = 1.0;
1352 force->speed_left = -1.0; 1103 force->speed_left = -1.0;
1353 SET_FLAG (force, FLAG_APPLIED); 1104 SET_FLAG (force, FLAG_APPLIED);
1354 1105
… …
1360 force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob); 1111 force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob);
1361 if (force->resist[i] > 100) 1112 if (force->resist[i] > 100)
1362 force->resist[i] = 100; 1113 force->resist[i] = 100;
1363 } 1114 }
1364 } 1115 }
1116
1365 if (spell_ob->stats.hp) 1117 if (spell_ob->stats.hp)
1366 force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob); 1118 force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
1367 1119
1368 if (tmp->type == PLAYER) 1120 if (tmp->type == PLAYER)
1369 { 1121 {
1370 /* Stat adjustment spells */ 1122 /* Stat adjustment spells */
1371 for (i = 0; i < NUM_STATS; i++) 1123 for (i = 0; i < NUM_STATS; i++)
1372 { 1124 {
1373 sint8 stat = get_attr_value (&spell_ob->stats, i), k, sm; 1125 if (sint8 stat = spell_ob->stats.stat (i))
1374
1375 if (stat)
1376 { 1126 {
1377 sm = 0; 1127 sint8 sm = 0;
1378 for (k = 0; k < stat; k++) 1128 for (sint8 k = 0; k < stat; k++)
1379 sm += rndm (1, 3); 1129 sm += rndm (1, 3);
1380 1130
1381 if ((get_attr_value (&tmp->stats, i) + sm) > (15 + 5 * stat)) 1131 if (tmp->stats.stat (i) + sm > 15 + 5 * stat)
1382 { 1132 sm = max (0, (15 + 5 * stat) - tmp->stats.stat (i));
1383 sm = (15 + 5 * stat) - get_attr_value (&tmp->stats, i); 1133
1384 if (sm < 0) 1134 force->stats.stat (i) = sm;
1385 sm = 0; 1135
1386 }
1387 set_attr_value (&force->stats, i, sm);
1388 if (!sm) 1136 if (!sm)
1389 new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]); 1137 new_draw_info (NDI_UNIQUE, 0, op, no_gain_msgs[i]);
1390 } 1138 }
1391 } 1139 }
1392 } 1140 }
… …
1413 force->attacktype = spell_ob->attacktype; 1161 force->attacktype = spell_ob->attacktype;
1414 1162
1415 insert_ob_in_ob (force, tmp); 1163 insert_ob_in_ob (force, tmp);
1416 change_abil (tmp, force); /* Mostly to display any messages */ 1164 change_abil (tmp, force); /* Mostly to display any messages */
1417 tmp->update_stats (); 1165 tmp->update_stats ();
1166
1418 return 1; 1167 return 1;
1419} 1168}
1420 1169
1421/* This used to be part of cast_change_ability, but it really didn't make 1170/* This used to be part of cast_change_ability, but it really didn't make
1422 * a lot of sense, since most of the values it derives are from the god 1171 * a lot of sense, since most of the values it derives are from the god
1423 * of the caster. 1172 * of the caster.
1424 */ 1173 */
1425
1426int 1174int
1427cast_bless (object *op, object *caster, object *spell_ob, int dir) 1175cast_bless (object *op, object *caster, object *spell_ob, int dir)
1428{ 1176{
1429 int i; 1177 int i;
1430 object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp; 1178 object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp;
… …
1525 insert_ob_in_ob (force, tmp); 1273 insert_ob_in_ob (force, tmp);
1526 tmp->update_stats (); 1274 tmp->update_stats ();
1527 return 1; 1275 return 1;
1528} 1276}
1529 1277
1530
1531
1532/* Alchemy code by Mark Wedel 1278/* Alchemy code by Mark Wedel
1533 * 1279 *
1534 * This code adds a new spell, called alchemy. Alchemy will turn 1280 * This code adds a new spell, called alchemy. Alchemy will turn
1535 * objects to gold nuggets, the value of the gold nuggets being 1281 * objects to pyrite ("false gold"), henceforth called gold nuggets.
1536 * about 90% of that of the item itself. It uses the value of the
1537 * object before charisma adjustments, because the nuggets themselves
1538 * will be will be adjusted by charisma when sold.
1539 * 1282 *
1540 * Large nuggets are worth 25 gp each (base). You will always get 1283 * The value of the gold nuggets being about 90% of that of the item
1541 * the maximum number of large nuggets you could get. 1284 * itself. It uses the value of the object before charisma adjustments,
1542 * Small nuggets are worth 1 gp each (base). You will get from 0 1285 * because the nuggets themselves will be will be adjusted by charisma
1543 * to the max amount of small nuggets as you could get. 1286 * when sold.
1544 *
1545 * For example, if an item is worth 110 gold, you will get
1546 * 4 large nuggets, and from 0-10 small nuggets.
1547 * 1287 *
1548 * There is also a chance (1:30) that you will get nothing at all 1288 * There is also a chance (1:30) that you will get nothing at all
1549 * for the object. There is also a maximum weight that will be 1289 * for the object. There is also a maximum weight that will be
1550 * alchemied. 1290 * alchemised.
1551 */ 1291 */
1552
1553/* I didn't feel like passing these as arguements to the
1554 * two functions that need them. Real values are put in them
1555 * when the spell is cast, and these are freed when the spell
1556 * is finished.
1557 */
1558static object *small, *large;
1559
1560static void 1292static void
1561alchemy_object (object *obj, int *small_nuggets, int *large_nuggets, int *weight) 1293alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1562{ 1294{
1563 uint64 value = query_cost (obj, NULL, F_TRUE); 1295 uint64 value = query_cost (obj, NULL, F_TRUE);
1564 1296
1565 /* Give third price when we alchemy money (This should hopefully 1297 /* Give third price when we alchemy money (This should hopefully
1566 * make it so that it isn't worth it to alchemy money, sell 1298 * make it so that it isn't worth it to alchemy money, sell
1567 * the nuggets, alchemy the gold from that, etc. 1299 * the nuggets, alchemy the gold from that, etc.
1568 * Otherwise, give 9 silver on the gold for other objects, 1300 * Otherwise, give 9 silver on the gold for other objects,
1569 * so that it would still be more affordable to haul 1301 * so that it would still be more affordable to haul
1570 * the stuff back to town. 1302 * the stuff back to town.
1571 */ 1303 */
1572
1573 if (QUERY_FLAG (obj, FLAG_UNPAID)) 1304 if (QUERY_FLAG (obj, FLAG_UNPAID))
1574 value = 0; 1305 value = 0;
1575 else if (obj->type == MONEY || obj->type == GEM) 1306 else if (obj->type == MONEY || obj->type == GEM)
1576 value /= 3; 1307 value /= 3;
1577 else 1308 else
1578 value = (value * 9) / 10; 1309 value = value * 9 / 10;
1579 1310
1580 value /= 4; // fix by GHJ, don't understand, pcg
1581
1582 if ((obj->value > 0) && rndm (0, 29)) 1311 if (obj->value > 0 && rndm (0, 29))
1583 { 1312 total_value += value;
1584 int count;
1585 1313
1586 count = value / large->value;
1587 *large_nuggets += count;
1588 value -= (uint64) count *(uint64) large->value;
1589
1590 count = value / small->value;
1591 *small_nuggets += count;
1592 }
1593
1594 /* Turn 25 small nuggets into 1 large nugget. If the value
1595 * of large nuggets is not evenly divisable by the small nugget
1596 * value, take off an extra small_nugget (Assuming small_nuggets!=0)
1597 */
1598 if (*small_nuggets * small->value >= large->value)
1599 {
1600 (*large_nuggets)++;
1601 *small_nuggets -= large->value / small->value;
1602 if (*small_nuggets && large->value % small->value)
1603 (*small_nuggets)--;
1604 }
1605 weight += obj->weight; 1314 total_weight += obj->total_weight ();
1315
1606 obj->destroy (); 1316 obj->destroy ();
1607} 1317}
1608 1318
1609static void
1610update_map (object *op, maptile *m, int small_nuggets, int large_nuggets, int x, int y)
1611{
1612 object *tmp;
1613 int flag = 0;
1614
1615 /* Put any nuggets below the player, but we can only pass this
1616 * flag if we are on the same space as the player
1617 */
1618 if (x == op->x && y == op->y && op->map == m)
1619 flag = INS_BELOW_ORIGINATOR;
1620
1621 if (small_nuggets)
1622 {
1623 tmp = small->clone ();
1624 tmp->nrof = small_nuggets;
1625 m->insert (tmp, x, y, op, flag);
1626 }
1627
1628 if (large_nuggets)
1629 {
1630 tmp = large->clone ();
1631 tmp->nrof = large_nuggets;
1632 m->insert (tmp, x, y, op, flag);
1633 }
1634}
1635
1636int 1319int
1637alchemy (object *op, object *caster, object *spell_ob) 1320alchemy (object *op, object *caster, object *spell_ob)
1638{ 1321{
1639 int x, y, weight = 0, weight_max, large_nuggets, small_nuggets, mflags;
1640 sint16 nx, ny;
1641 object *next, *tmp;
1642 maptile *mp;
1643
1644 if (op->type != PLAYER) 1322 if (op->type != PLAYER)
1645 return 0; 1323 return 0;
1646 1324
1325 archetype *nugget[3];
1326
1327 nugget[0] = archetype::find ("pyrite3");
1328 nugget[1] = archetype::find ("pyrite2");
1329 nugget[2] = archetype::find ("pyrite");
1330
1647 /* Put a maximum weight of items that can be alchemied. Limits the power 1331 /* Put a maximum weight of items that can be alchemised. Limits the power
1648 * some, and also prevents people from alcheming every table/chair/clock 1332 * some, and also prevents people from alchemising every table/chair/clock
1649 * in sight 1333 * in sight
1650 */ 1334 */
1651 weight_max = spell_ob->duration + +SP_level_duration_adjust (caster, spell_ob); 1335 int duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
1652 weight_max *= 1000; 1336 int weight_max = duration * 1000;
1653 small = get_archetype ("smallnugget"), large = get_archetype ("largenugget"); 1337 uint64 value_max = duration * 1000;
1654 1338
1339 int weight = 0;
1340
1655 for (y = op->y - 1; y <= op->y + 1; y++) 1341 for (int y = op->y - 1; y <= op->y + 1; y++)
1656 { 1342 {
1657 for (x = op->x - 1; x <= op->x + 1; x++) 1343 for (int x = op->x - 1; x <= op->x + 1; x++)
1658 { 1344 {
1345 uint64 value = 0;
1346
1659 nx = x; 1347 sint16 nx = x;
1660 ny = y; 1348 sint16 ny = y;
1661 1349
1662 mp = op->map; 1350 maptile *mp = op->map;
1663 1351
1664 mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny); 1352 int mflags = get_map_flags (mp, &mp, nx, ny, &nx, &ny);
1665 1353
1666 if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC)) 1354 if (mflags & (P_OUT_OF_MAP | P_NO_MAGIC))
1667 continue; 1355 continue;
1668 1356
1669 /* Treat alchemy a little differently - most spell effects 1357 /* Treat alchemy a little differently - most spell effects
… …
1671 * ground level effect. 1359 * ground level effect.
1672 */ 1360 */
1673 if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK) 1361 if (GET_MAP_MOVE_BLOCK (mp, nx, ny) & MOVE_WALK)
1674 continue; 1362 continue;
1675 1363
1676 small_nuggets = 0; 1364 for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1677 large_nuggets = 0;
1678
1679 for (tmp = GET_MAP_OB (mp, nx, ny); tmp != NULL; tmp = next)
1680 { 1365 {
1681 next = tmp->above; 1366 next = tmp->above;
1367
1682 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) && 1368 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) &&
1683 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON)) 1369 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON))
1684 { 1370 {
1685
1686 if (tmp->inv) 1371 if (tmp->inv)
1687 { 1372 {
1688 object *next1, *tmp1; 1373 object *next1, *tmp1;
1689 1374
1690 for (tmp1 = tmp->inv; tmp1 != NULL; tmp1 = next1) 1375 for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1691 { 1376 {
1692 next1 = tmp1->below; 1377 next1 = tmp1->below;
1693 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) && 1378 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) &&
1694 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON)) 1379 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON))
1695 alchemy_object (tmp1, &small_nuggets, &large_nuggets, &weight); 1380 alchemy_object (tmp1, value, weight);
1696 } 1381 }
1697 } 1382 }
1383
1698 alchemy_object (tmp, &small_nuggets, &large_nuggets, &weight); 1384 alchemy_object (tmp, value, weight);
1699 1385
1700 if (weight > weight_max) 1386 if (weight > weight_max)
1701 { 1387 break;
1702 update_map (op, mp, small_nuggets, large_nuggets, nx, ny);
1703 large->destroy ();
1704 small->destroy ();
1705 return 1;
1706 } 1388 }
1707 } /* is alchemable object */
1708 } /* process all objects on this space */
1709
1710 /* Insert all the nuggets at one time. This probably saves time, but
1711 * it also prevents us from alcheming nuggets that were just created
1712 * with this spell.
1713 */ 1389 }
1714 update_map (op, mp, small_nuggets, large_nuggets, nx, ny); 1390
1391 value -= rndm (value >> 4);
1392 value = min (value, value_max);
1393
1394 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1395 if (int nrof = value / nugget [i]->value)
1396 {
1397 value -= nrof * nugget[i]->value;
1398
1399 object *tmp = arch_to_object (nugget[i]);
1400 tmp->nrof = nrof;
1401 tmp->flag [FLAG_IDENTIFIED] = true;
1402 caster->map->insert (tmp, x, y, caster, 0);
1715 } 1403 }
1716 }
1717 1404
1718 large->destroy (); 1405 if (weight > weight_max)
1719 small->destroy (); 1406 goto bailout;
1720 /* reset this so that if player standing on a big pile of stuff, 1407 }
1721 * it is redrawn properly. 1408 }
1722 */ 1409
1723 op->contr->ns->look_position = 0; 1410bailout:
1724 return 1; 1411 return 1;
1725} 1412}
1726 1413
1727 1414
1728/* This function removes the cursed/damned status on equipped 1415/* This function removes the cursed/damned status on equipped
… …
1755 } 1442 }
1756 1443
1757 if (op->type == PLAYER) 1444 if (op->type == PLAYER)
1758 { 1445 {
1759 if (success) 1446 if (success)
1760 {
1761 new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now."); 1447 new_draw_info (NDI_UNIQUE, 0, op, "You feel like some of your items are looser now.");
1762 }
1763 else 1448 else
1764 { 1449 {
1765 if (was_one) 1450 if (was_one)
1766 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse."); 1451 new_draw_info (NDI_UNIQUE, 0, op, "You failed to remove the curse.");
1767 else 1452 else
… …
1791 { 1476 {
1792 identify (tmp); 1477 identify (tmp);
1793 1478
1794 if (op->type == PLAYER) 1479 if (op->type == PLAYER)
1795 { 1480 {
1796 new_draw_info_format (NDI_UNIQUE, 0, op, "You have %s.", long_desc (tmp, op)); 1481 new_draw_info_format (NDI_UNIQUE, 0, op, "You identified: %s.", long_desc (tmp, op));
1797 1482
1798 if (tmp->msg) 1483 if (tmp->msg)
1799 { 1484 {
1800 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:"); 1485 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1801 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg); 1486 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
… …
1813 * stuff on the floor. Only identify stuff on the floor if the spell 1498 * stuff on the floor. Only identify stuff on the floor if the spell
1814 * was not fully used. 1499 * was not fully used.
1815 */ 1500 */
1816 if (num_ident) 1501 if (num_ident)
1817 { 1502 {
1818 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 1503 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1819 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1504 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1820 { 1505 {
1821 identify (tmp); 1506 identify (tmp);
1822 1507
1823 if (op->type == PLAYER) 1508 if (op->type == PLAYER)
1824 { 1509 {
1825 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground is %s.", long_desc (tmp, op)); 1510 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground you identified: %s.", long_desc (tmp, op));
1826 1511
1827 if (tmp->msg) 1512 if (tmp->msg)
1828 { 1513 {
1829 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:"); 1514 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1830 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg); 1515 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
… …
2180 /* Basically, if the object is magical and not counterspell, 1865 /* Basically, if the object is magical and not counterspell,
2181 * we will more or less remove the object. Don't counterspell 1866 * we will more or less remove the object. Don't counterspell
2182 * monsters either. 1867 * monsters either.
2183 */ 1868 */
2184 1869
2185 if (head->attacktype & AT_MAGIC && 1870 if (head->attacktype & AT_MAGIC
2186 !(head->attacktype & AT_COUNTERSPELL) && !QUERY_FLAG (head, FLAG_MONSTER) && (op->level > head->level)) 1871 && !(head->attacktype & AT_COUNTERSPELL)
1872 && !QUERY_FLAG (head, FLAG_MONSTER)
1873 && (op->level > head->level))
2187 head->destroy (); 1874 head->destroy ();
2188 else 1875 else
2189 switch (head->type) 1876 switch (head->type)
2190 { 1877 {
2191 case SPELL_EFFECT: 1878 case SPELL_EFFECT:
1879 // XXX: Don't affect floor spelleffects. See also XXX comment
1880 // about sanctuary in spell_util.C
1881 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1882 continue;
1883
2192 if (op->level > head->level) 1884 if (op->level > head->level)
2193 head->destroy (); 1885 head->destroy ();
2194 1886
2195 break; 1887 break;
2196 1888
… …
2263 * This code was very odd - code early on would only let players use the spell, 1955 * This code was very odd - code early on would only let players use the spell,
2264 * yet the code wass full of player checks. I've presumed that the code 1956 * yet the code wass full of player checks. I've presumed that the code
2265 * that only let players use it was correct, and removed all the other 1957 * that only let players use it was correct, and removed all the other
2266 * player checks. MSW 2003-01-06 1958 * player checks. MSW 2003-01-06
2267 */ 1959 */
2268
2269int 1960int
2270animate_weapon (object *op, object *caster, object *spell, int dir) 1961animate_weapon (object *op, object *caster, object *spell, int dir)
2271{ 1962{
2272 object *weapon, *tmp; 1963 object *weapon, *tmp;
2273 char buf[MAX_BUF]; 1964 char buf[MAX_BUF];
2274 int a, i; 1965 int a, i;
2275 sint16 x, y; 1966 sint16 x, y;
2276 maptile *m; 1967 maptile *m;
2277 materialtype_t *mt;
2278 1968
2279 if (!spell->other_arch) 1969 if (!spell->other_arch)
2280 { 1970 {
2281 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 1971 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
2282 LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name); 1972 LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);
… …
2285 /* exit if it's not a player using this spell. */ 1975 /* exit if it's not a player using this spell. */
2286 if (op->type != PLAYER) 1976 if (op->type != PLAYER)
2287 return 0; 1977 return 0;
2288 1978
2289 /* if player already has a golem, abort */ 1979 /* if player already has a golem, abort */
2290 if (op->contr->ranges[range_golem]) 1980 if (object *golem = op->contr->golem)
2291 { 1981 {
2292 control_golem (op->contr->ranges[range_golem], dir); 1982 control_golem (golem, dir);
2293 return 0; 1983 return 0;
2294 } 1984 }
2295 1985
2296 /* if no direction specified, pick one */ 1986 /* if no direction specified, pick one */
2297 if (!dir) 1987 if (!dir)
… …
2301 x = op->x + freearr_x[dir]; 1991 x = op->x + freearr_x[dir];
2302 y = op->y + freearr_y[dir]; 1992 y = op->y + freearr_y[dir];
2303 1993
2304 /* if there's no place to put the golem, abort */ 1994 /* if there's no place to put the golem, abort */
2305 if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) || 1995 if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) ||
2306 ((spell->other_arch->clone.move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->clone.move_type)) 1996 ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2307 { 1997 {
2308 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 1998 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
2309 return 0; 1999 return 0;
2310 } 2000 }
2311 2001
… …
2315 if (!weapon) 2005 if (!weapon)
2316 { 2006 {
2317 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!"); 2007 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
2318 return 0; 2008 return 0;
2319 } 2009 }
2320 if (spell->race && strcmp (weapon->arch->name, spell->race)) 2010 if (spell->race && strcmp (weapon->arch->archname, spell->race))
2321 { 2011 {
2322 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon."); 2012 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
2323 return 0; 2013 return 0;
2324 } 2014 }
2325 if (weapon->type != WEAPON) 2015 if (weapon->type != WEAPON)
… …
2343 /* create the golem object */ 2033 /* create the golem object */
2344 tmp = arch_to_object (spell->other_arch); 2034 tmp = arch_to_object (spell->other_arch);
2345 2035
2346 /* if animated by a player, give the player control of the golem */ 2036 /* if animated by a player, give the player control of the golem */
2347 CLEAR_FLAG (tmp, FLAG_MONSTER); 2037 CLEAR_FLAG (tmp, FLAG_MONSTER);
2348 SET_FLAG (tmp, FLAG_FRIENDLY);
2349 tmp->stats.exp = 0; 2038 tmp->stats.exp = 0;
2350 add_friendly_object (tmp); 2039 add_friendly_object (tmp);
2351 tmp->type = GOLEM; 2040 tmp->type = GOLEM;
2352 tmp->set_owner (op); 2041 tmp->set_owner (op);
2042 op->contr->golem = tmp;
2353 set_spell_skill (op, caster, spell, tmp); 2043 set_spell_skill (op, caster, spell, tmp);
2354 op->contr->ranges[range_golem] = tmp;
2355 op->contr->shoottype = range_golem;
2356 2044
2357 /* Give the weapon to the golem now. A bit of a hack to check the 2045 /* Give the weapon to the golem now. A bit of a hack to check the
2358 * removed flag - it should only be set if get_split_object was 2046 * removed flag - it should only be set if get_split_object was
2359 * used above. 2047 * used above.
2360 */ 2048 */
2361 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2049 if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2362 weapon->remove (); 2050 weapon->remove ();
2051
2363 insert_ob_in_ob (weapon, tmp); 2052 insert_ob_in_ob (weapon, tmp);
2364 esrv_send_item (op, weapon); 2053 esrv_send_item (op, weapon);
2365 /* To do everything necessary to let a golem use the weapon is a pain, 2054 /* To do everything necessary to let a golem use the weapon is a pain,
2366 * so instead, just set it as equipped (otherwise, we need to update 2055 * so instead, just set it as equipped (otherwise, we need to update
2367 * body_info, skills, etc) 2056 * body_info, skills, etc)
… …
2395 2084
2396 /* attacktype */ 2085 /* attacktype */
2397 if (!tmp->attacktype) 2086 if (!tmp->attacktype)
2398 tmp->attacktype = AT_PHYSICAL; 2087 tmp->attacktype = AT_PHYSICAL;
2399 2088
2400 mt = NULL;
2401 if (op->materialname != NULL)
2402 mt = name_to_material (op->materialname); 2089 if (materialtype_t *mt = name_to_material (op->materialname))
2403 if (mt != NULL)
2404 { 2090 {
2405 for (i = 0; i < NROFATTACKS; i++) 2091 for (i = 0; i < NROFATTACKS; i++)
2406 tmp->resist[i] = 50 - (mt->save[i] * 5); 2092 tmp->resist[i] = 50 - (mt->save[i] * 5);
2407 a = mt->save[0]; 2093 a = mt->save[0];
2408 } 2094 }
… …
2410 { 2096 {
2411 for (i = 0; i < NROFATTACKS; i++) 2097 for (i = 0; i < NROFATTACKS; i++)
2412 tmp->resist[i] = 5; 2098 tmp->resist[i] = 5;
2413 a = 10; 2099 a = 10;
2414 } 2100 }
2101
2415 /* Set weapon's immunity */ 2102 /* Set weapon's immunity */
2416 tmp->resist[ATNR_CONFUSION] = 100; 2103 tmp->resist[ATNR_CONFUSION] = 100;
2417 tmp->resist[ATNR_POISON] = 100; 2104 tmp->resist[ATNR_POISON] = 100;
2418 tmp->resist[ATNR_SLOW] = 100; 2105 tmp->resist[ATNR_SLOW] = 100;
2419 tmp->resist[ATNR_PARALYZE] = 100; 2106 tmp->resist[ATNR_PARALYZE] = 100;
… …
2425 2112
2426 /* Improve weapon's armour value according to best save vs. physical of its material */ 2113 /* Improve weapon's armour value according to best save vs. physical of its material */
2427 2114
2428 if (a > 14) 2115 if (a > 14)
2429 a = 14; 2116 a = 14;
2117
2430 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a)); 2118 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2431 2119
2432 /* Determine golem's speed */ 2120 /* Determine golem's speed */
2433 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell))); 2121 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2434 2122

Diff Legend

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