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.204 by root, Mon Oct 19 21:48:49 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;
… …
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 update_button (trap, originator);
1390 break;
1391
1392 case ALTAR:
1393 /* sacrifice victim on trap */
1394 apply_altar (trap, victim, originator);
1395 break;
1396
1397 case THROWN_OBJ:
1398 if (trap->inv == NULL)
1399 break;
1400 /* fallthrough */
1401
1402 case ARROW:
1403 /* bad bug: monster throw a object, make a step forwards, step on object ,
1404 * trigger this here and get hit by own missile - and will be own enemy.
1405 * Victim then is his own enemy and will start to kill herself (this is
1406 * removed) but we have not synced victim and his missile. To avoid senseless
1407 * action, we avoid hits here
1408 */
1409 if ((QUERY_FLAG (victim, FLAG_ALIVE) && trap->speed) && trap->owner != victim)
1410 hit_with_arrow (trap, victim);
1411 break;
1412
1413 case SPELL_EFFECT:
1414 apply_spell_effect (trap, victim);
1415 break;
1416
1417 case TRAPDOOR:
1384 { 1418 {
1419 int max, sound_was_played;
1420 object *ab, *ab_next;
1421
1385 if (!trap->stats.maxsp) 1422 if (!trap->value)
1386 trap->stats.maxsp = 2; 1423 {
1424 int tot;
1387 1425
1388 /* Is this correct? From the docs, it doesn't look like it 1426 for (ab = trap->above, tot = 0; ab; ab = ab->above)
1389 * should be divided by trap->speed 1427 if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1428 tot += ab->head_ ()->total_weight ();
1429
1430 if (!(trap->value = (tot > trap->weight) ? 1 : 0))
1431 break;
1432
1433 SET_ANIMATION (trap, trap->value);
1434 update_object (trap, UP_OBJ_FACE);
1435 }
1436
1437 for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next)
1438 {
1439 /* need to set this up, since if we do transfer the object,
1440 * ab->above would be bogus
1390 */ 1441 */
1391 victim->speed_left = -FABS (trap->stats.maxsp * victim->speed / trap->speed); 1442 ab_next = ab->above;
1392 1443
1393 /* Just put in some sanity check. I think there is a bug in the 1444 if ((ab->move_type && trap->move_on) || ab->move_type == 0)
1394 * above with some objects have zero speed, and thus the player 1445 {
1395 * getting permanently paralyzed. 1446 if (!sound_was_played)
1447 {
1448 trap->play_sound (trap->sound ? trap->sound : sound_find ("fall_hole"));
1449 sound_was_played = 1;
1450 }
1451
1452 ab->statusmsg ("You fall into a trapdoor!", NDI_RED);
1453 transfer_ob (ab, EXIT_X (trap), EXIT_Y (trap), 0, ab);
1454 }
1396 */ 1455 }
1397 if (victim->speed_left < -50.f) 1456 break;
1398 victim->speed_left = -50.f;
1399 /* LOG(llevDebug, "apply, playermove, player speed_left=%f\n", victim->speed_left); */
1400 } 1457 }
1401 goto leave;
1402 1458
1403 case SPINNER: 1459 case CONVERTER:
1404 if (victim->direction) 1460 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 { 1461 {
1456 int tot; 1462 originator->failmsg (format ("The %s seems to be broken!", query_name (trap)));
1457 1463 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 } 1464 }
1468 1465
1469 for (ab = trap->above, max = 100, sound_was_played = 0; --max && ab; ab = ab_next) 1466 break;
1467
1468 case TRIGGER_BUTTON:
1469 case TRIGGER_PEDESTAL:
1470 case TRIGGER_ALTAR:
1471 check_trigger (trap, victim, originator);
1472 break;
1473
1474 case DEEP_SWAMP:
1475 walk_on_deep_swamp (trap, victim);
1476 break;
1477
1478 case CHECK_INV:
1479 check_inv (victim, trap);
1480 break;
1481
1482 case HOLE:
1483 move_apply_hole (trap, victim);
1484 break;
1485
1486 case EXIT:
1487 if (victim->type == PLAYER && EXIT_PATH (trap))
1470 { 1488 {
1471 /* need to set this up, since if we do transfer the object, 1489 /* Basically, don't show exits leading to random maps the
1472 * ab->above would be bogus 1490 * players output.
1473 */ 1491 */
1474 ab_next = ab->above; 1492 if (trap->msg && !EXIT_PATH (trap).starts_with ("/!"))
1493 victim->statusmsg (trap->msg, NDI_NAVY);
1475 1494
1476 if ((ab->move_type && trap->move_on) || ab->move_type == 0) 1495 trap->play_sound (trap->sound);
1477 { 1496 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 } 1497 }
1488 goto leave; 1498 break;
1489 }
1490 1499
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: 1500 case ENCOUNTER:
1533 /* may be some leftovers on this */ 1501 /* may be some leftovers on this */
1534 goto leave; 1502 break;
1535 1503
1536 case SHOP_MAT: 1504 case SHOP_MAT:
1537 apply_shop_mat (trap, victim); 1505 apply_shop_mat (trap, victim);
1538 goto leave; 1506 break;
1539 1507
1540 /* Drop a certain amount of gold, and have one item identified */ 1508 /* Drop a certain amount of gold, and have one item identified */
1541 case IDENTIFY_ALTAR: 1509 case IDENTIFY_ALTAR:
1542 apply_id_altar (victim, trap, originator); 1510 apply_id_altar (victim, trap, originator);
1543 goto leave; 1511 break;
1544 1512
1545 case SIGN: 1513 case SIGN:
1546 if (victim->type != PLAYER && trap->stats.food > 0) 1514 if (victim->type != PLAYER && trap->stats.food > 0)
1547 goto leave; /* monsters musn't apply magic_mouths with counters */ 1515 break; /* monsters musn't apply magic_mouths with counters */
1548 1516
1549 apply_sign (victim, trap, 1); 1517 apply_sign (victim, trap, 1);
1550 goto leave; 1518 break;
1551 1519
1552 case CONTAINER: 1520 case CONTAINER:
1553 apply_container (victim, trap); 1521 apply_container (victim, trap);
1554 goto leave; 1522 break;
1555 1523
1556 case RUNE: 1524 case RUNE:
1557 case TRAP: 1525 case TRAP:
1558 if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE)) 1526 if (trap->level && QUERY_FLAG (victim, FLAG_ALIVE))
1559 spring_trap (trap, victim); 1527 spring_trap (trap, victim);
1560 goto leave; 1528 break;
1561 1529
1562 default: 1530 default:
1563 LOG (llevDebug, "name %s, arch %s, type %d with fly/walk on/off not " 1531 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); 1532 "handled in move_apply()\n", &trap->name, &trap->arch->archname, trap->type);
1565 goto leave; 1533 break;
1566 } 1534 }
1567 1535
1568leave:
1569 recursion_depth--; 1536 recursion_depth--;
1570} 1537}
1571 1538
1572/** 1539/**
1573 * Handles reading a regular (ie not containing a spell) book. 1540 * Handles reading a regular (ie not containing a spell) book.
… …
1584 return; 1551 return;
1585 } 1552 }
1586 1553
1587 if (!tmp->msg) 1554 if (!tmp->msg)
1588 { 1555 {
1589 op->failmsg (format ("You open the %s and find it empty.", &tmp->name)); 1556 op->failmsg (format ("The %s contains nothing but meaningless gibberish. H<There is nothing interesting to read here.>", &tmp->name));
1590 return; 1557 return;
1591 } 1558 }
1592 1559
1593 /* need a literacy skill to read stuff! */ 1560 /* need a literacy skill to read stuff! */
1594 skill_ob = find_skill_by_name (op, tmp->skill); 1561 skill_ob = find_skill_by_name (op, tmp->skill);
… …
1776 LOG (llevError, "apply_spellbook: Book %s has no spell in it!\n", &tmp->name); 1743 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!"); 1744 op->failmsg ("The spellbook symbols make no sense. This is a bug, please report!");
1778 return; 1745 return;
1779 } 1746 }
1780 1747
1781 if (skop->level < int (sqrtf (spell->level) * 1.5f)) 1748 int learn_level = sqrtf (spell->level) * 1.5f;
1749 if (skop->level < learn_level)
1782 { 1750 {
1783 op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low.>", &tmp->skill)); 1751 op->failmsg (format ("You are unable to decipher the strange symbols. H<Your %s level is too low, it must be at least %d.>",
1752 &tmp->skill, learn_level));
1784 return; 1753 return;
1785 } 1754 }
1786 1755
1787 op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name)); 1756 op->statusmsg (format ("The spellbook contains the %s level spell %s.", get_levelnumber (spell->level), &spell->name));
1788 1757
… …
2339/** 2308/**
2340 * This function will try to apply a lighter and in case no lighter 2309 * 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, 2310 * is specified it will try to find a lighter in the players inventory,
2342 * and inform him about this requirement. 2311 * and inform him about this requirement.
2343 * 2312 *
2344 * who - the player 2313 * who - the player
2345 * op - the item we want to light 2314 * op - the item we want to light
2346 * ligher - the lighter or 0 if a lighter has yet to be found 2315 * lighter - the lighter or 0 if a lighter has yet to be found
2347 */ 2316 */
2317static object *
2348object *auto_apply_lighter (object *who, object *op, object *lighter) 2318auto_apply_lighter (object *who, object *op, object *lighter)
2349{ 2319{
2350 if (lighter == 0) 2320 if (lighter == 0)
2351 { 2321 {
2352 for (object *tmp = who->inv; tmp; tmp = tmp->below) 2322 for (object *tmp = who->inv; tmp; tmp = tmp->below)
2353 { 2323 {
… …
2400 int is_player_env = 0; 2370 int is_player_env = 0;
2401 2371
2402 item = find_marked_object (who); 2372 item = find_marked_object (who);
2403 if (item) 2373 if (item)
2404 { 2374 {
2405 if (!auto_apply_lighter (who, 0, lighter)) 2375 if (!auto_apply_lighter (who, item, lighter))
2406 return; 2376 return;
2407 2377
2408 /* Perhaps we should split what we are trying to light on fire? 2378 /* 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 2379 * I can't see many times when you would want to light multiple
2410 * objects at once. 2380 * objects at once.
… …
2616 if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who))) 2586 if (INVOKE_OBJECT (APPLY, op, ARG_OBJECT (who)))
2617 return RESULT_INT (0); 2587 return RESULT_INT (0);
2618 2588
2619 switch (op->type) 2589 switch (op->type)
2620 { 2590 {
2621 case CF_HANDLE: 2591 case T_HANDLE:
2622 who->play_sound (sound_find ("turn_handle")); 2592 who->play_sound (sound_find ("turn_handle"));
2623 who->statusmsg ("You turn the handle."); 2593 who->statusmsg ("You turn the handle.");
2624 op->value = op->value ? 0 : 1; 2594 op->value = op->value ? 0 : 1;
2625 SET_ANIMATION (op, op->value); 2595 SET_ANIMATION (op, op->value);
2626 update_object (op, UP_OBJ_FACE); 2596 update_object (op, UP_OBJ_FACE);
2627 push_button (op, who); 2597 push_button (op, who);
2628 return 1; 2598 return 1;
2629 2599
2630 case TRIGGER: 2600 case TRIGGER:
2631 if (check_trigger (op, who)) 2601 if (check_trigger (op, who, who))
2632 { 2602 {
2633 who->statusmsg ("You turn the handle."); 2603 who->statusmsg ("You turn the handle.");
2634 who->play_sound (sound_find ("turn_handle")); 2604 who->play_sound (sound_find ("turn_handle"));
2635 } 2605 }
2636 else 2606 else
… …
2641 case EXIT: 2611 case EXIT:
2642 if (who->type != PLAYER) 2612 if (who->type != PLAYER)
2643 return 0; 2613 return 0;
2644 2614
2645 if (!EXIT_PATH (op) || !is_legal_2ways_exit (who, op)) 2615 if (!EXIT_PATH (op) || !is_legal_2ways_exit (who, op))
2646 who->failmsg (format ("The %s is closed.", query_name (op))); 2616 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 2617 else
2648 { 2618 {
2649 /* Don't display messages for random maps. */ 2619 /* Don't display messages for random maps. */
2650 if (op->msg && !EXIT_PATH (op).starts_with ("/!")) 2620 if (op->msg && !EXIT_PATH (op).starts_with ("/!"))
2651 who->statusmsg (op->msg, NDI_NAVY); 2621 who->statusmsg (op->msg, NDI_NAVY);
… …
2874 * we don't use a corrupt pointer for the next object, so we get the 2844 * 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 2845 * 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 2846 * problem if player_apply() has a bug in that it uses the object but does
2877 * not return a proper value. 2847 * not return a proper value.
2878 */ 2848 */
2879 for (object *next, *tmp = pl->container ? pl->container->inv : pl->below; tmp; tmp = next) 2849 for (object *next, *tmp = pl->container_ () ? pl->container_ ()->inv : pl->below; tmp; tmp = next)
2880 { 2850 {
2881 next = tmp->below; 2851 next = tmp->below;
2882 2852
2883 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 2853 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
2884 floors++; 2854 floors++;
… …
3390 * skill so that the dam and wc get updated 3360 * skill so that the dam and wc get updated
3391 */ 3361 */
3392 who->change_skill (skop); 3362 who->change_skill (skop);
3393 } 3363 }
3394 3364
3395 if (who->type == PLAYER 3365 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 { 3366 {
3399 who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER); 3367 who->failmsg ("Equipping that combined with other items would consume your soul!" LACK_ITEM_POWER);
3400 return 1; 3368 return 1;
3401 } 3369 }
3402 3370
… …
3410 return RESULT_INT (0); 3378 return RESULT_INT (0);
3411 3379
3412 switch (op->type) 3380 switch (op->type)
3413 { 3381 {
3414 case WEAPON: 3382 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 3383 //TODO: this obviously fails for players using a shorter prefix
3426 // i.e. "R" can use Ragnarok's sword. 3384 // i.e. "R" can use Ragnarok's sword.
3427 if (op->level && !op->name.starts_with (who->name)) 3385 if (op->level && !op->name.starts_with (who->name))
3428 { 3386 {
3429 /* if the weapon does not have the name as the character, can't use it. */ 3387 /* if the weapon does not have the name as the character, can't use it. */
… …
3555 } 3513 }
3556 3514
3557 break; 3515 break;
3558 3516
3559 case BOW: 3517 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)) 3518 if (op->level && !op->name.starts_with (who->name))
3571 { 3519 {
3572 who->failmsg ("The weapon does not recognize you as its owner. " 3520 who->failmsg ("The weapon does not recognize you as its owner. "
3573 "H<Its name indicates that it belongs to somebody else.>"); 3521 "H<Its name indicates that it belongs to somebody else.>");
3574 if (tmp) 3522 if (tmp)
… …
3839 } 3787 }
3840 3788
3841 for (mapspace *ms = spaces + size (); ms-- > spaces; ) 3789 for (mapspace *ms = spaces + size (); ms-- > spaces; )
3842 for (object *tmp = ms->bot; tmp; tmp = tmp->above) 3790 for (object *tmp = ms->bot; tmp; tmp = tmp->above)
3843 if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL)) 3791 if (tmp->above && (tmp->type == TRIGGER_BUTTON || tmp->type == TRIGGER_PEDESTAL))
3844 check_trigger (tmp, tmp->above); 3792 check_trigger (tmp, tmp->above, tmp->above);
3845} 3793}
3846 3794
3847/** 3795/**
3848 * Handles player eating food that temporarily changes status (resistances, stats). 3796 * Handles player eating food that temporarily changes status (resistances, stats).
3849 * This used to call cast_change_attr(), but 3797 * This used to call cast_change_attr(), but
… …
3854eat_special_food (object *who, object *food) 3802eat_special_food (object *who, object *food)
3855{ 3803{
3856 object *force; 3804 object *force;
3857 int i, did_one = 0; 3805 int i, did_one = 0;
3858 3806
3859 force = get_archetype (FORCE_NAME); 3807 char buf[64];
3808 snprintf (buf, sizeof(buf), "sp_food_%s", &food->title);
3809 shstr key (buf);
3860 3810
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 */ 3811 /* bigger morsel of food = longer effect time */
3882 force->duration = food->stats.food / 5; 3812 int duration = TIME2TICK (food->stats.food);
3883 SET_FLAG (force, FLAG_APPLIED); 3813
3884 change_abil (who, force); 3814 if (force = who->force_find (key))
3885 insert_ob_in_ob (force, who); 3815 {
3816 if (duration > abs (force->speed_left / force->speed))
3817 {
3818 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));
3819 force->force_set_timer (duration);
3820 }
3821 else
3822 new_draw_info (NDI_UNIQUE, 0, who, "It had no additional effect.");
3823
3824 return;
3886 } 3825 }
3887 else 3826 else
3827 {
3828 force = who->force_add (key, duration);
3829 force->name = key;
3830
3831 /* check if the food affects a stat */
3832 for (i = 0; i < NUM_STATS; i++)
3833 if (sint8 k = food->stats.stat (i))
3834 {
3835 force->stats.stat (i) = k;
3836 did_one = 1;
3837 }
3838
3839 /* check if we can protect the eater */
3840 for (i = 0; i < NROFATTACKS; i++)
3841 {
3842 if (food->resist[i] > 0)
3843 {
3844 force->resist[i] = food->resist[i];
3845 did_one = 1;
3846 }
3847 }
3848
3849 if (did_one)
3850 {
3851 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));
3852
3853 /* make the force take effect and report effects to user */
3854 change_abil (who, force);
3855 }
3856 else
3888 force->destroy (); 3857 force->destroy ();
3858 }
3889 3859
3890 /* check for hp, sp change */ 3860 /* check for hp, sp change */
3891 if (food->stats.hp != 0) 3861 if (food->stats.hp != 0)
3892 { 3862 {
3893 if (QUERY_FLAG (food, FLAG_CURSED)) 3863 if (QUERY_FLAG (food, FLAG_CURSED))

Diff Legend

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