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.74 by root, Tue Oct 16 00:30:25 2007 UTC vs.
Revision 1.148 by root, Sat Nov 17 23:40:04 2018 UTC

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

Diff Legend

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