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.63 by root, Tue Jul 10 07:31:20 2007 UTC vs.
Revision 1.107 by elmex, Thu Sep 17 16:53:15 2009 UTC

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

Diff Legend

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