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

Diff Legend

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