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.51 by root, Sat May 12 18:23:51 2007 UTC vs.
Revision 1.129 by root, Mon Nov 12 03:14:32 2012 UTC

1/* 1/*
2 * CrossFire, A Multiplayer game 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6 * Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992 Frank Tore Johansen
7 * 7 *
8 * This program 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 2 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 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 * 17 *
18 * You should have received a copy of the Affero GNU General Public License
19 * and the GNU General Public License along with this program. If not, see
20 * <http://www.gnu.org/licenses/>.
21 *
22 * The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 23 */
24 24
25#include <global.h> 25#include <global.h>
26#include <funcpoint.h>
27 26
28/* Handy little macro that adds exp and keeps it within bounds. Since 27/* Handy little macro that adds exp and keeps it within bounds. Since
29 * we are now using 64 bit values, I'm not all concerned about overflow issues 28 * we are now using 64 bit values, I'm not all concerned about overflow issues
30 * with exptotal wrapping. exptotal is typically op->exp, or op->perm_exp 29 * with exptotal wrapping. exptotal is typically op->exp, or op->perm_exp
31 */ 30 */
… …
109 * These limits are probably overly generous, but being there were no values 108 * These limits are probably overly generous, but being there were no values
110 * before, you need to start someplace. 109 * before, you need to start someplace.
111 */ 110 */
112 111
113const uint32 weight_limit[MAX_STAT + 1] = { 112const uint32 weight_limit[MAX_STAT + 1] = {
114 200000, /* 0 */ 113 200000, /* 0 */
115 250000, 300000, 350000, 400000, 500000, /* 5 */ 114 250000, 300000, 350000, 400000, 500000, /* 5 */
116 600000, 700000, 800000, 900000, 1000000, /* 10 */ 115 600000, 700000, 800000, 900000, 1000000, /* 10 */
117 1100000, 1200000, 1300000, 1400000, 1500000, /* 15 */ 116 1100000, 1200000, 1300000, 1400000, 1500000, /* 15 */
118 1650000, 1800000, 1950000, 2100000, 2250000, /* 20 */ 117 1650000, 1800000, 1950000, 2100000, 2250000, /* 20 */
119 2400000, 2550000, 2700000, 2850000, 3000000, /* 25 */ 118 2400000, 2550000, 2700000, 2850000, 3000000, /* 25 */
120 3250000, 3500000, 3750000, 4000000, 4500000 /*30 */ 119 3250000, 3500000, 3750000, 4000000, 4500000 /* 30 */
121}; 120};
122 121
123const int learn_spell[MAX_STAT + 1] = { 122const int learn_spell[MAX_STAT + 1] = {
124 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 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,
125 100, 100, 100, 100, 100, 100 124 100, 100, 100, 100, 100, 100
… …
140/* 139/*
141 Since this is nowhere defined ... 140 Since this is nowhere defined ...
142 Both come in handy at least in function add_exp() 141 Both come in handy at least in function add_exp()
143*/ 142*/
144 143
145#define MAX_EXPERIENCE levels[settings.max_level] 144#define MAX_EXPERIENCE levels [settings.max_level]
146 145
147/* because exp_obj sum to make the total score, 146/* because exp_obj sum to make the total score,
148 * we cannot allow that sum to exceed the maximum 147 * we cannot allow that sum to exceed the maximum
149 * amount of experience a player can gain. Thus 148 * amount of experience a player can gain. Thus
150 * we define MAX_EXP_IN_OBJ. It is important to try 149 * we define MAX_EXP_IN_OBJ. It is important to try
… …
157 * line with progression of previous levels, so 156 * line with progression of previous levels, so
158 * if more levels are desired, this should be fixed. 157 * if more levels are desired, this should be fixed.
159 * -b.t. 158 * -b.t.
160 */ 159 */
161 160
162#define MAX_EXP_IN_OBJ levels[settings.max_level]/(MAX_EXP_CAT - 1) 161#define MAX_EXP_IN_OBJ MAX_EXP_IN_OBJ / (MAX_EXP_CAT - 1)
163
164extern sint64 *levels;
165 162
166#define MAX_SAVE_LEVEL 110 163#define MAX_SAVE_LEVEL 110
167 164
168/* This no longer needs to be changed anytime the number of 165/* This no longer needs to be changed anytime the number of
169 * levels is increased - rather, did_make_save will do the 166 * levels is increased - rather, did_make_save will do the
… …
242change_attr_value (living *stats, int attr, sint8 value) 239change_attr_value (living *stats, int attr, sint8 value)
243{ 240{
244 stats->stat (attr) += value; 241 stats->stat (attr) += value;
245} 242}
246 243
247sint8 &
248living::stat (int index)
249{
250 switch (index)
251 {
252 case STR: return Str;
253 case DEX: return Dex;
254 case CON: return Con;
255 case INT: return Int;
256 case WIS: return Wis;
257 case POW: return Pow;
258 case CHA: return Cha;
259 }
260
261 LOG (llevError | logBacktrace, "living.stat() called with out-of-range stat index");
262 static sint8 dummy;
263 return dummy;
264}
265
266sint8
267living::stat (int index) const
268{
269 switch (index)
270 {
271 case STR: return Str;
272 case DEX: return Dex;
273 case CON: return Con;
274 case INT: return Int;
275 case WIS: return Wis;
276 case POW: return Pow;
277 case CHA: return Cha;
278 }
279
280 LOG (llevError | logBacktrace, "living.stat() called with out-of-range stat index");
281 static sint8 dummy;
282 return dummy;
283}
284
285/* 244/*
286 * Ensures that all stats (str/dex/con/wis/cha/int) are within the 245 * Ensures that all stats (str/dex/con/wis/cha/int) are within the
287 * 1-30 stat limit. 246 * 1-30 stat limit.
288 */ 247 */
289void 248void
… …
301/* Rather than having a whole bunch of if (flag) new_draw.. else new_draw, 260/* Rather than having a whole bunch of if (flag) new_draw.. else new_draw,
302 * make this macro to clean those up. Not usuable outside change_abil 261 * make this macro to clean those up. Not usuable outside change_abil
303 * function since some of the values passed to new_draw_info are hardcoded. 262 * function since some of the values passed to new_draw_info are hardcoded.
304 */ 263 */
305#define DIFF_MSG(flag, msg1, msg2) \ 264#define DIFF_MSG(flag, msg1, msg2) \
306 new_draw_info(NDI_UNIQUE, 0, op, (flag>0)?msg1:msg2); 265 new_draw_info (NDI_UNIQUE, 0, op, (flag > 0) ? msg1 : msg2);
307 266
308/* return 1 if we sucessfully changed a stat, 0 if nothing was changed. */ 267/* return 1 if we sucessfully changed a stat, 0 if nothing was changed. */
309 268
310/* flag is set to 1 if we are applying the object, -1 if we are removing 269/* flag is set to 1 if we are applying the object, -1 if we are removing
311 * the object. 270 * the object.
… …
319 * that gives them that ability. 278 * that gives them that ability.
320 */ 279 */
321int 280int
322change_abil (object *op, object *tmp) 281change_abil (object *op, object *tmp)
323{ 282{
324 int flag = QUERY_FLAG (tmp, FLAG_APPLIED) ? 1 : -1, success = 0; 283 int flag = tmp->flag [FLAG_APPLIED] ? 1 : -1;
284 int success = 0;
325 char message[MAX_BUF]; 285 char message[MAX_BUF];
326 int potion_max = 0; 286 int potion_max = 0;
327 287
328 /* remember what object was like before it was changed. note that 288 // keep some stats for comparison purposes
329 * refop is a local copy of op only to be used for detecting changes 289 object::flags_t prev_flag = op->flag;
330 * found by update_stats. refop is not a real object 290 MoveType prev_move_type = op->move_type;
331 */ 291 sint16 prev_resist [NROFATTACKS]; // clumsy
332 object_copy refop = *op; 292 assert (sizeof (prev_resist) == sizeof (op->resist));
293 memcpy (prev_resist, op->resist, sizeof (prev_resist));
333 294
334 if (op->type == PLAYER) 295 if (op->type == PLAYER)
335 { 296 {
336 if (tmp->type == POTION) 297 if (tmp->type == POTION)
337 { 298 {
338 potion_max = 1; 299 potion_max = 1;
300
339 for (int j = 0; j < NUM_STATS; j++) 301 for (int j = 0; j < NUM_STATS; j++)
340 { 302 {
341 int ostat = op->contr->orig_stats.stat (j); 303 int ostat = op->contr->orig_stats.stat (j);
342 int i = tmp->stats.stat (j); 304 int i = tmp->stats.stat (j);
343 305
344 /* nstat is what the stat will be after use of the potion */ 306 /* nstat is what the stat will be after use of the potion */
345 int nstat = flag * i + ostat; 307 int nstat = flag * i + ostat;
346 308
347 /* Do some bounds checking. While I don't think any 309 /* Do some bounds checking. There is the potential for potions
348 * potions do so right now, there is the potential for potions
349 * that adjust that stat by more than one point, so we need 310 * that adjust that stat by more than one point, so we need
350 * to allow for that. 311 * to allow for that.
351 */ 312 */
352 if (nstat < 1 && i * flag < 0) 313 if (nstat < 1 && i * flag < 0)
353 nstat = 1; 314 nstat = 1;
354 else if (nstat > 20 + op->arch->clone.stats.stat (j)) 315 else if (nstat > 20 + op->arch->stats.stat (j))
355 nstat = 20 + op->arch->clone.stats.stat (j); 316 nstat = 20 + op->arch->stats.stat (j);
356 317
357 if (nstat != ostat) 318 if (nstat != ostat)
358 { 319 {
359 op->contr->orig_stats.stat (j) = nstat; 320 op->contr->orig_stats.stat (j) = nstat;
360 potion_max = 0; 321 potion_max = 0;
… …
405 { 366 {
406 success = 1; 367 success = 1;
407 DIFF_MSG (flag, "Your hands begin to glow red.", "Your hands stop glowing red."); 368 DIFF_MSG (flag, "Your hands begin to glow red.", "Your hands stop glowing red.");
408 } 369 }
409 370
410 if (QUERY_FLAG (op, FLAG_LIFESAVE) != QUERY_FLAG (&refop, FLAG_LIFESAVE)) 371 if (op->flag [FLAG_LIFESAVE] != prev_flag [FLAG_LIFESAVE])
411 { 372 {
412 success = 1; 373 success = 1;
413 DIFF_MSG (flag, "You feel very protected.", "You don't feel protected anymore."); 374 DIFF_MSG (flag, "You feel very protected.", "You don't feel protected anymore.");
414 } 375 }
415 376
416 if (QUERY_FLAG (op, FLAG_REFL_MISSILE) != QUERY_FLAG (&refop, FLAG_REFL_MISSILE)) 377 if (op->flag [FLAG_REFL_MISSILE] != prev_flag [FLAG_REFL_MISSILE])
417 { 378 {
418 success = 1; 379 success = 1;
419 DIFF_MSG (flag, "A magic force shimmers around you.", "The magic force fades away."); 380 DIFF_MSG (flag, "A magic force shimmers around you.", "The magic force fades away.");
420 } 381 }
421 382
422 if (QUERY_FLAG (op, FLAG_REFL_SPELL) != QUERY_FLAG (&refop, FLAG_REFL_SPELL)) 383 if (op->flag [FLAG_REFL_SPELL] != prev_flag [FLAG_REFL_SPELL])
423 { 384 {
424 success = 1; 385 success = 1;
425 DIFF_MSG (flag, "You feel more safe now, somehow.", "Suddenly you feel less safe, somehow."); 386 DIFF_MSG (flag, "You feel more safe now, somehow.", "Suddenly you feel less safe, somehow.");
426 } 387 }
427 388
… …
429 * user has multiple items giving the same type appled like we 390 * user has multiple items giving the same type appled like we
430 * used to - that is more work than what we gain, plus messages 391 * used to - that is more work than what we gain, plus messages
431 * can be misleading (a little higher could be miscontrued from 392 * can be misleading (a little higher could be miscontrued from
432 * from fly high) 393 * from fly high)
433 */ 394 */
434 if (tmp->move_type && op->move_type != refop.move_type) 395 if (tmp->move_type && op->move_type != prev_move_type)
435 { 396 {
436 success = 1; 397 success = 1;
437 398
438 /* MOVE_FLY_HIGH trumps MOVE_FLY_LOW - changing your move_fly_low 399 /* MOVE_FLY_HIGH trumps MOVE_FLY_LOW - changing your move_fly_low
439 * status doesn't make a difference if you are flying high 400 * status doesn't make a difference if you are flying high
440 */ 401 */
441 if (tmp->move_type & MOVE_FLY_LOW && !(op->move_type & MOVE_FLY_HIGH)) 402 if (tmp->move_type & MOVE_FLY_LOW && !(op->move_type & MOVE_FLY_HIGH))
442 { 403 {
443 DIFF_MSG (flag, "You start to float in the air!.", "You float down to the ground."); 404 DIFF_MSG (flag, "You start to float in the air!", "You float down to the ground.");
444 } 405 }
445 406
446 if (tmp->move_type & MOVE_FLY_HIGH) 407 if (tmp->move_type & MOVE_FLY_HIGH)
447 { 408 {
448 /* double conditional - second case covers if you have move_fly_low - 409 /* double conditional - second case covers if you have move_fly_low -
… …
452 (op->move_type & MOVE_FLY_LOW ? "You fly lower in the air" : "You float down to the ground.")); 413 (op->move_type & MOVE_FLY_LOW ? "You fly lower in the air" : "You float down to the ground."));
453 } 414 }
454 415
455 if (tmp->move_type & MOVE_SWIM) 416 if (tmp->move_type & MOVE_SWIM)
456 DIFF_MSG (flag, "You feel ready for a swim", "You no longer feel like swimming"); 417 DIFF_MSG (flag, "You feel ready for a swim", "You no longer feel like swimming");
457
458 /* Changing move status may mean you are affected by things you weren't before */
459 check_move_on (op, op);
460 } 418 }
461 419
462 /* becoming UNDEAD... a special treatment for this flag. Only those not 420 /* becoming UNDEAD... a special treatment for this flag. Only those not
463 * originally undead may change their status 421 * originally undead may change their status
464 */ 422 */
465 if (!QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD)) 423 if (!op->arch->flag [FLAG_UNDEAD])
466 if (QUERY_FLAG (op, FLAG_UNDEAD) != QUERY_FLAG (&refop, FLAG_UNDEAD)) 424 if (op->flag [FLAG_UNDEAD] != prev_flag [FLAG_UNDEAD])
467 { 425 {
468 success = 1; 426 success = 1;
469 if (flag > 0) 427 if (flag > 0)
470 { 428 {
471 op->race = "undead"; 429 op->race = "undead";
472 new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce drains away!"); 430 new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce drains away!");
473 } 431 }
474 else 432 else
475 { 433 {
476 op->race = op->arch->clone.race; 434 op->race = op->arch->race;
477 new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce returns!"); 435 new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce returns!");
478 } 436 }
479 } 437 }
480 438
481 if (QUERY_FLAG (op, FLAG_STEALTH) != QUERY_FLAG (&refop, FLAG_STEALTH)) 439 if (op->flag [FLAG_STEALTH] != prev_flag [FLAG_STEALTH])
482 { 440 {
483 success = 1; 441 success = 1;
484 DIFF_MSG (flag, "You walk more quietly.", "You walk more noisily."); 442 DIFF_MSG (flag, "You walk more quietly.", "You walk more noisily.");
485 } 443 }
486 444
487 if (QUERY_FLAG (op, FLAG_MAKE_INVIS) != QUERY_FLAG (&refop, FLAG_MAKE_INVIS)) 445 if (op->flag [FLAG_MAKE_INVIS] != prev_flag [FLAG_MAKE_INVIS])
488 { 446 {
489 success = 1; 447 success = 1;
490 DIFF_MSG (flag, "You become transparent.", "You can see yourself."); 448 DIFF_MSG (flag, "You become transparent.", "You can see yourself.");
491 } 449 }
492 450
493 /* blinded you can tell if more blinded since blinded player has minimal 451 /* blinded you can tell if more blinded since blinded player has minimal
494 * vision 452 * vision
495 */ 453 */
496 if (QUERY_FLAG (tmp, FLAG_BLIND)) 454 if (tmp->flag [FLAG_BLIND])
497 { 455 {
498 success = 1; 456 success = 1;
499 if (flag > 0) 457 if (flag > 0)
500 { 458 {
501 if (QUERY_FLAG (op, FLAG_WIZ)) 459 if (op->flag [FLAG_WIZ])
502 new_draw_info (NDI_UNIQUE, 0, op, "Your mortal self is blinded."); 460 new_draw_info (NDI_UNIQUE, 0, op, "Your mortal self is blinded.");
503 else 461 else
504 { 462 {
505 new_draw_info (NDI_UNIQUE, 0, op, "You are blinded."); 463 new_draw_info (NDI_UNIQUE, 0, op, "You are blinded.");
506 SET_FLAG (op, FLAG_BLIND); 464 op->set_flag (FLAG_BLIND);
507 if (op->type == PLAYER) 465 if (op->type == PLAYER)
508 op->contr->do_los = 1; 466 op->contr->do_los = 1;
509 } 467 }
510 } 468 }
511 else 469 else
512 { 470 {
513 if (QUERY_FLAG (op, FLAG_WIZ)) 471 if (op->flag [FLAG_WIZ])
514 new_draw_info (NDI_UNIQUE, 0, op, "Your mortal self can now see again."); 472 new_draw_info (NDI_UNIQUE, 0, op, "Your mortal self can now see again.");
515 else 473 else
516 { 474 {
517 new_draw_info (NDI_UNIQUE, 0, op, "Your vision returns."); 475 new_draw_info (NDI_UNIQUE, 0, op, "Your vision returns.");
518 CLEAR_FLAG (op, FLAG_BLIND); 476 op->clr_flag (FLAG_BLIND);
519 if (op->type == PLAYER) 477 if (op->type == PLAYER)
520 op->contr->do_los = 1; 478 op->contr->do_los = 1;
521 } 479 }
522 } 480 }
523 } 481 }
524 482
525 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK) != QUERY_FLAG (&refop, FLAG_SEE_IN_DARK)) 483 if (op->flag [FLAG_SEE_IN_DARK] != prev_flag [FLAG_SEE_IN_DARK])
526 { 484 {
527 success = 1; 485 success = 1;
528 if (op->type == PLAYER) 486 if (op->type == PLAYER)
529 op->contr->do_los = 1; 487 op->contr->do_los = 1;
530 DIFF_MSG (flag, "Your vision is better in the dark.", "You see less well in the dark."); 488 DIFF_MSG (flag, "Your vision is better in the dark.", "You see less well in the dark.");
531 } 489 }
532 490
533 if (QUERY_FLAG (op, FLAG_XRAYS) != QUERY_FLAG (&refop, FLAG_XRAYS)) 491 if (op->flag [FLAG_XRAYS] != prev_flag [FLAG_XRAYS])
534 { 492 {
535 success = 1; 493 success = 1;
536 if (flag > 0) 494 if (flag > 0)
537 { 495 {
538 if (QUERY_FLAG (op, FLAG_WIZ)) 496 if (op->flag [FLAG_WIZ])
539 new_draw_info (NDI_UNIQUE, 0, op, "Your vision becomes a little clearer."); 497 new_draw_info (NDI_UNIQUE, 0, op, "Your vision becomes a little clearer.");
540 else 498 else
541 { 499 {
542 new_draw_info (NDI_UNIQUE, 0, op, "Everything becomes transparent."); 500 new_draw_info (NDI_UNIQUE, 0, op, "Everything becomes transparent.");
543 if (op->type == PLAYER) 501 if (op->type == PLAYER)
544 op->contr->do_los = 1; 502 op->contr->do_los = 1;
545 } 503 }
546 } 504 }
547 else 505 else
548 { 506 {
549 if (QUERY_FLAG (op, FLAG_WIZ)) 507 if (op->flag [FLAG_WIZ])
550 new_draw_info (NDI_UNIQUE, 0, op, "Your vision becomes a bit out of focus."); 508 new_draw_info (NDI_UNIQUE, 0, op, "Your vision becomes a bit out of focus.");
551 else 509 else
552 { 510 {
553 new_draw_info (NDI_UNIQUE, 0, op, "Everything suddenly looks very solid."); 511 new_draw_info (NDI_UNIQUE, 0, op, "Everything suddenly looks very solid.");
554 if (op->type == PLAYER) 512 if (op->type == PLAYER)
… …
561 { 519 {
562 success = 1; 520 success = 1;
563 DIFF_MSG (flag * tmp->stats.luck, "You feel more lucky.", "You feel less lucky."); 521 DIFF_MSG (flag * tmp->stats.luck, "You feel more lucky.", "You feel less lucky.");
564 } 522 }
565 523
524 if (digest_types [tmp->type])
525 {
566 if (tmp->stats.hp && op->type == PLAYER) 526 if (tmp->stats.hp && op->type == PLAYER)
567 { 527 {
568 success = 1; 528 success = 1;
569 DIFF_MSG (flag * tmp->stats.hp, "You feel much more healthy!", "You feel much less healthy!"); 529 DIFF_MSG (flag * tmp->stats.hp, "You feel much more healthy!", "You feel much less healthy!");
570 } 530 }
571 531
572 if (tmp->stats.sp && op->type == PLAYER && tmp->type != SKILL) 532 if (tmp->stats.sp && op->type == PLAYER
573 { 533 && tmp->type != SKILL && tmp->type != BOW)
534 {
574 success = 1; 535 success = 1;
575 DIFF_MSG (flag * tmp->stats.sp, "You feel one with the powers of magic!", "You suddenly feel very mundane."); 536 DIFF_MSG (flag * tmp->stats.sp, "You feel one with the powers of magic!", "You suddenly feel very mundane.");
576 } 537 }
577 538
578 /* for the future when artifacts set this -b.t. */ 539 /* for the future when artifacts set this -b.t. */
579 if (tmp->stats.grace && op->type == PLAYER) 540 if (tmp->stats.grace && op->type == PLAYER)
580 { 541 {
581 success = 1; 542 success = 1;
582 DIFF_MSG (flag * tmp->stats.grace, "You feel closer to your god!", "You suddenly feel less holy."); 543 DIFF_MSG (flag * tmp->stats.grace, "You feel closer to your god!", "You suddenly feel less holy.");
583 } 544 }
584 545
585 if (tmp->stats.food && op->type == PLAYER) 546 if (tmp->stats.food && op->type == PLAYER)
586 { 547 {
587 success = 1; 548 success = 1;
588 DIFF_MSG (flag * tmp->stats.food, "You feel your digestion slowing down.", "You feel your digestion speeding up."); 549 DIFF_MSG (flag * tmp->stats.food, "You feel your digestion slowing down.", "You feel your digestion speeding up.");
550 }
589 } 551 }
590 552
591 /* Messages for changed resistance */ 553 /* Messages for changed resistance */
592 for (int i = 0; i < NROFATTACKS; i++) 554 for (int i = 0; i < NROFATTACKS; i++)
593 { 555 {
594 if (i == ATNR_PHYSICAL) 556 if (i == ATNR_PHYSICAL)
595 continue; /* Don't display about armour */ 557 continue; /* Don't display about armour */
596 558
597 if (op->resist[i] != refop.resist[i]) 559 if (op->resist [i] != prev_resist [i])
598 { 560 {
599 success = 1; 561 success = 1;
562
600 if (op->resist[i] > refop.resist[i]) 563 if (op->resist [i] > prev_resist [i])
601 sprintf (message, "Your resistance to %s rises to %d%%.", change_resist_msg[i], op->resist[i]); 564 sprintf (message, "Your resistance to %s rises to %d%%.", change_resist_msg [i], op->resist [i]);
602 else 565 else
603 sprintf (message, "Your resistance to %s drops to %d%%.", change_resist_msg[i], op->resist[i]); 566 sprintf (message, "Your resistance to %s drops to %d%%.", change_resist_msg [i], op->resist [i]);
604 567
605 new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, op, message); 568 new_draw_info (NDI_UNIQUE | NDI_BLUE, 0, op, message);
606 } 569 }
607 } 570 }
608 571
609 if (!potion_max) 572 if (!potion_max)
610 {
611 for (int j = 0; j < NUM_STATS; j++) 573 for (int j = 0; j < NUM_STATS; j++)
612 {
613 if (int i = tmp->stats.stat (j)) 574 if (int i = tmp->stats.stat (j))
614 { 575 {
615 success = 1; 576 success = 1;
616 DIFF_MSG (i * flag, gain_msg[j], lose_msg[j]); 577 DIFF_MSG (i * flag, gain_msg[j], lose_msg[j]);
617 } 578 }
618 }
619 }
620 579
621 return success; 580 return success;
622} 581}
623 582
624/* 583/*
… …
635object::drain_specific_stat (int deplete_stats) 594object::drain_specific_stat (int deplete_stats)
636{ 595{
637 object *tmp; 596 object *tmp;
638 archetype *at; 597 archetype *at;
639 598
640 at = archetype::find (ARCH_DEPLETION); 599 at = archetype::find (shstr_depletion);
641 if (!at) 600 if (!at)
642 { 601 {
643 LOG (llevError, "Couldn't find archetype depletion.\n"); 602 LOG (llevError, "Couldn't find archetype depletion.\n");
644 return; 603 return;
645 } 604 }
… …
647 { 606 {
648 tmp = present_arch_in_ob (at, this); 607 tmp = present_arch_in_ob (at, this);
649 608
650 if (!tmp) 609 if (!tmp)
651 { 610 {
652 tmp = arch_to_object (at); 611 tmp = at->instance ();
653 tmp = insert_ob_in_ob (tmp, this); 612 tmp = insert_ob_in_ob (tmp, this);
654 SET_FLAG (tmp, FLAG_APPLIED); 613 tmp->set_flag (FLAG_APPLIED);
655 } 614 }
656 } 615 }
657 616
658 new_draw_info (NDI_UNIQUE, 0, this, drain_msg[deplete_stats]); 617 new_draw_info (NDI_UNIQUE, 0, this, drain_msg[deplete_stats]);
659 change_attr_value (&tmp->stats, deplete_stats, -1); 618 change_attr_value (&tmp->stats, deplete_stats, -1);
… …
665 * via an applied bad_luck object. 624 * via an applied bad_luck object.
666 */ 625 */
667void 626void
668object::change_luck (int value) 627object::change_luck (int value)
669{ 628{
670 archetype *at = archetype::find ("luck"); 629 archetype *at = archetype::find (shstr_luck);
671 if (!at) 630 if (!at)
672 LOG (llevError, "Couldn't find archetype luck.\n"); 631 LOG (llevError, "Couldn't find archetype luck.\n");
673 else 632 else
674 { 633 {
675 object *tmp = present_arch_in_ob (at, this); 634 object *tmp = present_arch_in_ob (at, this);
… …
677 if (!tmp) 636 if (!tmp)
678 { 637 {
679 if (!value) 638 if (!value)
680 return; 639 return;
681 640
682 tmp = arch_to_object (at); 641 tmp = at->instance ();
683 tmp = insert_ob_in_ob (tmp, this); 642 tmp = insert_ob_in_ob (tmp, this);
684 SET_FLAG (tmp, FLAG_APPLIED); 643 tmp->set_flag (FLAG_APPLIED);
685 } 644 }
686 645
687 if (value) 646 if (value)
688 { 647 {
689 /* Limit the luck value of the bad luck object to +/-100. This 648 /* Limit the luck value of the bad luck object to +/-100. This
… …
723void 682void
724object::remove_statbonus () 683object::remove_statbonus ()
725{ 684{
726 for (int i = 0; i < NUM_STATS; ++i) 685 for (int i = 0; i < NUM_STATS; ++i)
727 { 686 {
728 sint8 v = arch->clone.stats.stat (i); 687 sint8 v = arch->stats.stat (i);
729 stats.stat (i) -= v; 688 stats.stat (i) -= v;
730 contr->orig_stats.stat (i) -= v; 689 contr->orig_stats.stat (i) -= v;
731 } 690 }
732} 691}
733 692
… …
737void 696void
738object::add_statbonus () 697object::add_statbonus ()
739{ 698{
740 for (int i = 0; i < NUM_STATS; ++i) 699 for (int i = 0; i < NUM_STATS; ++i)
741 { 700 {
742 sint8 v = arch->clone.stats.stat (i); 701 sint8 v = arch->stats.stat (i);
743 stats.stat (i) += v; 702 stats.stat (i) += v;
744 contr->orig_stats.stat (i) += v; 703 contr->orig_stats.stat (i) += v;
745 } 704 }
746} 705}
706
707static struct copy_flags : object::flags_t
708{
709 copy_flags ()
710 {
711 set (FLAG_LIFESAVE);
712 set (FLAG_REFL_SPELL);
713 set (FLAG_REFL_MISSILE);
714 set (FLAG_STEALTH);
715 set (FLAG_XRAYS);
716 set (FLAG_BLIND);
717 set (FLAG_SEE_IN_DARK);
718 }
719} copy_flags;
747 720
748/* 721/*
749 * Updates all abilities given by applied objects in the inventory 722 * Updates all abilities given by applied objects in the inventory
750 * of the given object. Note: This function works for both monsters 723 * of the given object. Note: This function works for both monsters
751 * and players; the "player" in the name is purely an archaic inheritance. 724 * and players; the "player" in the name is purely an archaic inheritance.
… …
756 * spell system split, grace points now added to system --peterm 729 * spell system split, grace points now added to system --peterm
757 */ 730 */
758void 731void
759object::update_stats () 732object::update_stats ()
760{ 733{
761 int i, j;
762 float f, max = 9, added_speed = 0, bonus_speed = 0, sp_tmp, speed_reduce_from_disease = 1; 734 float max_speed = 9, added_speed = 0, bonus_speed = 0, speed_reduce_from_disease = 1;
763 int weapon_weight = 0, weapon_speed = 0; 735 int weapon_weight = 0, weapon_speed = 0;
764 int best_wc = 0, best_ac = 0, wc = 0, ac = 0; 736 int best_wc = 0, best_ac = 0, wc = 0, ac = 0;
765 int prot[NROFATTACKS], vuln[NROFATTACKS], potion_resist[NROFATTACKS]; 737 int prot[NROFATTACKS], vuln[NROFATTACKS], potion_resist[NROFATTACKS];
766 object *grace_obj = NULL, *mana_obj = NULL, *wc_obj = NULL, *tmp; 738 object *grace_obj = NULL, *mana_obj = NULL, *tmp;
767 float old_speed = speed; 739 float old_speed = speed;
740 int stat_sum [NUM_STATS];
741
742 MoveType move_type; // we use change_move_type to change it, so use a local copy
768 743
769 /* First task is to clear all the values back to their original values */ 744 /* First task is to clear all the values back to their original values */
770 if (type == PLAYER) 745 if (type == PLAYER)
771 { 746 {
747 contr->delayed_update = false;
748
772 for (i = 0; i < NUM_STATS; i++) 749 for (int i = 0; i < NUM_STATS; i++)
773 stats.stat (i) = contr->orig_stats.stat (i); 750 stat_sum [i] = contr->orig_stats.stat (i);
774 751
775 if (settings.spell_encumbrance == TRUE) 752 if (settings.spell_encumbrance == TRUE)
776 contr->encumbrance = 0; 753 contr->encumbrance = 0;
777 754
778 attacktype = 0; 755 attacktype = 0;
… …
788 for (int i = NUM_BODY_LOCATIONS; i--; ) 765 for (int i = NUM_BODY_LOCATIONS; i--; )
789 slot[i].used = slot[i].info; 766 slot[i].used = slot[i].info;
790 767
791 slaying = 0; 768 slaying = 0;
792 769
793 if (!QUERY_FLAG (this, FLAG_WIZ)) 770 if (!this->flag [FLAG_WIZ])
794 {
795 CLEAR_FLAG (this, FLAG_XRAYS);
796 CLEAR_FLAG (this, FLAG_MAKE_INVIS);
797 } 771 {
772 this->clr_flag (FLAG_XRAYS);
773 this->clr_flag (FLAG_MAKE_INVIS);
774 }
798 775
799 CLEAR_FLAG (this, FLAG_LIFESAVE); 776 this->clr_flag (FLAG_LIFESAVE);
800 CLEAR_FLAG (this, FLAG_STEALTH); 777 this->clr_flag (FLAG_STEALTH);
801 CLEAR_FLAG (this, FLAG_BLIND); 778 this->clr_flag (FLAG_BLIND);
802 779
803 if (!QUERY_FLAG (&arch->clone, FLAG_REFL_SPELL )) CLEAR_FLAG (this, FLAG_REFL_SPELL); 780 if (!arch->flag [FLAG_REFL_SPELL ]) this->clr_flag (FLAG_REFL_SPELL);
804 if (!QUERY_FLAG (&arch->clone, FLAG_REFL_MISSILE)) CLEAR_FLAG (this, FLAG_REFL_MISSILE); 781 if (!arch->flag [FLAG_REFL_MISSILE]) this->clr_flag (FLAG_REFL_MISSILE);
805 if (!QUERY_FLAG (&arch->clone, FLAG_UNDEAD )) CLEAR_FLAG (this, FLAG_UNDEAD); 782 if (!arch->flag [FLAG_UNDEAD ]) this->clr_flag (FLAG_UNDEAD);
806 if (!QUERY_FLAG (&arch->clone, FLAG_SEE_IN_DARK )) CLEAR_FLAG (this, FLAG_SEE_IN_DARK); 783 if (!arch->flag [FLAG_SEE_IN_DARK ]) this->clr_flag (FLAG_SEE_IN_DARK);
807 784
808 path_attuned = arch->clone.path_attuned; 785 path_attuned = arch->path_attuned;
809 path_repelled = arch->clone.path_repelled; 786 path_repelled = arch->path_repelled;
810 path_denied = arch->clone.path_denied; 787 path_denied = arch->path_denied;
811 glow_radius = arch->clone.glow_radius; 788 glow_radius = arch->glow_radius;
812 move_type = arch->clone.move_type; 789 move_type = arch->move_type;
813
814 chosen_skill = 0;
815 790
816 /* initializing resistances from the values in player/monster's 791 /* initializing resistances from the values in player/monster's
817 * archetype clone 792 * archetype clone
818 */ 793 */
819 memcpy (&resist, &arch->clone.resist, sizeof (resist)); 794 memcpy (&resist, &arch->resist, sizeof (resist));
820 795
821 for (i = 0; i < NROFATTACKS; i++) 796 for (int i = 0; i < NROFATTACKS; i++)
822 { 797 {
823 if (resist[i] > 0) 798 if (resist[i] > 0)
824 prot[i] = resist[i], vuln[i] = 0; 799 prot[i] = resist[i], vuln[i] = 0;
825 else 800 else
826 vuln[i] = -(resist[i]), prot[i] = 0; 801 vuln[i] = -resist[i], prot[i] = 0;
827 802
828 potion_resist[i] = 0; 803 potion_resist[i] = -1000;
829 } 804 }
830 805
831 wc = arch->clone.stats.wc; 806 wc = arch->stats.wc;
832 stats.dam = arch->clone.stats.dam; 807 stats.dam = arch->stats.dam;
833 808
834 /* for players which cannot use armour, they gain AC -1 per 3 levels, 809 /* for players which cannot use armour, they gain AC -1 per 3 levels,
835 * plus a small amount of physical resist, those poor suckers. ;) 810 * plus a small amount of physical resist, those poor suckers. ;)
836 * the fact that maxlevel is factored in could be considered sort of bogus - 811 * the fact that maxlevel is factored in could be considered sort of bogus -
837 * we should probably give them some bonus and cap it off - otherwise, 812 * we should probably give them some bonus and cap it off - otherwise,
838 * basically, if a server updates its max level, these playes may find 813 * basically, if a server updates its max level, these playes may find
839 * that their protection from physical goes down 814 * that their protection from physical goes down
840 */ 815 */
841 if (!QUERY_FLAG (this, FLAG_USE_ARMOUR) && type == PLAYER) 816 if (!this->flag [FLAG_USE_ARMOUR] && type == PLAYER)
842 { 817 {
843 ac = MAX (-10, arch->clone.stats.ac - level / 3); 818 ac = max (-10, arch->stats.ac - level / 3);
844 prot[ATNR_PHYSICAL] += ((100 - prot[AT_PHYSICAL]) * (80 * level / settings.max_level)) / 100; 819 prot[ATNR_PHYSICAL] += ((100 - prot[AT_PHYSICAL]) * (80 * level / settings.max_level)) / 100;
845 } 820 }
846 else 821 else
847 ac = arch->clone.stats.ac; 822 ac = arch->stats.ac;
848 823
849 stats.luck = arch->clone.stats.luck; 824 stats.luck = arch->stats.luck;
850 speed = arch->clone.speed; 825 speed = arch->speed;
826
827 chosen_skill = 0;
851 828
852 /* OK - we've reset most all the objects attributes to sane values. 829 /* OK - we've reset most all the objects attributes to sane values.
853 * now go through and make adjustments for what the player has equipped. 830 * now go through and make adjustments for what the player has equipped.
854 */ 831 */
855 for (tmp = inv; tmp; tmp = tmp->below) 832 for (tmp = inv; tmp; tmp = tmp->below)
856 { 833 {
857 /* See note in map.c:update_position about making this additive
858 * since light sources are never applied, need to put check here.
859 */
860 if (tmp->glow_radius > glow_radius)
861 glow_radius = tmp->glow_radius;
862
863 /* This happens because apply_potion calls change_abil with the potion 834 /* This happens because apply_potion calls change_abil with the potion
864 * applied so we can tell the player what changed. But change_abil 835 * applied so we can tell the player what changed. But change_abil
865 * then calls this function. 836 * then calls this function.
866 */ 837 */
867 if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == POTION) 838 if (tmp->flag [FLAG_APPLIED] && tmp->type == POTION)
868 continue; 839 continue;
840
841 glow_radius += tmp->glow_radius;
869 842
870 /* For some things, we don't care what is equipped */ 843 /* For some things, we don't care what is equipped */
871 if (tmp->type == SKILL) 844 if (tmp->type == SKILL)
872 { 845 {
873 /* Want to take the highest skill here. */ 846 /* Want to take the highest skill here. */
… …
886 else if (tmp->level > grace_obj->level) 859 else if (tmp->level > grace_obj->level)
887 grace_obj = tmp; 860 grace_obj = tmp;
888 } 861 }
889 } 862 }
890 863
891 /* Container objects are not meant to adjust a players, but other applied 864 /* Container objects are not meant to adjust players, but other applied
892 * objects need to make adjustments. 865 * objects need to make adjustments.
893 * This block should handle all player specific changes 866 * This block should handle all player specific changes
894 * The check for Praying is a bit of a hack - god given bonuses are put 867 * The check for Praying is a bit of a hack - god given bonuses are put
895 * in the praying skill, and the player should always get those. 868 * in the praying skill, and the player should always get those.
896 * It also means we need to put in additional checks for applied below, 869 * It also means we need to put in additional checks for applied below,
897 * because the skill shouldn't count against body positions being used 870 * because the skill shouldn't count against body positions being used
898 * up, etc. 871 * up, etc.
899 */ 872 */
900 if ((tmp->flag [FLAG_APPLIED] 873 if ((tmp->flag [FLAG_APPLIED]
901 && tmp->type != CONTAINER 874 && tmp->type != CONTAINER
902 && tmp->type != CLOSE_CON) 875 && tmp->type != CLOSE_CON
903 || (tmp->type == SKILL 876 && tmp->type != SPELL)
904 && tmp->subtype == SK_PRAYING)) 877 || (tmp->type == SKILL && tmp->subtype == SK_PRAYING))
905 { 878 {
906 if (type == PLAYER) 879 if (type == PLAYER)
907 { 880 {
908 if (tmp == contr->combat_ob || tmp == contr->ranged_ob) 881 contr->item_power += tmp->item_power;
909 if (tmp != current_weapon && (tmp->type != SKILL || tmp->subtype != SK_PRAYING))
910 continue;
911 882
912 for (i = 0; i < NUM_STATS; i++) 883 for (int i = 0; i < NUM_STATS; i++)
913 change_attr_value (&stats, i, tmp->stats.stat (i)); 884 stat_sum [i] += tmp->stats.stat (i);
914 885
915 /* these are the items that currently can change digestion, regeneration, 886 if (digest_types [tmp->type])
916 * spell point recovery and mana point recovery. Seems sort of an arbitary
917 * list, but other items store other info into stats array.
918 */
919 if (tmp->type == WEAPON || tmp->type == BOW ||
920 tmp->type == ARMOUR || tmp->type == HELMET ||
921 tmp->type == SHIELD || tmp->type == RING ||
922 tmp->type == BOOTS || tmp->type == GLOVES ||
923 tmp->type == AMULET || tmp->type == GIRDLE ||
924 tmp->type == BRACERS || tmp->type == CLOAK ||
925 tmp->type == DISEASE || tmp->type == FORCE ||
926 tmp->type == SKILL)
927 { 887 {
928 contr->digestion += tmp->stats.food; 888 contr->digestion += tmp->stats.food;
929 contr->gen_hp += tmp->stats.hp; 889 contr->gen_hp += tmp->stats.hp;
890 if (tmp->type != BOW) // ugly exception for bows
930 contr->gen_sp += tmp->stats.sp; 891 contr->gen_sp += tmp->stats.sp;
931 contr->gen_grace += tmp->stats.grace; 892 contr->gen_grace += tmp->stats.grace;
932 contr->gen_sp_armour += tmp->gen_sp_armour; 893 contr->gen_sp_armour += tmp->gen_sp_armour;
933 contr->item_power += tmp->item_power;
934 } 894 }
935 } /* if this is a player */ 895 } /* if this is a player */
936 else 896 else
937 { 897 {
938 if (tmp->type == WEAPON) 898 if (tmp->type == WEAPON)
939 current_weapon = tmp; 899 current_weapon = tmp;
940 } 900 }
941 901
942 /* Update slots used for items */ 902 /* Update slots used for items */
943 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 903 if (tmp->flag [FLAG_APPLIED]) // exclude praying...
944 for (i = 0; i < NUM_BODY_LOCATIONS; i++) 904 for (int i = 0; i < NUM_BODY_LOCATIONS; i++)
945 slot[i].used += tmp->slot[i].info; 905 slot[i].used += tmp->slot[i].info;
946 906
947 if (tmp->type == SYMPTOM) 907 if (tmp->type == SYMPTOM)
948 {
949 speed_reduce_from_disease = tmp->last_sp / 100.f; 908 min_it (speed_reduce_from_disease, tmp->last_sp ? tmp->last_sp / 100.f : 1.f);
950 909
951 if (speed_reduce_from_disease == 0)
952 speed_reduce_from_disease = 1;
953 }
954
955 /* Pos. and neg. protections are counted seperate (-> pro/vuln). 910 /* Pos. and neg. protections are counted separate (-> pro/vuln).
956 * (Negative protections are calculated exactly like positive.) 911 * (Negative protections are calculated exactly like positive.)
957 * Resistance from potions are treated special as well. If there's 912 * Resistance from potions are treated special as well. If there's
958 * more than one potion-effect, the bigger prot.-value is taken. 913 * more than one potion-effect, the bigger prot.-value is taken.
959 */ 914 */
960 if (tmp->type != POTION) 915 if (tmp->type == POTION_EFFECT)
961 {
962 for (i = 0; i < NROFATTACKS; i++) 916 for (int i = 0; i < NROFATTACKS; i++)
963 {
964 /* Potential for cursed potions, in which case we just can use
965 * a straight MAX, as potion_resist is initialised to zero.
966 */
967 if (tmp->type == POTION_EFFECT)
968 {
969 if (potion_resist[i])
970 potion_resist[i] = MAX (potion_resist[i], tmp->resist[i]);
971 else
972 potion_resist[i] = tmp->resist[i]; 917 max_it (potion_resist[i], tmp->resist[i]);
973 } 918 else if (tmp->type != POTION)
919 for (int i = 0; i < NROFATTACKS; i++)
974 else if (tmp->resist[i] > 0) 920 if (tmp->resist[i] > 0)
975 prot[i] += ((100 - prot[i]) * tmp->resist[i]) / 100; 921 prot[i] += (100 - prot[i]) * tmp->resist[i] / 100;
976 else if (tmp->resist[i] < 0) 922 else if (tmp->resist[i] < 0)
977 vuln[i] += ((100 - vuln[i]) * -tmp->resist[i]) / 100; 923 vuln[i] += (100 - vuln[i]) * -tmp->resist[i] / 100;
978 }
979 }
980 924
981 /* There may be other things that should not adjust the attacktype */ 925 /* There may be other things that should not adjust the attacktype */
982 if ((tmp->type != WEAPON && tmp->type != BOW && tmp->type != SYMPTOM) 926 if (tmp->type != SYMPTOM)
983 || current_weapon == tmp)
984 { 927 {
985 attacktype |= tmp->attacktype; 928 attacktype |= tmp->attacktype;
986 path_attuned |= tmp->path_attuned; 929 path_attuned |= tmp->path_attuned;
987 path_repelled |= tmp->path_repelled; 930 path_repelled |= tmp->path_repelled;
988 path_denied |= tmp->path_denied; 931 path_denied |= tmp->path_denied;
989 move_type |= tmp->move_type; 932 move_type |= tmp->move_type;
990 stats.luck += tmp->stats.luck; 933 stats.luck += tmp->stats.luck;
991 } 934 }
992 935
993 if (QUERY_FLAG (tmp, FLAG_LIFESAVE )) SET_FLAG (this, FLAG_LIFESAVE); 936 flag |= tmp->flag & copy_flags;
994 if (QUERY_FLAG (tmp, FLAG_REFL_SPELL )) SET_FLAG (this, FLAG_REFL_SPELL);
995 if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE)) SET_FLAG (this, FLAG_REFL_MISSILE);
996 if (QUERY_FLAG (tmp, FLAG_STEALTH )) SET_FLAG (this, FLAG_STEALTH);
997 if (QUERY_FLAG (tmp, FLAG_XRAYS )) SET_FLAG (this, FLAG_XRAYS);
998 if (QUERY_FLAG (tmp, FLAG_BLIND )) SET_FLAG (this, FLAG_BLIND);
999 if (QUERY_FLAG (tmp, FLAG_SEE_IN_DARK )) SET_FLAG (this, FLAG_SEE_IN_DARK);
1000 937
1001 if (QUERY_FLAG (tmp, FLAG_UNDEAD) && !QUERY_FLAG (&arch->clone, FLAG_UNDEAD)) 938 if (tmp->flag [FLAG_UNDEAD] && !arch->flag [FLAG_UNDEAD])
1002 SET_FLAG (this, FLAG_UNDEAD); 939 this->set_flag (FLAG_UNDEAD);
1003 940
1004 if (QUERY_FLAG (tmp, FLAG_MAKE_INVIS)) 941 //TODO: copy_flags?
942 if (tmp->flag [FLAG_MAKE_INVIS])
1005 { 943 {
1006 SET_FLAG (this, FLAG_MAKE_INVIS); 944 set_flag (FLAG_MAKE_INVIS);
1007 invisible = 1; 945 invisible = 1;
1008 } 946 }
1009 947
1010 if (tmp->stats.exp && tmp->type != SKILL) 948 if (tmp->stats.exp && tmp->type != SKILL)
1011 { 949 {
… …
1018 added_speed += tmp->stats.exp; 956 added_speed += tmp->stats.exp;
1019 } 957 }
1020 958
1021 switch (tmp->type) 959 switch (tmp->type)
1022 { 960 {
1023#if 0
1024 case WAND:
1025 case ROD: 961 case SKILL:
1026 case HORN: 962 {
1027 if (type != PLAYER || current_weapon == tmp) 963 // some skills will end up here without counting as "applied"
964 if (!tmp->flag [FLAG_APPLIED] || skill_flags [tmp->subtype] & SF_AUTARK)
965 break;
966
967 if (chosen_skill)
968 {
969 LOG (llevDebug, "fix_player, op %s has multiple skills applied (%s and %s)\n",
970 &name, &chosen_skill->name, &tmp->name);
971
972 tmp->flag [FLAG_APPLIED] = false;
973 update_stats ();
974 return;
975 }
976
1028 chosen_skill = tmp; 977 chosen_skill = tmp;
1029 break;
1030#endif
1031 978
1032 /* skills modifying the character -b.t. */
1033 /* for all skills and skill granting objects */
1034 case SKILL:
1035 if (!QUERY_FLAG (tmp, FLAG_APPLIED))
1036 break;
1037
1038 if (IS_COMBAT_SKILL (tmp->subtype))
1039 wc_obj = tmp;
1040
1041 if (chosen_skill)
1042 LOG (llevDebug, "fix_player, op %s has multiple skills applied\n", &name);
1043
1044 chosen_skill = tmp;
1045
1046 if (tmp->stats.dam > 0) 979 if (tmp->stats.dam > 0)
1047 { /* skill is a 'weapon' */ 980 { /* skill is a 'weapon' */
1048 if (!QUERY_FLAG (this, FLAG_READY_WEAPON)) 981 if (!this->flag [FLAG_READY_WEAPON])
1049 weapon_speed = WEAPON_SPEED (tmp); 982 weapon_speed = max (0, WEAPON_SPEED (tmp));
1050 983
1051 if (weapon_speed < 0)
1052 weapon_speed = 0;
1053
1054 weapon_weight = tmp->weight; 984 weapon_weight = tmp->weight;
1055 stats.dam += tmp->stats.dam * (1 + (chosen_skill->level / 9)); 985 stats.dam += 1 + chosen_skill->level * tmp->stats.dam / 9;
1056 986
1057 if (tmp->magic) 987 if (tmp->magic)
1058 stats.dam += tmp->magic; 988 stats.dam += tmp->magic;
1059 } 989 }
1060 990
1061 if (tmp->stats.wc) 991 if (tmp->stats.wc)
1062 wc -= tmp->stats.wc + tmp->magic; 992 wc -= tmp->stats.wc + tmp->magic;
1063 993
1064 if (tmp->slaying) 994 if (tmp->slaying)
1065 slaying = tmp->slaying; 995 slaying = tmp->slaying;
1066 996
1067 if (tmp->stats.ac) 997 if (tmp->stats.ac)
1068 ac -= tmp->stats.ac + tmp->magic; 998 ac -= tmp->stats.ac + tmp->magic;
1069 999
1070 if (settings.spell_encumbrance == TRUE && type == PLAYER) 1000 if (settings.spell_encumbrance == TRUE && type == PLAYER)
1071 contr->encumbrance += (int) 3 *tmp->weight / 1000; 1001 contr->encumbrance += weight_to_kg_approx (3 * tmp->weight);
1072
1073 break; 1002 }
1074 1003
1075 case SKILL_TOOL:
1076 if (chosen_skill)
1077 LOG (llevDebug, "fix_player, op %s has multiple skills applied\n", &name);
1078
1079 chosen_skill = tmp;
1080 break; 1004 break;
1081 1005
1082 case SHIELD: 1006 case SHIELD:
1083 if (settings.spell_encumbrance == TRUE && type == PLAYER) 1007 if (settings.spell_encumbrance == TRUE && type == PLAYER)
1084 contr->encumbrance += (int) tmp->weight / 2000; 1008 contr->encumbrance += weight_to_kg_approx (tmp->weight) >> 1;
1009 //FALLTHROUGH
1085 case RING: 1010 case RING:
1086 case AMULET: 1011 case AMULET:
1087 case GIRDLE: 1012 case GIRDLE:
1088 case HELMET: 1013 case HELMET:
1089 case BOOTS: 1014 case BOOTS:
… …
1098 if (tmp->stats.ac) 1023 if (tmp->stats.ac)
1099 ac -= tmp->stats.ac + tmp->magic; 1024 ac -= tmp->stats.ac + tmp->magic;
1100 1025
1101 break; 1026 break;
1102 1027
1028 case RANGED:
1103 case BOW: 1029 case BOW:
1104 case WEAPON: 1030 case WEAPON:
1105 if (type != PLAYER || current_weapon == tmp)
1106 {
1107 wc -= tmp->stats.wc + tmp->magic; 1031 wc -= tmp->stats.wc + tmp->magic;
1108 1032
1109 if (tmp->stats.ac && tmp->stats.ac + tmp->magic > 0) 1033 if (tmp->stats.ac && tmp->stats.ac + tmp->magic > 0)
1110 ac -= tmp->stats.ac + tmp->magic; 1034 ac -= tmp->stats.ac + tmp->magic;
1111 1035
1112 stats.dam += tmp->stats.dam + tmp->magic; 1036 stats.dam += tmp->stats.dam + tmp->magic;
1113 weapon_weight = tmp->weight; 1037 weapon_weight = tmp->weight;
1114 weapon_speed = (WEAPON_SPEED (tmp) * 2 - tmp->magic) / 2; 1038 weapon_speed = (WEAPON_SPEED (tmp) * 2 - tmp->magic) / 2;
1115 1039
1116 if (weapon_speed < 0) 1040 if (weapon_speed < 0)
1117 weapon_speed = 0; 1041 weapon_speed = 0;
1118 1042
1119 slaying = tmp->slaying; 1043 slaying = tmp->slaying;
1120 1044
1121 /* If there is desire that two handed weapons should do 1045 /* If there is desire that two handed weapons should do
1122 * extra strength damage, this is where the code should 1046 * extra strength damage, this is where the code should
1123 * go. 1047 * go.
1124 */ 1048 */
1125 1049
1126 if (type == PLAYER) 1050 if (type == PLAYER)
1127 if (settings.spell_encumbrance) 1051 if (settings.spell_encumbrance)
1128 contr->encumbrance += tmp->weight * 3 / 1000; 1052 contr->encumbrance += weight_to_kg_approx (3 * tmp->weight);
1129 }
1130 1053
1131 break; 1054 break;
1132 1055
1133 case ARMOUR: /* Only the best of these three are used: */ 1056 case ARMOUR: /* Only the best of these three are used: */
1134 if (settings.spell_encumbrance == TRUE && type == PLAYER) 1057 if (settings.spell_encumbrance == TRUE && type == PLAYER)
1135 contr->encumbrance += tmp->weight / 1000; 1058 contr->encumbrance += weight_to_kg_approx (tmp->weight);
1136 1059
1137 case BRACERS: 1060 case BRACERS:
1138 case FORCE: 1061 case FORCE:
1139 if (tmp->stats.wc) 1062 if (tmp->stats.wc)
1140 { 1063 {
… …
1157 else /* To nullify the below effect */ 1080 else /* To nullify the below effect */
1158 ac += tmp->stats.ac + tmp->magic; 1081 ac += tmp->stats.ac + tmp->magic;
1159 } 1082 }
1160 1083
1161 if (tmp->stats.wc) 1084 if (tmp->stats.wc)
1162 wc -= (tmp->stats.wc + tmp->magic); 1085 wc -= tmp->stats.wc + tmp->magic;
1163 1086
1164 if (tmp->stats.ac) 1087 if (tmp->stats.ac)
1165 ac -= (tmp->stats.ac + tmp->magic); 1088 ac -= tmp->stats.ac + tmp->magic;
1166 1089
1167 if (ARMOUR_SPEED (tmp) && ARMOUR_SPEED (tmp) / 10.f < max) 1090 if (ARMOUR_SPEED (tmp))
1168 max = ARMOUR_SPEED (tmp) / 10.f; 1091 min_it (max_speed, ARMOUR_SPEED (tmp) / 10.f);
1169 1092
1170 break; 1093 break;
1171 } /* switch tmp->type */ 1094 } /* switch tmp->type */
1172 } /* item is equipped */ 1095 } /* item is equipped */
1173 } /* for loop of items */ 1096 } /* for loop of items */
1097
1098 min_it (glow_radius, MAX_LIGHT_RADIUS);
1174 1099
1175 /* We've gone through all the objects the player has equipped. For many things, we 1100 /* We've gone through all the objects the player has equipped. For many things, we
1176 * have generated intermediate values which we now need to assign. 1101 * have generated intermediate values which we now need to assign.
1177 */ 1102 */
1178 1103
… …
1180 * If there is an uncursed potion in effect, granting more protection 1105 * If there is an uncursed potion in effect, granting more protection
1181 * than that, we take: 'total resistance = resistance from potion'. 1106 * than that, we take: 'total resistance = resistance from potion'.
1182 * If there is a cursed (and no uncursed) potion in effect, we take 1107 * If there is a cursed (and no uncursed) potion in effect, we take
1183 * 'total resistance = vulnerability from cursed potion'. 1108 * 'total resistance = vulnerability from cursed potion'.
1184 */ 1109 */
1185 for (i = 0; i < NROFATTACKS; i++) 1110 for (int i = 0; i < NROFATTACKS; i++)
1186 { 1111 {
1187 resist[i] = prot[i] - vuln[i]; 1112 resist[i] = prot[i] - vuln[i];
1188 1113
1189 if (potion_resist[i] && ((potion_resist[i] > resist[i]) || (potion_resist[i] < 0))) 1114 if (potion_resist[i] != -1000
1115 && (potion_resist[i] < 0 || potion_resist[i] > resist[i]))
1190 resist[i] = potion_resist[i]; 1116 resist[i] = potion_resist[i];
1191 } 1117 }
1192 1118
1193 /* Figure out the players sp/mana/hp totals. */
1194 if (type == PLAYER) 1119 if (type == PLAYER)
1195 { 1120 {
1121 // clamp various player stats
1122 for (int i = 0; i < NUM_STATS; ++i)
1123 stats.stat (i) = stat_sum [i];
1124
1125 check_stat_bounds (&stats);
1126
1127 contr->digestion = clamp (contr->digestion, MIN_DIGESTION, MAX_DIGESTION);
1128
1129 /* Figure out the players sp/mana/hp totals. */
1196 int pl_level; 1130 int pl_level;
1197 1131
1198 check_stat_bounds (&(stats));
1199 pl_level = level;
1200
1201 if (pl_level < 1)
1202 pl_level = 1; /* safety, we should always get 1 levels worth of hp! */ 1132 pl_level = max (1, level); /* safety, we should always get 1 levels worth of hp! */
1203 1133
1204 /* You basically get half a con bonus/level. But we do take into account rounding, 1134 /* You basically get half a con bonus/level. But we do take into account rounding,
1205 * so if your bonus is 7, you still get 7 worth of bonus every 2 levels. 1135 * so if your bonus is 7, you still get 7 worth of bonus every 2 levels.
1206 */ 1136 */
1207 for (i = 1, stats.maxhp = 0; i <= pl_level && i <= 10; i++) 1137 stats.maxhp = 0;
1138 for (int i = 1; i <= min (10, pl_level); i++)
1208 { 1139 {
1209 j = contr->levhp[i] + con_bonus[stats.Con] / 2; 1140 int j = contr->levhp[i] + con_bonus[stats.Con] / 2;
1210 1141
1211 if (i % 2 && con_bonus[stats.Con] % 2) 1142 if (i % 2 && con_bonus[stats.Con] % 2)
1212 {
1213 if (con_bonus[stats.Con] > 0) 1143 if (con_bonus[stats.Con] > 0)
1214 j++; 1144 j++;
1215 else 1145 else
1216 j--; 1146 j--;
1217 }
1218 1147
1219 stats.maxhp += j > 1 ? j : 1; /* always get at least 1 hp/level */ 1148 stats.maxhp += j > 1 ? j : 1; /* always get at least 1 hp/level */
1220 } 1149 }
1221 1150
1222 for (i = 11; i <= level; i++) 1151 stats.maxhp += 2 * max (0, level - 10);
1223 stats.maxhp += 2;
1224 1152
1225 if (stats.hp > stats.maxhp) 1153 if (stats.hp > stats.maxhp)
1226 stats.hp = stats.maxhp; 1154 stats.hp = stats.maxhp;
1227 1155
1228 /* Sp gain is controlled by the level of the player's 1156 /* Sp gain is controlled by the level of the player's
… …
1241 1169
1242 if (mana_obj == this && type == PLAYER) 1170 if (mana_obj == this && type == PLAYER)
1243 stats.maxsp = 1; 1171 stats.maxsp = 1;
1244 else 1172 else
1245 { 1173 {
1246 sp_tmp = 0.f; 1174 float sp_tmp = 0.f;
1247 1175
1248 for (i = 1; i <= mana_obj->level && i <= 10; i++) 1176 for (int i = 1; i <= min (10, mana_obj->level); i++)
1249 { 1177 {
1250 float stmp; 1178 float stmp;
1251 1179
1252 /* Got some extra bonus at first level */ 1180 /* Got some extra bonus at first level */
1253 if (i < 2) 1181 if (i < 2)
1254 stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 6.f; 1182 stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 6.f;
1255 else 1183 else
1256 stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 12.f; 1184 stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 12.f;
1257 1185
1258 if (stmp < 1.f)
1259 stmp = 1.f;
1260
1261 sp_tmp += stmp; 1186 sp_tmp += max (1.f, stmp);
1262 } 1187 }
1263 1188
1264 stats.maxsp = (sint16)sp_tmp; 1189 stats.maxsp = int (sp_tmp) + 2 * max (0, mana_obj->level - 10);
1265
1266 for (i = 11; i <= mana_obj->level; i++)
1267 stats.maxsp += 2;
1268 } 1190 }
1191
1269 /* Characters can get their sp supercharged via rune of transferrance */ 1192 /* Characters can get their sp supercharged via rune of transferrance */
1270 if (stats.sp > stats.maxsp * 2) 1193 stats.sp = min (stats.sp, stats.maxsp * 2);
1271 stats.sp = stats.maxsp * 2;
1272 1194
1273 /* set maxgrace, notice 3-4 lines below it depends on both Wis and Pow */ 1195 /* set maxgrace, notice 3-4 lines below it depends on both Wis and Pow */
1274 if (!grace_obj || !grace_obj->level || type != PLAYER) 1196 if (!grace_obj || !grace_obj->level || type != PLAYER)
1275 grace_obj = this; 1197 grace_obj = this;
1276 1198
… …
1281 /* store grace in a float - this way, the divisions below don't create 1203 /* store grace in a float - this way, the divisions below don't create
1282 * big jumps when you go from level to level - with int's, it then 1204 * big jumps when you go from level to level - with int's, it then
1283 * becomes big jumps when the sums of the bonuses jump to the next 1205 * becomes big jumps when the sums of the bonuses jump to the next
1284 * step of 8 - with floats, even fractional ones are useful. 1206 * step of 8 - with floats, even fractional ones are useful.
1285 */ 1207 */
1286 sp_tmp = 0.f; 1208 float sp_tmp = 0.f;
1287 for (i = 1, stats.maxgrace = 0; i <= grace_obj->level && i <= 10; i++) 1209
1210 for (int i = 1; i <= min (10, grace_obj->level); i++)
1288 { 1211 {
1289 float grace_tmp = 0.f; 1212 float grace_tmp = 0.f;
1290 1213
1291 /* Got some extra bonus at first level */ 1214 /* Got some extra bonus at first level */
1292 if (i < 2) 1215 if (i < 2)
1293 grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 6.f; 1216 grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 6.f;
1294 else 1217 else
1295 grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 12.f; 1218 grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 12.f;
1296 1219
1297 if (grace_tmp < 1.f)
1298 grace_tmp = 1.f;
1299
1300 sp_tmp += grace_tmp; 1220 sp_tmp += max (1.f, grace_tmp);
1301 } 1221 }
1302 1222
1303 stats.maxgrace = (sint16)sp_tmp;
1304
1305 /* two grace points per level after 11 */ 1223 /* two grace points per level after 10 */
1306 for (i = 11; i <= grace_obj->level; i++) 1224 stats.maxgrace = int (sp_tmp) + 2 * max (0, grace_obj->level - 10);
1307 stats.maxgrace += 2;
1308 } 1225 }
1226
1309 /* No limit on grace vs maxgrace */ 1227 /* No limit on grace vs maxgrace */
1310 1228
1311 if (contr->braced) 1229 if (contr->braced)
1312 { 1230 {
1313 ac += 2; 1231 ac += 2;
… …
1325 * improvement every level, now its fighterlevel/5. So 1243 * improvement every level, now its fighterlevel/5. So
1326 * we give the player a bonus here in wc and dam 1244 * we give the player a bonus here in wc and dam
1327 * to make up for the change. Note that I left the 1245 * to make up for the change. Note that I left the
1328 * monster bonus the same as before. -b.t. 1246 * monster bonus the same as before. -b.t.
1329 */ 1247 */
1248 object *wc_obj = chosen_skill;
1330 1249
1331 if (type == PLAYER && wc_obj && wc_obj->level > 1) 1250 if (contr && wc_obj && wc_obj->level > 1)
1332 { 1251 {
1333 wc -= wc_obj->level + thaco_bonus[stats.Str]; 1252 wc -= wc_obj->level + thaco_bonus[stats.Str];
1334 1253
1335 for (i = 1; i < wc_obj->level; i++) 1254 for (int i = 1; i < wc_obj->level; i++)
1336 { 1255 {
1337 /* addtional wc every 6 levels */ 1256 /* additional wc every 6 levels */
1338 if (!(i % 6)) 1257 if (!(i % 6))
1339 wc--; 1258 wc--;
1340 1259
1341 /* addtional dam every 4 levels. */ 1260 /* additional dam every 4 levels. */
1342 if (!(i % 4) && dam_bonus[stats.Str] >= 0) 1261 if (!(i % 4) && dam_bonus[stats.Str] >= 0)
1343 stats.dam += 1 + dam_bonus[stats.Str] / 5; 1262 stats.dam += 1 + dam_bonus[stats.Str] / 5;
1344 } 1263 }
1345 } 1264 }
1346 else 1265 else
… …
1353 1272
1354 speed = 1.f + speed_bonus[stats.Dex]; 1273 speed = 1.f + speed_bonus[stats.Dex];
1355 1274
1356 if (settings.search_items && contr->search_str[0]) 1275 if (settings.search_items && contr->search_str[0])
1357 speed -= 1; 1276 speed -= 1;
1358
1359 if (attacktype == 0)
1360 attacktype = arch->clone.attacktype;
1361
1362 } /* End if player */ 1277 } /* End if player */
1363 1278
1364 if (added_speed >= 0) 1279 if (added_speed >= 0)
1365 speed += added_speed / 10.f; 1280 speed += added_speed / 10.f;
1366 else /* Something wrong here...: */ 1281 else /* Something wrong here...: */
1367 speed /= 1.f - added_speed; 1282 speed /= 1.f - added_speed;
1368 1283
1369 /* Max is determined by armour */ 1284 /* Max is determined by armour */
1370 if (speed > max) 1285 speed = min (speed, max_speed);
1371 speed = max;
1372 1286
1373 if (type == PLAYER) 1287 if (type == PLAYER)
1374 { 1288 {
1375 /* f is a number the represents the number of kg above (positive num) 1289 /* f is a number the represents the number of kg above (positive num)
1376 * or below (negative number) that the player is carrying. If above 1290 * or below (negative number) that the player is carrying. If above
1377 * weight limit, then player suffers a speed reduction based on how 1291 * weight limit, then player suffers a speed reduction based on how
1378 * much above he is, and what is max carry is 1292 * much above he is, and what is max carry is
1379 */ 1293 */
1380 f = (carrying / 1000) - max_carry[stats.Str]; 1294 double f = weight_to_kg_approx (carrying) - max_carry[stats.Str];
1381 if (f > 0) 1295 if (f > 0.f)
1382 speed = speed / (1.f + f / max_carry[stats.Str]); 1296 speed /= (1.f + f / max_carry[stats.Str]);
1383 } 1297 }
1384 1298
1385 speed += bonus_speed / 10.f; /* Not affected by limits */ 1299 speed += bonus_speed / 10.f; /* Not affected by limits */
1300 speed *= speed_reduce_from_disease;
1386 1301
1387 /* Put a lower limit on speed. Note with this speed, you move once every 1302 /* Put a lower limit on speed. Note with this speed, you move once every
1388 * 100 ticks or so. This amounts to once every 12 seconds of realtime. 1303 * 25 ticks or so. This amounts to once every 3 seconds of realtime.
1389 */ 1304 */
1390 speed = speed * speed_reduce_from_disease; 1305 max_it (speed, is_player () ? MIN_PLAYER_SPEED : MIN_ACTIVE_SPEED);
1391 1306
1392 if (speed < 0.01f && type == PLAYER) 1307 if (speed != old_speed)
1393 speed = 0.01f; 1308 set_speed (speed);
1394 1309
1395 if (type == PLAYER) 1310 if (type == PLAYER)
1396 { 1311 {
1397 /* (This formula was made by vidarl@ifi.uio.no) 1312 /* (This formula was made by vidarl@ifi.uio.no)
1398 * Note that we never used these values again - basically 1313 * Note that we never used these values again - basically
… …
1400 * that would just be a real pain to read. 1315 * that would just be a real pain to read.
1401 */ 1316 */
1402 float M = (max_carry[stats.Str] - 121) / 121.f; 1317 float M = (max_carry[stats.Str] - 121) / 121.f;
1403 float M2 = max_carry[stats.Str] / 100.f; 1318 float M2 = max_carry[stats.Str] / 100.f;
1404 float W = weapon_weight / 20000.f; 1319 float W = weapon_weight / 20000.f;
1405 float s = 2 - weapon_speed / 10.f; 1320 float s = (20 - weapon_speed) / 10.f;
1406 float D = (stats.Dex - 14) / 14.f; 1321 float D = (stats.Dex - 14) / 14.f;
1407 float K = 1 + M / 3.f - W / (3 * M2) + speed / 5.f + D / 2.f; 1322 float K = 1 + M / 3.f - W / (3 * M2) + speed / 5.f + D / 2.f;
1408 1323
1409 K *= (4 + level) *1.2f / (6 + level); 1324 K *= (4 + level) * 1.2f / (6 + level);
1410 1325
1411 if (K <= 0.f) 1326 if (K <= 0.01f)
1412 K = 0.01f; 1327 K = 0.01f;
1413 1328
1414 float S = speed / (K * s); 1329 contr->weapon_sp = K * s * .5f; //TODO: balance the .5
1415
1416 contr->weapon_sp = S;
1417 } 1330 }
1418 1331
1419 /* I want to limit the power of small monsters with big weapons: */ 1332 /* I want to limit the power of small monsters with big weapons: */
1420 if (type != PLAYER && arch && stats.dam > arch->clone.stats.dam * 3) 1333 if (type != PLAYER && arch && stats.dam > arch->stats.dam * 3)
1421 stats.dam = arch->clone.stats.dam * 3; 1334 stats.dam = arch->stats.dam * 3;
1422 1335
1423 /* Prevent overflows of wc - best you can get is ABS(120) - this 1336 stats.wc = clamp (wc, MIN_WC, MAX_WC);
1424 * should be more than enough - remember, AC is also in 8 bits, 1337 stats.ac = clamp (ac, MIN_AC, MAX_AC);
1425 * so its value is the same.
1426 */
1427 if (wc > 120)
1428 wc = 120;
1429 else if (wc < -120)
1430 wc = -120;
1431
1432 stats.wc = wc;
1433
1434 if (ac > 120)
1435 ac = 120;
1436 else if (ac < -120)
1437 ac = -120;
1438
1439 stats.ac = ac;
1440 1338
1441 /* if for some reason the creature doesn't have any move type, 1339 /* if for some reason the creature doesn't have any move type,
1442 * give them walking as a default. 1340 * give them walking as a default.
1443 * The second case is a special case - to more closely mimic the 1341 * The second case is a special case - to more closely mimic the
1444 * old behaviour - if your flying, your not walking - just 1342 * old behaviour - if your flying, your not walking - just
… …
1447 if (move_type == 0) 1345 if (move_type == 0)
1448 move_type = MOVE_WALK; 1346 move_type = MOVE_WALK;
1449 else if (move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH)) 1347 else if (move_type & (MOVE_FLY_LOW | MOVE_FLY_HIGH))
1450 move_type &= ~MOVE_WALK; 1348 move_type &= ~MOVE_WALK;
1451 1349
1452 if (speed != old_speed) 1350 // now apply the new move_type
1453 set_speed (speed); 1351 if (this->move_type != move_type)
1352 change_move_type (move_type);
1454 1353
1455 /* It is quite possible that a player's spell costing might have changed, 1354 /* It is quite possible that a player's spell costing might have changed,
1456 * so we will check that now. 1355 * so we will check that now.
1457 */ 1356 */
1458 if (type == PLAYER) 1357 if (is_player ())
1459 { 1358 contr->update_spells ();
1460 esrv_update_stats (contr);
1461 esrv_update_spells (contr);
1462 }
1463 1359
1464 // update the mapspace, if we are on a map 1360 // update the mapspace, if we are on a map
1465 if (!flag [FLAG_REMOVED] && map) 1361 if (!flag [FLAG_REMOVED] && map)
1466 map->at (x, y).flags_ = 0; 1362 map->at (x, y).flags_ = 0;
1363}
1364
1365void
1366object::set_glow_radius (sint8 rad)
1367{
1368 glow_radius = rad;
1369
1370 if (is_on_map ())
1371 update_all_los (map, x, y);
1372 else if (object *env = outer_env ())
1373 {
1374 env->update_stats ();
1375
1376 if (env->is_on_map ())
1377 update_all_los (env->map, env->x, env->y);
1378 }
1467} 1379}
1468 1380
1469/* 1381/*
1470 * Returns true if the given player is a legal class. 1382 * Returns true if the given player is a legal class.
1471 * The function to add and remove class-bonuses to the stats doesn't 1383 * The function to add and remove class-bonuses to the stats doesn't
… …
1487 1399
1488/* 1400/*
1489 * set the new dragon name after gaining levels or 1401 * set the new dragon name after gaining levels or
1490 * changing ability focus (later this can be extended to 1402 * changing ability focus (later this can be extended to
1491 * eventually change the player's face and animation) 1403 * eventually change the player's face and animation)
1492 *
1493 * Note that the title is written to 'own_title' in the
1494 * player struct. This should be changed to 'ext_title'
1495 * as soon as clients support this!
1496 * Please, anyone, write support for 'ext_title'.
1497 */ 1404 */
1498void 1405void
1499set_dragon_name (object *pl, const object *abil, const object *skin) 1406set_dragon_name (object *pl, const object *abil, const object *skin)
1500{ 1407{
1501 int atnr = -1; /* attacknumber of highest level */ 1408 int atnr = -1; /* attacknumber of highest level */
… …
1519 /* now if there are equals at highest level, pick the one with focus, 1426 /* now if there are equals at highest level, pick the one with focus,
1520 or else at random */ 1427 or else at random */
1521 if (atnr_is_dragon_enabled (abil->stats.exp) && abil->resist[abil->stats.exp] >= level) 1428 if (atnr_is_dragon_enabled (abil->stats.exp) && abil->resist[abil->stats.exp] >= level)
1522 atnr = abil->stats.exp; 1429 atnr = abil->stats.exp;
1523 1430
1524 level = (int) (level / 5.);
1525
1526 /* now set the new title */ 1431 /* now set the new title */
1527 if (pl->contr != NULL)
1528 {
1529 if (level == 0)
1530 sprintf (pl->contr->title, "%s hatchling", attacks[atnr]); 1432 if (level < 25) sprintf (pl->contr->title, "%s hatchling", attacks[atnr]);
1531 else if (level == 1)
1532 sprintf (pl->contr->title, "%s wyrm", attacks[atnr]); 1433 else if (level < 50) sprintf (pl->contr->title, "%s wyrm" , attacks[atnr]);
1533 else if (level == 2)
1534 sprintf (pl->contr->title, "%s wyvern", attacks[atnr]); 1434 else if (level < 75) sprintf (pl->contr->title, "%s wyvern" , attacks[atnr]);
1535 else if (level == 3)
1536 sprintf (pl->contr->title, "%s dragon", attacks[atnr]); 1435 else if (level < 100) sprintf (pl->contr->title, "%s dragon" , attacks[atnr]);
1537 else 1436 else
1538 { 1437 {
1539 /* special titles for extra high resistance! */ 1438 /* special titles for extra high resistance! */
1540 if (skin->resist[atnr] > 80)
1541 sprintf (pl->contr->title, "legendary %s dragon", attacks[atnr]); 1439 if (skin->resist[atnr] > 80) sprintf (pl->contr->title, "legendary %s dragon", attacks[atnr]);
1542 else if (skin->resist[atnr] > 50)
1543 sprintf (pl->contr->title, "ancient %s dragon", attacks[atnr]); 1440 else if (skin->resist[atnr] > 50) sprintf (pl->contr->title, "ancient %s dragon" , attacks[atnr]);
1544 else
1545 sprintf (pl->contr->title, "big %s dragon", attacks[atnr]); 1441 else sprintf (pl->contr->title, "big %s dragon" , attacks[atnr]);
1546 }
1547 } 1442 }
1548 1443
1549 strcpy (pl->contr->own_title, ""); 1444 strcpy (pl->contr->own_title, "");
1550} 1445}
1551 1446
1552/* 1447/*
1553 * This function is called when a dragon-player gains 1448 * This function is called when a dragon-player gains
1554 * an overall level. Here, the dragon might gain new abilities 1449 * an overall level. Here, the dragon might gain new abilities
1555 * or change the ability-focus. 1450 * or change the ability-focus.
1556 */ 1451 */
1557void 1452static void
1558dragon_level_gain (object *who) 1453dragon_level_gain (object *who)
1559{ 1454{
1560 object *abil = NULL; /* pointer to dragon ability force */ 1455 object *abil = NULL; /* pointer to dragon ability force */
1561 object *skin = NULL; /* pointer to dragon skin force */ 1456 object *skin = NULL; /* pointer to dragon skin force */
1562 object *tmp = NULL; /* tmp. object */ 1457 object *tmp = NULL; /* tmp. object */
1563 char buf[MAX_BUF]; /* tmp. string buffer */ 1458 char buf[MAX_BUF]; /* tmp. string buffer */
1564 1459
1565 /* now grab the 'dragon_ability'-forces from the player's inventory */ 1460 /* now grab the 'dragon_ability'-forces from the player's inventory */
1566 shstr_cmp dragon_ability_force ("dragon_ability_force");
1567 shstr_cmp dragon_skin_force ("dragon_skin_force");
1568
1569 for (tmp = who->inv; tmp; tmp = tmp->below) 1461 for (tmp = who->inv; tmp; tmp = tmp->below)
1570 if (tmp->type == FORCE) 1462 if (tmp->type == FORCE)
1571 if (tmp->arch->name == dragon_ability_force) 1463 if (tmp->arch->archname == shstr_dragon_ability_force)
1572 abil = tmp; 1464 abil = tmp;
1573 else if (tmp->arch->name == dragon_skin_force) 1465 else if (tmp->arch->archname == shstr_dragon_skin_force)
1574 skin = tmp; 1466 skin = tmp;
1575 1467
1576 /* if the force is missing -> bail out */ 1468 /* if the force is missing -> bail out */
1577 if (abil == NULL) 1469 if (abil == NULL)
1578 return; 1470 return;
… …
1621 object *skill_obj; 1513 object *skill_obj;
1622 1514
1623 skill_obj = get_archetype_by_skill_name (skill_name, SKILL); 1515 skill_obj = get_archetype_by_skill_name (skill_name, SKILL);
1624 if (!skill_obj) 1516 if (!skill_obj)
1625 { 1517 {
1626 LOG (llevError, "add_player_exp: couldn't find skill %s\n", skill_name); 1518 LOG (llevError, "give_skill_by_name: couldn't find skill %s\n", skill_name);
1627 return NULL; 1519 return NULL;
1628 } 1520 }
1521
1629 /* clear the flag - exp goes into this bucket, but player 1522 /* clear the flag - exp goes into this bucket, but player
1630 * still doesn't know it. 1523 * still doesn't know it.
1631 */ 1524 */
1632 CLEAR_FLAG (skill_obj, FLAG_CAN_USE_SKILL); 1525 skill_obj->clr_flag (FLAG_CAN_USE_SKILL);
1633 skill_obj->stats.exp = 0; 1526 skill_obj->stats.exp = 0;
1634 skill_obj->level = 1; 1527 skill_obj->level = 1;
1635 insert_ob_in_ob (skill_obj, op); 1528 op->insert (skill_obj);
1636 1529
1637 if (op->contr) 1530 if (player *pl = op->contr)
1638 { 1531 pl->link_skills ();
1639 op->contr->last_skill_ob [skill_obj->subtype] = skill_obj;
1640 if (op->contr->ns)
1641 op->contr->ns->last_skill_exp[skill_obj->subtype] = -1;//TODO: should be made superfluous
1642 }
1643 1532
1644 return skill_obj; 1533 return skill_obj;
1645} 1534}
1646
1647 1535
1648/* player_lvl_adj() - for the new exp system. we are concerned with 1536/* player_lvl_adj() - for the new exp system. we are concerned with
1649 * whether the player gets more hp, sp and new levels. 1537 * whether the player gets more hp, sp and new levels.
1650 * Note this this function should only be called for players. Monstes 1538 * Note this this function should only be called for players. Monstes
1651 * don't really gain levels 1539 * don't really gain levels
… …
1654 */ 1542 */
1655void 1543void
1656player_lvl_adj (object *who, object *op) 1544player_lvl_adj (object *who, object *op)
1657{ 1545{
1658 char buf[MAX_BUF]; 1546 char buf[MAX_BUF];
1547 bool changed = false;
1659 1548
1660 if (!op) /* when rolling stats */ 1549 if (!op) /* when rolling stats */
1661 op = who; 1550 op = who;
1662 1551
1663 if (op->level < settings.max_level && op->stats.exp >= level_exp (op->level + 1, who->expmul)) 1552 while (op->level < settings.max_level && op->stats.exp >= level_exp (op->level + 1, who->expmul))
1664 { 1553 {
1554 changed = true;
1555
1665 op->level++; 1556 op->level++;
1666 1557
1667 if (op != NULL && op == who && op->stats.exp > 1 && is_dragon_pl (who)) 1558 if (op && op == who && op->stats.exp > 1 && who->is_dragon ())
1668 dragon_level_gain (who); 1559 dragon_level_gain (who);
1669 1560
1670 /* Only roll these if it is the player (who) that gained the level */ 1561 /* Only roll these if it is the player (who) that gained the level */
1671 if (op == who && (who->level < 11) && who->type == PLAYER) 1562 if (op == who && (who->level < 11) && who->type == PLAYER)
1672 { 1563 {
1673 who->contr->levhp[who->level] = die_roll (2, 4, who, PREFER_HIGH) + 1; 1564 who->contr->levhp[who->level] = die_roll (2, 4, who, PREFER_HIGH) + 1;
1674 who->contr->levsp[who->level] = die_roll (2, 3, who, PREFER_HIGH); 1565 who->contr->levsp[who->level] = die_roll (2, 3, who, PREFER_HIGH);
1675 who->contr->levgrace[who->level] = die_roll (2, 2, who, PREFER_HIGH) - 1; 1566 who->contr->levgrace[who->level] = die_roll (2, 2, who, PREFER_HIGH) - 1;
1676 } 1567 }
1677 1568
1678 who->update_stats ();
1679 if (op->level > 1) 1569 if (op->level > 1)
1680 { 1570 {
1681 if (op->type != PLAYER) 1571 if (op->type != PLAYER)
1572 {
1573 who->contr->play_sound (sound_find ("skill_up"));
1682 sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name); 1574 sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);
1575 }
1683 else 1576 else
1577 {
1578 who->contr->play_sound (sound_find ("level_up"));
1684 sprintf (buf, "You are now level %d.", op->level); 1579 sprintf (buf, "You are now level %d.", op->level);
1580 }
1581
1685 if (who) 1582 if (who)
1686 new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf); 1583 new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
1687 } 1584 }
1688 player_lvl_adj (who, op); /* To increase more levels */
1689 } 1585 }
1586
1690 else if (op->level > 1 && op->stats.exp < level_exp (op->level, who->expmul)) 1587 while (op->level > 1 && op->stats.exp < level_exp (op->level, who->expmul))
1691 { 1588 {
1589 changed = true;
1590
1692 op->level--; 1591 op->level--;
1693 who->update_stats (); 1592
1694 if (op->type != PLAYER) 1593 if (op->type != PLAYER)
1695 { 1594 {
1696 sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name); 1595 sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);
1697 new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf); 1596 new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
1698 } 1597 }
1699 player_lvl_adj (who, op); /* To decrease more levels */
1700 } 1598 }
1701 1599
1702 /* check if the spell data has changed */ 1600 if (changed)
1703 esrv_update_stats (who->contr); 1601 who->update_stats (); // should cause esrv_update_stats and esrv_update_spells
1704 esrv_update_spells (who->contr);
1705} 1602}
1706 1603
1707/* 1604/*
1708 * Returns how much experience is needed for a player to become 1605 * Returns how much experience is needed for a player to become
1709 * the given level. level should really never exceed max_level 1606 * the given level. level should really never exceed max_level
1710 */ 1607 */
1711 1608
1712sint64 1609sint64
1713level_exp (int level, double expmul) 1610level_exp (int level, double expmul)
1714{ 1611{
1715 if (level > settings.max_level) 1612 return expmul * level_to_min_exp (level);
1716 return (sint64) (expmul * levels[settings.max_level]);
1717
1718 return (sint64) (expmul * levels[level]);
1719} 1613}
1720 1614
1721/* 1615/*
1722 * Ensure that the permanent experience requirements in an exp object are met. 1616 * Ensure that the permanent experience requirements in an exp object are met.
1723 * This really just checks 'op to make sure the perm_exp value is within 1617 * This really just checks 'op to make sure the perm_exp value is within
… …
1751 * NULL, in which case exp increases the players general 1645 * NULL, in which case exp increases the players general
1752 * total, but not any particular skill. 1646 * total, but not any particular skill.
1753 * flag is what to do if the player doesn't have the skill: 1647 * flag is what to do if the player doesn't have the skill:
1754 */ 1648 */
1755static void 1649static void
1756add_player_exp (object *op, sint64 exp, const char *skill_name, int flag) 1650add_player_exp (object *op, sint64 exp, shstr_tmp skill_name, int flag)
1757{ 1651{
1758 object *skill_obj = NULL; 1652 object *skill_obj;
1759 sint64 limit, exp_to_add; 1653 sint64 limit, exp_to_add;
1760 int i;
1761 1654
1762 /* prevents some forms of abuse. */ 1655 /* prevents some forms of abuse. */
1763 if (op->contr->braced) 1656 if (op->contr->braced)
1764 exp /= 5; 1657 exp /= 5;
1765 1658
1766 /* Try to find the matching skill. 1659 /* Try to find the matching skill.
1767 * We do a shortcut/time saving mechanism first - see if it matches 1660 * We do a shortcut/time saving mechanism first - see if it matches
1768 * chosen_skill. This means we don't need to search through 1661 * chosen_skill. This means we don't need to search through
1769 * the players inventory. 1662 * the players inventory.
1770 */ 1663 */
1664 skill_obj = 0;
1665
1771 if (skill_name) 1666 if (skill_name)
1772 { 1667 {
1773 if (op->chosen_skill && op->chosen_skill->type == SKILL && !strcmp (skill_name, op->chosen_skill->skill)) 1668 skill_obj = op->contr->find_skill (skill_name);
1774 skill_obj = op->chosen_skill;
1775 else
1776 {
1777 for (i = 0; i < NUM_SKILLS; i++)
1778 if (op->contr->last_skill_ob[i] && !strcmp (op->contr->last_skill_ob[i]->skill, skill_name))
1779 {
1780 skill_obj = op->contr->last_skill_ob[i];
1781 break;
1782 }
1783 1669
1784 /* Player doesn't have the skill. Check to see what to do, and give 1670 /* Player doesn't have the skill. Check to see what to do, and give
1785 * it to the player if necessary 1671 * it to the player if necessary
1786 */ 1672 */
1787 if (!skill_obj) 1673 if (!skill_obj)
1788 { 1674 {
1789 if (flag == SK_EXP_NONE) 1675 if (flag == SK_EXP_NONE)
1790 return; 1676 return;
1677
1791 else if (flag == SK_EXP_ADD_SKILL) 1678 if (flag == SK_EXP_ADD_SKILL)
1792 give_skill_by_name (op, skill_name); 1679 skill_obj = give_skill_by_name (op, skill_name);
1793 }
1794 } 1680 }
1795 } 1681 }
1796 1682
1797 if (flag != SK_EXP_SKILL_ONLY) 1683 if (flag != SK_EXP_SKILL_ONLY)
1798 { 1684 {
1799 /* Basically, you can never gain more experience in one shot 1685 /* Basically, you can never gain more experience in one shot
1800 * than half what you need to gain for next level. 1686 * than half what you need to gain for next level.
1801 */ 1687 */
1802 exp_to_add = exp; 1688 exp_to_add = exp;
1803 limit = (levels[op->level + 1] - levels[op->level]) / 2; 1689 limit = (levels [op->level + 1] - levels [op->level]) / 2;
1804 if (exp_to_add > limit) 1690 if (exp_to_add > limit)
1805 exp_to_add = limit; 1691 exp_to_add = limit;
1806 1692
1807 ADD_EXP (op->stats.exp, (sint64) ((float) exp_to_add * (skill_obj ? skill_obj->expmul : 1))); 1693 ADD_EXP (op->stats.exp, (sint64) ((float) exp_to_add * (skill_obj ? skill_obj->expmul : 1)));
1808 if (settings.permanent_exp_ratio) 1694 if (settings.permanent_exp_ratio)
… …
1815 } 1701 }
1816 1702
1817 if (skill_obj) 1703 if (skill_obj)
1818 { 1704 {
1819 exp_to_add = exp; 1705 exp_to_add = exp;
1820 limit = (levels[skill_obj->level + 1] - levels[skill_obj->level]) / 2; 1706 limit = (levels [skill_obj->level + 1] - levels [skill_obj->level]) / 2;
1821 if (exp_to_add > limit) 1707 if (exp_to_add > limit)
1822 exp_to_add = limit; 1708 exp_to_add = limit;
1823 1709
1824 ADD_EXP (skill_obj->stats.exp, exp_to_add); 1710 ADD_EXP (skill_obj->stats.exp, exp_to_add);
1825 if (settings.permanent_exp_ratio) 1711 if (settings.permanent_exp_ratio)
… …
1831 player_lvl_adj (op, skill_obj); 1717 player_lvl_adj (op, skill_obj);
1832 } 1718 }
1833} 1719}
1834 1720
1835/* This function checks to make sure that object 'op' can 1721/* This function checks to make sure that object 'op' can
1836 * lost 'exp' experience. It returns the amount of exp 1722 * lose 'exp' experience. It returns the amount of exp
1837 * object 'op' can in fact lose - it basically makes 1723 * object 'op' can in fact lose - it basically makes
1838 * adjustments based on permanent exp and the like. 1724 * adjustments based on permanent exp and the like.
1839 * This function should always be used for losing experience - 1725 * This function should always be used for losing experience -
1840 * the 'exp' value passed should be positive - this is the 1726 * the 'exp' value passed should be positive - this is the
1841 * amount that should get subtract from the player. 1727 * amount that should get subtract from the player.
1842 */ 1728 */
1843sint64 1729static sint64
1844check_exp_loss (const object *op, sint64 exp) 1730check_exp_loss (const object *op, sint64 exp)
1845{ 1731{
1846 sint64 del_exp; 1732 sint64 del_exp;
1847 1733
1848 if (exp > op->stats.exp) 1734 if (exp > op->stats.exp)
1849 exp = op->stats.exp; 1735 exp = op->stats.exp;
1736
1850 if (settings.permanent_exp_ratio) 1737 if (settings.permanent_exp_ratio)
1851 { 1738 {
1852 del_exp = (sint64) ((op->stats.exp - op->perm_exp) * PERM_EXP_MAX_LOSS_RATIO); 1739 del_exp = (sint64) ((op->stats.exp - op->perm_exp) * PERM_EXP_MAX_LOSS_RATIO);
1740
1853 if (del_exp < 0) 1741 if (del_exp < 0)
1854 del_exp = 0; 1742 del_exp = 0;
1743
1855 if (exp > del_exp) 1744 if (exp > del_exp)
1856 exp = del_exp; 1745 exp = del_exp;
1857 } 1746 }
1747
1858 return exp; 1748 return exp;
1859} 1749}
1860 1750
1861sint64 1751sint64
1862check_exp_adjust (const object *op, sint64 exp) 1752check_exp_adjust (const object *op, sint64 exp)
1863{ 1753{
1864 if (exp < 0) 1754 if (exp < 0)
1865 return check_exp_loss (op, exp); 1755 return check_exp_loss (op, exp);
1866 else 1756 else
1867 return MIN (exp, (sint64) MAX_EXPERIENCE - op->stats.exp); 1757 return min (exp, (sint64)MAX_EXPERIENCE - op->stats.exp);
1868} 1758}
1869
1870 1759
1871/* Subtracts experience from player. 1760/* Subtracts experience from player.
1872 * if skill is set and flag == SK_SUBTRACT_SKILL_EXP, then we 1761 * if skill is set and flag == SK_SUBTRACT_SKILL_EXP, then we
1873 * only subtract from the matching skill. Otherwise, 1762 * only subtract from the matching skill. Otherwise,
1874 * this subtracts a portion from all 1763 * this subtracts a portion from all
… …
1879 * where everything is at the minimum perm exp, he would lose nothing. 1768 * where everything is at the minimum perm exp, he would lose nothing.
1880 * exp is the amount of exp to subtract - thus, it should be 1769 * exp is the amount of exp to subtract - thus, it should be
1881 * a postive number. 1770 * a postive number.
1882 */ 1771 */
1883static void 1772static void
1884subtract_player_exp (object *op, sint64 exp, const char *skill, int flag) 1773subtract_player_exp (object *op, sint64 exp, shstr_tmp skill, int flag)
1885{ 1774{
1886 float fraction = (float) exp / (float) op->stats.exp; 1775 float fraction = (float) exp / (float) op->stats.exp;
1887 object *tmp; 1776 object *tmp;
1888 sint64 del_exp; 1777 sint64 del_exp;
1889 1778
1890 for (tmp = op->inv; tmp; tmp = tmp->below) 1779 for (tmp = op->inv; tmp; tmp = tmp->below)
1891 if (tmp->type == SKILL && tmp->stats.exp) 1780 if (tmp->type == SKILL && tmp->stats.exp)
1892 { 1781 {
1893 if (flag == SK_SUBTRACT_SKILL_EXP && skill && !strcmp (tmp->skill, skill)) 1782 if (flag == SK_SUBTRACT_SKILL_EXP && skill && tmp->skill == skill)
1894 { 1783 {
1895 del_exp = check_exp_loss (tmp, exp); 1784 del_exp = check_exp_loss (tmp, exp);
1896 tmp->stats.exp -= del_exp; 1785 tmp->stats.exp -= del_exp;
1897 player_lvl_adj (op, tmp); 1786 player_lvl_adj (op, tmp);
1898 } 1787 }
1899 else if (flag != SK_SUBTRACT_SKILL_EXP) 1788 else if (flag != SK_SUBTRACT_SKILL_EXP)
1900 { 1789 {
1901 /* only want to process other skills if we are not trying 1790 /* only want to process other skills if we are not trying
1902 * to match a specific skill. 1791 * to match a specific skill.
1903 */ 1792 */
1904 del_exp = check_exp_loss (tmp, (sint64) (tmp->stats.exp * fraction)); 1793 del_exp = check_exp_loss (tmp, tmp->stats.exp * fraction);
1905 tmp->stats.exp -= del_exp; 1794 tmp->stats.exp -= del_exp;
1906 player_lvl_adj (op, tmp); 1795 player_lvl_adj (op, tmp);
1907 } 1796 }
1908 } 1797 }
1909 1798
… …
1923 * skill_name is the skill that should get the exp added. 1812 * skill_name is the skill that should get the exp added.
1924 * flag is what to do if player doesn't have the skill. 1813 * flag is what to do if player doesn't have the skill.
1925 * these last two values are only used for players. 1814 * these last two values are only used for players.
1926 */ 1815 */
1927void 1816void
1928change_exp (object *op, sint64 exp, const char *skill_name, int flag) 1817change_exp (object *op, sint64 exp, shstr_tmp skill_name, int flag)
1929{ 1818{
1930#ifdef EXP_DEBUG 1819#ifdef EXP_DEBUG
1931 LOG (llevDebug, "change_exp() called for %s, exp = %" PRId64 "\n", query_name (op), exp); 1820 LOG (llevDebug, "change_exp() called for %s, exp = %" PRId64 "\n", query_name (op), exp);
1932#endif 1821#endif
1933 1822
… …
1950 * worth. 1839 * worth.
1951 */ 1840 */
1952 if (op->type != PLAYER) 1841 if (op->type != PLAYER)
1953 { 1842 {
1954 /* Sanity check */ 1843 /* Sanity check */
1955 if (!QUERY_FLAG (op, FLAG_ALIVE)) 1844 if (!op->flag [FLAG_ALIVE])
1956 return; 1845 return;
1957 1846
1958 /* reset exp to max allowed value. We subtract from 1847 /* reset exp to max allowed value. We subtract from
1959 * MAX_EXPERIENCE to prevent overflows. If the player somehow has 1848 * MAX_EXPERIENCE to prevent overflows. If the player somehow has
1960 * more than max exp, just return. 1849 * more than max exp, just return.
… …
1986 * amount of permenent experience, whichever gives the lowest loss. 1875 * amount of permenent experience, whichever gives the lowest loss.
1987 */ 1876 */
1988void 1877void
1989apply_death_exp_penalty (object *op) 1878apply_death_exp_penalty (object *op)
1990{ 1879{
1991 object *tmp;
1992 sint64 loss; 1880 sint64 loss;
1993 sint64 percentage_loss; /* defined by the setting 'death_penalty_percent' */ 1881 sint64 percentage_loss; /* defined by the setting 'death_penalty_percent' */
1994 sint64 level_loss; /* defined by the setting 'death_penalty_levels */ 1882 sint64 level_loss; /* defined by the setting 'death_penalty_levels */
1995 1883
1996 for (tmp = op->inv; tmp; tmp = tmp->below) 1884 for (object *tmp = op->inv; tmp; tmp = tmp->below)
1997 if (tmp->type == SKILL && tmp->stats.exp) 1885 if (tmp->type == SKILL && tmp->stats.exp)
1998 { 1886 {
1999
2000 percentage_loss = tmp->stats.exp * settings.death_penalty_ratio / 100; 1887 percentage_loss = tmp->stats.exp * settings.death_penalty_ratio / 100;
2001 level_loss = tmp->stats.exp - levels[MAX (0, tmp->level - settings.death_penalty_level)]; 1888 level_loss = tmp->stats.exp - levels [max (0, tmp->level - settings.death_penalty_level)];
2002 1889
2003 /* With the revised exp system, you can get cases where 1890 /* With the revised exp system, you can get cases where
2004 * losing several levels would still require that you have more 1891 * losing several levels would still require that you have more
2005 * exp than you currently have - this is true if the levels 1892 * exp than you currently have - this is true if the levels
2006 * tables is a lot harder. 1893 * tables is a lot harder.
2007 */ 1894 */
2008 if (level_loss < 0) 1895 if (level_loss < 0)
2009 level_loss = 0; 1896 level_loss = 0;
2010 1897
2011 loss = check_exp_loss (tmp, MIN (level_loss, percentage_loss)); 1898 loss = check_exp_loss (tmp, min (level_loss, percentage_loss));
2012 1899
2013 tmp->stats.exp -= loss; 1900 tmp->stats.exp -= loss;
2014 player_lvl_adj (op, tmp); 1901 player_lvl_adj (op, tmp);
2015 } 1902 }
2016 1903
2017 percentage_loss = op->stats.exp * settings.death_penalty_ratio / 100; 1904 percentage_loss = op->stats.exp * settings.death_penalty_ratio / 100;
2018 level_loss = op->stats.exp - levels[MAX (0, op->level - settings.death_penalty_level)]; 1905 level_loss = op->stats.exp - levels [max (0, op->level - settings.death_penalty_level)];
1906
2019 if (level_loss < 0) 1907 if (level_loss < 0)
2020 level_loss = 0; 1908 level_loss = 0;
1909
2021 loss = check_exp_loss (op, MIN (level_loss, percentage_loss)); 1910 loss = check_exp_loss (op, min (level_loss, percentage_loss));
2022 1911
2023 op->stats.exp -= loss; 1912 op->stats.exp -= loss;
2024 player_lvl_adj (op, NULL); 1913 player_lvl_adj (op, NULL);
2025} 1914}
2026 1915

Diff Legend

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