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.66 by root, Fri Aug 10 01:47:53 2007 UTC vs.
Revision 1.79 by root, Mon Apr 21 07:01:40 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 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>
… …
125 * create nonnmagic arrows, or even -1, etc... 125 * create nonnmagic arrows, or even -1, etc...
126 */ 126 */
127int 127int
128cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg) 128cast_create_missile (object *op, object *caster, object *spell, int dir, const char *stringarg)
129{ 129{
130 int missile_plus = 0, bonus_plus = 0; 130 int bonus_plus = 0;
131 const char *missile_name; 131 const char *missile_name = "arrow";
132 object *tmp, *missile;
133 132
134 missile_name = "arrow";
135
136 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 133 for (object *tmp = op->inv; tmp; tmp = tmp->below)
137 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED)) 134 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
138 missile_name = tmp->race; 135 missile_name = tmp->race;
139 136
140 missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell); 137 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
141 138
142 if (archetype::find (missile_name) == NULL) 139 archetype *missile_arch = archetype::find (missile_name);
140
141 if (!missile_arch)
143 { 142 {
144 LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name); 143 LOG (llevDebug, "Cast create_missile: could not find archetype %s\n", missile_name);
145 return 0; 144 return 0;
146 } 145 }
147 146
148 missile = get_archetype (missile_name); 147 object *missile = missile_arch->instance ();
149 148
150 if (stringarg) 149 if (stringarg)
151 { 150 {
152 /* If it starts with a letter, presume it is a description */ 151 /* If it starts with a letter, presume it is a description */
153 if (isalpha (*stringarg)) 152 if (isalpha (*stringarg))
… …
171 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg); 170 new_draw_info_format (NDI_UNIQUE, 0, op, "You are not allowed to create %ss of %s", missile_name, stringarg);
172 return 0; 171 return 0;
173 } 172 }
174 173
175 give_artifact_abilities (missile, al->item); 174 give_artifact_abilities (missile, al->item);
176 /* These special arrows cost something extra. Don't have them also be magical - 175 /* These special arrows cost something extra. Don't have them also be magical -
177 * otherwise, in most cases, not enough will be created. I don't want to get into 176 * otherwise, in most cases, not enough will be created. I don't want to get into
178 * the parsing of having to do both plus and type. 177 * the parsing of having to do both plus and type.
179 */ 178 */
180 bonus_plus = 1 + (al->item->value / 5); 179 bonus_plus = 1 + (al->item->value / 5);
181 missile_plus = 0; 180 missile_plus = 0;
182 } 181 }
183 else if (atoi (stringarg) < missile_plus) 182 else if (atoi (stringarg) < missile_plus)
184 missile_plus = atoi (stringarg); 183 missile_plus = atoi (stringarg);
185 } 184 }
186 185
187 if (missile_plus > 4) 186 missile_plus = clamp (missile_plus, -4, 4);
188 missile_plus = 4;
189 else if (missile_plus < -4)
190 missile_plus = -4;
191 187
192 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell); 188 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
193 missile->nrof -= 3 * (missile_plus + bonus_plus); 189 missile->nrof -= 3 * (missile_plus + bonus_plus);
194 190
195 if (missile->nrof < 1) 191 if (missile->nrof < 1)
… …
215{ 211{
216 int food_value; 212 int food_value;
217 archetype *at = NULL; 213 archetype *at = NULL;
218 object *new_op; 214 object *new_op;
219 215
220 food_value = spell_ob->stats.food + +50 * SP_level_duration_adjust (caster, spell_ob); 216 food_value = spell_ob->stats.food + 50 * SP_level_duration_adjust (caster, spell_ob);
221 217
222 if (stringarg) 218 if (stringarg)
223 { 219 {
224 at = find_archetype_by_object_type_name (FOOD, stringarg); 220 at = find_archetype_by_object_type_name (FOOD, stringarg);
225 if (at == NULL) 221 if (at == NULL)
… …
284{ 280{
285 int r, mflags, maxrange; 281 int r, mflags, maxrange;
286 object *tmp; 282 object *tmp;
287 maptile *m; 283 maptile *m;
288 284
289
290 if (!dir) 285 if (!dir)
291 { 286 {
292 examine_monster (op, op); 287 examine_monster (op, op);
293 return 1; 288 return 1;
294 } 289 }
… …
335 * pl is invisible. 330 * pl is invisible.
336 */ 331 */
337int 332int
338makes_invisible_to (object *pl, object *mon) 333makes_invisible_to (object *pl, object *mon)
339{ 334{
340
341 if (!pl->invisible) 335 if (!pl->invisible)
342 return 0; 336 return 0;
337
343 if (pl->type == PLAYER) 338 if (pl->type == PLAYER)
344 { 339 {
345 /* If race isn't set, then invisible unless it is undead */ 340 /* If race isn't set, then invisible unless it is undead */
346 if (!pl->contr->invis_race) 341 if (!pl->contr->invis_race)
347 { 342 {
348 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 343 if (QUERY_FLAG (mon, FLAG_UNDEAD))
349 return 0; 344 return 0;
345
350 return 1; 346 return 1;
351 } 347 }
348
352 /* invis_race is set if we get here */ 349 /* invis_race is set if we get here */
353 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon)) 350 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon))
354 return 1; 351 return 1;
352
355 /* No race, can't be invisible to it */ 353 /* No race, can't be invisible to it */
356 if (!mon->race) 354 if (!mon->race)
357 return 0; 355 return 0;
356
358 if (strstr (mon->race, pl->contr->invis_race)) 357 if (strstr (mon->race, pl->contr->invis_race))
359 return 1; 358 return 1;
359
360 /* Nothing matched above, return 0 */ 360 /* Nothing matched above, return 0 */
361 return 0; 361 return 0;
362 } 362 }
363 else 363 else
364 { 364 {
… …
601 601
602 if (is_dragon_pl (op)) 602 if (is_dragon_pl (op))
603 /* now grab the 'dragon_ability'-force from the player's inventory */ 603 /* now grab the 'dragon_ability'-force from the player's inventory */
604 for (tmp = op->inv; tmp; tmp = tmp->below) 604 for (tmp = op->inv; tmp; tmp = tmp->below)
605 { 605 {
606 if (tmp->type == FORCE && !strcmp (tmp->arch->archname, "dragon_ability_force")) 606 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
607 { 607 {
608 if (tmp->stats.exp == 0) 608 if (tmp->stats.exp == 0)
609 buf << "Your metabolism isn't focused on anything.\n"; 609 buf << "Your metabolism isn't focused on anything.\n";
610 else 610 else
611 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n"; 611 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
… …
895 895
896 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 896 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
897 return 1; 897 return 1;
898} 898}
899 899
900
901/* cast_heal: Heals something. 900/* cast_heal: Heals something.
902 * op is the caster. 901 * op is the caster.
903 * dir is the direction he is casting it in. 902 * dir is the direction he is casting it in.
904 * spell is the spell object. 903 * spell is the spell object.
905 */ 904 */
… …
931 { 930 {
932 /* See how many points we actually heal. Instead of messages 931 /* See how many points we actually heal. Instead of messages
933 * based on type of spell, we instead do messages based 932 * based on type of spell, we instead do messages based
934 * on amount of damage healed. 933 * on amount of damage healed.
935 */ 934 */
936 if (heal > (tmp->stats.maxhp - tmp->stats.hp)) 935 if (heal > tmp->stats.maxhp - tmp->stats.hp)
937 heal = tmp->stats.maxhp - tmp->stats.hp; 936 heal = tmp->stats.maxhp - tmp->stats.hp;
937
938 tmp->stats.hp += heal; 938 tmp->stats.hp += heal;
939 939
940 if (tmp->stats.hp >= tmp->stats.maxhp) 940 if (tmp->stats.hp >= tmp->stats.maxhp)
941 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!"); 941 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
942 else if (heal > 50) 942 else if (heal > 50)
… …
951 success = 1; 951 success = 1;
952 } 952 }
953 } 953 }
954 954
955 if (spell->attacktype & AT_DISEASE) 955 if (spell->attacktype & AT_DISEASE)
956 if (cure_disease (tmp, op)) 956 if (cure_disease (tmp, op, spell))
957 success = 1; 957 success = 1;
958 958
959 if (spell->attacktype & AT_POISON) 959 if (spell->attacktype & AT_POISON)
960 { 960 {
961 at = archetype::find ("poisoning"); 961 at = archetype::find ("poisoning");
… …
1010 } 1010 }
1011 1011
1012 if (spell->stats.food && tmp->stats.food < 999) 1012 if (spell->stats.food && tmp->stats.food < 999)
1013 { 1013 {
1014 tmp->stats.food += spell->stats.food; 1014 tmp->stats.food += spell->stats.food;
1015
1015 if (tmp->stats.food > 999) 1016 if (tmp->stats.food > 999)
1016 tmp->stats.food = 999; 1017 tmp->stats.food = 999;
1018
1017 success = 1; 1019 success = 1;
1018 /* We could do something a bit better like the messages for healing above */ 1020 /* We could do something a bit better like the messages for healing above */
1019 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food"); 1021 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1020 } 1022 }
1021 1023
… …
1292static void 1294static void
1293alchemy_object (object *obj, uint64 &total_value, int &total_weight) 1295alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1294{ 1296{
1295 uint64 value = query_cost (obj, NULL, F_TRUE); 1297 uint64 value = query_cost (obj, NULL, F_TRUE);
1296 1298
1297 /* Give third price when we alchemy money (This should hopefully 1299 /* Give third price when we alchemy money (this should hopefully
1298 * make it so that it isn't worth it to alchemy money, sell 1300 * make it so that it isn't worth it to alchemy money, sell
1299 * the nuggets, alchemy the gold from that, etc. 1301 * the nuggets, alchemy the gold from that, etc.
1300 * Otherwise, give 9 silver on the gold for other objects, 1302 * Otherwise, give 9 silver on the gold for other objects,
1301 * so that it would still be more affordable to haul 1303 * so that it would still be more affordable to haul
1302 * the stuff back to town. 1304 * the stuff back to town.
… …
1397 value -= nrof * nugget[i]->value; 1399 value -= nrof * nugget[i]->value;
1398 1400
1399 object *tmp = arch_to_object (nugget[i]); 1401 object *tmp = arch_to_object (nugget[i]);
1400 tmp->nrof = nrof; 1402 tmp->nrof = nrof;
1401 tmp->flag [FLAG_IDENTIFIED] = true; 1403 tmp->flag [FLAG_IDENTIFIED] = true;
1402 caster->map->insert (tmp, x, y, caster, 0); 1404 op->map->insert (tmp, x, y, op, 0);
1403 } 1405 }
1404 1406
1405 if (weight > weight_max) 1407 if (weight > weight_max)
1406 goto bailout; 1408 goto bailout;
1407 } 1409 }
… …
1456 1458
1457 return success; 1459 return success;
1458} 1460}
1459 1461
1460/* Identifies objects in the players inventory/on the ground */ 1462/* Identifies objects in the players inventory/on the ground */
1461
1462int 1463int
1463cast_identify (object *op, object *caster, object *spell) 1464cast_identify (object *op, object *caster, object *spell)
1464{ 1465{
1466 dynbuf_text buf;
1465 object *tmp; 1467 object *tmp;
1466 int success = 0, num_ident;
1467 1468
1468 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1469 int num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1469 1470
1470 if (num_ident < 1) 1471 if (num_ident < 1)
1471 num_ident = 1; 1472 num_ident = 1;
1472 1473
1473 for (tmp = op->inv; tmp; tmp = tmp->below) 1474 for (tmp = op->inv; tmp; tmp = tmp->below)
… …
1476 { 1477 {
1477 identify (tmp); 1478 identify (tmp);
1478 1479
1479 if (op->type == PLAYER) 1480 if (op->type == PLAYER)
1480 { 1481 {
1481 new_draw_info_format (NDI_UNIQUE, 0, op, "You identified: %s.", long_desc (tmp, op)); 1482 buf.printf ("You identified: %s.\n\n", long_desc (tmp, op));
1482 1483
1483 if (tmp->msg) 1484 if (tmp->msg)
1484 { 1485 buf << "The item has a story:\n\n" << tmp->msg << "\n\n";
1485 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1486 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1487 }
1488 } 1486 }
1489 1487
1490 num_ident--; 1488 num_ident--;
1491 success = 1;
1492 if (!num_ident) 1489 if (!num_ident)
1493 break; 1490 break;
1494 } 1491 }
1495 } 1492 }
1496 1493
… …
1505 { 1502 {
1506 identify (tmp); 1503 identify (tmp);
1507 1504
1508 if (op->type == PLAYER) 1505 if (op->type == PLAYER)
1509 { 1506 {
1510 new_draw_info_format (NDI_UNIQUE, 0, op, "On the ground you identified: %s.", long_desc (tmp, op)); 1507 buf.printf ("On the ground you identified: %s.\n\n", long_desc (tmp, op));
1511 1508
1512 if (tmp->msg) 1509 if (tmp->msg)
1513 { 1510 buf << "The item has a story:\n\n" << tmp->msg << "\n\n";
1514 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1515 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1516 }
1517 1511
1518 esrv_send_item (op, tmp); 1512 esrv_send_item (op, tmp);
1519 } 1513 }
1520 1514
1521 num_ident--; 1515 num_ident--;
1522 success = 1;
1523 if (!num_ident) 1516 if (!num_ident)
1524 break; 1517 break;
1525 } 1518 }
1526 } 1519 }
1527 1520
1528 if (!success) 1521 if (buf.empty ())
1529 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified."); 1522 {
1523 op->failmsg ("You can't reach anything unidentified.");
1524 return 0;
1525 }
1530 else 1526 else
1527 {
1528 if (op->contr)
1529 op->contr->infobox (MSG_CHANNEL ("identify"), buf);
1530
1531 spell_effect (spell, op->x, op->y, op->map, op); 1531 spell_effect (spell, op->x, op->y, op->map, op);
1532 1532 return 1;
1533 return success; 1533 }
1534} 1534}
1535 1535
1536int 1536int
1537cast_detection (object *op, object *caster, object *spell, object *skill) 1537cast_detection (object *op, object *caster, object *spell, object *skill)
1538{ 1538{
… …
2023 return 0; 2023 return 0;
2024 } 2024 }
2025 2025
2026 if (weapon->nrof > 1) 2026 if (weapon->nrof > 1)
2027 { 2027 {
2028 tmp = get_split_ob (weapon, 1); 2028 tmp = weapon->split ();
2029 esrv_send_item (op, weapon); 2029 esrv_send_item (op, weapon);
2030 weapon = tmp; 2030 weapon = tmp;
2031 } 2031 }
2032 2032
2033 /* create the golem object */ 2033 /* create the golem object */
… …
2041 tmp->set_owner (op); 2041 tmp->set_owner (op);
2042 op->contr->golem = tmp; 2042 op->contr->golem = tmp;
2043 set_spell_skill (op, caster, spell, tmp); 2043 set_spell_skill (op, caster, spell, tmp);
2044 2044
2045 /* 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
2046 * removed flag - it should only be set if get_split_object was 2046 * removed flag - it should only be set if weapon->split was
2047 * used above. 2047 * used above.
2048 */ 2048 */
2049 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2049 if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2050 weapon->remove (); 2050 weapon->remove ();
2051 2051
… …
2167 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here."); 2167 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2168 } 2168 }
2169 return success; 2169 return success;
2170} 2170}
2171 2171
2172
2173
2174
2175
2176/* 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.
2177 * 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,
2178 * spell is the spell object itself. 2174 * spell is the spell object itself.
2179 */ 2175 */
2180int 2176int
… …
2191 2187
2192 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);
2193 2189
2194 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);
2195 2191
2196 new_aura->set_owner (op);
2197 set_spell_skill (op, caster, spell, new_aura); 2192 set_spell_skill (op, caster, spell, new_aura);
2198 new_aura->attacktype = spell->attacktype; 2193 new_aura->attacktype = spell->attacktype;
2199 2194
2200 new_aura->level = caster_level (caster, spell); 2195 new_aura->level = caster_level (caster, spell);
2196
2201 if (refresh) 2197 if (refresh)
2202 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.");
2203 else 2199 else
2204 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
2205 insert_ob_in_ob (new_aura, op); 2202 insert_ob_in_ob (new_aura, op);
2203 new_aura->set_owner (op);
2204
2206 return 1; 2205 return 1;
2207} 2206}
2208
2209 2207
2210/* 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,
2211 * 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
2212 * around him. 2210 * around him.
2213 * Aura parameters: 2211 * Aura parameters:
2214 * duration: duration counter. 2212 * duration: duration counter.
2215 * attacktype: aura's attacktype 2213 * attacktype: aura's attacktype
2216 * other_arch: archetype to drop where we attack 2214 * other_arch: archetype to drop where we attack
2217 */ 2215 */
2218
2219void 2216void
2220move_aura (object *aura) 2217move_aura (object *aura)
2221{ 2218{
2222 int i, mflags;
2223 object *env;
2224 maptile *m;
2225
2226 /* auras belong in inventories */ 2219 /* auras belong in inventories */
2227 env = aura->env; 2220 object *env = aura->env;
2221 object *owner = aura->owner;
2228 2222
2229 /* no matter what we've gotta remove the aura... 2223 /* no matter what we've gotta remove the aura...
2230 * we'll put it back if its time isn't up. 2224 * we'll put it back if its time isn't up.
2231 */ 2225 */
2232 aura->remove (); 2226 aura->remove ();
… …
2237 aura->destroy (); 2231 aura->destroy ();
2238 return; 2232 return;
2239 } 2233 }
2240 2234
2241 /* auras only exist in inventories */ 2235 /* auras only exist in inventories */
2242 if (env == NULL || env->map == NULL) 2236 if (!env || !env->map)
2243 { 2237 {
2244 aura->destroy (); 2238 aura->destroy ();
2245 return; 2239 return;
2246 } 2240 }
2247 2241
2248 /* we need to jump out of the inventory for a bit 2242 /* we need to jump out of the inventory for a bit
2249 * in order to hit the map conveniently. 2243 * in order to hit the map conveniently.
2250 */ 2244 */
2251 aura->insert_at (env, aura); 2245 aura->insert_at (env, aura);
2252 2246
2253 for (i = 1; i < 9; i++) 2247 for (int i = 1; i < 9; i++)
2254 { 2248 {
2255 sint16 nx, ny; 2249 mapxy pos (env);
2250 pos.move (i);
2256 2251
2257 nx = aura->x + freearr_x[i];
2258 ny = aura->y + freearr_y[i];
2259 mflags = get_map_flags (env->map, &m, nx, ny, &nx, &ny);
2260
2261 /* Consider the movement tyep of the person with the aura as 2252 /* Consider the movement type of the person with the aura as
2262 * 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
2263 * 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.
2264 */ 2255 */
2265 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)))
2266 { 2257 {
2267 hit_map (aura, i, aura->attacktype, 0); 2258 hit_map (aura, i, aura->attacktype, 0);
2268 2259
2269 if (aura->other_arch) 2260 if (aura->other_arch)
2270 m->insert (arch_to_object (aura->other_arch), nx, ny, aura); 2261 pos.insert (arch_to_object (aura->other_arch), aura);
2271 } 2262 }
2272 } 2263 }
2273 2264
2274 /* put the aura back in the player's inventory */ 2265 /* put the aura back in the player's inventory */
2275 aura->remove (); 2266 env->insert (aura);
2276 insert_ob_in_ob (aura, env); 2267 aura->set_owner (owner);
2277} 2268}
2278 2269
2279/* moves the peacemaker spell. 2270/* moves the peacemaker spell.
2280 * op is the piece object. 2271 * op is the piece object.
2281 */ 2272 */
2282
2283void 2273void
2284move_peacemaker (object *op) 2274move_peacemaker (object *op)
2285{ 2275{
2286 object *tmp; 2276 object *tmp;
2287 2277

Diff Legend

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