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.65 by root, Wed Aug 1 00:26:04 2007 UTC vs.
Revision 1.81 by root, Sat May 3 12:29:09 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>
… …
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 op->play_sound (sound_find ("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)
… …
125 * create nonnmagic arrows, or even -1, etc... 124 * create nonnmagic arrows, or even -1, etc...
126 */ 125 */
127int 126int
128cast_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)
129{ 128{
130 int missile_plus = 0, bonus_plus = 0; 129 int bonus_plus = 0;
131 const char *missile_name; 130 const char *missile_name = "arrow";
132 object *tmp, *missile;
133 131
134 missile_name = "arrow";
135
136 for (tmp = op->inv; tmp != NULL; tmp = tmp->below) 132 for (object *tmp = op->inv; tmp; tmp = tmp->below)
137 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED)) 133 if (tmp->type == BOW && QUERY_FLAG (tmp, FLAG_APPLIED))
138 missile_name = tmp->race; 134 missile_name = tmp->race;
139 135
140 missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell); 136 int missile_plus = spell->stats.dam + SP_level_dam_adjust (caster, spell);
141 137
142 if (archetype::find (missile_name) == NULL) 138 archetype *missile_arch = archetype::find (missile_name);
139
140 if (!missile_arch)
143 { 141 {
144 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);
145 return 0; 143 return 0;
146 } 144 }
147 145
148 missile = get_archetype (missile_name); 146 object *missile = missile_arch->instance ();
149 147
150 if (stringarg) 148 if (stringarg)
151 { 149 {
152 /* If it starts with a letter, presume it is a description */ 150 /* If it starts with a letter, presume it is a description */
153 if (isalpha (*stringarg)) 151 if (isalpha (*stringarg))
… …
171 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);
172 return 0; 170 return 0;
173 } 171 }
174 172
175 give_artifact_abilities (missile, al->item); 173 give_artifact_abilities (missile, al->item);
176 /* 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 -
177 * 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
178 * the parsing of having to do both plus and type. 176 * the parsing of having to do both plus and type.
179 */ 177 */
180 bonus_plus = 1 + (al->item->value / 5); 178 bonus_plus = 1 + (al->item->value / 5);
181 missile_plus = 0; 179 missile_plus = 0;
182 } 180 }
183 else if (atoi (stringarg) < missile_plus) 181 else if (atoi (stringarg) < missile_plus)
184 missile_plus = atoi (stringarg); 182 missile_plus = atoi (stringarg);
185 } 183 }
186 184
187 if (missile_plus > 4) 185 missile_plus = clamp (missile_plus, -4, 4);
188 missile_plus = 4;
189 else if (missile_plus < -4)
190 missile_plus = -4;
191 186
192 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell); 187 missile->nrof = spell->duration + SP_level_duration_adjust (caster, spell);
193 missile->nrof -= 3 * (missile_plus + bonus_plus); 188 missile->nrof -= 3 * (missile_plus + bonus_plus);
194 189
195 if (missile->nrof < 1) 190 if (missile->nrof < 1)
… …
215{ 210{
216 int food_value; 211 int food_value;
217 archetype *at = NULL; 212 archetype *at = NULL;
218 object *new_op; 213 object *new_op;
219 214
220 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);
221 216
222 if (stringarg) 217 if (stringarg)
223 { 218 {
224 at = find_archetype_by_object_type_name (FOOD, stringarg); 219 at = find_archetype_by_object_type_name (FOOD, stringarg);
225 if (at == NULL) 220 if (at == NULL)
… …
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 }
… …
335 * pl is invisible. 329 * pl is invisible.
336 */ 330 */
337int 331int
338makes_invisible_to (object *pl, object *mon) 332makes_invisible_to (object *pl, object *mon)
339{ 333{
340
341 if (!pl->invisible) 334 if (!pl->invisible)
342 return 0; 335 return 0;
336
343 if (pl->type == PLAYER) 337 if (pl->type == PLAYER)
344 { 338 {
345 /* If race isn't set, then invisible unless it is undead */ 339 /* If race isn't set, then invisible unless it is undead */
346 if (!pl->contr->invis_race) 340 if (!pl->contr->invis_race)
347 { 341 {
348 if (QUERY_FLAG (mon, FLAG_UNDEAD)) 342 if (QUERY_FLAG (mon, FLAG_UNDEAD))
349 return 0; 343 return 0;
344
350 return 1; 345 return 1;
351 } 346 }
347
352 /* invis_race is set if we get here */ 348 /* invis_race is set if we get here */
353 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon)) 349 if (!strcmp (pl->contr->invis_race, "undead") && is_true_undead (mon))
354 return 1; 350 return 1;
351
355 /* No race, can't be invisible to it */ 352 /* No race, can't be invisible to it */
356 if (!mon->race) 353 if (!mon->race)
357 return 0; 354 return 0;
355
358 if (strstr (mon->race, pl->contr->invis_race)) 356 if (strstr (mon->race, pl->contr->invis_race))
359 return 1; 357 return 1;
358
360 /* Nothing matched above, return 0 */ 359 /* Nothing matched above, return 0 */
361 return 0; 360 return 0;
362 } 361 }
363 else 362 else
364 { 363 {
… …
601 600
602 if (is_dragon_pl (op)) 601 if (is_dragon_pl (op))
603 /* now grab the 'dragon_ability'-force from the player's inventory */ 602 /* now grab the 'dragon_ability'-force from the player's inventory */
604 for (tmp = op->inv; tmp; tmp = tmp->below) 603 for (tmp = op->inv; tmp; tmp = tmp->below)
605 { 604 {
606 if (tmp->type == FORCE && !strcmp (tmp->arch->archname, "dragon_ability_force")) 605 if (tmp->type == FORCE && tmp->arch->archname == shstr_dragon_ability_force)
607 { 606 {
608 if (tmp->stats.exp == 0) 607 if (tmp->stats.exp == 0)
609 buf << "Your metabolism isn't focused on anything.\n"; 608 buf << "Your metabolism isn't focused on anything.\n";
610 else 609 else
611 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n"; 610 buf << "Your metabolism is focused on " << change_resist_msg[tmp->stats.exp] << ".\n";
… …
895 894
896 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */ 895 op->speed_left = -FABS (op->speed) * 5; /* Freeze them for a short while */
897 return 1; 896 return 1;
898} 897}
899 898
900
901/* cast_heal: Heals something. 899/* cast_heal: Heals something.
902 * op is the caster. 900 * op is the caster.
903 * dir is the direction he is casting it in. 901 * dir is the direction he is casting it in.
904 * spell is the spell object. 902 * spell is the spell object.
905 */ 903 */
… …
931 { 929 {
932 /* See how many points we actually heal. Instead of messages 930 /* See how many points we actually heal. Instead of messages
933 * based on type of spell, we instead do messages based 931 * based on type of spell, we instead do messages based
934 * on amount of damage healed. 932 * on amount of damage healed.
935 */ 933 */
936 if (heal > (tmp->stats.maxhp - tmp->stats.hp)) 934 if (heal > tmp->stats.maxhp - tmp->stats.hp)
937 heal = tmp->stats.maxhp - tmp->stats.hp; 935 heal = tmp->stats.maxhp - tmp->stats.hp;
936
938 tmp->stats.hp += heal; 937 tmp->stats.hp += heal;
939 938
940 if (tmp->stats.hp >= tmp->stats.maxhp) 939 if (tmp->stats.hp >= tmp->stats.maxhp)
941 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!"); 940 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel just fine!");
942 else if (heal > 50) 941 else if (heal > 50)
… …
951 success = 1; 950 success = 1;
952 } 951 }
953 } 952 }
954 953
955 if (spell->attacktype & AT_DISEASE) 954 if (spell->attacktype & AT_DISEASE)
956 if (cure_disease (tmp, op)) 955 if (cure_disease (tmp, op, spell))
957 success = 1; 956 success = 1;
958 957
959 if (spell->attacktype & AT_POISON) 958 if (spell->attacktype & AT_POISON)
960 { 959 {
961 at = archetype::find ("poisoning"); 960 at = archetype::find ("poisoning");
… …
1010 } 1009 }
1011 1010
1012 if (spell->stats.food && tmp->stats.food < 999) 1011 if (spell->stats.food && tmp->stats.food < 999)
1013 { 1012 {
1014 tmp->stats.food += spell->stats.food; 1013 tmp->stats.food += spell->stats.food;
1014
1015 if (tmp->stats.food > 999) 1015 if (tmp->stats.food > 999)
1016 tmp->stats.food = 999; 1016 tmp->stats.food = 999;
1017
1017 success = 1; 1018 success = 1;
1018 /* We could do something a bit better like the messages for healing above */ 1019 /* 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"); 1020 new_draw_info (NDI_UNIQUE, 0, tmp, "You feel your belly fill with food");
1020 } 1021 }
1021 1022
… …
1276} 1277}
1277 1278
1278/* Alchemy code by Mark Wedel 1279/* Alchemy code by Mark Wedel
1279 * 1280 *
1280 * This code adds a new spell, called alchemy. Alchemy will turn 1281 * This code adds a new spell, called alchemy. Alchemy will turn
1281 * objects to gold nuggets, the value of the gold nuggets being 1282 * objects to pyrite ("false gold"), henceforth called gold nuggets.
1282 * about 90% of that of the item itself. It uses the value of the
1283 * object before charisma adjustments, because the nuggets themselves
1284 * will be will be adjusted by charisma when sold.
1285 * 1283 *
1286 * Large nuggets are worth 25 gp each (base). You will always get 1284 * The value of the gold nuggets being about 90% of that of the item
1287 * the maximum number of large nuggets you could get. 1285 * itself. It uses the value of the object before charisma adjustments,
1288 * Small nuggets are worth 1 gp each (base). You will get from 0 1286 * because the nuggets themselves will be will be adjusted by charisma
1289 * to the max amount of small nuggets as you could get. 1287 * when sold.
1290 *
1291 * For example, if an item is worth 110 gold, you will get
1292 * 4 large nuggets, and from 0-10 small nuggets.
1293 * 1288 *
1294 * There is also a chance (1:30) that you will get nothing at all 1289 * There is also a chance (1:30) that you will get nothing at all
1295 * for the object. There is also a maximum weight that will be 1290 * for the object. There is also a maximum weight that will be
1296 * alchemised. 1291 * alchemised.
1297 */ 1292 */
1298static void 1293static void
1299alchemy_object (object *obj, uint64 &total_value, int &total_weight) 1294alchemy_object (object *obj, uint64 &total_value, int &total_weight)
1300{ 1295{
1301 uint64 value = query_cost (obj, NULL, F_TRUE); 1296 uint64 value = query_cost (obj, NULL, F_TRUE);
1302 1297
1303 /* Give third price when we alchemy money (This should hopefully 1298 /* Give third price when we alchemy money (this should hopefully
1304 * make it so that it isn't worth it to alchemy money, sell 1299 * make it so that it isn't worth it to alchemy money, sell
1305 * the nuggets, alchemy the gold from that, etc. 1300 * the nuggets, alchemy the gold from that, etc.
1306 * Otherwise, give 9 silver on the gold for other objects, 1301 * Otherwise, give 9 silver on the gold for other objects,
1307 * so that it would still be more affordable to haul 1302 * so that it would still be more affordable to haul
1308 * the stuff back to town. 1303 * the stuff back to town.
… …
1320 total_weight += obj->total_weight (); 1315 total_weight += obj->total_weight ();
1321 1316
1322 obj->destroy (); 1317 obj->destroy ();
1323} 1318}
1324 1319
1325static void
1326update_map (object *op, maptile *m, int small_nuggets, object *small, int large_nuggets, object *large, int x, int y)
1327{
1328 int flag = 0;
1329
1330 /* Put any nuggets below the player, but we can only pass this
1331 * flag if we are on the same space as the player
1332 */
1333 if (x == op->x && y == op->y && op->map == m)
1334 flag = INS_BELOW_ORIGINATOR;
1335
1336 if (small_nuggets)
1337 {
1338 object *tmp = small->clone ();
1339 tmp->nrof = small_nuggets;
1340 m->insert (tmp, x, y, op, flag);
1341 }
1342
1343 if (large_nuggets)
1344 {
1345 object *tmp = large->clone ();
1346 tmp->nrof = large_nuggets;
1347 m->insert (tmp, x, y, op, flag);
1348 }
1349
1350 if (object *pl = m->at (x, y).player ())
1351 if (pl->contr->ns)
1352 pl->contr->ns->look_position = 0;
1353}
1354
1355int 1320int
1356alchemy (object *op, object *caster, object *spell_ob) 1321alchemy (object *op, object *caster, object *spell_ob)
1357{ 1322{
1358 if (op->type != PLAYER) 1323 if (op->type != PLAYER)
1359 return 0; 1324 return 0;
1360 1325
1361 object *large = get_archetype ("largenugget"); 1326 archetype *nugget[3];
1362 object *small = get_archetype ("smallnugget"); 1327
1328 nugget[0] = archetype::find ("pyrite3");
1329 nugget[1] = archetype::find ("pyrite2");
1330 nugget[2] = archetype::find ("pyrite");
1363 1331
1364 /* Put a maximum weight of items that can be alchemised. Limits the power 1332 /* Put a maximum weight of items that can be alchemised. Limits the power
1365 * some, and also prevents people from alchemising every table/chair/clock 1333 * some, and also prevents people from alchemising every table/chair/clock
1366 * in sight 1334 * in sight
1367 */ 1335 */
… …
1419 if (weight > weight_max) 1387 if (weight > weight_max)
1420 break; 1388 break;
1421 } 1389 }
1422 } 1390 }
1423 1391
1392 value -= rndm (value >> 4);
1424 value = min (value, value_max); 1393 value = min (value, value_max);
1425 1394
1426 uint64 count = value / large->value; 1395 for (int i = 0; i < sizeof (nugget) / sizeof (nugget [0]); ++i)
1427 int large_nuggets = count; 1396 if (int nrof = value / nugget [i]->value)
1428 value -= count * large->value;
1429
1430 count = value / small->value;
1431 int small_nuggets = count;
1432
1433 /* Insert all the nuggets at one time. This probably saves time, but
1434 * it also prevents us from alcheming nuggets that were just created
1435 * with this spell.
1436 */ 1397 {
1437 update_map (op, mp, small_nuggets, small, large_nuggets, large, nx, ny); 1398 value -= nrof * nugget[i]->value;
1399
1400 object *tmp = arch_to_object (nugget[i]);
1401 tmp->nrof = nrof;
1402 tmp->flag [FLAG_IDENTIFIED] = true;
1403 op->map->insert (tmp, x, y, op, 0);
1404 }
1438 1405
1439 if (weight > weight_max) 1406 if (weight > weight_max)
1440 goto bailout; 1407 goto bailout;
1441 } 1408 }
1442 } 1409 }
1443 1410
1444bailout: 1411bailout:
1445 large->destroy ();
1446 small->destroy ();
1447 return 1; 1412 return 1;
1448} 1413}
1449
1450 1414
1451/* This function removes the cursed/damned status on equipped 1415/* This function removes the cursed/damned status on equipped
1452 * items. 1416 * items.
1453 */ 1417 */
1454int 1418int
… …
1461 if (QUERY_FLAG (tmp, FLAG_APPLIED) && 1425 if (QUERY_FLAG (tmp, FLAG_APPLIED) &&
1462 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) || 1426 ((QUERY_FLAG (tmp, FLAG_CURSED) && QUERY_FLAG (spell, FLAG_CURSED)) ||
1463 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED)))) 1427 (QUERY_FLAG (tmp, FLAG_DAMNED) && QUERY_FLAG (spell, FLAG_DAMNED))))
1464 { 1428 {
1465 was_one++; 1429 was_one++;
1430
1466 if (tmp->level <= caster_level (caster, spell)) 1431 if (tmp->level <= caster_level (caster, spell))
1467 { 1432 {
1468 success++; 1433 success++;
1469 if (QUERY_FLAG (spell, FLAG_DAMNED)) 1434 if (QUERY_FLAG (spell, FLAG_DAMNED))
1470 CLEAR_FLAG (tmp, FLAG_DAMNED); 1435 CLEAR_FLAG (tmp, FLAG_DAMNED);
1471 1436
1472 CLEAR_FLAG (tmp, FLAG_CURSED); 1437 CLEAR_FLAG (tmp, FLAG_CURSED);
1473 CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED); 1438 CLEAR_FLAG (tmp, FLAG_KNOWN_CURSED);
1474 tmp->value = 0; /* Still can't sell it */ 1439 tmp->value = 0; /* Still can't sell it */
1475 if (op->type == PLAYER) 1440
1441 if (object *pl = tmp->visible_to ())
1476 esrv_send_item (op, tmp); 1442 esrv_update_item (UPD_FLAGS, pl, tmp);
1477 } 1443 }
1478 } 1444 }
1479 1445
1480 if (op->type == PLAYER) 1446 if (op->type == PLAYER)
1481 { 1447 {
… …
1492 1458
1493 return success; 1459 return success;
1494} 1460}
1495 1461
1496/* Identifies objects in the players inventory/on the ground */ 1462/* Identifies objects in the players inventory/on the ground */
1497
1498int 1463int
1499cast_identify (object *op, object *caster, object *spell) 1464cast_identify (object *op, object *caster, object *spell)
1500{ 1465{
1466 dynbuf_text buf;
1501 object *tmp; 1467 object *tmp;
1502 int success = 0, num_ident;
1503 1468
1504 num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell); 1469 int num_ident = spell->stats.dam + SP_level_dam_adjust (caster, spell);
1505 1470
1506 if (num_ident < 1) 1471 if (num_ident < 1)
1507 num_ident = 1; 1472 num_ident = 1;
1508 1473
1509 for (tmp = op->inv; tmp; tmp = tmp->below) 1474 for (tmp = op->inv; tmp; tmp = tmp->below)
… …
1512 { 1477 {
1513 identify (tmp); 1478 identify (tmp);
1514 1479
1515 if (op->type == PLAYER) 1480 if (op->type == PLAYER)
1516 { 1481 {
1517 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));
1518 1483
1519 if (tmp->msg) 1484 if (tmp->msg)
1520 { 1485 buf << "The item has a story:\n\n" << tmp->msg << "\n\n";
1521 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1522 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1523 }
1524 } 1486 }
1525 1487
1526 num_ident--; 1488 num_ident--;
1527 success = 1;
1528 if (!num_ident) 1489 if (!num_ident)
1529 break; 1490 break;
1530 } 1491 }
1531 } 1492 }
1532 1493
… …
1539 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above) 1500 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp; tmp = tmp->above)
1540 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp)) 1501 if (!QUERY_FLAG (tmp, FLAG_IDENTIFIED) && !tmp->invisible && need_identify (tmp))
1541 { 1502 {
1542 identify (tmp); 1503 identify (tmp);
1543 1504
1544 if (op->type == PLAYER) 1505 if (object *pl = tmp->visible_to ())
1545 { 1506 {
1546 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));
1547 1508
1548 if (tmp->msg) 1509 if (tmp->msg)
1549 { 1510 buf << "The item has a story:\n\n" << tmp->msg << "\n\n";
1550 new_draw_info (NDI_UNIQUE, 0, op, "The item has a story:");
1551 new_draw_info (NDI_UNIQUE, 0, op, tmp->msg);
1552 }
1553
1554 esrv_send_item (op, tmp);
1555 } 1511 }
1556 1512
1557 num_ident--; 1513 num_ident--;
1558 success = 1;
1559 if (!num_ident) 1514 if (!num_ident)
1560 break; 1515 break;
1561 } 1516 }
1562 } 1517 }
1563 1518
1564 if (!success) 1519 if (buf.empty ())
1565 new_draw_info (NDI_UNIQUE, 0, op, "You can't reach anything unidentified."); 1520 {
1521 op->failmsg ("You can't reach anything unidentified.");
1522 return 0;
1523 }
1566 else 1524 else
1525 {
1526 if (op->contr)
1527 op->contr->infobox (MSG_CHANNEL ("identify"), buf);
1528
1567 spell_effect (spell, op->x, op->y, op->map, op); 1529 spell_effect (spell, op->x, op->y, op->map, op);
1568 1530 return 1;
1569 return success; 1531 }
1570} 1532}
1571 1533
1572int 1534int
1573cast_detection (object *op, object *caster, object *spell, object *skill) 1535cast_detection (object *op, object *caster, object *spell, object *skill)
1574{ 1536{
… …
1716 1678
1717 /* Now process objects in the players inventory if detect curse or magic */ 1679 /* Now process objects in the players inventory if detect curse or magic */
1718 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL)) 1680 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) || QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL))
1719 { 1681 {
1720 done_one = 0; 1682 done_one = 0;
1683
1721 for (tmp = op->inv; tmp; tmp = tmp->below) 1684 for (tmp = op->inv; tmp; tmp = tmp->below)
1722 { 1685 {
1723 if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED)) 1686 if (!tmp->invisible && !QUERY_FLAG (tmp, FLAG_IDENTIFIED))
1724 { 1687 {
1725 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL)) 1688 if (QUERY_FLAG (spell, FLAG_KNOWN_MAGICAL) && is_magical (tmp) && !QUERY_FLAG (tmp, FLAG_KNOWN_MAGICAL))
1726 { 1689 {
1727 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL); 1690 SET_FLAG (tmp, FLAG_KNOWN_MAGICAL);
1728 if (op->type == PLAYER) 1691
1692 if (object *pl = tmp->visible_to ())
1729 esrv_send_item (op, tmp); 1693 esrv_update_item (UPD_FLAGS, pl, tmp);
1730 } 1694 }
1695
1731 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) && 1696 if (QUERY_FLAG (spell, FLAG_KNOWN_CURSED) && !QUERY_FLAG (tmp, FLAG_KNOWN_CURSED) &&
1732 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED))) 1697 (QUERY_FLAG (tmp, FLAG_CURSED) || QUERY_FLAG (tmp, FLAG_DAMNED)))
1733 { 1698 {
1734 SET_FLAG (tmp, FLAG_KNOWN_CURSED); 1699 SET_FLAG (tmp, FLAG_KNOWN_CURSED);
1735 if (op->type == PLAYER) 1700
1701 if (object *pl = tmp->visible_to ())
1736 esrv_send_item (op, tmp); 1702 esrv_update_item (UPD_FLAGS, pl, tmp);
1737 } 1703 }
1738 } /* if item is not identified */ 1704 } /* if item is not identified */
1739 } /* for the players inventory */ 1705 } /* for the players inventory */
1740 } /* if detect magic/curse and object is a player */ 1706 } /* if detect magic/curse and object is a player */
1707
1741 return 1; 1708 return 1;
1742} 1709}
1743 1710
1744 1711
1745/** 1712/**
… …
1935 break; 1902 break;
1936 } 1903 }
1937 } 1904 }
1938} 1905}
1939 1906
1940
1941
1942/* cast_consecrate() - a spell to make an altar your god's */ 1907/* cast_consecrate() - a spell to make an altar your god's */
1943int 1908int
1944cast_consecrate (object *op, object *caster, object *spell) 1909cast_consecrate (object *op, object *caster, object *spell)
1945{ 1910{
1946 char buf[MAX_BUF]; 1911 char buf[MAX_BUF];
… …
1970 /* If we got here, we are consecrating an altar */ 1935 /* If we got here, we are consecrating an altar */
1971 sprintf (buf, "Altar of %s", &god->name); 1936 sprintf (buf, "Altar of %s", &god->name);
1972 tmp->name = buf; 1937 tmp->name = buf;
1973 tmp->level = caster_level (caster, spell); 1938 tmp->level = caster_level (caster, spell);
1974 tmp->other_arch = god->arch; 1939 tmp->other_arch = god->arch;
1940
1975 if (op->type == PLAYER) 1941 if (op->type == PLAYER)
1976 esrv_update_item (UPD_NAME, op, tmp); 1942 esrv_update_item (UPD_NAME, op, tmp);
1943
1977 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name); 1944 new_draw_info_format (NDI_UNIQUE, 0, op, "You consecrated the altar to %s!", &god->name);
1978 return 1; 1945 return 1;
1979 } 1946 }
1980 } 1947 }
1981 } 1948 }
… …
2057 { 2024 {
2058 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon)); 2025 new_draw_info_format (NDI_BLACK, 0, op, "You need to unequip %s before using it in this spell", query_name (weapon));
2059 return 0; 2026 return 0;
2060 } 2027 }
2061 2028
2062 if (weapon->nrof > 1) 2029 weapon = weapon->split ();
2063 {
2064 tmp = get_split_ob (weapon, 1);
2065 esrv_send_item (op, weapon);
2066 weapon = tmp;
2067 }
2068 2030
2069 /* create the golem object */ 2031 /* create the golem object */
2070 tmp = arch_to_object (spell->other_arch); 2032 tmp = arch_to_object (spell->other_arch);
2071 2033
2072 /* if animated by a player, give the player control of the golem */ 2034 /* if animated by a player, give the player control of the golem */
… …
2077 tmp->set_owner (op); 2039 tmp->set_owner (op);
2078 op->contr->golem = tmp; 2040 op->contr->golem = tmp;
2079 set_spell_skill (op, caster, spell, tmp); 2041 set_spell_skill (op, caster, spell, tmp);
2080 2042
2081 /* Give the weapon to the golem now. A bit of a hack to check the 2043 /* Give the weapon to the golem now. A bit of a hack to check the
2082 * removed flag - it should only be set if get_split_object was 2044 * removed flag - it should only be set if weapon->split was
2083 * used above. 2045 * used above.
2084 */ 2046 */
2085 if (!QUERY_FLAG (weapon, FLAG_REMOVED)) 2047 if (!QUERY_FLAG (weapon, FLAG_REMOVED))
2086 weapon->remove (); 2048 weapon->remove ();
2087 2049
2088 insert_ob_in_ob (weapon, tmp); 2050 tmp->insert (weapon);
2089 esrv_send_item (op, weapon); 2051
2090 /* To do everything necessary to let a golem use the weapon is a pain, 2052 /* To do everything necessary to let a golem use the weapon is a pain,
2091 * so instead, just set it as equipped (otherwise, we need to update 2053 * so instead, just set it as equipped (otherwise, we need to update
2092 * body_info, skills, etc) 2054 * body_info, skills, etc)
2093 */ 2055 */
2094 SET_FLAG (tmp, FLAG_USE_WEAPON); 2056 SET_FLAG (tmp, FLAG_USE_WEAPON);
… …
2203 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here."); 2165 new_draw_info (NDI_UNIQUE, 0, op, "It can be no darker here.");
2204 } 2166 }
2205 return success; 2167 return success;
2206} 2168}
2207 2169
2208
2209
2210
2211
2212/* create an aura spell object and put it in the player's inventory. 2170/* create an aura spell object and put it in the player's inventory.
2213 * as usual, op is player, caster is the object casting the spell, 2171 * as usual, op is player, caster is the object casting the spell,
2214 * spell is the spell object itself. 2172 * spell is the spell object itself.
2215 */ 2173 */
2216int 2174int
… …
2227 2185
2228 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell); 2186 new_aura->duration = spell->duration + 10 * SP_level_duration_adjust (caster, spell);
2229 2187
2230 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell); 2188 new_aura->stats.dam = spell->stats.dam + SP_level_dam_adjust (caster, spell);
2231 2189
2232 new_aura->set_owner (op);
2233 set_spell_skill (op, caster, spell, new_aura); 2190 set_spell_skill (op, caster, spell, new_aura);
2234 new_aura->attacktype = spell->attacktype; 2191 new_aura->attacktype = spell->attacktype;
2235 2192
2236 new_aura->level = caster_level (caster, spell); 2193 new_aura->level = caster_level (caster, spell);
2194
2237 if (refresh) 2195 if (refresh)
2238 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect."); 2196 new_draw_info (NDI_UNIQUE, 0, op, "You recast the spell while in effect.");
2239 else 2197 else
2240 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force."); 2198 new_draw_info (NDI_UNIQUE, 0, op, "You create an aura of magical force.");
2199
2241 insert_ob_in_ob (new_aura, op); 2200 insert_ob_in_ob (new_aura, op);
2201 new_aura->set_owner (op);
2202
2242 return 1; 2203 return 1;
2243} 2204}
2244
2245 2205
2246/* move aura function. An aura is a part of someone's inventory, 2206/* move aura function. An aura is a part of someone's inventory,
2247 * which he carries with him, but which acts on the map immediately 2207 * which he carries with him, but which acts on the map immediately
2248 * around him. 2208 * around him.
2249 * Aura parameters: 2209 * Aura parameters:
2250 * duration: duration counter. 2210 * duration: duration counter.
2251 * attacktype: aura's attacktype 2211 * attacktype: aura's attacktype
2252 * other_arch: archetype to drop where we attack 2212 * other_arch: archetype to drop where we attack
2253 */ 2213 */
2254
2255void 2214void
2256move_aura (object *aura) 2215move_aura (object *aura)
2257{ 2216{
2258 int i, mflags;
2259 object *env;
2260 maptile *m;
2261
2262 /* auras belong in inventories */ 2217 /* auras belong in inventories */
2263 env = aura->env; 2218 object *env = aura->env;
2219 object *owner = aura->owner;
2264 2220
2265 /* no matter what we've gotta remove the aura... 2221 /* no matter what we've gotta remove the aura...
2266 * we'll put it back if its time isn't up. 2222 * we'll put it back if its time isn't up.
2267 */ 2223 */
2268 aura->remove (); 2224 aura->remove ();
… …
2273 aura->destroy (); 2229 aura->destroy ();
2274 return; 2230 return;
2275 } 2231 }
2276 2232
2277 /* auras only exist in inventories */ 2233 /* auras only exist in inventories */
2278 if (env == NULL || env->map == NULL) 2234 if (!env || !env->map)
2279 { 2235 {
2280 aura->destroy (); 2236 aura->destroy ();
2281 return; 2237 return;
2282 } 2238 }
2283 2239
2284 /* we need to jump out of the inventory for a bit 2240 /* we need to jump out of the inventory for a bit
2285 * in order to hit the map conveniently. 2241 * in order to hit the map conveniently.
2286 */ 2242 */
2287 aura->insert_at (env, aura); 2243 aura->insert_at (env, aura);
2288 2244
2289 for (i = 1; i < 9; i++) 2245 for (int i = 1; i < 9; i++)
2290 { 2246 {
2291 sint16 nx, ny; 2247 mapxy pos (env);
2248 pos.move (i);
2292 2249
2293 nx = aura->x + freearr_x[i];
2294 ny = aura->y + freearr_y[i];
2295 mflags = get_map_flags (env->map, &m, nx, ny, &nx, &ny);
2296
2297 /* Consider the movement tyep of the person with the aura as 2250 /* Consider the movement type of the person with the aura as
2298 * movement type of the aura. Eg, if the player is flying, the aura 2251 * movement type of the aura. Eg, if the player is flying, the aura
2299 * is flying also, if player is walking, it is on the ground, etc. 2252 * is flying also, if player is walking, it is on the ground, etc.
2300 */ 2253 */
2301 if (!(mflags & P_OUT_OF_MAP) && !(OB_TYPE_MOVE_BLOCK (env, GET_MAP_MOVE_BLOCK (m, nx, ny)))) 2254 if (pos.normalise () && !(OB_TYPE_MOVE_BLOCK (env, pos->move_block)))
2302 { 2255 {
2303 hit_map (aura, i, aura->attacktype, 0); 2256 hit_map (aura, i, aura->attacktype, 0);
2304 2257
2305 if (aura->other_arch) 2258 if (aura->other_arch)
2306 m->insert (arch_to_object (aura->other_arch), nx, ny, aura); 2259 pos.insert (arch_to_object (aura->other_arch), aura);
2307 } 2260 }
2308 } 2261 }
2309 2262
2310 /* put the aura back in the player's inventory */ 2263 /* put the aura back in the player's inventory */
2311 aura->remove (); 2264 env->insert (aura);
2312 insert_ob_in_ob (aura, env); 2265 aura->set_owner (owner);
2313} 2266}
2314 2267
2315/* moves the peacemaker spell. 2268/* moves the peacemaker spell.
2316 * op is the piece object. 2269 * op is the piece object.
2317 */ 2270 */
2318
2319void 2271void
2320move_peacemaker (object *op) 2272move_peacemaker (object *op)
2321{ 2273{
2322 object *tmp; 2274 object *tmp;
2323 2275
2324 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above) 2276 for (tmp = GET_MAP_OB (op->map, op->x, op->y); tmp != NULL; tmp = tmp->above)
2325 { 2277 {
2326 int atk_lev, def_lev; 2278 int atk_lev, def_lev;
2327 object *victim = tmp; 2279 object *victim = tmp->head_ ();
2328 2280
2329 if (tmp->head)
2330 victim = tmp->head;
2331 if (!QUERY_FLAG (victim, FLAG_MONSTER)) 2281 if (!QUERY_FLAG (victim, FLAG_MONSTER))
2332 continue; 2282 continue;
2283
2333 if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE)) 2284 if (QUERY_FLAG (victim, FLAG_UNAGGRESSIVE))
2334 continue; 2285 continue;
2286
2335 if (victim->stats.exp == 0) 2287 if (victim->stats.exp == 0)
2336 continue; 2288 continue;
2337 2289
2338 def_lev = MAX (1, victim->level); 2290 def_lev = MAX (1, victim->level);
2339 atk_lev = MAX (1, op->level); 2291 atk_lev = MAX (1, op->level);
2340 2292
2341 if (rndm (0, atk_lev - 1) > def_lev) 2293 if (rndm (0, atk_lev - 1) > def_lev)
2342 { 2294 {
2343 /* make this sucker peaceful. */ 2295 /* make this sucker peaceful. */
2344 2296
2297 INVOKE_OBJECT (KILL, victim, ARG_OBJECT (op));
2345 change_exp (op->owner, victim->stats.exp, op->skill, 0); 2298 change_exp (op->owner, victim->stats.exp, op->skill, 0);
2346 victim->stats.exp = 0; 2299 victim->stats.exp = 0;
2347#if 0 2300#if 0
2348 /* No idea why these were all set to zero - if something 2301 /* No idea why these were all set to zero - if something
2349 * makes this creature agressive, he should still do damage. 2302 * makes this creature agressive, he should still do damage.
… …
2356 victim->attack_movement = RANDO2; 2309 victim->attack_movement = RANDO2;
2357 SET_FLAG (victim, FLAG_UNAGGRESSIVE); 2310 SET_FLAG (victim, FLAG_UNAGGRESSIVE);
2358 SET_FLAG (victim, FLAG_RUN_AWAY); 2311 SET_FLAG (victim, FLAG_RUN_AWAY);
2359 SET_FLAG (victim, FLAG_RANDOM_MOVE); 2312 SET_FLAG (victim, FLAG_RANDOM_MOVE);
2360 CLEAR_FLAG (victim, FLAG_MONSTER); 2313 CLEAR_FLAG (victim, FLAG_MONSTER);
2314
2361 if (victim->name) 2315 if (victim->name)
2362 {
2363 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);
2364 }
2365 } 2317 }
2366 } 2318 }
2367} 2319}
2368 2320
2369 2321

Diff Legend

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