ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/living.C
Revision: 1.95
Committed: Wed Dec 31 17:35:37 2008 UTC (15 years, 4 months ago) by root
Content type: text/plain
Branch: MAIN
CVS Tags: rel-2_75
Changes since 1.94: +2 -2 lines
Log Message:
refactoring of shstr classe,s new shstr_tmp, lots of minor rewriting

File Contents

# User Rev Content
1 elmex 1.1 /*
2 root 1.80 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 pippijn 1.30 *
4 root 1.82 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 root 1.65 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6     * Copyright (©) 1992,2007 Frank Tore Johansen
7 pippijn 1.30 *
8 root 1.80 * Deliantra is free software: you can redistribute it and/or modify
9 root 1.68 * it under the terms of the GNU General Public License as published by
10     * the Free Software Foundation, either version 3 of the License, or
11     * (at your option) any later version.
12 pippijn 1.30 *
13 root 1.68 * This program is distributed in the hope that it will be useful,
14     * but WITHOUT ANY WARRANTY; without even the implied warranty of
15     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16     * GNU General Public License for more details.
17 pippijn 1.30 *
18 root 1.68 * You should have received a copy of the GNU General Public License
19     * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 root 1.65 *
21 root 1.80 * The authors can be reached via e-mail to <support@deliantra.net>
22 pippijn 1.30 */
23 elmex 1.1
24     #include <global.h>
25    
26     /* Handy little macro that adds exp and keeps it within bounds. Since
27     * we are now using 64 bit values, I'm not all concerned about overflow issues
28     * with exptotal wrapping. exptotal is typically op->exp, or op->perm_exp
29     */
30     #define ADD_EXP(exptotal, exp) {exptotal += exp; if (exptotal > MAX_EXPERIENCE) exptotal = MAX_EXPERIENCE; }
31    
32 root 1.9 static const int con_bonus[MAX_STAT + 1] = {
33     -6, -5, -4, -3, -2, -1, -1, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20,
34     22, 25, 30, 40, 50
35 elmex 1.1 };
36    
37     /* changed the name of this to "sp_bonus" from "int_bonus"
38     * because Pow can now be the stat that controls spellpoint
39     * advancement. -b.t.
40     */
41 root 1.9 static const int sp_bonus[MAX_STAT + 1] = {
42     -10, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 15, 20, 25,
43     30, 40, 50, 70, 100
44 elmex 1.1 };
45    
46 root 1.9 static const int grace_bonus[MAX_STAT + 1] = {
47     -10, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 15, 20, 25,
48     30, 40, 50, 70, 100
49 elmex 1.1 };
50    
51     /* 0.92.7 Changed way charisma works. Values now
52     * represent how much more it costs to buy something than to sell it
53     * (10, a value of 10 means it is that if it costs 50 gp to buy, you
54     * would only get 5 gp when you sell.) Let query_cost do the calculations
55     * on how to really do this. Buy keeping it this simple number, it is
56     * much easier to know how things will be influenced. A value of '1' means
57     * buying and selling is both the same value - any value less than or equal
58     * to 1 should not be used.
59     * At least as of now, the only place that uses this code is query_cost,
60     * in server/shop.c. This bonus is split evenly between buying and selling
61     * (ie, if the bonus is 2.0, then items are bought for 1.33 list, and sold
62     * at .667
63     * This is figured by diff=(y-1)/(1+y), and for buy, it is 1+diff, for sell
64     * it is 1-diff
65     */
66    
67     const float cha_bonus[MAX_STAT + 1] = { 10.0,
68 root 1.9 10.0, 9.0, 8.0, 7.0, 6.0, /* 5 */
69     5.0, 4.5, 4.0, 3.5, 3.0, /* 10 */
70     2.9, 2.8, 2.7, 2.6, 2.5, /* 15 */
71     2.4, 2.3, 2.2, 2.1, 2.0, /* 20 */
72     1.9, 1.8, 1.7, 1.6, 1.5, /* 25 */
73     1.4, 1.3, 1.2, 1.1, 1.0 /* 30 */
74 elmex 1.1 };
75    
76 root 1.9 const int dex_bonus[MAX_STAT + 1] = {
77     -4, -3, -2, -2, -1, -1, -1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7
78 elmex 1.1 };
79    
80     /* speed_bonus uses dex as its stat */
81 root 1.9 const float speed_bonus[MAX_STAT + 1] = {
82 elmex 1.1 -0.4, -0.35, -0.3, -0.25, -0.2, -0.16, -0.12, -0.09, -0.06, -0.03, -0.01, 0, 0.01, 0.03,
83     0.05, 0.1, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.8, 1.0, 1.2, 1.4,
84     1.6, 1.8, 2.0, 2.5, 3.0
85     };
86    
87     /* dam_bonus, thaco_bonus, max_carry, weight limit all are based on
88     * strength.
89     */
90 root 1.9 const int dam_bonus[MAX_STAT + 1] = {
91     -2, -2, -2, -1, -1, -1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 6, 7, 8, 10, 15
92 elmex 1.1 };
93    
94 root 1.9 const int thaco_bonus[MAX_STAT + 1] = {
95     -2, -2, -1, -1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 7, 8, 10
96 elmex 1.1 };
97    
98     /* Max you can carry before you start getting extra speed penalties */
99 root 1.9 const int max_carry[MAX_STAT + 1] = {
100     2, 4, 7, 11, 16, 22, 29, 37, 46, 56, 67, 79, 92, 106, 121, 137, 154, 172, 191, 211, 232, 254, 277,
101     301, 326, 352, 400, 450, 500, 600, 1000
102 elmex 1.1 };
103    
104     /* weight_limit - the absolute most a character can carry - a character can't
105     * pick stuff up if it would put him above this limit.
106     * value is in grams, so we don't need to do conversion later
107     * These limits are probably overly generous, but being there were no values
108     * before, you need to start someplace.
109     */
110    
111 root 1.9 const uint32 weight_limit[MAX_STAT + 1] = {
112     200000, /* 0 */
113     250000, 300000, 350000, 400000, 500000, /* 5 */
114     600000, 700000, 800000, 900000, 1000000, /* 10 */
115     1100000, 1200000, 1300000, 1400000, 1500000, /* 15 */
116     1650000, 1800000, 1950000, 2100000, 2250000, /* 20 */
117     2400000, 2550000, 2700000, 2850000, 3000000, /* 25 */
118     3250000, 3500000, 3750000, 4000000, 4500000 /*30 */
119 elmex 1.1 };
120    
121 root 1.9 const int learn_spell[MAX_STAT + 1] = {
122     0, 0, 0, 1, 2, 4, 8, 12, 16, 25, 36, 45, 55, 65, 70, 75, 80, 85, 90, 95, 100, 100, 100, 100, 100,
123     100, 100, 100, 100, 100, 100
124 elmex 1.1 };
125    
126 root 1.9 const int cleric_chance[MAX_STAT + 1] = {
127     100, 100, 100, 100, 90, 80, 70, 60, 50, 40, 35, 30, 25, 20, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0
128 elmex 1.1 };
129    
130 root 1.9 const int turn_bonus[MAX_STAT + 1] = {
131     -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 5, 5, 6, 7, 8, 9, 10, 12, 15
132 elmex 1.1 };
133    
134 root 1.9 const int fear_bonus[MAX_STAT + 1] = {
135     3, 3, 3, 3, 2, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
136 elmex 1.1 };
137    
138     /*
139     Since this is nowhere defined ...
140     Both come in handy at least in function add_exp()
141     */
142    
143     #define MAX_EXPERIENCE levels[settings.max_level]
144    
145     /* because exp_obj sum to make the total score,
146     * we cannot allow that sum to exceed the maximum
147     * amount of experience a player can gain. Thus
148     * we define MAX_EXP_IN_OBJ. It is important to try
149     * to make the value of MAX_EXP_CAT close to the
150     * actual number of experience objects in the game,
151     * otherwise the maximum level in any experience
152     * category could be quite low. To help the situation
153     * out a little I added 10 more levels, and jacked
154     * up the last level experience value. Its out of
155     * line with progression of previous levels, so
156     * if more levels are desired, this should be fixed.
157     * -b.t.
158     */
159    
160 root 1.9 #define MAX_EXP_IN_OBJ levels[settings.max_level]/(MAX_EXP_CAT - 1)
161 elmex 1.1
162     extern sint64 *levels;
163    
164     #define MAX_SAVE_LEVEL 110
165 root 1.9
166 elmex 1.1 /* This no longer needs to be changed anytime the number of
167     * levels is increased - rather, did_make_save will do the
168     * right thing and always use range within this table.
169     * for safety, savethrow should not be accessed directly anymore,
170     * and instead did_make_save should be used instead.
171     */
172 root 1.9 static const int savethrow[MAX_SAVE_LEVEL + 1] = {
173 elmex 1.1 18,
174 root 1.9 18, 17, 16, 15, 14, 14, 13, 13, 12, 12, 12, 11, 11, 11, 11, 10, 10, 10, 10, 9,
175     9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6,
176     6, 6, 6, 6, 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4,
177     4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2,
178     2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
179     1, 1, 1, 1, 1, 1, 1, 1, 1, 1
180 elmex 1.1 };
181    
182     const char *const attacks[NROFATTACKS] = {
183     "physical", "magical", "fire", "electricity", "cold", "confusion",
184     "acid", "drain", "weaponmagic", "ghosthit", "poison", "slow",
185     "paralyze", "turn undead", "fear", "cancellation", "depletion", "death",
186 root 1.9 "chaos", "counterspell", "god power", "holy power", "blinding", "",
187 elmex 1.1 "life stealing"
188     };
189    
190     static const char *const drain_msg[NUM_STATS] = {
191     "Oh no! You are weakened!",
192     "You're feeling clumsy!",
193     "You feel less healthy",
194     "You suddenly begin to lose your memory!",
195 root 1.9 "Watch out, your mind is going!",
196 root 1.28 "Your spirit feels drained!",
197 root 1.27 "Your face gets distorted!",
198 elmex 1.1 };
199     const char *const restore_msg[NUM_STATS] = {
200     "You feel your strength return.",
201     "You feel your agility return.",
202     "You feel your health return.",
203 root 1.27 "You feel your memory return.",
204 elmex 1.1 "You feel your wisdom return.",
205 root 1.28 "You feel your spirits return.",
206 elmex 1.1 "You feel your charisma return.",
207     };
208     const char *const gain_msg[NUM_STATS] = {
209 root 1.9 "You feel stronger.",
210     "You feel more agile.",
211     "You feel healthy.",
212 root 1.27 "You feel smarter.",
213 root 1.9 "You feel wiser.",
214 root 1.28 "You feel more potent.",
215 root 1.9 "You seem to look better.",
216 elmex 1.1 };
217     const char *const lose_msg[NUM_STATS] = {
218 root 1.9 "You feel weaker!",
219     "You feel clumsy!",
220     "You feel less healthy!",
221 root 1.27 "You feel stupid!",
222 root 1.9 "You lose some of your memory!",
223 root 1.28 "You feel less potent!",
224 root 1.9 "You look ugly!",
225 elmex 1.1 };
226    
227     const char *const statname[NUM_STATS] = {
228 root 1.21 "strength", "dexterity", "constitution", "intelligence", "wisdom", "power", "charisma"
229 elmex 1.1 };
230    
231     const char *const short_stat_name[NUM_STATS] = {
232 root 1.21 "Str", "Dex", "Con", "Int", "Wis", "Pow", "Cha"
233 elmex 1.1 };
234    
235     /*
236     * Like set_attr_value(), but instead the value (which can be negative)
237     * is added to the specified stat.
238     */
239     void
240 root 1.19 change_attr_value (living *stats, int attr, sint8 value)
241 root 1.9 {
242 root 1.50 stats->stat (attr) += value;
243     }
244 root 1.19
245 elmex 1.1 /*
246     * Ensures that all stats (str/dex/con/wis/cha/int) are within the
247     * 1-30 stat limit.
248     */
249 root 1.9 void
250 root 1.19 check_stat_bounds (living *stats)
251 root 1.9 {
252 root 1.50 for (int i = 0; i < NUM_STATS; i++)
253     {
254     sint8 &v = stats->stat (i);
255     v = clamp (v, MIN_STAT, MAX_STAT);
256     }
257 elmex 1.1 }
258    
259     #define ORIG_S(xyz,abc) (op->contr->orig_stats.abc)
260    
261     /* Rather than having a whole bunch of if (flag) new_draw.. else new_draw,
262     * make this macro to clean those up. Not usuable outside change_abil
263     * function since some of the values passed to new_draw_info are hardcoded.
264     */
265     #define DIFF_MSG(flag, msg1, msg2) \
266     new_draw_info(NDI_UNIQUE, 0, op, (flag>0)?msg1:msg2);
267    
268     /* return 1 if we sucessfully changed a stat, 0 if nothing was changed. */
269 root 1.9
270 elmex 1.1 /* flag is set to 1 if we are applying the object, -1 if we are removing
271     * the object.
272     * It is the calling functions responsibilty to check to see if the object
273     * can be applied or not.
274     * The main purpose of calling this function is the messages that are
275 root 1.48 * displayed - update_stats should really always be called after this when
276 elmex 1.1 * removing an object - that is because it is impossible to know if some object
277     * is the only source of an attacktype or spell attunement, so this function
278     * will clear the bits, but the player may still have some other object
279     * that gives them that ability.
280     */
281 root 1.9 int
282     change_abil (object *op, object *tmp)
283     {
284 root 1.84 int flag = tmp->flag [FLAG_APPLIED] ? 1 : -1;
285     int success = 0;
286 root 1.9 char message[MAX_BUF];
287     int potion_max = 0;
288    
289 root 1.84 // keep some stats for comparison purposes
290 root 1.83 object::flags_t prev_flag = op->flag;
291     MoveType prev_move_type = op->move_type;
292     sint16 prev_resist [NROFATTACKS]; // clumsy
293     assert (sizeof (prev_resist) == sizeof (op->resist));
294     memcpy (prev_resist, op->resist, sizeof (prev_resist));
295 root 1.9
296     if (op->type == PLAYER)
297     {
298     if (tmp->type == POTION)
299     {
300     potion_max = 1;
301 root 1.84
302 root 1.51 for (int j = 0; j < NUM_STATS; j++)
303 root 1.9 {
304 root 1.51 int ostat = op->contr->orig_stats.stat (j);
305     int i = tmp->stats.stat (j);
306 root 1.9
307     /* nstat is what the stat will be after use of the potion */
308 root 1.51 int nstat = flag * i + ostat;
309 root 1.9
310 root 1.84 /* Do some bounds checking. There is the potential for potions
311 root 1.9 * that adjust that stat by more than one point, so we need
312     * to allow for that.
313     */
314     if (nstat < 1 && i * flag < 0)
315     nstat = 1;
316 root 1.67 else if (nstat > 20 + op->arch->stats.stat (j))
317     nstat = 20 + op->arch->stats.stat (j);
318 root 1.20
319 root 1.9 if (nstat != ostat)
320     {
321 root 1.50 op->contr->orig_stats.stat (j) = nstat;
322 root 1.9 potion_max = 0;
323 root 1.3 }
324 root 1.9 else if (i)
325     {
326     /* potion is useless - player has already hit the natural maximum */
327     potion_max = 1;
328 root 1.3 }
329     }
330 root 1.20
331 root 1.9 /* This section of code ups the characters normal stats also. I am not
332     * sure if this is strictly necessary, being that fix_player probably
333     * recalculates this anyway.
334     */
335 root 1.51 for (int j = 0; j < NUM_STATS; j++)
336 root 1.50 change_attr_value (&op->stats, j, flag * tmp->stats.stat (j));
337 root 1.20
338 root 1.48 check_stat_bounds (&op->stats);
339 root 1.9 } /* end of potion handling code */
340     }
341    
342 root 1.51 /* reset attributes that update_stats doesn't reset since it doesn't search
343 root 1.9 * everything to set
344     */
345     if (flag == -1)
346     {
347 root 1.48 op->attacktype &= ~tmp->attacktype;
348     op->path_attuned &= ~tmp->path_attuned;
349 root 1.9 op->path_repelled &= ~tmp->path_repelled;
350 root 1.48 op->path_denied &= ~tmp->path_denied;
351 root 1.9 /* Presuming here that creatures only have move_type,
352     * and not the other move_ fields.
353     */
354 root 1.48 op->move_type &= ~tmp->move_type;
355 elmex 1.1 }
356    
357 root 1.9 /* call fix_player since op object could have whatever attribute due
358 root 1.51 * to multiple items. if update_stats always has to be called after
359 root 1.9 * change_ability then might as well call it from here
360     */
361 root 1.19 op->update_stats ();
362 root 1.9
363 root 1.51 /* update_stats won't add the bows ability to the player, so don't
364 root 1.9 * print out message if this is a bow.
365     */
366     if (tmp->attacktype & AT_CONFUSION && tmp->type != BOW)
367     {
368     success = 1;
369     DIFF_MSG (flag, "Your hands begin to glow red.", "Your hands stop glowing red.");
370     }
371 root 1.20
372 root 1.83 if (op->flag [FLAG_LIFESAVE] != prev_flag [FLAG_LIFESAVE])
373 root 1.9 {
374     success = 1;
375     DIFF_MSG (flag, "You feel very protected.", "You don't feel protected anymore.");
376     }
377 root 1.20
378 root 1.83 if (op->flag [FLAG_REFL_MISSILE] != prev_flag [FLAG_REFL_MISSILE])
379 root 1.9 {
380     success = 1;
381     DIFF_MSG (flag, "A magic force shimmers around you.", "The magic force fades away.");
382     }
383 root 1.20
384 root 1.83 if (op->flag [FLAG_REFL_SPELL] != prev_flag [FLAG_REFL_SPELL])
385 root 1.9 {
386     success = 1;
387     DIFF_MSG (flag, "You feel more safe now, somehow.", "Suddenly you feel less safe, somehow.");
388     }
389 root 1.20
390 root 1.9 /* movement type has changed. We don't care about cases where
391     * user has multiple items giving the same type appled like we
392     * used to - that is more work than what we gain, plus messages
393     * can be misleading (a little higher could be miscontrued from
394     * from fly high)
395     */
396 root 1.83 if (tmp->move_type && op->move_type != prev_move_type)
397 root 1.9 {
398     success = 1;
399 elmex 1.1
400 root 1.9 /* MOVE_FLY_HIGH trumps MOVE_FLY_LOW - changing your move_fly_low
401     * status doesn't make a difference if you are flying high
402     */
403     if (tmp->move_type & MOVE_FLY_LOW && !(op->move_type & MOVE_FLY_HIGH))
404     {
405 root 1.86 DIFF_MSG (flag, "You start to float in the air!", "You float down to the ground.");
406 root 1.3 }
407    
408 root 1.9 if (tmp->move_type & MOVE_FLY_HIGH)
409     {
410     /* double conditional - second case covers if you have move_fly_low -
411     * in that case, you don't actually land
412     */
413 root 1.51 DIFF_MSG (flag, "You soar into the air!",
414 root 1.9 (op->move_type & MOVE_FLY_LOW ? "You fly lower in the air" : "You float down to the ground."));
415 root 1.3 }
416 root 1.48
417 root 1.9 if (tmp->move_type & MOVE_SWIM)
418     DIFF_MSG (flag, "You feel ready for a swim", "You no longer feel like swimming");
419 elmex 1.1
420 root 1.9 /* Changing move status may mean you are affected by things you weren't before */
421     check_move_on (op, op);
422 elmex 1.1 }
423    
424 root 1.9 /* becoming UNDEAD... a special treatment for this flag. Only those not
425     * originally undead may change their status
426     */
427 root 1.83 if (!op->arch->flag [FLAG_UNDEAD])
428     if (op->flag [FLAG_UNDEAD] != prev_flag [FLAG_UNDEAD])
429 root 1.9 {
430     success = 1;
431     if (flag > 0)
432     {
433     op->race = "undead";
434     new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce drains away!");
435     }
436     else
437     {
438 root 1.67 op->race = op->arch->race;
439 root 1.9 new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce returns!");
440     }
441     }
442 elmex 1.1
443 root 1.83 if (op->flag [FLAG_STEALTH] != prev_flag [FLAG_STEALTH])
444 root 1.9 {
445     success = 1;
446     DIFF_MSG (flag, "You walk more quietly.", "You walk more noisily.");
447 elmex 1.1 }
448 root 1.20
449 root 1.83 if (op->flag [FLAG_MAKE_INVIS] != prev_flag [FLAG_MAKE_INVIS])
450 root 1.9 {
451     success = 1;
452     DIFF_MSG (flag, "You become transparent.", "You can see yourself.");
453 elmex 1.1 }
454 root 1.20
455 root 1.9 /* blinded you can tell if more blinded since blinded player has minimal
456     * vision
457     */
458 root 1.83 if (tmp->flag [FLAG_BLIND])
459 root 1.9 {
460     success = 1;
461     if (flag > 0)
462     {
463 root 1.83 if (op->flag [FLAG_WIZ])
464 root 1.9 new_draw_info (NDI_UNIQUE, 0, op, "Your mortal self is blinded.");
465     else
466     {
467     new_draw_info (NDI_UNIQUE, 0, op, "You are blinded.");
468     SET_FLAG (op, FLAG_BLIND);
469     if (op->type == PLAYER)
470     op->contr->do_los = 1;
471 root 1.3 }
472 root 1.9 }
473     else
474     {
475 root 1.83 if (op->flag [FLAG_WIZ])
476 root 1.9 new_draw_info (NDI_UNIQUE, 0, op, "Your mortal self can now see again.");
477     else
478     {
479     new_draw_info (NDI_UNIQUE, 0, op, "Your vision returns.");
480     CLEAR_FLAG (op, FLAG_BLIND);
481     if (op->type == PLAYER)
482     op->contr->do_los = 1;
483 root 1.3 }
484     }
485 elmex 1.1 }
486    
487 root 1.83 if (op->flag [FLAG_SEE_IN_DARK] != prev_flag [FLAG_SEE_IN_DARK])
488 root 1.9 {
489     success = 1;
490     if (op->type == PLAYER)
491     op->contr->do_los = 1;
492     DIFF_MSG (flag, "Your vision is better in the dark.", "You see less well in the dark.");
493 elmex 1.1 }
494    
495 root 1.83 if (op->flag [FLAG_XRAYS] != prev_flag [FLAG_XRAYS])
496 root 1.9 {
497     success = 1;
498     if (flag > 0)
499     {
500 root 1.83 if (op->flag [FLAG_WIZ])
501 root 1.9 new_draw_info (NDI_UNIQUE, 0, op, "Your vision becomes a little clearer.");
502     else
503     {
504     new_draw_info (NDI_UNIQUE, 0, op, "Everything becomes transparent.");
505     if (op->type == PLAYER)
506     op->contr->do_los = 1;
507 root 1.3 }
508 root 1.9 }
509     else
510     {
511 root 1.83 if (op->flag [FLAG_WIZ])
512 root 1.9 new_draw_info (NDI_UNIQUE, 0, op, "Your vision becomes a bit out of focus.");
513     else
514     {
515     new_draw_info (NDI_UNIQUE, 0, op, "Everything suddenly looks very solid.");
516     if (op->type == PLAYER)
517     op->contr->do_los = 1;
518 root 1.3 }
519     }
520 elmex 1.1 }
521    
522 root 1.9 if (tmp->stats.luck)
523     {
524     success = 1;
525     DIFF_MSG (flag * tmp->stats.luck, "You feel more lucky.", "You feel less lucky.");
526 elmex 1.1 }
527    
528 root 1.9 if (tmp->stats.hp && op->type == PLAYER)
529     {
530     success = 1;
531     DIFF_MSG (flag * tmp->stats.hp, "You feel much more healthy!", "You feel much less healthy!");
532 elmex 1.1 }
533    
534 root 1.9 if (tmp->stats.sp && op->type == PLAYER && tmp->type != SKILL)
535     {
536     success = 1;
537     DIFF_MSG (flag * tmp->stats.sp, "You feel one with the powers of magic!", "You suddenly feel very mundane.");
538 elmex 1.1 }
539    
540 root 1.9 /* for the future when artifacts set this -b.t. */
541     if (tmp->stats.grace && op->type == PLAYER)
542     {
543     success = 1;
544     DIFF_MSG (flag * tmp->stats.grace, "You feel closer to your god!", "You suddenly feel less holy.");
545 elmex 1.1 }
546    
547 root 1.9 if (tmp->stats.food && op->type == PLAYER)
548     {
549     success = 1;
550     DIFF_MSG (flag * tmp->stats.food, "You feel your digestion slowing down.", "You feel your digestion speeding up.");
551 elmex 1.1 }
552    
553 root 1.9 /* Messages for changed resistance */
554 root 1.51 for (int i = 0; i < NROFATTACKS; i++)
555 root 1.9 {
556     if (i == ATNR_PHYSICAL)
557     continue; /* Don't display about armour */
558    
559 root 1.83 if (op->resist [i] != prev_resist [i])
560 root 1.9 {
561     success = 1;
562 root 1.83
563     if (op->resist [i] > prev_resist [i])
564     sprintf (message, "Your resistance to %s rises to %d%%.", change_resist_msg [i], op->resist [i]);
565 root 1.9 else
566 root 1.83 sprintf (message, "Your resistance to %s drops to %d%%.", change_resist_msg [i], op->resist [i]);
567 root 1.9
568     new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, op, message);
569 root 1.3 }
570 elmex 1.1 }
571    
572 elmex 1.18 if (!potion_max)
573 root 1.84 for (int j = 0; j < NUM_STATS; j++)
574     if (int i = tmp->stats.stat (j))
575 root 1.9 {
576 root 1.84 success = 1;
577     DIFF_MSG (i * flag, gain_msg[j], lose_msg[j]);
578 root 1.3 }
579 root 1.20
580 root 1.9 return success;
581 elmex 1.1 }
582    
583     /*
584     * Stat draining by Vick 930307
585     * (Feeling evil, I made it work as well now. -Frank 8)
586     */
587 root 1.9 void
588 root 1.19 object::drain_stat ()
589 root 1.9 {
590 root 1.33 drain_specific_stat (rndm (NUM_STATS));
591 elmex 1.1 }
592    
593 root 1.9 void
594 root 1.19 object::drain_specific_stat (int deplete_stats)
595 root 1.9 {
596 elmex 1.1 object *tmp;
597     archetype *at;
598    
599 root 1.11 at = archetype::find (ARCH_DEPLETION);
600 root 1.9 if (!at)
601     {
602     LOG (llevError, "Couldn't find archetype depletion.\n");
603     return;
604     }
605     else
606     {
607 root 1.19 tmp = present_arch_in_ob (at, this);
608    
609 root 1.9 if (!tmp)
610     {
611     tmp = arch_to_object (at);
612 root 1.19 tmp = insert_ob_in_ob (tmp, this);
613 root 1.9 SET_FLAG (tmp, FLAG_APPLIED);
614     }
615     }
616    
617 root 1.19 new_draw_info (NDI_UNIQUE, 0, this, drain_msg[deplete_stats]);
618 root 1.9 change_attr_value (&tmp->stats, deplete_stats, -1);
619 root 1.19 update_stats ();
620 elmex 1.1 }
621    
622     /*
623     * A value of 0 indicates timeout, otherwise change the luck of the object.
624     * via an applied bad_luck object.
625     */
626 root 1.9 void
627 root 1.19 object::change_luck (int value)
628 root 1.9 {
629 root 1.19 archetype *at = archetype::find ("luck");
630 elmex 1.1 if (!at)
631 root 1.9 LOG (llevError, "Couldn't find archetype luck.\n");
632     else
633     {
634 root 1.19 object *tmp = present_arch_in_ob (at, this);
635    
636 root 1.9 if (!tmp)
637     {
638     if (!value)
639     return;
640 root 1.19
641 root 1.9 tmp = arch_to_object (at);
642 root 1.19 tmp = insert_ob_in_ob (tmp, this);
643 root 1.9 SET_FLAG (tmp, FLAG_APPLIED);
644     }
645 root 1.19
646 root 1.9 if (value)
647     {
648     /* Limit the luck value of the bad luck object to +/-100. This
649     * (arbitrary) value prevents overflows (both in the bad luck object and
650     * in op itself).
651     */
652 root 1.19 int new_luck = tmp->stats.luck + value;
653    
654 root 1.9 if (new_luck >= -100 && new_luck <= 100)
655     {
656 root 1.19 stats.luck += value;
657 root 1.9 tmp->stats.luck = new_luck;
658     }
659     }
660     else
661     {
662     if (!tmp->stats.luck)
663 root 1.19 return;
664    
665 root 1.9 /* Randomly change the players luck. Basically, we move it
666     * back neutral (if greater>0, subtract, otherwise add)
667     */
668 root 1.32 if (rndm (abs (tmp->stats.luck)) >= rndm (30))
669 root 1.9 {
670     int diff = tmp->stats.luck > 0 ? -1 : 1;
671    
672 root 1.19 stats.luck += diff;
673 root 1.9 tmp->stats.luck += diff;
674     }
675     }
676 elmex 1.1 }
677     }
678    
679     /*
680     * Subtracts stat-bonuses given by the class which the player has chosen.
681     */
682 root 1.9 void
683 root 1.19 object::remove_statbonus ()
684 root 1.9 {
685 root 1.51 for (int i = 0; i < NUM_STATS; ++i)
686     {
687 root 1.67 sint8 v = arch->stats.stat (i);
688 root 1.51 stats.stat (i) -= v;
689     contr->orig_stats.stat (i) -= v;
690     }
691 elmex 1.1 }
692    
693     /*
694     * Adds stat-bonuses given by the class which the player has chosen.
695     */
696 root 1.9 void
697 root 1.19 object::add_statbonus ()
698 root 1.9 {
699 root 1.51 for (int i = 0; i < NUM_STATS; ++i)
700     {
701 root 1.67 sint8 v = arch->stats.stat (i);
702 root 1.51 stats.stat (i) += v;
703     contr->orig_stats.stat (i) += v;
704     }
705 elmex 1.1 }
706    
707 root 1.74 /* These are the items that currently can change digestion, regeneration,
708     * spell point recovery and mana point recovery. Seems sort of an arbitary
709     * list, but other items store other info into stats array.
710     */
711     static struct digest_types : std::bitset<NUM_TYPES>
712     {
713     digest_types ()
714     {
715     set (WEAPON);
716     set (BOW);
717     set (ARMOUR);
718     set (HELMET);
719     set (SHIELD);
720     set (RING);
721     set (BOOTS);
722     set (GLOVES);
723     set (AMULET);
724     set (GIRDLE);
725     set (BRACERS);
726     set (CLOAK);
727     set (DISEASE);
728     set (FORCE);
729     set (SKILL);
730     }
731     } digest_types;
732    
733     static struct copy_flags : object::flags_t
734     {
735     copy_flags ()
736     {
737     set (FLAG_LIFESAVE);
738     set (FLAG_REFL_SPELL);
739     set (FLAG_REFL_MISSILE);
740     set (FLAG_STEALTH);
741     set (FLAG_XRAYS);
742     set (FLAG_BLIND);
743     set (FLAG_SEE_IN_DARK);
744     }
745     } copy_flags;
746    
747 elmex 1.1 /*
748     * Updates all abilities given by applied objects in the inventory
749     * of the given object. Note: This function works for both monsters
750     * and players; the "player" in the name is purely an archaic inheritance.
751     * This functions starts from base values (archetype or player object)
752     * and then adjusts them according to what the player has equipped.
753 root 1.36 *
754     * July 95 - inserted stuff to handle new skills/exp system - b.t.
755     * spell system split, grace points now added to system --peterm
756 elmex 1.1 */
757 root 1.9 void
758 root 1.19 object::update_stats ()
759 root 1.9 {
760 root 1.74 float f, max_speed = 9, added_speed = 0, bonus_speed = 0, speed_reduce_from_disease = 1;
761 root 1.9 int weapon_weight = 0, weapon_speed = 0;
762     int best_wc = 0, best_ac = 0, wc = 0, ac = 0;
763     int prot[NROFATTACKS], vuln[NROFATTACKS], potion_resist[NROFATTACKS];
764 root 1.55 object *grace_obj = NULL, *mana_obj = NULL, *tmp;
765 root 1.24 float old_speed = speed;
766 root 1.75 int stat_sum [NUM_STATS];
767 root 1.9
768     /* First task is to clear all the values back to their original values */
769 root 1.19 if (type == PLAYER)
770 root 1.9 {
771 root 1.75 for (int i = 0; i < NUM_STATS; i++)
772     stat_sum [i] = contr->orig_stats.stat (i);
773 root 1.19
774 root 1.9 if (settings.spell_encumbrance == TRUE)
775 root 1.19 contr->encumbrance = 0;
776 root 1.9
777 root 1.19 attacktype = 0;
778 root 1.39
779     contr->digestion = 0;
780     contr->gen_hp = 0;
781     contr->gen_sp = 0;
782     contr->gen_grace = 0;
783 root 1.19 contr->gen_sp_armour = 10;
784 root 1.39 contr->item_power = 0;
785 root 1.9 }
786    
787 root 1.47 for (int i = NUM_BODY_LOCATIONS; i--; )
788     slot[i].used = slot[i].info;
789 root 1.19
790     slaying = 0;
791 root 1.9
792 root 1.19 if (!QUERY_FLAG (this, FLAG_WIZ))
793 root 1.9 {
794 root 1.19 CLEAR_FLAG (this, FLAG_XRAYS);
795     CLEAR_FLAG (this, FLAG_MAKE_INVIS);
796 root 1.9 }
797    
798 root 1.19 CLEAR_FLAG (this, FLAG_LIFESAVE);
799     CLEAR_FLAG (this, FLAG_STEALTH);
800     CLEAR_FLAG (this, FLAG_BLIND);
801    
802 root 1.67 if (!QUERY_FLAG (arch, FLAG_REFL_SPELL )) CLEAR_FLAG (this, FLAG_REFL_SPELL);
803     if (!QUERY_FLAG (arch, FLAG_REFL_MISSILE)) CLEAR_FLAG (this, FLAG_REFL_MISSILE);
804     if (!QUERY_FLAG (arch, FLAG_UNDEAD )) CLEAR_FLAG (this, FLAG_UNDEAD);
805     if (!QUERY_FLAG (arch, FLAG_SEE_IN_DARK )) CLEAR_FLAG (this, FLAG_SEE_IN_DARK);
806    
807     path_attuned = arch->path_attuned;
808     path_repelled = arch->path_repelled;
809     path_denied = arch->path_denied;
810     glow_radius = arch->glow_radius;
811     move_type = arch->move_type;
812 root 1.39
813 root 1.46 chosen_skill = 0;
814 root 1.9
815     /* initializing resistances from the values in player/monster's
816     * archetype clone
817     */
818 root 1.67 memcpy (&resist, &arch->resist, sizeof (resist));
819 root 1.9
820 root 1.75 for (int i = 0; i < NROFATTACKS; i++)
821 root 1.9 {
822 root 1.19 if (resist[i] > 0)
823     prot[i] = resist[i], vuln[i] = 0;
824 root 1.9 else
825 root 1.19 vuln[i] = -(resist[i]), prot[i] = 0;
826 root 1.46
827 root 1.9 potion_resist[i] = 0;
828     }
829    
830 root 1.67 wc = arch->stats.wc;
831     stats.dam = arch->stats.dam;
832 root 1.9
833     /* for players which cannot use armour, they gain AC -1 per 3 levels,
834     * plus a small amount of physical resist, those poor suckers. ;)
835     * the fact that maxlevel is factored in could be considered sort of bogus -
836     * we should probably give them some bonus and cap it off - otherwise,
837     * basically, if a server updates its max level, these playes may find
838     * that their protection from physical goes down
839     */
840 root 1.19 if (!QUERY_FLAG (this, FLAG_USE_ARMOUR) && type == PLAYER)
841 root 1.9 {
842 root 1.74 ac = max (-10, arch->stats.ac - level / 3);
843 root 1.19 prot[ATNR_PHYSICAL] += ((100 - prot[AT_PHYSICAL]) * (80 * level / settings.max_level)) / 100;
844 elmex 1.1 }
845 root 1.9 else
846 root 1.67 ac = arch->stats.ac;
847 root 1.9
848 root 1.67 stats.luck = arch->stats.luck;
849     speed = arch->speed;
850 root 1.9
851     /* OK - we've reset most all the objects attributes to sane values.
852     * now go through and make adjustments for what the player has equipped.
853     */
854 root 1.19 for (tmp = inv; tmp; tmp = tmp->below)
855 root 1.9 {
856     /* This happens because apply_potion calls change_abil with the potion
857 root 1.40 * applied so we can tell the player what changed. But change_abil
858 root 1.9 * then calls this function.
859     */
860     if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == POTION)
861 root 1.19 continue;
862 root 1.3
863 root 1.94 glow_radius += tmp->glow_radius;
864 root 1.64
865 root 1.9 /* For some things, we don't care what is equipped */
866     if (tmp->type == SKILL)
867     {
868     /* Want to take the highest skill here. */
869     if (IS_MANA_SKILL (tmp->subtype))
870     {
871     if (!mana_obj)
872     mana_obj = tmp;
873     else if (tmp->level > mana_obj->level)
874     mana_obj = tmp;
875     }
876 root 1.19
877 root 1.9 if (IS_GRACE_SKILL (tmp->subtype))
878     {
879     if (!grace_obj)
880     grace_obj = tmp;
881     else if (tmp->level > grace_obj->level)
882     grace_obj = tmp;
883 root 1.3 }
884     }
885    
886 root 1.85 /* Container objects are not meant to adjust players, but other applied
887 root 1.9 * objects need to make adjustments.
888     * This block should handle all player specific changes
889     * The check for Praying is a bit of a hack - god given bonuses are put
890     * in the praying skill, and the player should always get those.
891     * It also means we need to put in additional checks for applied below,
892     * because the skill shouldn't count against body positions being used
893     * up, etc.
894     */
895 root 1.49 if ((tmp->flag [FLAG_APPLIED]
896 root 1.39 && tmp->type != CONTAINER
897     && tmp->type != CLOSE_CON)
898     || (tmp->type == SKILL
899     && tmp->subtype == SK_PRAYING))
900 root 1.9 {
901 root 1.19 if (type == PLAYER)
902 root 1.9 {
903 root 1.69 contr->item_power += tmp->item_power;
904    
905 root 1.49 if (tmp == contr->combat_ob || tmp == contr->ranged_ob)
906 root 1.58 if (tmp != current_weapon
907     && (tmp->type != SKILL || tmp->subtype != SK_PRAYING)
908     && !tmp->flag [FLAG_CURSED]
909     && !tmp->flag [FLAG_DAMNED])
910 root 1.49 continue;
911 root 1.46
912 root 1.74 for (int i = 0; i < NUM_STATS; i++)
913 root 1.76 stat_sum [i] = stat_sum [i] + tmp->stats.stat (i);
914 root 1.9
915 root 1.74 if (digest_types [tmp->type])
916 root 1.9 {
917 root 1.75 contr->digestion += tmp->stats.food;
918 root 1.19 contr->gen_hp += tmp->stats.hp;
919 root 1.87 if (tmp->type != BOW) // ugly exception for bows
920     contr->gen_sp += tmp->stats.sp;
921 root 1.19 contr->gen_grace += tmp->stats.grace;
922     contr->gen_sp_armour += tmp->gen_sp_armour;
923 root 1.3 }
924 root 1.9 } /* if this is a player */
925 root 1.46 else
926     {
927     if (tmp->type == WEAPON)
928     current_weapon = tmp;
929     }
930 root 1.3
931 root 1.9 /* Update slots used for items */
932     if (QUERY_FLAG (tmp, FLAG_APPLIED))
933 root 1.75 for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
934 root 1.47 slot[i].used += tmp->slot[i].info;
935 root 1.3
936 root 1.9 if (tmp->type == SYMPTOM)
937 root 1.77 speed_reduce_from_disease =
938     min (speed_reduce_from_disease, tmp->last_sp ? tmp->last_sp / 100.f : 1.f);
939 root 1.3
940 root 1.85 /* Pos. and neg. protections are counted separate (-> pro/vuln).
941 root 1.34 * (Negative protections are calculated exactly like positive.)
942 root 1.9 * Resistance from potions are treated special as well. If there's
943     * more than one potion-effect, the bigger prot.-value is taken.
944     */
945     if (tmp->type != POTION)
946     {
947 root 1.75 for (int i = 0; i < NROFATTACKS; i++)
948 root 1.9 {
949     /* Potential for cursed potions, in which case we just can use
950 pippijn 1.23 * a straight MAX, as potion_resist is initialised to zero.
951 root 1.9 */
952     if (tmp->type == POTION_EFFECT)
953     {
954     if (potion_resist[i])
955 root 1.74 potion_resist[i] = max (potion_resist[i], tmp->resist[i]);
956 root 1.9 else
957     potion_resist[i] = tmp->resist[i];
958 root 1.3 }
959 root 1.9 else if (tmp->resist[i] > 0)
960 root 1.34 prot[i] += ((100 - prot[i]) * tmp->resist[i]) / 100;
961 root 1.9 else if (tmp->resist[i] < 0)
962 root 1.34 vuln[i] += ((100 - vuln[i]) * -tmp->resist[i]) / 100;
963 root 1.9 }
964     }
965    
966     /* There may be other things that should not adjust the attacktype */
967 root 1.53 if (tmp->type != SYMPTOM)
968 root 1.46 {
969     attacktype |= tmp->attacktype;
970     path_attuned |= tmp->path_attuned;
971     path_repelled |= tmp->path_repelled;
972     path_denied |= tmp->path_denied;
973     move_type |= tmp->move_type;
974     stats.luck += tmp->stats.luck;
975     }
976 root 1.19
977 root 1.74 flag |= tmp->flag & copy_flags;
978 root 1.9
979 root 1.67 if (QUERY_FLAG (tmp, FLAG_UNDEAD) && !QUERY_FLAG (arch, FLAG_UNDEAD))
980 root 1.19 SET_FLAG (this, FLAG_UNDEAD);
981 root 1.9
982     if (QUERY_FLAG (tmp, FLAG_MAKE_INVIS))
983     {
984 root 1.19 SET_FLAG (this, FLAG_MAKE_INVIS);
985     invisible = 1;
986 root 1.9 }
987    
988     if (tmp->stats.exp && tmp->type != SKILL)
989     {
990     if (tmp->stats.exp > 0)
991     {
992 root 1.40 added_speed += tmp->stats.exp / 3.f;
993 root 1.44 bonus_speed += tmp->stats.exp / 3.f + 1.f;
994 root 1.3 }
995 root 1.9 else
996 root 1.40 added_speed += tmp->stats.exp;
997 root 1.3 }
998    
999 root 1.9 switch (tmp->type)
1000     {
1001 root 1.46 #if 0
1002 root 1.45 case WAND:
1003     case ROD:
1004     case HORN:
1005 root 1.46 if (type != PLAYER || current_weapon == tmp)
1006     chosen_skill = tmp;
1007 root 1.45 break;
1008 root 1.46 #endif
1009 root 1.45
1010 root 1.10 /* skills modifying the character -b.t. */
1011     /* for all skills and skill granting objects */
1012     case SKILL:
1013 root 1.63 {
1014     if (!QUERY_FLAG (tmp, FLAG_APPLIED) || skill_flags [tmp->subtype] & SF_APPLY)
1015     break;
1016    
1017     if (chosen_skill)
1018     {
1019     LOG (llevDebug, "fix_player, op %s has multiple skills applied (%s and %s)\n",
1020     &name, &chosen_skill->name, &tmp->name);
1021    
1022     tmp->flag [FLAG_APPLIED] = false;
1023     update_stats ();
1024     return;
1025     }
1026     else
1027     chosen_skill = tmp;
1028    
1029     if (tmp->stats.dam > 0)
1030     { /* skill is a 'weapon' */
1031     if (!QUERY_FLAG (this, FLAG_READY_WEAPON))
1032     weapon_speed = WEAPON_SPEED (tmp);
1033    
1034     if (weapon_speed < 0)
1035     weapon_speed = 0;
1036    
1037     weapon_weight = tmp->weight;
1038     stats.dam += 1 + chosen_skill->level * tmp->stats.dam / 9;
1039    
1040     if (tmp->magic)
1041     stats.dam += tmp->magic;
1042     }
1043 root 1.3
1044 root 1.63 if (tmp->stats.wc)
1045     wc -= tmp->stats.wc + tmp->magic;
1046 root 1.19
1047 root 1.63 if (tmp->slaying)
1048     slaying = tmp->slaying;
1049 root 1.19
1050 root 1.63 if (tmp->stats.ac)
1051     ac -= tmp->stats.ac + tmp->magic;
1052 root 1.3
1053 root 1.63 if (settings.spell_encumbrance == TRUE && type == PLAYER)
1054     contr->encumbrance += (int) 3 *tmp->weight / 1000;
1055     }
1056 root 1.19
1057 root 1.10 break;
1058 root 1.3
1059 root 1.10 case SHIELD:
1060 root 1.19 if (settings.spell_encumbrance == TRUE && type == PLAYER)
1061     contr->encumbrance += (int) tmp->weight / 2000;
1062 root 1.10 case RING:
1063     case AMULET:
1064     case GIRDLE:
1065     case HELMET:
1066     case BOOTS:
1067     case GLOVES:
1068     case CLOAK:
1069     if (tmp->stats.wc)
1070 root 1.37 wc -= tmp->stats.wc + tmp->magic;
1071 root 1.19
1072 root 1.10 if (tmp->stats.dam)
1073 root 1.37 stats.dam += tmp->stats.dam + tmp->magic;
1074 root 1.19
1075 root 1.10 if (tmp->stats.ac)
1076 root 1.37 ac -= tmp->stats.ac + tmp->magic;
1077 root 1.19
1078 root 1.10 break;
1079    
1080 root 1.45 case BOW:
1081 root 1.10 case WEAPON:
1082 root 1.46 if (type != PLAYER || current_weapon == tmp)
1083 root 1.45 {
1084     wc -= tmp->stats.wc + tmp->magic;
1085    
1086     if (tmp->stats.ac && tmp->stats.ac + tmp->magic > 0)
1087     ac -= tmp->stats.ac + tmp->magic;
1088    
1089     stats.dam += tmp->stats.dam + tmp->magic;
1090     weapon_weight = tmp->weight;
1091     weapon_speed = (WEAPON_SPEED (tmp) * 2 - tmp->magic) / 2;
1092    
1093     if (weapon_speed < 0)
1094     weapon_speed = 0;
1095 root 1.19
1096 root 1.45 slaying = tmp->slaying;
1097    
1098     /* If there is desire that two handed weapons should do
1099     * extra strength damage, this is where the code should
1100     * go.
1101     */
1102    
1103     if (type == PLAYER)
1104 root 1.46 if (settings.spell_encumbrance)
1105     contr->encumbrance += tmp->weight * 3 / 1000;
1106 root 1.45 }
1107 root 1.9
1108 root 1.10 break;
1109 root 1.9
1110 root 1.10 case ARMOUR: /* Only the best of these three are used: */
1111 root 1.19 if (settings.spell_encumbrance == TRUE && type == PLAYER)
1112 root 1.40 contr->encumbrance += tmp->weight / 1000;
1113 root 1.10
1114     case BRACERS:
1115     case FORCE:
1116     if (tmp->stats.wc)
1117     {
1118     if (best_wc < tmp->stats.wc + tmp->magic)
1119     {
1120     wc += best_wc;
1121     best_wc = tmp->stats.wc + tmp->magic;
1122     }
1123     else
1124     wc += tmp->stats.wc + tmp->magic;
1125     }
1126 root 1.19
1127 root 1.10 if (tmp->stats.ac)
1128     {
1129     if (best_ac < tmp->stats.ac + tmp->magic)
1130     {
1131     ac += best_ac; /* Remove last bonus */
1132     best_ac = tmp->stats.ac + tmp->magic;
1133     }
1134     else /* To nullify the below effect */
1135     ac += tmp->stats.ac + tmp->magic;
1136     }
1137 root 1.19
1138 root 1.10 if (tmp->stats.wc)
1139 root 1.95 wc -= tmp->stats.wc + tmp->magic;
1140 root 1.19
1141 root 1.10 if (tmp->stats.ac)
1142 root 1.95 ac -= tmp->stats.ac + tmp->magic;
1143 root 1.19
1144 root 1.74 if (ARMOUR_SPEED (tmp))
1145     max_speed = min (max_speed, ARMOUR_SPEED (tmp) / 10.f);
1146 root 1.19
1147 root 1.10 break;
1148 root 1.9 } /* switch tmp->type */
1149     } /* item is equipped */
1150     } /* for loop of items */
1151    
1152 root 1.94 glow_radius = min (glow_radius, MAX_LIGHT_RADIUS);
1153    
1154 root 1.9 /* We've gone through all the objects the player has equipped. For many things, we
1155     * have generated intermediate values which we now need to assign.
1156     */
1157    
1158     /* 'total resistance = total protections - total vulnerabilities'.
1159     * If there is an uncursed potion in effect, granting more protection
1160     * than that, we take: 'total resistance = resistance from potion'.
1161     * If there is a cursed (and no uncursed) potion in effect, we take
1162     * 'total resistance = vulnerability from cursed potion'.
1163     */
1164 root 1.75 for (int i = 0; i < NROFATTACKS; i++)
1165 root 1.9 {
1166 root 1.19 resist[i] = prot[i] - vuln[i];
1167    
1168     if (potion_resist[i] && ((potion_resist[i] > resist[i]) || (potion_resist[i] < 0)))
1169     resist[i] = potion_resist[i];
1170 elmex 1.1 }
1171    
1172 root 1.19 if (type == PLAYER)
1173 root 1.9 {
1174 root 1.75 // clamp various player stats
1175     for (int i = 0; i < NUM_STATS; ++i)
1176     stats.stat (i) = clamp (stat_sum [i], MIN_STAT, MAX_STAT);
1177    
1178     contr->digestion = clamp (contr->digestion, MIN_DIGESTION, MAX_DIGESTION);
1179    
1180     /* Figure out the players sp/mana/hp totals. */
1181 root 1.9 int pl_level;
1182    
1183 root 1.19 check_stat_bounds (&(stats));
1184     pl_level = level;
1185 root 1.9
1186     if (pl_level < 1)
1187     pl_level = 1; /* safety, we should always get 1 levels worth of hp! */
1188    
1189     /* You basically get half a con bonus/level. But we do take into account rounding,
1190     * so if your bonus is 7, you still get 7 worth of bonus every 2 levels.
1191     */
1192 root 1.75 stats.maxhp = 0;
1193     for (int i = 1; i <= min (10, pl_level); i++)
1194 root 1.9 {
1195 root 1.75 int j = contr->levhp[i] + con_bonus[stats.Con] / 2;
1196 root 1.19
1197     if (i % 2 && con_bonus[stats.Con] % 2)
1198 root 1.74 if (con_bonus[stats.Con] > 0)
1199     j++;
1200     else
1201     j--;
1202 root 1.19
1203     stats.maxhp += j > 1 ? j : 1; /* always get at least 1 hp/level */
1204 root 1.9 }
1205    
1206 root 1.75 stats.maxhp += 2 * max (0, level - 10);
1207 elmex 1.1
1208 root 1.19 if (stats.hp > stats.maxhp)
1209     stats.hp = stats.maxhp;
1210 elmex 1.1
1211 root 1.9 /* Sp gain is controlled by the level of the player's
1212     * relevant experience object (mana_obj, see above)
1213     */
1214     /* following happen when skills system is not used */
1215     if (!mana_obj)
1216 root 1.19 mana_obj = this;
1217    
1218 root 1.9 if (!grace_obj)
1219 root 1.19 grace_obj = this;
1220    
1221 root 1.9 /* set maxsp */
1222 root 1.19 if (!mana_obj || !mana_obj->level || type != PLAYER)
1223     mana_obj = this;
1224 root 1.9
1225 root 1.19 if (mana_obj == this && type == PLAYER)
1226     stats.maxsp = 1;
1227 root 1.9 else
1228     {
1229 root 1.74 float sp_tmp = 0.f;
1230 root 1.19
1231 root 1.75 for (int i = 1; i <= min (10, mana_obj->level); i++)
1232 root 1.9 {
1233     float stmp;
1234    
1235     /* Got some extra bonus at first level */
1236     if (i < 2)
1237 root 1.40 stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 6.f;
1238 root 1.9 else
1239 root 1.40 stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 12.f;
1240 root 1.19
1241 root 1.74 sp_tmp += max (1.f, stmp);
1242 root 1.3 }
1243 root 1.19
1244 root 1.74 stats.maxsp = int (sp_tmp) + 2 * max (0, mana_obj->level - 10);
1245 root 1.3 }
1246 root 1.54
1247 root 1.9 /* Characters can get their sp supercharged via rune of transferrance */
1248 root 1.74 stats.sp = min (stats.sp, stats.maxsp * 2);
1249 root 1.9
1250     /* set maxgrace, notice 3-4 lines below it depends on both Wis and Pow */
1251 root 1.19 if (!grace_obj || !grace_obj->level || type != PLAYER)
1252     grace_obj = this;
1253 root 1.9
1254 root 1.19 if (grace_obj == this && type == PLAYER)
1255     stats.maxgrace = 1;
1256 root 1.9 else
1257     {
1258     /* store grace in a float - this way, the divisions below don't create
1259     * big jumps when you go from level to level - with int's, it then
1260     * becomes big jumps when the sums of the bonuses jump to the next
1261     * step of 8 - with floats, even fractional ones are useful.
1262     */
1263 root 1.74 float sp_tmp = 0.f;
1264    
1265 root 1.75 for (int i = 1; i <= min (10, grace_obj->level); i++)
1266 root 1.9 {
1267 root 1.40 float grace_tmp = 0.f;
1268 root 1.9
1269     /* Got some extra bonus at first level */
1270     if (i < 2)
1271 root 1.40 grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 6.f;
1272 root 1.9 else
1273 root 1.40 grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 12.f;
1274 root 1.19
1275 root 1.74 sp_tmp += max (1.f, grace_tmp);
1276 root 1.3 }
1277 root 1.19
1278 root 1.74 /* two grace points per level after 10 */
1279     stats.maxgrace = int (sp_tmp) + 2 * max (0, grace_obj->level - 10);
1280 root 1.3 }
1281 root 1.54
1282 root 1.9 /* No limit on grace vs maxgrace */
1283 root 1.3
1284 root 1.19 if (contr->braced)
1285 root 1.9 {
1286     ac += 2;
1287     wc += 4;
1288 root 1.3 }
1289 root 1.9 else
1290 root 1.19 ac -= dex_bonus[stats.Dex];
1291 root 1.9
1292     /* In new exp/skills system, wc bonuses are related to
1293     * the players level in a relevant exp object (wc_obj)
1294     * not the general player level -b.t.
1295     * I changed this slightly so that wc bonuses are better
1296     * than before. This is to balance out the fact that
1297     * the player no longer gets a personal weapon w/ 1
1298     * improvement every level, now its fighterlevel/5. So
1299     * we give the player a bonus here in wc and dam
1300     * to make up for the change. Note that I left the
1301     * monster bonus the same as before. -b.t.
1302     */
1303 root 1.55 object *wc_obj = chosen_skill;
1304 root 1.9
1305 root 1.54 if (contr && wc_obj && wc_obj->level > 1)
1306 root 1.9 {
1307 root 1.37 wc -= wc_obj->level + thaco_bonus[stats.Str];
1308    
1309 root 1.75 for (int i = 1; i < wc_obj->level; i++)
1310 root 1.9 {
1311 root 1.54 /* additional wc every 6 levels */
1312 root 1.9 if (!(i % 6))
1313     wc--;
1314 root 1.37
1315 root 1.54 /* additional dam every 4 levels. */
1316 root 1.37 if (!(i % 4) && dam_bonus[stats.Str] >= 0)
1317     stats.dam += 1 + dam_bonus[stats.Str] / 5;
1318 root 1.9 }
1319     }
1320     else
1321 root 1.37 wc -= level + thaco_bonus[stats.Str];
1322 root 1.9
1323 root 1.19 stats.dam += dam_bonus[stats.Str];
1324 root 1.9
1325 root 1.19 if (stats.dam < 1)
1326     stats.dam = 1;
1327 root 1.9
1328 root 1.40 speed = 1.f + speed_bonus[stats.Dex];
1329 root 1.19
1330     if (settings.search_items && contr->search_str[0])
1331     speed -= 1;
1332    
1333     if (attacktype == 0)
1334 root 1.67 attacktype = arch->attacktype;
1335 root 1.9 } /* End if player */
1336    
1337     if (added_speed >= 0)
1338 root 1.40 speed += added_speed / 10.f;
1339 root 1.9 else /* Something wrong here...: */
1340 root 1.40 speed /= 1.f - added_speed;
1341 root 1.3
1342 root 1.9 /* Max is determined by armour */
1343 root 1.74 speed = min (speed, max_speed);
1344 elmex 1.1
1345 root 1.19 if (type == PLAYER)
1346 root 1.9 {
1347     /* f is a number the represents the number of kg above (positive num)
1348     * or below (negative number) that the player is carrying. If above
1349     * weight limit, then player suffers a speed reduction based on how
1350     * much above he is, and what is max carry is
1351     */
1352 root 1.78 float f = (carrying / 1000) - max_carry[stats.Str];
1353     if (f > 0.f)
1354 root 1.40 speed = speed / (1.f + f / max_carry[stats.Str]);
1355 elmex 1.1 }
1356    
1357 root 1.40 speed += bonus_speed / 10.f; /* Not affected by limits */
1358 root 1.78 speed *= speed_reduce_from_disease;
1359 root 1.77
1360 root 1.9 /* Put a lower limit on speed. Note with this speed, you move once every
1361 root 1.78 * 25 ticks or so. This amounts to once every 3 seconds of realtime.
1362 root 1.9 */
1363 root 1.78 if (speed < 0.04f && type == PLAYER)
1364     speed = 0.04f;
1365 root 1.9
1366 root 1.77 if (speed != old_speed)
1367     set_speed (speed);
1368    
1369 root 1.19 if (type == PLAYER)
1370 root 1.9 {
1371     /* (This formula was made by vidarl@ifi.uio.no)
1372     * Note that we never used these values again - basically
1373     * all of these could be subbed into one big equation, but
1374     * that would just be a real pain to read.
1375     */
1376 root 1.40 float M = (max_carry[stats.Str] - 121) / 121.f;
1377     float M2 = max_carry[stats.Str] / 100.f;
1378     float W = weapon_weight / 20000.f;
1379 root 1.56 float s = (20 - weapon_speed) / 10.f;
1380 root 1.40 float D = (stats.Dex - 14) / 14.f;
1381     float K = 1 + M / 3.f - W / (3 * M2) + speed / 5.f + D / 2.f;
1382    
1383 root 1.56 K *= (4 + level) * 1.2f / (6 + level);
1384 root 1.40
1385 root 1.56 if (K <= 0.01f)
1386 root 1.40 K = 0.01f;
1387    
1388 root 1.61 contr->weapon_sp = K * s * .5f; //TODO: balance the .5
1389 root 1.9 }
1390 root 1.19
1391 root 1.9 /* I want to limit the power of small monsters with big weapons: */
1392 root 1.67 if (type != PLAYER && arch && stats.dam > arch->stats.dam * 3)
1393     stats.dam = arch->stats.dam * 3;
1394 root 1.9
1395 root 1.56 stats.wc = clamp (wc, MIN_WC, MAX_WC);
1396     stats.ac = clamp (ac, MIN_AC, MAX_AC);
1397 root 1.9
1398     /* if for some reason the creature doesn't have any move type,
1399     * give them walking as a default.
1400     * The second case is a special case - to more closely mimic the
1401     * old behaviour - if your flying, your not walking - just
1402     * one or the other.
1403     */
1404 root 1.19 if (move_type == 0)
1405     move_type = MOVE_WALK;
1406     else if (move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH))
1407     move_type &= ~MOVE_WALK;
1408 elmex 1.1
1409 root 1.9 /* It is quite possible that a player's spell costing might have changed,
1410     * so we will check that now.
1411     */
1412 root 1.19 if (type == PLAYER)
1413     {
1414     esrv_update_stats (contr);
1415     esrv_update_spells (contr);
1416     }
1417 root 1.35
1418     // update the mapspace, if we are on a map
1419     if (!flag [FLAG_REMOVED] && map)
1420     map->at (x, y).flags_ = 0;
1421 elmex 1.1 }
1422    
1423     /*
1424     * Returns true if the given player is a legal class.
1425     * The function to add and remove class-bonuses to the stats doesn't
1426     * check if the stat becomes negative, thus this function
1427     * merely checks that all stats are 1 or more, and returns
1428     * false otherwise.
1429     */
1430 root 1.9 int
1431     allowed_class (const object *op)
1432     {
1433 root 1.40 return op->stats.Dex > 0
1434     && op->stats.Str > 0
1435     && op->stats.Con > 0
1436     && op->stats.Int > 0
1437     && op->stats.Wis > 0
1438     && op->stats.Pow > 0
1439     && op->stats.Cha > 0;
1440 elmex 1.1 }
1441    
1442     /*
1443     * set the new dragon name after gaining levels or
1444     * changing ability focus (later this can be extended to
1445     * eventually change the player's face and animation)
1446     */
1447 root 1.9 void
1448     set_dragon_name (object *pl, const object *abil, const object *skin)
1449     {
1450     int atnr = -1; /* attacknumber of highest level */
1451     int level = 0; /* highest level */
1452 elmex 1.1 int i;
1453    
1454     /* Perhaps do something more clever? */
1455 root 1.9 if (!abil || !skin)
1456     return;
1457    
1458 elmex 1.1 /* first, look for the highest level */
1459 root 1.9 for (i = 0; i < NROFATTACKS; i++)
1460     {
1461     if (atnr_is_dragon_enabled (i) && (atnr == -1 || abil->resist[i] > abil->resist[atnr]))
1462     {
1463     level = abil->resist[i];
1464     atnr = i;
1465     }
1466 elmex 1.1 }
1467 root 1.9
1468 elmex 1.1 /* now if there are equals at highest level, pick the one with focus,
1469     or else at random */
1470 root 1.9 if (atnr_is_dragon_enabled (abil->stats.exp) && abil->resist[abil->stats.exp] >= level)
1471 elmex 1.1 atnr = abil->stats.exp;
1472 root 1.9
1473 elmex 1.1 /* now set the new title */
1474 root 1.88 if (level < 25) sprintf (pl->contr->title, "%s hatchling", attacks[atnr]);
1475     else if (level < 50) sprintf (pl->contr->title, "%s wyrm" , attacks[atnr]);
1476     else if (level < 75) sprintf (pl->contr->title, "%s wyvern" , attacks[atnr]);
1477     else if (level < 100) sprintf (pl->contr->title, "%s dragon" , attacks[atnr]);
1478     else
1479 root 1.9 {
1480 root 1.88 /* special titles for extra high resistance! */
1481     if (skin->resist[atnr] > 80) sprintf (pl->contr->title, "legendary %s dragon", attacks[atnr]);
1482     else if (skin->resist[atnr] > 50) sprintf (pl->contr->title, "ancient %s dragon" , attacks[atnr]);
1483     else sprintf (pl->contr->title, "big %s dragon" , attacks[atnr]);
1484 elmex 1.1 }
1485 root 1.9
1486     strcpy (pl->contr->own_title, "");
1487 elmex 1.1 }
1488    
1489     /*
1490     * This function is called when a dragon-player gains
1491     * an overall level. Here, the dragon might gain new abilities
1492     * or change the ability-focus.
1493     */
1494 root 1.9 void
1495     dragon_level_gain (object *who)
1496     {
1497     object *abil = NULL; /* pointer to dragon ability force */
1498     object *skin = NULL; /* pointer to dragon skin force */
1499     object *tmp = NULL; /* tmp. object */
1500     char buf[MAX_BUF]; /* tmp. string buffer */
1501    
1502     /* now grab the 'dragon_ability'-forces from the player's inventory */
1503 root 1.29 for (tmp = who->inv; tmp; tmp = tmp->below)
1504     if (tmp->type == FORCE)
1505 root 1.70 if (tmp->arch->archname == shstr_dragon_ability_force)
1506 root 1.29 abil = tmp;
1507 root 1.70 else if (tmp->arch->archname == shstr_dragon_skin_force)
1508 root 1.29 skin = tmp;
1509    
1510 root 1.9 /* if the force is missing -> bail out */
1511     if (abil == NULL)
1512     return;
1513    
1514     /* The ability_force keeps track of maximum level ever achieved.
1515     * New abilties can only be gained by surpassing this max level
1516     */
1517     if (who->level > abil->level)
1518     {
1519     /* increase our focused ability */
1520     abil->resist[abil->stats.exp]++;
1521    
1522    
1523     if (abil->resist[abil->stats.exp] > 0 && abil->resist[abil->stats.exp] % 5 == 0)
1524     {
1525     /* time to hand out a new ability-gift */
1526     dragon_ability_gain (who, (int) abil->stats.exp, (int) ((1 + abil->resist[abil->stats.exp]) / 5.));
1527     }
1528    
1529     if (abil->last_eat > 0 && atnr_is_dragon_enabled (abil->last_eat))
1530     {
1531     /* apply new ability focus */
1532     sprintf (buf, "Your metabolism now focuses on %s!", change_resist_msg[abil->last_eat]);
1533     new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, who, buf);
1534    
1535     abil->stats.exp = abil->last_eat;
1536     abil->last_eat = 0;
1537     }
1538    
1539     abil->level = who->level;
1540     }
1541    
1542     /* last but not least, set the new title for the dragon */
1543     set_dragon_name (who, abil, skin);
1544 elmex 1.1 }
1545    
1546     /* Handy function - given the skill name skill_name, we find the skill
1547     * archetype/object, set appropriate values, and insert it into
1548     * the object (op) that is passed.
1549     * We return the skill - this makes it easier for calling functions that
1550     * want to do something with it immediately.
1551     */
1552 root 1.9 object *
1553     give_skill_by_name (object *op, const char *skill_name)
1554 elmex 1.1 {
1555 root 1.9 object *skill_obj;
1556 elmex 1.1
1557 root 1.9 skill_obj = get_archetype_by_skill_name (skill_name, SKILL);
1558     if (!skill_obj)
1559     {
1560 root 1.89 LOG (llevError, "give_skill_by_name: couldn't find skill %s\n", skill_name);
1561 root 1.9 return NULL;
1562     }
1563 root 1.55
1564 root 1.9 /* clear the flag - exp goes into this bucket, but player
1565     * still doesn't know it.
1566     */
1567     CLEAR_FLAG (skill_obj, FLAG_CAN_USE_SKILL);
1568     skill_obj->stats.exp = 0;
1569     skill_obj->level = 1;
1570 root 1.89 op->insert (skill_obj);
1571 root 1.26
1572 root 1.57 if (player *pl = op->contr)
1573 root 1.89 pl->link_skills ();
1574 root 1.26
1575 root 1.9 return skill_obj;
1576 elmex 1.1 }
1577    
1578     /* player_lvl_adj() - for the new exp system. we are concerned with
1579     * whether the player gets more hp, sp and new levels.
1580     * Note this this function should only be called for players. Monstes
1581     * don't really gain levels
1582     * who is the player, op is what we are checking to gain the level
1583     * (eg, skill)
1584     */
1585 root 1.9 void
1586     player_lvl_adj (object *who, object *op)
1587     {
1588     char buf[MAX_BUF];
1589 root 1.73 bool changed = false;
1590 root 1.9
1591     if (!op) /* when rolling stats */
1592     op = who;
1593    
1594 root 1.73 while (op->level < settings.max_level && op->stats.exp >= level_exp (op->level + 1, who->expmul))
1595 root 1.9 {
1596 root 1.73 changed = true;
1597    
1598 root 1.9 op->level++;
1599    
1600 root 1.54 if (op && op == who && op->stats.exp > 1 && is_dragon_pl (who))
1601 root 1.9 dragon_level_gain (who);
1602    
1603     /* Only roll these if it is the player (who) that gained the level */
1604     if (op == who && (who->level < 11) && who->type == PLAYER)
1605     {
1606     who->contr->levhp[who->level] = die_roll (2, 4, who, PREFER_HIGH) + 1;
1607     who->contr->levsp[who->level] = die_roll (2, 3, who, PREFER_HIGH);
1608     who->contr->levgrace[who->level] = die_roll (2, 2, who, PREFER_HIGH) - 1;
1609     }
1610    
1611     if (op->level > 1)
1612     {
1613     if (op->type != PLAYER)
1614 root 1.73 {
1615     who->contr->play_sound (sound_find ("skill_up"));
1616     sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);
1617     }
1618 root 1.9 else
1619 root 1.73 {
1620     who->contr->play_sound (sound_find ("level_up"));
1621     sprintf (buf, "You are now level %d.", op->level);
1622     }
1623 root 1.54
1624 root 1.9 if (who)
1625     new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
1626     }
1627 root 1.73 }
1628 root 1.54
1629 root 1.73 while (op->level > 1 && op->stats.exp < level_exp (op->level, who->expmul))
1630 root 1.9 {
1631 root 1.73 changed = true;
1632    
1633 root 1.9 op->level--;
1634 root 1.54
1635 root 1.9 if (op->type != PLAYER)
1636     {
1637     sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);
1638     new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
1639 root 1.3 }
1640 root 1.73 }
1641 root 1.54
1642 root 1.73 if (changed)
1643     {
1644     who->update_stats ();
1645     esrv_update_stats (who->contr);
1646     /* check if the spell data has changed */
1647     esrv_update_spells (who->contr);
1648 elmex 1.1 }
1649     }
1650    
1651     /*
1652     * Returns how much experience is needed for a player to become
1653     * the given level. level should really never exceed max_level
1654     */
1655    
1656 root 1.9 sint64
1657     level_exp (int level, double expmul)
1658     {
1659     if (level > settings.max_level)
1660     return (sint64) (expmul * levels[settings.max_level]);
1661 root 1.40
1662 root 1.9 return (sint64) (expmul * levels[level]);
1663 elmex 1.1 }
1664    
1665     /*
1666     * Ensure that the permanent experience requirements in an exp object are met.
1667     * This really just checks 'op to make sure the perm_exp value is within
1668     * proper range. Note that the checking of what is passed through
1669     * has been reduced. Since there is now a proper field for perm_exp,
1670     * this can now work on a much larger set of objects.
1671     */
1672 root 1.9 void
1673     calc_perm_exp (object *op)
1674 elmex 1.1 {
1675 root 1.9 int p_exp_min;
1676    
1677     /* Ensure that our permanent experience minimum is met.
1678     * permenent_exp_ratio is an integer percentage, we divide by 100
1679     * to get the fraction */
1680     p_exp_min = (int) (settings.permanent_exp_ratio * (float) (op->stats.exp) / 100);
1681    
1682     if (op->perm_exp < p_exp_min)
1683     op->perm_exp = p_exp_min;
1684    
1685     /* Cap permanent experience. */
1686     if (op->perm_exp < 0)
1687     op->perm_exp = 0;
1688     else if (op->perm_exp > (sint64) MAX_EXPERIENCE)
1689     op->perm_exp = MAX_EXPERIENCE;
1690 elmex 1.1 }
1691    
1692     /* Add experience to a player - exp should only be positive.
1693     * Updates permanent exp for the skill we are adding to.
1694     * skill_name is the skill to add exp to. Skill name can be
1695     * NULL, in which case exp increases the players general
1696     * total, but not any particular skill.
1697     * flag is what to do if the player doesn't have the skill:
1698     */
1699 root 1.9 static void
1700     add_player_exp (object *op, sint64 exp, const char *skill_name, int flag)
1701 elmex 1.1 {
1702 root 1.90 object *skill_obj;
1703 elmex 1.4 sint64 limit, exp_to_add;
1704     int i;
1705    
1706     /* prevents some forms of abuse. */
1707     if (op->contr->braced)
1708 root 1.46 exp /= 5;
1709 elmex 1.4
1710     /* Try to find the matching skill.
1711     * We do a shortcut/time saving mechanism first - see if it matches
1712 root 1.46 * chosen_skill. This means we don't need to search through
1713 elmex 1.4 * the players inventory.
1714     */
1715 root 1.90 skill_obj = 0;
1716    
1717 elmex 1.4 if (skill_name)
1718     {
1719 root 1.90 skill_obj = op->contr->find_skill (skill_name);
1720    
1721     /* Player doesn't have the skill. Check to see what to do, and give
1722     * it to the player if necessary
1723     */
1724     if (!skill_obj)
1725 elmex 1.4 {
1726 root 1.90 if (flag == SK_EXP_NONE)
1727     return;
1728    
1729     if (flag == SK_EXP_ADD_SKILL)
1730     skill_obj = give_skill_by_name (op, skill_name);
1731 root 1.3 }
1732 elmex 1.1 }
1733    
1734 elmex 1.4 if (flag != SK_EXP_SKILL_ONLY)
1735     {
1736     /* Basically, you can never gain more experience in one shot
1737     * than half what you need to gain for next level.
1738     */
1739     exp_to_add = exp;
1740     limit = (levels[op->level + 1] - levels[op->level]) / 2;
1741     if (exp_to_add > limit)
1742     exp_to_add = limit;
1743    
1744 root 1.9 ADD_EXP (op->stats.exp, (sint64) ((float) exp_to_add * (skill_obj ? skill_obj->expmul : 1)));
1745 elmex 1.4 if (settings.permanent_exp_ratio)
1746     {
1747 root 1.9 ADD_EXP (op->perm_exp, (sint64) ((float) exp_to_add * PERM_EXP_GAIN_RATIO * (skill_obj ? skill_obj->expmul : 1)));
1748 elmex 1.4 calc_perm_exp (op);
1749     }
1750    
1751     player_lvl_adj (op, NULL);
1752     }
1753    
1754     if (skill_obj)
1755     {
1756     exp_to_add = exp;
1757     limit = (levels[skill_obj->level + 1] - levels[skill_obj->level]) / 2;
1758     if (exp_to_add > limit)
1759     exp_to_add = limit;
1760    
1761     ADD_EXP (skill_obj->stats.exp, exp_to_add);
1762     if (settings.permanent_exp_ratio)
1763     {
1764 root 1.9 skill_obj->perm_exp += (sint64) ((float) exp_to_add * PERM_EXP_GAIN_RATIO);
1765 elmex 1.4 calc_perm_exp (skill_obj);
1766     }
1767 elmex 1.1
1768 elmex 1.4 player_lvl_adj (op, skill_obj);
1769 elmex 1.1 }
1770     }
1771    
1772     /* This function checks to make sure that object 'op' can
1773 root 1.93 * lose 'exp' experience. It returns the amount of exp
1774 elmex 1.1 * object 'op' can in fact lose - it basically makes
1775     * adjustments based on permanent exp and the like.
1776     * This function should always be used for losing experience -
1777     * the 'exp' value passed should be positive - this is the
1778     * amount that should get subtract from the player.
1779     */
1780 root 1.9 sint64
1781     check_exp_loss (const object *op, sint64 exp)
1782 elmex 1.1 {
1783 root 1.9 sint64 del_exp;
1784 elmex 1.1
1785 root 1.9 if (exp > op->stats.exp)
1786     exp = op->stats.exp;
1787 root 1.93
1788 root 1.9 if (settings.permanent_exp_ratio)
1789     {
1790     del_exp = (sint64) ((op->stats.exp - op->perm_exp) * PERM_EXP_MAX_LOSS_RATIO);
1791 root 1.93
1792 root 1.9 if (del_exp < 0)
1793     del_exp = 0;
1794 root 1.93
1795 root 1.9 if (exp > del_exp)
1796     exp = del_exp;
1797 elmex 1.1 }
1798 root 1.93
1799 root 1.9 return exp;
1800 elmex 1.1 }
1801    
1802 root 1.9 sint64
1803     check_exp_adjust (const object *op, sint64 exp)
1804 elmex 1.1 {
1805 root 1.9 if (exp < 0)
1806     return check_exp_loss (op, exp);
1807     else
1808 root 1.93 return min (exp, (sint64)MAX_EXPERIENCE - op->stats.exp);
1809 elmex 1.1 }
1810    
1811     /* Subtracts experience from player.
1812     * if skill is set and flag == SK_SUBTRACT_SKILL_EXP, then we
1813     * only subtract from the matching skill. Otherwise,
1814     * this subtracts a portion from all
1815     * skills the player has. Eg, if we figure the player is losing 10%
1816     * of his total exp, what happens is he loses 10% from all his skills.
1817     * Note that if permanent exp is used, player may not in fact lose
1818     * as much as listed. Eg, if player has gotten reduced to the point
1819     * where everything is at the minimum perm exp, he would lose nothing.
1820     * exp is the amount of exp to subtract - thus, it should be
1821     * a postive number.
1822     */
1823 root 1.9 static void
1824     subtract_player_exp (object *op, sint64 exp, const char *skill, int flag)
1825 elmex 1.1 {
1826 root 1.9 float fraction = (float) exp / (float) op->stats.exp;
1827     object *tmp;
1828     sint64 del_exp;
1829    
1830     for (tmp = op->inv; tmp; tmp = tmp->below)
1831     if (tmp->type == SKILL && tmp->stats.exp)
1832     {
1833 root 1.90 if (flag == SK_SUBTRACT_SKILL_EXP && skill && !strcmp (&tmp->skill, skill))
1834 root 1.9 {
1835     del_exp = check_exp_loss (tmp, exp);
1836     tmp->stats.exp -= del_exp;
1837     player_lvl_adj (op, tmp);
1838     }
1839     else if (flag != SK_SUBTRACT_SKILL_EXP)
1840     {
1841     /* only want to process other skills if we are not trying
1842     * to match a specific skill.
1843     */
1844     del_exp = check_exp_loss (tmp, (sint64) (tmp->stats.exp * fraction));
1845     tmp->stats.exp -= del_exp;
1846     player_lvl_adj (op, tmp);
1847     }
1848     }
1849 root 1.35
1850 root 1.9 if (flag != SK_SUBTRACT_SKILL_EXP)
1851     {
1852     del_exp = check_exp_loss (op, exp);
1853     op->stats.exp -= del_exp;
1854     player_lvl_adj (op, NULL);
1855 elmex 1.1 }
1856     }
1857    
1858     /* change_exp() - changes experience to a player/monster. This
1859     * does bounds checking to make sure we don't overflow the max exp.
1860     *
1861     * The exp passed is typically not modified much by this function -
1862     * it is assumed the caller has modified the exp as needed.
1863     * skill_name is the skill that should get the exp added.
1864     * flag is what to do if player doesn't have the skill.
1865     * these last two values are only used for players.
1866     */
1867 root 1.9 void
1868     change_exp (object *op, sint64 exp, const char *skill_name, int flag)
1869     {
1870 elmex 1.1 #ifdef EXP_DEBUG
1871 root 1.17 LOG (llevDebug, "change_exp() called for %s, exp = %" PRId64 "\n", query_name (op), exp);
1872 elmex 1.1 #endif
1873    
1874 root 1.9 /* safety */
1875     if (!op)
1876     {
1877     LOG (llevError, "change_exp() called for null object!\n");
1878     return;
1879     }
1880    
1881     /* if no change in exp, just return - most of the below code
1882     * won't do anything if the value is 0 anyways.
1883     */
1884     if (exp == 0)
1885     return;
1886    
1887     /* Monsters are easy - we just adjust their exp - we
1888     * don't adjust level, since in most cases it is unrelated to
1889     * the exp they have - the monsters exp represents what its
1890     * worth.
1891     */
1892     if (op->type != PLAYER)
1893     {
1894     /* Sanity check */
1895     if (!QUERY_FLAG (op, FLAG_ALIVE))
1896     return;
1897    
1898     /* reset exp to max allowed value. We subtract from
1899     * MAX_EXPERIENCE to prevent overflows. If the player somehow has
1900     * more than max exp, just return.
1901     */
1902     if (exp > 0 && (op->stats.exp > (sint64) (MAX_EXPERIENCE - exp)))
1903     {
1904     exp = MAX_EXPERIENCE - op->stats.exp;
1905     if (exp < 0)
1906     return;
1907 root 1.3 }
1908 elmex 1.1
1909 root 1.9 op->stats.exp += exp;
1910 elmex 1.1 }
1911 root 1.9 else
1912     { /* Players only */
1913     if (exp > 0)
1914     add_player_exp (op, exp, skill_name, flag);
1915     else
1916     /* note that when you lose exp, it doesn't go against
1917     * a particular skill, so we don't need to pass that
1918     * along.
1919     */
1920 root 1.32 subtract_player_exp (op, abs (exp), skill_name, flag);
1921 elmex 1.1 }
1922     }
1923    
1924     /* Applies a death penalty experience, the size of this is defined by the
1925     * settings death_penalty_percentage and death_penalty_levels, and by the
1926     * amount of permenent experience, whichever gives the lowest loss.
1927     */
1928 root 1.9 void
1929     apply_death_exp_penalty (object *op)
1930     {
1931     sint64 loss;
1932     sint64 percentage_loss; /* defined by the setting 'death_penalty_percent' */
1933     sint64 level_loss; /* defined by the setting 'death_penalty_levels */
1934    
1935 root 1.93 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1936 root 1.9 if (tmp->type == SKILL && tmp->stats.exp)
1937     {
1938     percentage_loss = tmp->stats.exp * settings.death_penalty_ratio / 100;
1939     level_loss = tmp->stats.exp - levels[MAX (0, tmp->level - settings.death_penalty_level)];
1940    
1941     /* With the revised exp system, you can get cases where
1942     * losing several levels would still require that you have more
1943     * exp than you currently have - this is true if the levels
1944     * tables is a lot harder.
1945     */
1946     if (level_loss < 0)
1947     level_loss = 0;
1948 root 1.3
1949 root 1.93 loss = check_exp_loss (tmp, min (level_loss, percentage_loss));
1950 root 1.3
1951 root 1.9 tmp->stats.exp -= loss;
1952     player_lvl_adj (op, tmp);
1953     }
1954 elmex 1.1
1955 root 1.9 percentage_loss = op->stats.exp * settings.death_penalty_ratio / 100;
1956 root 1.93 level_loss = op->stats.exp - levels[max (0, op->level - settings.death_penalty_level)];
1957 root 1.55
1958 root 1.9 if (level_loss < 0)
1959     level_loss = 0;
1960 root 1.93
1961     loss = check_exp_loss (op, min (level_loss, percentage_loss));
1962 elmex 1.1
1963 root 1.9 op->stats.exp -= loss;
1964     player_lvl_adj (op, NULL);
1965 elmex 1.1 }
1966    
1967     /* This function takes an object (monster/player, op), and
1968     * determines if it makes a basic save throw by looking at the
1969     * save_throw table. level is the effective level to make
1970     * the save at, and bonus is any plus/bonus (typically based on
1971     * resistance to particular attacktype.
1972     * Returns 1 if op makes his save, 0 if he failed
1973     */
1974 root 1.9 int
1975     did_make_save (const object *op, int level, int bonus)
1976 elmex 1.1 {
1977 root 1.9 if (level > MAX_SAVE_LEVEL)
1978     level = MAX_SAVE_LEVEL;
1979 elmex 1.1
1980 root 1.9 if ((random_roll (1, 20, op, PREFER_HIGH) + bonus) < savethrow[level])
1981     return 0;
1982 root 1.19
1983 root 1.9 return 1;
1984 elmex 1.1 }