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.83 by root, Tue May 6 16:55:26 2008 UTC vs.
Revision 1.133 by root, Sun May 2 19:51:50 2010 UTC

1/* 1/*
2 * This file is part of Deliantra, the Roguelike Realtime MMORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * it under the terms of the GNU General Public License as published by 9 * the terms of the Affero GNU General Public License as published by the
10 * the Free Software Foundation, either version 3 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your option) any later version. 11 * 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,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
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 Affero GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
20 * 21 *
21 * The authors can be reached via e-mail to <support@deliantra.net> 22 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 23 */
23 24
24#include <global.h> 25#include <global.h>
… …
57} 58}
58 59
59int 60int
60recharge (object *op, object *caster, object *spell_ob) 61recharge (object *op, object *caster, object *spell_ob)
61{ 62{
62 object *wand, *tmp;
63 int ncharges; 63 int ncharges;
64 64
65 wand = find_marked_object (op); 65 object *wand = op->mark ();
66
66 if (wand == NULL || wand->type != WAND) 67 if (!wand || wand->type != WAND)
67 { 68 {
68 new_draw_info (NDI_UNIQUE, 0, op, "You need to mark the wand you want to recharge."); 69 op->failmsg ("You need to mark the wand you want to recharge.");
69 return 0; 70 return 0;
70 } 71 }
72
71 if (!(random_roll (0, 3, op, PREFER_HIGH))) 73 if (!(random_roll (0, 3, op, PREFER_HIGH)))
72 { 74 {
73 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand)); 75 op->failmsgf ("The %s vibrates violently, then explodes!", query_name (wand));
74 op->play_sound (sound_find ("ob_explode")); 76 op->play_sound (sound_find ("ob_explode"));
75 wand->destroy (); 77 wand->destroy ();
76 tmp = get_archetype ("fireball"); 78 object *tmp = get_archetype (shstr_fireball);
77 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10; 79 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
78 80
79 if (!tmp->stats.dam) 81 if (!tmp->stats.dam)
80 tmp->stats.dam = 1; 82 tmp->stats.dam = 1;
81 83
… …
92 94
93 if (wand->inv && wand->inv->level) 95 if (wand->inv && wand->inv->level)
94 ncharges /= wand->inv->level; 96 ncharges /= wand->inv->level;
95 else 97 else
96 { 98 {
97 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is broken.", query_name (wand)); 99 op->failmsgf ("Your %s is broken.", query_name (wand));
98 return 0; 100 return 0;
99 } 101 }
100 102
101 if (!ncharges) 103 if (!ncharges)
102 ncharges = 1; 104 ncharges = 1;
103 105
104 wand->stats.food += ncharges; 106 wand->stats.food += ncharges;
105 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand)); 107 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
106 108
107 if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE)) 109 if (wand->arch && wand->arch->flag [FLAG_ANIMATE])
108 { 110 {
109 SET_FLAG (wand, FLAG_ANIMATE); 111 wand->set_flag (FLAG_ANIMATE);
110 wand->set_speed (wand->arch->speed); 112 wand->set_speed (wand->arch->speed);
111 } 113 }
112 114
113 return 1; 115 return 1;
114} 116}
… …
122 * The # of arrows created also goes up with level, so if a 30th level mage 124 * The # of arrows created also goes up with level, so if a 30th level mage
123 * wants LOTS of arrows, and doesn't care what the plus is he could 125 * wants LOTS of arrows, and doesn't care what the plus is he could
124 * create nonnmagic arrows, or even -1, etc... 126 * create nonnmagic arrows, or even -1, etc...
125 */ 127 */
126int 128int
127cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg) 129cast_create_missile (object *op, object *caster, object *spell, int dir, const char *spellparam)
128{ 130{
129 int bonus_plus = 0; 131 int bonus_plus = 0;
130 const char *missile_name = "arrow"; 132 const char *missile_name = "arrow";
131 133
132 for (object *tmp = op->inv; tmp; tmp = tmp->below) 134 for (object *tmp = op->inv; tmp; tmp = tmp->below)
133 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED)) 135 if (tmp->type == BOW && tmp->flag [FLAG_APPLIED])
134 missile_name = tmp->race; 136 missile_name = tmp->race;
135 137
136 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell); 138 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
137 139
138 archetype *missile_arch = archetype::find (missile_name); 140 archetype *missile_arch = archetype::find (missile_name);
… …
143 return 0; 145 return 0;
144 } 146 }
145 147
146 object *missile = missile_arch->instance (); 148 object *missile = missile_arch->instance ();
147 149
148 if (stringarg) 150 if (spellparam)
149 { 151 {
150 /* If it starts with a letter, presume it is a description */ 152 /* If it starts with a letter, presume it is a description */
151 if (isalpha (*stringarg)) 153 if (isalpha (*spellparam))
152 { 154 {
153 artifact *al = find_artifactlist (missile->type)->items; 155 artifact *al = find_artifactlist (missile->type)->items;
154 156
155 for (; al; al = al->next) 157 for (; al; al = al->next)
156 if (!strcasecmp (al->item->name, stringarg)) 158 if (!strcasecmp (al->item->name, spellparam))
157 break; 159 break;
158 160
159 if (!al) 161 if (!al)
160 { 162 {
161 missile->destroy (); 163 missile->destroy ();
162 new_draw_info_format (NDI_UNIQUE, 0, op, "No such object %ss of %s", missile_name, stringarg); 164 op->failmsgf ("No such object %ss of %s", missile_name, spellparam);
163 return 0; 165 return 0;
164 } 166 }
165 167
166 if (al->item->slaying) 168 if (al->item->slaying)
167 { 169 {
168 missile->destroy (); 170 missile->destroy ();
169 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg); 171 op->failmsgf ("You are not allowed to create %ss of %s", missile_name, spellparam);
170 return 0; 172 return 0;
171 } 173 }
172 174
173 give_artifact_abilities (missile, al->item); 175 give_artifact_abilities (missile, al->item);
174 /* These special arrows cost something extra. Don't have them also be magical - 176 /* These special arrows cost something extra. Don't have them also be magical -
… …
176 * the parsing of having to do both plus and type. 178 * the parsing of having to do both plus and type.
177 */ 179 */
178 bonus_plus = 1 + (al->item->value / 5); 180 bonus_plus = 1 + (al->item->value / 5);
179 missile_plus = 0; 181 missile_plus = 0;
180 } 182 }
181 else if (atoi (stringarg) < missile_plus) 183 else if (atoi (spellparam) < missile_plus)
182 missile_plus = atoi (stringarg); 184 missile_plus = atoi (spellparam);
183 } 185 }
184 186
185 missile_plus = clamp (missile_plus, -4, 4); 187 missile_plus = clamp (missile_plus, -4, 4);
186 188
187 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell); 189 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
… …
192 194
193 missile->magic = missile_plus; 195 missile->magic = missile_plus;
194 /* Can't get any money for these objects */ 196 /* Can't get any money for these objects */
195 missile->value = 0; 197 missile->value = 0;
196 198
197 SET_FLAG (missile, FLAG_IDENTIFIED); 199 missile->set_flag (FLAG_IDENTIFIED);
198 200
199 if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !missile->destroyed ()) 201 if (!cast_create_obj (op, caster, missile, dir) && op->type == PLAYER && !missile->destroyed ())
200 pick_up (op, missile); 202 pick_up (op, missile);
201 203
202 return 1; 204 return 1;
203} 205}
204 206
205 207
206/* allows the choice of what sort of food object to make. 208/* allows the choice of what sort of food object to make.
207 * If stringarg is NULL, it will create food dependent on level --PeterM*/ 209 * If spellparam is NULL, it will create food dependent on level --PeterM*/
208int 210int
209cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *stringarg) 211cast_create_food (object *op, object *caster, object *spell_ob, int dir, const char *spellparam)
210{ 212{
211 int food_value; 213 int food_value;
212 archetype *at = NULL; 214 archetype *at = NULL;
213 object *new_op; 215 object *new_op;
214 216
215 food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob); 217 food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);
216 218
217 if (stringarg) 219 if (spellparam)
218 { 220 {
219 at = find_archetype_by_object_type_name (FOOD, stringarg); 221 at = find_archetype_by_object_type_name (FOOD, spellparam);
220 if (at == NULL) 222 if (at == NULL)
221 at = find_archetype_by_object_type_name (DRINK, stringarg); 223 at = find_archetype_by_object_type_name (DRINK, spellparam);
222 if (at == NULL || at->stats.food > food_value) 224 if (at == NULL || at->stats.food > food_value)
223 stringarg = NULL; 225 spellparam = NULL;
224 } 226 }
225 227
226 if (!stringarg) 228 if (!spellparam)
227 { 229 {
228 archetype *at_tmp; 230 archetype *at_tmp;
229 231
230 /* We try to find the archetype with the maximum food value. 232 /* We try to find the archetype with the maximum food value.
231 * This removes the dependancy of hard coded food values in this 233 * This removes the dependancy of hard coded food values in this
… …
256 /* Pretty unlikely (there are some very low food items), but you never 258 /* Pretty unlikely (there are some very low food items), but you never
257 * know 259 * know
258 */ 260 */
259 if (!at) 261 if (!at)
260 { 262 {
261 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food."); 263 op->failmsgf ("You don't have enough experience to create any food.");
262 return 0; 264 return 0;
263 } 265 }
264 266
265 food_value /= at->stats.food; 267 food_value /= at->stats.food;
266 new_op = arch_to_object (at); 268 new_op = at->instance ();
267 new_op->nrof = food_value; 269 new_op->nrof = food_value;
268 270
269 new_op->value = 0; 271 new_op->value = 0;
270 if (new_op->nrof < 1) 272 if (new_op->nrof < 1)
271 new_op->nrof = 1; 273 new_op->nrof = 1;
… …
296 mflags = get_map_flags (m, &m, x, y, &x, &y); 298 mflags = get_map_flags (m, &m, x, y, &x, &y);
297 299
298 if (mflags & P_OUT_OF_MAP) 300 if (mflags & P_OUT_OF_MAP)
299 break; 301 break;
300 302
301 if (!QUERY_FLAG (op, FLAG_WIZCAST) && (mflags & P_NO_MAGIC)) 303 if (!op->flag [FLAG_WIZCAST] && (mflags & P_NO_MAGIC))
302 { 304 {
303 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic."); 305 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks your magic.");
304 return 0; 306 return 0;
305 } 307 }
308
306 if (mflags & P_IS_ALIVE) 309 if (mflags & P_IS_ALIVE)
307 { 310 {
308 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = tmp->above) 311 for (tmp = GET_MAP_OB (m, x, y); tmp; tmp = tmp->above)
309 if (QUERY_FLAG (tmp, FLAG_ALIVE) && (tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER))) 312 if (tmp->flag [FLAG_ALIVE] && (tmp->type == PLAYER || tmp->flag [FLAG_MONSTER]))
310 { 313 {
311 new_draw_info (NDI_UNIQUE, 0, op, "You detect something."); 314 new_draw_info (NDI_UNIQUE, 0, op, "You detect something.");
312 if (tmp->head != NULL) 315 if (tmp->head != NULL)
313 tmp = tmp->head; 316 tmp = tmp->head;
314 examine_monster (op, tmp); 317 examine_monster (op, tmp);
… …
337 if (pl->type == PLAYER) 340 if (pl->type == PLAYER)
338 { 341 {
339 /* If race isn't set, then invisible unless it is undead */ 342 /* If race isn't set, then invisible unless it is undead */
340 if (!pl->contr->invis_race) 343 if (!pl->contr->invis_race)
341 { 344 {
342 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 345 if (mon->flag [FLAG_UNDEAD])
343 return 0; 346 return 0;
344 347
345 return 1; 348 return 1;
346 } 349 }
347 350
348 /* invis_race is set if we get here */ 351 /* invis_race is set if we get here */
349 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon)) 352 if (pl->contr->invis_race == shstr_undead && is_true_undead (mon))
350 return 1; 353 return 1;
351 354
352 /* No race, can't be invisible to it */ 355 /* No race, can't be invisible to it */
353 if (!mon->race) 356 if (!mon->race)
354 return 0; 357 return 0;
355 358
356 if (strstr (mon->race, pl->contr->invis_race)) 359 if (mon->race.contains (pl->contr->invis_race))
357 return 1; 360 return 1;
358 361
359 /* Nothing matched above, return 0 */ 362 /* Nothing matched above, return 0 */
360 return 0; 363 return 0;
361 } 364 }
… …
378int 381int
379cast_invisible (object *op, object *caster, object *spell_ob) 382cast_invisible (object *op, object *caster, object *spell_ob)
380{ 383{
381 if (op->invisible > 1000) 384 if (op->invisible > 1000)
382 { 385 {
383 new_draw_info (NDI_UNIQUE, 0, op, "You can not extend the duration of your invisibility any further"); 386 op->failmsg ("You can not extend the duration of your invisibility any further");
384 return 0; 387 return 0;
385 } 388 }
386 389
387 /* Remove the switch with 90% duplicate code - just handle the differences with 390 /* Remove the switch with 90% duplicate code - just handle the differences with
388 * and if statement or two. 391 * and if statement or two.
… …
394 397
395 if (op->type == PLAYER) 398 if (op->type == PLAYER)
396 { 399 {
397 op->contr->invis_race = spell_ob->race; 400 op->contr->invis_race = spell_ob->race;
398 401
399 if (QUERY_FLAG (spell_ob, FLAG_MAKE_INVIS)) 402 if (spell_ob->flag [FLAG_MAKE_INVIS])
400 op->contr->tmp_invis = 0; 403 op->contr->tmp_invis = 0;
401 else 404 else
402 op->contr->tmp_invis = 1; 405 op->contr->tmp_invis = 1;
403 406
404 op->contr->hidden = 0; 407 op->contr->hidden = 0;
… …
424/* earth to dust spell. Basically destroys earthwalls in the area. 427/* earth to dust spell. Basically destroys earthwalls in the area.
425 */ 428 */
426int 429int
427cast_earth_to_dust (object *op, object *caster, object *spell_ob) 430cast_earth_to_dust (object *op, object *caster, object *spell_ob)
428{ 431{
429 object *tmp, *next;
430 int range, i, j, mflags; 432 int range, i, j, mflags;
431 sint16 sx, sy; 433 sint16 sx, sy;
432 maptile *m; 434 maptile *m;
433
434 if (op->type != PLAYER)
435 return 0;
436 435
437 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 436 range = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
438 437
439 for (i = -range; i <= range; i++) 438 for (i = -range; i <= range; i++)
440 for (j = -range; j <= range; j++) 439 for (j = -range; j <= range; j++)
… …
445 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy); 444 mflags = get_map_flags (m, &m, sx, sy, &sx, &sy);
446 445
447 if (mflags & P_OUT_OF_MAP) 446 if (mflags & P_OUT_OF_MAP)
448 continue; 447 continue;
449 448
450 // earth to dust tears down everything that can be teared down 449 // earth to dust tears down everything that can be torn down
451 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = next) 450 for (object *next, *tmp = m->at (sx, sy).bot; tmp; tmp = next)
452 { 451 {
453 next = tmp->above; 452 next = tmp->above;
454 if (QUERY_FLAG (tmp, FLAG_TEAR_DOWN)) 453
454 if (tmp->flag [FLAG_TEAR_DOWN])
455 hit_player (tmp, 9998, op, AT_PHYSICAL, 0); 455 hit_player (tmp, 9998, op, AT_PHYSICAL, 0);
456 } 456 }
457 } 457 }
458 458
459 return 1; 459 return 1;
… …
461 461
462void 462void
463execute_word_of_recall (object *op) 463execute_word_of_recall (object *op)
464{ 464{
465 if (object *pl = op->in_player ()) 465 if (object *pl = op->in_player ())
466 {
467 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST)) 466 if (pl->ms ().flags () & P_NO_CLERIC && !pl->flag [FLAG_WIZCAST])
468 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you."); 467 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
469 else 468 else
470 pl->player_goto (op->slaying, op->stats.hp, op->stats.sp); 469 pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);
471 }
472 470
473 op->destroy (); 471 op->destroy ();
474} 472}
475 473
476/* Word of recall causes the player to return 'home'. 474/* Word of recall causes the player to return 'home'.
… …
478 * time delay effect. 476 * time delay effect.
479 */ 477 */
480int 478int
481cast_word_of_recall (object *op, object *caster, object *spell_ob) 479cast_word_of_recall (object *op, object *caster, object *spell_ob)
482{ 480{
483 object *dummy; 481 if (!op->is_player ())
484 int time;
485
486 if (op->type != PLAYER)
487 return 0; 482 return 0;
488 483
489 if (find_obj_by_type_subtype (op, SPELL_EFFECT, SP_WORD_OF_RECALL)) 484 if (find_obj_by_type_subtype (op, SPELL_EFFECT, SP_WORD_OF_RECALL))
490 { 485 {
491 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 486 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
492 return 1; 487 return 1;
493 } 488 }
494 489
495 dummy = get_archetype (FORCE_NAME); 490 object *dummy = get_archetype (FORCE_NAME);
496 if (dummy == NULL)
497 {
498 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
499 LOG (llevError, "cast_word_of_recall: get_archetype(force) failed!\n");
500 return 0;
501 }
502 491
503 time = spell_ob->duration - SP_level_duration_adjust (caster, spell_ob); 492 int time = max (1, spell_ob->duration - SP_level_duration_adjust (caster, spell_ob));
504 if (time < 1)
505 time = 1;
506 493
507 /* value of speed really doesn't make much difference, as long as it is 494 /* value of speed really doesn't make much difference, as long as it is
508 * positive. Lower value may be useful so that the problem doesn't 495 * positive. Lower value may be useful so that the problem doesn't
509 * do anything really odd if it say a -1000 or something. 496 * do anything really odd if it say a -1000 or something.
510 */ 497 */
511 dummy->set_speed (0.002); 498 dummy->set_speed (0.002);
512 dummy->speed_left = -dummy->speed * time; 499 dummy->speed_left = -dummy->speed * time;
513 dummy->type = SPELL_EFFECT; 500 dummy->type = SPELL_EFFECT;
514 dummy->subtype = SP_WORD_OF_RECALL; 501 dummy->subtype = SP_WORD_OF_RECALL;
515 502 dummy->slaying = op->contr->savebed_map;
516 /* If we could take advantage of enter_player_savebed() here, it would be 503 dummy->stats.hp = op->contr->bed_x;
517 * nice, but until the map load fails, we can't. 504 dummy->stats.sp = op->contr->bed_y;
518 */
519 EXIT_PATH (dummy) = op->contr->savebed_map;
520 EXIT_X (dummy) = op->contr->bed_x;
521 EXIT_Y (dummy) = op->contr->bed_y;
522 505
523 op->insert (dummy); 506 op->insert (dummy);
524 507
525 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you."); 508 new_draw_info (NDI_UNIQUE, 0, op, "You feel a force starting to build up inside you.");
526 509
… …
565 548
566int 549int
567perceive_self (object *op) 550perceive_self (object *op)
568{ 551{
569 const char *cp = describe_item (op, op); 552 const char *cp = describe_item (op, op);
570 archetype *at = archetype::find (ARCH_DEPLETION); 553 archetype *at = archetype::find (shstr_depletion);
571 554
572 dynbuf_text buf; 555 dynbuf_text &buf = msg_dynbuf; buf.clear ();
573 556
574 if (player *pl = op->contr) 557 if (!op->is_player ())
558 return 0;
559
575 if (object *race = archetype::find (op->race)) 560 if (object *race = archetype::find (op->race))
576 buf << "You are a " << (pl->gender ? "female" : "male") << " " << &race->name << ".\n"; 561 buf << " - You are a G<male|female> " << &race->name << ".\n";
577 562
578 if (object *god = find_god (determine_god (op))) 563 if (object *god = find_god (determine_god (op)))
579 buf << "You worship " << &god->name << ".\n"; 564 buf << " - You worship " << &god->name << ".\n";
580 else 565 else
581 buf << "You worship no god.\n"; 566 buf << " - You worship no god.\n";
582 567
583 object *tmp = present_arch_in_ob (at, op); 568 object *tmp = present_arch_in_ob (at, op);
584 569
585 if (*cp == '\0' && tmp == NULL) 570 if (*cp == '\0' && !tmp)
586 buf << "You feel very mundane. "; 571 buf << " - You feel very mundane. ";
587 else 572 else
588 { 573 {
589 buf << "You have: " << cp << ".\n"; 574 buf << " - You have: " << cp << ".\n";
590 575
591 if (tmp) 576 if (tmp)
592 for (int i = 0; i < NUM_STATS; i++) 577 for (int i = 0; i < NUM_STATS; i++)
593 if (tmp->stats.stat (i) < 0) 578 if (tmp->stats.stat (i) < 0)
594 buf.printf ("Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i)); 579 buf.printf (" - Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
595 } 580 }
596 581
597 if (is_dragon_pl (op)) 582 if (op->is_dragon ())
598 /* now grab the 'dragon_ability'-force from the player's inventory */ 583 /* now grab the 'dragon_ability'-force from the player's inventory */
599 for (tmp = op->inv; tmp; tmp = tmp->below) 584 for (tmp = op->inv; tmp; tmp = tmp->below)
600 { 585 {
601 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force) 586 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
602 { 587 {
603 if (tmp->stats.exp == 0) 588 if (tmp->stats.exp == 0)
604 buf << "Your metabolism isn't focused on anything.\n"; 589 buf << " - Your metabolism isn't focused on anything.\n";
605 else 590 else
606 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n"; 591 buf << " - Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
607 592
608 break; 593 break;
609 } 594 }
610 } 595 }
611 596
612 buf << '\0'; // zero-terminate 597 op->contr->infobox (MSG_CHANNEL ("perceiveself"), buf);
613
614 new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ());
615 598
616 return 1; 599 return 1;
617} 600}
618 601
619/* This creates magic walls. Really, it can create most any object, 602/* This creates magic walls. Really, it can create most any object,
… …
645 628
646 if ((spell_ob->move_block || x != op->x || y != op->y) && 629 if ((spell_ob->move_block || x != op->x || y != op->y) &&
647 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) || 630 (get_map_flags (m, &m, x, y, &x, &y) & (P_OUT_OF_MAP | P_IS_ALIVE) ||
648 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block))) 631 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) == spell_ob->move_block)))
649 { 632 {
650 new_draw_info (NDI_UNIQUE, 0, op, "Something is in the way."); 633 op->failmsg ("Something is in the way.");
651 return 0; 634 return 0;
652 } 635 }
653 636
654 if (spell_ob->other_arch) 637 if (spell_ob->other_arch)
655 tmp = arch_to_object (spell_ob->other_arch); 638 tmp = spell_ob->other_arch->instance ();
656 else if (spell_ob->race) 639 else if (spell_ob->race)
657 { 640 {
658 char buf1[MAX_BUF]; 641 char buf1[MAX_BUF];
659 642
660 sprintf (buf1, spell_ob->race, dir); 643 sprintf (buf1, spell_ob->race, dir);
… …
664 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1); 647 LOG (llevError, "summon_wall: Unable to find archetype %s\n", buf1);
665 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken."); 648 new_draw_info (NDI_UNIQUE, 0, op, "This spell is broken.");
666 return 0; 649 return 0;
667 } 650 }
668 651
669 tmp = arch_to_object (at); 652 tmp = at->instance ();
670 } 653 }
671 else 654 else
672 { 655 {
673 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name); 656 LOG (llevError, "magic_wall: spell %s lacks other_arch\n", &spell_ob->name);
674 return 0; 657 return 0;
… …
679 tmp->attacktype = spell_ob->attacktype; 662 tmp->attacktype = spell_ob->attacktype;
680 tmp->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 663 tmp->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
681 tmp->stats.dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 664 tmp->stats.dam = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
682 tmp->range = 0; 665 tmp->range = 0;
683 } 666 }
684 else if (QUERY_FLAG (tmp, FLAG_ALIVE)) 667 else if (tmp->flag [FLAG_ALIVE])
685 { 668 {
686 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 669 tmp->stats.hp = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
687 tmp->stats.maxhp = tmp->stats.hp; 670 tmp->stats.maxhp = tmp->stats.hp;
688 } 671 }
689 672
690 if (QUERY_FLAG (spell_ob, FLAG_IS_USED_UP) || QUERY_FLAG (tmp, FLAG_IS_USED_UP)) 673 if (spell_ob->flag [FLAG_IS_USED_UP] || tmp->flag [FLAG_IS_USED_UP])
691 { 674 {
692 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob); 675 tmp->stats.food = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob);
693 SET_FLAG (tmp, FLAG_IS_USED_UP); 676 tmp->set_flag (FLAG_IS_USED_UP);
694 } 677 }
695 678
696 if (QUERY_FLAG (spell_ob, FLAG_TEAR_DOWN)) 679 if (spell_ob->flag [FLAG_TEAR_DOWN])
697 { 680 {
698 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob); 681 tmp->stats.hp = spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob);
699 tmp->stats.maxhp = tmp->stats.hp; 682 tmp->stats.maxhp = tmp->stats.hp;
700 SET_FLAG (tmp, FLAG_TEAR_DOWN); 683 tmp->set_flag (FLAG_TEAR_DOWN);
701 SET_FLAG (tmp, FLAG_ALIVE); 684 tmp->set_flag (FLAG_ALIVE);
702 } 685 }
703 686
704 /* This can't really hurt - if the object doesn't kill anything, 687 /* This can't really hurt - if the object doesn't kill anything,
705 * these fields just won't be used. Do not set the owner for 688 * these fields just won't be used. Do not set the owner for
706 * earthwalls, though, so they survive restarts. 689 * earthwalls, though, so they survive restarts.
707 */ 690 */
708 if (tmp->type != EARTHWALL) //TODO 691 if (tmp->type != EARTHWALL) //TODO
709 tmp->set_owner (op); 692 tmp->set_owner (op);
710 693
711 set_spell_skill (op, caster, spell_ob, tmp); 694 set_spell_skill (op, caster, spell_ob, tmp);
712 tmp->level = caster_level (caster, spell_ob) / 2; 695 tmp->level = casting_level (caster, spell_ob) / 2;
713 696
714 name = tmp->name; 697 name = tmp->name;
715 if (!(tmp = m->insert (tmp, x, y, op))) 698 if (!(tmp = m->insert (tmp, x, y, op)))
716 { 699 {
717 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name); 700 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
718 return 0; 701 return 0;
719 } 702 }
720 703
721 /* If this is a spellcasting wall, need to insert the spell object */ 704 /* If this is a spellcasting wall, need to insert the spell object */
722 if (tmp->other_arch && tmp->other_arch->type == SPELL) 705 if (tmp->other_arch && tmp->other_arch->type == SPELL)
723 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp); 706 insert_ob_in_ob (tmp->other_arch->instance (), tmp);
724 707
725 /* This code causes the wall to extend some distance in 708 /* This code causes the wall to extend some distance in
726 * each direction, or until an obstruction is encountered. 709 * each direction, or until an obstruction is encountered.
727 * posblocked and negblocked help determine how far the 710 * posblocked and negblocked help determine how far the
728 * created wall can extend, it won't go extend through 711 * created wall can extend, it won't go extend through
… …
748 object *tmp2 = tmp->clone (); 731 object *tmp2 = tmp->clone ();
749 m->insert (tmp2, x, y, op); 732 m->insert (tmp2, x, y, op);
750 733
751 /* If this is a spellcasting wall, need to insert the spell object */ 734 /* If this is a spellcasting wall, need to insert the spell object */
752 if (tmp2->other_arch && tmp2->other_arch->type == SPELL) 735 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
753 tmp2->insert (arch_to_object (tmp2->other_arch)); 736 tmp2->insert (tmp2->other_arch->instance ());
754 737
755 } 738 }
756 else 739 else
757 posblocked = 1; 740 posblocked = 1;
758 741
… …
765 { 748 {
766 object *tmp2 = tmp->clone (); 749 object *tmp2 = tmp->clone ();
767 m->insert (tmp2, x, y, op); 750 m->insert (tmp2, x, y, op);
768 751
769 if (tmp2->other_arch && tmp2->other_arch->type == SPELL) 752 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
770 tmp2->insert (arch_to_object (tmp2->other_arch)); 753 tmp2->insert (tmp2->other_arch->instance ());
771 } 754 }
772 else 755 else
773 negblocked = 1; 756 negblocked = 1;
774 } 757 }
775 758
776 if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) 759 if (tmp->flag [FLAG_BLOCKSVIEW])
777 update_all_los (op->map, op->x, op->y); 760 update_all_los (op->map, op->x, op->y);
778 761
779 return 1; 762 return 1;
780} 763}
781 764
782int 765int
783dimension_door (object *op, object *caster, object *spob, int dir) 766dimension_door (object *op, object *caster, object *spob, int dir, const char *spellparam)
784{ 767{
785 uint32 dist, maxdist; 768 uint32 dist, maxdist;
786 int mflags; 769 int mflags;
787 maptile *m; 770 maptile *m;
788 sint16 sx, sy; 771 sint16 sx, sy;
… …
790 if (op->type != PLAYER) 773 if (op->type != PLAYER)
791 return 0; 774 return 0;
792 775
793 if (!dir) 776 if (!dir)
794 { 777 {
795 new_draw_info (NDI_UNIQUE, 0, op, "In what direction?"); 778 op->failmsg ("In what direction?");
796 return 0; 779 return 0;
797 } 780 }
798 781
799 /* Given the new outdoor maps, can't let players dimension door for 782 /* Given the new outdoor maps, can't let players dimension door for
800 * ever, so put limits in. 783 * ever, so put limits in.
801 */ 784 */
802 maxdist = spob->range + SP_level_range_adjust (caster, spob); 785 maxdist = spob->range + SP_level_range_adjust (caster, spob);
803 786
804 if (op->contr->count) 787 if (spellparam)
805 { 788 {
789 int count = atoi (spellparam);
790
806 if (op->contr->count > maxdist) 791 if (count > maxdist)
807 { 792 {
808 new_draw_info (NDI_UNIQUE, 0, op, "You can't dimension door that far!"); 793 op->failmsg ("You can't dimension door that far!");
809 return 0; 794 return 0;
810 } 795 }
811 796
812 for (dist = 0; dist < op->contr->count; dist++) 797 for (dist = 0; dist < count; dist++)
813 { 798 {
814 mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy); 799 mflags = get_map_flags (op->map, &m, op->x + freearr_x[dir] * (dist + 1), op->y + freearr_y[dir] * (dist + 1), &sx, &sy);
815 800
816 if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP)) 801 if (mflags & (P_NO_MAGIC | P_OUT_OF_MAP))
817 break; 802 break;
818 803
819 if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy))) 804 if ((mflags & P_BLOCKSVIEW) && OB_TYPE_MOVE_BLOCK (op, GET_MAP_MOVE_BLOCK (m, sx, sy)))
820 break; 805 break;
821 } 806 }
822 807
823 if (dist < op->contr->count) 808 if (dist < count)
824 { 809 {
825 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n"); 810 new_draw_info (NDI_UNIQUE, 0, op, "Something blocks the magic of the spell.\n");
826 op->contr->count = 0;
827 return 0; 811 return 0;
828 } 812 }
829
830 op->contr->count = 0;
831 813
832 /* Remove code that puts player on random space on maps. IMO, 814 /* Remove code that puts player on random space on maps. IMO,
833 * a lot of maps probably have areas the player should not get to, 815 * a lot of maps probably have areas the player should not get to,
834 * but may not be marked as NO_MAGIC (as they may be bounded 816 * but may not be marked as NO_MAGIC (as they may be bounded
835 * by such squares). Also, there are probably treasure rooms and 817 * by such squares). Also, there are probably treasure rooms and
… …
877 break; 859 break;
878 860
879 } 861 }
880 if (!dist) 862 if (!dist)
881 { 863 {
882 new_draw_info (NDI_UNIQUE, 0, op, "Your spell failed!\n"); 864 op->failmsg ("Your spell failed!\n");
883 return 0; 865 return 0;
884 } 866 }
885 } 867 }
886 868
887 /* Actually move the player now */ 869 /* Actually move the player now */
888 if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op))) 870 if (!(op = op->map->insert (op, op->x + freearr_x[dir] * dist, op->y + freearr_y[dir] * dist, op)))
889 return 1; 871 return 1;
890 872
891 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 873 op->speed_left = -5. * op->speed; /* Freeze them for a short while */
874
892 return 1; 875 return 1;
893} 876}
894 877
895/* cast_heal: Heals something. 878/* cast_heal: Heals something.
896 * op is the caster. 879 * op is the caster.
… …
951 if (cure_disease (tmp, op, spell)) 934 if (cure_disease (tmp, op, spell))
952 success = 1; 935 success = 1;
953 936
954 if (spell->attacktype & AT_POISON) 937 if (spell->attacktype & AT_POISON)
955 { 938 {
956 at = archetype::find ("poisoning"); 939 at = archetype::find (shstr_poisoning);
957 poison = present_arch_in_ob (at, tmp); 940 poison = present_arch_in_ob (at, tmp);
958 if (poison) 941 if (poison)
959 { 942 {
960 success = 1; 943 success = 1;
961 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed"); 944 new_draw_info (NDI_UNIQUE, 0, tmp, "Your body feels cleansed");
… …
963 } 946 }
964 } 947 }
965 948
966 if (spell->attacktype & AT_CONFUSION) 949 if (spell->attacktype & AT_CONFUSION)
967 { 950 {
968 poison = present_in_ob_by_name (FORCE, "confusion", tmp); 951 poison = present_in_ob_by_name (FORCE, shstr_confusion, tmp);
969 if (poison) 952 if (poison)
970 { 953 {
971 success = 1; 954 success = 1;
972 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer"); 955 new_draw_info (NDI_UNIQUE, 0, tmp, "Your mind feels clearer");
973 poison->duration = 1; 956 poison->duration = 1;
974 } 957 }
975 } 958 }
976 959
977 if (spell->attacktype & AT_BLIND) 960 if (spell->attacktype & AT_BLIND)
978 { 961 {
979 at = archetype::find ("blindness"); 962 at = archetype::find (shstr_blindness);
980 poison = present_arch_in_ob (at, tmp); 963 poison = present_arch_in_ob (at, tmp);
981 if (poison) 964 if (poison)
982 { 965 {
983 success = 1; 966 success = 1;
984 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return."); 967 new_draw_info (NDI_UNIQUE, 0, tmp, "Your vision begins to return.");
… …
1002 tmp->stats.grace = tmp->stats.maxgrace; 985 tmp->stats.grace = tmp->stats.maxgrace;
1003 success = 1; 986 success = 1;
1004 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!"); 987 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel redeemed with your god!");
1005 } 988 }
1006 989
1007 if (spell->stats.food && tmp->stats.food < 999) 990 if (spell->stats.food && tmp->stats.food < MAX_FOOD)
1008 { 991 {
1009 tmp->stats.food += spell->stats.food; 992 tmp->stats.food += spell->stats.food;
1010 993 min_it (tmp->stats.food, MAX_FOOD);
1011 if (tmp->stats.food > 999)
1012 tmp->stats.food = 999;
1013 994
1014 success = 1; 995 success = 1;
1015 /* We could do something a bit better like the messages for healing above */ 996 /* We could do something a bit better like the messages for healing above */
1016 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 997 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1017 } 998 }
… …
1032 "You don't feel any more powerful." 1013 "You don't feel any more powerful."
1033 "You are no easier to look at.", 1014 "You are no easier to look at.",
1034}; 1015};
1035 1016
1036int 1017int
1018change_ability_duration (object *spell, object *caster)
1019{
1020 return spell->duration + SP_level_duration_adjust (caster, spell) * 50;
1021}
1022
1023int
1037cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent) 1024cast_change_ability (object *op, object *caster, object *spell_ob, int dir, int silent)
1038{ 1025{
1039 object *force = NULL; 1026 object *force = 0;
1040 int i; 1027 int i;
1041 1028
1042 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1029 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1043 object *tmp = dir 1030 object *tmp = dir
1044 ? find_target_for_friendly_spell (op, dir) 1031 ? find_target_for_friendly_spell (op, dir)
1045 : op; 1032 : op;
1046 1033
1047 if (!tmp) 1034 if (!tmp)
1048 return 0; 1035 return 0;
1049 1036
1050 /* If we've already got a force of this type, don't add a new one. */ 1037 /* If we've already got a force of this type, don't add a new one. */
… …
1058 break; 1045 break;
1059 } 1046 }
1060 else if (spell_ob->race && spell_ob->race == tmp2->name) 1047 else if (spell_ob->race && spell_ob->race == tmp2->name)
1061 { 1048 {
1062 if (!silent) 1049 if (!silent)
1063 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl); 1050 op->failmsgf ("You can not cast %s while %s is in effect",
1051 &spell_ob->name, &tmp2->name_pl);
1052
1064 return 0; 1053 return 0;
1065 } 1054 }
1066 } 1055 }
1067 } 1056 }
1057
1058 int duration = change_ability_duration (spell_ob, caster);
1059
1068 if (force == NULL) 1060 if (force)
1069 {
1070 force = get_archetype (FORCE_NAME);
1071 force->subtype = FORCE_CHANGE_ABILITY;
1072 if (spell_ob->race)
1073 force->name = spell_ob->race;
1074 else
1075 force->name = spell_ob->name;
1076 force->name_pl = spell_ob->name;
1077 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
1078
1079 } 1061 {
1080 else
1081 {
1082 int duration;
1083
1084 duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1085 if (duration > force->duration) 1062 if (duration > force->duration)
1086 { 1063 {
1087 force->duration = duration; 1064 force->duration = duration;
1088 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 1065 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
1089 } 1066 }
1090 else 1067 else
1091 {
1092 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect."); 1068 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1093 }
1094 1069
1095 return 1; 1070 return 1;
1096 } 1071 }
1097 1072
1098 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1073 new_draw_info_format (NDI_UNIQUE, 0, op,
1074 "You create an aura of magical force. H<The effect will last for about %.10g seconds.>",
1075 TICK2TIME (duration));
1076
1077 force = get_archetype (FORCE_NAME);
1078 force->subtype = FORCE_CHANGE_ABILITY;
1079 force->duration = duration;
1080
1081 if (spell_ob->race)
1082 force->name = spell_ob->race;
1083 else
1084 force->name = spell_ob->name;
1085
1086 force->name_pl = spell_ob->name;
1087
1099 force->speed = 1.0; 1088 force->speed = 1.0;
1100 force->speed_left = -1.0; 1089 force->speed_left = -1.0;
1101 SET_FLAG (force, FLAG_APPLIED); 1090 force->set_flag (FLAG_APPLIED);
1102 1091
1103 /* Now start processing the effects. First, protections */ 1092 /* Now start processing the effects. First, protections */
1104 for (i = 0; i < NROFATTACKS; i++) 1093 for (i = 0; i < NROFATTACKS; i++)
1105 {
1106 if (spell_ob->resist[i]) 1094 if (spell_ob->resist[i])
1107 {
1108 force->resist[i] = spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob); 1095 force->resist[i] = min (100, spell_ob->resist[i] + SP_level_dam_adjust (caster, spell_ob));
1109 if (force->resist[i] > 100)
1110 force->resist[i] = 100;
1111 }
1112 }
1113 1096
1114 if (spell_ob->stats.hp) 1097 if (spell_ob->stats.hp)
1115 force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob); 1098 force->stats.hp = spell_ob->stats.hp + SP_level_dam_adjust (caster, spell_ob);
1116 1099
1117 if (tmp->type == PLAYER) 1100 if (tmp->type == PLAYER)
… …
1136 } 1119 }
1137 } 1120 }
1138 1121
1139 force->move_type = spell_ob->move_type; 1122 force->move_type = spell_ob->move_type;
1140 1123
1141 if (QUERY_FLAG (spell_ob, FLAG_SEE_IN_DARK)) 1124 if (spell_ob->flag [FLAG_SEE_IN_DARK])
1142 SET_FLAG (force, FLAG_SEE_IN_DARK); 1125 force->set_flag (FLAG_SEE_IN_DARK);
1143 1126
1144 if (QUERY_FLAG (spell_ob, FLAG_XRAYS)) 1127 if (spell_ob->flag [FLAG_XRAYS])
1145 SET_FLAG (force, FLAG_XRAYS); 1128 force->set_flag (FLAG_XRAYS);
1146 1129
1147 /* Haste/bonus speed */ 1130 /* Haste/bonus speed */
1148 if (spell_ob->stats.exp) 1131 if (spell_ob->stats.exp)
1149 { 1132 {
1150 if (op->speed > 0.5f) 1133 if (op->speed > 0.5f)
… …
1170 */ 1153 */
1171int 1154int
1172cast_bless (object *op, object *caster, object *spell_ob, int dir) 1155cast_bless (object *op, object *caster, object *spell_ob, int dir)
1173{ 1156{
1174 int i; 1157 int i;
1175 object *god = find_god (determine_god (op)), *tmp2, *force = NULL, *tmp; 1158 object *god = find_god (determine_god (op)), *force = NULL, *tmp;
1176 1159
1177 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */ 1160 /* if dir = 99 op defaults to tmp, eat_special_food() requires this. */
1178 if (dir != 0) 1161 if (dir != 0)
1179 { 1162 {
1180 tmp = find_target_for_friendly_spell (op, dir); 1163 tmp = find_target_for_friendly_spell (op, dir);
1164
1165 if (!tmp)
1166 return 0;
1181 } 1167 }
1182 else 1168 else
1183 {
1184 tmp = op; 1169 tmp = op;
1185 }
1186 1170
1187 /* If we've already got a force of this type, don't add a new one. */ 1171 /* If we've already got a force of this type, don't add a new one. */
1188 for (tmp2 = tmp->inv; tmp2 != NULL; tmp2 = tmp2->below) 1172 for (object *tmp2 = tmp->inv; tmp2; tmp2 = tmp2->below)
1189 { 1173 {
1190 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY) 1174 if (tmp2->type == FORCE && tmp2->subtype == FORCE_CHANGE_ABILITY)
1191 { 1175 {
1192 if (tmp2->name == spell_ob->name) 1176 if (tmp2->name == spell_ob->name)
1193 { 1177 {
… …
1199 new_draw_info_format (NDI_UNIQUE, 0, op, "You can not cast %s while %s is in effect", &spell_ob->name, &tmp2->name_pl); 1183 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 return 0; 1184 return 0;
1201 } 1185 }
1202 } 1186 }
1203 } 1187 }
1188
1204 if (force == NULL) 1189 if (force == NULL)
1205 { 1190 {
1206 force = get_archetype (FORCE_NAME); 1191 force = get_archetype (FORCE_NAME);
1207 force->subtype = FORCE_CHANGE_ABILITY; 1192 force->subtype = FORCE_CHANGE_ABILITY;
1208 if (spell_ob->race) 1193 if (spell_ob->race)
… …
1226 { 1211 {
1227 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect."); 1212 new_draw_info (NDI_UNIQUE, 0, op, "Recasting the spell had no effect.");
1228 } 1213 }
1229 return 0; 1214 return 0;
1230 } 1215 }
1216
1231 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50; 1217 force->duration = spell_ob->duration + SP_level_duration_adjust (caster, spell_ob) * 50;
1232 force->speed = 1.0; 1218 force->speed = 1.0;
1233 force->speed_left = -1.0; 1219 force->speed_left = -1.0;
1234 SET_FLAG (force, FLAG_APPLIED); 1220 force->set_flag (FLAG_APPLIED);
1235 1221
1236 if (!god) 1222 if (!god)
1237 { 1223 {
1238 new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty."); 1224 new_draw_info (NDI_UNIQUE, 0, op, "Your blessing seems empty.");
1239 } 1225 }
1240 else 1226 else
1241 { 1227 {
1242 /* Only give out good benefits, and put a max on it */ 1228 /* Only give out good benefits, and put a max on it */
1243 for (i = 0; i < NROFATTACKS; i++) 1229 for (i = 0; i < NROFATTACKS; i++)
1244 {
1245 if (god->resist[i] > 0) 1230 if (god->resist[i] > 0)
1246 {
1247 force->resist[i] = MIN (god->resist[i], spell_ob->resist[ATNR_GODPOWER]); 1231 force->resist[i] = min (god->resist[i], spell_ob->resist[ATNR_GODPOWER]);
1248 } 1232
1249 }
1250 force->path_attuned |= god->path_attuned; 1233 force->path_attuned |= god->path_attuned;
1251 1234
1252 if (spell_ob->attacktype) 1235 if (spell_ob->attacktype)
1253 force->slaying = god->slaying; 1236 force->slaying = god->slaying;
1254 1237
… …
1296 * the nuggets, alchemy the gold from that, etc. 1279 * the nuggets, alchemy the gold from that, etc.
1297 * Otherwise, give 9 silver on the gold for other objects, 1280 * Otherwise, give 9 silver on the gold for other objects,
1298 * so that it would still be more affordable to haul 1281 * so that it would still be more affordable to haul
1299 * the stuff back to town. 1282 * the stuff back to town.
1300 */ 1283 */
1301 if (QUERY_FLAG (obj, FLAG_UNPAID)) 1284 if (obj->flag [FLAG_UNPAID])
1302 value = 0; 1285 value = 0;
1303 else if (obj->type == MONEY || obj->type == GEM) 1286 else if (obj->type == MONEY || obj->type == GEM)
1304 value /= 3; 1287 value /= 3;
1305 else 1288 else
1306 value = value * 9 / 10; 1289 value = value * 9 / 10;
… …
1319 if (op->type != PLAYER) 1302 if (op->type != PLAYER)
1320 return 0; 1303 return 0;
1321 1304
1322 archetype *nugget[3]; 1305 archetype *nugget[3];
1323 1306
1324 nugget[0] = archetype::find ("pyrite3"); 1307 nugget[0] = archetype::find (shstr_pyrite3);
1325 nugget[1] = archetype::find ("pyrite2"); 1308 nugget[1] = archetype::find (shstr_pyrite2);
1326 nugget[2] = archetype::find ("pyrite"); 1309 nugget[2] = archetype::find (shstr_pyrite);
1327 1310
1328 /* Put a maximum weight of items that can be alchemised. Limits the power 1311 /* Put a maximum weight of items that can be alchemised. Limits the power
1329 * some, and also prevents people from alchemising every table/chair/clock 1312 * some, and also prevents people from alchemising every table/chair/clock
1330 * in sight 1313 * in sight
1331 */ 1314 */
… …
1360 1343
1361 for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next) 1344 for (object *next, *tmp = mp->at (nx, ny).bot; tmp; tmp = next)
1362 { 1345 {
1363 next = tmp->above; 1346 next = tmp->above;
1364 1347
1365 if (tmp->weight > 0 && !QUERY_FLAG (tmp, FLAG_NO_PICK) && 1348 if (tmp->weight > 0 && !tmp->flag [FLAG_NO_PICK] &&
1366 !QUERY_FLAG (tmp, FLAG_ALIVE) && !QUERY_FLAG (tmp, FLAG_IS_CAULDRON)) 1349 !tmp->flag [FLAG_ALIVE] && !tmp->flag [FLAG_IS_CAULDRON])
1367 { 1350 {
1368 if (tmp->inv) 1351 if (tmp->inv)
1369 { 1352 {
1370 object *next1, *tmp1; 1353 object *next1, *tmp1;
1371 1354
1372 for (tmp1 = tmp->inv; tmp1; tmp1 = next1) 1355 for (tmp1 = tmp->inv; tmp1; tmp1 = next1)
1373 { 1356 {
1374 next1 = tmp1->below; 1357 next1 = tmp1->below;
1375 if (tmp1->weight > 0 && !QUERY_FLAG (tmp1, FLAG_NO_PICK) && 1358 if (tmp1->weight > 0 && !tmp1->flag [FLAG_NO_PICK] &&
1376 !QUERY_FLAG (tmp1, FLAG_ALIVE) && !QUERY_FLAG (tmp1, FLAG_IS_CAULDRON)) 1359 !tmp1->flag [FLAG_ALIVE] && !tmp1->flag [FLAG_IS_CAULDRON])
1377 alchemy_object (tmp1, value, weight); 1360 alchemy_object (tmp1, value, weight);
1378 } 1361 }
1379 } 1362 }
1380 1363
1381 alchemy_object (tmp, value, weight); 1364 alchemy_object (tmp, value, weight);
… …
1386 } 1369 }
1387 1370
1388 value -= rndm (value >> 4); 1371 value -= rndm (value >> 4);
1389 value = min (value, value_max); 1372 value = min (value, value_max);
1390 1373
1391 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i) 1374 for (int i = 0; i < array_length (nugget); ++i)
1392 if (int nrof = value / nugget [i]->value) 1375 if (int nrof = value / nugget [i]->value)
1393 { 1376 {
1394 value -= nrof * nugget[i]->value; 1377 value -= nrof * nugget[i]->value;
1395 1378
1396 object *tmp = arch_to_object (nugget[i]); 1379 object *tmp = nugget[i]->instance ();
1397 tmp->nrof = nrof; 1380 tmp->nrof = nrof;
1398 tmp->flag [FLAG_IDENTIFIED] = true; 1381 tmp->flag [FLAG_IDENTIFIED] = true;
1399 op->map->insert (tmp, x, y, op, 0); 1382 op->map->insert (tmp, x, y, op, 0);
1400 } 1383 }
1401 1384
… …
1412 * items. 1395 * items.
1413 */ 1396 */
1414int 1397int
1415remove_curse (object *op, object *caster, object *spell) 1398remove_curse (object *op, object *caster, object *spell)
1416{ 1399{
1417 object *tmp;
1418 int success = 0, was_one = 0; 1400 int success = 0, was_one = 0;
1419 1401
1420 for (tmp = op->inv; tmp; tmp = tmp->below) 1402 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1421 if (QUERY_FLAG (tmp, FLAG_APPLIED) && 1403 if (tmp->flag [FLAG_APPLIED] &&
1422 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) || 1404 ((tmp->flag [FLAG_CURSED] && spell->flag [FLAG_CURSED]) ||
1423 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED)))) 1405 (tmp->flag [FLAG_DAMNED] && spell->flag [FLAG_DAMNED])))
1424 { 1406 {
1425 was_one++; 1407 was_one++;
1426 1408
1427 if (tmp->level <= caster_level (caster, spell)) 1409 if (tmp->level <= casting_level (caster, spell))
1428 { 1410 {
1429 success++; 1411 success++;
1430 if (QUERY_FLAG (spell, FLAG_DAMNED)) 1412 if (spell->flag [FLAG_DAMNED])
1431 CLEAR_FLAG (tmp, FLAG_DAMNED); 1413 tmp->clr_flag (FLAG_DAMNED);
1432 1414
1433 CLEAR_FLAG (tmp, FLAG_CURSED); 1415 tmp->clr_flag (FLAG_CURSED);
1434 CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED); 1416 tmp->clr_flag (FLAG_KNOWN_CURSED);
1435 tmp->value = 0; /* Still can't sell it */ 1417 tmp->value = 0; /* Still can't sell it */
1436 1418
1437 if (object *pl = tmp->visible_to ()) 1419 if (object *pl = tmp->visible_to ())
1438 esrv_update_item (UPD_FLAGS, pl, tmp); 1420 esrv_update_item (UPD_FLAGS, pl, tmp);
1439 } 1421 }
… …
1457 1439
1458/* Identifies objects in the players inventory/on the ground */ 1440/* Identifies objects in the players inventory/on the ground */
1459int 1441int
1460cast_identify (object *op, object *caster, object *spell) 1442cast_identify (object *op, object *caster, object *spell)
1461{ 1443{
1462 dynbuf_text buf;
1463 object *tmp; 1444 object *tmp;
1445 dynbuf_text &buf = msg_dynbuf; buf.clear ();
1464 1446
1465 int num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1447 int num_ident = max (1, spell->stats.dam + SP_level_dam_adjust (caster, spell));
1466
1467 if (num_ident < 1)
1468 num_ident = 1;
1469 1448
1470 for (tmp = op->inv; tmp; tmp = tmp->below) 1449 for (tmp = op->inv; tmp; tmp = tmp->below)
1471 { 1450 {
1472 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1451 if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && tmp->need_identify ())
1473 { 1452 {
1474 identify (tmp); 1453 identify (tmp);
1475 1454
1476 if (op->type == PLAYER) 1455 if (op->type == PLAYER)
1477 { 1456 {
1478 buf.printf ("You identified: %s.\n\n", long_desc (tmp, op)); 1457 buf.printf ("You identified: %s.\r", long_desc (tmp, op));
1479 1458
1480 if (tmp->msg) 1459 if (tmp->msg)
1481 buf << "The item has a story:\n\n" << tmp->msg << "\n\n"; 1460 buf << "The item has a story:\r" << tmp->msg << "\n\n";
1482 } 1461 }
1483 1462
1484 num_ident--;
1485 if (!num_ident) 1463 if (!--num_ident)
1486 break; 1464 break;
1487 } 1465 }
1488 } 1466 }
1489 1467
1490 /* If all the power of the spell has been used up, don't go and identify 1468 /* If all the power of the spell has been used up, don't go and identify
… …
1492 * was not fully used. 1470 * was not fully used.
1493 */ 1471 */
1494 if (num_ident) 1472 if (num_ident)
1495 { 1473 {
1496 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above) 1474 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1497 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1475 if (!tmp->flag [FLAG_IDENTIFIED] && !tmp->invisible && tmp->need_identify ())
1498 { 1476 {
1499 identify (tmp); 1477 identify (tmp);
1500 1478
1501 if (object *pl = tmp->visible_to ()) 1479 if (object *pl = tmp->visible_to ())
1502 { 1480 {
1503 buf.printf ("On the ground you identified: %s.\n\n", long_desc (tmp, op)); 1481 buf.printf ("On the ground you identified: %s.\r", long_desc (tmp, op));
1504 1482
1505 if (tmp->msg) 1483 if (tmp->msg)
1506 buf << "The item has a story:\n\n" << tmp->msg << "\n\n"; 1484 buf << "The item has a story:\r" << tmp->msg << "\n\n";
1507 } 1485 }
1508 1486
1509 num_ident--;
1510 if (!num_ident) 1487 if (!--num_ident)
1511 break; 1488 break;
1512 } 1489 }
1513 } 1490 }
1514 1491
1515 if (buf.empty ()) 1492 if (buf.empty ())
… …
1537 1514
1538 /* We precompute some values here so that we don't have to keep 1515 /* We precompute some values here so that we don't have to keep
1539 * doing it over and over again. 1516 * doing it over and over again.
1540 */ 1517 */
1541 god = find_god (determine_god (op)); 1518 god = find_god (determine_god (op));
1542 level = caster_level (caster, spell); 1519 level = casting_level (caster, spell);
1543 range = spell->range + SP_level_range_adjust (caster, spell); 1520 range = spell->range + SP_level_range_adjust (caster, spell);
1544 1521
1545 if (!skill) 1522 if (!skill)
1546 skill = caster; 1523 skill = caster;
1547 1524
1548 for (x = op->x - range; x <= op->x + range; x++) 1525 dynbuf buf;
1549 for (y = op->y - range; y <= op->y + range; y++) 1526 unordered_mapwalk (buf, op, -range, -range, range, range)
1550 { 1527 {
1551 m = op->map;
1552 mflags = get_map_flags (m, &m, x, y, &nx, &ny);
1553 if (mflags & P_OUT_OF_MAP)
1554 continue;
1555
1556 /* For most of the detections, we only detect objects above the 1528 /* For most of the detections, we only detect objects above the
1557 * floor. But this is not true for show invisible. 1529 * floor. But this is not true for show invisible.
1558 * Basically, we just go and find the top object and work 1530 * Basically, we just go and find the top object and work
1559 * down - that is easier than working up. 1531 * down - that is easier than working up.
1560 */ 1532 */
1561 1533
1562 for (last = NULL, tmp = GET_MAP_OB (m, nx, ny); tmp; tmp = tmp->above) 1534 for (last = 0, tmp = m->at (nx, ny).bot; tmp; tmp = tmp->above)
1563 last = tmp; 1535 last = tmp;
1564 1536
1565 /* Shouldn't happen, but if there are no objects on a space, this 1537 /* Shouldn't happen, but if there are no objects on a space, this
1566 * would happen. 1538 * would happen.
1567 */ 1539 */
1568 if (!last) 1540 if (!last)
1569 continue; 1541 continue;
1570 1542
1571 done_one = 0; 1543 done_one = 0;
1572 floor = 0; 1544 floor = 0;
1573 detect = NULL; 1545 detect = 0;
1574 for (tmp = last; tmp; tmp = tmp->below) 1546 for (tmp = last; tmp; tmp = tmp->below)
1575 { 1547 {
1576 /* show invisible */ 1548 /* show invisible */
1577 if (QUERY_FLAG (spell, FLAG_MAKE_INVIS) && 1549 if (spell->flag [FLAG_MAKE_INVIS]
1578 /* Might there be other objects that we can make visible? */ 1550 /* Might there be other objects that we can make visible? */
1579 (tmp->invisible && (QUERY_FLAG (tmp, FLAG_MONSTER) || 1551 && (tmp->invisible && (tmp->flag [FLAG_MONSTER]
1580 (tmp->type == PLAYER && !QUERY_FLAG (tmp, FLAG_WIZ)) || 1552 || (tmp->type == PLAYER && !tmp->flag [FLAG_WIZ])
1581 tmp->type == CF_HANDLE || 1553 || tmp->type == T_HANDLE
1582 tmp->type == TRAPDOOR || tmp->type == EXIT || tmp->type == HOLE || 1554 || tmp->type == TRAPDOOR
1555 || tmp->type == EXIT
1556 || tmp->type == HOLE
1557 || tmp->type == BUTTON
1583 tmp->type == BUTTON || tmp->type == TELEPORTER || 1558 || tmp->type == TELEPORTER
1559 || tmp->type == GATE
1584 tmp->type == GATE || tmp->type == LOCKED_DOOR || 1560 || tmp->type == LOCKED_DOOR
1585 tmp->type == WEAPON || tmp->type == ALTAR || tmp->type == SIGN || 1561 || tmp->type == WEAPON
1562 || tmp->type == ALTAR
1563 || (tmp->type == SIGN && tmp->face != magicmouth_face)
1586 tmp->type == TRIGGER_PEDESTAL || tmp->type == SPECIAL_KEY || 1564 || tmp->type == TRIGGER_PEDESTAL
1587 tmp->type == TREASURE || tmp->type == BOOK || tmp->type == HOLY_ALTAR))) 1565 || tmp->type == SPECIAL_KEY
1566 || tmp->type == TREASURE
1567 || tmp->type == BOOK
1568 || tmp->type == HOLY_ALTAR
1569 || tmp->type == CONTAINER)))
1588 { 1570 {
1571 printf ("show inv %s\n", tmp->debug_desc());//D
1589 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4) 1572 if (random_roll (0, skill->level - 1, op, PREFER_HIGH) > level / 4)
1590 { 1573 {
1591 tmp->invisible = 0; 1574 tmp->invisible = 0;
1575 done_one = 1;
1576 }
1577 }
1578
1579 if (tmp->flag [FLAG_IS_FLOOR])
1580 floor = 1;
1581
1582 /* All detections below this point don't descend beneath the floor,
1583 * so just continue on. We could be clever and look at the type of
1584 * detection to completely break out if we don't care about objects beneath
1585 * the floor, but once we get to the floor, not likely a very big issue anyways.
1586 */
1587 if (floor)
1588 continue;
1589
1590 /* I had thought about making detect magic and detect curse
1591 * show the flash the magic item like it does for detect monster.
1592 * however, if the object is within sight, this would then make it
1593 * difficult to see what object is magical/cursed, so the
1594 * effect wouldn't be as apparent.
1595 */
1596
1597 /* detect magic */
1598 if (spell->flag [FLAG_KNOWN_MAGICAL]
1599 && !tmp->flag [FLAG_KNOWN_MAGICAL]
1600 && !tmp->flag [FLAG_IDENTIFIED]
1601 && tmp->need_identify ()
1602 && is_magical (tmp))
1603 {
1604 tmp->set_flag (FLAG_KNOWN_MAGICAL);
1605 /* make runes more visible */
1606 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1607 tmp->stats.Cha /= 4;
1608
1609 done_one = 1;
1610 }
1611
1612 /* detect monster */
1613 if (spell->flag [FLAG_MONSTER] && (tmp->flag [FLAG_MONSTER] || tmp->type == PLAYER))
1614 {
1615 done_one = 2;
1616
1617 if (!detect)
1618 detect = tmp;
1619 }
1620
1621 /* Basically, if race is set in the spell, then the creatures race must
1622 * match that. if the spell race is set to GOD, then the gods opposing
1623 * race must match.
1624 */
1625 if (spell->race && tmp->flag [FLAG_MONSTER] && tmp->race &&
1626 ((spell->race == shstr_GOD && god && god->slaying.contains (tmp->race)) ||
1627 spell->race.contains (tmp->race)))
1628 {
1629 done_one = 2;
1630
1631 if (!detect)
1632 detect = tmp;
1633 }
1634
1635 if (spell->flag [FLAG_KNOWN_CURSED]
1636 && !tmp->flag [FLAG_KNOWN_CURSED]
1637 && tmp->need_identify ()
1638 && (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED]))
1639 {
1640 tmp->set_flag (FLAG_KNOWN_CURSED);
1641 done_one = 1;
1642 }
1643
1644 // Do mining detection spell:
1645 if (spell->last_sp == 1) // 1 - detect any vein
1646 {
1647 if (tmp->type == VEIN)
1648 {
1649 if (tmp->other_arch)
1650 {
1651 if (!detect)
1652 detect = tmp->other_arch;
1653 done_one = 2;
1654 }
1655 else
1592 done_one = 1; 1656 done_one = 1;
1593 } 1657 }
1594 } 1658 }
1595
1596 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1597 floor = 1;
1598
1599 /* All detections below this point don't descend beneath the floor,
1600 * so just continue on. We could be clever and look at the type of
1601 * detection to completely break out if we don't care about objects beneath
1602 * the floor, but once we get to the floor, not likely a very big issue anyways.
1603 */
1604 if (floor)
1605 continue;
1606
1607 /* I had thought about making detect magic and detect curse
1608 * show the flash the magic item like it does for detect monster.
1609 * however, if the object is within sight, this would then make it
1610 * difficult to see what object is magical/cursed, so the
1611 * effect wouldn't be as apparant.
1612 */
1613
1614 /* detect magic */
1615 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) &&
1616 !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL) && !QUERY_FLAG (tmp, FLAG_IDENTIFIED) && is_magical (tmp))
1617 {
1618 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1619 /* make runes more visibile */
1620 if (tmp->type == RUNE && tmp->attacktype & AT_MAGIC)
1621 tmp->stats.Cha /= 4;
1622 done_one = 1;
1623 }
1624 /* detect monster */
1625 if (QUERY_FLAG (spell, FLAG_MONSTER) && (QUERY_FLAG (tmp, FLAG_MONSTER) || tmp->type == PLAYER))
1626 {
1627 done_one = 2;
1628 if (!detect)
1629 detect = tmp;
1630 }
1631 /* Basically, if race is set in the spell, then the creatures race must
1632 * match that. if the spell race is set to GOD, then the gods opposing
1633 * race must match.
1634 */
1635 if (spell->race && QUERY_FLAG (tmp, FLAG_MONSTER) && tmp->race &&
1636 ((!strcmp (spell->race, "GOD") && god && god->slaying && strstr (god->slaying, tmp->race)) ||
1637 (strstr (spell->race, tmp->race))))
1638 {
1639 done_one = 2;
1640 if (!detect)
1641 detect = tmp;
1642 }
1643 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1644 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1645 {
1646 SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1647 done_one = 1;
1648 }
1649 } /* for stack of objects on this space */ 1659 } /* for stack of objects on this space */
1650 1660
1651 /* Code here puts an effect of the spell on the space, so you can see 1661 /* Code here puts an effect of the spell on the space, so you can see
1652 * where the magic is. 1662 * where the magic is.
1653 */ 1663 */
1654 if (done_one) 1664 if (done_one)
1655 { 1665 {
1656 object *detect_ob = arch_to_object (spell->other_arch); 1666 object *detect_ob = spell->other_arch->instance ();
1657 1667
1658 /* if this is set, we want to copy the face */ 1668 /* if this is set, we want to copy the face */
1659 if (done_one == 2 && detect) 1669 if (done_one == 2 && detect)
1660 { 1670 {
1661 detect_ob->face = detect->face; 1671 detect_ob->face = detect->face;
1662 detect_ob->animation_id = detect->animation_id; 1672 detect_ob->animation_id = detect->animation_id;
1663 detect_ob->anim_speed = detect->anim_speed; 1673 detect_ob->anim_speed = detect->anim_speed;
1664 detect_ob->last_anim = 0; 1674 detect_ob->last_anim = 0;
1665 /* by default, the detect_ob is already animated */ 1675 /* by default, the detect_ob is already animated */
1666 if (!QUERY_FLAG (detect, FLAG_ANIMATE)) 1676 if (!detect->flag [FLAG_ANIMATE])
1667 CLEAR_FLAG (detect_ob, FLAG_ANIMATE); 1677 detect_ob->clr_flag (FLAG_ANIMATE);
1668 } 1678 }
1669 1679
1670 m->insert (detect_ob, nx, ny, op); 1680 m->insert (detect_ob, nx, ny, op, INS_ON_TOP);
1671 } 1681 }
1672 } /* for processing the surrounding spaces */ 1682 } /* for processing the surrounding spaces */
1673 1683
1674 1684
1675 /* Now process objects in the players inventory if detect curse or magic */ 1685 /* Now process objects in the players inventory if detect curse or magic */
1676 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL)) 1686 if (spell->flag [FLAG_KNOWN_CURSED] || spell->flag [FLAG_KNOWN_MAGICAL])
1677 { 1687 {
1678 done_one = 0; 1688 done_one = 0;
1679 1689
1680 for (tmp = op->inv; tmp; tmp = tmp->below) 1690 for (tmp = op->inv; tmp; tmp = tmp->below)
1681 { 1691 {
1682 if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED)) 1692 if (!tmp->invisible && !tmp->flag [FLAG_IDENTIFIED])
1683 { 1693 {
1684 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL)) 1694 if (spell->flag [FLAG_KNOWN_MAGICAL] && is_magical (tmp) && !tmp->flag [FLAG_KNOWN_MAGICAL])
1685 { 1695 {
1686 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL); 1696 tmp->set_flag (FLAG_KNOWN_MAGICAL);
1687 1697
1688 if (object *pl = tmp->visible_to ()) 1698 if (object *pl = tmp->visible_to ())
1689 esrv_update_item (UPD_FLAGS, pl, tmp); 1699 esrv_update_item (UPD_FLAGS, pl, tmp);
1690 } 1700 }
1691 1701
1692 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && 1702 if (spell->flag [FLAG_KNOWN_CURSED] && !tmp->flag [FLAG_KNOWN_CURSED] &&
1693 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))) 1703 (tmp->flag [FLAG_CURSED] || tmp->flag [FLAG_DAMNED]))
1694 { 1704 {
1695 SET_FLAG (tmp, FLAG_KNOWN_CURSED); 1705 tmp->set_flag (FLAG_KNOWN_CURSED);
1696 1706
1697 if (object *pl = tmp->visible_to ()) 1707 if (object *pl = tmp->visible_to ())
1698 esrv_update_item (UPD_FLAGS, pl, tmp); 1708 esrv_update_item (UPD_FLAGS, pl, tmp);
1699 } 1709 }
1700 } /* if item is not identified */ 1710 } /* if item is not identified */
… …
1721 1731
1722 new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you."); 1732 new_draw_info (NDI_UNIQUE, 0, victim, "You feel energy course through you.");
1723 1733
1724 if (victim->stats.sp >= victim->stats.maxsp * 2) 1734 if (victim->stats.sp >= victim->stats.maxsp * 2)
1725 { 1735 {
1726 object *tmp;
1727
1728 new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!"); 1736 new_draw_info (NDI_UNIQUE, 0, victim, "Your head explodes!");
1729
1730 /* Explodes a fireball centered at player */
1731 tmp = get_archetype (EXPLODING_FIREBALL);
1732 tmp->dam_modifier = random_roll (1, caster_level, victim, PREFER_LOW) / 5 + 1;
1733 tmp->stats.maxhp = random_roll (1, caster_level, victim, PREFER_LOW) / 10 + 2;
1734
1735 tmp->insert_at (victim);
1736 victim->stats.sp = 2 * victim->stats.maxsp; 1737 victim->stats.sp = 2 * victim->stats.maxsp;
1738 create_exploding_ball_at (victim, caster_level);
1737 } 1739 }
1738 else if (victim->stats.sp >= victim->stats.maxsp * 1.88) 1740 else if (victim->stats.sp >= victim->stats.maxsp * 1.88)
1739 new_draw_info (NDI_UNIQUE, NDI_ORANGE, victim, "You feel like your head is going to explode."); 1741 new_draw_info (NDI_UNIQUE | NDI_ORANGE, 0, victim, "You feel like your head is going to explode.");
1740 else if (victim->stats.sp >= victim->stats.maxsp * 1.66) 1742 else if (victim->stats.sp >= victim->stats.maxsp * 1.66)
1741 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!"); 1743 new_draw_info (NDI_UNIQUE, 0, victim, "You get a splitting headache!");
1742 else if (victim->stats.sp >= victim->stats.maxsp * 1.5) 1744 else if (victim->stats.sp >= victim->stats.maxsp * 1.5)
1743 { 1745 {
1744 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world."); 1746 new_draw_info (NDI_UNIQUE, 0, victim, "Chaos fills your world.");
… …
1768 mflags = get_map_flags (m, &m, x, y, &x, &y); 1770 mflags = get_map_flags (m, &m, x, y, &x, &y);
1769 1771
1770 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE) 1772 if (!(mflags & P_OUT_OF_MAP) && mflags & P_IS_ALIVE)
1771 { 1773 {
1772 for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above) 1774 for (plyr = GET_MAP_OB (m, x, y); plyr != NULL; plyr = plyr->above)
1773 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 1775 if (plyr != op && plyr->flag [FLAG_ALIVE])
1774 break; 1776 break;
1775 } 1777 }
1776 1778
1777 1779
1778 /* If we did not find a player in the specified direction, transfer 1780 /* If we did not find a player in the specified direction, transfer
1779 * to anyone on top of us. This is used for the rune of transference mostly. 1781 * to anyone on top of us. This is used for the rune of transference mostly.
1780 */ 1782 */
1781 if (plyr == NULL) 1783 if (plyr == NULL)
1782 for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above) 1784 for (plyr = GET_MAP_OB (op->map, op->x, op->y); plyr != NULL; plyr = plyr->above)
1783 if (plyr != op && QUERY_FLAG (plyr, FLAG_ALIVE)) 1785 if (plyr != op && plyr->flag [FLAG_ALIVE])
1784 break; 1786 break;
1785 1787
1786 if (!plyr) 1788 if (!plyr)
1787 { 1789 {
1788 new_draw_info (NDI_BLACK, 0, op, "There is no one there."); 1790 op->failmsg ("There is no one there.");
1789 return 0; 1791 return 0;
1790 } 1792 }
1791 /* give sp */ 1793 /* give sp */
1792 if (spell->stats.dam > 0) 1794 if (spell->stats.dam > 0)
1793 { 1795 {
1794 plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell); 1796 plyr->stats.sp += spell->stats.dam + SP_level_dam_adjust (caster, spell);
1795 charge_mana_effect (plyr, caster_level (caster, spell)); 1797 charge_mana_effect (plyr, casting_level (caster, spell));
1796 return 1; 1798 return 1;
1797 } 1799 }
1798 /* suck sp away. Can't suck sp from yourself */ 1800 /* suck sp away. Can't suck sp from yourself */
1799 else if (op != plyr) 1801 else if (op != plyr)
1800 { 1802 {
… …
1805 if (rate > 95) 1807 if (rate > 95)
1806 rate = 95; 1808 rate = 95;
1807 1809
1808 sucked = (plyr->stats.sp * rate) / 100; 1810 sucked = (plyr->stats.sp * rate) / 100;
1809 plyr->stats.sp -= sucked; 1811 plyr->stats.sp -= sucked;
1810 if (QUERY_FLAG (op, FLAG_ALIVE)) 1812 if (op->flag [FLAG_ALIVE])
1811 { 1813 {
1812 /* Player doesn't get full credit */ 1814 /* Player doesn't get full credit */
1813 sucked = (sucked * rate) / 100; 1815 sucked = (sucked * rate) / 100;
1814 op->stats.sp += sucked; 1816 op->stats.sp += sucked;
1815 if (sucked > 0) 1817 if (sucked > 0)
1816 { 1818 {
1817 charge_mana_effect (op, caster_level (caster, spell)); 1819 charge_mana_effect (op, casting_level (caster, spell));
1818 } 1820 }
1819 } 1821 }
1820 return 1; 1822 return 1;
1821 } 1823 }
1822 return 0; 1824 return 0;
… …
1866 * monsters either. 1868 * monsters either.
1867 */ 1869 */
1868 1870
1869 if (head->attacktype & AT_MAGIC 1871 if (head->attacktype & AT_MAGIC
1870 && !(head->attacktype & AT_COUNTERSPELL) 1872 && !(head->attacktype & AT_COUNTERSPELL)
1871 && !QUERY_FLAG (head, FLAG_MONSTER) 1873 && !head->flag [FLAG_MONSTER]
1872 && (op->level > head->level)) 1874 && (op->level > head->level))
1873 head->destroy (); 1875 head->destroy ();
1874 else 1876 else
1875 switch (head->type) 1877 switch (head->type)
1876 { 1878 {
1877 case SPELL_EFFECT: 1879 case SPELL_EFFECT:
1878 // XXX: Don't affect floor spelleffects. See also XXX comment 1880 // XXX: Don't affect floor spelleffects. See also XXX comment
1879 // about sanctuary in spell_util.C 1881 // about sanctuary in spell_util.C
1880 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1882 if (tmp->flag [FLAG_IS_FLOOR])
1881 continue; 1883 continue;
1882 1884
1883 if (op->level > head->level) 1885 if (op->level > head->level)
1884 head->destroy (); 1886 head->destroy ();
1885 1887
… …
1908 1910
1909 object *tmp, *god = find_god (determine_god (op)); 1911 object *tmp, *god = find_god (determine_god (op));
1910 1912
1911 if (!god) 1913 if (!god)
1912 { 1914 {
1913 new_draw_info (NDI_UNIQUE, 0, op, "You can't consecrate anything if you don't worship a god!"); 1915 op->failmsg ("You can't consecrate anything if you don't worship a god!");
1914 return 0; 1916 return 0;
1915 } 1917 }
1916 1918
1917 for (tmp = op->below; tmp; tmp = tmp->below) 1919 for (tmp = op->below; tmp; tmp = tmp->below)
1918 { 1920 {
1919 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1921 if (tmp->flag [FLAG_IS_FLOOR])
1920 break; 1922 break;
1921 if (tmp->type == HOLY_ALTAR) 1923 if (tmp->type == HOLY_ALTAR)
1922 { 1924 {
1923 1925
1924 if (tmp->level > caster_level (caster, spell)) 1926 if (tmp->level > casting_level (caster, spell))
1925 { 1927 {
1926 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not powerful enough to reconsecrate the %s", &tmp->name); 1928 op->failmsgf ("You are not powerful enough to reconsecrate the %s", &tmp->name);
1927 return 0; 1929 return 0;
1928 } 1930 }
1929 else 1931 else
1930 { 1932 {
1931 /* If we got here, we are consecrating an altar */ 1933 /* If we got here, we are consecrating an altar */
1932 sprintf (buf, "Altar of %s", &god->name); 1934 sprintf (buf, "Altar of %s", &god->name);
1933 tmp->name = buf; 1935 tmp->name = buf;
1934 tmp->level = caster_level (caster, spell); 1936 tmp->level = casting_level (caster, spell);
1935 tmp->other_arch = god->arch; 1937 tmp->other_arch = god->arch;
1936 1938
1937 if (op->type == PLAYER) 1939 if (op->type == PLAYER)
1938 esrv_update_item (UPD_NAME, op, tmp); 1940 esrv_update_item (UPD_NAME, op, tmp);
1939 1941
1940 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name); 1942 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
1941 return 1; 1943 return 1;
1942 } 1944 }
1943 } 1945 }
1944 } 1946 }
1945 new_draw_info (NDI_UNIQUE, 0, op, "You are not standing over an altar!"); 1947
1948 op->failmsg ("You are not standing over an altar!");
1946 return 0; 1949 return 0;
1947} 1950}
1948 1951
1949/* animate_weapon - 1952/* animate_weapon -
1950 * Generalization of staff_to_snake. Makes a golem out of the caster's weapon. 1953 * Generalization of staff_to_snake. Makes a golem out of the caster's weapon.
… …
1957 * player checks. MSW 2003-01-06 1960 * player checks. MSW 2003-01-06
1958 */ 1961 */
1959int 1962int
1960animate_weapon (object *op, object *caster, object *spell, int dir) 1963animate_weapon (object *op, object *caster, object *spell, int dir)
1961{ 1964{
1962 object *weapon, *tmp;
1963 char buf[MAX_BUF]; 1965 char buf[MAX_BUF];
1964 int a, i; 1966 int a, i;
1965 sint16 x, y; 1967 sint16 x, y;
1966 maptile *m; 1968 maptile *m;
1967 1969
… …
1982 return 0; 1984 return 0;
1983 } 1985 }
1984 1986
1985 /* if no direction specified, pick one */ 1987 /* if no direction specified, pick one */
1986 if (!dir) 1988 if (!dir)
1987 dir = find_free_spot (NULL, op->map, op->x, op->y, 1, 9); 1989 dir = find_free_spot (spell->other_arch, op->map, op->x, op->y, 1, 9);
1988 1990
1989 m = op->map; 1991 m = op->map;
1990 x = op->x + freearr_x[dir]; 1992 x = op->x + freearr_x[dir];
1991 y = op->y + freearr_y[dir]; 1993 y = op->y + freearr_y[dir];
1992 1994
1993 /* if there's no place to put the golem, abort */ 1995 /* if there's no place to put the golem, abort */
1994 if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) || 1996 if (dir < 0 || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP)
1995 ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type)) 1997 || ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
1996 { 1998 {
1997 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 1999 op->failmsg ("There is something in the way.");
1998 return 0; 2000 return 0;
1999 } 2001 }
2000 2002
2001 /* Use the weapon marked by the player. */ 2003 /* Use the weapon marked by the player. */
2002 weapon = find_marked_object (op); 2004 object *weapon = op->mark ();
2003 2005
2004 if (!weapon) 2006 if (!weapon)
2005 { 2007 {
2006 new_draw_info (NDI_BLACK, 0, op, "You must mark a weapon to use with this spell!"); 2008 op->failmsg ("You must mark a weapon to use with this spell!");
2007 return 0; 2009 return 0;
2008 } 2010 }
2011
2009 if (spell->race && strcmp (weapon->arch->archname, spell->race)) 2012 if (spell->race && weapon->arch->archname != spell->race)
2010 { 2013 {
2011 new_draw_info (NDI_UNIQUE, 0, op, "The spell fails to transform your weapon."); 2014 op->failmsg ("The spell fails to transform your weapon.");
2012 return 0; 2015 return 0;
2013 } 2016 }
2017
2014 if (weapon->type != WEAPON) 2018 if (weapon->type != WEAPON)
2015 { 2019 {
2016 new_draw_info (NDI_UNIQUE, 0, op, "You need to wield a weapon to animate it."); 2020 op->failmsg ("You need to wield a weapon to animate it.");
2017 return 0; 2021 return 0;
2018 } 2022 }
2019 if (QUERY_FLAG (weapon, FLAG_APPLIED)) 2023
2024 if (weapon->flag [FLAG_APPLIED])
2020 { 2025 {
2021 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon)); 2026 op->failmsgf ("You need to unequip %s before using it in this spell", query_name (weapon));
2022 return 0; 2027 return 0;
2023 } 2028 }
2024 2029
2025 weapon = weapon->split (); 2030 weapon = weapon->split ();
2026 2031
2027 /* create the golem object */ 2032 /* create the golem object */
2028 tmp = arch_to_object (spell->other_arch); 2033 object *tmp = spell->other_arch->instance ();
2029 2034
2030 /* if animated by a player, give the player control of the golem */ 2035 /* if animated by a player, give the player control of the golem */
2031 CLEAR_FLAG (tmp, FLAG_MONSTER); 2036 tmp->clr_flag (FLAG_MONSTER);
2032 tmp->stats.exp = 0; 2037 tmp->stats.exp = 0;
2033 add_friendly_object (tmp); 2038 add_friendly_object (tmp);
2034 tmp->type = GOLEM; 2039 tmp->type = GOLEM;
2035 tmp->set_owner (op); 2040 tmp->set_owner (op);
2036 op->contr->golem = tmp; 2041 op->contr->golem = tmp;
… …
2038 2043
2039 /* Give the weapon to the golem now. A bit of a hack to check the 2044 /* Give the weapon to the golem now. A bit of a hack to check the
2040 * removed flag - it should only be set if weapon->split was 2045 * removed flag - it should only be set if weapon->split was
2041 * used above. 2046 * used above.
2042 */ 2047 */
2043 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2048 if (!weapon->flag [FLAG_REMOVED])
2044 weapon->remove (); 2049 weapon->remove ();
2045 2050
2046 tmp->insert (weapon); 2051 tmp->insert (weapon);
2047 2052
2048 /* To do everything necessary to let a golem use the weapon is a pain, 2053 /* To do everything necessary to let a golem use the weapon is a pain,
2049 * so instead, just set it as equipped (otherwise, we need to update 2054 * so instead, just set it as equipped (otherwise, we need to update
2050 * body_info, skills, etc) 2055 * body_info, skills, etc)
2051 */ 2056 */
2052 SET_FLAG (tmp, FLAG_USE_WEAPON); 2057 tmp->set_flag (FLAG_USE_WEAPON);
2053 SET_FLAG (weapon, FLAG_APPLIED); 2058 weapon->set_flag (FLAG_APPLIED);
2054 tmp->update_stats (); 2059 tmp->update_stats ();
2055 2060
2056 /* There used to be 'odd' code that basically seemed to take the absolute 2061 /* There used to be 'odd' code that basically seemed to take the absolute
2057 * value of the weapon->magic an use that. IMO, that doesn't make sense - 2062 * value of the weapon->magic an use that. IMO, that doesn't make sense -
2058 * if you're using a crappy weapon, it shouldn't be as good. 2063 * if you're using a crappy weapon, it shouldn't be as good.
… …
2078 2083
2079 /* attacktype */ 2084 /* attacktype */
2080 if (!tmp->attacktype) 2085 if (!tmp->attacktype)
2081 tmp->attacktype = AT_PHYSICAL; 2086 tmp->attacktype = AT_PHYSICAL;
2082 2087
2083 if (materialtype_t *mt = name_to_material (op->materialname))
2084 {
2085 for (i = 0; i < NROFATTACKS; i++) 2088 for (i = 0; i < NROFATTACKS; i++)
2086 tmp->resist[i] = 50 - (mt->save[i] * 5); 2089 tmp->resist[i] = 50 - (op->material->save[i] * 5);
2087 a = mt->save[0]; 2090
2088 } 2091 a = op->material->save[0];
2089 else
2090 {
2091 for (i = 0; i < NROFATTACKS; i++)
2092 tmp->resist[i] = 5;
2093 a = 10;
2094 }
2095 2092
2096 /* Set weapon's immunity */ 2093 /* Set weapon's immunity */
2097 tmp->resist[ATNR_CONFUSION] = 100; 2094 tmp->resist[ATNR_CONFUSION] = 100;
2098 tmp->resist[ATNR_POISON] = 100; 2095 tmp->resist[ATNR_POISON] = 100;
2099 tmp->resist[ATNR_SLOW] = 100; 2096 tmp->resist[ATNR_SLOW] = 100;
… …
2126 tmp->state = weapon->state; 2123 tmp->state = weapon->state;
2127 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE]; 2124 tmp->flag [FLAG_ANIMATE] = weapon->flag [FLAG_ANIMATE];
2128 } 2125 }
2129 2126
2130 /* make experience increase in proportion to the strength of the summoned creature. */ 2127 /* make experience increase in proportion to the strength of the summoned creature. */
2131 tmp->stats.exp *= 1 + (MAX (spell->stats.maxgrace, spell->stats.sp) / caster_level (caster, spell)); 2128 tmp->stats.exp *= 1 + (max (spell->stats.maxgrace, spell->stats.sp) / casting_level (caster, spell));
2132 2129
2133 tmp->speed_left = -1; 2130 tmp->speed_left = -1;
2134 tmp->direction = dir; 2131 tmp->direction = dir;
2135 2132
2136 m->insert (tmp, x, y, op); 2133 m->insert (tmp, x, y, op);
… …
2140/* cast_daylight() - changes the map darkness level *lower* */ 2137/* cast_daylight() - changes the map darkness level *lower* */
2141 2138
2142/* cast_change_map_lightlevel: Was cast_daylight/nightfall. 2139/* cast_change_map_lightlevel: Was cast_daylight/nightfall.
2143 * This changes the light level for the entire map. 2140 * This changes the light level for the entire map.
2144 */ 2141 */
2145
2146int 2142int
2147cast_change_map_lightlevel (object *op, object *caster, object *spell) 2143cast_change_map_lightlevel (object *op, object *caster, object *spell)
2148{ 2144{
2149 int success; 2145 int success;
2150 2146
… …
2154 success = op->map->change_map_light (spell->stats.dam); 2150 success = op->map->change_map_light (spell->stats.dam);
2155 2151
2156 if (!success) 2152 if (!success)
2157 { 2153 {
2158 if (spell->stats.dam < 0) 2154 if (spell->stats.dam < 0)
2159 new_draw_info (NDI_UNIQUE, 0, op, "It can be no brighter here."); 2155 op->failmsg ("It can be no brighter here.");
2160 else 2156 else
2161 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here."); 2157 op->failmsg ("It can be no darker here.");
2162 } 2158 }
2159
2163 return success; 2160 return success;
2164} 2161}
2165 2162
2166/* create an aura spell object and put it in the player's inventory. 2163/* create an aura spell object and put it in the player's inventory.
2167 * as usual, op is player, caster is the object casting the spell, 2164 * as usual, op is player, caster is the object casting the spell,
… …
2175 2172
2176 new_aura = present_arch_in_ob (spell->other_arch, op); 2173 new_aura = present_arch_in_ob (spell->other_arch, op);
2177 if (new_aura) 2174 if (new_aura)
2178 refresh = 1; 2175 refresh = 1;
2179 else 2176 else
2180 new_aura = arch_to_object (spell->other_arch); 2177 new_aura = spell->other_arch->instance ();
2181 2178
2182 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2179 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2183 2180
2184 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2181 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2185 2182
2186 set_spell_skill (op, caster, spell, new_aura); 2183 set_spell_skill (op, caster, spell, new_aura);
2187 new_aura->attacktype = spell->attacktype; 2184 new_aura->attacktype = spell->attacktype;
2188 2185
2189 new_aura->level = caster_level (caster, spell); 2186 new_aura->level = casting_level (caster, spell);
2190 2187
2191 if (refresh) 2188 if (refresh)
2192 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 2189 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2193 else 2190 else
2194 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force."); 2191 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
… …
2250 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block))) 2247 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2251 { 2248 {
2252 hit_map (aura, i, aura->attacktype, 0); 2249 hit_map (aura, i, aura->attacktype, 0);
2253 2250
2254 if (aura->other_arch) 2251 if (aura->other_arch)
2255 pos.insert (arch_to_object (aura->other_arch), aura); 2252 pos.insert (aura->other_arch->instance (), aura);
2256 } 2253 }
2257 } 2254 }
2258 2255
2259 /* put the aura back in the player's inventory */ 2256 /* put the aura back in the player's inventory */
2260 env->insert (aura); 2257 env->insert (aura);
… …
2265 * op is the piece object. 2262 * op is the piece object.
2266 */ 2263 */
2267void 2264void
2268move_peacemaker (object *op) 2265move_peacemaker (object *op)
2269{ 2266{
2270 object *tmp; 2267 for (object *tmp = op->ms ().bot; tmp; tmp = tmp->above)
2271
2272 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2273 { 2268 {
2274 int atk_lev, def_lev; 2269 int atk_lev, def_lev;
2275 object *victim = tmp->head_ (); 2270 object *victim = tmp->head_ ();
2276 2271
2277 if (!QUERY_FLAG (victim, FLAG_MONSTER)) 2272 if (!victim->flag [FLAG_MONSTER])
2278 continue; 2273 continue;
2279 2274
2280 if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE)) 2275 if (victim->flag [FLAG_UNAGGRESSIVE])
2281 continue; 2276 continue;
2282 2277
2283 if (victim->stats.exp == 0) 2278 if (victim->stats.exp == 0)
2284 continue; 2279 continue;
2285 2280
2286 def_lev = MAX (1, victim->level); 2281 def_lev = max (1, victim->level);
2287 atk_lev = MAX (1, op->level); 2282 atk_lev = max (1, op->level);
2288 2283
2289 if (rndm (0, atk_lev - 1) > def_lev) 2284 if (rndm (0, atk_lev - 1) > def_lev)
2290 { 2285 {
2291 /* make this sucker peaceful. */ 2286 /* make this sucker peaceful. */
2292 2287
… …
2301 victim->stats.sp = 0; 2296 victim->stats.sp = 0;
2302 victim->stats.grace = 0; 2297 victim->stats.grace = 0;
2303 victim->stats.Pow = 0; 2298 victim->stats.Pow = 0;
2304#endif 2299#endif
2305 victim->attack_movement = RANDO2; 2300 victim->attack_movement = RANDO2;
2306 SET_FLAG (victim, FLAG_UNAGGRESSIVE); 2301 victim->set_flag (FLAG_UNAGGRESSIVE);
2307 SET_FLAG (victim, FLAG_RUN_AWAY); 2302 victim->set_flag (FLAG_RUN_AWAY);
2308 SET_FLAG (victim, FLAG_RANDOM_MOVE); 2303 victim->set_flag (FLAG_RANDOM_MOVE);
2309 CLEAR_FLAG (victim, FLAG_MONSTER); 2304 victim->clr_flag (FLAG_MONSTER);
2310 2305
2311 if (victim->name) 2306 if (victim->name)
2312 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name); 2307 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2313 } 2308 }
2314 } 2309 }
2315} 2310}
2316
2317 2311
2318/* This writes a rune that contains the appropriate message. 2312/* This writes a rune that contains the appropriate message.
2319 * There really isn't any adjustments we make. 2313 * There really isn't any adjustments we make.
2320 */ 2314 */
2321
2322int 2315int
2323write_mark (object *op, object *spell, const char *msg) 2316write_mark (object *op, object *spell, const char *msg)
2324{ 2317{
2325 char rune[HUGE_BUF];
2326 object *tmp;
2327
2328 if (!msg || msg[0] == 0) 2318 if (!msg || msg[0] == 0)
2329 { 2319 {
2330 new_draw_info (NDI_UNIQUE, 0, op, "Write what?"); 2320 op->failmsg ("Write what?");
2331 return 0; 2321 return 0;
2332 } 2322 }
2333 2323
2334 if (strcasestr_local (msg, "endmsg")) 2324 if (!msg_is_safe (msg))
2335 { 2325 {
2336 new_draw_info (NDI_UNIQUE, 0, op, "Trying to cheat are we?"); 2326 op->failmsg ("Trying to cheat are we? H<@-signs are not allowed in marking runes.>");
2337 LOG (llevInfo, "write_rune: player %s tried to write bogus rune %s\n", &op->name, msg); 2327 LOG (llevInfo, "write_mark: player %s tried to write bogus rune %s\n", &op->name, msg);
2338 return 0; 2328 return 0;
2339 } 2329 }
2330
2340 if (!spell->other_arch) 2331 if (!spell->other_arch)
2341 return 0; 2332 return 0;
2342 tmp = arch_to_object (spell->other_arch);
2343 2333
2344 snprintf (rune, sizeof (rune), "%s\n", msg); 2334 object *tmp = spell->other_arch->instance ();
2345 2335
2346 tmp->race = op->name; /*Save the owner of the rune */ 2336 tmp->race = op->name; /*Save the owner of the rune */
2347 tmp->msg = rune; 2337 tmp->msg = msg;
2348 2338
2349 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR); 2339 tmp->insert_at (op, op, INS_BELOW_ORIGINATOR);
2340
2350 return 1; 2341 return 1;
2351} 2342}
2343

Diff Legend

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