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.60 by root, Sun Jun 24 01:09:28 2007 UTC vs.
Revision 1.101 by root, Mon Apr 27 01:44:49 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 it 8 * Deliantra is free software: you can redistribute it and/or modify
9 * under the terms of the GNU General Public License as published by the Free 9 * it under the terms of the GNU General Public License as published by
10 * Software Foundation; either version 2 of the License, or (at your option) 10 * the Free Software Foundation, either version 3 of the License, or
11 * 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, but 13 * This program is distributed in the hope that it will be useful,
14 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * 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 along 18 * You should have received a copy of the GNU General Public License
19 * with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 * 20 *
22 * 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>
23 */ 22 */
24 23
25#include <global.h> 24#include <global.h>
26#include <object.h> 25#include <object.h>
27#include <living.h> 26#include <living.h>
62{ 61{
63 object *wand, *tmp; 62 object *wand, *tmp;
64 int ncharges; 63 int ncharges;
65 64
66 wand = find_marked_object (op); 65 wand = find_marked_object (op);
67 if (wand == NULL || wand->type != WAND) 66 if (!wand || wand->type != WAND)
68 { 67 {
69 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.");
70 return 0; 69 return 0;
71 } 70 }
72 if (!(random_roll (0, 3, op, PREFER_HIGH))) 71 if (!(random_roll (0, 3, op, PREFER_HIGH)))
73 { 72 {
74 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));
75 play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE); 74 op->play_sound (sound_find ("ob_explode"));
76 esrv_del_item (op->contr, wand->count);
77 wand->destroy (); 75 wand->destroy ();
78 tmp = get_archetype ("fireball"); 76 tmp = get_archetype ("fireball");
79 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;
80 78
81 if (!tmp->stats.dam) 79 if (!tmp->stats.dam)
123 * great a plus, the default is used. 121 * great a plus, the default is used.
124 * 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
125 * 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
126 * create nonnmagic arrows, or even -1, etc... 124 * create nonnmagic arrows, or even -1, etc...
127 */ 125 */
128
129int 126int
130cast_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 *stringarg)
131{ 128{
132 int missile_plus = 0, bonus_plus = 0; 129 int bonus_plus = 0;
133 const char *missile_name; 130 const char *missile_name = "arrow";
134 object *tmp, *missile;
135 131
136 missile_name = "arrow";
137
138 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 132 for (object *tmp = op->inv; tmp; tmp = tmp->below)
139 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED)) 133 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
140 missile_name = tmp->race; 134 missile_name = tmp->race;
141 135
142 missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell); 136 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
143 137
144 if (archetype::find (missile_name) == NULL) 138 archetype *missile_arch = archetype::find (missile_name);
139
140 if (!missile_arch)
145 { 141 {
146 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);
147 return 0; 143 return 0;
148 } 144 }
149 145
150 missile = get_archetype (missile_name); 146 object *missile = missile_arch->instance ();
151 147
152 if (stringarg) 148 if (stringarg)
153 { 149 {
154 /* If it starts with a letter, presume it is a description */ 150 /* If it starts with a letter, presume it is a description */
155 if (isalpha (*stringarg)) 151 if (isalpha (*stringarg))
173 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, stringarg);
174 return 0; 170 return 0;
175 } 171 }
176 172
177 give_artifact_abilities (missile, al->item); 173 give_artifact_abilities (missile, al->item);
178 /* 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 -
179 * 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
180 * the parsing of having to do both plus and type. 176 * the parsing of having to do both plus and type.
181 */ 177 */
182 bonus_plus = 1 + (al->item->value / 5); 178 bonus_plus = 1 + (al->item->value / 5);
183 missile_plus = 0; 179 missile_plus = 0;
184 } 180 }
185 else if (atoi (stringarg) < missile_plus) 181 else if (atoi (stringarg) < missile_plus)
186 missile_plus = atoi (stringarg); 182 missile_plus = atoi (stringarg);
187 } 183 }
188 184
189 if (missile_plus > 4) 185 missile_plus = clamp (missile_plus, -4, 4);
190 missile_plus = 4;
191 else if (missile_plus < -4)
192 missile_plus = -4;
193 186
194 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell); 187 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
195 missile->nrof -= 3 * (missile_plus + bonus_plus); 188 missile->nrof -= 3 * (missile_plus + bonus_plus);
196 189
197 if (missile->nrof < 1) 190 if (missile->nrof < 1)
217{ 210{
218 int food_value; 211 int food_value;
219 archetype *at = NULL; 212 archetype *at = NULL;
220 object *new_op; 213 object *new_op;
221 214
222 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);
223 216
224 if (stringarg) 217 if (stringarg)
225 { 218 {
226 at = find_archetype_by_object_type_name (FOOD, stringarg); 219 at = find_archetype_by_object_type_name (FOOD, stringarg);
227 if (at == NULL) 220 if (at == NULL)
257 && at_tmp->weight < at->weight))) 250 && at_tmp->weight < at->weight)))
258 at = at_tmp; 251 at = at_tmp;
259 } 252 }
260 } 253 }
261 } 254 }
255
262 /* Pretty unlikely (there are some very low food items), but you never 256 /* Pretty unlikely (there are some very low food items), but you never
263 * know 257 * know
264 */ 258 */
265 if (!at) 259 if (!at)
266 { 260 {
285{ 279{
286 int r, mflags, maxrange; 280 int r, mflags, maxrange;
287 object *tmp; 281 object *tmp;
288 maptile *m; 282 maptile *m;
289 283
290
291 if (!dir) 284 if (!dir)
292 { 285 {
293 examine_monster (op, op); 286 examine_monster (op, op);
294 return 1; 287 return 1;
295 } 288 }
289
296 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 290 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
297 for (r = 1; r < maxrange; r++) 291 for (r = 1; r < maxrange; r++)
298 { 292 {
299 sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir]; 293 sint16 x = op->x + r * freearr_x[dir], y = op->y + r * freearr_y[dir];
300 294
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;
320 examine_monster (op, tmp); 315 examine_monster (op, tmp);
321 return 1; 316 return 1;
322 } 317 }
323 } 318 }
324 } 319 }
320
325 new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing."); 321 new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");
326 return 1; 322 return 1;
327} 323}
328
329 324
330/* This checks to see if 'pl' is invisible to 'mon'. 325/* This checks to see if 'pl' is invisible to 'mon'.
331 * does race check, undead check, etc 326 * does race check, undead check, etc
332 * Returns TRUE if mon can't see pl, false 327 * Returns TRUE if mon can't see pl, false
333 * otherwise. This doesn't check range, walls, etc. It 328 * otherwise. This doesn't check range, walls, etc. It
335 * pl is invisible. 330 * pl is invisible.
336 */ 331 */
337int 332int
338makes_invisible_to (object *pl, object *mon) 333makes_invisible_to (object *pl, object *mon)
339{ 334{
340
341 if (!pl->invisible) 335 if (!pl->invisible)
342 return 0; 336 return 0;
337
343 if (pl->type == PLAYER) 338 if (pl->type == PLAYER)
344 { 339 {
345 /* If race isn't set, then invisible unless it is undead */ 340 /* If race isn't set, then invisible unless it is undead */
346 if (!pl->contr->invis_race) 341 if (!pl->contr->invis_race)
347 { 342 {
348 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 343 if (QUERY_FLAG (mon, FLAG_UNDEAD))
349 return 0; 344 return 0;
345
350 return 1; 346 return 1;
351 } 347 }
348
352 /* invis_race is set if we get here */ 349 /* invis_race is set if we get here */
353 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon)) 350 if (pl->contr->invis_race == shstr_undead && is_true_undead (mon))
354 return 1; 351 return 1;
352
355 /* No race, can't be invisible to it */ 353 /* No race, can't be invisible to it */
356 if (!mon->race) 354 if (!mon->race)
357 return 0; 355 return 0;
356
358 if (strstr (mon->race, pl->contr->invis_race)) 357 if (mon->race.contains (pl->contr->invis_race))
359 return 1; 358 return 1;
359
360 /* Nothing matched above, return 0 */ 360 /* Nothing matched above, return 0 */
361 return 0; 361 return 0;
362 } 362 }
363 else 363 else
364 { 364 {
466 if (object *pl = op->in_player ()) 466 if (object *pl = op->in_player ())
467 { 467 {
468 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST)) 468 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
469 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you."); 469 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
470 else 470 else
471 { 471 pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);
472 // remove first so we do not call update_stats
473 op->remove ();
474 pl->enter_exit (op);
475 }
476 } 472 }
477 473
478 op->destroy (); 474 op->destroy ();
479} 475}
480 476
496 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 492 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
497 return 1; 493 return 1;
498 } 494 }
499 495
500 dummy = get_archetype (FORCE_NAME); 496 dummy = get_archetype (FORCE_NAME);
501 if (dummy == NULL) 497
498 if (!dummy)
502 { 499 {
503 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 500 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
504 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n"); 501 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
505 return 0; 502 return 0;
506 } 503 }
572perceive_self (object *op) 569perceive_self (object *op)
573{ 570{
574 const char *cp = describe_item (op, op); 571 const char *cp = describe_item (op, op);
575 archetype *at = archetype::find (ARCH_DEPLETION); 572 archetype *at = archetype::find (ARCH_DEPLETION);
576 573
577 dynbuf_text buf; 574 dynbuf_text &buf = msg_dynbuf; buf.clear ();
578 575
579 if (player *pl = op->contr) 576 if (!op->is_player ())
577 return 0;
578
580 if (object *race = archetype::find (op->race)) 579 if (object *race = archetype::find (op->race))
581 buf << "You are a " << (pl->gender ? "female" : "male") << " " << &race->name << ".\n"; 580 buf << " - You are a G<male|female> " << &race->name << ".\n";
582 581
583 if (object *god = find_god (determine_god (op))) 582 if (object *god = find_god (determine_god (op)))
584 buf << "You worship " << &god->name << ".\n"; 583 buf << " - You worship " << &god->name << ".\n";
585 else 584 else
586 buf << "You worship no god.\n"; 585 buf << " - You worship no god.\n";
587 586
588 object *tmp = present_arch_in_ob (at, op); 587 object *tmp = present_arch_in_ob (at, op);
589 588
590 if (*cp == '\0' && tmp == NULL) 589 if (*cp == '\0' && !tmp)
591 buf << "You feel very mundane. "; 590 buf << " - You feel very mundane. ";
592 else 591 else
593 { 592 {
594 buf << "You have: " << cp << ".\n"; 593 buf << " - You have: " << cp << ".\n";
595 594
596 if (tmp) 595 if (tmp)
597 for (int i = 0; i < NUM_STATS; i++) 596 for (int i = 0; i < NUM_STATS; i++)
598 if (tmp->stats.stat (i) < 0) 597 if (tmp->stats.stat (i) < 0)
599 buf.printf ("Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i)); 598 buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
600 } 599 }
601 600
602 if (is_dragon_pl (op)) 601 if (is_dragon_pl (op))
603 /* now grab the 'dragon_ability'-force from the player's inventory */ 602 /* now grab the 'dragon_ability'-force from the player's inventory */
604 for (tmp = op->inv; tmp; tmp = tmp->below) 603 for (tmp = op->inv; tmp; tmp = tmp->below)
605 { 604 {
606 if (tmp->type == FORCE && !strcmp (tmp->arch->archname, "dragon_ability_force")) 605 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
607 { 606 {
608 if (tmp->stats.exp == 0) 607 if (tmp->stats.exp == 0)
609 buf << "Your metabolism isn't focused on anything.\n"; 608 buf << " - Your metabolism isn't focused on anything.\n";
610 else 609 else
611 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n"; 610 buf << " - Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
612 611
613 break; 612 break;
614 } 613 }
615 } 614 }
616 615
617 new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ()); 616 op->contr->infobox (MSG_CHANNEL ("perceiveself"), buf);
618 617
619 return 1; 618 return 1;
620} 619}
621 620
622/* This creates magic walls. Really, it can create most any object, 621/* This creates magic walls. Really, it can create most any object,
710 */ 709 */
711 if (tmp->type != EARTHWALL) //TODO 710 if (tmp->type != EARTHWALL) //TODO
712 tmp->set_owner (op); 711 tmp->set_owner (op);
713 712
714 set_spell_skill (op, caster, spell_ob, tmp); 713 set_spell_skill (op, caster, spell_ob, tmp);
715 tmp->level = caster_level (caster, spell_ob) / 2; 714 tmp->level = casting_level (caster, spell_ob) / 2;
716 715
717 name = tmp->name; 716 name = tmp->name;
718 if (!(tmp = m->insert (tmp, x, y, op))) 717 if (!(tmp = m->insert (tmp, x, y, op)))
719 { 718 {
720 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name); 719 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
893 892
894 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 893 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
895 return 1; 894 return 1;
896} 895}
897 896
898
899/* cast_heal: Heals something. 897/* cast_heal: Heals something.
900 * op is the caster. 898 * op is the caster.
901 * dir is the direction he is casting it in. 899 * dir is the direction he is casting it in.
902 * spell is the spell object. 900 * spell is the spell object.
903 */ 901 */
929 { 927 {
930 /* See how many points we actually heal. Instead of messages 928 /* See how many points we actually heal. Instead of messages
931 * based on type of spell, we instead do messages based 929 * based on type of spell, we instead do messages based
932 * on amount of damage healed. 930 * on amount of damage healed.
933 */ 931 */
934 if (heal > (tmp->stats.maxhp - tmp->stats.hp)) 932 if (heal > tmp->stats.maxhp - tmp->stats.hp)
935 heal = tmp->stats.maxhp - tmp->stats.hp; 933 heal = tmp->stats.maxhp - tmp->stats.hp;
934
936 tmp->stats.hp += heal; 935 tmp->stats.hp += heal;
937 936
938 if (tmp->stats.hp >= tmp->stats.maxhp) 937 if (tmp->stats.hp >= tmp->stats.maxhp)
939 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!"); 938 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
940 else if (heal > 50) 939 else if (heal > 50)
949 success = 1; 948 success = 1;
950 } 949 }
951 } 950 }
952 951
953 if (spell->attacktype & AT_DISEASE) 952 if (spell->attacktype & AT_DISEASE)
954 if (cure_disease (tmp, op)) 953 if (cure_disease (tmp, op, spell))
955 success = 1; 954 success = 1;
956 955
957 if (spell->attacktype & AT_POISON) 956 if (spell->attacktype & AT_POISON)
958 { 957 {
959 at = archetype::find ("poisoning"); 958 at = archetype::find ("poisoning");
1008 } 1007 }
1009 1008
1010 if (spell->stats.food && tmp->stats.food < 999) 1009 if (spell->stats.food && tmp->stats.food < 999)
1011 { 1010 {
1012 tmp->stats.food += spell->stats.food; 1011 tmp->stats.food += spell->stats.food;
1012
1013 if (tmp->stats.food > 999) 1013 if (tmp->stats.food > 999)
1014 tmp->stats.food = 999; 1014 tmp->stats.food = 999;
1015
1015 success = 1; 1016 success = 1;
1016 /* We could do something a bit better like the messages for healing above */ 1017 /* We could do something a bit better like the messages for healing above */
1017 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 1018 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1018 } 1019 }
1019 1020
1035}; 1036};
1036 1037
1037int 1038int
1038cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent) 1039cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1039{ 1040{
1040 object *force = NULL; 1041 object *force = 0;
1041 int i; 1042 int i;
1042 1043
1043 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1044 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1044 object *tmp = dir 1045 object *tmp = dir
1045 ? find_target_for_friendly_spell (op, dir) 1046 ? find_target_for_friendly_spell (op, dir)
1046 : op; 1047 : op;
1047 1048
1048 if (!tmp) 1049 if (!tmp)
1049 return 0; 1050 return 0;
1050 1051
1051 /* If we've already got a force of this type, don't add a new one. */ 1052 /* If we've already got a force of this type, don't add a new one. */
1060 } 1061 }
1061 else if (spell_ob->race && spell_ob->race == tmp2->name) 1062 else if (spell_ob->race && spell_ob->race == tmp2->name)
1062 { 1063 {
1063 if (!silent) 1064 if (!silent)
1064 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl); 1065 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
1066
1065 return 0; 1067 return 0;
1066 } 1068 }
1067 } 1069 }
1068 } 1070 }
1069 if (force == NULL) 1071
1072 if (!force)
1070 { 1073 {
1071 force = get_archetype (FORCE_NAME); 1074 force = get_archetype (FORCE_NAME);
1072 force->subtype = FORCE_CHANGE_ABILITY; 1075 force->subtype = FORCE_CHANGE_ABILITY;
1076
1073 if (spell_ob->race) 1077 if (spell_ob->race)
1074 force->name = spell_ob->race; 1078 force->name = spell_ob->race;
1075 else 1079 else
1076 force->name = spell_ob->name; 1080 force->name = spell_ob->name;
1081
1077 force->name_pl = spell_ob->name; 1082 force->name_pl = spell_ob->name;
1078 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force."); 1083 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
1079 1084
1080 } 1085 }
1081 else 1086 else
1087 { 1092 {
1088 force->duration = duration; 1093 force->duration = duration;
1089 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 1094 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1090 } 1095 }
1091 else 1096 else
1092 {
1093 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect."); 1097 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1094 }
1095 1098
1096 return 1; 1099 return 1;
1097 } 1100 }
1098 1101
1099 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1102 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1171 */ 1174 */
1172int 1175int
1173cast_bless (object *op, object *caster, object *spell_ob, int dir) 1176cast_bless (object *op, object *caster, object *spell_ob, int dir)
1174{ 1177{
1175 int i; 1178 int i;
1176 object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp; 1179 object *god = find_god (determine_god (op)), *force = NULL, *tmp;
1177 1180
1178 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1181 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1179 if (dir != 0) 1182 if (dir != 0)
1180 { 1183 {
1181 tmp = find_target_for_friendly_spell (op, dir); 1184 tmp = find_target_for_friendly_spell (op, dir);
1185
1186 if (!tmp)
1187 return 0;
1182 } 1188 }
1183 else 1189 else
1184 {
1185 tmp = op; 1190 tmp = op;
1186 }
1187 1191
1188 /* If we've already got a force of this type, don't add a new one. */ 1192 /* If we've already got a force of this type, don't add a new one. */
1189 for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) 1193 for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1190 { 1194 {
1191 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY) 1195 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1192 { 1196 {
1193 if (tmp2->name == spell_ob->name) 1197 if (tmp2->name == spell_ob->name)
1194 { 1198 {
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); 1204 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl);
1201 return 0; 1205 return 0;
1202 } 1206 }
1203 } 1207 }
1204 } 1208 }
1209
1205 if (force == NULL) 1210 if (force == NULL)
1206 { 1211 {
1207 force = get_archetype (FORCE_NAME); 1212 force = get_archetype (FORCE_NAME);
1208 force->subtype = FORCE_CHANGE_ABILITY; 1213 force->subtype = FORCE_CHANGE_ABILITY;
1209 if (spell_ob->race) 1214 if (spell_ob->race)
1274} 1279}
1275 1280
1276/* Alchemy code by Mark Wedel 1281/* Alchemy code by Mark Wedel
1277 * 1282 *
1278 * This code adds a new spell, called alchemy. Alchemy will turn 1283 * This code adds a new spell, called alchemy. Alchemy will turn
1279 * objects to gold nuggets, the value of the gold nuggets being 1284 * objects to pyrite ("false gold"), henceforth called gold nuggets.
1280 * about 90% of that of the item itself. It uses the value of the
1281 * object before charisma adjustments, because the nuggets themselves
1282 * will be will be adjusted by charisma when sold.
1283 * 1285 *
1284 * Large nuggets are worth 25 gp each (base). You will always get 1286 * The value of the gold nuggets being about 90% of that of the item
1285 * the maximum number of large nuggets you could get. 1287 * itself. It uses the value of the object before charisma adjustments,
1286 * Small nuggets are worth 1 gp each (base). You will get from 0 1288 * because the nuggets themselves will be will be adjusted by charisma
1287 * to the max amount of small nuggets as you could get. 1289 * when sold.
1288 *
1289 * For example, if an item is worth 110 gold, you will get
1290 * 4 large nuggets, and from 0-10 small nuggets.
1291 * 1290 *
1292 * There is also a chance (1:30) that you will get nothing at all 1291 * There is also a chance (1:30) that you will get nothing at all
1293 * for the object. There is also a maximum weight that will be 1292 * for the object. There is also a maximum weight that will be
1294 * alchemised. 1293 * alchemised.
1295 */ 1294 */
1296static void 1295static void
1297alchemy_object (object *obj, uint64 &total_value, int &total_weight) 1296alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1298{ 1297{
1299 uint64 value = query_cost (obj, NULL, F_TRUE); 1298 uint64 value = query_cost (obj, NULL, F_TRUE);
1300 1299
1301 /* Give third price when we alchemy money (This should hopefully 1300 /* Give third price when we alchemy money (this should hopefully
1302 * make it so that it isn't worth it to alchemy money, sell 1301 * make it so that it isn't worth it to alchemy money, sell
1303 * the nuggets, alchemy the gold from that, etc. 1302 * the nuggets, alchemy the gold from that, etc.
1304 * Otherwise, give 9 silver on the gold for other objects, 1303 * Otherwise, give 9 silver on the gold for other objects,
1305 * so that it would still be more affordable to haul 1304 * so that it would still be more affordable to haul
1306 * the stuff back to town. 1305 * the stuff back to town.
1318 total_weight += obj->total_weight (); 1317 total_weight += obj->total_weight ();
1319 1318
1320 obj->destroy (); 1319 obj->destroy ();
1321} 1320}
1322 1321
1323static void
1324update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1325{
1326 int flag = 0;
1327
1328 /* Put any nuggets below the player, but we can only pass this
1329 * flag if we are on the same space as the player
1330 */
1331 if (x == op->x && y == op->y && op->map == m)
1332 flag = INS_BELOW_ORIGINATOR;
1333
1334 if (small_nuggets)
1335 {
1336 object *tmp = small->clone ();
1337 tmp->nrof = small_nuggets;
1338 m->insert (tmp, x, y, op, flag);
1339 }
1340
1341 if (large_nuggets)
1342 {
1343 object *tmp = large->clone ();
1344 tmp->nrof = large_nuggets;
1345 m->insert (tmp, x, y, op, flag);
1346 }
1347
1348 if (object *pl = m->at (x, y).player ())
1349 if (pl->contr->ns)
1350 pl->contr->ns->look_position = 0;
1351}
1352
1353int 1322int
1354alchemy (object *op, object *caster, object *spell_ob) 1323alchemy (object *op, object *caster, object *spell_ob)
1355{ 1324{
1356 if (op->type != PLAYER) 1325 if (op->type != PLAYER)
1357 return 0; 1326 return 0;
1358 1327
1359 object *large = get_archetype ("largenugget"); 1328 archetype *nugget[3];
1360 object *small = get_archetype ("smallnugget"); 1329
1330 nugget[0] = archetype::find ("pyrite3");
1331 nugget[1] = archetype::find ("pyrite2");
1332 nugget[2] = archetype::find ("pyrite");
1361 1333
1362 /* Put a maximum weight of items that can be alchemised. Limits the power 1334 /* Put a maximum weight of items that can be alchemised. Limits the power
1363 * some, and also prevents people from alchemising every table/chair/clock 1335 * some, and also prevents people from alchemising every table/chair/clock
1364 * in sight 1336 * in sight
1365 */ 1337 */
1417 if (weight > weight_max) 1389 if (weight > weight_max)
1418 break; 1390 break;
1419 } 1391 }
1420 } 1392 }
1421 1393
1394 value -= rndm (value >> 4);
1422 value = min (value, value_max); 1395 value = min (value, value_max);
1423 1396
1424 uint64 count = value / large->value; 1397 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1425 int large_nuggets = count; 1398 if (int nrof = value / nugget [i]->value)
1426 value -= count * large->value;
1427
1428 count = value / small->value;
1429 int small_nuggets = count;
1430
1431 /* Insert all the nuggets at one time. This probably saves time, but
1432 * it also prevents us from alcheming nuggets that were just created
1433 * with this spell.
1434 */ 1399 {
1435 update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny); 1400 value -= nrof * nugget[i]->value;
1401
1402 object *tmp = arch_to_object (nugget[i]);
1403 tmp->nrof = nrof;
1404 tmp->flag [FLAG_IDENTIFIED] = true;
1405 op->map->insert (tmp, x, y, op, 0);
1406 }
1436 1407
1437 if (weight > weight_max) 1408 if (weight > weight_max)
1438 goto bailout; 1409 goto bailout;
1439 } 1410 }
1440 } 1411 }
1441 1412
1442bailout: 1413bailout:
1443 large->destroy ();
1444 small->destroy ();
1445 return 1; 1414 return 1;
1446} 1415}
1447
1448 1416
1449/* This function removes the cursed/damned status on equipped 1417/* This function removes the cursed/damned status on equipped
1450 * items. 1418 * items.
1451 */ 1419 */
1452int 1420int
1459 if (QUERY_FLAG (tmp, FLAG_APPLIED) && 1427 if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
1460 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) || 1428 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1461 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED)))) 1429 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1462 { 1430 {
1463 was_one++; 1431 was_one++;
1432
1464 if (tmp->level <= caster_level (caster, spell)) 1433 if (tmp->level <= casting_level (caster, spell))
1465 { 1434 {
1466 success++; 1435 success++;
1467 if (QUERY_FLAG (spell, FLAG_DAMNED)) 1436 if (QUERY_FLAG (spell, FLAG_DAMNED))
1468 CLEAR_FLAG (tmp, FLAG_DAMNED); 1437 CLEAR_FLAG (tmp, FLAG_DAMNED);
1469 1438
1470 CLEAR_FLAG (tmp, FLAG_CURSED); 1439 CLEAR_FLAG (tmp, FLAG_CURSED);
1471 CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED); 1440 CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);
1472 tmp->value = 0; /* Still can't sell it */ 1441 tmp->value = 0; /* Still can't sell it */
1473 if (op->type == PLAYER) 1442
1443 if (object *pl = tmp->visible_to ())
1474 esrv_send_item (op, tmp); 1444 esrv_update_item (UPD_FLAGS, pl, tmp);
1475 } 1445 }
1476 } 1446 }
1477 1447
1478 if (op->type == PLAYER) 1448 if (op->type == PLAYER)
1479 { 1449 {
1490 1460
1491 return success; 1461 return success;
1492} 1462}
1493 1463
1494/* Identifies objects in the players inventory/on the ground */ 1464/* Identifies objects in the players inventory/on the ground */
1495
1496int 1465int
1497cast_identify (object *op, object *caster, object *spell) 1466cast_identify (object *op, object *caster, object *spell)
1498{ 1467{
1499 object *tmp; 1468 object *tmp;
1500 int success = 0, num_ident; 1469 dynbuf_text &buf = msg_dynbuf; buf.clear ();
1501 1470
1502 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1471 int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1503
1504 if (num_ident < 1)
1505 num_ident = 1;
1506 1472
1507 for (tmp = op->inv; tmp; tmp = tmp->below) 1473 for (tmp = op->inv; tmp; tmp = tmp->below)
1508 { 1474 {
1509 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1475 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1510 { 1476 {
1511 identify (tmp); 1477 identify (tmp);
1512 1478
1513 if (op->type == PLAYER) 1479 if (op->type == PLAYER)
1514 { 1480 {
1515 new_draw_info_format (NDI_UNIQUE, 0, op, "You identified: %s.", long_desc (tmp, op)); 1481 buf.printf ("You identified: %s.\r", long_desc (tmp, op));
1516 1482
1517 if (tmp->msg) 1483 if (tmp->msg)
1518 { 1484 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 } 1485 }
1523 1486
1524 num_ident--;
1525 success = 1;
1526 if (!num_ident) 1487 if (!--num_ident)
1527 break; 1488 break;
1528 } 1489 }
1529 } 1490 }
1530 1491
1531 /* If all the power of the spell has been used up, don't go and identify 1492 /* If all the power of the spell has been used up, don't go and identify
1537 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above) 1498 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1538 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1499 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1539 { 1500 {
1540 identify (tmp); 1501 identify (tmp);
1541 1502
1542 if (op->type == PLAYER) 1503 if (object *pl = tmp->visible_to ())
1543 { 1504 {
1544 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground you identified: %s.", long_desc (tmp, op)); 1505 buf.printf ("On the ground you identified: %s.\r", long_desc (tmp, op));
1545 1506
1546 if (tmp->msg) 1507 if (tmp->msg)
1547 { 1508 buf << "The item has a story:\r" << tmp->msg << "\n\n";
1548 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1549 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1550 }
1551
1552 esrv_send_item (op, tmp);
1553 } 1509 }
1554 1510
1555 num_ident--;
1556 success = 1;
1557 if (!num_ident) 1511 if (!--num_ident)
1558 break; 1512 break;
1559 } 1513 }
1560 } 1514 }
1561 1515
1562 if (!success) 1516 if (buf.empty ())
1563 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified."); 1517 {
1518 op->failmsg ("You can't reach anything unidentified.");
1519 return 0;
1520 }
1564 else 1521 else
1522 {
1523 if (op->contr)
1524 op->contr->infobox (MSG_CHANNEL ("identify"), buf);
1525
1565 spell_effect (spell, op->x, op->y, op->map, op); 1526 spell_effect (spell, op->x, op->y, op->map, op);
1566 1527 return 1;
1567 return success; 1528 }
1568} 1529}
1569 1530
1570int 1531int
1571cast_detection (object *op, object *caster, object *spell, object *skill) 1532cast_detection (object *op, object *caster, object *spell, object *skill)
1572{ 1533{
1577 1538
1578 /* We precompute some values here so that we don't have to keep 1539 /* We precompute some values here so that we don't have to keep
1579 * doing it over and over again. 1540 * doing it over and over again.
1580 */ 1541 */
1581 god = find_god (determine_god (op)); 1542 god = find_god (determine_god (op));
1582 level = caster_level (caster, spell); 1543 level = casting_level (caster, spell);
1583 range = spell->range + SP_level_range_adjust (caster, spell); 1544 range = spell->range + SP_level_range_adjust (caster, spell);
1584 1545
1585 if (!skill) 1546 if (!skill)
1586 skill = caster; 1547 skill = caster;
1587 1548
1588 for (x = op->x - range; x <= op->x + range; x++) 1549 unordered_mapwalk (op, -range, -range, range, range)
1589 for (y = op->y - range; y <= op->y + range; y++)
1590 { 1550 {
1591 m = op->map;
1592 mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1593 if (mflags & P_OUT_OF_MAP)
1594 continue;
1595
1596 /* For most of the detections, we only detect objects above the 1551 /* For most of the detections, we only detect objects above the
1597 * floor. But this is not true for show invisible. 1552 * floor. But this is not true for show invisible.
1598 * Basically, we just go and find the top object and work 1553 * Basically, we just go and find the top object and work
1599 * down - that is easier than working up. 1554 * down - that is easier than working up.
1600 */ 1555 */
1601 1556
1602 for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above) 1557 for (last = NULL, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1603 last = tmp; 1558 last = tmp;
1604 1559
1605 /* Shouldn't happen, but if there are no objects on a space, this 1560 /* Shouldn't happen, but if there are no objects on a space, this
1606 * would happen. 1561 * would happen.
1607 */ 1562 */
1608 if (!last) 1563 if (!last)
1609 continue; 1564 continue;
1610 1565
1611 done_one = 0; 1566 done_one = 0;
1612 floor = 0; 1567 floor = 0;
1613 detect = NULL; 1568 detect = NULL;
1614 for (tmp = last; tmp; tmp = tmp->below) 1569 for (tmp = last; tmp; tmp = tmp->below)
1615 { 1570 {
1616 /* show invisible */ 1571 /* show invisible */
1617 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) && 1572 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) &&
1618 /* Might there be other objects that we can make visible? */ 1573 /* Might there be other objects that we can make visible? */
1619 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) || 1574 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) ||
1620 (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) || 1575 (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ))
1621 tmp->type == CF_HANDLE || 1576 || tmp->type == CF_HANDLE
1622 tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE || 1577 || tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE
1623 tmp->type == BUTTON || tmp->type == TELEPORTER || 1578 || tmp->type == BUTTON || tmp->type == TELEPORTER
1624 tmp->type == GATE || tmp->type == LOCKED_DOOR || 1579 || tmp->type == GATE || tmp->type == LOCKED_DOOR
1625 tmp->type == WEAPON || tmp->type == ALTAR || tmp->type == SIGN || 1580 || tmp->type == WEAPON || tmp->type == ALTAR || tmp->type == SIGN
1626 tmp->type == TRIGGER_PEDESTAL || tmp->type == SPECIAL_KEY || 1581 || tmp->type == TRIGGER_PEDESTAL || tmp->type == SPECIAL_KEY
1627 tmp->type == TREASURE || tmp->type == BOOK || tmp->type == HOLY_ALTAR))) 1582 || tmp->type == TREASURE || tmp->type == BOOK || tmp->type == HOLY_ALTAR)))
1628 { 1583 {
1629 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4) 1584 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1630 { 1585 {
1631 tmp->invisible = 0; 1586 tmp->invisible = 0;
1632 done_one = 1; 1587 done_one = 1;
1633 } 1588 }
1634 } 1589 }
1635 1590
1636 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1591 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1637 floor = 1; 1592 floor = 1;
1638 1593
1639 /* All detections below this point don't descend beneath the floor, 1594 /* All detections below this point don't descend beneath the floor,
1640 * so just continue on. We could be clever and look at the type of 1595 * so just continue on. We could be clever and look at the type of
1641 * detection to completely break out if we don't care about objects beneath 1596 * detection to completely break out if we don't care about objects beneath
1642 * the floor, but once we get to the floor, not likely a very big issue anyways. 1597 * the floor, but once we get to the floor, not likely a very big issue anyways.
1643 */ 1598 */
1644 if (floor) 1599 if (floor)
1645 continue; 1600 continue;
1646 1601
1647 /* I had thought about making detect magic and detect curse 1602 /* I had thought about making detect magic and detect curse
1648 * show the flash the magic item like it does for detect monster. 1603 * show the flash the magic item like it does for detect monster.
1649 * however, if the object is within sight, this would then make it 1604 * however, if the object is within sight, this would then make it
1650 * difficult to see what object is magical/cursed, so the 1605 * difficult to see what object is magical/cursed, so the
1651 * effect wouldn't be as apparant. 1606 * effect wouldn't be as apparent.
1652 */ 1607 */
1653 1608
1654 /* detect magic */ 1609 /* detect magic */
1655 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && 1610 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&
1656 !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp)) 1611 !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))
1657 { 1612 {
1658 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL); 1613 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1659 /* make runes more visibile */ 1614 /* make runes more visibile */
1660 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC) 1615 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1661 tmp->stats.Cha /= 4; 1616 tmp->stats.Cha /= 4;
1617
1662 done_one = 1; 1618 done_one = 1;
1663 } 1619 }
1620
1664 /* detect monster */ 1621 /* detect monster */
1665 if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER)) 1622 if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))
1666 { 1623 {
1667 done_one = 2; 1624 done_one = 2;
1625
1668 if (!detect) 1626 if (!detect)
1669 detect = tmp; 1627 detect = tmp;
1670 } 1628 }
1629
1671 /* Basically, if race is set in the spell, then the creatures race must 1630 /* Basically, if race is set in the spell, then the creatures race must
1672 * match that. if the spell race is set to GOD, then the gods opposing 1631 * match that. if the spell race is set to GOD, then the gods opposing
1673 * race must match. 1632 * race must match.
1674 */ 1633 */
1675 if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race && 1634 if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&
1676 ((!strcmp (spell->race, "GOD") && god && god->slaying && strstr (god->slaying, tmp->race)) || 1635 ((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||
1677 (strstr (spell->race, tmp->race)))) 1636 spell->race.contains (tmp->race)))
1678 { 1637 {
1679 done_one = 2; 1638 done_one = 2;
1639
1680 if (!detect) 1640 if (!detect)
1681 detect = tmp; 1641 detect = tmp;
1682 } 1642 }
1643
1683 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && 1644 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1684 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))) 1645 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1685 { 1646 {
1686 SET_FLAG (tmp, FLAG_KNOWN_CURSED); 1647 SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1687 done_one = 1; 1648 done_one = 1;
1688 } 1649 }
1689 } /* for stack of objects on this space */ 1650 } /* for stack of objects on this space */
1690 1651
1691 /* Code here puts an effect of the spell on the space, so you can see 1652 /* Code here puts an effect of the spell on the space, so you can see
1692 * where the magic is. 1653 * where the magic is.
1693 */ 1654 */
1694 if (done_one) 1655 if (done_one)
1695 { 1656 {
1696 object *detect_ob = arch_to_object (spell->other_arch); 1657 object *detect_ob = arch_to_object (spell->other_arch);
1697 1658
1698 /* if this is set, we want to copy the face */ 1659 /* if this is set, we want to copy the face */
1699 if (done_one == 2 && detect) 1660 if (done_one == 2 && detect)
1700 { 1661 {
1701 detect_ob->face = detect->face; 1662 detect_ob->face = detect->face;
1702 detect_ob->animation_id = detect->animation_id; 1663 detect_ob->animation_id = detect->animation_id;
1703 detect_ob->anim_speed = detect->anim_speed; 1664 detect_ob->anim_speed = detect->anim_speed;
1704 detect_ob->last_anim = 0; 1665 detect_ob->last_anim = 0;
1705 /* by default, the detect_ob is already animated */ 1666 /* by default, the detect_ob is already animated */
1706 if (!QUERY_FLAG (detect, FLAG_ANIMATE)) 1667 if (!QUERY_FLAG (detect, FLAG_ANIMATE))
1707 CLEAR_FLAG (detect_ob, FLAG_ANIMATE); 1668 CLEAR_FLAG (detect_ob, FLAG_ANIMATE);
1708 } 1669 }
1709 1670
1710 m->insert (detect_ob, nx, ny, op); 1671 m->insert (detect_ob, nx, ny, op);
1711 } 1672 }
1712 } /* for processing the surrounding spaces */ 1673 } /* for processing the surrounding spaces */
1713 1674
1714 1675
1715 /* Now process objects in the players inventory if detect curse or magic */ 1676 /* Now process objects in the players inventory if detect curse or magic */
1716 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL)) 1677 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))
1717 { 1678 {
1718 done_one = 0; 1679 done_one = 0;
1680
1719 for (tmp = op->inv; tmp; tmp = tmp->below) 1681 for (tmp = op->inv; tmp; tmp = tmp->below)
1720 { 1682 {
1721 if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED)) 1683 if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1722 { 1684 {
1723 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL)) 1685 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))
1724 { 1686 {
1725 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL); 1687 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1726 if (op->type == PLAYER) 1688
1689 if (object *pl = tmp->visible_to ())
1727 esrv_send_item (op, tmp); 1690 esrv_update_item (UPD_FLAGS, pl, tmp);
1728 } 1691 }
1692
1729 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && 1693 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1730 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))) 1694 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1731 { 1695 {
1732 SET_FLAG (tmp, FLAG_KNOWN_CURSED); 1696 SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1733 if (op->type == PLAYER) 1697
1698 if (object *pl = tmp->visible_to ())
1734 esrv_send_item (op, tmp); 1699 esrv_update_item (UPD_FLAGS, pl, tmp);
1735 } 1700 }
1736 } /* if item is not identified */ 1701 } /* if item is not identified */
1737 } /* for the players inventory */ 1702 } /* for the players inventory */
1738 } /* if detect magic/curse and object is a player */ 1703 } /* if detect magic/curse and object is a player */
1704
1739 return 1; 1705 return 1;
1740} 1706}
1741 1707
1742 1708
1743/** 1709/**
1756 1722
1757 new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you."); 1723 new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");
1758 1724
1759 if (victim->stats.sp >= victim->stats.maxsp * 2) 1725 if (victim->stats.sp >= victim->stats.maxsp * 2)
1760 { 1726 {
1761 object *tmp;
1762
1763 new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!"); 1727 new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");
1764
1765 /* Explodes a fireball centered at player */
1766 tmp = get_archetype (EXPLODING_FIREBALL);
1767 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
1768 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
1769
1770 tmp->insert_at (victim);
1771 victim->stats.sp = 2 * victim->stats.maxsp; 1728 victim->stats.sp = 2 * victim->stats.maxsp;
1729 create_exploding_ball_at (victim, caster_level);
1772 } 1730 }
1773 else if (victim->stats.sp >= victim->stats.maxsp * 1.88) 1731 else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
1774 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode."); 1732 new_draw_info (NDI_UNIQUE | NDI_ORANGE, 0, victim, "You feel like your head is going to explode.");
1775 else if (victim->stats.sp >= victim->stats.maxsp * 1.66) 1733 else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
1776 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!"); 1734 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
1777 else if (victim->stats.sp >= victim->stats.maxsp * 1.5) 1735 else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
1778 { 1736 {
1779 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world."); 1737 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
1825 } 1783 }
1826 /* give sp */ 1784 /* give sp */
1827 if (spell->stats.dam > 0) 1785 if (spell->stats.dam > 0)
1828 { 1786 {
1829 plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell); 1787 plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);
1830 charge_mana_effect (plyr, caster_level (caster, spell)); 1788 charge_mana_effect (plyr, casting_level (caster, spell));
1831 return 1; 1789 return 1;
1832 } 1790 }
1833 /* suck sp away. Can't suck sp from yourself */ 1791 /* suck sp away. Can't suck sp from yourself */
1834 else if (op != plyr) 1792 else if (op != plyr)
1835 { 1793 {
1847 /* Player doesn't get full credit */ 1805 /* Player doesn't get full credit */
1848 sucked = (sucked * rate) / 100; 1806 sucked = (sucked * rate) / 100;
1849 op->stats.sp += sucked; 1807 op->stats.sp += sucked;
1850 if (sucked > 0) 1808 if (sucked > 0)
1851 { 1809 {
1852 charge_mana_effect (op, caster_level (caster, spell)); 1810 charge_mana_effect (op, casting_level (caster, spell));
1853 } 1811 }
1854 } 1812 }
1855 return 1; 1813 return 1;
1856 } 1814 }
1857 return 0; 1815 return 0;
1933 break; 1891 break;
1934 } 1892 }
1935 } 1893 }
1936} 1894}
1937 1895
1938
1939
1940/* cast_consecrate() - a spell to make an altar your god's */ 1896/* cast_consecrate() - a spell to make an altar your god's */
1941int 1897int
1942cast_consecrate (object *op, object *caster, object *spell) 1898cast_consecrate (object *op, object *caster, object *spell)
1943{ 1899{
1944 char buf[MAX_BUF]; 1900 char buf[MAX_BUF];
1956 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1912 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1957 break; 1913 break;
1958 if (tmp->type == HOLY_ALTAR) 1914 if (tmp->type == HOLY_ALTAR)
1959 { 1915 {
1960 1916
1961 if (tmp->level > caster_level (caster, spell)) 1917 if (tmp->level > casting_level (caster, spell))
1962 { 1918 {
1963 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name); 1919 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name);
1964 return 0; 1920 return 0;
1965 } 1921 }
1966 else 1922 else
1967 { 1923 {
1968 /* If we got here, we are consecrating an altar */ 1924 /* If we got here, we are consecrating an altar */
1969 sprintf (buf, "Altar of %s", &god->name); 1925 sprintf (buf, "Altar of %s", &god->name);
1970 tmp->name = buf; 1926 tmp->name = buf;
1971 tmp->level = caster_level (caster, spell); 1927 tmp->level = casting_level (caster, spell);
1972 tmp->other_arch = god->arch; 1928 tmp->other_arch = god->arch;
1929
1973 if (op->type == PLAYER) 1930 if (op->type == PLAYER)
1974 esrv_update_item (UPD_NAME, op, tmp); 1931 esrv_update_item (UPD_NAME, op, tmp);
1932
1975 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name); 1933 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
1976 return 1; 1934 return 1;
1977 } 1935 }
1978 } 1936 }
1979 } 1937 }
1997 object *weapon, *tmp; 1955 object *weapon, *tmp;
1998 char buf[MAX_BUF]; 1956 char buf[MAX_BUF];
1999 int a, i; 1957 int a, i;
2000 sint16 x, y; 1958 sint16 x, y;
2001 maptile *m; 1959 maptile *m;
2002 materialtype_t *mt;
2003 1960
2004 if (!spell->other_arch) 1961 if (!spell->other_arch)
2005 { 1962 {
2006 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 1963 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
2007 LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name); 1964 LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);
2018 return 0; 1975 return 0;
2019 } 1976 }
2020 1977
2021 /* if no direction specified, pick one */ 1978 /* if no direction specified, pick one */
2022 if (!dir) 1979 if (!dir)
2023 dir = find_free_spot (NULL, op->map, op->x, op->y, 1, 9); 1980 dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);
2024 1981
2025 m = op->map; 1982 m = op->map;
2026 x = op->x + freearr_x[dir]; 1983 x = op->x + freearr_x[dir];
2027 y = op->y + freearr_y[dir]; 1984 y = op->y + freearr_y[dir];
2028 1985
2029 /* if there's no place to put the golem, abort */ 1986 /* if there's no place to put the golem, abort */
2030 if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) || 1987 if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
2031 ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type)) 1988 || ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2032 { 1989 {
2033 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 1990 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
2034 return 0; 1991 return 0;
2035 } 1992 }
2036 1993
2040 if (!weapon) 1997 if (!weapon)
2041 { 1998 {
2042 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!"); 1999 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!");
2043 return 0; 2000 return 0;
2044 } 2001 }
2002
2045 if (spell->race && strcmp (weapon->arch->archname, spell->race)) 2003 if (spell->race && weapon->arch->archname != spell->race)
2046 { 2004 {
2047 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon."); 2005 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon.");
2048 return 0; 2006 return 0;
2049 } 2007 }
2008
2050 if (weapon->type != WEAPON) 2009 if (weapon->type != WEAPON)
2051 { 2010 {
2052 new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it."); 2011 new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it.");
2053 return 0; 2012 return 0;
2054 } 2013 }
2014
2055 if (QUERY_FLAG (weapon, FLAG_APPLIED)) 2015 if (QUERY_FLAG (weapon, FLAG_APPLIED))
2056 { 2016 {
2057 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon)); 2017 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));
2058 return 0; 2018 return 0;
2059 } 2019 }
2060 2020
2061 if (weapon->nrof > 1) 2021 weapon = weapon->split ();
2062 {
2063 tmp = get_split_ob (weapon, 1);
2064 esrv_send_item (op, weapon);
2065 weapon = tmp;
2066 }
2067 2022
2068 /* create the golem object */ 2023 /* create the golem object */
2069 tmp = arch_to_object (spell->other_arch); 2024 tmp = arch_to_object (spell->other_arch);
2070 2025
2071 /* if animated by a player, give the player control of the golem */ 2026 /* if animated by a player, give the player control of the golem */
2076 tmp->set_owner (op); 2031 tmp->set_owner (op);
2077 op->contr->golem = tmp; 2032 op->contr->golem = tmp;
2078 set_spell_skill (op, caster, spell, tmp); 2033 set_spell_skill (op, caster, spell, tmp);
2079 2034
2080 /* Give the weapon to the golem now. A bit of a hack to check the 2035 /* Give the weapon to the golem now. A bit of a hack to check the
2081 * removed flag - it should only be set if get_split_object was 2036 * removed flag - it should only be set if weapon->split was
2082 * used above. 2037 * used above.
2083 */ 2038 */
2084 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2039 if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2085 weapon->remove (); 2040 weapon->remove ();
2086 2041
2087 insert_ob_in_ob (weapon, tmp); 2042 tmp->insert (weapon);
2088 esrv_send_item (op, weapon); 2043
2089 /* To do everything necessary to let a golem use the weapon is a pain, 2044 /* To do everything necessary to let a golem use the weapon is a pain,
2090 * so instead, just set it as equipped (otherwise, we need to update 2045 * so instead, just set it as equipped (otherwise, we need to update
2091 * body_info, skills, etc) 2046 * body_info, skills, etc)
2092 */ 2047 */
2093 SET_FLAG (tmp, FLAG_USE_WEAPON); 2048 SET_FLAG (tmp, FLAG_USE_WEAPON);
2119 2074
2120 /* attacktype */ 2075 /* attacktype */
2121 if (!tmp->attacktype) 2076 if (!tmp->attacktype)
2122 tmp->attacktype = AT_PHYSICAL; 2077 tmp->attacktype = AT_PHYSICAL;
2123 2078
2124 mt = NULL;
2125 if (op->materialname != NULL)
2126 mt = name_to_material (op->materialname); 2079 if (materialtype_t *mt = name_to_material (op->materialname))
2127 if (mt != NULL)
2128 { 2080 {
2129 for (i = 0; i < NROFATTACKS; i++) 2081 for (i = 0; i < NROFATTACKS; i++)
2130 tmp->resist[i] = 50 - (mt->save[i] * 5); 2082 tmp->resist[i] = 50 - (mt->save[i] * 5);
2131 a = mt->save[0]; 2083 a = mt->save[0];
2132 } 2084 }
2134 { 2086 {
2135 for (i = 0; i < NROFATTACKS; i++) 2087 for (i = 0; i < NROFATTACKS; i++)
2136 tmp->resist[i] = 5; 2088 tmp->resist[i] = 5;
2137 a = 10; 2089 a = 10;
2138 } 2090 }
2091
2139 /* Set weapon's immunity */ 2092 /* Set weapon's immunity */
2140 tmp->resist[ATNR_CONFUSION] = 100; 2093 tmp->resist[ATNR_CONFUSION] = 100;
2141 tmp->resist[ATNR_POISON] = 100; 2094 tmp->resist[ATNR_POISON] = 100;
2142 tmp->resist[ATNR_SLOW] = 100; 2095 tmp->resist[ATNR_SLOW] = 100;
2143 tmp->resist[ATNR_PARALYZE] = 100; 2096 tmp->resist[ATNR_PARALYZE] = 100;
2149 2102
2150 /* Improve weapon's armour value according to best save vs. physical of its material */ 2103 /* Improve weapon's armour value according to best save vs. physical of its material */
2151 2104
2152 if (a > 14) 2105 if (a > 14)
2153 a = 14; 2106 a = 14;
2107
2154 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a)); 2108 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2155 2109
2156 /* Determine golem's speed */ 2110 /* Determine golem's speed */
2157 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell))); 2111 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2158 2112
2168 tmp->state = weapon->state; 2122 tmp->state = weapon->state;
2169 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE]; 2123 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2170 } 2124 }
2171 2125
2172 /* make experience increase in proportion to the strength of the summoned creature. */ 2126 /* make experience increase in proportion to the strength of the summoned creature. */
2173 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell)); 2127 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));
2174 2128
2175 tmp->speed_left = -1; 2129 tmp->speed_left = -1;
2176 tmp->direction = dir; 2130 tmp->direction = dir;
2177 2131
2178 m->insert (tmp, x, y, op); 2132 m->insert (tmp, x, y, op);
2182/* cast_daylight() - changes the map darkness level *lower* */ 2136/* cast_daylight() - changes the map darkness level *lower* */
2183 2137
2184/* cast_change_map_lightlevel: Was cast_daylight/nightfall. 2138/* cast_change_map_lightlevel: Was cast_daylight/nightfall.
2185 * This changes the light level for the entire map. 2139 * This changes the light level for the entire map.
2186 */ 2140 */
2187
2188int 2141int
2189cast_change_map_lightlevel (object *op, object *caster, object *spell) 2142cast_change_map_lightlevel (object *op, object *caster, object *spell)
2190{ 2143{
2191 int success; 2144 int success;
2192 2145
2200 if (spell->stats.dam < 0) 2153 if (spell->stats.dam < 0)
2201 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here."); 2154 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here.");
2202 else 2155 else
2203 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here."); 2156 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2204 } 2157 }
2158
2205 return success; 2159 return success;
2206} 2160}
2207
2208
2209
2210
2211 2161
2212/* create an aura spell object and put it in the player's inventory. 2162/* create an aura spell object and put it in the player's inventory.
2213 * as usual, op is player, caster is the object casting the spell, 2163 * as usual, op is player, caster is the object casting the spell,
2214 * spell is the spell object itself. 2164 * spell is the spell object itself.
2215 */ 2165 */
2227 2177
2228 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2178 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2229 2179
2230 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2180 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2231 2181
2232 new_aura->set_owner (op);
2233 set_spell_skill (op, caster, spell, new_aura); 2182 set_spell_skill (op, caster, spell, new_aura);
2234 new_aura->attacktype = spell->attacktype; 2183 new_aura->attacktype = spell->attacktype;
2235 2184
2236 new_aura->level = caster_level (caster, spell); 2185 new_aura->level = casting_level (caster, spell);
2186
2237 if (refresh) 2187 if (refresh)
2238 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 2188 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2239 else 2189 else
2240 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force."); 2190 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
2191
2241 insert_ob_in_ob (new_aura, op); 2192 insert_ob_in_ob (new_aura, op);
2193 new_aura->set_owner (op);
2194
2242 return 1; 2195 return 1;
2243} 2196}
2244
2245 2197
2246/* move aura function. An aura is a part of someone's inventory, 2198/* move aura function. An aura is a part of someone's inventory,
2247 * which he carries with him, but which acts on the map immediately 2199 * which he carries with him, but which acts on the map immediately
2248 * around him. 2200 * around him.
2249 * Aura parameters: 2201 * Aura parameters:
2250 * duration: duration counter. 2202 * duration: duration counter.
2251 * attacktype: aura's attacktype 2203 * attacktype: aura's attacktype
2252 * other_arch: archetype to drop where we attack 2204 * other_arch: archetype to drop where we attack
2253 */ 2205 */
2254
2255void 2206void
2256move_aura (object *aura) 2207move_aura (object *aura)
2257{ 2208{
2258 int i, mflags;
2259 object *env;
2260 maptile *m;
2261
2262 /* auras belong in inventories */ 2209 /* auras belong in inventories */
2263 env = aura->env; 2210 object *env = aura->env;
2211 object *owner = aura->owner;
2264 2212
2265 /* no matter what we've gotta remove the aura... 2213 /* no matter what we've gotta remove the aura...
2266 * we'll put it back if its time isn't up. 2214 * we'll put it back if its time isn't up.
2267 */ 2215 */
2268 aura->remove (); 2216 aura->remove ();
2273 aura->destroy (); 2221 aura->destroy ();
2274 return; 2222 return;
2275 } 2223 }
2276 2224
2277 /* auras only exist in inventories */ 2225 /* auras only exist in inventories */
2278 if (env == NULL || env->map == NULL) 2226 if (!env || !env->map)
2279 { 2227 {
2280 aura->destroy (); 2228 aura->destroy ();
2281 return; 2229 return;
2282 } 2230 }
2283 2231
2284 /* we need to jump out of the inventory for a bit 2232 /* we need to jump out of the inventory for a bit
2285 * in order to hit the map conveniently. 2233 * in order to hit the map conveniently.
2286 */ 2234 */
2287 aura->insert_at (env, aura); 2235 aura->insert_at (env, aura);
2288 2236
2289 for (i = 1; i < 9; i++) 2237 for (int i = 1; i < 9; i++)
2290 { 2238 {
2291 sint16 nx, ny; 2239 mapxy pos (env);
2240 pos.move (i);
2292 2241
2293 nx = aura->x + freearr_x[i];
2294 ny = aura->y + freearr_y[i];
2295 mflags = get_map_flags (env->map, &m, nx, ny, &nx, &ny);
2296
2297 /* Consider the movement tyep of the person with the aura as 2242 /* Consider the movement type of the person with the aura as
2298 * movement type of the aura. Eg, if the player is flying, the aura 2243 * movement type of the aura. Eg, if the player is flying, the aura
2299 * is flying also, if player is walking, it is on the ground, etc. 2244 * is flying also, if player is walking, it is on the ground, etc.
2300 */ 2245 */
2301 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny)))) 2246 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2302 { 2247 {
2303 hit_map (aura, i, aura->attacktype, 0); 2248 hit_map (aura, i, aura->attacktype, 0);
2304 2249
2305 if (aura->other_arch) 2250 if (aura->other_arch)
2306 m->insert (arch_to_object (aura->other_arch), nx, ny, aura); 2251 pos.insert (arch_to_object (aura->other_arch), aura);
2307 } 2252 }
2308 } 2253 }
2309 2254
2310 /* put the aura back in the player's inventory */ 2255 /* put the aura back in the player's inventory */
2311 aura->remove (); 2256 env->insert (aura);
2312 insert_ob_in_ob (aura, env); 2257 aura->set_owner (owner);
2313} 2258}
2314 2259
2315/* moves the peacemaker spell. 2260/* moves the peacemaker spell.
2316 * op is the piece object. 2261 * op is the piece object.
2317 */ 2262 */
2318
2319void 2263void
2320move_peacemaker (object *op) 2264move_peacemaker (object *op)
2321{ 2265{
2322 object *tmp; 2266 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
2323
2324 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2325 { 2267 {
2326 int atk_lev, def_lev; 2268 int atk_lev, def_lev;
2327 object *victim = tmp; 2269 object *victim = tmp->head_ ();
2328 2270
2329 if (tmp->head)
2330 victim = tmp->head;
2331 if (!QUERY_FLAG (victim, FLAG_MONSTER)) 2271 if (!QUERY_FLAG (victim, FLAG_MONSTER))
2332 continue; 2272 continue;
2273
2333 if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE)) 2274 if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))
2334 continue; 2275 continue;
2276
2335 if (victim->stats.exp == 0) 2277 if (victim->stats.exp == 0)
2336 continue; 2278 continue;
2337 2279
2338 def_lev = MAX (1, victim->level); 2280 def_lev = MAX (1, victim->level);
2339 atk_lev = MAX (1, op->level); 2281 atk_lev = MAX (1, op->level);
2340 2282
2341 if (rndm (0, atk_lev - 1) > def_lev) 2283 if (rndm (0, atk_lev - 1) > def_lev)
2342 { 2284 {
2343 /* make this sucker peaceful. */ 2285 /* make this sucker peaceful. */
2344 2286
2287 INVOKE_OBJECT (KILL, victim, ARG_OBJECT (op));
2345 change_exp (op->owner, victim->stats.exp, op->skill, 0); 2288 change_exp (op->owner, victim->stats.exp, op->skill, 0);
2346 victim->stats.exp = 0; 2289 victim->stats.exp = 0;
2347#if 0 2290#if 0
2348 /* No idea why these were all set to zero - if something 2291 /* No idea why these were all set to zero - if something
2349 * makes this creature agressive, he should still do damage. 2292 * makes this creature agressive, he should still do damage.
2356 victim->attack_movement = RANDO2; 2299 victim->attack_movement = RANDO2;
2357 SET_FLAG (victim, FLAG_UNAGGRESSIVE); 2300 SET_FLAG (victim, FLAG_UNAGGRESSIVE);
2358 SET_FLAG (victim, FLAG_RUN_AWAY); 2301 SET_FLAG (victim, FLAG_RUN_AWAY);
2359 SET_FLAG (victim, FLAG_RANDOM_MOVE); 2302 SET_FLAG (victim, FLAG_RANDOM_MOVE);
2360 CLEAR_FLAG (victim, FLAG_MONSTER); 2303 CLEAR_FLAG (victim, FLAG_MONSTER);
2304
2361 if (victim->name) 2305 if (victim->name)
2362 {
2363 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name); 2306 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2364 } 2307 }
2365 }
2366 } 2308 }
2367} 2309}
2368
2369 2310
2370/* This writes a rune that contains the appropriate message. 2311/* This writes a rune that contains the appropriate message.
2371 * There really isn't any adjustments we make. 2312 * There really isn't any adjustments we make.
2372 */ 2313 */
2373
2374int 2314int
2375write_mark (object *op, object *spell, const char *msg) 2315write_mark (object *op, object *spell, const char *msg)
2376{ 2316{
2377 char rune[HUGE_BUF];
2378 object *tmp;
2379
2380 if (!msg || msg[0] == 0) 2317 if (!msg || msg[0] == 0)
2381 { 2318 {
2382 new_draw_info (NDI_UNIQUE, 0, op, "Write what?"); 2319 new_draw_info (NDI_UNIQUE, 0, op, "Write what?");
2383 return 0; 2320 return 0;
2384 } 2321 }
2387 { 2324 {
2388 new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?"); 2325 new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?");
2389 LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg); 2326 LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg);
2390 return 0; 2327 return 0;
2391 } 2328 }
2329
2392 if (!spell->other_arch) 2330 if (!spell->other_arch)
2393 return 0; 2331 return 0;
2332
2394 tmp = arch_to_object (spell->other_arch); 2333 object *tmp = arch_to_object (spell->other_arch);
2395
2396 snprintf (rune, sizeof (rune), "%s\n", msg);
2397 2334
2398 tmp->race = op->name; /*Save the owner of the rune */ 2335 tmp->race = op->name; /*Save the owner of the rune */
2399 tmp->msg = rune; 2336 tmp->msg = msg;
2400 2337
2401 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR); 2338 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2339
2402 return 1; 2340 return 1;
2403} 2341}
2342

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines