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

Comparing deliantra/server/common/living.C (file contents):
Revision 1.83 by root, Fri May 2 20:16:24 2008 UTC vs.
Revision 1.102 by root, Wed Nov 11 04:45:22 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 (©) 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 * 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 <global.h> 25#include <global.h>
… …
279 * that gives them that ability. 280 * that gives them that ability.
280 */ 281 */
281int 282int
282change_abil (object *op, object *tmp) 283change_abil (object *op, object *tmp)
283{ 284{
284 int flag = QUERY_FLAG (tmp, FLAG_APPLIED) ? 1 : -1, success = 0; 285 int flag = tmp->flag [FLAG_APPLIED] ? 1 : -1;
286 int success = 0;
285 char message[MAX_BUF]; 287 char message[MAX_BUF];
286 int potion_max = 0; 288 int potion_max = 0;
287 289
290 // keep some stats for comparison purposes
288 object::flags_t prev_flag = op->flag; 291 object::flags_t prev_flag = op->flag;
289 MoveType prev_move_type = op->move_type; 292 MoveType prev_move_type = op->move_type;
290 sint16 prev_resist [NROFATTACKS]; // clumsy 293 sint16 prev_resist [NROFATTACKS]; // clumsy
291 assert (sizeof (prev_resist) == sizeof (op->resist)); 294 assert (sizeof (prev_resist) == sizeof (op->resist));
292 memcpy (prev_resist, op->resist, sizeof (prev_resist)); 295 memcpy (prev_resist, op->resist, sizeof (prev_resist));
… …
294 if (op->type == PLAYER) 297 if (op->type == PLAYER)
295 { 298 {
296 if (tmp->type == POTION) 299 if (tmp->type == POTION)
297 { 300 {
298 potion_max = 1; 301 potion_max = 1;
302
299 for (int j = 0; j < NUM_STATS; j++) 303 for (int j = 0; j < NUM_STATS; j++)
300 { 304 {
301 int ostat = op->contr->orig_stats.stat (j); 305 int ostat = op->contr->orig_stats.stat (j);
302 int i = tmp->stats.stat (j); 306 int i = tmp->stats.stat (j);
303 307
304 /* nstat is what the stat will be after use of the potion */ 308 /* nstat is what the stat will be after use of the potion */
305 int nstat = flag * i + ostat; 309 int nstat = flag * i + ostat;
306 310
307 /* Do some bounds checking. While I don't think any 311 /* Do some bounds checking. There is the potential for potions
308 * potions do so right now, there is the potential for potions
309 * that adjust that stat by more than one point, so we need 312 * that adjust that stat by more than one point, so we need
310 * to allow for that. 313 * to allow for that.
311 */ 314 */
312 if (nstat < 1 && i * flag < 0) 315 if (nstat < 1 && i * flag < 0)
313 nstat = 1; 316 nstat = 1;
… …
398 /* MOVE_FLY_HIGH trumps MOVE_FLY_LOW - changing your move_fly_low 401 /* MOVE_FLY_HIGH trumps MOVE_FLY_LOW - changing your move_fly_low
399 * status doesn't make a difference if you are flying high 402 * status doesn't make a difference if you are flying high
400 */ 403 */
401 if (tmp->move_type & MOVE_FLY_LOW && !(op->move_type & MOVE_FLY_HIGH)) 404 if (tmp->move_type & MOVE_FLY_LOW && !(op->move_type & MOVE_FLY_HIGH))
402 { 405 {
403 DIFF_MSG (flag, "You start to float in the air!.", "You float down to the ground."); 406 DIFF_MSG (flag, "You start to float in the air!", "You float down to the ground.");
404 } 407 }
405 408
406 if (tmp->move_type & MOVE_FLY_HIGH) 409 if (tmp->move_type & MOVE_FLY_HIGH)
407 { 410 {
408 /* double conditional - second case covers if you have move_fly_low - 411 /* double conditional - second case covers if you have move_fly_low -
… …
566 new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, op, message); 569 new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, op, message);
567 } 570 }
568 } 571 }
569 572
570 if (!potion_max) 573 if (!potion_max)
571 {
572 for (int j = 0; j < NUM_STATS; j++) 574 for (int j = 0; j < NUM_STATS; j++)
573 {
574 if (int i = tmp->stats.stat (j)) 575 if (int i = tmp->stats.stat (j))
575 { 576 {
576 success = 1; 577 success = 1;
577 DIFF_MSG (i * flag, gain_msg[j], lose_msg[j]); 578 DIFF_MSG (i * flag, gain_msg[j], lose_msg[j]);
578 } 579 }
579 }
580 }
581 580
582 return success; 581 return success;
583} 582}
584 583
585/* 584/*
… …
596object::drain_specific_stat (int deplete_stats) 595object::drain_specific_stat (int deplete_stats)
597{ 596{
598 object *tmp; 597 object *tmp;
599 archetype *at; 598 archetype *at;
600 599
601 at = archetype::find (ARCH_DEPLETION); 600 at = archetype::find (shstr_depletion);
602 if (!at) 601 if (!at)
603 { 602 {
604 LOG (llevError, "Couldn't find archetype depletion.\n"); 603 LOG (llevError, "Couldn't find archetype depletion.\n");
605 return; 604 return;
606 } 605 }
… …
626 * via an applied bad_luck object. 625 * via an applied bad_luck object.
627 */ 626 */
628void 627void
629object::change_luck (int value) 628object::change_luck (int value)
630{ 629{
631 archetype *at = archetype::find ("luck"); 630 archetype *at = archetype::find (shstr_luck);
632 if (!at) 631 if (!at)
633 LOG (llevError, "Couldn't find archetype luck.\n"); 632 LOG (llevError, "Couldn't find archetype luck.\n");
634 else 633 else
635 { 634 {
636 object *tmp = present_arch_in_ob (at, this); 635 object *tmp = present_arch_in_ob (at, this);
… …
768 int stat_sum [NUM_STATS]; 767 int stat_sum [NUM_STATS];
769 768
770 /* First task is to clear all the values back to their original values */ 769 /* First task is to clear all the values back to their original values */
771 if (type == PLAYER) 770 if (type == PLAYER)
772 { 771 {
772 contr->delayed_update = false;
773
773 for (int i = 0; i < NUM_STATS; i++) 774 for (int i = 0; i < NUM_STATS; i++)
774 stat_sum [i] = contr->orig_stats.stat (i); 775 stat_sum [i] = contr->orig_stats.stat (i);
775 776
776 if (settings.spell_encumbrance == TRUE) 777 if (settings.spell_encumbrance == TRUE)
777 contr->encumbrance = 0; 778 contr->encumbrance = 0;
… …
860 * then calls this function. 861 * then calls this function.
861 */ 862 */
862 if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == POTION) 863 if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == POTION)
863 continue; 864 continue;
864 865
865 /* See note in map.c:update_position about making this additive
866 * since light sources are never applied, need to put check here.
867 */
868 if (tmp->glow_radius > glow_radius)
869 glow_radius = tmp->glow_radius; 866 glow_radius += tmp->glow_radius;
870 867
871 /* For some things, we don't care what is equipped */ 868 /* For some things, we don't care what is equipped */
872 if (tmp->type == SKILL) 869 if (tmp->type == SKILL)
873 { 870 {
874 /* Want to take the highest skill here. */ 871 /* Want to take the highest skill here. */
… …
887 else if (tmp->level > grace_obj->level) 884 else if (tmp->level > grace_obj->level)
888 grace_obj = tmp; 885 grace_obj = tmp;
889 } 886 }
890 } 887 }
891 888
892 /* Container objects are not meant to adjust a players, but other applied 889 /* Container objects are not meant to adjust players, but other applied
893 * objects need to make adjustments. 890 * objects need to make adjustments.
894 * This block should handle all player specific changes 891 * This block should handle all player specific changes
895 * The check for Praying is a bit of a hack - god given bonuses are put 892 * The check for Praying is a bit of a hack - god given bonuses are put
896 * in the praying skill, and the player should always get those. 893 * in the praying skill, and the player should always get those.
897 * It also means we need to put in additional checks for applied below, 894 * It also means we need to put in additional checks for applied below,
… …
920 917
921 if (digest_types [tmp->type]) 918 if (digest_types [tmp->type])
922 { 919 {
923 contr->digestion += tmp->stats.food; 920 contr->digestion += tmp->stats.food;
924 contr->gen_hp += tmp->stats.hp; 921 contr->gen_hp += tmp->stats.hp;
922 if (tmp->type != BOW) // ugly exception for bows
925 contr->gen_sp += tmp->stats.sp; 923 contr->gen_sp += tmp->stats.sp;
926 contr->gen_grace += tmp->stats.grace; 924 contr->gen_grace += tmp->stats.grace;
927 contr->gen_sp_armour += tmp->gen_sp_armour; 925 contr->gen_sp_armour += tmp->gen_sp_armour;
928 } 926 }
929 } /* if this is a player */ 927 } /* if this is a player */
930 else 928 else
… …
940 938
941 if (tmp->type == SYMPTOM) 939 if (tmp->type == SYMPTOM)
942 speed_reduce_from_disease = 940 speed_reduce_from_disease =
943 min (speed_reduce_from_disease, tmp->last_sp ? tmp->last_sp / 100.f : 1.f); 941 min (speed_reduce_from_disease, tmp->last_sp ? tmp->last_sp / 100.f : 1.f);
944 942
945 /* Pos. and neg. protections are counted seperate (-> pro/vuln). 943 /* Pos. and neg. protections are counted separate (-> pro/vuln).
946 * (Negative protections are calculated exactly like positive.) 944 * (Negative protections are calculated exactly like positive.)
947 * Resistance from potions are treated special as well. If there's 945 * Resistance from potions are treated special as well. If there's
948 * more than one potion-effect, the bigger prot.-value is taken. 946 * more than one potion-effect, the bigger prot.-value is taken.
949 */ 947 */
950 if (tmp->type != POTION) 948 if (tmp->type != POTION)
… …
1139 else /* To nullify the below effect */ 1137 else /* To nullify the below effect */
1140 ac += tmp->stats.ac + tmp->magic; 1138 ac += tmp->stats.ac + tmp->magic;
1141 } 1139 }
1142 1140
1143 if (tmp->stats.wc) 1141 if (tmp->stats.wc)
1144 wc -= (tmp->stats.wc + tmp->magic); 1142 wc -= tmp->stats.wc + tmp->magic;
1145 1143
1146 if (tmp->stats.ac) 1144 if (tmp->stats.ac)
1147 ac -= (tmp->stats.ac + tmp->magic); 1145 ac -= tmp->stats.ac + tmp->magic;
1148 1146
1149 if (ARMOUR_SPEED (tmp)) 1147 if (ARMOUR_SPEED (tmp))
1150 max_speed = min (max_speed, ARMOUR_SPEED (tmp) / 10.f); 1148 max_speed = min (max_speed, ARMOUR_SPEED (tmp) / 10.f);
1151 1149
1152 break; 1150 break;
1153 } /* switch tmp->type */ 1151 } /* switch tmp->type */
1154 } /* item is equipped */ 1152 } /* item is equipped */
1155 } /* for loop of items */ 1153 } /* for loop of items */
1154
1155 glow_radius = min (glow_radius, MAX_LIGHT_RADIUS);
1156 1156
1157 /* We've gone through all the objects the player has equipped. For many things, we 1157 /* We've gone through all the objects the player has equipped. For many things, we
1158 * have generated intermediate values which we now need to assign. 1158 * have generated intermediate values which we now need to assign.
1159 */ 1159 */
1160 1160
… …
1330 1330
1331 speed = 1.f + speed_bonus[stats.Dex]; 1331 speed = 1.f + speed_bonus[stats.Dex];
1332 1332
1333 if (settings.search_items && contr->search_str[0]) 1333 if (settings.search_items && contr->search_str[0])
1334 speed -= 1; 1334 speed -= 1;
1335
1336 if (attacktype == 0)
1337 attacktype = arch->attacktype;
1338 } /* End if player */ 1335 } /* End if player */
1339 1336
1340 if (added_speed >= 0) 1337 if (added_speed >= 0)
1341 speed += added_speed / 10.f; 1338 speed += added_speed / 10.f;
1342 else /* Something wrong here...: */ 1339 else /* Something wrong here...: */
… …
1410 move_type &= ~MOVE_WALK; 1407 move_type &= ~MOVE_WALK;
1411 1408
1412 /* It is quite possible that a player's spell costing might have changed, 1409 /* It is quite possible that a player's spell costing might have changed,
1413 * so we will check that now. 1410 * so we will check that now.
1414 */ 1411 */
1415 if (type == PLAYER) 1412 if (is_player ())
1416 { 1413 contr->update_spells ();
1417 esrv_update_stats (contr);
1418 esrv_update_spells (contr);
1419 }
1420 1414
1421 // update the mapspace, if we are on a map 1415 // update the mapspace, if we are on a map
1422 if (!flag [FLAG_REMOVED] && map) 1416 if (!flag [FLAG_REMOVED] && map)
1423 map->at (x, y).flags_ = 0; 1417 map->at (x, y).flags_ = 0;
1418}
1419
1420void
1421object::set_glow_radius (sint8 rad)
1422{
1423 glow_radius = rad;
1424
1425 if (is_on_map ())
1426 update_all_los (map, x, y);
1427 else if (object *env = outer_env ())
1428 {
1429 env->update_stats ();
1430
1431 if (env->is_on_map ())
1432 update_all_los (env->map, env->x, env->y);
1433 }
1424} 1434}
1425 1435
1426/* 1436/*
1427 * Returns true if the given player is a legal class. 1437 * Returns true if the given player is a legal class.
1428 * The function to add and remove class-bonuses to the stats doesn't 1438 * The function to add and remove class-bonuses to the stats doesn't
… …
1444 1454
1445/* 1455/*
1446 * set the new dragon name after gaining levels or 1456 * set the new dragon name after gaining levels or
1447 * changing ability focus (later this can be extended to 1457 * changing ability focus (later this can be extended to
1448 * eventually change the player's face and animation) 1458 * eventually change the player's face and animation)
1449 *
1450 * Note that the title is written to 'own_title' in the
1451 * player struct. This should be changed to 'ext_title'
1452 * as soon as clients support this!
1453 * Please, anyone, write support for 'ext_title'.
1454 */ 1459 */
1455void 1460void
1456set_dragon_name (object *pl, const object *abil, const object *skin) 1461set_dragon_name (object *pl, const object *abil, const object *skin)
1457{ 1462{
1458 int atnr = -1; /* attacknumber of highest level */ 1463 int atnr = -1; /* attacknumber of highest level */
… …
1476 /* now if there are equals at highest level, pick the one with focus, 1481 /* now if there are equals at highest level, pick the one with focus,
1477 or else at random */ 1482 or else at random */
1478 if (atnr_is_dragon_enabled (abil->stats.exp) && abil->resist[abil->stats.exp] >= level) 1483 if (atnr_is_dragon_enabled (abil->stats.exp) && abil->resist[abil->stats.exp] >= level)
1479 atnr = abil->stats.exp; 1484 atnr = abil->stats.exp;
1480 1485
1481 level = (int) (level / 25.);
1482
1483 /* now set the new title */ 1486 /* now set the new title */
1484 if (pl->contr)
1485 {
1486 if (level == 0)
1487 sprintf (pl->contr->title, "%s hatchling", attacks[atnr]); 1487 if (level < 25) sprintf (pl->contr->title, "%s hatchling", attacks[atnr]);
1488 else if (level == 1)
1489 sprintf (pl->contr->title, "%s wyrm", attacks[atnr]); 1488 else if (level < 50) sprintf (pl->contr->title, "%s wyrm" , attacks[atnr]);
1490 else if (level == 2)
1491 sprintf (pl->contr->title, "%s wyvern", attacks[atnr]); 1489 else if (level < 75) sprintf (pl->contr->title, "%s wyvern" , attacks[atnr]);
1492 else if (level == 3)
1493 sprintf (pl->contr->title, "%s dragon", attacks[atnr]); 1490 else if (level < 100) sprintf (pl->contr->title, "%s dragon" , attacks[atnr]);
1494 else 1491 else
1495 { 1492 {
1496 /* special titles for extra high resistance! */ 1493 /* special titles for extra high resistance! */
1497 if (skin->resist[atnr] > 80)
1498 sprintf (pl->contr->title, "legendary %s dragon", attacks[atnr]); 1494 if (skin->resist[atnr] > 80) sprintf (pl->contr->title, "legendary %s dragon", attacks[atnr]);
1499 else if (skin->resist[atnr] > 50)
1500 sprintf (pl->contr->title, "ancient %s dragon", attacks[atnr]); 1495 else if (skin->resist[atnr] > 50) sprintf (pl->contr->title, "ancient %s dragon" , attacks[atnr]);
1501 else
1502 sprintf (pl->contr->title, "big %s dragon", attacks[atnr]); 1496 else sprintf (pl->contr->title, "big %s dragon" , attacks[atnr]);
1503 }
1504 } 1497 }
1505 1498
1506 strcpy (pl->contr->own_title, ""); 1499 strcpy (pl->contr->own_title, "");
1507} 1500}
1508 1501
1509/* 1502/*
1510 * This function is called when a dragon-player gains 1503 * This function is called when a dragon-player gains
1511 * an overall level. Here, the dragon might gain new abilities 1504 * an overall level. Here, the dragon might gain new abilities
1512 * or change the ability-focus. 1505 * or change the ability-focus.
1513 */ 1506 */
1514void 1507static void
1515dragon_level_gain (object *who) 1508dragon_level_gain (object *who)
1516{ 1509{
1517 object *abil = NULL; /* pointer to dragon ability force */ 1510 object *abil = NULL; /* pointer to dragon ability force */
1518 object *skin = NULL; /* pointer to dragon skin force */ 1511 object *skin = NULL; /* pointer to dragon skin force */
1519 object *tmp = NULL; /* tmp. object */ 1512 object *tmp = NULL; /* tmp. object */
… …
1575 object *skill_obj; 1568 object *skill_obj;
1576 1569
1577 skill_obj = get_archetype_by_skill_name (skill_name, SKILL); 1570 skill_obj = get_archetype_by_skill_name (skill_name, SKILL);
1578 if (!skill_obj) 1571 if (!skill_obj)
1579 { 1572 {
1580 LOG (llevError, "add_player_exp: couldn't find skill %s\n", skill_name); 1573 LOG (llevError, "give_skill_by_name: couldn't find skill %s\n", skill_name);
1581 return NULL; 1574 return NULL;
1582 } 1575 }
1583 1576
1584 /* clear the flag - exp goes into this bucket, but player 1577 /* clear the flag - exp goes into this bucket, but player
1585 * still doesn't know it. 1578 * still doesn't know it.
1586 */ 1579 */
1587 CLEAR_FLAG (skill_obj, FLAG_CAN_USE_SKILL); 1580 CLEAR_FLAG (skill_obj, FLAG_CAN_USE_SKILL);
1588 skill_obj->stats.exp = 0; 1581 skill_obj->stats.exp = 0;
1589 skill_obj->level = 1; 1582 skill_obj->level = 1;
1590 insert_ob_in_ob (skill_obj, op); 1583 op->insert (skill_obj);
1591 1584
1592 if (player *pl = op->contr) 1585 if (player *pl = op->contr)
1593 { 1586 pl->link_skills ();
1594 pl->last_skill_ob [skill_obj->subtype] = skill_obj;
1595 if (pl->ns)
1596 pl->ns->last_skill_exp[skill_obj->subtype] = -1;//TODO: should be made superfluous
1597 }
1598 1587
1599 return skill_obj; 1588 return skill_obj;
1600} 1589}
1601 1590
1602/* player_lvl_adj() - for the new exp system. we are concerned with 1591/* player_lvl_adj() - for the new exp system. we are concerned with
… …
1662 new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf); 1651 new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
1663 } 1652 }
1664 } 1653 }
1665 1654
1666 if (changed) 1655 if (changed)
1667 { 1656 who->update_stats (); // should cause esrv_update_stats and esrv_update_spells
1668 who->update_stats ();
1669 esrv_update_stats (who->contr);
1670 /* check if the spell data has changed */
1671 esrv_update_spells (who->contr);
1672 }
1673} 1657}
1674 1658
1675/* 1659/*
1676 * Returns how much experience is needed for a player to become 1660 * Returns how much experience is needed for a player to become
1677 * the given level. level should really never exceed max_level 1661 * the given level. level should really never exceed max_level
… …
1721 * flag is what to do if the player doesn't have the skill: 1705 * flag is what to do if the player doesn't have the skill:
1722 */ 1706 */
1723static void 1707static void
1724add_player_exp (object *op, sint64 exp, const char *skill_name, int flag) 1708add_player_exp (object *op, sint64 exp, const char *skill_name, int flag)
1725{ 1709{
1726 object *skill_obj = NULL; 1710 object *skill_obj;
1727 sint64 limit, exp_to_add; 1711 sint64 limit, exp_to_add;
1728 int i; 1712 int i;
1729 1713
1730 /* prevents some forms of abuse. */ 1714 /* prevents some forms of abuse. */
1731 if (op->contr->braced) 1715 if (op->contr->braced)
… …
1734 /* Try to find the matching skill. 1718 /* Try to find the matching skill.
1735 * We do a shortcut/time saving mechanism first - see if it matches 1719 * We do a shortcut/time saving mechanism first - see if it matches
1736 * chosen_skill. This means we don't need to search through 1720 * chosen_skill. This means we don't need to search through
1737 * the players inventory. 1721 * the players inventory.
1738 */ 1722 */
1723 skill_obj = 0;
1724
1739 if (skill_name) 1725 if (skill_name)
1740 { 1726 {
1741 if (op->chosen_skill && op->chosen_skill->type == SKILL && !strcmp (skill_name, op->chosen_skill->skill)) 1727 skill_obj = op->contr->find_skill (skill_name);
1742 skill_obj = op->chosen_skill;
1743 else
1744 {
1745 for (i = 0; i < NUM_SKILLS; i++)
1746 if (op->contr->last_skill_ob[i] && !strcmp (op->contr->last_skill_ob[i]->skill, skill_name))
1747 {
1748 skill_obj = op->contr->last_skill_ob[i];
1749 break;
1750 }
1751 1728
1752 /* Player doesn't have the skill. Check to see what to do, and give 1729 /* Player doesn't have the skill. Check to see what to do, and give
1753 * it to the player if necessary 1730 * it to the player if necessary
1754 */ 1731 */
1755 if (!skill_obj) 1732 if (!skill_obj)
1756 { 1733 {
1757 if (flag == SK_EXP_NONE) 1734 if (flag == SK_EXP_NONE)
1758 return; 1735 return;
1736
1759 else if (flag == SK_EXP_ADD_SKILL) 1737 if (flag == SK_EXP_ADD_SKILL)
1760 give_skill_by_name (op, skill_name); 1738 skill_obj = give_skill_by_name (op, skill_name);
1761 }
1762 } 1739 }
1763 } 1740 }
1764 1741
1765 if (flag != SK_EXP_SKILL_ONLY) 1742 if (flag != SK_EXP_SKILL_ONLY)
1766 { 1743 {
… …
1799 player_lvl_adj (op, skill_obj); 1776 player_lvl_adj (op, skill_obj);
1800 } 1777 }
1801} 1778}
1802 1779
1803/* This function checks to make sure that object 'op' can 1780/* This function checks to make sure that object 'op' can
1804 * lost 'exp' experience. It returns the amount of exp 1781 * lose 'exp' experience. It returns the amount of exp
1805 * object 'op' can in fact lose - it basically makes 1782 * object 'op' can in fact lose - it basically makes
1806 * adjustments based on permanent exp and the like. 1783 * adjustments based on permanent exp and the like.
1807 * This function should always be used for losing experience - 1784 * This function should always be used for losing experience -
1808 * the 'exp' value passed should be positive - this is the 1785 * the 'exp' value passed should be positive - this is the
1809 * amount that should get subtract from the player. 1786 * amount that should get subtract from the player.
1810 */ 1787 */
1811sint64 1788static sint64
1812check_exp_loss (const object *op, sint64 exp) 1789check_exp_loss (const object *op, sint64 exp)
1813{ 1790{
1814 sint64 del_exp; 1791 sint64 del_exp;
1815 1792
1816 if (exp > op->stats.exp) 1793 if (exp > op->stats.exp)
1817 exp = op->stats.exp; 1794 exp = op->stats.exp;
1795
1818 if (settings.permanent_exp_ratio) 1796 if (settings.permanent_exp_ratio)
1819 { 1797 {
1820 del_exp = (sint64) ((op->stats.exp - op->perm_exp) * PERM_EXP_MAX_LOSS_RATIO); 1798 del_exp = (sint64) ((op->stats.exp - op->perm_exp) * PERM_EXP_MAX_LOSS_RATIO);
1799
1821 if (del_exp < 0) 1800 if (del_exp < 0)
1822 del_exp = 0; 1801 del_exp = 0;
1802
1823 if (exp > del_exp) 1803 if (exp > del_exp)
1824 exp = del_exp; 1804 exp = del_exp;
1825 } 1805 }
1806
1826 return exp; 1807 return exp;
1827} 1808}
1828 1809
1829sint64 1810sint64
1830check_exp_adjust (const object *op, sint64 exp) 1811check_exp_adjust (const object *op, sint64 exp)
1831{ 1812{
1832 if (exp < 0) 1813 if (exp < 0)
1833 return check_exp_loss (op, exp); 1814 return check_exp_loss (op, exp);
1834 else 1815 else
1835 return MIN (exp, (sint64) MAX_EXPERIENCE - op->stats.exp); 1816 return min (exp, (sint64)MAX_EXPERIENCE - op->stats.exp);
1836} 1817}
1837
1838 1818
1839/* Subtracts experience from player. 1819/* Subtracts experience from player.
1840 * if skill is set and flag == SK_SUBTRACT_SKILL_EXP, then we 1820 * if skill is set and flag == SK_SUBTRACT_SKILL_EXP, then we
1841 * only subtract from the matching skill. Otherwise, 1821 * only subtract from the matching skill. Otherwise,
1842 * this subtracts a portion from all 1822 * this subtracts a portion from all
… …
1856 sint64 del_exp; 1836 sint64 del_exp;
1857 1837
1858 for (tmp = op->inv; tmp; tmp = tmp->below) 1838 for (tmp = op->inv; tmp; tmp = tmp->below)
1859 if (tmp->type == SKILL && tmp->stats.exp) 1839 if (tmp->type == SKILL && tmp->stats.exp)
1860 { 1840 {
1861 if (flag == SK_SUBTRACT_SKILL_EXP && skill && !strcmp (tmp->skill, skill)) 1841 if (flag == SK_SUBTRACT_SKILL_EXP && skill && !strcmp (&tmp->skill, skill))
1862 { 1842 {
1863 del_exp = check_exp_loss (tmp, exp); 1843 del_exp = check_exp_loss (tmp, exp);
1864 tmp->stats.exp -= del_exp; 1844 tmp->stats.exp -= del_exp;
1865 player_lvl_adj (op, tmp); 1845 player_lvl_adj (op, tmp);
1866 } 1846 }
… …
1954 * amount of permenent experience, whichever gives the lowest loss. 1934 * amount of permenent experience, whichever gives the lowest loss.
1955 */ 1935 */
1956void 1936void
1957apply_death_exp_penalty (object *op) 1937apply_death_exp_penalty (object *op)
1958{ 1938{
1959 object *tmp;
1960 sint64 loss; 1939 sint64 loss;
1961 sint64 percentage_loss; /* defined by the setting 'death_penalty_percent' */ 1940 sint64 percentage_loss; /* defined by the setting 'death_penalty_percent' */
1962 sint64 level_loss; /* defined by the setting 'death_penalty_levels */ 1941 sint64 level_loss; /* defined by the setting 'death_penalty_levels */
1963 1942
1964 for (tmp = op->inv; tmp; tmp = tmp->below) 1943 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1965 if (tmp->type == SKILL && tmp->stats.exp) 1944 if (tmp->type == SKILL && tmp->stats.exp)
1966 { 1945 {
1967
1968 percentage_loss = tmp->stats.exp * settings.death_penalty_ratio / 100; 1946 percentage_loss = tmp->stats.exp * settings.death_penalty_ratio / 100;
1969 level_loss = tmp->stats.exp - levels[MAX (0, tmp->level - settings.death_penalty_level)]; 1947 level_loss = tmp->stats.exp - levels [max (0, tmp->level - settings.death_penalty_level)];
1970 1948
1971 /* With the revised exp system, you can get cases where 1949 /* With the revised exp system, you can get cases where
1972 * losing several levels would still require that you have more 1950 * losing several levels would still require that you have more
1973 * exp than you currently have - this is true if the levels 1951 * exp than you currently have - this is true if the levels
1974 * tables is a lot harder. 1952 * tables is a lot harder.
1975 */ 1953 */
1976 if (level_loss < 0) 1954 if (level_loss < 0)
1977 level_loss = 0; 1955 level_loss = 0;
1978 1956
1979 loss = check_exp_loss (tmp, MIN (level_loss, percentage_loss)); 1957 loss = check_exp_loss (tmp, min (level_loss, percentage_loss));
1980 1958
1981 tmp->stats.exp -= loss; 1959 tmp->stats.exp -= loss;
1982 player_lvl_adj (op, tmp); 1960 player_lvl_adj (op, tmp);
1983 } 1961 }
1984 1962
1985 percentage_loss = op->stats.exp * settings.death_penalty_ratio / 100; 1963 percentage_loss = op->stats.exp * settings.death_penalty_ratio / 100;
1986 level_loss = op->stats.exp - levels[MAX (0, op->level - settings.death_penalty_level)]; 1964 level_loss = op->stats.exp - levels[max (0, op->level - settings.death_penalty_level)];
1987 1965
1988 if (level_loss < 0) 1966 if (level_loss < 0)
1989 level_loss = 0; 1967 level_loss = 0;
1968
1990 loss = check_exp_loss (op, MIN (level_loss, percentage_loss)); 1969 loss = check_exp_loss (op, min (level_loss, percentage_loss));
1991 1970
1992 op->stats.exp -= loss; 1971 op->stats.exp -= loss;
1993 player_lvl_adj (op, NULL); 1972 player_lvl_adj (op, NULL);
1994} 1973}
1995 1974

Diff Legend

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