ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/server/apply.C
(Generate patch)

Comparing deliantra/server/server/apply.C (file contents):
Revision 1.187 by elmex, Tue Jan 13 13:29:57 2009 UTC vs.
Revision 1.206 by root, Fri Oct 23 03:08:35 2009 UTC

… …
3 * 3 *
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (©) 1992,2007 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * Deliantra is free software: you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify it under
9 * it under the terms of the GNU General Public License as published by 9 * the terms of the Affero GNU General Public License as published by the
10 * the Free Software Foundation, either version 3 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your option) any later version. 11 * 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,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
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 Affero GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
20 * 21 *
21 * The authors can be reached via e-mail to <support@deliantra.net> 22 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 23 */
23 24
24#include <cmath> 25#include <cmath>
25 26
… …
92 * Return value: 1 if money was destroyed, 0 if not. 93 * Return value: 1 if money was destroyed, 0 if not.
93 */ 94 */
94static int 95static int
95apply_id_altar (object *money, object *altar, object *pl) 96apply_id_altar (object *money, object *altar, object *pl)
96{ 97{
97 dynbuf_text buf; 98 dynbuf_text &buf = msg_dynbuf; buf.clear ();
98 99
99 if (!pl || pl->type != PLAYER) 100 if (!pl || pl->type != PLAYER)
100 return 0; 101 return 0;
101 102
102 /* Check for MONEY type is a special hack - it prevents 'nothing needs 103 /* Check for MONEY type is a special hack - it prevents 'nothing needs
103 * identifying' from being printed out more than it needs to be. 104 * identifying' from being printed out more than it needs to be.
104 */ 105 */
105 if (!check_altar_sacrifice (altar, money) || money->type != MONEY) 106 if (!check_altar_sacrifice (altar, money, pl) || money->type != MONEY)
106 return 0; 107 return 0;
107 108
108 /* if the player has a marked item, identify that if it needs to be 109 /* if the player has a marked item, identify that if it needs to be
109 * identified. If it doesn't, then go through the player inventory. 110 * identified. If it doesn't, then go through the player inventory.
110 */ 111 */
111 if (object *marked = find_marked_object (pl)) 112 if (object *marked = find_marked_object (pl))
112 if (!QUERY_FLAG (marked, FLAG_IDENTIFIED) && need_identify (marked)) 113 if (!QUERY_FLAG (marked, FLAG_IDENTIFIED) && need_identify (marked))
113 { 114 {
114 if (operate_altar (altar, &money)) 115 if (operate_altar (altar, &money, pl))
115 { 116 {
116 identify (marked); 117 identify (marked);
117 118
118 buf.printf ("You have %s.\r", long_desc (marked, pl)); 119 buf.printf ("You have %s.\r", long_desc (marked, pl));
119 if (marked->msg) 120 if (marked->msg)
… …
125 126
126 for (object *id = pl->inv; id; id = id->below) 127 for (object *id = pl->inv; id; id = id->below)
127 { 128 {
128 if (!QUERY_FLAG (id, FLAG_IDENTIFIED) && !id->invisible && need_identify (id)) 129 if (!QUERY_FLAG (id, FLAG_IDENTIFIED) && !id->invisible && need_identify (id))
129 { 130 {
130 if (operate_altar (altar, &money)) 131 if (operate_altar (altar, &money, pl))
131 { 132 {
132 identify (id); 133 identify (id);
133 134
134 buf.printf ("You have %s.\r", long_desc (id, pl)); 135 buf.printf ("You have %s.\r", long_desc (id, pl));
135 if (id->msg) 136 if (id->msg)
… …
396/**************************************************************************** 397/****************************************************************************
397 * Weapon improvement code follows 398 * Weapon improvement code follows
398 ****************************************************************************/ 399 ****************************************************************************/
399 400
400/** 401/**
402 * This function just checks whether who can handle equipping an item
403 * with item_power.
404 */
405
406bool
407check_item_power (object *who, int item_power)
408{
409 if (who->type == PLAYER
410 && item_power
411 && item_power + who->contr->item_power > settings.item_power_factor * who->level)
412 return false;
413 else
414 return true;
415}
416
417/**
401 * This returns the sum of nrof of item (arch name). 418 * This returns the sum of nrof of item (arch name).
402 */ 419 */
403static int 420static int
404check_item (object *op, shstr_cmp item) 421check_item (object *op, shstr_cmp item)
405{ 422{
… …
450 } 467 }
451 468
452 prev = op; 469 prev = op;
453 op = op->below; 470 op = op->below;
454 } 471 }
455}
456
457/**
458 * This checks to see of the player (who) is sufficient level to use a weapon
459 * with improvs improvements (typically last_eat). We take an int here
460 * instead of the object so that the improvement code can pass along the
461 * increased value to see if the object is usuable.
462 * we return 1 (true) if the player can use the weapon.
463 */
464static int
465check_weapon_power (const object *who, int improvs)
466{
467/* Old code is below (commented out). Basically, since weapons are the only
468 * object players really have any control to improve, it's a bit harsh to
469 * require high level in some combat skill, so we just use overall level.
470 */
471#if 1
472 if (((who->level / 5) + 5) >= improvs)
473 return 1;
474 else
475 return 0;
476
477#else
478 int level = 0;
479
480 /* The skill system hands out wc and dam bonuses to fighters
481 * more generously than the old system (see fix_player). Thus
482 * we need to curtail the power of player enchanted weapons.
483 * I changed this to 1 improvement per "fighter" level/5 -b.t.
484 * Note: Nothing should break by allowing this ratio to be different or
485 * using normal level - it is just a matter of play balance.
486 */
487 if (who->type == PLAYER)
488 {
489 object *wc_obj = NULL;
490
491 for (wc_obj = who->inv; wc_obj; wc_obj = wc_obj->below)
492 if (wc_obj->type == SKILL && IS_COMBAT_SKILL (wc_obj->subtype) && wc_obj->level > level)
493 level = wc_obj->level;
494
495 if (!level)
496 {
497 LOG (llevError, "Error: Player: %s lacks wc experience object\n", who->name);
498 level = who->level;
499 }
500 }
501 else
502 level = who->level;
503
504 return (improvs <= ((level / 5) + 5));
505#endif
506} 472}
507 473
508/** 474/**
509 * Returns how many items of type improver->slaying there are under op. 475 * Returns how many items of type improver->slaying there are under op.
510 * Will display a message if none found, and 1 if improver->slaying is NULL. 476 * Will display a message if none found, and 1 if improver->slaying is NULL.
… …
639 if (improver->stats.sp == IMPROVE_PREPARE) 605 if (improver->stats.sp == IMPROVE_PREPARE)
640 return prepare_weapon (op, improver, weapon); 606 return prepare_weapon (op, improver, weapon);
641 607
642 if (weapon->level == 0) 608 if (weapon->level == 0)
643 { 609 {
644 op->failmsg ("This weapon has not been prepared. H<You first ahve to prepare a weapon with a prepare weapon scroll.>"); 610 op->failmsg (
611 "This weapon has not been prepared."
612 " H<You first have to prepare a weapon with a prepare weapon scroll.>");
645 return 0; 613 return 0;
646 } 614 }
647 615
648 if (weapon->level == weapon->last_eat && weapon->item_power >= 100) 616 if (weapon->last_eat >= weapon->level // improvements used up
617 || weapon->item_power >= 100) // or item_power >= arbitrary limit of 100
649 { 618 {
650 op->failmsg ("This weapon cannot be improved any more."); 619 op->failmsg ("This weapon cannot be improved any more.");
651 return 0; 620 return 0;
652 } 621 }
653 622
654 if (QUERY_FLAG (weapon, FLAG_APPLIED) && !check_weapon_power (op, weapon->last_eat + 1)) 623 if (QUERY_FLAG (weapon, FLAG_APPLIED)
624 && !check_item_power (op, weapon->item_power + 1))
655 { 625 {
656 op->failmsg ("Improving the weapon will make it too " 626 op->failmsg ("Improving the weapon will make it too "
657 "powerful for you to use. Unready it if you " 627 "powerful for you to use. Unready it if you "
658 "really want to improve it."); 628 "really want to improve it.");
659 return 0; 629 return 0;
… …
888 * Takes one type of items and makes another. 858 * Takes one type of items and makes another.
889 * converter is the object that is doing the conversion. 859 * converter is the object that is doing the conversion.
890 * item is the object that triggered the converter - if it is not 860 * item is the object that triggered the converter - if it is not
891 * what the converter wants, this will not do anything. 861 * what the converter wants, this will not do anything.
892 */ 862 */
893static int 863int
894convert_item (object *item, object *converter) 864convert_item (object *item, object *converter)
895{ 865{
896 sint64 nr, price_in; 866 sint64 nr, price_in;
897 867
898 if (item->flag [FLAG_UNPAID]) 868 if (item->flag [FLAG_UNPAID])
… …
1038 } 1008 }
1039 1009
1040 // already applied == open on ground, or open in inv, or active in inv 1010 // already applied == open on ground, or open in inv, or active in inv
1041 if (sack->flag [FLAG_APPLIED]) 1011 if (sack->flag [FLAG_APPLIED])
1042 { 1012 {
1043 if (op->container == sack) 1013 if (op->container_ () == sack)
1044 { 1014 {
1045 // open on ground or inv, so close 1015 // open on ground or inv, so close
1046 op->close_container (); 1016 op->close_container ();
1047 return 1; 1017 return 1;
1048 } 1018 }
… …
1091{ 1061{
1092 /* Only players can make sacrifices on spell casting altars. */ 1062 /* Only players can make sacrifices on spell casting altars. */
1093 if (altar->inv && (!originator || originator->type != PLAYER)) 1063 if (altar->inv && (!originator || originator->type != PLAYER))
1094 return 0; 1064 return 0;
1095 1065
1096 if (operate_altar (altar, &sacrifice)) 1066 if (operate_altar (altar, &sacrifice, originator))
1097 { 1067 {
1098 /* Simple check. Unfortunately, it means you can't cast magic bullet 1068 /* Simple check. Unfortunately, it means you can't cast magic bullet
1099 * with an altar. We call it a Potion - altars are stationary - it 1069 * with an altar. We call it a Potion - altars are stationary - it
1100 * is up to map designers to use them properly. 1070 * is up to map designers to use them properly.
1101 */ 1071 */
… …
1137 1107
1138 SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */ 1108 SET_FLAG (op, FLAG_NO_APPLY); /* prevent loops */
1139 1109
1140 bool has_unpaid = false; 1110 bool has_unpaid = false;
1141 1111
1142 // quite inefficient to do this here twice, but the api doesn'T lend itself to 1112 // quite inefficient to do this here twice, but the api doesn't lend itself to
1143 // a quick and small change :( 1113 // a quick and small change :(
1144 for (object::depth_iterator item = op->begin (); item != op->end (); ++item) 1114 for (object::depth_iterator item = op->begin (); item != op->end (); ++item)
1145 if (item->flag [FLAG_UNPAID]) 1115 if (item->flag [FLAG_UNPAID])
1146 { 1116 {
1147 has_unpaid = true; 1117 has_unpaid = true;
… …
1355 return; 1325 return;
1356 1326
1357 /* move_apply() is the most likely candidate for causing unwanted and 1327 /* move_apply() is the most likely candidate for causing unwanted and
1358 * possibly unlimited recursion. 1328 * possibly unlimited recursion.
1359 */ 1329 */
1360 /* The following was changed because it was causing perfeclty correct 1330 /* The following was changed because it was causing perfectly correct
1361 * maps to fail. 1) it's not an error to recurse: 1331 * maps to fail. 1) it's not an error to recurse:
1362 * rune detonates, summoning monster. monster lands on nearby rune. 1332 * rune detonates, summoning monster. monster lands on nearby rune.
1363 * nearby rune detonates. This sort of recursion is expected and 1333 * nearby rune detonates. This sort of recursion is expected and
1364 * proper. This code was causing needless crashes. 1334 * proper. This code was causing needless crashes.
1365 */ 1335 */
… …
1372 1342
1373 recursion_depth++; 1343 recursion_depth++;
1374 if (trap->head) 1344 if (trap->head)
1375 trap = trap->head; 1345 trap = trap->head;
1376 1346
1377 if (INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator))) 1347 if (!INVOKE_OBJECT (MOVE_TRIGGER, trap, ARG_OBJECT (victim), ARG_OBJECT (originator)))
1378 goto leave;
1379
1380 switch (trap->type) 1348 switch (trap->type)
1381 { 1349 {
1382 case PLAYERMOVER: 1350 case PLAYERMOVER:
1383 if (trap->attacktype && (trap->level || victim->type != PLAYER) && !should_director_abort (trap, victim)) 1351 if (trap->attacktype && (trap->level || victim->type != PLAYER) && !should_director_abort (trap, victim))
1352 {
1353 if (!trap->stats.maxsp)
1354 trap->stats.maxsp = 2;
1355
1356 /* Is this correct? From the docs, it doesn't look like it
1357 * should be divided by trap->speed
1358 */
1359 victim->speed_left = -FABS (trap->stats.maxsp * victim->speed / trap->speed);
1360
1361 /* Just put in some sanity check. I think there is a bug in the
1362 * above with some objects have zero speed, and thus the player
1363 * getting permanently paralyzed.
1364 */
1365 if (victim->speed_left < -50.f)
1366 victim->speed_left = -50.f;
1367 /* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
1368 }
1369 break;
1370
1371 case SPINNER:
1372 if (victim->direction)
1373 {
1374 victim->direction = absdir (victim->direction - trap->stats.sp);
1375 update_turn_face (victim);
1376 }
1377 break;
1378
1379 case DIRECTOR:
1380 if (victim->direction && !should_director_abort (trap, victim))
1381 {
1382 victim->direction = trap->stats.sp;
1383 update_turn_face (victim);
1384 }
1385 break;
1386
1387 case BUTTON:
1388 case PEDESTAL:
1389 case T_MATCH:
1390 update_button (trap, originator);
1391 break;
1392
1393 case ALTAR:
1394 /* sacrifice victim on trap */
1395 apply_altar (trap, victim, originator);
1396 break;
1397
1398 case THROWN_OBJ:
1399 if (trap->inv == NULL)
1400 break;
1401 /* fallthrough */
1402
1403 case ARROW:
1404 /* bad bug: monster throw a object, make a step forwards, step on object ,
1405 * trigger this here and get hit by own missile - and will be own enemy.
1406 * Victim then is his own enemy and will start to kill herself (this is
1407 * removed) but we have not synced victim and his missile. To avoid senseless
1408 * action, we avoid hits here
1409 */
1410 if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim)
1411 hit_with_arrow (trap, victim);
1412 break;
1413
1414 case SPELL_EFFECT:
1415 apply_spell_effect (trap, victim);
1416 break;
1417
1418 case TRAPDOOR:
1384 { 1419 {
1420 int max, sound_was_played;
1421 object *ab, *ab_next;
1422
1385 if (!trap->stats.maxsp) 1423 if (!trap->value)
1386 trap->stats.maxsp = 2; 1424 {
1425 int tot;
1387 1426
1388 /* Is this correct? From the docs, it doesn't look like it 1427 for (ab = trap->above, tot = 0; ab; ab = ab->above)
1389 * should be divided by trap->speed 1428 if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1429 tot += ab->head_ ()->total_weight ();
1430
1431 if (!(trap->value = (tot > trap->weight) ? 1 : 0))
1432 break;
1433
1434 SET_ANIMATION (trap, trap->value);
1435 update_object (trap, UP_OBJ_FACE);
1436 }
1437
1438 for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next)
1439 {
1440 /* need to set this up, since if we do transfer the object,
1441 * ab->above would be bogus
1390 */ 1442 */
1391 victim->speed_left = -FABS (trap->stats.maxsp * victim->speed / trap->speed); 1443 ab_next = ab->above;
1392 1444
1393 /* Just put in some sanity check. I think there is a bug in the 1445 if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1394 * above with some objects have zero speed, and thus the player 1446 {
1395 * getting permanently paralyzed. 1447 if (!sound_was_played)
1448 {
1449 trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
1450 sound_was_played = 1;
1451 }
1452
1453 ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
1454 transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
1455 }
1396 */ 1456 }
1397 if (victim->speed_left < -50.f) 1457 break;
1398 victim->speed_left = -50.f;
1399 /* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
1400 } 1458 }
1401 goto leave;
1402 1459
1403 case SPINNER: 1460 case CONVERTER:
1404 if (victim->direction) 1461 if (convert_item (victim, trap) < 0)
1405 {
1406 victim->direction = absdir (victim->direction - trap->stats.sp);
1407 update_turn_face (victim);
1408 }
1409 goto leave;
1410
1411 case DIRECTOR:
1412 if (victim->direction && !should_director_abort (trap, victim))
1413 {
1414 victim->direction = trap->stats.sp;
1415 update_turn_face (victim);
1416 }
1417 goto leave;
1418
1419 case BUTTON:
1420 case PEDESTAL:
1421 update_button (trap, originator);
1422 goto leave;
1423
1424 case ALTAR:
1425 /* sacrifice victim on trap */
1426 apply_altar (trap, victim, originator);
1427 goto leave;
1428
1429 case THROWN_OBJ:
1430 if (trap->inv == NULL)
1431 goto leave;
1432 /* fallthrough */
1433
1434 case ARROW:
1435 /* bad bug: monster throw a object, make a step forwards, step on object ,
1436 * trigger this here and get hit by own missile - and will be own enemy.
1437 * Victim then is his own enemy and will start to kill herself (this is
1438 * removed) but we have not synced victim and his missile. To avoid senseless
1439 * action, we avoid hits here
1440 */
1441 if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim)
1442 hit_with_arrow (trap, victim);
1443 goto leave;
1444
1445 case SPELL_EFFECT:
1446 apply_spell_effect (trap, victim);
1447 goto leave;
1448
1449 case TRAPDOOR:
1450 {
1451 int max, sound_was_played;
1452 object *ab, *ab_next;
1453
1454 if (!trap->value)
1455 { 1462 {
1456 int tot; 1463 originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1457 1464 archetype::get (shstr_burnout)->insert_at (trap, trap);
1458 for (ab = trap->above, tot = 0; ab; ab = ab->above)
1459 if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1460 tot += ab->head_ ()->total_weight ();
1461
1462 if (!(trap->value = (tot > trap->weight) ? 1 : 0))
1463 goto leave;
1464
1465 SET_ANIMATION (trap, trap->value);
1466 update_object (trap, UP_OBJ_FACE);
1467 } 1465 }
1468 1466
1469 for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next) 1467 break;
1468
1469 case TRIGGER_BUTTON:
1470 case TRIGGER_PEDESTAL:
1471 case TRIGGER_ALTAR:
1472 check_trigger (trap, victim, originator);
1473 break;
1474
1475 case DEEP_SWAMP:
1476 walk_on_deep_swamp (trap, victim);
1477 break;
1478
1479 case CHECK_INV:
1480 check_inv (victim, trap);
1481 break;
1482
1483 case HOLE:
1484 move_apply_hole (trap, victim);
1485 break;
1486
1487 case EXIT:
1488 if (victim->type == PLAYER && EXIT_PATH (trap))
1470 { 1489 {
1471 /* need to set this up, since if we do transfer the object, 1490 /* Basically, don't show exits leading to random maps the
1472 * ab->above would be bogus 1491 * players output.
1473 */ 1492 */
1474 ab_next = ab->above; 1493 if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))
1494 victim->statusmsg (trap->msg, NDI_NAVY);
1475 1495
1476 if ((ab->move_type && trap->move_on) || ab->move_type == 0) 1496 trap->play_sound (trap->sound);
1477 { 1497 victim->enter_exit (trap);
1478 if (!sound_was_played)
1479 {
1480 trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
1481 sound_was_played = 1;
1482 }
1483
1484 ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
1485 transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
1486 }
1487 } 1498 }
1488 goto leave; 1499 break;
1489 }
1490 1500
1491 case CONVERTER:
1492 if (convert_item (victim, trap) < 0)
1493 {
1494 originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1495 archetype::get (shstr_burnout)->insert_at (trap, trap);
1496 }
1497
1498 goto leave;
1499
1500 case TRIGGER_BUTTON:
1501 case TRIGGER_PEDESTAL:
1502 case TRIGGER_ALTAR:
1503 check_trigger (trap, victim);
1504 goto leave;
1505
1506 case DEEP_SWAMP:
1507 walk_on_deep_swamp (trap, victim);
1508 goto leave;
1509
1510 case CHECK_INV:
1511 check_inv (victim, trap);
1512 goto leave;
1513
1514 case HOLE:
1515 move_apply_hole (trap, victim);
1516 goto leave;
1517
1518 case EXIT:
1519 if (victim->type == PLAYER && EXIT_PATH (trap))
1520 {
1521 /* Basically, don't show exits leading to random maps the
1522 * players output.
1523 */
1524 if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))
1525 victim->statusmsg (trap->msg, NDI_NAVY);
1526
1527 trap->play_sound (trap->sound);
1528 victim->enter_exit (trap);
1529 }
1530 goto leave;
1531
1532 case ENCOUNTER: 1501 case ENCOUNTER:
1533 /* may be some leftovers on this */ 1502 /* may be some leftovers on this */
1534 goto leave; 1503 break;
1535 1504
1536 case SHOP_MAT: 1505 case SHOP_MAT:
1537 apply_shop_mat (trap, victim); 1506 apply_shop_mat (trap, victim);
1538 goto leave; 1507 break;
1539 1508
1540 /* Drop a certain amount of gold, and have one item identified */ 1509 /* Drop a certain amount of gold, and have one item identified */
1541 case IDENTIFY_ALTAR: 1510 case IDENTIFY_ALTAR:
1542 apply_id_altar (victim, trap, originator); 1511 apply_id_altar (victim, trap, originator);
1543 goto leave; 1512 break;
1544 1513
1545 case SIGN: 1514 case SIGN:
1546 if (victim->type != PLAYER && trap->stats.food > 0) 1515 if (victim->type != PLAYER && trap->stats.food > 0)
1547 goto leave; /* monsters musn't apply magic_mouths with counters */ 1516 break; /* monsters musn't apply magic_mouths with counters */
1548 1517
1549 apply_sign (victim, trap, 1); 1518 apply_sign (victim, trap, 1);
1550 goto leave; 1519 break;
1551 1520
1552 case CONTAINER: 1521 case CONTAINER:
1553 apply_container (victim, trap); 1522 apply_container (victim, trap);
1554 goto leave; 1523 break;
1555 1524
1556 case RUNE: 1525 case RUNE:
1557 case TRAP: 1526 case TRAP:
1558 if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE)) 1527 if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))
1559 spring_trap (trap, victim); 1528 spring_trap (trap, victim);
1560 goto leave; 1529 break;
1561 1530
1562 default: 1531 default:
1563 LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not " 1532 LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not "
1564 "handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type); 1533 "handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type);
1565 goto leave; 1534 break;
1566 } 1535 }
1567 1536
1568leave:
1569 recursion_depth--; 1537 recursion_depth--;
1570} 1538}
1571 1539
1572/** 1540/**
1573 * Handles reading a regular (ie not containing a spell) book. 1541 * Handles reading a regular (ie not containing a spell) book.
… …
1584 return; 1552 return;
1585 } 1553 }
1586 1554
1587 if (!tmp->msg) 1555 if (!tmp->msg)
1588 { 1556 {
1589 op->failmsg (format ("You open the %s and find it empty.", &tmp->name)); 1557 op->failmsg (format ("The %s contains nothing but meaningless gibberish. H<There is nothing interesting to read here.>", &tmp->name));
1590 return; 1558 return;
1591 } 1559 }
1592 1560
1593 /* need a literacy skill to read stuff! */ 1561 /* need a literacy skill to read stuff! */
1594 skill_ob = find_skill_by_name (op, tmp->skill); 1562 skill_ob = find_skill_by_name (op, tmp->skill);
… …
1776 LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name); 1744 LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name);
1777 op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!"); 1745 op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");
1778 return; 1746 return;
1779 } 1747 }
1780 1748
1781 if (skop->level < int (sqrtf (spell->level) * 1.5f)) 1749 int learn_level = sqrtf (spell->level) * 1.5f;
1750 if (skop->level < learn_level)
1782 { 1751 {
1783 op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low.>", &tmp->skill)); 1752 op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low, it must be at least %d.>",
1753 &tmp->skill, learn_level));
1784 return; 1754 return;
1785 } 1755 }
1786 1756
1787 op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name)); 1757 op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));
1788 1758
… …
2339/** 2309/**
2340 * This function will try to apply a lighter and in case no lighter 2310 * This function will try to apply a lighter and in case no lighter
2341 * is specified it will try to find a lighter in the players inventory, 2311 * is specified it will try to find a lighter in the players inventory,
2342 * and inform him about this requirement. 2312 * and inform him about this requirement.
2343 * 2313 *
2344 * who - the player 2314 * who - the player
2345 * op - the item we want to light 2315 * op - the item we want to light
2346 * ligher - the lighter or 0 if a lighter has yet to be found 2316 * lighter - the lighter or 0 if a lighter has yet to be found
2347 */ 2317 */
2318static object *
2348object *auto_apply_lighter (object *who, object *op, object *lighter) 2319auto_apply_lighter (object *who, object *op, object *lighter)
2349{ 2320{
2350 if (lighter == 0) 2321 if (lighter == 0)
2351 { 2322 {
2352 for (object *tmp = who->inv; tmp; tmp = tmp->below) 2323 for (object *tmp = who->inv; tmp; tmp = tmp->below)
2353 { 2324 {
… …
2400 int is_player_env = 0; 2371 int is_player_env = 0;
2401 2372
2402 item = find_marked_object (who); 2373 item = find_marked_object (who);
2403 if (item) 2374 if (item)
2404 { 2375 {
2405 if (!auto_apply_lighter (who, 0, lighter)) 2376 if (!auto_apply_lighter (who, item, lighter))
2406 return; 2377 return;
2407 2378
2408 /* Perhaps we should split what we are trying to light on fire? 2379 /* Perhaps we should split what we are trying to light on fire?
2409 * I can't see many times when you would want to light multiple 2380 * I can't see many times when you would want to light multiple
2410 * objects at once. 2381 * objects at once.
… …
2616 if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who))) 2587 if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who)))
2617 return RESULT_INT (0); 2588 return RESULT_INT (0);
2618 2589
2619 switch (op->type) 2590 switch (op->type)
2620 { 2591 {
2621 case CF_HANDLE: 2592 case T_HANDLE:
2622 who->play_sound (sound_find ("turn_handle")); 2593 who->play_sound (sound_find ("turn_handle"));
2623 who->statusmsg ("You turn the handle."); 2594 who->statusmsg ("You turn the handle.");
2624 op->value = op->value ? 0 : 1; 2595 op->value = op->value ? 0 : 1;
2625 SET_ANIMATION (op, op->value); 2596 SET_ANIMATION (op, op->value);
2626 update_object (op, UP_OBJ_FACE); 2597 update_object (op, UP_OBJ_FACE);
2627 push_button (op, who); 2598 push_button (op, who);
2628 return 1; 2599 return 1;
2629 2600
2630 case TRIGGER: 2601 case TRIGGER:
2631 if (check_trigger (op, who)) 2602 if (check_trigger (op, who, who))
2632 { 2603 {
2633 who->statusmsg ("You turn the handle."); 2604 who->statusmsg ("You turn the handle.");
2634 who->play_sound (sound_find ("turn_handle")); 2605 who->play_sound (sound_find ("turn_handle"));
2635 } 2606 }
2636 else 2607 else
… …
2641 case EXIT: 2612 case EXIT:
2642 if (who->type != PLAYER) 2613 if (who->type != PLAYER)
2643 return 0; 2614 return 0;
2644 2615
2645 if (!EXIT_PATH (op) || !is_legal_2ways_exit (who, op)) 2616 if (!EXIT_PATH (op) || !is_legal_2ways_exit (who, op))
2646 who->failmsg (format ("The %s is closed.", query_name (op))); 2617 who->failmsg (format ("The %s is closed. H<And will stay closed, until somebody fires up the map editor and adds it.>", query_name (op)));
2647 else 2618 else
2648 { 2619 {
2649 /* Don't display messages for random maps. */ 2620 /* Don't display messages for random maps. */
2650 if (op->msg && !EXIT_PATH (op).starts_with ("/!")) 2621 if (op->msg && !EXIT_PATH (op).starts_with ("/!"))
2651 who->statusmsg (op->msg, NDI_NAVY); 2622 who->statusmsg (op->msg, NDI_NAVY);
… …
2874 * we don't use a corrupt pointer for the next object, so we get the 2845 * we don't use a corrupt pointer for the next object, so we get the
2875 * next object in the stack before applying. This is can only be a 2846 * next object in the stack before applying. This is can only be a
2876 * problem if player_apply() has a bug in that it uses the object but does 2847 * problem if player_apply() has a bug in that it uses the object but does
2877 * not return a proper value. 2848 * not return a proper value.
2878 */ 2849 */
2879 for (object *next, *tmp = pl->container ? pl->container->inv : pl->below; tmp; tmp = next) 2850 for (object *next, *tmp = pl->container_ () ? pl->container_ ()->inv : pl->below; tmp; tmp = next)
2880 { 2851 {
2881 next = tmp->below; 2852 next = tmp->below;
2882 2853
2883 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 2854 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2884 floors++; 2855 floors++;
… …
3390 * skill so that the dam and wc get updated 3361 * skill so that the dam and wc get updated
3391 */ 3362 */
3392 who->change_skill (skop); 3363 who->change_skill (skop);
3393 } 3364 }
3394 3365
3395 if (who->type == PLAYER 3366 if (!check_item_power (who, op->item_power))
3396 && op->item_power
3397 && op->item_power + who->contr->item_power > settings.item_power_factor * who->level)
3398 { 3367 {
3399 who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER); 3368 who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);
3400 return 1; 3369 return 1;
3401 } 3370 }
3402 3371
… …
3410 return RESULT_INT (0); 3379 return RESULT_INT (0);
3411 3380
3412 switch (op->type) 3381 switch (op->type)
3413 { 3382 {
3414 case WEAPON: 3383 case WEAPON:
3415 if (!check_weapon_power (who, op->last_eat))
3416 {
3417 op->failmsg ("This weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3418
3419 if (tmp)
3420 insert_ob_in_ob (tmp, who);
3421
3422 return 1;
3423 }
3424
3425 //TODO: this obviously fails for players using a shorter prefix 3384 //TODO: this obviously fails for players using a shorter prefix
3426 // i.e. "R" can use Ragnarok's sword. 3385 // i.e. "R" can use Ragnarok's sword.
3427 if (op->level && !op->name.starts_with (who->name)) 3386 if (op->level && !op->name.starts_with (who->name))
3428 { 3387 {
3429 /* if the weapon does not have the name as the character, can't use it. */ 3388 /* if the weapon does not have the name as the character, can't use it. */
… …
3555 } 3514 }
3556 3515
3557 break; 3516 break;
3558 3517
3559 case BOW: 3518 case BOW:
3560 if (!check_weapon_power (who, op->last_eat))
3561 {
3562 who->failmsg ("That weapon is too powerful for you to use. It would consume your soul!" LACK_ITEM_POWER);
3563
3564 if (tmp)
3565 insert_ob_in_ob (tmp, who);
3566
3567 return 1;
3568 }
3569
3570 if (op->level && !op->name.starts_with (who->name)) 3519 if (op->level && !op->name.starts_with (who->name))
3571 { 3520 {
3572 who->failmsg ("The weapon does not recognize you as its owner. " 3521 who->failmsg ("The weapon does not recognize you as its owner. "
3573 "H<Its name indicates that it belongs to somebody else.>"); 3522 "H<Its name indicates that it belongs to somebody else.>");
3574 if (tmp) 3523 if (tmp)
… …
3839 } 3788 }
3840 3789
3841 for (mapspace *ms = spaces + size (); ms-- > spaces; ) 3790 for (mapspace *ms = spaces + size (); ms-- > spaces; )
3842 for (object *tmp = ms->bot; tmp; tmp = tmp->above) 3791 for (object *tmp = ms->bot; tmp; tmp = tmp->above)
3843 if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL)) 3792 if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL))
3844 check_trigger (tmp, tmp->above); 3793 check_trigger (tmp, tmp->above, tmp->above);
3845} 3794}
3846 3795
3847/** 3796/**
3848 * Handles player eating food that temporarily changes status (resistances, stats). 3797 * Handles player eating food that temporarily changes status (resistances, stats).
3849 * This used to call cast_change_attr(), but 3798 * This used to call cast_change_attr(), but
… …
3854eat_special_food (object *who, object *food) 3803eat_special_food (object *who, object *food)
3855{ 3804{
3856 object *force; 3805 object *force;
3857 int i, did_one = 0; 3806 int i, did_one = 0;
3858 3807
3859 force = get_archetype (FORCE_NAME); 3808 char buf[64];
3809 snprintf (buf, sizeof(buf), "sp_food_%s", &food->title);
3810 shstr key (buf);
3860 3811
3861 for (i = 0; i < NUM_STATS; i++)
3862 if (sint8 k = food->stats.stat (i))
3863 {
3864 force->stats.stat (i) = k;
3865 did_one = 1;
3866 }
3867
3868 /* check if we can protect the eater */
3869 for (i = 0; i < NROFATTACKS; i++)
3870 {
3871 if (food->resist[i] > 0)
3872 {
3873 force->resist[i] = food->resist[i] / 2;
3874 did_one = 1;
3875 }
3876 }
3877
3878 if (did_one)
3879 {
3880 force->set_speed (0.1);
3881 /* bigger morsel of food = longer effect time */ 3812 /* bigger morsel of food = longer effect time */
3882 force->duration = food->stats.food / 5; 3813 int duration = TIME2TICK (food->stats.food);
3883 SET_FLAG (force, FLAG_APPLIED); 3814
3884 change_abil (who, force); 3815 if (force = who->force_find (key))
3885 insert_ob_in_ob (force, who); 3816 {
3817 if (duration > abs (force->speed_left / force->speed))
3818 {
3819 new_draw_info_format (NDI_UNIQUE, 0, who, "More magical force spreads through you. H<The effect will last for about %.10g more seconds.>", TICK2TIME (duration));
3820 force->force_set_timer (duration);
3821 }
3822 else
3823 new_draw_info (NDI_UNIQUE, 0, who, "It had no additional effect.");
3824
3825 return;
3886 } 3826 }
3887 else 3827 else
3828 {
3829 force = who->force_add (key, duration);
3830 force->name = key;
3831
3832 /* check if the food affects a stat */
3833 for (i = 0; i < NUM_STATS; i++)
3834 if (sint8 k = food->stats.stat (i))
3835 {
3836 force->stats.stat (i) = k;
3837 did_one = 1;
3838 }
3839
3840 /* check if we can protect the eater */
3841 for (i = 0; i < NROFATTACKS; i++)
3842 {
3843 if (food->resist[i] > 0)
3844 {
3845 force->resist[i] = food->resist[i];
3846 did_one = 1;
3847 }
3848 }
3849
3850 if (did_one)
3851 {
3852 new_draw_info_format (NDI_UNIQUE, 0, who, "You are suffused with magical force. H<The effect will last for about %.10g seconds.>", TICK2TIME (duration));
3853
3854 /* make the force take effect and report effects to user */
3855 change_abil (who, force);
3856 }
3857 else
3888 force->destroy (); 3858 force->destroy ();
3859 }
3889 3860
3890 /* check for hp, sp change */ 3861 /* check for hp, sp change */
3891 if (food->stats.hp != 0) 3862 if (food->stats.hp != 0)
3892 { 3863 {
3893 if (QUERY_FLAG (food, FLAG_CURSED)) 3864 if (QUERY_FLAG (food, FLAG_CURSED))

Diff Legend

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