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.56 by root, Mon Jun 4 12:19:09 2007 UTC vs.
Revision 1.83 by root, Tue May 6 16:55:26 2008 UTC

1/* 1/*
2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG. 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Crossfire TRT is free software; you can redistribute it and/or modify it 8 * Deliantra is free software: you can redistribute it and/or modify
9 * under the terms of the GNU General Public License as published by the Free 9 * it under the terms of the GNU General Public License as published by
10 * Software Foundation; either version 2 of the License, or (at your option) 10 * the Free Software Foundation, either version 3 of the License, or
11 * any later version. 11 * (at your option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, but 13 * This program is distributed in the hope that it will be useful,
14 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License along 18 * You should have received a copy of the GNU General Public License
19 * with Crossfire TRT; if not, write to the Free Software Foundation, Inc. 51 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 * 20 *
22 * The authors can be reached via e-mail to <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 22 */
24 23
25#include <global.h> 24#include <global.h>
26#include <object.h> 25#include <object.h>
27#include <living.h> 26#include <living.h>
… …
70 return 0; 69 return 0;
71 } 70 }
72 if (!(random_roll (0, 3, op, PREFER_HIGH))) 71 if (!(random_roll (0, 3, op, PREFER_HIGH)))
73 { 72 {
74 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand)); 73 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s vibrates violently, then explodes!", query_name (wand));
75 play_sound_map (op->map, op->x, op->y, SOUND_OB_EXPLODE); 74 op->play_sound (sound_find ("ob_explode"));
76 esrv_del_item (op->contr, wand->count);
77 wand->destroy (); 75 wand->destroy ();
78 tmp = get_archetype ("fireball"); 76 tmp = get_archetype ("fireball");
79 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10; 77 tmp->stats.dam = (spell_ob->stats.dam + SP_level_dam_adjust (caster, spell_ob)) / 10;
80 78
81 if (!tmp->stats.dam) 79 if (!tmp->stats.dam)
… …
104 ncharges = 1; 102 ncharges = 1;
105 103
106 wand->stats.food += ncharges; 104 wand->stats.food += ncharges;
107 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand)); 105 new_draw_info_format (NDI_UNIQUE, 0, op, "The %s glows with power.", query_name (wand));
108 106
109 if (wand->arch && QUERY_FLAG (&wand->arch->clone, FLAG_ANIMATE)) 107 if (wand->arch && QUERY_FLAG (wand->arch, FLAG_ANIMATE))
110 { 108 {
111 SET_FLAG (wand, FLAG_ANIMATE); 109 SET_FLAG (wand, FLAG_ANIMATE);
112 wand->set_speed (wand->arch->clone.speed); 110 wand->set_speed (wand->arch->speed);
113 } 111 }
114 112
115 return 1; 113 return 1;
116} 114}
117 115
… …
123 * great a plus, the default is used. 121 * great a plus, the default is used.
124 * The # of arrows created also goes up with level, so if a 30th level mage 122 * The # of arrows created also goes up with level, so if a 30th level mage
125 * wants LOTS of arrows, and doesn't care what the plus is he could 123 * wants LOTS of arrows, and doesn't care what the plus is he could
126 * create nonnmagic arrows, or even -1, etc... 124 * create nonnmagic arrows, or even -1, etc...
127 */ 125 */
128
129int 126int
130cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg) 127cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg)
131{ 128{
132 int missile_plus = 0, bonus_plus = 0; 129 int bonus_plus = 0;
133 const char *missile_name; 130 const char *missile_name = "arrow";
134 object *tmp, *missile;
135 131
136 missile_name = "arrow";
137
138 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 132 for (object *tmp = op->inv; tmp; tmp = tmp->below)
139 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED)) 133 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
140 missile_name = tmp->race; 134 missile_name = tmp->race;
141 135
142 missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell); 136 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
143 137
144 if (archetype::find (missile_name) == NULL) 138 archetype *missile_arch = archetype::find (missile_name);
139
140 if (!missile_arch)
145 { 141 {
146 LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name); 142 LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);
147 return 0; 143 return 0;
148 } 144 }
149 145
150 missile = get_archetype (missile_name); 146 object *missile = missile_arch->instance ();
151 147
152 if (stringarg) 148 if (stringarg)
153 { 149 {
154 /* If it starts with a letter, presume it is a description */ 150 /* If it starts with a letter, presume it is a description */
155 if (isalpha (*stringarg)) 151 if (isalpha (*stringarg))
… …
173 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg); 169 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg);
174 return 0; 170 return 0;
175 } 171 }
176 172
177 give_artifact_abilities (missile, al->item); 173 give_artifact_abilities (missile, al->item);
178 /* These special arrows cost something extra. Don't have them also be magical - 174 /* These special arrows cost something extra. Don't have them also be magical -
179 * otherwise, in most cases, not enough will be created. I don't want to get into 175 * otherwise, in most cases, not enough will be created. I don't want to get into
180 * the parsing of having to do both plus and type. 176 * the parsing of having to do both plus and type.
181 */ 177 */
182 bonus_plus = 1 + (al->item->value / 5); 178 bonus_plus = 1 + (al->item->value / 5);
183 missile_plus = 0; 179 missile_plus = 0;
184 } 180 }
185 else if (atoi (stringarg) < missile_plus) 181 else if (atoi (stringarg) < missile_plus)
186 missile_plus = atoi (stringarg); 182 missile_plus = atoi (stringarg);
187 } 183 }
188 184
189 if (missile_plus > 4) 185 missile_plus = clamp (missile_plus, -4, 4);
190 missile_plus = 4;
191 else if (missile_plus < -4)
192 missile_plus = -4;
193 186
194 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell); 187 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
195 missile->nrof -= 3 * (missile_plus + bonus_plus); 188 missile->nrof -= 3 * (missile_plus + bonus_plus);
196 189
197 if (missile->nrof < 1) 190 if (missile->nrof < 1)
… …
217{ 210{
218 int food_value; 211 int food_value;
219 archetype *at = NULL; 212 archetype *at = NULL;
220 object *new_op; 213 object *new_op;
221 214
222 food_value = spell_ob->stats.food + +50 * SP_level_duration_adjust (caster, spell_ob); 215 food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);
223 216
224 if (stringarg) 217 if (stringarg)
225 { 218 {
226 at = find_archetype_by_object_type_name (FOOD, stringarg); 219 at = find_archetype_by_object_type_name (FOOD, stringarg);
227 if (at == NULL) 220 if (at == NULL)
228 at = find_archetype_by_object_type_name (DRINK, stringarg); 221 at = find_archetype_by_object_type_name (DRINK, stringarg);
229 if (at == NULL || at->clone.stats.food > food_value) 222 if (at == NULL || at->stats.food > food_value)
230 stringarg = NULL; 223 stringarg = NULL;
231 } 224 }
232 225
233 if (!stringarg) 226 if (!stringarg)
234 { 227 {
… …
240 * We don't use flesh types because the weight values of those need 233 * We don't use flesh types because the weight values of those need
241 * to be altered from the donor. 234 * to be altered from the donor.
242 */ 235 */
243 236
244 /* We assume the food items don't have multiple parts */ 237 /* We assume the food items don't have multiple parts */
245 for (at_tmp = first_archetype; at_tmp != NULL; at_tmp = at_tmp->next) 238 for_all_archetypes (at_tmp)
246 { 239 {
247 if (at_tmp->clone.type == FOOD || at_tmp->clone.type == DRINK) 240 if (at_tmp->type == FOOD || at_tmp->type == DRINK)
248 { 241 {
249 /* Basically, if the food value is something that is creatable 242 /* Basically, if the food value is something that is creatable
250 * under the limits of the spell and it is higher than 243 * under the limits of the spell and it is higher than
251 * the item we have now, take it instead. 244 * the item we have now, take it instead.
252 */ 245 */
253 if (at_tmp->clone.stats.food <= food_value && (!at || at_tmp->clone.stats.food > at->clone.stats.food)) 246 if (at_tmp->stats.food <= food_value
247 && (!at
248 || at_tmp->stats.food > at->stats.food
249 || (at_tmp->stats.food == at->stats.food
250 && at_tmp->weight < at->weight)))
254 at = at_tmp; 251 at = at_tmp;
255 } 252 }
256 } 253 }
257 } 254 }
255
258 /* 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
259 * know 257 * know
260 */ 258 */
261 if (!at) 259 if (!at)
262 { 260 {
263 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food."); 261 new_draw_info (NDI_UNIQUE, 0, op, "You don't have enough experience to create any food.");
264 return 0; 262 return 0;
265 } 263 }
266 264
267 food_value /= at->clone.stats.food; 265 food_value /= at->stats.food;
268 new_op = arch_to_object (at); 266 new_op = arch_to_object (at);
269 new_op->nrof = food_value; 267 new_op->nrof = food_value;
270 268
271 new_op->value = 0; 269 new_op->value = 0;
272 if (new_op->nrof < 1) 270 if (new_op->nrof < 1)
… …
281{ 279{
282 int r, mflags, maxrange; 280 int r, mflags, maxrange;
283 object *tmp; 281 object *tmp;
284 maptile *m; 282 maptile *m;
285 283
286
287 if (!dir) 284 if (!dir)
288 { 285 {
289 examine_monster (op, op); 286 examine_monster (op, op);
290 return 1; 287 return 1;
291 } 288 }
289
292 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob); 290 maxrange = spell_ob->range + SP_level_range_adjust (caster, spell_ob);
293 for (r = 1; r < maxrange; r++) 291 for (r = 1; r < maxrange; r++)
294 { 292 {
295 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];
296 294
… …
316 examine_monster (op, tmp); 314 examine_monster (op, tmp);
317 return 1; 315 return 1;
318 } 316 }
319 } 317 }
320 } 318 }
319
321 new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing."); 320 new_draw_info (NDI_UNIQUE, 0, op, "You detect nothing.");
322 return 1; 321 return 1;
323} 322}
324
325 323
326/* This checks to see if 'pl' is invisible to 'mon'. 324/* This checks to see if 'pl' is invisible to 'mon'.
327 * does race check, undead check, etc 325 * does race check, undead check, etc
328 * Returns TRUE if mon can't see pl, false 326 * Returns TRUE if mon can't see pl, false
329 * otherwise. This doesn't check range, walls, etc. It 327 * otherwise. This doesn't check range, walls, etc. It
… …
331 * pl is invisible. 329 * pl is invisible.
332 */ 330 */
333int 331int
334makes_invisible_to (object *pl, object *mon) 332makes_invisible_to (object *pl, object *mon)
335{ 333{
336
337 if (!pl->invisible) 334 if (!pl->invisible)
338 return 0; 335 return 0;
336
339 if (pl->type == PLAYER) 337 if (pl->type == PLAYER)
340 { 338 {
341 /* If race isn't set, then invisible unless it is undead */ 339 /* If race isn't set, then invisible unless it is undead */
342 if (!pl->contr->invis_race) 340 if (!pl->contr->invis_race)
343 { 341 {
344 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 342 if (QUERY_FLAG (mon, FLAG_UNDEAD))
345 return 0; 343 return 0;
344
346 return 1; 345 return 1;
347 } 346 }
347
348 /* invis_race is set if we get here */ 348 /* invis_race is set if we get here */
349 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon)) 349 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon))
350 return 1; 350 return 1;
351
351 /* No race, can't be invisible to it */ 352 /* No race, can't be invisible to it */
352 if (!mon->race) 353 if (!mon->race)
353 return 0; 354 return 0;
355
354 if (strstr (mon->race, pl->contr->invis_race)) 356 if (strstr (mon->race, pl->contr->invis_race))
355 return 1; 357 return 1;
358
356 /* Nothing matched above, return 0 */ 359 /* Nothing matched above, return 0 */
357 return 0; 360 return 0;
358 } 361 }
359 else 362 else
360 { 363 {
… …
462 if (object *pl = op->in_player ()) 465 if (object *pl = op->in_player ())
463 { 466 {
464 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST)) 467 if (pl->ms ().flags () & P_NO_CLERIC && !QUERY_FLAG (pl, FLAG_WIZCAST))
465 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you."); 468 new_draw_info (NDI_UNIQUE, 0, pl, "You feel something fizzle inside you.");
466 else 469 else
467 { 470 pl->player_goto (op->slaying, op->stats.hp, op->stats.sp);
468 // remove first so we do not call update_stats
469 op->remove ();
470 pl->enter_exit (op);
471 }
472 } 471 }
473 472
474 op->destroy (); 473 op->destroy ();
475} 474}
476 475
… …
565} 564}
566 565
567int 566int
568perceive_self (object *op) 567perceive_self (object *op)
569{ 568{
570 char buf[MAX_BUF];
571 const char *cp = describe_item (op, op); 569 const char *cp = describe_item (op, op);
572 archetype *at = archetype::find (ARCH_DEPLETION); 570 archetype *at = archetype::find (ARCH_DEPLETION);
573 object *tmp;
574 int i;
575 571
572 dynbuf_text buf;
573
574 if (player *pl = op->contr)
575 if (object *race = archetype::find (op->race))
576 buf << "You are a " << (pl->gender ? "female" : "male") << " " << &race->name << ".\n";
577
576 tmp = find_god (determine_god (op)); 578 if (object *god = find_god (determine_god (op)))
577 if (tmp) 579 buf << "You worship " << &god->name << ".\n";
578 new_draw_info_format (NDI_UNIQUE, 0, op, "You worship %s", &tmp->name);
579 else 580 else
580 new_draw_info (NDI_UNIQUE, 0, op, "You worship no god"); 581 buf << "You worship no god.\n";
581 582
582 tmp = present_arch_in_ob (at, op); 583 object *tmp = present_arch_in_ob (at, op);
583 584
584 if (*cp == '\0' && tmp == NULL) 585 if (*cp == '\0' && tmp == NULL)
585 new_draw_info (NDI_UNIQUE, 0, op, "You feel very mundane"); 586 buf << "You feel very mundane. ";
586 else 587 else
587 { 588 {
588 new_draw_info (NDI_UNIQUE, 0, op, "You have:"); 589 buf << "You have: " << cp << ".\n";
589 new_draw_info (NDI_UNIQUE, 0, op, cp);
590 590
591 if (tmp) 591 if (tmp)
592 for (i = 0; i < NUM_STATS; i++) 592 for (int i = 0; i < NUM_STATS; i++)
593 if (tmp->stats.stat (i) < 0) 593 if (tmp->stats.stat (i) < 0)
594 new_draw_info_format (NDI_UNIQUE, 0, op, "Your %s is depleted by %d", statname[i], -tmp->stats.stat (i)); 594 buf.printf ("Your %s is depleted by %d.\n", statname[i], -tmp->stats.stat (i));
595 } 595 }
596 596
597 if (is_dragon_pl (op)) 597 if (is_dragon_pl (op))
598 {
599 /* now grab the 'dragon_ability'-force from the player's inventory */ 598 /* now grab the 'dragon_ability'-force from the player's inventory */
600 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 599 for (tmp = op->inv; tmp; tmp = tmp->below)
601 { 600 {
602 if (tmp->type == FORCE && !strcmp (tmp->arch->archname, "dragon_ability_force")) 601 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
603 { 602 {
604 if (tmp->stats.exp == 0) 603 if (tmp->stats.exp == 0)
605 sprintf (buf, "Your metabolism isn't focused on anything."); 604 buf << "Your metabolism isn't focused on anything.\n";
606 else 605 else
607 sprintf (buf, "Your metabolism is focused on %s.", change_resist_msg[tmp->stats.exp]); 606 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
608 607
609 new_draw_info (NDI_UNIQUE, 0, op, buf);
610 break; 608 break;
611 } 609 }
612 } 610 }
613 } 611
612 buf << '\0'; // zero-terminate
613
614 new_draw_info (NDI_UNIQUE, 0, op, buf.linearise ());
614 615
615 return 1; 616 return 1;
616} 617}
617 618
618/* This creates magic walls. Really, it can create most any object, 619/* This creates magic walls. Really, it can create most any object,
… …
716 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name); 717 new_draw_info_format (NDI_UNIQUE, 0, op, "Something destroys your %s", name);
717 return 0; 718 return 0;
718 } 719 }
719 720
720 /* If this is a spellcasting wall, need to insert the spell object */ 721 /* If this is a spellcasting wall, need to insert the spell object */
721 if (tmp->other_arch && tmp->other_arch->clone.type == SPELL) 722 if (tmp->other_arch && tmp->other_arch->type == SPELL)
722 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp); 723 insert_ob_in_ob (arch_to_object (tmp->other_arch), tmp);
723 724
724 /* This code causes the wall to extend some distance in 725 /* This code causes the wall to extend some distance in
725 * each direction, or until an obstruction is encountered. 726 * each direction, or until an obstruction is encountered.
726 * posblocked and negblocked help determine how far the 727 * posblocked and negblocked help determine how far the
… …
746 { 747 {
747 object *tmp2 = tmp->clone (); 748 object *tmp2 = tmp->clone ();
748 m->insert (tmp2, x, y, op); 749 m->insert (tmp2, x, y, op);
749 750
750 /* If this is a spellcasting wall, need to insert the spell object */ 751 /* If this is a spellcasting wall, need to insert the spell object */
751 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 752 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
752 tmp2->insert (arch_to_object (tmp2->other_arch)); 753 tmp2->insert (arch_to_object (tmp2->other_arch));
753 754
754 } 755 }
755 else 756 else
756 posblocked = 1; 757 posblocked = 1;
… …
763 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked) 764 ((spell_ob->move_block & GET_MAP_MOVE_BLOCK (m, x, y)) != spell_ob->move_block) && !negblocked)
764 { 765 {
765 object *tmp2 = tmp->clone (); 766 object *tmp2 = tmp->clone ();
766 m->insert (tmp2, x, y, op); 767 m->insert (tmp2, x, y, op);
767 768
768 if (tmp2->other_arch && tmp2->other_arch->clone.type == SPELL) 769 if (tmp2->other_arch && tmp2->other_arch->type == SPELL)
769 tmp2->insert (arch_to_object (tmp2->other_arch)); 770 tmp2->insert (arch_to_object (tmp2->other_arch));
770 } 771 }
771 else 772 else
772 negblocked = 1; 773 negblocked = 1;
773 } 774 }
… …
889 890
890 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 891 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
891 return 1; 892 return 1;
892} 893}
893 894
894
895/* cast_heal: Heals something. 895/* cast_heal: Heals something.
896 * op is the caster. 896 * op is the caster.
897 * dir is the direction he is casting it in. 897 * dir is the direction he is casting it in.
898 * spell is the spell object. 898 * spell is the spell object.
899 */ 899 */
… …
925 { 925 {
926 /* See how many points we actually heal. Instead of messages 926 /* See how many points we actually heal. Instead of messages
927 * based on type of spell, we instead do messages based 927 * based on type of spell, we instead do messages based
928 * on amount of damage healed. 928 * on amount of damage healed.
929 */ 929 */
930 if (heal > (tmp->stats.maxhp - tmp->stats.hp)) 930 if (heal > tmp->stats.maxhp - tmp->stats.hp)
931 heal = tmp->stats.maxhp - tmp->stats.hp; 931 heal = tmp->stats.maxhp - tmp->stats.hp;
932
932 tmp->stats.hp += heal; 933 tmp->stats.hp += heal;
933 934
934 if (tmp->stats.hp >= tmp->stats.maxhp) 935 if (tmp->stats.hp >= tmp->stats.maxhp)
935 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!"); 936 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
936 else if (heal > 50) 937 else if (heal > 50)
… …
945 success = 1; 946 success = 1;
946 } 947 }
947 } 948 }
948 949
949 if (spell->attacktype & AT_DISEASE) 950 if (spell->attacktype & AT_DISEASE)
950 if (cure_disease (tmp, op)) 951 if (cure_disease (tmp, op, spell))
951 success = 1; 952 success = 1;
952 953
953 if (spell->attacktype & AT_POISON) 954 if (spell->attacktype & AT_POISON)
954 { 955 {
955 at = archetype::find ("poisoning"); 956 at = archetype::find ("poisoning");
… …
1004 } 1005 }
1005 1006
1006 if (spell->stats.food && tmp->stats.food < 999) 1007 if (spell->stats.food && tmp->stats.food < 999)
1007 { 1008 {
1008 tmp->stats.food += spell->stats.food; 1009 tmp->stats.food += spell->stats.food;
1010
1009 if (tmp->stats.food > 999) 1011 if (tmp->stats.food > 999)
1010 tmp->stats.food = 999; 1012 tmp->stats.food = 999;
1013
1011 success = 1; 1014 success = 1;
1012 /* We could do something a bit better like the messages for healing above */ 1015 /* We could do something a bit better like the messages for healing above */
1013 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 1016 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1014 } 1017 }
1015 1018
… …
1270} 1273}
1271 1274
1272/* Alchemy code by Mark Wedel 1275/* Alchemy code by Mark Wedel
1273 * 1276 *
1274 * This code adds a new spell, called alchemy. Alchemy will turn 1277 * This code adds a new spell, called alchemy. Alchemy will turn
1275 * objects to gold nuggets, the value of the gold nuggets being 1278 * objects to pyrite ("false gold"), henceforth called gold nuggets.
1276 * about 90% of that of the item itself. It uses the value of the
1277 * object before charisma adjustments, because the nuggets themselves
1278 * will be will be adjusted by charisma when sold.
1279 * 1279 *
1280 * Large nuggets are worth 25 gp each (base). You will always get 1280 * The value of the gold nuggets being about 90% of that of the item
1281 * the maximum number of large nuggets you could get. 1281 * itself. It uses the value of the object before charisma adjustments,
1282 * Small nuggets are worth 1 gp each (base). You will get from 0 1282 * because the nuggets themselves will be will be adjusted by charisma
1283 * to the max amount of small nuggets as you could get. 1283 * when sold.
1284 *
1285 * For example, if an item is worth 110 gold, you will get
1286 * 4 large nuggets, and from 0-10 small nuggets.
1287 * 1284 *
1288 * There is also a chance (1:30) that you will get nothing at all 1285 * There is also a chance (1:30) that you will get nothing at all
1289 * for the object. There is also a maximum weight that will be 1286 * for the object. There is also a maximum weight that will be
1290 * alchemised. 1287 * alchemised.
1291 */ 1288 */
1292static void 1289static void
1293alchemy_object (object *obj, uint64 &total_value, int &total_weight) 1290alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1294{ 1291{
1295 uint64 value = query_cost (obj, NULL, F_TRUE); 1292 uint64 value = query_cost (obj, NULL, F_TRUE);
1296 1293
1297 /* Give third price when we alchemy money (This should hopefully 1294 /* Give third price when we alchemy money (this should hopefully
1298 * make it so that it isn't worth it to alchemy money, sell 1295 * make it so that it isn't worth it to alchemy money, sell
1299 * the nuggets, alchemy the gold from that, etc. 1296 * the nuggets, alchemy the gold from that, etc.
1300 * Otherwise, give 9 silver on the gold for other objects, 1297 * Otherwise, give 9 silver on the gold for other objects,
1301 * so that it would still be more affordable to haul 1298 * so that it would still be more affordable to haul
1302 * the stuff back to town. 1299 * the stuff back to town.
… …
1314 total_weight += obj->total_weight (); 1311 total_weight += obj->total_weight ();
1315 1312
1316 obj->destroy (); 1313 obj->destroy ();
1317} 1314}
1318 1315
1319static void
1320update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1321{
1322 int flag = 0;
1323
1324 /* Put any nuggets below the player, but we can only pass this
1325 * flag if we are on the same space as the player
1326 */
1327 if (x == op->x && y == op->y && op->map == m)
1328 flag = INS_BELOW_ORIGINATOR;
1329
1330 if (small_nuggets)
1331 {
1332 object *tmp = small->clone ();
1333 tmp->nrof = small_nuggets;
1334 m->insert (tmp, x, y, op, flag);
1335 }
1336
1337 if (large_nuggets)
1338 {
1339 object *tmp = large->clone ();
1340 tmp->nrof = large_nuggets;
1341 m->insert (tmp, x, y, op, flag);
1342 }
1343
1344 if (object *pl = m->at (x, y).player ())
1345 if (pl->contr->ns)
1346 pl->contr->ns->look_position = 0;
1347}
1348
1349int 1316int
1350alchemy (object *op, object *caster, object *spell_ob) 1317alchemy (object *op, object *caster, object *spell_ob)
1351{ 1318{
1352 if (op->type != PLAYER) 1319 if (op->type != PLAYER)
1353 return 0; 1320 return 0;
1354 1321
1355 object *large = get_archetype ("largenugget"); 1322 archetype *nugget[3];
1356 object *small = get_archetype ("smallnugget"); 1323
1324 nugget[0] = archetype::find ("pyrite3");
1325 nugget[1] = archetype::find ("pyrite2");
1326 nugget[2] = archetype::find ("pyrite");
1357 1327
1358 /* Put a maximum weight of items that can be alchemised. Limits the power 1328 /* Put a maximum weight of items that can be alchemised. Limits the power
1359 * some, and also prevents people from alchemising every table/chair/clock 1329 * some, and also prevents people from alchemising every table/chair/clock
1360 * in sight 1330 * in sight
1361 */ 1331 */
… …
1413 if (weight > weight_max) 1383 if (weight > weight_max)
1414 break; 1384 break;
1415 } 1385 }
1416 } 1386 }
1417 1387
1388 value -= rndm (value >> 4);
1418 value = min (value, value_max); 1389 value = min (value, value_max);
1419 1390
1420 uint64 count = value / large->value; 1391 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1421 int large_nuggets = count; 1392 if (int nrof = value / nugget [i]->value)
1422 value -= count * large->value;
1423
1424 count = value / small->value;
1425 int small_nuggets = count;
1426
1427 /* Insert all the nuggets at one time. This probably saves time, but
1428 * it also prevents us from alcheming nuggets that were just created
1429 * with this spell.
1430 */ 1393 {
1431 update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny); 1394 value -= nrof * nugget[i]->value;
1395
1396 object *tmp = arch_to_object (nugget[i]);
1397 tmp->nrof = nrof;
1398 tmp->flag [FLAG_IDENTIFIED] = true;
1399 op->map->insert (tmp, x, y, op, 0);
1400 }
1432 1401
1433 if (weight > weight_max) 1402 if (weight > weight_max)
1434 goto bailout; 1403 goto bailout;
1435 } 1404 }
1436 } 1405 }
1437 1406
1438bailout: 1407bailout:
1439 large->destroy ();
1440 small->destroy ();
1441 return 1; 1408 return 1;
1442} 1409}
1443
1444 1410
1445/* This function removes the cursed/damned status on equipped 1411/* This function removes the cursed/damned status on equipped
1446 * items. 1412 * items.
1447 */ 1413 */
1448int 1414int
… …
1455 if (QUERY_FLAG (tmp, FLAG_APPLIED) && 1421 if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
1456 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) || 1422 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1457 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED)))) 1423 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1458 { 1424 {
1459 was_one++; 1425 was_one++;
1426
1460 if (tmp->level <= caster_level (caster, spell)) 1427 if (tmp->level <= caster_level (caster, spell))
1461 { 1428 {
1462 success++; 1429 success++;
1463 if (QUERY_FLAG (spell, FLAG_DAMNED)) 1430 if (QUERY_FLAG (spell, FLAG_DAMNED))
1464 CLEAR_FLAG (tmp, FLAG_DAMNED); 1431 CLEAR_FLAG (tmp, FLAG_DAMNED);
1465 1432
1466 CLEAR_FLAG (tmp, FLAG_CURSED); 1433 CLEAR_FLAG (tmp, FLAG_CURSED);
1467 CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED); 1434 CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);
1468 tmp->value = 0; /* Still can't sell it */ 1435 tmp->value = 0; /* Still can't sell it */
1469 if (op->type == PLAYER) 1436
1437 if (object *pl = tmp->visible_to ())
1470 esrv_send_item (op, tmp); 1438 esrv_update_item (UPD_FLAGS, pl, tmp);
1471 } 1439 }
1472 } 1440 }
1473 1441
1474 if (op->type == PLAYER) 1442 if (op->type == PLAYER)
1475 { 1443 {
… …
1486 1454
1487 return success; 1455 return success;
1488} 1456}
1489 1457
1490/* Identifies objects in the players inventory/on the ground */ 1458/* Identifies objects in the players inventory/on the ground */
1491
1492int 1459int
1493cast_identify (object *op, object *caster, object *spell) 1460cast_identify (object *op, object *caster, object *spell)
1494{ 1461{
1462 dynbuf_text buf;
1495 object *tmp; 1463 object *tmp;
1496 int success = 0, num_ident;
1497 1464
1498 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1465 int num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1499 1466
1500 if (num_ident < 1) 1467 if (num_ident < 1)
1501 num_ident = 1; 1468 num_ident = 1;
1502 1469
1503 for (tmp = op->inv; tmp; tmp = tmp->below) 1470 for (tmp = op->inv; tmp; tmp = tmp->below)
… …
1506 { 1473 {
1507 identify (tmp); 1474 identify (tmp);
1508 1475
1509 if (op->type == PLAYER) 1476 if (op->type == PLAYER)
1510 { 1477 {
1511 new_draw_info_format (NDI_UNIQUE, 0, op, "You identified: %s.", long_desc (tmp, op)); 1478 buf.printf ("You identified: %s.\n\n", long_desc (tmp, op));
1512 1479
1513 if (tmp->msg) 1480 if (tmp->msg)
1514 { 1481 buf << "The item has a story:\n\n" << tmp->msg << "\n\n";
1515 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1516 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1517 }
1518 } 1482 }
1519 1483
1520 num_ident--; 1484 num_ident--;
1521 success = 1;
1522 if (!num_ident) 1485 if (!num_ident)
1523 break; 1486 break;
1524 } 1487 }
1525 } 1488 }
1526 1489
… …
1533 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above) 1496 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1534 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1497 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1535 { 1498 {
1536 identify (tmp); 1499 identify (tmp);
1537 1500
1538 if (op->type == PLAYER) 1501 if (object *pl = tmp->visible_to ())
1539 { 1502 {
1540 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground you identified: %s.", long_desc (tmp, op)); 1503 buf.printf ("On the ground you identified: %s.\n\n", long_desc (tmp, op));
1541 1504
1542 if (tmp->msg) 1505 if (tmp->msg)
1543 { 1506 buf << "The item has a story:\n\n" << tmp->msg << "\n\n";
1544 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1545 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1546 }
1547
1548 esrv_send_item (op, tmp);
1549 } 1507 }
1550 1508
1551 num_ident--; 1509 num_ident--;
1552 success = 1;
1553 if (!num_ident) 1510 if (!num_ident)
1554 break; 1511 break;
1555 } 1512 }
1556 } 1513 }
1557 1514
1558 if (!success) 1515 if (buf.empty ())
1559 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified."); 1516 {
1517 op->failmsg ("You can't reach anything unidentified.");
1518 return 0;
1519 }
1560 else 1520 else
1521 {
1522 if (op->contr)
1523 op->contr->infobox (MSG_CHANNEL ("identify"), buf);
1524
1561 spell_effect (spell, op->x, op->y, op->map, op); 1525 spell_effect (spell, op->x, op->y, op->map, op);
1562 1526 return 1;
1563 return success; 1527 }
1564} 1528}
1565 1529
1566int 1530int
1567cast_detection (object *op, object *caster, object *spell, object *skill) 1531cast_detection (object *op, object *caster, object *spell, object *skill)
1568{ 1532{
… …
1710 1674
1711 /* Now process objects in the players inventory if detect curse or magic */ 1675 /* Now process objects in the players inventory if detect curse or magic */
1712 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL)) 1676 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))
1713 { 1677 {
1714 done_one = 0; 1678 done_one = 0;
1679
1715 for (tmp = op->inv; tmp; tmp = tmp->below) 1680 for (tmp = op->inv; tmp; tmp = tmp->below)
1716 { 1681 {
1717 if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED)) 1682 if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1718 { 1683 {
1719 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL)) 1684 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))
1720 { 1685 {
1721 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL); 1686 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1722 if (op->type == PLAYER) 1687
1688 if (object *pl = tmp->visible_to ())
1723 esrv_send_item (op, tmp); 1689 esrv_update_item (UPD_FLAGS, pl, tmp);
1724 } 1690 }
1691
1725 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && 1692 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1726 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))) 1693 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1727 { 1694 {
1728 SET_FLAG (tmp, FLAG_KNOWN_CURSED); 1695 SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1729 if (op->type == PLAYER) 1696
1697 if (object *pl = tmp->visible_to ())
1730 esrv_send_item (op, tmp); 1698 esrv_update_item (UPD_FLAGS, pl, tmp);
1731 } 1699 }
1732 } /* if item is not identified */ 1700 } /* if item is not identified */
1733 } /* for the players inventory */ 1701 } /* for the players inventory */
1734 } /* if detect magic/curse and object is a player */ 1702 } /* if detect magic/curse and object is a player */
1703
1735 return 1; 1704 return 1;
1736} 1705}
1737 1706
1738 1707
1739/** 1708/**
… …
1929 break; 1898 break;
1930 } 1899 }
1931 } 1900 }
1932} 1901}
1933 1902
1934
1935
1936/* cast_consecrate() - a spell to make an altar your god's */ 1903/* cast_consecrate() - a spell to make an altar your god's */
1937int 1904int
1938cast_consecrate (object *op, object *caster, object *spell) 1905cast_consecrate (object *op, object *caster, object *spell)
1939{ 1906{
1940 char buf[MAX_BUF]; 1907 char buf[MAX_BUF];
… …
1964 /* If we got here, we are consecrating an altar */ 1931 /* If we got here, we are consecrating an altar */
1965 sprintf (buf, "Altar of %s", &god->name); 1932 sprintf (buf, "Altar of %s", &god->name);
1966 tmp->name = buf; 1933 tmp->name = buf;
1967 tmp->level = caster_level (caster, spell); 1934 tmp->level = caster_level (caster, spell);
1968 tmp->other_arch = god->arch; 1935 tmp->other_arch = god->arch;
1936
1969 if (op->type == PLAYER) 1937 if (op->type == PLAYER)
1970 esrv_update_item (UPD_NAME, op, tmp); 1938 esrv_update_item (UPD_NAME, op, tmp);
1939
1971 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name); 1940 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
1972 return 1; 1941 return 1;
1973 } 1942 }
1974 } 1943 }
1975 } 1944 }
… …
1993 object *weapon, *tmp; 1962 object *weapon, *tmp;
1994 char buf[MAX_BUF]; 1963 char buf[MAX_BUF];
1995 int a, i; 1964 int a, i;
1996 sint16 x, y; 1965 sint16 x, y;
1997 maptile *m; 1966 maptile *m;
1998 materialtype_t *mt;
1999 1967
2000 if (!spell->other_arch) 1968 if (!spell->other_arch)
2001 { 1969 {
2002 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!"); 1970 new_draw_info (NDI_UNIQUE, 0, op, "Oops, program error!");
2003 LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name); 1971 LOG (llevError, "animate_weapon failed: spell %s missing other_arch!\n", &spell->name);
… …
2022 x = op->x + freearr_x[dir]; 1990 x = op->x + freearr_x[dir];
2023 y = op->y + freearr_y[dir]; 1991 y = op->y + freearr_y[dir];
2024 1992
2025 /* if there's no place to put the golem, abort */ 1993 /* if there's no place to put the golem, abort */
2026 if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) || 1994 if ((dir == -1) || (get_map_flags (m, &m, x, y, &x, &y) & P_OUT_OF_MAP) ||
2027 ((spell->other_arch->clone.move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->clone.move_type)) 1995 ((spell->other_arch->move_type & GET_MAP_MOVE_BLOCK (m, x, y)) == spell->other_arch->move_type))
2028 { 1996 {
2029 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way."); 1997 new_draw_info (NDI_UNIQUE, 0, op, "There is something in the way.");
2030 return 0; 1998 return 0;
2031 } 1999 }
2032 2000
… …
2052 { 2020 {
2053 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon)); 2021 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));
2054 return 0; 2022 return 0;
2055 } 2023 }
2056 2024
2057 if (weapon->nrof > 1) 2025 weapon = weapon->split ();
2058 {
2059 tmp = get_split_ob (weapon, 1);
2060 esrv_send_item (op, weapon);
2061 weapon = tmp;
2062 }
2063 2026
2064 /* create the golem object */ 2027 /* create the golem object */
2065 tmp = arch_to_object (spell->other_arch); 2028 tmp = arch_to_object (spell->other_arch);
2066 2029
2067 /* if animated by a player, give the player control of the golem */ 2030 /* if animated by a player, give the player control of the golem */
… …
2072 tmp->set_owner (op); 2035 tmp->set_owner (op);
2073 op->contr->golem = tmp; 2036 op->contr->golem = tmp;
2074 set_spell_skill (op, caster, spell, tmp); 2037 set_spell_skill (op, caster, spell, tmp);
2075 2038
2076 /* Give the weapon to the golem now. A bit of a hack to check the 2039 /* Give the weapon to the golem now. A bit of a hack to check the
2077 * removed flag - it should only be set if get_split_object was 2040 * removed flag - it should only be set if weapon->split was
2078 * used above. 2041 * used above.
2079 */ 2042 */
2080 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2043 if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2081 weapon->remove (); 2044 weapon->remove ();
2082 2045
2083 insert_ob_in_ob (weapon, tmp); 2046 tmp->insert (weapon);
2084 esrv_send_item (op, weapon); 2047
2085 /* To do everything necessary to let a golem use the weapon is a pain, 2048 /* To do everything necessary to let a golem use the weapon is a pain,
2086 * so instead, just set it as equipped (otherwise, we need to update 2049 * so instead, just set it as equipped (otherwise, we need to update
2087 * body_info, skills, etc) 2050 * body_info, skills, etc)
2088 */ 2051 */
2089 SET_FLAG (tmp, FLAG_USE_WEAPON); 2052 SET_FLAG (tmp, FLAG_USE_WEAPON);
… …
2115 2078
2116 /* attacktype */ 2079 /* attacktype */
2117 if (!tmp->attacktype) 2080 if (!tmp->attacktype)
2118 tmp->attacktype = AT_PHYSICAL; 2081 tmp->attacktype = AT_PHYSICAL;
2119 2082
2120 mt = NULL;
2121 if (op->materialname != NULL)
2122 mt = name_to_material (op->materialname); 2083 if (materialtype_t *mt = name_to_material (op->materialname))
2123 if (mt != NULL)
2124 { 2084 {
2125 for (i = 0; i < NROFATTACKS; i++) 2085 for (i = 0; i < NROFATTACKS; i++)
2126 tmp->resist[i] = 50 - (mt->save[i] * 5); 2086 tmp->resist[i] = 50 - (mt->save[i] * 5);
2127 a = mt->save[0]; 2087 a = mt->save[0];
2128 } 2088 }
… …
2130 { 2090 {
2131 for (i = 0; i < NROFATTACKS; i++) 2091 for (i = 0; i < NROFATTACKS; i++)
2132 tmp->resist[i] = 5; 2092 tmp->resist[i] = 5;
2133 a = 10; 2093 a = 10;
2134 } 2094 }
2095
2135 /* Set weapon's immunity */ 2096 /* Set weapon's immunity */
2136 tmp->resist[ATNR_CONFUSION] = 100; 2097 tmp->resist[ATNR_CONFUSION] = 100;
2137 tmp->resist[ATNR_POISON] = 100; 2098 tmp->resist[ATNR_POISON] = 100;
2138 tmp->resist[ATNR_SLOW] = 100; 2099 tmp->resist[ATNR_SLOW] = 100;
2139 tmp->resist[ATNR_PARALYZE] = 100; 2100 tmp->resist[ATNR_PARALYZE] = 100;
… …
2145 2106
2146 /* Improve weapon's armour value according to best save vs. physical of its material */ 2107 /* Improve weapon's armour value according to best save vs. physical of its material */
2147 2108
2148 if (a > 14) 2109 if (a > 14)
2149 a = 14; 2110 a = 14;
2111
2150 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a)); 2112 tmp->resist[ATNR_PHYSICAL] = 100 - (int) ((100.0 - (float) tmp->resist[ATNR_PHYSICAL]) / (30.0 - 2.0 * a));
2151 2113
2152 /* Determine golem's speed */ 2114 /* Determine golem's speed */
2153 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell))); 2115 tmp->set_speed (min (3.33, 0.4 + 0.1 * SP_level_range_adjust (caster, spell)));
2154 2116
… …
2199 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here."); 2161 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2200 } 2162 }
2201 return success; 2163 return success;
2202} 2164}
2203 2165
2204
2205
2206
2207
2208/* create an aura spell object and put it in the player's inventory. 2166/* create an aura spell object and put it in the player's inventory.
2209 * as usual, op is player, caster is the object casting the spell, 2167 * as usual, op is player, caster is the object casting the spell,
2210 * spell is the spell object itself. 2168 * spell is the spell object itself.
2211 */ 2169 */
2212int 2170int
… …
2223 2181
2224 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2182 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2225 2183
2226 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2184 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2227 2185
2228 new_aura->set_owner (op);
2229 set_spell_skill (op, caster, spell, new_aura); 2186 set_spell_skill (op, caster, spell, new_aura);
2230 new_aura->attacktype = spell->attacktype; 2187 new_aura->attacktype = spell->attacktype;
2231 2188
2232 new_aura->level = caster_level (caster, spell); 2189 new_aura->level = caster_level (caster, spell);
2190
2233 if (refresh) 2191 if (refresh)
2234 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 2192 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2235 else 2193 else
2236 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force."); 2194 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
2195
2237 insert_ob_in_ob (new_aura, op); 2196 insert_ob_in_ob (new_aura, op);
2197 new_aura->set_owner (op);
2198
2238 return 1; 2199 return 1;
2239} 2200}
2240
2241 2201
2242/* move aura function. An aura is a part of someone's inventory, 2202/* move aura function. An aura is a part of someone's inventory,
2243 * which he carries with him, but which acts on the map immediately 2203 * which he carries with him, but which acts on the map immediately
2244 * around him. 2204 * around him.
2245 * Aura parameters: 2205 * Aura parameters:
2246 * duration: duration counter. 2206 * duration: duration counter.
2247 * attacktype: aura's attacktype 2207 * attacktype: aura's attacktype
2248 * other_arch: archetype to drop where we attack 2208 * other_arch: archetype to drop where we attack
2249 */ 2209 */
2250
2251void 2210void
2252move_aura (object *aura) 2211move_aura (object *aura)
2253{ 2212{
2254 int i, mflags;
2255 object *env;
2256 maptile *m;
2257
2258 /* auras belong in inventories */ 2213 /* auras belong in inventories */
2259 env = aura->env; 2214 object *env = aura->env;
2215 object *owner = aura->owner;
2260 2216
2261 /* no matter what we've gotta remove the aura... 2217 /* no matter what we've gotta remove the aura...
2262 * we'll put it back if its time isn't up. 2218 * we'll put it back if its time isn't up.
2263 */ 2219 */
2264 aura->remove (); 2220 aura->remove ();
… …
2269 aura->destroy (); 2225 aura->destroy ();
2270 return; 2226 return;
2271 } 2227 }
2272 2228
2273 /* auras only exist in inventories */ 2229 /* auras only exist in inventories */
2274 if (env == NULL || env->map == NULL) 2230 if (!env || !env->map)
2275 { 2231 {
2276 aura->destroy (); 2232 aura->destroy ();
2277 return; 2233 return;
2278 } 2234 }
2279 2235
2280 /* we need to jump out of the inventory for a bit 2236 /* we need to jump out of the inventory for a bit
2281 * in order to hit the map conveniently. 2237 * in order to hit the map conveniently.
2282 */ 2238 */
2283 aura->insert_at (env, aura); 2239 aura->insert_at (env, aura);
2284 2240
2285 for (i = 1; i < 9; i++) 2241 for (int i = 1; i < 9; i++)
2286 { 2242 {
2287 sint16 nx, ny; 2243 mapxy pos (env);
2244 pos.move (i);
2288 2245
2289 nx = aura->x + freearr_x[i];
2290 ny = aura->y + freearr_y[i];
2291 mflags = get_map_flags (env->map, &m, nx, ny, &nx, &ny);
2292
2293 /* Consider the movement tyep of the person with the aura as 2246 /* Consider the movement type of the person with the aura as
2294 * movement type of the aura. Eg, if the player is flying, the aura 2247 * movement type of the aura. Eg, if the player is flying, the aura
2295 * is flying also, if player is walking, it is on the ground, etc. 2248 * is flying also, if player is walking, it is on the ground, etc.
2296 */ 2249 */
2297 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny)))) 2250 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2298 { 2251 {
2299 hit_map (aura, i, aura->attacktype, 0); 2252 hit_map (aura, i, aura->attacktype, 0);
2300 2253
2301 if (aura->other_arch) 2254 if (aura->other_arch)
2302 m->insert (arch_to_object (aura->other_arch), nx, ny, aura); 2255 pos.insert (arch_to_object (aura->other_arch), aura);
2303 } 2256 }
2304 } 2257 }
2305 2258
2306 /* put the aura back in the player's inventory */ 2259 /* put the aura back in the player's inventory */
2307 aura->remove (); 2260 env->insert (aura);
2308 insert_ob_in_ob (aura, env); 2261 aura->set_owner (owner);
2309} 2262}
2310 2263
2311/* moves the peacemaker spell. 2264/* moves the peacemaker spell.
2312 * op is the piece object. 2265 * op is the piece object.
2313 */ 2266 */
2314
2315void 2267void
2316move_peacemaker (object *op) 2268move_peacemaker (object *op)
2317{ 2269{
2318 object *tmp; 2270 object *tmp;
2319 2271
2320 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 2272 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2321 { 2273 {
2322 int atk_lev, def_lev; 2274 int atk_lev, def_lev;
2323 object *victim = tmp; 2275 object *victim = tmp->head_ ();
2324 2276
2325 if (tmp->head)
2326 victim = tmp->head;
2327 if (!QUERY_FLAG (victim, FLAG_MONSTER)) 2277 if (!QUERY_FLAG (victim, FLAG_MONSTER))
2328 continue; 2278 continue;
2279
2329 if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE)) 2280 if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))
2330 continue; 2281 continue;
2282
2331 if (victim->stats.exp == 0) 2283 if (victim->stats.exp == 0)
2332 continue; 2284 continue;
2333 2285
2334 def_lev = MAX (1, victim->level); 2286 def_lev = MAX (1, victim->level);
2335 atk_lev = MAX (1, op->level); 2287 atk_lev = MAX (1, op->level);
2336 2288
2337 if (rndm (0, atk_lev - 1) > def_lev) 2289 if (rndm (0, atk_lev - 1) > def_lev)
2338 { 2290 {
2339 /* make this sucker peaceful. */ 2291 /* make this sucker peaceful. */
2340 2292
2293 INVOKE_OBJECT (KILL, victim, ARG_OBJECT (op));
2341 change_exp (op->owner, victim->stats.exp, op->skill, 0); 2294 change_exp (op->owner, victim->stats.exp, op->skill, 0);
2342 victim->stats.exp = 0; 2295 victim->stats.exp = 0;
2343#if 0 2296#if 0
2344 /* No idea why these were all set to zero - if something 2297 /* No idea why these were all set to zero - if something
2345 * makes this creature agressive, he should still do damage. 2298 * makes this creature agressive, he should still do damage.
… …
2352 victim->attack_movement = RANDO2; 2305 victim->attack_movement = RANDO2;
2353 SET_FLAG (victim, FLAG_UNAGGRESSIVE); 2306 SET_FLAG (victim, FLAG_UNAGGRESSIVE);
2354 SET_FLAG (victim, FLAG_RUN_AWAY); 2307 SET_FLAG (victim, FLAG_RUN_AWAY);
2355 SET_FLAG (victim, FLAG_RANDOM_MOVE); 2308 SET_FLAG (victim, FLAG_RANDOM_MOVE);
2356 CLEAR_FLAG (victim, FLAG_MONSTER); 2309 CLEAR_FLAG (victim, FLAG_MONSTER);
2310
2357 if (victim->name) 2311 if (victim->name)
2358 {
2359 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name); 2312 new_draw_info_format (NDI_UNIQUE, 0, op->owner, "%s no longer feels like fighting.", &victim->name);
2360 }
2361 } 2313 }
2362 } 2314 }
2363} 2315}
2364 2316
2365 2317

Diff Legend

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