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.69 by root, Thu Aug 23 17:17:41 2007 UTC vs.
Revision 1.104 by root, Sat Jun 27 03:51:05 2009 UTC

1/* 1/*
2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Crossfire TRT is free software: you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify
9 * 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
10 * the Free Software Foundation, either version 3 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version. 11 * (at your option) any later version.
12 * 12 *
13 * 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,
… …
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * 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
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * 20 *
21 * The authors can be reached via e-mail to <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <support@deliantra.net>
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>
… …
61{ 61{
62 object *wand, *tmp; 62 object *wand, *tmp;
63 int ncharges; 63 int ncharges;
64 64
65 wand = find_marked_object (op); 65 wand = find_marked_object (op);
66 if (wand == NULL || wand->type != WAND) 66 if (!wand || wand->type != WAND)
67 { 67 {
68 new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge."); 68 new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge.");
69 return 0; 69 return 0;
70 } 70 }
71 if (!(random_roll (0, 3, op, PREFER_HIGH))) 71 if (!(random_roll (0, 3, op, PREFER_HIGH)))
72 { 72 {
73 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));
74 op->play_sound (sound_find ("ob_explode")); 74 op->play_sound (sound_find ("ob_explode"));
75 esrv_del_item (op->contr, wand->count);
76 wand->destroy (); 75 wand->destroy ();
77 tmp = get_archetype ("fireball"); 76 tmp = get_archetype ("fireball");
78 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10; 77 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
79 78
80 if (!tmp->stats.dam) 79 if (!tmp->stats.dam)
… …
123 * The # of arrows created also goes up with level, so if a 30th level mage 122 * The # of arrows created also goes up with level, so if a 30th level mage
124 * wants LOTS of arrows, and doesn't care what the plus is he could 123 * wants LOTS of arrows, and doesn't care what the plus is he could
125 * create nonnmagic arrows, or even -1, etc... 124 * create nonnmagic arrows, or even -1, etc...
126 */ 125 */
127int 126int
128cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg) 127cast_create_missile (object *op, object *caster, object *spell, int dir, const char *spellparam)
129{ 128{
130 int missile_plus = 0, bonus_plus = 0; 129 int bonus_plus = 0;
131 const char *missile_name; 130 const char *missile_name = "arrow";
132 object *tmp, *missile;
133 131
134 missile_name = "arrow";
135
136 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 132 for (object *tmp = op->inv; tmp; tmp = tmp->below)
137 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED)) 133 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
138 missile_name = tmp->race; 134 missile_name = tmp->race;
139 135
140 missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell); 136 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
141 137
142 if (archetype::find (missile_name) == NULL) 138 archetype *missile_arch = archetype::find (missile_name);
139
140 if (!missile_arch)
143 { 141 {
144 LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name); 142 LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);
145 return 0; 143 return 0;
146 } 144 }
147 145
148 missile = get_archetype (missile_name); 146 object *missile = missile_arch->instance ();
149 147
150 if (stringarg) 148 if (spellparam)
151 { 149 {
152 /* If it starts with a letter, presume it is a description */ 150 /* If it starts with a letter, presume it is a description */
153 if (isalpha (*stringarg)) 151 if (isalpha (*spellparam))
154 { 152 {
155 artifact *al = find_artifactlist (missile->type)->items; 153 artifact *al = find_artifactlist (missile->type)->items;
156 154
157 for (; al; al = al->next) 155 for (; al; al = al->next)
158 if (!strcasecmp (al->item->name, stringarg)) 156 if (!strcasecmp (al->item->name, spellparam))
159 break; 157 break;
160 158
161 if (!al) 159 if (!al)
162 { 160 {
163 missile->destroy (); 161 missile->destroy ();
164 new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, stringarg); 162 new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, spellparam);
165 return 0; 163 return 0;
166 } 164 }
167 165
168 if (al->item->slaying) 166 if (al->item->slaying)
169 { 167 {
170 missile->destroy (); 168 missile->destroy ();
171 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg); 169 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, spellparam);
172 return 0; 170 return 0;
173 } 171 }
174 172
175 give_artifact_abilities (missile, al->item); 173 give_artifact_abilities (missile, al->item);
176 /* These special arrows cost something extra. Don't have them also be magical - 174 /* These special arrows cost something extra. Don't have them also be magical -
177 * otherwise, in most cases, not enough will be created. I don't want to get into 175 * otherwise, in most cases, not enough will be created. I don't want to get into
178 * the parsing of having to do both plus and type. 176 * the parsing of having to do both plus and type.
179 */ 177 */
180 bonus_plus = 1 + (al->item->value / 5); 178 bonus_plus = 1 + (al->item->value / 5);
181 missile_plus = 0; 179 missile_plus = 0;
182 } 180 }
183 else if (atoi (stringarg) < missile_plus) 181 else if (atoi (spellparam) < missile_plus)
184 missile_plus = atoi (stringarg); 182 missile_plus = atoi (spellparam);
185 } 183 }
186 184
187 if (missile_plus > 4) 185 missile_plus = clamp (missile_plus, -4, 4);
188 missile_plus = 4;
189 else if (missile_plus < -4)
190 missile_plus = -4;
191 186
192 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell); 187 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
193 missile->nrof -= 3 * (missile_plus + bonus_plus); 188 missile->nrof -= 3 * (missile_plus + bonus_plus);
194 189
195 if (missile->nrof < 1) 190 if (missile->nrof < 1)
… …
207 return 1; 202 return 1;
208} 203}
209 204
210 205
211/* allows the choice of what sort of food object to make. 206/* allows the choice of what sort of food object to make.
212 * If stringarg is NULL, it will create food dependent on level --PeterM*/ 207 * If spellparam is NULL, it will create food dependent on level --PeterM*/
213int 208int
214cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *stringarg) 209cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *spellparam)
215{ 210{
216 int food_value; 211 int food_value;
217 archetype *at = NULL; 212 archetype *at = NULL;
218 object *new_op; 213 object *new_op;
219 214
220 food_value = spell_ob->stats.food + +50 * SP_level_duration_adjust (caster, spell_ob); 215 food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);
221 216
222 if (stringarg) 217 if (spellparam)
223 { 218 {
224 at = find_archetype_by_object_type_name (FOOD, stringarg); 219 at = find_archetype_by_object_type_name (FOOD, spellparam);
225 if (at == NULL) 220 if (at == NULL)
226 at = find_archetype_by_object_type_name (DRINK, stringarg); 221 at = find_archetype_by_object_type_name (DRINK, spellparam);
227 if (at == NULL || at->stats.food > food_value) 222 if (at == NULL || at->stats.food > food_value)
228 stringarg = NULL; 223 spellparam = NULL;
229 } 224 }
230 225
231 if (!stringarg) 226 if (!spellparam)
232 { 227 {
233 archetype *at_tmp; 228 archetype *at_tmp;
234 229
235 /* We try to find the archetype with the maximum food value. 230 /* We try to find the archetype with the maximum food value.
236 * This removes the dependancy of hard coded food values in this 231 * This removes the dependancy of hard coded food values in this
… …
284{ 279{
285 int r, mflags, maxrange; 280 int r, mflags, maxrange;
286 object *tmp; 281 object *tmp;
287 maptile *m; 282 maptile *m;
288 283
289
290 if (!dir) 284 if (!dir)
291 { 285 {
292 examine_monster (op, op); 286 examine_monster (op, op);
293 return 1; 287 return 1;
294 } 288 }
… …
307 if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC)) 301 if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC))
308 { 302 {
309 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic."); 303 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
310 return 0; 304 return 0;
311 } 305 }
306
312 if (mflags & P_IS_ALIVE) 307 if (mflags & P_IS_ALIVE)
313 { 308 {
314 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above) 309 for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
315 if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER))) 310 if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER)))
316 { 311 {
317 new_draw_info (NDI_UNIQUE, 0, op, "You detect something."); 312 new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
318 if (tmp->head != NULL) 313 if (tmp->head != NULL)
319 tmp = tmp->head; 314 tmp = tmp->head;
… …
350 345
351 return 1; 346 return 1;
352 } 347 }
353 348
354 /* invis_race is set if we get here */ 349 /* invis_race is set if we get here */
355 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon)) 350 if (pl->contr->invis_race == shstr_undead && is_true_undead (mon))
356 return 1; 351 return 1;
357 352
358 /* No race, can't be invisible to it */ 353 /* No race, can't be invisible to it */
359 if (!mon->race) 354 if (!mon->race)
360 return 0; 355 return 0;
361 356
362 if (strstr (mon->race, pl->contr->invis_race)) 357 if (mon->race.contains (pl->contr->invis_race))
363 return 1; 358 return 1;
364 359
365 /* Nothing matched above, return 0 */ 360 /* Nothing matched above, return 0 */
366 return 0; 361 return 0;
367 } 362 }
… …
430/* earth to dust spell. Basically destroys earthwalls in the area. 425/* earth to dust spell. Basically destroys earthwalls in the area.
431 */ 426 */
432int 427int
433cast_earth_to_dust (object *op, object *caster, object *spell_ob) 428cast_earth_to_dust (object *op, object *caster, object *spell_ob)
434{ 429{
435 object *tmp, *next;
436 int range, i, j, mflags; 430 int range, i, j, mflags;
437 sint16 sx, sy; 431 sint16 sx, sy;
438 maptile *m; 432 maptile *m;
439
440 if (op->type != PLAYER)
441 return 0;
442 433
443 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 434 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
444 435
445 for (i = -range; i <= range; i++) 436 for (i = -range; i <= range; i++)
446 for (j = -range; j <= range; j++) 437 for (j = -range; j <= range; j++)
… …
451 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy); 442 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
452 443
453 if (mflags & P_OUT_OF_MAP) 444 if (mflags & P_OUT_OF_MAP)
454 continue; 445 continue;
455 446
456 // earth to dust tears down everything that can be teared down 447 // earth to dust tears down everything that can be torn down
457 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next) 448 for (object *next, *tmp = m->at (sx, sy).bot; tmp; tmp = next)
458 { 449 {
459 next = tmp->above; 450 next = tmp->above;
451
460 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN)) 452 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN))
461 hit_player (tmp, 9998, op, AT_PHYSICAL, 0); 453 hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
462 } 454 }
463 } 455 }
464 456
… …
471 if (object *pl = op->in_player ()) 463 if (object *pl = op->in_player ())
472 { 464 {
473 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST)) 465 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
474 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you."); 466 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
475 else 467 else
476 { 468 pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);
477 // remove first so we do not call update_stats
478 op->remove ();
479 pl->enter_exit (op);
480 }
481 } 469 }
482 470
483 op->destroy (); 471 op->destroy ();
484} 472}
485 473
… …
501 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 489 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
502 return 1; 490 return 1;
503 } 491 }
504 492
505 dummy = get_archetype (FORCE_NAME); 493 dummy = get_archetype (FORCE_NAME);
506 if (dummy == NULL) 494
495 if (!dummy)
507 { 496 {
508 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 497 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
509 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n"); 498 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
510 return 0; 499 return 0;
511 } 500 }
… …
577perceive_self (object *op) 566perceive_self (object *op)
578{ 567{
579 const char *cp = describe_item (op, op); 568 const char *cp = describe_item (op, op);
580 archetype *at = archetype::find (ARCH_DEPLETION); 569 archetype *at = archetype::find (ARCH_DEPLETION);
581 570
582 dynbuf_text buf; 571 dynbuf_text &buf = msg_dynbuf; buf.clear ();
583 572
584 if (player *pl = op->contr) 573 if (!op->is_player ())
574 return 0;
575
585 if (object *race = archetype::find (op->race)) 576 if (object *race = archetype::find (op->race))
586 buf << "You are a " << (pl->gender ? "female" : "male") << " " << &race->name << ".\n"; 577 buf << " - You are a G<male|female> " << &race->name << ".\n";
587 578
588 if (object *god = find_god (determine_god (op))) 579 if (object *god = find_god (determine_god (op)))
589 buf << "You worship " << &god->name << ".\n"; 580 buf << " - You worship " << &god->name << ".\n";
590 else 581 else
591 buf << "You worship no god.\n"; 582 buf << " - You worship no god.\n";
592 583
593 object *tmp = present_arch_in_ob (at, op); 584 object *tmp = present_arch_in_ob (at, op);
594 585
595 if (*cp == '\0' && tmp == NULL) 586 if (*cp == '\0' && !tmp)
596 buf << "You feel very mundane. "; 587 buf << " - You feel very mundane. ";
597 else 588 else
598 { 589 {
599 buf << "You have: " << cp << ".\n"; 590 buf << " - You have: " << cp << ".\n";
600 591
601 if (tmp) 592 if (tmp)
602 for (int i = 0; i < NUM_STATS; i++) 593 for (int i = 0; i < NUM_STATS; i++)
603 if (tmp->stats.stat (i) < 0) 594 if (tmp->stats.stat (i) < 0)
604 buf.printf ("Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i)); 595 buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
605 } 596 }
606 597
607 if (is_dragon_pl (op)) 598 if (is_dragon_pl (op))
608 /* now grab the 'dragon_ability'-force from the player's inventory */ 599 /* now grab the 'dragon_ability'-force from the player's inventory */
609 for (tmp = op->inv; tmp; tmp = tmp->below) 600 for (tmp = op->inv; tmp; tmp = tmp->below)
610 { 601 {
611 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force) 602 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
612 { 603 {
613 if (tmp->stats.exp == 0) 604 if (tmp->stats.exp == 0)
614 buf << "Your metabolism isn't focused on anything.\n"; 605 buf << " - Your metabolism isn't focused on anything.\n";
615 else 606 else
616 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n"; 607 buf << " - Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
617 608
618 break; 609 break;
619 } 610 }
620 } 611 }
621 612
622 buf << '\0'; // zero-terminate 613 op->contr->infobox (MSG_CHANNEL ("perceiveself"), buf);
623
624 new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ());
625 614
626 return 1; 615 return 1;
627} 616}
628 617
629/* This creates magic walls. Really, it can create most any object, 618/* This creates magic walls. Really, it can create most any object,
… …
717 */ 706 */
718 if (tmp->type != EARTHWALL) //TODO 707 if (tmp->type != EARTHWALL) //TODO
719 tmp->set_owner (op); 708 tmp->set_owner (op);
720 709
721 set_spell_skill (op, caster, spell_ob, tmp); 710 set_spell_skill (op, caster, spell_ob, tmp);
722 tmp->level = caster_level (caster, spell_ob) / 2; 711 tmp->level = casting_level (caster, spell_ob) / 2;
723 712
724 name = tmp->name; 713 name = tmp->name;
725 if (!(tmp = m->insert (tmp, x, y, op))) 714 if (!(tmp = m->insert (tmp, x, y, op)))
726 { 715 {
727 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name); 716 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
… …
788 777
789 return 1; 778 return 1;
790} 779}
791 780
792int 781int
793dimension_door (object *op, object *caster, object *spob, int dir) 782dimension_door (object *op, object *caster, object *spob, int dir, const char *spellparam)
794{ 783{
795 uint32 dist, maxdist; 784 uint32 dist, maxdist;
796 int mflags; 785 int mflags;
797 maptile *m; 786 maptile *m;
798 sint16 sx, sy; 787 sint16 sx, sy;
… …
809 /* Given the new outdoor maps, can't let players dimension door for 798 /* Given the new outdoor maps, can't let players dimension door for
810 * ever, so put limits in. 799 * ever, so put limits in.
811 */ 800 */
812 maxdist = spob->range + SP_level_range_adjust (caster, spob); 801 maxdist = spob->range + SP_level_range_adjust (caster, spob);
813 802
814 if (op->contr->count) 803 if (spellparam)
815 { 804 {
805 int count = atoi (spellparam);
806
816 if (op->contr->count > maxdist) 807 if (count > maxdist)
817 { 808 {
818 new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!"); 809 new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!");
819 return 0; 810 return 0;
820 } 811 }
821 812
822 for (dist = 0; dist < op->contr->count; dist++) 813 for (dist = 0; dist < count; dist++)
823 { 814 {
824 mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy); 815 mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);
825 816
826 if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP)) 817 if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
827 break; 818 break;
828 819
829 if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))) 820 if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
830 break; 821 break;
831 } 822 }
832 823
833 if (dist < op->contr->count) 824 if (dist < count)
834 { 825 {
835 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n"); 826 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
836 op->contr->count = 0;
837 return 0; 827 return 0;
838 } 828 }
839
840 op->contr->count = 0;
841 829
842 /* Remove code that puts player on random space on maps. IMO, 830 /* Remove code that puts player on random space on maps. IMO,
843 * a lot of maps probably have areas the player should not get to, 831 * a lot of maps probably have areas the player should not get to,
844 * but may not be marked as NO_MAGIC (as they may be bounded 832 * but may not be marked as NO_MAGIC (as they may be bounded
845 * by such squares). Also, there are probably treasure rooms and 833 * by such squares). Also, there are probably treasure rooms and
… …
900 888
901 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 889 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
902 return 1; 890 return 1;
903} 891}
904 892
905
906/* cast_heal: Heals something. 893/* cast_heal: Heals something.
907 * op is the caster. 894 * op is the caster.
908 * dir is the direction he is casting it in. 895 * dir is the direction he is casting it in.
909 * spell is the spell object. 896 * spell is the spell object.
910 */ 897 */
… …
936 { 923 {
937 /* See how many points we actually heal. Instead of messages 924 /* See how many points we actually heal. Instead of messages
938 * based on type of spell, we instead do messages based 925 * based on type of spell, we instead do messages based
939 * on amount of damage healed. 926 * on amount of damage healed.
940 */ 927 */
941 if (heal > (tmp->stats.maxhp - tmp->stats.hp)) 928 if (heal > tmp->stats.maxhp - tmp->stats.hp)
942 heal = tmp->stats.maxhp - tmp->stats.hp; 929 heal = tmp->stats.maxhp - tmp->stats.hp;
930
943 tmp->stats.hp += heal; 931 tmp->stats.hp += heal;
944 932
945 if (tmp->stats.hp >= tmp->stats.maxhp) 933 if (tmp->stats.hp >= tmp->stats.maxhp)
946 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!"); 934 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
947 else if (heal > 50) 935 else if (heal > 50)
… …
956 success = 1; 944 success = 1;
957 } 945 }
958 } 946 }
959 947
960 if (spell->attacktype & AT_DISEASE) 948 if (spell->attacktype & AT_DISEASE)
961 if (cure_disease (tmp, op)) 949 if (cure_disease (tmp, op, spell))
962 success = 1; 950 success = 1;
963 951
964 if (spell->attacktype & AT_POISON) 952 if (spell->attacktype & AT_POISON)
965 { 953 {
966 at = archetype::find ("poisoning"); 954 at = archetype::find ("poisoning");
… …
1015 } 1003 }
1016 1004
1017 if (spell->stats.food && tmp->stats.food < 999) 1005 if (spell->stats.food && tmp->stats.food < 999)
1018 { 1006 {
1019 tmp->stats.food += spell->stats.food; 1007 tmp->stats.food += spell->stats.food;
1008
1020 if (tmp->stats.food > 999) 1009 if (tmp->stats.food > 999)
1021 tmp->stats.food = 999; 1010 tmp->stats.food = 999;
1011
1022 success = 1; 1012 success = 1;
1023 /* We could do something a bit better like the messages for healing above */ 1013 /* We could do something a bit better like the messages for healing above */
1024 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 1014 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1025 } 1015 }
1026 1016
… …
1042}; 1032};
1043 1033
1044int 1034int
1045cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent) 1035cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1046{ 1036{
1047 object *force = NULL; 1037 object *force = 0;
1048 int i; 1038 int i;
1049 1039
1050 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1040 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1051 object *tmp = dir 1041 object *tmp = dir
1052 ? find_target_for_friendly_spell (op, dir) 1042 ? find_target_for_friendly_spell (op, dir)
1053 : op; 1043 : op;
1054 1044
1055 if (!tmp) 1045 if (!tmp)
1056 return 0; 1046 return 0;
1057 1047
1058 /* If we've already got a force of this type, don't add a new one. */ 1048 /* If we've already got a force of this type, don't add a new one. */
… …
1067 } 1057 }
1068 else if (spell_ob->race && spell_ob->race == tmp2->name) 1058 else if (spell_ob->race && spell_ob->race == tmp2->name)
1069 { 1059 {
1070 if (!silent) 1060 if (!silent)
1071 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl); 1061 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
1062
1072 return 0; 1063 return 0;
1073 } 1064 }
1074 } 1065 }
1075 } 1066 }
1076 if (force == NULL) 1067
1068 if (!force)
1077 { 1069 {
1078 force = get_archetype (FORCE_NAME); 1070 force = get_archetype (FORCE_NAME);
1079 force->subtype = FORCE_CHANGE_ABILITY; 1071 force->subtype = FORCE_CHANGE_ABILITY;
1072
1080 if (spell_ob->race) 1073 if (spell_ob->race)
1081 force->name = spell_ob->race; 1074 force->name = spell_ob->race;
1082 else 1075 else
1083 force->name = spell_ob->name; 1076 force->name = spell_ob->name;
1077
1084 force->name_pl = spell_ob->name; 1078 force->name_pl = spell_ob->name;
1085 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force."); 1079 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
1086 1080
1087 } 1081 }
1088 else 1082 else
… …
1094 { 1088 {
1095 force->duration = duration; 1089 force->duration = duration;
1096 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 1090 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1097 } 1091 }
1098 else 1092 else
1099 {
1100 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.");
1101 }
1102 1094
1103 return 1; 1095 return 1;
1104 } 1096 }
1105 1097
1106 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1098 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
… …
1178 */ 1170 */
1179int 1171int
1180cast_bless (object *op, object *caster, object *spell_ob, int dir) 1172cast_bless (object *op, object *caster, object *spell_ob, int dir)
1181{ 1173{
1182 int i; 1174 int i;
1183 object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp; 1175 object *god = find_god (determine_god (op)), *force = NULL, *tmp;
1184 1176
1185 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1177 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1186 if (dir != 0) 1178 if (dir != 0)
1187 { 1179 {
1188 tmp = find_target_for_friendly_spell (op, dir); 1180 tmp = find_target_for_friendly_spell (op, dir);
1181
1182 if (!tmp)
1183 return 0;
1189 } 1184 }
1190 else 1185 else
1191 {
1192 tmp = op; 1186 tmp = op;
1193 }
1194 1187
1195 /* If we've already got a force of this type, don't add a new one. */ 1188 /* If we've already got a force of this type, don't add a new one. */
1196 for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) 1189 for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1197 { 1190 {
1198 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY) 1191 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1199 { 1192 {
1200 if (tmp2->name == spell_ob->name) 1193 if (tmp2->name == spell_ob->name)
1201 { 1194 {
… …
1207 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl); 1200 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
1208 return 0; 1201 return 0;
1209 } 1202 }
1210 } 1203 }
1211 } 1204 }
1205
1212 if (force == NULL) 1206 if (force == NULL)
1213 { 1207 {
1214 force = get_archetype (FORCE_NAME); 1208 force = get_archetype (FORCE_NAME);
1215 force->subtype = FORCE_CHANGE_ABILITY; 1209 force->subtype = FORCE_CHANGE_ABILITY;
1216 if (spell_ob->race) 1210 if (spell_ob->race)
… …
1297static void 1291static void
1298alchemy_object (object *obj, uint64 &total_value, int &total_weight) 1292alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1299{ 1293{
1300 uint64 value = query_cost (obj, NULL, F_TRUE); 1294 uint64 value = query_cost (obj, NULL, F_TRUE);
1301 1295
1302 /* Give third price when we alchemy money (This should hopefully 1296 /* Give third price when we alchemy money (this should hopefully
1303 * make it so that it isn't worth it to alchemy money, sell 1297 * make it so that it isn't worth it to alchemy money, sell
1304 * the nuggets, alchemy the gold from that, etc. 1298 * the nuggets, alchemy the gold from that, etc.
1305 * Otherwise, give 9 silver on the gold for other objects, 1299 * Otherwise, give 9 silver on the gold for other objects,
1306 * so that it would still be more affordable to haul 1300 * so that it would still be more affordable to haul
1307 * the stuff back to town. 1301 * the stuff back to town.
… …
1414 1408
1415bailout: 1409bailout:
1416 return 1; 1410 return 1;
1417} 1411}
1418 1412
1419
1420/* This function removes the cursed/damned status on equipped 1413/* This function removes the cursed/damned status on equipped
1421 * items. 1414 * items.
1422 */ 1415 */
1423int 1416int
1424remove_curse (object *op, object *caster, object *spell) 1417remove_curse (object *op, object *caster, object *spell)
… …
1430 if (QUERY_FLAG (tmp, FLAG_APPLIED) && 1423 if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
1431 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) || 1424 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1432 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED)))) 1425 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1433 { 1426 {
1434 was_one++; 1427 was_one++;
1428
1435 if (tmp->level <= caster_level (caster, spell)) 1429 if (tmp->level <= casting_level (caster, spell))
1436 { 1430 {
1437 success++; 1431 success++;
1438 if (QUERY_FLAG (spell, FLAG_DAMNED)) 1432 if (QUERY_FLAG (spell, FLAG_DAMNED))
1439 CLEAR_FLAG (tmp, FLAG_DAMNED); 1433 CLEAR_FLAG (tmp, FLAG_DAMNED);
1440 1434
1441 CLEAR_FLAG (tmp, FLAG_CURSED); 1435 CLEAR_FLAG (tmp, FLAG_CURSED);
1442 CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED); 1436 CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);
1443 tmp->value = 0; /* Still can't sell it */ 1437 tmp->value = 0; /* Still can't sell it */
1444 if (op->type == PLAYER) 1438
1439 if (object *pl = tmp->visible_to ())
1445 esrv_send_item (op, tmp); 1440 esrv_update_item (UPD_FLAGS, pl, tmp);
1446 } 1441 }
1447 } 1442 }
1448 1443
1449 if (op->type == PLAYER) 1444 if (op->type == PLAYER)
1450 { 1445 {
… …
1461 1456
1462 return success; 1457 return success;
1463} 1458}
1464 1459
1465/* Identifies objects in the players inventory/on the ground */ 1460/* Identifies objects in the players inventory/on the ground */
1466
1467int 1461int
1468cast_identify (object *op, object *caster, object *spell) 1462cast_identify (object *op, object *caster, object *spell)
1469{ 1463{
1470 object *tmp; 1464 object *tmp;
1471 int success = 0, num_ident; 1465 dynbuf_text &buf = msg_dynbuf; buf.clear ();
1472 1466
1473 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1467 int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1474
1475 if (num_ident < 1)
1476 num_ident = 1;
1477 1468
1478 for (tmp = op->inv; tmp; tmp = tmp->below) 1469 for (tmp = op->inv; tmp; tmp = tmp->below)
1479 { 1470 {
1480 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1471 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1481 { 1472 {
1482 identify (tmp); 1473 identify (tmp);
1483 1474
1484 if (op->type == PLAYER) 1475 if (op->type == PLAYER)
1485 { 1476 {
1486 new_draw_info_format (NDI_UNIQUE, 0, op, "You identified: %s.", long_desc (tmp, op)); 1477 buf.printf ("You identified: %s.\r", long_desc (tmp, op));
1487 1478
1488 if (tmp->msg) 1479 if (tmp->msg)
1489 { 1480 buf << "The item has a story:\r" << tmp->msg << "\n\n";
1490 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1491 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1492 }
1493 } 1481 }
1494 1482
1495 num_ident--;
1496 success = 1;
1497 if (!num_ident) 1483 if (!--num_ident)
1498 break; 1484 break;
1499 } 1485 }
1500 } 1486 }
1501 1487
1502 /* If all the power of the spell has been used up, don't go and identify 1488 /* If all the power of the spell has been used up, don't go and identify
… …
1508 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above) 1494 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1509 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1495 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1510 { 1496 {
1511 identify (tmp); 1497 identify (tmp);
1512 1498
1513 if (op->type == PLAYER) 1499 if (object *pl = tmp->visible_to ())
1514 { 1500 {
1515 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground you identified: %s.", long_desc (tmp, op)); 1501 buf.printf ("On the ground you identified: %s.\r", long_desc (tmp, op));
1516 1502
1517 if (tmp->msg) 1503 if (tmp->msg)
1518 { 1504 buf << "The item has a story:\r" << tmp->msg << "\n\n";
1519 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1520 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1521 }
1522
1523 esrv_send_item (op, tmp);
1524 } 1505 }
1525 1506
1526 num_ident--;
1527 success = 1;
1528 if (!num_ident) 1507 if (!--num_ident)
1529 break; 1508 break;
1530 } 1509 }
1531 } 1510 }
1532 1511
1533 if (!success) 1512 if (buf.empty ())
1534 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified."); 1513 {
1514 op->failmsg ("You can't reach anything unidentified.");
1515 return 0;
1516 }
1535 else 1517 else
1518 {
1519 if (op->contr)
1520 op->contr->infobox (MSG_CHANNEL ("identify"), buf);
1521
1536 spell_effect (spell, op->x, op->y, op->map, op); 1522 spell_effect (spell, op->x, op->y, op->map, op);
1537 1523 return 1;
1538 return success; 1524 }
1539} 1525}
1540 1526
1541int 1527int
1542cast_detection (object *op, object *caster, object *spell, object *skill) 1528cast_detection (object *op, object *caster, object *spell, object *skill)
1543{ 1529{
… …
1548 1534
1549 /* We precompute some values here so that we don't have to keep 1535 /* We precompute some values here so that we don't have to keep
1550 * doing it over and over again. 1536 * doing it over and over again.
1551 */ 1537 */
1552 god = find_god (determine_god (op)); 1538 god = find_god (determine_god (op));
1553 level = caster_level (caster, spell); 1539 level = casting_level (caster, spell);
1554 range = spell->range + SP_level_range_adjust (caster, spell); 1540 range = spell->range + SP_level_range_adjust (caster, spell);
1555 1541
1556 if (!skill) 1542 if (!skill)
1557 skill = caster; 1543 skill = caster;
1558 1544
1559 for (x = op->x - range; x <= op->x + range; x++) 1545 unordered_mapwalk (op, -range, -range, range, range)
1560 for (y = op->y - range; y <= op->y + range; y++)
1561 { 1546 {
1562 m = op->map;
1563 mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1564 if (mflags & P_OUT_OF_MAP)
1565 continue;
1566
1567 /* For most of the detections, we only detect objects above the 1547 /* For most of the detections, we only detect objects above the
1568 * floor. But this is not true for show invisible. 1548 * floor. But this is not true for show invisible.
1569 * Basically, we just go and find the top object and work 1549 * Basically, we just go and find the top object and work
1570 * down - that is easier than working up. 1550 * down - that is easier than working up.
1571 */ 1551 */
1572 1552
1573 for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above) 1553 for (last = NULL, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1574 last = tmp; 1554 last = tmp;
1575 1555
1576 /* Shouldn't happen, but if there are no objects on a space, this 1556 /* Shouldn't happen, but if there are no objects on a space, this
1577 * would happen. 1557 * would happen.
1578 */ 1558 */
1579 if (!last) 1559 if (!last)
1580 continue; 1560 continue;
1581 1561
1582 done_one = 0; 1562 done_one = 0;
1583 floor = 0; 1563 floor = 0;
1584 detect = NULL; 1564 detect = NULL;
1585 for (tmp = last; tmp; tmp = tmp->below) 1565 for (tmp = last; tmp; tmp = tmp->below)
1586 { 1566 {
1587 /* show invisible */ 1567 /* show invisible */
1588 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) && 1568 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&
1589 /* Might there be other objects that we can make visible? */ 1569 /* Might there be other objects that we can make visible? */
1590 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) || 1570 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER)
1591 (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) || 1571 || (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ))
1592 tmp->type == CF_HANDLE || 1572 || tmp->type == CF_HANDLE
1593 tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE || 1573 || tmp->type == TRAPDOOR
1574 || tmp->type == EXIT
1575 || tmp->type == HOLE
1576 || tmp->type == BUTTON
1594 tmp->type == BUTTON || tmp->type == TELEPORTER || 1577 || tmp->type == TELEPORTER
1578 || tmp->type == GATE
1595 tmp->type == GATE || tmp->type == LOCKED_DOOR || 1579 || tmp->type == LOCKED_DOOR
1596 tmp->type == WEAPON || tmp->type == ALTAR || tmp->type == SIGN || 1580 || tmp->type == WEAPON
1581 || tmp->type == ALTAR
1582 || tmp->type == SIGN
1597 tmp->type == TRIGGER_PEDESTAL || tmp->type == SPECIAL_KEY || 1583 || tmp->type == TRIGGER_PEDESTAL
1598 tmp->type == TREASURE || tmp->type == BOOK || tmp->type == HOLY_ALTAR))) 1584 || tmp->type == SPECIAL_KEY
1585 || tmp->type == TREASURE
1586 || tmp->type == BOOK
1587 || tmp->type == HOLY_ALTAR
1588 || tmp->type == CONTAINER)))
1599 { 1589 {
1600 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4) 1590 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1601 { 1591 {
1602 tmp->invisible = 0; 1592 tmp->invisible = 0;
1603 done_one = 1; 1593 done_one = 1;
1604 } 1594 }
1605 } 1595 }
1606 1596
1607 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1597 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1608 floor = 1; 1598 floor = 1;
1609 1599
1610 /* All detections below this point don't descend beneath the floor, 1600 /* All detections below this point don't descend beneath the floor,
1611 * so just continue on. We could be clever and look at the type of 1601 * so just continue on. We could be clever and look at the type of
1612 * detection to completely break out if we don't care about objects beneath 1602 * detection to completely break out if we don't care about objects beneath
1613 * the floor, but once we get to the floor, not likely a very big issue anyways. 1603 * the floor, but once we get to the floor, not likely a very big issue anyways.
1614 */ 1604 */
1615 if (floor) 1605 if (floor)
1616 continue; 1606 continue;
1617 1607
1618 /* I had thought about making detect magic and detect curse 1608 /* I had thought about making detect magic and detect curse
1619 * show the flash the magic item like it does for detect monster. 1609 * show the flash the magic item like it does for detect monster.
1620 * however, if the object is within sight, this would then make it 1610 * however, if the object is within sight, this would then make it
1621 * difficult to see what object is magical/cursed, so the 1611 * difficult to see what object is magical/cursed, so the
1622 * effect wouldn't be as apparant. 1612 * effect wouldn't be as apparent.
1623 */ 1613 */
1624 1614
1625 /* detect magic */ 1615 /* detect magic */
1626 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && 1616 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&
1627 !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp)) 1617 !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))
1628 { 1618 {
1629 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL); 1619 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1630 /* make runes more visibile */ 1620 /* make runes more visibile */
1631 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC) 1621 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1632 tmp->stats.Cha /= 4; 1622 tmp->stats.Cha /= 4;
1623
1633 done_one = 1; 1624 done_one = 1;
1634 } 1625 }
1626
1635 /* detect monster */ 1627 /* detect monster */
1636 if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER)) 1628 if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))
1637 { 1629 {
1638 done_one = 2; 1630 done_one = 2;
1631
1639 if (!detect) 1632 if (!detect)
1640 detect = tmp; 1633 detect = tmp;
1641 } 1634 }
1635
1642 /* Basically, if race is set in the spell, then the creatures race must 1636 /* Basically, if race is set in the spell, then the creatures race must
1643 * match that. if the spell race is set to GOD, then the gods opposing 1637 * match that. if the spell race is set to GOD, then the gods opposing
1644 * race must match. 1638 * race must match.
1645 */ 1639 */
1646 if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race && 1640 if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&
1647 ((!strcmp (spell->race, "GOD") && god && god->slaying && strstr (god->slaying, tmp->race)) || 1641 ((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||
1648 (strstr (spell->race, tmp->race)))) 1642 spell->race.contains (tmp->race)))
1649 { 1643 {
1650 done_one = 2; 1644 done_one = 2;
1645
1651 if (!detect) 1646 if (!detect)
1652 detect = tmp; 1647 detect = tmp;
1653 } 1648 }
1649
1654 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && 1650 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1655 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))) 1651 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1656 { 1652 {
1657 SET_FLAG (tmp, FLAG_KNOWN_CURSED); 1653 SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1658 done_one = 1; 1654 done_one = 1;
1659 } 1655 }
1660 } /* for stack of objects on this space */ 1656 } /* for stack of objects on this space */
1661 1657
1662 /* Code here puts an effect of the spell on the space, so you can see 1658 /* Code here puts an effect of the spell on the space, so you can see
1663 * where the magic is. 1659 * where the magic is.
1664 */ 1660 */
1665 if (done_one) 1661 if (done_one)
1666 { 1662 {
1667 object *detect_ob = arch_to_object (spell->other_arch); 1663 object *detect_ob = arch_to_object (spell->other_arch);
1668 1664
1669 /* if this is set, we want to copy the face */ 1665 /* if this is set, we want to copy the face */
1670 if (done_one == 2 && detect) 1666 if (done_one == 2 && detect)
1671 { 1667 {
1672 detect_ob->face = detect->face; 1668 detect_ob->face = detect->face;
1673 detect_ob->animation_id = detect->animation_id; 1669 detect_ob->animation_id = detect->animation_id;
1674 detect_ob->anim_speed = detect->anim_speed; 1670 detect_ob->anim_speed = detect->anim_speed;
1675 detect_ob->last_anim = 0; 1671 detect_ob->last_anim = 0;
1676 /* by default, the detect_ob is already animated */ 1672 /* by default, the detect_ob is already animated */
1677 if (!QUERY_FLAG (detect, FLAG_ANIMATE)) 1673 if (!QUERY_FLAG (detect, FLAG_ANIMATE))
1678 CLEAR_FLAG (detect_ob, FLAG_ANIMATE); 1674 CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
1679 } 1675 }
1680 1676
1681 m->insert (detect_ob, nx, ny, op); 1677 m->insert (detect_ob, nx, ny, op);
1682 } 1678 }
1683 } /* for processing the surrounding spaces */ 1679 } /* for processing the surrounding spaces */
1684 1680
1685 1681
1686 /* Now process objects in the players inventory if detect curse or magic */ 1682 /* Now process objects in the players inventory if detect curse or magic */
1687 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL)) 1683 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))
1688 { 1684 {
1689 done_one = 0; 1685 done_one = 0;
1686
1690 for (tmp = op->inv; tmp; tmp = tmp->below) 1687 for (tmp = op->inv; tmp; tmp = tmp->below)
1691 { 1688 {
1692 if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED)) 1689 if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1693 { 1690 {
1694 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL)) 1691 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))
1695 { 1692 {
1696 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL); 1693 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1697 if (op->type == PLAYER) 1694
1695 if (object *pl = tmp->visible_to ())
1698 esrv_send_item (op, tmp); 1696 esrv_update_item (UPD_FLAGS, pl, tmp);
1699 } 1697 }
1698
1700 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && 1699 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1701 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))) 1700 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1702 { 1701 {
1703 SET_FLAG (tmp, FLAG_KNOWN_CURSED); 1702 SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1704 if (op->type == PLAYER) 1703
1704 if (object *pl = tmp->visible_to ())
1705 esrv_send_item (op, tmp); 1705 esrv_update_item (UPD_FLAGS, pl, tmp);
1706 } 1706 }
1707 } /* if item is not identified */ 1707 } /* if item is not identified */
1708 } /* for the players inventory */ 1708 } /* for the players inventory */
1709 } /* if detect magic/curse and object is a player */ 1709 } /* if detect magic/curse and object is a player */
1710
1710 return 1; 1711 return 1;
1711} 1712}
1712 1713
1713 1714
1714/** 1715/**
… …
1727 1728
1728 new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you."); 1729 new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");
1729 1730
1730 if (victim->stats.sp >= victim->stats.maxsp * 2) 1731 if (victim->stats.sp >= victim->stats.maxsp * 2)
1731 { 1732 {
1732 object *tmp;
1733
1734 new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!"); 1733 new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");
1735
1736 /* Explodes a fireball centered at player */
1737 tmp = get_archetype (EXPLODING_FIREBALL);
1738 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
1739 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
1740
1741 tmp->insert_at (victim);
1742 victim->stats.sp = 2 * victim->stats.maxsp; 1734 victim->stats.sp = 2 * victim->stats.maxsp;
1735 create_exploding_ball_at (victim, caster_level);
1743 } 1736 }
1744 else if (victim->stats.sp >= victim->stats.maxsp * 1.88) 1737 else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
1745 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode."); 1738 new_draw_info (NDI_UNIQUE | NDI_ORANGE, 0, victim, "You feel like your head is going to explode.");
1746 else if (victim->stats.sp >= victim->stats.maxsp * 1.66) 1739 else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
1747 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!"); 1740 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
1748 else if (victim->stats.sp >= victim->stats.maxsp * 1.5) 1741 else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
1749 { 1742 {
1750 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world."); 1743 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
… …
1796 } 1789 }
1797 /* give sp */ 1790 /* give sp */
1798 if (spell->stats.dam > 0) 1791 if (spell->stats.dam > 0)
1799 { 1792 {
1800 plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell); 1793 plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);
1801 charge_mana_effect (plyr, caster_level (caster, spell)); 1794 charge_mana_effect (plyr, casting_level (caster, spell));
1802 return 1; 1795 return 1;
1803 } 1796 }
1804 /* suck sp away. Can't suck sp from yourself */ 1797 /* suck sp away. Can't suck sp from yourself */
1805 else if (op != plyr) 1798 else if (op != plyr)
1806 { 1799 {
… …
1818 /* Player doesn't get full credit */ 1811 /* Player doesn't get full credit */
1819 sucked = (sucked * rate) / 100; 1812 sucked = (sucked * rate) / 100;
1820 op->stats.sp += sucked; 1813 op->stats.sp += sucked;
1821 if (sucked > 0) 1814 if (sucked > 0)
1822 { 1815 {
1823 charge_mana_effect (op, caster_level (caster, spell)); 1816 charge_mana_effect (op, casting_level (caster, spell));
1824 } 1817 }
1825 } 1818 }
1826 return 1; 1819 return 1;
1827 } 1820 }
1828 return 0; 1821 return 0;
… …
1904 break; 1897 break;
1905 } 1898 }
1906 } 1899 }
1907} 1900}
1908 1901
1909
1910
1911/* cast_consecrate() - a spell to make an altar your god's */ 1902/* cast_consecrate() - a spell to make an altar your god's */
1912int 1903int
1913cast_consecrate (object *op, object *caster, object *spell) 1904cast_consecrate (object *op, object *caster, object *spell)
1914{ 1905{
1915 char buf[MAX_BUF]; 1906 char buf[MAX_BUF];
… …
1927 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1918 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1928 break; 1919 break;
1929 if (tmp->type == HOLY_ALTAR) 1920 if (tmp->type == HOLY_ALTAR)
1930 { 1921 {
1931 1922
1932 if (tmp->level > caster_level (caster, spell)) 1923 if (tmp->level > casting_level (caster, spell))
1933 { 1924 {
1934 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name); 1925 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);
1935 return 0; 1926 return 0;
1936 } 1927 }
1937 else 1928 else
1938 { 1929 {
1939 /* If we got here, we are consecrating an altar */ 1930 /* If we got here, we are consecrating an altar */
1940 sprintf (buf, "Altar of %s", &god->name); 1931 sprintf (buf, "Altar of %s", &god->name);
1941 tmp->name = buf; 1932 tmp->name = buf;
1942 tmp->level = caster_level (caster, spell); 1933 tmp->level = casting_level (caster, spell);
1943 tmp->other_arch = god->arch; 1934 tmp->other_arch = god->arch;
1935
1944 if (op->type == PLAYER) 1936 if (op->type == PLAYER)
1945 esrv_update_item (UPD_NAME, op, tmp); 1937 esrv_update_item (UPD_NAME, op, tmp);
1938
1946 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name); 1939 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
1947 return 1; 1940 return 1;
1948 } 1941 }
1949 } 1942 }
1950 } 1943 }
… …
1988 return 0; 1981 return 0;
1989 } 1982 }
1990 1983
1991 /* if no direction specified, pick one */ 1984 /* if no direction specified, pick one */
1992 if (!dir) 1985 if (!dir)
1993 dir = find_free_spot (NULL, op->map, op->x, op->y, 1, 9); 1986 dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);
1994 1987
1995 m = op->map; 1988 m = op->map;
1996 x = op->x + freearr_x[dir]; 1989 x = op->x + freearr_x[dir];
1997 y = op->y + freearr_y[dir]; 1990 y = op->y + freearr_y[dir];
1998 1991
1999 /* if there's no place to put the golem, abort */ 1992 /* if there's no place to put the golem, abort */
2000 if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) || 1993 if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
2001 ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type)) 1994 || ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2002 { 1995 {
2003 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 1996 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
2004 return 0; 1997 return 0;
2005 } 1998 }
2006 1999
… …
2010 if (!weapon) 2003 if (!weapon)
2011 { 2004 {
2012 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!"); 2005 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
2013 return 0; 2006 return 0;
2014 } 2007 }
2008
2015 if (spell->race && strcmp (weapon->arch->archname, spell->race)) 2009 if (spell->race && weapon->arch->archname != spell->race)
2016 { 2010 {
2017 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon."); 2011 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
2018 return 0; 2012 return 0;
2019 } 2013 }
2014
2020 if (weapon->type != WEAPON) 2015 if (weapon->type != WEAPON)
2021 { 2016 {
2022 new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it."); 2017 new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");
2023 return 0; 2018 return 0;
2024 } 2019 }
2020
2025 if (QUERY_FLAG (weapon, FLAG_APPLIED)) 2021 if (QUERY_FLAG (weapon, FLAG_APPLIED))
2026 { 2022 {
2027 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon)); 2023 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));
2028 return 0; 2024 return 0;
2029 } 2025 }
2030 2026
2031 if (weapon->nrof > 1) 2027 weapon = weapon->split ();
2032 {
2033 tmp = get_split_ob (weapon, 1);
2034 esrv_send_item (op, weapon);
2035 weapon = tmp;
2036 }
2037 2028
2038 /* create the golem object */ 2029 /* create the golem object */
2039 tmp = arch_to_object (spell->other_arch); 2030 tmp = arch_to_object (spell->other_arch);
2040 2031
2041 /* if animated by a player, give the player control of the golem */ 2032 /* if animated by a player, give the player control of the golem */
… …
2046 tmp->set_owner (op); 2037 tmp->set_owner (op);
2047 op->contr->golem = tmp; 2038 op->contr->golem = tmp;
2048 set_spell_skill (op, caster, spell, tmp); 2039 set_spell_skill (op, caster, spell, tmp);
2049 2040
2050 /* Give the weapon to the golem now. A bit of a hack to check the 2041 /* Give the weapon to the golem now. A bit of a hack to check the
2051 * removed flag - it should only be set if get_split_object was 2042 * removed flag - it should only be set if weapon->split was
2052 * used above. 2043 * used above.
2053 */ 2044 */
2054 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2045 if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2055 weapon->remove (); 2046 weapon->remove ();
2056 2047
2057 insert_ob_in_ob (weapon, tmp); 2048 tmp->insert (weapon);
2058 esrv_send_item (op, weapon); 2049
2059 /* To do everything necessary to let a golem use the weapon is a pain, 2050 /* To do everything necessary to let a golem use the weapon is a pain,
2060 * so instead, just set it as equipped (otherwise, we need to update 2051 * so instead, just set it as equipped (otherwise, we need to update
2061 * body_info, skills, etc) 2052 * body_info, skills, etc)
2062 */ 2053 */
2063 SET_FLAG (tmp, FLAG_USE_WEAPON); 2054 SET_FLAG (tmp, FLAG_USE_WEAPON);
… …
2137 tmp->state = weapon->state; 2128 tmp->state = weapon->state;
2138 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE]; 2129 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2139 } 2130 }
2140 2131
2141 /* make experience increase in proportion to the strength of the summoned creature. */ 2132 /* make experience increase in proportion to the strength of the summoned creature. */
2142 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell)); 2133 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));
2143 2134
2144 tmp->speed_left = -1; 2135 tmp->speed_left = -1;
2145 tmp->direction = dir; 2136 tmp->direction = dir;
2146 2137
2147 m->insert (tmp, x, y, op); 2138 m->insert (tmp, x, y, op);
… …
2151/* cast_daylight() - changes the map darkness level *lower* */ 2142/* cast_daylight() - changes the map darkness level *lower* */
2152 2143
2153/* cast_change_map_lightlevel: Was cast_daylight/nightfall. 2144/* cast_change_map_lightlevel: Was cast_daylight/nightfall.
2154 * This changes the light level for the entire map. 2145 * This changes the light level for the entire map.
2155 */ 2146 */
2156
2157int 2147int
2158cast_change_map_lightlevel (object *op, object *caster, object *spell) 2148cast_change_map_lightlevel (object *op, object *caster, object *spell)
2159{ 2149{
2160 int success; 2150 int success;
2161 2151
… …
2169 if (spell->stats.dam < 0) 2159 if (spell->stats.dam < 0)
2170 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here."); 2160 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2171 else 2161 else
2172 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here."); 2162 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2173 } 2163 }
2164
2174 return success; 2165 return success;
2175} 2166}
2176
2177
2178
2179
2180 2167
2181/* create an aura spell object and put it in the player's inventory. 2168/* create an aura spell object and put it in the player's inventory.
2182 * as usual, op is player, caster is the object casting the spell, 2169 * as usual, op is player, caster is the object casting the spell,
2183 * spell is the spell object itself. 2170 * spell is the spell object itself.
2184 */ 2171 */
… …
2196 2183
2197 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2184 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2198 2185
2199 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2186 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2200 2187
2201 new_aura->set_owner (op);
2202 set_spell_skill (op, caster, spell, new_aura); 2188 set_spell_skill (op, caster, spell, new_aura);
2203 new_aura->attacktype = spell->attacktype; 2189 new_aura->attacktype = spell->attacktype;
2204 2190
2205 new_aura->level = caster_level (caster, spell); 2191 new_aura->level = casting_level (caster, spell);
2192
2206 if (refresh) 2193 if (refresh)
2207 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 2194 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2208 else 2195 else
2209 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force."); 2196 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
2197
2210 insert_ob_in_ob (new_aura, op); 2198 insert_ob_in_ob (new_aura, op);
2199 new_aura->set_owner (op);
2200
2211 return 1; 2201 return 1;
2212} 2202}
2213
2214 2203
2215/* move aura function. An aura is a part of someone's inventory, 2204/* move aura function. An aura is a part of someone's inventory,
2216 * which he carries with him, but which acts on the map immediately 2205 * which he carries with him, but which acts on the map immediately
2217 * around him. 2206 * around him.
2218 * Aura parameters: 2207 * Aura parameters:
2219 * duration: duration counter. 2208 * duration: duration counter.
2220 * attacktype: aura's attacktype 2209 * attacktype: aura's attacktype
2221 * other_arch: archetype to drop where we attack 2210 * other_arch: archetype to drop where we attack
2222 */ 2211 */
2223
2224void 2212void
2225move_aura (object *aura) 2213move_aura (object *aura)
2226{ 2214{
2227 int i, mflags;
2228 object *env;
2229 maptile *m;
2230
2231 /* auras belong in inventories */ 2215 /* auras belong in inventories */
2232 env = aura->env; 2216 object *env = aura->env;
2217 object *owner = aura->owner;
2233 2218
2234 /* no matter what we've gotta remove the aura... 2219 /* no matter what we've gotta remove the aura...
2235 * we'll put it back if its time isn't up. 2220 * we'll put it back if its time isn't up.
2236 */ 2221 */
2237 aura->remove (); 2222 aura->remove ();
… …
2242 aura->destroy (); 2227 aura->destroy ();
2243 return; 2228 return;
2244 } 2229 }
2245 2230
2246 /* auras only exist in inventories */ 2231 /* auras only exist in inventories */
2247 if (env == NULL || env->map == NULL) 2232 if (!env || !env->map)
2248 { 2233 {
2249 aura->destroy (); 2234 aura->destroy ();
2250 return; 2235 return;
2251 } 2236 }
2252 2237
2253 /* we need to jump out of the inventory for a bit 2238 /* we need to jump out of the inventory for a bit
2254 * in order to hit the map conveniently. 2239 * in order to hit the map conveniently.
2255 */ 2240 */
2256 aura->insert_at (env, aura); 2241 aura->insert_at (env, aura);
2257 2242
2258 for (i = 1; i < 9; i++) 2243 for (int i = 1; i < 9; i++)
2259 { 2244 {
2260 sint16 nx, ny; 2245 mapxy pos (env);
2246 pos.move (i);
2261 2247
2262 nx = aura->x + freearr_x[i];
2263 ny = aura->y + freearr_y[i];
2264 mflags = get_map_flags (env->map, &m, nx, ny, &nx, &ny);
2265
2266 /* Consider the movement tyep of the person with the aura as 2248 /* Consider the movement type of the person with the aura as
2267 * movement type of the aura. Eg, if the player is flying, the aura 2249 * movement type of the aura. Eg, if the player is flying, the aura
2268 * is flying also, if player is walking, it is on the ground, etc. 2250 * is flying also, if player is walking, it is on the ground, etc.
2269 */ 2251 */
2270 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny)))) 2252 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2271 { 2253 {
2272 hit_map (aura, i, aura->attacktype, 0); 2254 hit_map (aura, i, aura->attacktype, 0);
2273 2255
2274 if (aura->other_arch) 2256 if (aura->other_arch)
2275 m->insert (arch_to_object (aura->other_arch), nx, ny, aura); 2257 pos.insert (arch_to_object (aura->other_arch), aura);
2276 } 2258 }
2277 } 2259 }
2278 2260
2279 /* put the aura back in the player's inventory */ 2261 /* put the aura back in the player's inventory */
2280 aura->remove (); 2262 env->insert (aura);
2281 insert_ob_in_ob (aura, env); 2263 aura->set_owner (owner);
2282} 2264}
2283 2265
2284/* moves the peacemaker spell. 2266/* moves the peacemaker spell.
2285 * op is the piece object. 2267 * op is the piece object.
2286 */ 2268 */
2287
2288void 2269void
2289move_peacemaker (object *op) 2270move_peacemaker (object *op)
2290{ 2271{
2291 object *tmp; 2272 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
2292
2293 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2294 { 2273 {
2295 int atk_lev, def_lev; 2274 int atk_lev, def_lev;
2296 object *victim = tmp; 2275 object *victim = tmp->head_ ();
2297 2276
2298 if (tmp->head)
2299 victim = tmp->head;
2300 if (!QUERY_FLAG (victim, FLAG_MONSTER)) 2277 if (!QUERY_FLAG (victim, FLAG_MONSTER))
2301 continue; 2278 continue;
2279
2302 if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE)) 2280 if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))
2303 continue; 2281 continue;
2282
2304 if (victim->stats.exp == 0) 2283 if (victim->stats.exp == 0)
2305 continue; 2284 continue;
2306 2285
2307 def_lev = MAX (1, victim->level); 2286 def_lev = MAX (1, victim->level);
2308 atk_lev = MAX (1, op->level); 2287 atk_lev = MAX (1, op->level);
2309 2288
2310 if (rndm (0, atk_lev - 1) > def_lev) 2289 if (rndm (0, atk_lev - 1) > def_lev)
2311 { 2290 {
2312 /* make this sucker peaceful. */ 2291 /* make this sucker peaceful. */
2313 2292
2293 INVOKE_OBJECT (KILL, victim, ARG_OBJECT (op));
2314 change_exp (op->owner, victim->stats.exp, op->skill, 0); 2294 change_exp (op->owner, victim->stats.exp, op->skill, 0);
2315 victim->stats.exp = 0; 2295 victim->stats.exp = 0;
2316#if 0 2296#if 0
2317 /* No idea why these were all set to zero - if something 2297 /* No idea why these were all set to zero - if something
2318 * makes this creature agressive, he should still do damage. 2298 * makes this creature agressive, he should still do damage.
… …
2325 victim->attack_movement = RANDO2; 2305 victim->attack_movement = RANDO2;
2326 SET_FLAG (victim, FLAG_UNAGGRESSIVE); 2306 SET_FLAG (victim, FLAG_UNAGGRESSIVE);
2327 SET_FLAG (victim, FLAG_RUN_AWAY); 2307 SET_FLAG (victim, FLAG_RUN_AWAY);
2328 SET_FLAG (victim, FLAG_RANDOM_MOVE); 2308 SET_FLAG (victim, FLAG_RANDOM_MOVE);
2329 CLEAR_FLAG (victim, FLAG_MONSTER); 2309 CLEAR_FLAG (victim, FLAG_MONSTER);
2310
2330 if (victim->name) 2311 if (victim->name)
2331 {
2332 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name); 2312 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2333 } 2313 }
2334 }
2335 } 2314 }
2336} 2315}
2337
2338 2316
2339/* This writes a rune that contains the appropriate message. 2317/* This writes a rune that contains the appropriate message.
2340 * There really isn't any adjustments we make. 2318 * There really isn't any adjustments we make.
2341 */ 2319 */
2342
2343int 2320int
2344write_mark (object *op, object *spell, const char *msg) 2321write_mark (object *op, object *spell, const char *msg)
2345{ 2322{
2346 char rune[HUGE_BUF];
2347 object *tmp;
2348
2349 if (!msg || msg[0] == 0) 2323 if (!msg || msg[0] == 0)
2350 { 2324 {
2351 new_draw_info (NDI_UNIQUE, 0, op, "Write what?"); 2325 new_draw_info (NDI_UNIQUE, 0, op, "Write what?");
2352 return 0; 2326 return 0;
2353 } 2327 }
… …
2356 { 2330 {
2357 new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?"); 2331 new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");
2358 LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg); 2332 LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg);
2359 return 0; 2333 return 0;
2360 } 2334 }
2335
2361 if (!spell->other_arch) 2336 if (!spell->other_arch)
2362 return 0; 2337 return 0;
2338
2363 tmp = arch_to_object (spell->other_arch); 2339 object *tmp = arch_to_object (spell->other_arch);
2364
2365 snprintf (rune, sizeof (rune), "%s\n", msg);
2366 2340
2367 tmp->race = op->name; /*Save the owner of the rune */ 2341 tmp->race = op->name; /*Save the owner of the rune */
2368 tmp->msg = rune; 2342 tmp->msg = msg;
2369 2343
2370 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR); 2344 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2345
2371 return 1; 2346 return 1;
2372} 2347}
2348

Diff Legend

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