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.27 by root, Mon Jan 8 20:39:48 2007 UTC vs.
Revision 1.73 by root, Tue Jul 31 18:08:58 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3 3 *
4 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 7 *
8 This program is free software; you can redistribute it and/or modify 8 * Crossfire TRT is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version. 11 * (at your option) any later version.
12 12 *
13 This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details. 16 * GNU General Public License for more details.
17 17 *
18 You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 *
21
22 The authors can be reached via e-mail at <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <crossfire@schmorp.de>
23*/ 22 */
24 23
25#include <global.h> 24#include <global.h>
26#include <funcpoint.h> 25#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
… …
193 "Oh no! You are weakened!", 192 "Oh no! You are weakened!",
194 "You're feeling clumsy!", 193 "You're feeling clumsy!",
195 "You feel less healthy", 194 "You feel less healthy",
196 "You suddenly begin to lose your memory!", 195 "You suddenly begin to lose your memory!",
197 "Watch out, your mind is going!", 196 "Watch out, your mind is going!",
198 "Your spirit feels drained!" 197 "Your spirit feels drained!",
199 "Your face gets distorted!", 198 "Your face gets distorted!",
200}; 199};
201const char *const restore_msg[NUM_STATS] = { 200const char *const restore_msg[NUM_STATS] = {
202 "You feel your strength return.", 201 "You feel your strength return.",
203 "You feel your agility return.", 202 "You feel your agility return.",
204 "You feel your health return.", 203 "You feel your health return.",
205 "You feel your memory return.", 204 "You feel your memory return.",
206 "You feel your wisdom return.", 205 "You feel your wisdom return.",
207 "You feel your spirits return." 206 "You feel your spirits return.",
208 "You feel your charisma return.", 207 "You feel your charisma return.",
209}; 208};
210const char *const gain_msg[NUM_STATS] = { 209const char *const gain_msg[NUM_STATS] = {
211 "You feel stronger.", 210 "You feel stronger.",
212 "You feel more agile.", 211 "You feel more agile.",
213 "You feel healthy.", 212 "You feel healthy.",
214 "You feel smarter.", 213 "You feel smarter.",
215 "You feel wiser.", 214 "You feel wiser.",
216 "You feel more potent." 215 "You feel more potent.",
217 "You seem to look better.", 216 "You seem to look better.",
218}; 217};
219const char *const lose_msg[NUM_STATS] = { 218const char *const lose_msg[NUM_STATS] = {
220 "You feel weaker!", 219 "You feel weaker!",
221 "You feel clumsy!", 220 "You feel clumsy!",
222 "You feel less healthy!", 221 "You feel less healthy!",
223 "You feel stupid!", 222 "You feel stupid!",
224 "You lose some of your memory!", 223 "You lose some of your memory!",
225 "You feel less potent!" 224 "You feel less potent!",
226 "You look ugly!", 225 "You look ugly!",
227}; 226};
228 227
229const char *const statname[NUM_STATS] = { 228const char *const statname[NUM_STATS] = {
230 "strength", "dexterity", "constitution", "intelligence", "wisdom", "power", "charisma" 229 "strength", "dexterity", "constitution", "intelligence", "wisdom", "power", "charisma"
231}; 230};
232 231
233const char *const short_stat_name[NUM_STATS] = { 232const char *const short_stat_name[NUM_STATS] = {
234 "Str", "Dex", "Con", "Int", "Wis", "Pow", "Cha" 233 "Str", "Dex", "Con", "Int", "Wis", "Pow", "Cha"
235}; 234};
236
237/*
238 * sets Str/Dex/con/Wis/Cha/Int/Pow in stats to value, depending on
239 * what attr is (STR to POW).
240 */
241void
242set_attr_value (living *stats, int attr, sint8 value)
243{
244 switch (attr)
245 {
246 case STR:
247 stats->Str = value;
248 break;
249 case DEX:
250 stats->Dex = value;
251 break;
252 case CON:
253 stats->Con = value;
254 break;
255 case WIS:
256 stats->Wis = value;
257 break;
258 case POW:
259 stats->Pow = value;
260 break;
261 case CHA:
262 stats->Cha = value;
263 break;
264 case INT:
265 stats->Int = value;
266 break;
267 }
268}
269 235
270/* 236/*
271 * Like set_attr_value(), but instead the value (which can be negative) 237 * Like set_attr_value(), but instead the value (which can be negative)
272 * is added to the specified stat. 238 * is added to the specified stat.
273 */ 239 */
274void 240void
275change_attr_value (living *stats, int attr, sint8 value) 241change_attr_value (living *stats, int attr, sint8 value)
276{ 242{
277 if (value == 0) 243 stats->stat (attr) += value;
278 return;
279
280 switch (attr)
281 {
282 case STR:
283 stats->Str += value;
284 break;
285 case DEX:
286 stats->Dex += value;
287 break;
288 case CON:
289 stats->Con += value;
290 break;
291 case WIS:
292 stats->Wis += value;
293 break;
294 case POW:
295 stats->Pow += value;
296 break;
297 case CHA:
298 stats->Cha += value;
299 break;
300 case INT:
301 stats->Int += value;
302 break;
303 default:
304 LOG (llevError, "Invalid attribute in change_attr_value: %d\n", attr);
305 }
306}
307
308/*
309 * returns the specified stat. See also set_attr_value().
310 */
311
312sint8
313get_attr_value (const living *stats, int attr)
314{
315 switch (attr)
316 {
317 case STR: return stats->Str;
318 case DEX: return stats->Dex;
319 case CON: return stats->Con;
320 case WIS: return stats->Wis;
321 case CHA: return stats->Cha;
322 case INT: return stats->Int;
323 case POW: return stats->Pow;
324 }
325
326 return 0;
327} 244}
328 245
329/* 246/*
330 * Ensures that all stats (str/dex/con/wis/cha/int) are within the 247 * Ensures that all stats (str/dex/con/wis/cha/int) are within the
331 * 1-30 stat limit. 248 * 1-30 stat limit.
332 */ 249 */
333
334void 250void
335check_stat_bounds (living *stats) 251check_stat_bounds (living *stats)
336{ 252{
337 int i, v;
338
339 for (i = 0; i < NUM_STATS; i++) 253 for (int i = 0; i < NUM_STATS; i++)
340 if ((v = get_attr_value (stats, i)) > MAX_STAT) 254 {
341 set_attr_value (stats, i, MAX_STAT); 255 sint8 &v = stats->stat (i);
342 else if (v < MIN_STAT) 256 v = clamp (v, MIN_STAT, MAX_STAT);
343 set_attr_value (stats, i, MIN_STAT); 257 }
344} 258}
345 259
346#define ORIG_S(xyz,abc) (op->contr->orig_stats.abc) 260#define ORIG_S(xyz,abc) (op->contr->orig_stats.abc)
347 261
348/* Rather than having a whole bunch of if (flag) new_draw.. else new_draw, 262/* Rather than having a whole bunch of if (flag) new_draw.. else new_draw,
… …
357/* flag is set to 1 if we are applying the object, -1 if we are removing 271/* flag is set to 1 if we are applying the object, -1 if we are removing
358 * the object. 272 * the object.
359 * It is the calling functions responsibilty to check to see if the object 273 * It is the calling functions responsibilty to check to see if the object
360 * can be applied or not. 274 * can be applied or not.
361 * The main purpose of calling this function is the messages that are 275 * The main purpose of calling this function is the messages that are
362 * displayed - fix_player should really always be called after this when 276 * displayed - update_stats should really always be called after this when
363 * removing an object - that is because it is impossible to know if some object 277 * removing an object - that is because it is impossible to know if some object
364 * is the only source of an attacktype or spell attunement, so this function 278 * is the only source of an attacktype or spell attunement, so this function
365 * will clear the bits, but the player may still have some other object 279 * will clear the bits, but the player may still have some other object
366 * that gives them that ability. 280 * that gives them that ability.
367 */ 281 */
368int 282int
369change_abil (object *op, object *tmp) 283change_abil (object *op, object *tmp)
370{ 284{
371 int flag = QUERY_FLAG (tmp, FLAG_APPLIED) ? 1 : -1, i, j, success = 0; 285 int flag = QUERY_FLAG (tmp, FLAG_APPLIED) ? 1 : -1, success = 0;
372 char message[MAX_BUF]; 286 char message[MAX_BUF];
373 int potion_max = 0; 287 int potion_max = 0;
374 288
375 /* remember what object was like before it was changed. note that 289 /* remember what object was like before it was changed. note that
376 * refop is a local copy of op only to be used for detecting changes 290 * refop is a local copy of op only to be used for detecting changes
… …
381 if (op->type == PLAYER) 295 if (op->type == PLAYER)
382 { 296 {
383 if (tmp->type == POTION) 297 if (tmp->type == POTION)
384 { 298 {
385 potion_max = 1; 299 potion_max = 1;
386 for (j = 0; j < NUM_STATS; j++) 300 for (int j = 0; j < NUM_STATS; j++)
387 { 301 {
388 int nstat, ostat; 302 int ostat = op->contr->orig_stats.stat (j);
389 303 int i = tmp->stats.stat (j);
390 ostat = get_attr_value (&(op->contr->orig_stats), j);
391 i = get_attr_value (&(tmp->stats), j);
392 304
393 /* nstat is what the stat will be after use of the potion */ 305 /* nstat is what the stat will be after use of the potion */
394 nstat = flag * i + ostat; 306 int nstat = flag * i + ostat;
395 307
396 /* Do some bounds checking. While I don't think any 308 /* Do some bounds checking. While I don't think any
397 * potions do so right now, there is the potential for potions 309 * potions do so right now, there is the potential for potions
398 * 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
399 * to allow for that. 311 * to allow for that.
400 */ 312 */
401 if (nstat < 1 && i * flag < 0) 313 if (nstat < 1 && i * flag < 0)
402 nstat = 1; 314 nstat = 1;
403 else if (nstat > 20 + get_attr_value (&(op->arch->clone.stats), j)) 315 else if (nstat > 20 + op->arch->stats.stat (j))
404 { 316 nstat = 20 + op->arch->stats.stat (j);
405 nstat = 20 + get_attr_value (&(op->arch->clone.stats), j);
406 }
407 317
408 if (nstat != ostat) 318 if (nstat != ostat)
409 { 319 {
410 set_attr_value (&(op->contr->orig_stats), j, nstat); 320 op->contr->orig_stats.stat (j) = nstat;
411 potion_max = 0; 321 potion_max = 0;
412 } 322 }
413 else if (i) 323 else if (i)
414 { 324 {
415 /* potion is useless - player has already hit the natural maximum */ 325 /* potion is useless - player has already hit the natural maximum */
… …
419 329
420 /* This section of code ups the characters normal stats also. I am not 330 /* This section of code ups the characters normal stats also. I am not
421 * sure if this is strictly necessary, being that fix_player probably 331 * sure if this is strictly necessary, being that fix_player probably
422 * recalculates this anyway. 332 * recalculates this anyway.
423 */ 333 */
424 for (j = 0; j < NUM_STATS; j++) 334 for (int j = 0; j < NUM_STATS; j++)
425 change_attr_value (&(op->stats), j, flag * get_attr_value (&(tmp->stats), j)); 335 change_attr_value (&op->stats, j, flag * tmp->stats.stat (j));
426 336
427 check_stat_bounds (&(op->stats)); 337 check_stat_bounds (&op->stats);
428 } /* end of potion handling code */ 338 } /* end of potion handling code */
429 } 339 }
430 340
431 /* reset attributes that fix_player doesn't reset since it doesn't search 341 /* reset attributes that update_stats doesn't reset since it doesn't search
432 * everything to set 342 * everything to set
433 */ 343 */
434 if (flag == -1) 344 if (flag == -1)
435 { 345 {
436 op->attacktype &= ~tmp->attacktype; 346 op->attacktype &= ~tmp->attacktype;
437 op->path_attuned &= ~tmp->path_attuned; 347 op->path_attuned &= ~tmp->path_attuned;
438 op->path_repelled &= ~tmp->path_repelled; 348 op->path_repelled &= ~tmp->path_repelled;
439 op->path_denied &= ~tmp->path_denied; 349 op->path_denied &= ~tmp->path_denied;
440 /* Presuming here that creatures only have move_type, 350 /* Presuming here that creatures only have move_type,
441 * and not the other move_ fields. 351 * and not the other move_ fields.
442 */ 352 */
443 op->move_type &= ~tmp->move_type; 353 op->move_type &= ~tmp->move_type;
444 } 354 }
445 355
446 /* call fix_player since op object could have whatever attribute due 356 /* call fix_player since op object could have whatever attribute due
447 * to multiple items. if fix_player always has to be called after 357 * to multiple items. if update_stats always has to be called after
448 * change_ability then might as well call it from here 358 * change_ability then might as well call it from here
449 */ 359 */
450 op->update_stats (); 360 op->update_stats ();
451 361
452 /* Fix player won't add the bows ability to the player, so don't 362 /* update_stats won't add the bows ability to the player, so don't
453 * print out message if this is a bow. 363 * print out message if this is a bow.
454 */ 364 */
455 if (tmp->attacktype & AT_CONFUSION && tmp->type != BOW) 365 if (tmp->attacktype & AT_CONFUSION && tmp->type != BOW)
456 { 366 {
457 success = 1; 367 success = 1;
… …
497 if (tmp->move_type & MOVE_FLY_HIGH) 407 if (tmp->move_type & MOVE_FLY_HIGH)
498 { 408 {
499 /* double conditional - second case covers if you have move_fly_low - 409 /* double conditional - second case covers if you have move_fly_low -
500 * in that case, you don't actually land 410 * in that case, you don't actually land
501 */ 411 */
502 DIFF_MSG (flag, "You soar into the air air!.", 412 DIFF_MSG (flag, "You soar into the air!",
503 (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."));
504 } 414 }
415
505 if (tmp->move_type & MOVE_SWIM) 416 if (tmp->move_type & MOVE_SWIM)
506 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");
507 418
508 /* Changing move status may mean you are affected by things you weren't before */ 419 /* Changing move status may mean you are affected by things you weren't before */
509 check_move_on (op, op); 420 check_move_on (op, op);
510 } 421 }
511 422
512 /* becoming UNDEAD... a special treatment for this flag. Only those not 423 /* becoming UNDEAD... a special treatment for this flag. Only those not
513 * originally undead may change their status 424 * originally undead may change their status
514 */ 425 */
515 if (!QUERY_FLAG (&op->arch->clone, FLAG_UNDEAD)) 426 if (!QUERY_FLAG (op->arch, FLAG_UNDEAD))
516 if (QUERY_FLAG (op, FLAG_UNDEAD) != QUERY_FLAG (&refop, FLAG_UNDEAD)) 427 if (QUERY_FLAG (op, FLAG_UNDEAD) != QUERY_FLAG (&refop, FLAG_UNDEAD))
517 { 428 {
518 success = 1; 429 success = 1;
519 if (flag > 0) 430 if (flag > 0)
520 { 431 {
521 op->race = "undead"; 432 op->race = "undead";
522 new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce drains away!"); 433 new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce drains away!");
523 } 434 }
524 else 435 else
525 { 436 {
526 op->race = op->arch->clone.race; 437 op->race = op->arch->race;
527 new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce returns!"); 438 new_draw_info (NDI_UNIQUE, 0, op, "Your lifeforce returns!");
528 } 439 }
529 } 440 }
530 441
531 if (QUERY_FLAG (op, FLAG_STEALTH) != QUERY_FLAG (&refop, FLAG_STEALTH)) 442 if (QUERY_FLAG (op, FLAG_STEALTH) != QUERY_FLAG (&refop, FLAG_STEALTH))
… …
637 success = 1; 548 success = 1;
638 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.");
639 } 550 }
640 551
641 /* Messages for changed resistance */ 552 /* Messages for changed resistance */
642 for (i = 0; i < NROFATTACKS; i++) 553 for (int i = 0; i < NROFATTACKS; i++)
643 { 554 {
644 if (i == ATNR_PHYSICAL) 555 if (i == ATNR_PHYSICAL)
645 continue; /* Don't display about armour */ 556 continue; /* Don't display about armour */
646 557
647 if (op->resist[i] != refop.resist[i]) 558 if (op->resist[i] != refop.resist[i])
… …
656 } 567 }
657 } 568 }
658 569
659 if (!potion_max) 570 if (!potion_max)
660 { 571 {
661 for (j = 0; j < NUM_STATS; j++) 572 for (int j = 0; j < NUM_STATS; j++)
662 { 573 {
663 if ((i = get_attr_value (&(tmp->stats), j)) != 0) 574 if (int i = tmp->stats.stat (j))
664 { 575 {
665 success = 1; 576 success = 1;
666 DIFF_MSG (i * flag, gain_msg[j], lose_msg[j]); 577 DIFF_MSG (i * flag, gain_msg[j], lose_msg[j]);
667 } 578 }
668 } 579 }
… …
673 584
674/* 585/*
675 * Stat draining by Vick 930307 586 * Stat draining by Vick 930307
676 * (Feeling evil, I made it work as well now. -Frank 8) 587 * (Feeling evil, I made it work as well now. -Frank 8)
677 */ 588 */
678
679void 589void
680object::drain_stat () 590object::drain_stat ()
681{ 591{
682 drain_specific_stat (RANDOM () % NUM_STATS); 592 drain_specific_stat (rndm (NUM_STATS));
683} 593}
684 594
685void 595void
686object::drain_specific_stat (int deplete_stats) 596object::drain_specific_stat (int deplete_stats)
687{ 597{
… …
755 return; 665 return;
756 666
757 /* Randomly change the players luck. Basically, we move it 667 /* Randomly change the players luck. Basically, we move it
758 * back neutral (if greater>0, subtract, otherwise add) 668 * back neutral (if greater>0, subtract, otherwise add)
759 */ 669 */
760 if (RANDOM () % (FABS (tmp->stats.luck)) >= RANDOM () % 30) 670 if (rndm (abs (tmp->stats.luck)) >= rndm (30))
761 { 671 {
762 int diff = tmp->stats.luck > 0 ? -1 : 1; 672 int diff = tmp->stats.luck > 0 ? -1 : 1;
763 673
764 stats.luck += diff; 674 stats.luck += diff;
765 tmp->stats.luck += diff; 675 tmp->stats.luck += diff;
… …
772 * Subtracts stat-bonuses given by the class which the player has chosen. 682 * Subtracts stat-bonuses given by the class which the player has chosen.
773 */ 683 */
774void 684void
775object::remove_statbonus () 685object::remove_statbonus ()
776{ 686{
777 stats.Str -= arch->clone.stats.Str; 687 for (int i = 0; i < NUM_STATS; ++i)
778 stats.Dex -= arch->clone.stats.Dex; 688 {
779 stats.Con -= arch->clone.stats.Con; 689 sint8 v = arch->stats.stat (i);
780 stats.Wis -= arch->clone.stats.Wis; 690 stats.stat (i) -= v;
781 stats.Pow -= arch->clone.stats.Pow; 691 contr->orig_stats.stat (i) -= v;
782 stats.Cha -= arch->clone.stats.Cha; 692 }
783 stats.Int -= arch->clone.stats.Int;
784
785 contr->orig_stats.Str -= arch->clone.stats.Str;
786 contr->orig_stats.Dex -= arch->clone.stats.Dex;
787 contr->orig_stats.Con -= arch->clone.stats.Con;
788 contr->orig_stats.Wis -= arch->clone.stats.Wis;
789 contr->orig_stats.Pow -= arch->clone.stats.Pow;
790 contr->orig_stats.Cha -= arch->clone.stats.Cha;
791 contr->orig_stats.Int -= arch->clone.stats.Int;
792} 693}
793 694
794/* 695/*
795 * Adds stat-bonuses given by the class which the player has chosen. 696 * Adds stat-bonuses given by the class which the player has chosen.
796 */ 697 */
797void 698void
798object::add_statbonus () 699object::add_statbonus ()
799{ 700{
800 stats.Str += arch->clone.stats.Str; 701 for (int i = 0; i < NUM_STATS; ++i)
801 stats.Dex += arch->clone.stats.Dex; 702 {
802 stats.Con += arch->clone.stats.Con; 703 sint8 v = arch->stats.stat (i);
803 stats.Wis += arch->clone.stats.Wis; 704 stats.stat (i) += v;
804 stats.Pow += arch->clone.stats.Pow; 705 contr->orig_stats.stat (i) += v;
805 stats.Cha += arch->clone.stats.Cha; 706 }
806 stats.Int += arch->clone.stats.Int;
807
808 contr->orig_stats.Str += arch->clone.stats.Str;
809 contr->orig_stats.Dex += arch->clone.stats.Dex;
810 contr->orig_stats.Con += arch->clone.stats.Con;
811 contr->orig_stats.Wis += arch->clone.stats.Wis;
812 contr->orig_stats.Pow += arch->clone.stats.Pow;
813 contr->orig_stats.Cha += arch->clone.stats.Cha;
814 contr->orig_stats.Int += arch->clone.stats.Int;
815} 707}
816 708
817/* 709/*
818 * Updates all abilities given by applied objects in the inventory 710 * Updates all abilities given by applied objects in the inventory
819 * of the given object. Note: This function works for both monsters 711 * of the given object. Note: This function works for both monsters
820 * and players; the "player" in the name is purely an archaic inheritance. 712 * and players; the "player" in the name is purely an archaic inheritance.
821 * This functions starts from base values (archetype or player object) 713 * This functions starts from base values (archetype or player object)
822 * and then adjusts them according to what the player has equipped. 714 * and then adjusts them according to what the player has equipped.
823 */ 715 *
824
825/* July 95 - inserted stuff to handle new skills/exp system - b.t. 716 * July 95 - inserted stuff to handle new skills/exp system - b.t.
826 spell system split, grace points now added to system --peterm 717 * spell system split, grace points now added to system --peterm
827 */ 718 */
828
829void 719void
830object::update_stats () 720object::update_stats ()
831{ 721{
832 int i, j; 722 int i, j;
833 float f, max = 9, added_speed = 0, bonus_speed = 0, sp_tmp, speed_reduce_from_disease = 1; 723 float f, max = 9, added_speed = 0, bonus_speed = 0, sp_tmp, speed_reduce_from_disease = 1;
834 int weapon_weight = 0, weapon_speed = 0; 724 int weapon_weight = 0, weapon_speed = 0;
835 int best_wc = 0, best_ac = 0, wc = 0, ac = 0; 725 int best_wc = 0, best_ac = 0, wc = 0, ac = 0;
836 int prot[NROFATTACKS], vuln[NROFATTACKS], potion_resist[NROFATTACKS]; 726 int prot[NROFATTACKS], vuln[NROFATTACKS], potion_resist[NROFATTACKS];
837 object *grace_obj = NULL, *mana_obj = NULL, *wc_obj = NULL, *tmp; 727 object *grace_obj = NULL, *mana_obj = NULL, *tmp;
838 float old_speed = speed; 728 float old_speed = speed;
839 729
840 /* First task is to clear all the values back to their original values */ 730 /* First task is to clear all the values back to their original values */
841 if (type == PLAYER) 731 if (type == PLAYER)
842 { 732 {
843 for (i = 0; i < NUM_STATS; i++) 733 for (i = 0; i < NUM_STATS; i++)
844 set_attr_value (&(stats), i, get_attr_value (&(contr->orig_stats), i)); 734 stats.stat (i) = contr->orig_stats.stat (i);
845 735
846 if (settings.spell_encumbrance == TRUE) 736 if (settings.spell_encumbrance == TRUE)
847 contr->encumbrance = 0; 737 contr->encumbrance = 0;
848 738
849 attacktype = 0; 739 attacktype = 0;
740
850 contr->digestion = 0; 741 contr->digestion = 0;
851 contr->gen_hp = 0; 742 contr->gen_hp = 0;
852 contr->gen_sp = 0; 743 contr->gen_sp = 0;
853 contr->gen_grace = 0; 744 contr->gen_grace = 0;
854 contr->gen_sp_armour = 10; 745 contr->gen_sp_armour = 10;
855 contr->item_power = 0; 746 contr->item_power = 0;
856
857 /* Don't clobber all the range_ values. range_golem otherwise
858 * gets reset for no good reason, and we don't want to reset
859 * range_magic (what spell is readied). These three below
860 * well get filled in based on what the player has equipped.
861 */
862 contr->ranges[range_bow] = NULL;
863 contr->ranges[range_misc] = NULL;
864 contr->ranges[range_skill] = NULL;
865 } 747 }
866 748
867 memcpy (body_used, body_info, sizeof (body_info)); 749 for (int i = NUM_BODY_LOCATIONS; i--; )
750 slot[i].used = slot[i].info;
868 751
869 slaying = 0; 752 slaying = 0;
870 753
871 if (!QUERY_FLAG (this, FLAG_WIZ)) 754 if (!QUERY_FLAG (this, FLAG_WIZ))
872 { 755 {
… …
876 759
877 CLEAR_FLAG (this, FLAG_LIFESAVE); 760 CLEAR_FLAG (this, FLAG_LIFESAVE);
878 CLEAR_FLAG (this, FLAG_STEALTH); 761 CLEAR_FLAG (this, FLAG_STEALTH);
879 CLEAR_FLAG (this, FLAG_BLIND); 762 CLEAR_FLAG (this, FLAG_BLIND);
880 763
881 if (!QUERY_FLAG (&arch->clone, FLAG_REFL_SPELL )) CLEAR_FLAG (this, FLAG_REFL_SPELL); 764 if (!QUERY_FLAG (arch, FLAG_REFL_SPELL )) CLEAR_FLAG (this, FLAG_REFL_SPELL);
882 if (!QUERY_FLAG (&arch->clone, FLAG_REFL_MISSILE)) CLEAR_FLAG (this, FLAG_REFL_MISSILE); 765 if (!QUERY_FLAG (arch, FLAG_REFL_MISSILE)) CLEAR_FLAG (this, FLAG_REFL_MISSILE);
883 if (!QUERY_FLAG (&arch->clone, FLAG_UNDEAD )) CLEAR_FLAG (this, FLAG_UNDEAD); 766 if (!QUERY_FLAG (arch, FLAG_UNDEAD )) CLEAR_FLAG (this, FLAG_UNDEAD);
884 if (!QUERY_FLAG (&arch->clone, FLAG_SEE_IN_DARK )) CLEAR_FLAG (this, FLAG_SEE_IN_DARK); 767 if (!QUERY_FLAG (arch, FLAG_SEE_IN_DARK )) CLEAR_FLAG (this, FLAG_SEE_IN_DARK);
885 768
886 path_attuned = arch->clone.path_attuned; 769 path_attuned = arch->path_attuned;
887 path_repelled = arch->clone.path_repelled; 770 path_repelled = arch->path_repelled;
888 path_denied = arch->clone.path_denied; 771 path_denied = arch->path_denied;
889 glow_radius = arch->clone.glow_radius; 772 glow_radius = arch->glow_radius;
890 move_type = arch->clone.move_type; 773 move_type = arch->move_type;
774
891 chosen_skill = NULL; 775 chosen_skill = 0;
892 776
893 /* initializing resistances from the values in player/monster's 777 /* initializing resistances from the values in player/monster's
894 * archetype clone 778 * archetype clone
895 */ 779 */
896 memcpy (&resist, &arch->clone.resist, sizeof (resist)); 780 memcpy (&resist, &arch->resist, sizeof (resist));
897 781
898 for (i = 0; i < NROFATTACKS; i++) 782 for (i = 0; i < NROFATTACKS; i++)
899 { 783 {
900 if (resist[i] > 0) 784 if (resist[i] > 0)
901 prot[i] = resist[i], vuln[i] = 0; 785 prot[i] = resist[i], vuln[i] = 0;
902 else 786 else
903 vuln[i] = -(resist[i]), prot[i] = 0; 787 vuln[i] = -(resist[i]), prot[i] = 0;
788
904 potion_resist[i] = 0; 789 potion_resist[i] = 0;
905 } 790 }
906 791
907 wc = arch->clone.stats.wc; 792 wc = arch->stats.wc;
908 stats.dam = arch->clone.stats.dam; 793 stats.dam = arch->stats.dam;
909 794
910 /* for players which cannot use armour, they gain AC -1 per 3 levels, 795 /* for players which cannot use armour, they gain AC -1 per 3 levels,
911 * plus a small amount of physical resist, those poor suckers. ;) 796 * plus a small amount of physical resist, those poor suckers. ;)
912 * the fact that maxlevel is factored in could be considered sort of bogus - 797 * the fact that maxlevel is factored in could be considered sort of bogus -
913 * we should probably give them some bonus and cap it off - otherwise, 798 * we should probably give them some bonus and cap it off - otherwise,
914 * basically, if a server updates its max level, these playes may find 799 * basically, if a server updates its max level, these playes may find
915 * that their protection from physical goes down 800 * that their protection from physical goes down
916 */ 801 */
917 if (!QUERY_FLAG (this, FLAG_USE_ARMOUR) && type == PLAYER) 802 if (!QUERY_FLAG (this, FLAG_USE_ARMOUR) && type == PLAYER)
918 { 803 {
919 ac = MAX (-10, arch->clone.stats.ac - level / 3); 804 ac = MAX (-10, arch->stats.ac - level / 3);
920 prot[ATNR_PHYSICAL] += ((100 - prot[AT_PHYSICAL]) * (80 * level / settings.max_level)) / 100; 805 prot[ATNR_PHYSICAL] += ((100 - prot[AT_PHYSICAL]) * (80 * level / settings.max_level)) / 100;
921 } 806 }
922 else 807 else
923 ac = arch->clone.stats.ac; 808 ac = arch->stats.ac;
924 809
925 stats.luck = arch->clone.stats.luck; 810 stats.luck = arch->stats.luck;
926 speed = arch->clone.speed; 811 speed = arch->speed;
927 812
928 /* OK - we've reset most all the objects attributes to sane values. 813 /* OK - we've reset most all the objects attributes to sane values.
929 * now go through and make adjustments for what the player has equipped. 814 * now go through and make adjustments for what the player has equipped.
930 */ 815 */
931
932 for (tmp = inv; tmp; tmp = tmp->below) 816 for (tmp = inv; tmp; tmp = tmp->below)
933 { 817 {
818 /* This happens because apply_potion calls change_abil with the potion
819 * applied so we can tell the player what changed. But change_abil
820 * then calls this function.
821 */
822 if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == POTION)
823 continue;
824
934 /* See note in map.c:update_position about making this additive 825 /* See note in map.c:update_position about making this additive
935 * since light sources are never applied, need to put check here. 826 * since light sources are never applied, need to put check here.
936 */ 827 */
937 if (tmp->glow_radius > glow_radius) 828 if (tmp->glow_radius > glow_radius)
938 glow_radius = tmp->glow_radius; 829 glow_radius = tmp->glow_radius;
939
940 /* This happens because apply_potion calls change_abil with the potion
941 * applied so we can tell the player what chagned. But change_abil
942 * then calls this function.
943 */
944 if (QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type == POTION)
945 continue;
946 830
947 /* For some things, we don't care what is equipped */ 831 /* For some things, we don't care what is equipped */
948 if (tmp->type == SKILL) 832 if (tmp->type == SKILL)
949 { 833 {
950 /* Want to take the highest skill here. */ 834 /* Want to take the highest skill here. */
… …
972 * in the praying skill, and the player should always get those. 856 * in the praying skill, and the player should always get those.
973 * It also means we need to put in additional checks for applied below, 857 * It also means we need to put in additional checks for applied below,
974 * because the skill shouldn't count against body positions being used 858 * because the skill shouldn't count against body positions being used
975 * up, etc. 859 * up, etc.
976 */ 860 */
977 if ((QUERY_FLAG (tmp, FLAG_APPLIED) && tmp->type != CONTAINER && tmp->type != CLOSE_CON) || 861 if ((tmp->flag [FLAG_APPLIED]
862 && tmp->type != CONTAINER
863 && tmp->type != CLOSE_CON)
864 || (tmp->type == SKILL
978 (tmp->type == SKILL && tmp->subtype == SK_PRAYING)) 865 && tmp->subtype == SK_PRAYING))
979 { 866 {
980 if (type == PLAYER) 867 if (type == PLAYER)
981 { 868 {
982 if (tmp->type == BOW) 869 contr->item_power += tmp->item_power;
983 contr->ranges[range_bow] = tmp;
984 870
985 if (tmp->type == WAND || tmp->type == ROD || tmp->type == HORN) 871 if (tmp == contr->combat_ob || tmp == contr->ranged_ob)
986 contr->ranges[range_misc] = tmp; 872 if (tmp != current_weapon
873 && (tmp->type != SKILL || tmp->subtype != SK_PRAYING)
874 && !tmp->flag [FLAG_CURSED]
875 && !tmp->flag [FLAG_DAMNED])
876 continue;
987 877
988 for (i = 0; i < NUM_STATS; i++) 878 for (i = 0; i < NUM_STATS; i++)
989 change_attr_value (&(stats), i, get_attr_value (&(tmp->stats), i)); 879 change_attr_value (&stats, i, tmp->stats.stat (i));
990 880
991 /* these are the items that currently can change digestion, regeneration, 881 /* These are the items that currently can change digestion, regeneration,
992 * spell point recovery and mana point recovery. Seems sort of an arbitary 882 * spell point recovery and mana point recovery. Seems sort of an arbitary
993 * list, but other items store other info into stats array. 883 * list, but other items store other info into stats array.
994 */ 884 */
995 if ((tmp->type == WEAPON) || 885 if (tmp->type == WEAPON || tmp->type == BOW ||
996 (tmp->type == ARMOUR) || (tmp->type == HELMET) || 886 tmp->type == ARMOUR || tmp->type == HELMET ||
997 (tmp->type == SHIELD) || (tmp->type == RING) || 887 tmp->type == SHIELD || tmp->type == RING ||
998 (tmp->type == BOOTS) || (tmp->type == GLOVES) || 888 tmp->type == BOOTS || tmp->type == GLOVES ||
999 (tmp->type == AMULET) || (tmp->type == GIRDLE) || 889 tmp->type == AMULET || tmp->type == GIRDLE ||
1000 (tmp->type == BRACERS) || (tmp->type == CLOAK) || 890 tmp->type == BRACERS || tmp->type == CLOAK ||
1001 (tmp->type == DISEASE) || (tmp->type == FORCE) || 891 tmp->type == DISEASE || tmp->type == FORCE ||
1002 (tmp->type == SKILL)) 892 tmp->type == SKILL)
1003 { 893 {
1004 contr->digestion += tmp->stats.food; 894 contr->digestion = clamp (int (contr->digestion) + tmp->stats.food, MIN_DIGESTION, MAX_DIGESTION);
1005 contr->gen_hp += tmp->stats.hp; 895 contr->gen_hp += tmp->stats.hp;
1006 contr->gen_sp += tmp->stats.sp; 896 contr->gen_sp += tmp->stats.sp;
1007 contr->gen_grace += tmp->stats.grace; 897 contr->gen_grace += tmp->stats.grace;
1008 contr->gen_sp_armour += tmp->gen_sp_armour; 898 contr->gen_sp_armour += tmp->gen_sp_armour;
1009 contr->item_power += tmp->item_power;
1010 } 899 }
1011 } /* if this is a player */ 900 } /* if this is a player */
901 else
902 {
903 if (tmp->type == WEAPON)
904 current_weapon = tmp;
905 }
1012 906
1013 /* Update slots used for items */ 907 /* Update slots used for items */
1014 if (QUERY_FLAG (tmp, FLAG_APPLIED)) 908 if (QUERY_FLAG (tmp, FLAG_APPLIED))
1015 for (i = 0; i < NUM_BODY_LOCATIONS; i++) 909 for (i = 0; i < NUM_BODY_LOCATIONS; i++)
1016 body_used[i] += tmp->body_info[i]; 910 slot[i].used += tmp->slot[i].info;
1017 911
1018 if (tmp->type == SYMPTOM) 912 if (tmp->type == SYMPTOM)
1019 { 913 {
1020 speed_reduce_from_disease = tmp->last_sp / 100.0; 914 speed_reduce_from_disease = tmp->last_sp / 100.f;
915
1021 if (speed_reduce_from_disease == 0) 916 if (speed_reduce_from_disease == 0)
1022 speed_reduce_from_disease = 1; 917 speed_reduce_from_disease = 1;
1023 } 918 }
1024 919
1025 /* Pos. and neg. protections are counted seperate (-> pro/vuln). 920 /* Pos. and neg. protections are counted seperate (-> pro/vuln).
1026 * (Negative protections are calculated extactly like positive.) 921 * (Negative protections are calculated exactly like positive.)
1027 * Resistance from potions are treated special as well. If there's 922 * Resistance from potions are treated special as well. If there's
1028 * more than one potion-effect, the bigger prot.-value is taken. 923 * more than one potion-effect, the bigger prot.-value is taken.
1029 */ 924 */
1030 if (tmp->type != POTION) 925 if (tmp->type != POTION)
1031 { 926 {
… …
1040 potion_resist[i] = MAX (potion_resist[i], tmp->resist[i]); 935 potion_resist[i] = MAX (potion_resist[i], tmp->resist[i]);
1041 else 936 else
1042 potion_resist[i] = tmp->resist[i]; 937 potion_resist[i] = tmp->resist[i];
1043 } 938 }
1044 else if (tmp->resist[i] > 0) 939 else if (tmp->resist[i] > 0)
1045 prot[i] += ((100 - prot[i]) * tmp->resist[i]) / 100; 940 prot[i] += ((100 - prot[i]) * tmp->resist[i]) / 100;
1046 else if (tmp->resist[i] < 0) 941 else if (tmp->resist[i] < 0)
1047 vuln[i] += ((100 - vuln[i]) * (-tmp->resist[i])) / 100; 942 vuln[i] += ((100 - vuln[i]) * -tmp->resist[i]) / 100;
1048 } 943 }
1049 } 944 }
1050 945
1051 /* There may be other things that should not adjust the attacktype */ 946 /* There may be other things that should not adjust the attacktype */
1052 if (tmp->type != BOW && tmp->type != SYMPTOM) 947 if (tmp->type != SYMPTOM)
948 {
1053 attacktype |= tmp->attacktype; 949 attacktype |= tmp->attacktype;
1054
1055 path_attuned |= tmp->path_attuned; 950 path_attuned |= tmp->path_attuned;
1056 path_repelled |= tmp->path_repelled; 951 path_repelled |= tmp->path_repelled;
1057 path_denied |= tmp->path_denied; 952 path_denied |= tmp->path_denied;
953 move_type |= tmp->move_type;
1058 stats.luck += tmp->stats.luck; 954 stats.luck += tmp->stats.luck;
1059 move_type |= tmp->move_type; 955 }
1060 956
1061 if (QUERY_FLAG (tmp, FLAG_LIFESAVE )) SET_FLAG (this, FLAG_LIFESAVE); 957 if (QUERY_FLAG (tmp, FLAG_LIFESAVE )) SET_FLAG (this, FLAG_LIFESAVE);
1062 if (QUERY_FLAG (tmp, FLAG_REFL_SPELL )) SET_FLAG (this, FLAG_REFL_SPELL); 958 if (QUERY_FLAG (tmp, FLAG_REFL_SPELL )) SET_FLAG (this, FLAG_REFL_SPELL);
1063 if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE)) SET_FLAG (this, FLAG_REFL_MISSILE); 959 if (QUERY_FLAG (tmp, FLAG_REFL_MISSILE)) SET_FLAG (this, FLAG_REFL_MISSILE);
1064 if (QUERY_FLAG (tmp, FLAG_STEALTH )) SET_FLAG (this, FLAG_STEALTH); 960 if (QUERY_FLAG (tmp, FLAG_STEALTH )) SET_FLAG (this, FLAG_STEALTH);
1065 if (QUERY_FLAG (tmp, FLAG_XRAYS )) SET_FLAG (this, FLAG_XRAYS); 961 if (QUERY_FLAG (tmp, FLAG_XRAYS )) SET_FLAG (this, FLAG_XRAYS);
1066 if (QUERY_FLAG (tmp, FLAG_BLIND )) SET_FLAG (this, FLAG_BLIND); 962 if (QUERY_FLAG (tmp, FLAG_BLIND )) SET_FLAG (this, FLAG_BLIND);
1067 if (QUERY_FLAG (tmp, FLAG_SEE_IN_DARK )) SET_FLAG (this, FLAG_SEE_IN_DARK); 963 if (QUERY_FLAG (tmp, FLAG_SEE_IN_DARK )) SET_FLAG (this, FLAG_SEE_IN_DARK);
1068 964
1069 if (QUERY_FLAG (tmp, FLAG_UNDEAD) && !QUERY_FLAG (&arch->clone, FLAG_UNDEAD)) 965 if (QUERY_FLAG (tmp, FLAG_UNDEAD) && !QUERY_FLAG (arch, FLAG_UNDEAD))
1070 SET_FLAG (this, FLAG_UNDEAD); 966 SET_FLAG (this, FLAG_UNDEAD);
1071 967
1072 if (QUERY_FLAG (tmp, FLAG_MAKE_INVIS)) 968 if (QUERY_FLAG (tmp, FLAG_MAKE_INVIS))
1073 { 969 {
1074 SET_FLAG (this, FLAG_MAKE_INVIS); 970 SET_FLAG (this, FLAG_MAKE_INVIS);
… …
1077 973
1078 if (tmp->stats.exp && tmp->type != SKILL) 974 if (tmp->stats.exp && tmp->type != SKILL)
1079 { 975 {
1080 if (tmp->stats.exp > 0) 976 if (tmp->stats.exp > 0)
1081 { 977 {
1082 added_speed += (float) tmp->stats.exp / 3.0; 978 added_speed += tmp->stats.exp / 3.f;
1083 bonus_speed += 1.0 + (float) tmp->stats.exp / 3.0; 979 bonus_speed += tmp->stats.exp / 3.f + 1.f;
1084 } 980 }
1085 else 981 else
1086 added_speed += (float) tmp->stats.exp; 982 added_speed += tmp->stats.exp;
1087 } 983 }
1088 984
1089 switch (tmp->type) 985 switch (tmp->type)
1090 { 986 {
987#if 0
988 case WAND:
989 case ROD:
990 case HORN:
991 if (type != PLAYER || current_weapon == tmp)
992 chosen_skill = tmp;
993 break;
994#endif
995
1091 /* skills modifying the character -b.t. */ 996 /* skills modifying the character -b.t. */
1092 /* for all skills and skill granting objects */ 997 /* for all skills and skill granting objects */
1093 case SKILL: 998 case SKILL:
1094 if (!QUERY_FLAG (tmp, FLAG_APPLIED)) 999 {
1000 if (!QUERY_FLAG (tmp, FLAG_APPLIED) || skill_flags [tmp->subtype] & SF_APPLY)
1095 break; 1001 break;
1096 1002
1097 if (IS_COMBAT_SKILL (tmp->subtype))
1098 wc_obj = tmp;
1099
1100 if (chosen_skill) 1003 if (chosen_skill)
1004 {
1101 LOG (llevDebug, "fix_player, op %s has multiple skills applied\n", &name); 1005 LOG (llevDebug, "fix_player, op %s has multiple skills applied (%s and %s)\n",
1006 &name, &chosen_skill->name, &tmp->name);
1102 1007
1008 tmp->flag [FLAG_APPLIED] = false;
1009 update_stats ();
1010 return;
1011 }
1012 else
1103 chosen_skill = tmp; 1013 chosen_skill = tmp;
1104 1014
1105 if (tmp->stats.dam > 0) 1015 if (tmp->stats.dam > 0)
1106 { /* skill is a 'weapon' */ 1016 { /* skill is a 'weapon' */
1107 if (!QUERY_FLAG (this, FLAG_READY_WEAPON)) 1017 if (!QUERY_FLAG (this, FLAG_READY_WEAPON))
1108 weapon_speed = (int) WEAPON_SPEED (tmp); 1018 weapon_speed = WEAPON_SPEED (tmp);
1109 1019
1110 if (weapon_speed < 0) 1020 if (weapon_speed < 0)
1111 weapon_speed = 0; 1021 weapon_speed = 0;
1112 1022
1113 weapon_weight = tmp->weight; 1023 weapon_weight = tmp->weight;
1114 stats.dam += tmp->stats.dam * (1 + (chosen_skill->level / 9)); 1024 stats.dam += 1 + chosen_skill->level * tmp->stats.dam / 9;
1115 1025
1116 if (tmp->magic) 1026 if (tmp->magic)
1117 stats.dam += tmp->magic; 1027 stats.dam += tmp->magic;
1118 } 1028 }
1119 1029
1120 if (tmp->stats.wc) 1030 if (tmp->stats.wc)
1121 wc -= (tmp->stats.wc + tmp->magic); 1031 wc -= tmp->stats.wc + tmp->magic;
1122 1032
1123 if (tmp->slaying != NULL) 1033 if (tmp->slaying)
1124 slaying = tmp->slaying; 1034 slaying = tmp->slaying;
1125 1035
1126 if (tmp->stats.ac) 1036 if (tmp->stats.ac)
1127 ac -= (tmp->stats.ac + tmp->magic); 1037 ac -= tmp->stats.ac + tmp->magic;
1128 1038
1129 if (settings.spell_encumbrance == TRUE && type == PLAYER) 1039 if (settings.spell_encumbrance == TRUE && type == PLAYER)
1130 contr->encumbrance += (int) 3 *tmp->weight / 1000; 1040 contr->encumbrance += (int) 3 *tmp->weight / 1000;
1131
1132 if (type == PLAYER)
1133 contr->ranges[range_skill] = this;
1134
1135 break; 1041 }
1136 1042
1137 case SKILL_TOOL:
1138 if (chosen_skill)
1139 LOG (llevDebug, "fix_player, op %s has multiple skills applied\n", &name);
1140
1141 chosen_skill = tmp;
1142
1143 if (type == PLAYER)
1144 contr->ranges[range_skill] = this;
1145 break; 1043 break;
1146 1044
1147 case SHIELD: 1045 case SHIELD:
1148 if (settings.spell_encumbrance == TRUE && type == PLAYER) 1046 if (settings.spell_encumbrance == TRUE && type == PLAYER)
1149 contr->encumbrance += (int) tmp->weight / 2000; 1047 contr->encumbrance += (int) tmp->weight / 2000;
… …
1153 case HELMET: 1051 case HELMET:
1154 case BOOTS: 1052 case BOOTS:
1155 case GLOVES: 1053 case GLOVES:
1156 case CLOAK: 1054 case CLOAK:
1157 if (tmp->stats.wc) 1055 if (tmp->stats.wc)
1158 wc -= (tmp->stats.wc + tmp->magic); 1056 wc -= tmp->stats.wc + tmp->magic;
1159 1057
1160 if (tmp->stats.dam) 1058 if (tmp->stats.dam)
1161 stats.dam += (tmp->stats.dam + tmp->magic); 1059 stats.dam += tmp->stats.dam + tmp->magic;
1162 1060
1163 if (tmp->stats.ac) 1061 if (tmp->stats.ac)
1164 ac -= (tmp->stats.ac + tmp->magic); 1062 ac -= tmp->stats.ac + tmp->magic;
1165 1063
1166 break; 1064 break;
1167 1065
1066 case BOW:
1168 case WEAPON: 1067 case WEAPON:
1068 if (type != PLAYER || current_weapon == tmp)
1069 {
1169 wc -= (tmp->stats.wc + tmp->magic); 1070 wc -= tmp->stats.wc + tmp->magic;
1170 1071
1171 if (tmp->stats.ac && tmp->stats.ac + tmp->magic > 0) 1072 if (tmp->stats.ac && tmp->stats.ac + tmp->magic > 0)
1172 ac -= tmp->stats.ac + tmp->magic; 1073 ac -= tmp->stats.ac + tmp->magic;
1173 1074
1174 stats.dam += (tmp->stats.dam + tmp->magic); 1075 stats.dam += tmp->stats.dam + tmp->magic;
1175 weapon_weight = tmp->weight; 1076 weapon_weight = tmp->weight;
1176 weapon_speed = ((int) WEAPON_SPEED (tmp) * 2 - tmp->magic) / 2; 1077 weapon_speed = (WEAPON_SPEED (tmp) * 2 - tmp->magic) / 2;
1177 1078
1178 if (weapon_speed < 0) 1079 if (weapon_speed < 0)
1179 weapon_speed = 0; 1080 weapon_speed = 0;
1180 1081
1181 slaying = tmp->slaying; 1082 slaying = tmp->slaying;
1083
1182 /* If there is desire that two handed weapons should do 1084 /* If there is desire that two handed weapons should do
1183 * extra strength damage, this is where the code should 1085 * extra strength damage, this is where the code should
1184 * go. 1086 * go.
1185 */ 1087 */
1186 current_weapon = tmp; 1088
1187 if (settings.spell_encumbrance == TRUE && type == PLAYER) 1089 if (type == PLAYER)
1090 if (settings.spell_encumbrance)
1188 contr->encumbrance += (int) 3 *tmp->weight / 1000; 1091 contr->encumbrance += tmp->weight * 3 / 1000;
1092 }
1189 1093
1190 break; 1094 break;
1191 1095
1192 case ARMOUR: /* Only the best of these three are used: */ 1096 case ARMOUR: /* Only the best of these three are used: */
1193 if (settings.spell_encumbrance == TRUE && type == PLAYER) 1097 if (settings.spell_encumbrance == TRUE && type == PLAYER)
1194 contr->encumbrance += (int) tmp->weight / 1000; 1098 contr->encumbrance += tmp->weight / 1000;
1195 1099
1196 case BRACERS: 1100 case BRACERS:
1197 case FORCE: 1101 case FORCE:
1198 if (tmp->stats.wc) 1102 if (tmp->stats.wc)
1199 { 1103 {
… …
1221 wc -= (tmp->stats.wc + tmp->magic); 1125 wc -= (tmp->stats.wc + tmp->magic);
1222 1126
1223 if (tmp->stats.ac) 1127 if (tmp->stats.ac)
1224 ac -= (tmp->stats.ac + tmp->magic); 1128 ac -= (tmp->stats.ac + tmp->magic);
1225 1129
1226 if (ARMOUR_SPEED (tmp) && ARMOUR_SPEED (tmp) / 10.0 < max) 1130 if (ARMOUR_SPEED (tmp) && ARMOUR_SPEED (tmp) / 10.f < max)
1227 max = ARMOUR_SPEED (tmp) / 10.0; 1131 max = ARMOUR_SPEED (tmp) / 10.f;
1228 1132
1229 break; 1133 break;
1230 } /* switch tmp->type */ 1134 } /* switch tmp->type */
1231 } /* item is equipped */ 1135 } /* item is equipped */
1232 } /* for loop of items */ 1136 } /* for loop of items */
… …
1300 1204
1301 if (mana_obj == this && type == PLAYER) 1205 if (mana_obj == this && type == PLAYER)
1302 stats.maxsp = 1; 1206 stats.maxsp = 1;
1303 else 1207 else
1304 { 1208 {
1305 sp_tmp = 0.0; 1209 sp_tmp = 0.f;
1306 1210
1307 for (i = 1; i <= mana_obj->level && i <= 10; i++) 1211 for (i = 1; i <= mana_obj->level && i <= 10; i++)
1308 { 1212 {
1309 float stmp; 1213 float stmp;
1310 1214
1311 /* Got some extra bonus at first level */ 1215 /* Got some extra bonus at first level */
1312 if (i < 2) 1216 if (i < 2)
1313 stmp = contr->levsp[i] + ((2.0 * (float) sp_bonus[stats.Pow] + (float) sp_bonus[stats.Int]) / 6.0); 1217 stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 6.f;
1314 else 1218 else
1315 stmp = (float) contr->levsp[i] + (2.0 * (float) sp_bonus[stats.Pow] + (float) sp_bonus[stats.Int]) / 12.0; 1219 stmp = contr->levsp[i] + (2.f * sp_bonus[stats.Pow] + sp_bonus[stats.Int]) / 12.f;
1316 1220
1317 if (stmp < 1.0) 1221 if (stmp < 1.f)
1318 stmp = 1.0; 1222 stmp = 1.f;
1319 1223
1320 sp_tmp += stmp; 1224 sp_tmp += stmp;
1321 } 1225 }
1322 1226
1323 stats.maxsp = (int) sp_tmp; 1227 stats.maxsp = (sint16)sp_tmp;
1324 1228
1325 for (i = 11; i <= mana_obj->level; i++) 1229 for (i = 11; i <= mana_obj->level; i++)
1326 stats.maxsp += 2; 1230 stats.maxsp += 2;
1327 } 1231 }
1232
1328 /* Characters can get their sp supercharged via rune of transferrance */ 1233 /* Characters can get their sp supercharged via rune of transferrance */
1329 if (stats.sp > stats.maxsp * 2) 1234 if (stats.sp > stats.maxsp * 2)
1330 stats.sp = stats.maxsp * 2; 1235 stats.sp = stats.maxsp * 2;
1331 1236
1332 /* set maxgrace, notice 3-4 lines below it depends on both Wis and Pow */ 1237 /* set maxgrace, notice 3-4 lines below it depends on both Wis and Pow */
… …
1340 /* store grace in a float - this way, the divisions below don't create 1245 /* store grace in a float - this way, the divisions below don't create
1341 * big jumps when you go from level to level - with int's, it then 1246 * big jumps when you go from level to level - with int's, it then
1342 * becomes big jumps when the sums of the bonuses jump to the next 1247 * becomes big jumps when the sums of the bonuses jump to the next
1343 * step of 8 - with floats, even fractional ones are useful. 1248 * step of 8 - with floats, even fractional ones are useful.
1344 */ 1249 */
1345 sp_tmp = 0.0; 1250 sp_tmp = 0.f;
1346 for (i = 1, stats.maxgrace = 0; i <= grace_obj->level && i <= 10; i++) 1251 for (i = 1, stats.maxgrace = 0; i <= grace_obj->level && i <= 10; i++)
1347 { 1252 {
1348 float grace_tmp = 0.0; 1253 float grace_tmp = 0.f;
1349 1254
1350 /* Got some extra bonus at first level */ 1255 /* Got some extra bonus at first level */
1351 if (i < 2) 1256 if (i < 2)
1352 grace_tmp = contr->levgrace[i] + (((float) grace_bonus[stats.Pow] + 1257 grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 6.f;
1353 2.0 * (float) grace_bonus[stats.Wis]) / 6.0);
1354 else 1258 else
1355 grace_tmp = (float) contr->levgrace[i]
1356 + ((float) grace_bonus[stats.Pow] + 2.0 * (float) grace_bonus[stats.Wis]) / 12.0; 1259 grace_tmp = contr->levgrace[i] + (grace_bonus[stats.Pow] + 2.f * grace_bonus[stats.Wis]) / 12.f;
1357 1260
1358 if (grace_tmp < 1.0) 1261 if (grace_tmp < 1.f)
1359 grace_tmp = 1.0; 1262 grace_tmp = 1.f;
1360 1263
1361 sp_tmp += grace_tmp; 1264 sp_tmp += grace_tmp;
1362 } 1265 }
1363 1266
1364 stats.maxgrace = (int) sp_tmp; 1267 stats.maxgrace = (sint16)sp_tmp;
1365 1268
1366 /* two grace points per level after 11 */ 1269 /* two grace points per level after 11 */
1367 for (i = 11; i <= grace_obj->level; i++) 1270 for (i = 11; i <= grace_obj->level; i++)
1368 stats.maxgrace += 2; 1271 stats.maxgrace += 2;
1369 } 1272 }
1273
1370 /* No limit on grace vs maxgrace */ 1274 /* No limit on grace vs maxgrace */
1371 1275
1372 if (contr->braced) 1276 if (contr->braced)
1373 { 1277 {
1374 ac += 2; 1278 ac += 2;
… …
1386 * improvement every level, now its fighterlevel/5. So 1290 * improvement every level, now its fighterlevel/5. So
1387 * we give the player a bonus here in wc and dam 1291 * we give the player a bonus here in wc and dam
1388 * to make up for the change. Note that I left the 1292 * to make up for the change. Note that I left the
1389 * monster bonus the same as before. -b.t. 1293 * monster bonus the same as before. -b.t.
1390 */ 1294 */
1295 object *wc_obj = chosen_skill;
1391 1296
1392 if (type == PLAYER && wc_obj && wc_obj->level > 1) 1297 if (contr && wc_obj && wc_obj->level > 1)
1393 { 1298 {
1394 wc -= (wc_obj->level + thaco_bonus[stats.Str]); 1299 wc -= wc_obj->level + thaco_bonus[stats.Str];
1300
1395 for (i = 1; i < wc_obj->level; i++) 1301 for (i = 1; i < wc_obj->level; i++)
1396 { 1302 {
1397 /* addtional wc every 6 levels */ 1303 /* additional wc every 6 levels */
1398 if (!(i % 6)) 1304 if (!(i % 6))
1399 wc--; 1305 wc--;
1306
1400 /* addtional dam every 4 levels. */ 1307 /* additional dam every 4 levels. */
1401 if (!(i % 4) && (dam_bonus[stats.Str] >= 0)) 1308 if (!(i % 4) && dam_bonus[stats.Str] >= 0)
1402 stats.dam += (1 + (dam_bonus[stats.Str] / 5)); 1309 stats.dam += 1 + dam_bonus[stats.Str] / 5;
1403 } 1310 }
1404 } 1311 }
1405 else 1312 else
1406 wc -= (level + thaco_bonus[stats.Str]); 1313 wc -= level + thaco_bonus[stats.Str];
1407 1314
1408 stats.dam += dam_bonus[stats.Str]; 1315 stats.dam += dam_bonus[stats.Str];
1409 1316
1410 if (stats.dam < 1) 1317 if (stats.dam < 1)
1411 stats.dam = 1; 1318 stats.dam = 1;
1412 1319
1413 speed = 1.0 + speed_bonus[stats.Dex]; 1320 speed = 1.f + speed_bonus[stats.Dex];
1414 1321
1415 if (settings.search_items && contr->search_str[0]) 1322 if (settings.search_items && contr->search_str[0])
1416 speed -= 1; 1323 speed -= 1;
1417 1324
1418 if (attacktype == 0) 1325 if (attacktype == 0)
1419 attacktype = arch->clone.attacktype; 1326 attacktype = arch->attacktype;
1420
1421 } /* End if player */ 1327 } /* End if player */
1422 1328
1423 if (added_speed >= 0) 1329 if (added_speed >= 0)
1424 speed += added_speed / 10.0; 1330 speed += added_speed / 10.f;
1425 else /* Something wrong here...: */ 1331 else /* Something wrong here...: */
1426 speed /= (float) (1.0 - added_speed); 1332 speed /= 1.f - added_speed;
1427 1333
1428 /* Max is determined by armour */ 1334 /* Max is determined by armour */
1429 if (speed > max) 1335 if (speed > max)
1430 speed = max; 1336 speed = max;
1431 1337
… …
1436 * weight limit, then player suffers a speed reduction based on how 1342 * weight limit, then player suffers a speed reduction based on how
1437 * much above he is, and what is max carry is 1343 * much above he is, and what is max carry is
1438 */ 1344 */
1439 f = (carrying / 1000) - max_carry[stats.Str]; 1345 f = (carrying / 1000) - max_carry[stats.Str];
1440 if (f > 0) 1346 if (f > 0)
1441 speed = speed / (1.0 + f / max_carry[stats.Str]); 1347 speed = speed / (1.f + f / max_carry[stats.Str]);
1442 } 1348 }
1443 1349
1444 speed += bonus_speed / 10.0; /* Not affected by limits */ 1350 speed += bonus_speed / 10.f; /* Not affected by limits */
1445 1351
1446 /* Put a lower limit on speed. Note with this speed, you move once every 1352 /* Put a lower limit on speed. Note with this speed, you move once every
1447 * 100 ticks or so. This amounts to once every 12 seconds of realtime. 1353 * 100 ticks or so. This amounts to once every 12 seconds of realtime.
1448 */ 1354 */
1449 speed = speed * speed_reduce_from_disease; 1355 speed = speed * speed_reduce_from_disease;
1450 1356
1451 if (speed < 0.01 && type == PLAYER) 1357 if (speed < 0.01f && type == PLAYER)
1452 speed = 0.01; 1358 speed = 0.01f;
1453 1359
1454 if (type == PLAYER) 1360 if (type == PLAYER)
1455 { 1361 {
1456 float M, W, s, D, K, S, M2;
1457
1458 /* (This formula was made by vidarl@ifi.uio.no) 1362 /* (This formula was made by vidarl@ifi.uio.no)
1459 * Note that we never used these values again - basically 1363 * Note that we never used these values again - basically
1460 * all of these could be subbed into one big equation, but 1364 * all of these could be subbed into one big equation, but
1461 * that would just be a real pain to read. 1365 * that would just be a real pain to read.
1462 */ 1366 */
1463 M = (max_carry[stats.Str] - 121) / 121.0; 1367 float M = (max_carry[stats.Str] - 121) / 121.f;
1464 M2 = max_carry[stats.Str] / 100.0; 1368 float M2 = max_carry[stats.Str] / 100.f;
1465 W = weapon_weight / 20000.0; 1369 float W = weapon_weight / 20000.f;
1466 s = 2 - weapon_speed / 10.0; 1370 float s = (20 - weapon_speed) / 10.f;
1467 D = (stats.Dex - 14) / 14.0; 1371 float D = (stats.Dex - 14) / 14.f;
1468 K = 1 + M / 3.0 - W / (3 * M2) + speed / 5.0 + D / 2.0; 1372 float K = 1 + M / 3.f - W / (3 * M2) + speed / 5.f + D / 2.f;
1373
1469 K *= (4 + level) / (float) (6 + level) * 1.2; 1374 K *= (4 + level) * 1.2f / (6 + level);
1375
1470 if (K <= 0) 1376 if (K <= 0.01f)
1471 K = 0.01; 1377 K = 0.01f;
1472 S = speed / (K * s); 1378
1473 contr->weapon_sp = S; 1379 contr->weapon_sp = K * s * .5f; //TODO: balance the .5
1474 } 1380 }
1475 1381
1476 /* I want to limit the power of small monsters with big weapons: */ 1382 /* I want to limit the power of small monsters with big weapons: */
1477 if (type != PLAYER && arch != NULL && stats.dam > arch->clone.stats.dam * 3) 1383 if (type != PLAYER && arch && stats.dam > arch->stats.dam * 3)
1478 stats.dam = arch->clone.stats.dam * 3; 1384 stats.dam = arch->stats.dam * 3;
1479 1385
1480 /* Prevent overflows of wc - best you can get is ABS(120) - this 1386 stats.wc = clamp (wc, MIN_WC, MAX_WC);
1481 * should be more than enough - remember, AC is also in 8 bits, 1387 stats.ac = clamp (ac, MIN_AC, MAX_AC);
1482 * so its value is the same.
1483 */
1484 if (wc > 120)
1485 wc = 120;
1486 else if (wc < -120)
1487 wc = -120;
1488
1489 stats.wc = wc;
1490
1491 if (ac > 120)
1492 ac = 120;
1493 else if (ac < -120)
1494 ac = -120;
1495
1496 stats.ac = ac;
1497 1388
1498 /* if for some reason the creature doesn't have any move type, 1389 /* if for some reason the creature doesn't have any move type,
1499 * give them walking as a default. 1390 * give them walking as a default.
1500 * The second case is a special case - to more closely mimic the 1391 * The second case is a special case - to more closely mimic the
1501 * old behaviour - if your flying, your not walking - just 1392 * old behaviour - if your flying, your not walking - just
… …
1515 if (type == PLAYER) 1406 if (type == PLAYER)
1516 { 1407 {
1517 esrv_update_stats (contr); 1408 esrv_update_stats (contr);
1518 esrv_update_spells (contr); 1409 esrv_update_spells (contr);
1519 } 1410 }
1411
1412 // update the mapspace, if we are on a map
1413 if (!flag [FLAG_REMOVED] && map)
1414 map->at (x, y).flags_ = 0;
1520} 1415}
1521 1416
1522/* 1417/*
1523 * Returns true if the given player is a legal class. 1418 * Returns true if the given player is a legal class.
1524 * The function to add and remove class-bonuses to the stats doesn't 1419 * The function to add and remove class-bonuses to the stats doesn't
… …
1527 * false otherwise. 1422 * false otherwise.
1528 */ 1423 */
1529int 1424int
1530allowed_class (const object *op) 1425allowed_class (const object *op)
1531{ 1426{
1532 return op->stats.Dex > 0 && op->stats.Str > 0 && op->stats.Con > 0 && 1427 return op->stats.Dex > 0
1533 op->stats.Int > 0 && op->stats.Wis > 0 && op->stats.Pow > 0 && op->stats.Cha > 0; 1428 && op->stats.Str > 0
1429 && op->stats.Con > 0
1430 && op->stats.Int > 0
1431 && op->stats.Wis > 0
1432 && op->stats.Pow > 0
1433 && op->stats.Cha > 0;
1534} 1434}
1535 1435
1536/* 1436/*
1537 * set the new dragon name after gaining levels or 1437 * set the new dragon name after gaining levels or
1538 * changing ability focus (later this can be extended to 1438 * changing ability focus (later this can be extended to
… …
1609 object *skin = NULL; /* pointer to dragon skin force */ 1509 object *skin = NULL; /* pointer to dragon skin force */
1610 object *tmp = NULL; /* tmp. object */ 1510 object *tmp = NULL; /* tmp. object */
1611 char buf[MAX_BUF]; /* tmp. string buffer */ 1511 char buf[MAX_BUF]; /* tmp. string buffer */
1612 1512
1613 /* now grab the 'dragon_ability'-forces from the player's inventory */ 1513 /* now grab the 'dragon_ability'-forces from the player's inventory */
1614 for (tmp = who->inv; tmp != NULL; tmp = tmp->below) 1514 for (tmp = who->inv; tmp; tmp = tmp->below)
1615 {
1616 if (tmp->type == FORCE) 1515 if (tmp->type == FORCE)
1617 { 1516 if (tmp->arch->archname == shstr_dragon_ability_force)
1618 if (strcmp (tmp->arch->name, "dragon_ability_force") == 0)
1619 abil = tmp; 1517 abil = tmp;
1620 if (strcmp (tmp->arch->name, "dragon_skin_force") == 0) 1518 else if (tmp->arch->archname == shstr_dragon_skin_force)
1621 skin = tmp; 1519 skin = tmp;
1622 } 1520
1623 }
1624 /* if the force is missing -> bail out */ 1521 /* if the force is missing -> bail out */
1625 if (abil == NULL) 1522 if (abil == NULL)
1626 return; 1523 return;
1627 1524
1628 /* The ability_force keeps track of maximum level ever achieved. 1525 /* The ability_force keeps track of maximum level ever achieved.
… …
1672 if (!skill_obj) 1569 if (!skill_obj)
1673 { 1570 {
1674 LOG (llevError, "add_player_exp: couldn't find skill %s\n", skill_name); 1571 LOG (llevError, "add_player_exp: couldn't find skill %s\n", skill_name);
1675 return NULL; 1572 return NULL;
1676 } 1573 }
1574
1677 /* clear the flag - exp goes into this bucket, but player 1575 /* clear the flag - exp goes into this bucket, but player
1678 * still doesn't know it. 1576 * still doesn't know it.
1679 */ 1577 */
1680 CLEAR_FLAG (skill_obj, FLAG_CAN_USE_SKILL); 1578 CLEAR_FLAG (skill_obj, FLAG_CAN_USE_SKILL);
1681 skill_obj->stats.exp = 0; 1579 skill_obj->stats.exp = 0;
1682 skill_obj->level = 1; 1580 skill_obj->level = 1;
1683 insert_ob_in_ob (skill_obj, op); 1581 insert_ob_in_ob (skill_obj, op);
1684 1582
1685 if (op->contr) 1583 if (player *pl = op->contr)
1686 { 1584 {
1687 op->contr->last_skill_ob [skill_obj->subtype] = skill_obj; 1585 pl->last_skill_ob [skill_obj->subtype] = skill_obj;
1688 if (op->contr->ns) 1586 if (pl->ns)
1689 op->contr->ns->last_skill_exp[skill_obj->subtype] = -1;//TODO: should be made superfluous 1587 pl->ns->last_skill_exp[skill_obj->subtype] = -1;//TODO: should be made superfluous
1690 } 1588 }
1691 1589
1692 return skill_obj; 1590 return skill_obj;
1693} 1591}
1694
1695 1592
1696/* player_lvl_adj() - for the new exp system. we are concerned with 1593/* player_lvl_adj() - for the new exp system. we are concerned with
1697 * whether the player gets more hp, sp and new levels. 1594 * whether the player gets more hp, sp and new levels.
1698 * Note this this function should only be called for players. Monstes 1595 * Note this this function should only be called for players. Monstes
1699 * don't really gain levels 1596 * don't really gain levels
… …
1702 */ 1599 */
1703void 1600void
1704player_lvl_adj (object *who, object *op) 1601player_lvl_adj (object *who, object *op)
1705{ 1602{
1706 char buf[MAX_BUF]; 1603 char buf[MAX_BUF];
1604 bool changed = false;
1707 1605
1708 if (!op) /* when rolling stats */ 1606 if (!op) /* when rolling stats */
1709 op = who; 1607 op = who;
1710 1608
1711 if (op->level < settings.max_level && op->stats.exp >= level_exp (op->level + 1, who->expmul)) 1609 while (op->level < settings.max_level && op->stats.exp >= level_exp (op->level + 1, who->expmul))
1712 { 1610 {
1611 changed = true;
1612
1713 op->level++; 1613 op->level++;
1714 1614
1715 if (op != NULL && op == who && op->stats.exp > 1 && is_dragon_pl (who)) 1615 if (op && op == who && op->stats.exp > 1 && is_dragon_pl (who))
1716 dragon_level_gain (who); 1616 dragon_level_gain (who);
1717 1617
1718 /* Only roll these if it is the player (who) that gained the level */ 1618 /* Only roll these if it is the player (who) that gained the level */
1719 if (op == who && (who->level < 11) && who->type == PLAYER) 1619 if (op == who && (who->level < 11) && who->type == PLAYER)
1720 { 1620 {
1721 who->contr->levhp[who->level] = die_roll (2, 4, who, PREFER_HIGH) + 1; 1621 who->contr->levhp[who->level] = die_roll (2, 4, who, PREFER_HIGH) + 1;
1722 who->contr->levsp[who->level] = die_roll (2, 3, who, PREFER_HIGH); 1622 who->contr->levsp[who->level] = die_roll (2, 3, who, PREFER_HIGH);
1723 who->contr->levgrace[who->level] = die_roll (2, 2, who, PREFER_HIGH) - 1; 1623 who->contr->levgrace[who->level] = die_roll (2, 2, who, PREFER_HIGH) - 1;
1724 } 1624 }
1725 1625
1726 who->update_stats ();
1727 if (op->level > 1) 1626 if (op->level > 1)
1728 { 1627 {
1729 if (op->type != PLAYER) 1628 if (op->type != PLAYER)
1629 {
1630 who->contr->play_sound (sound_find ("skill_up"));
1730 sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name); 1631 sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);
1632 }
1731 else 1633 else
1634 {
1635 who->contr->play_sound (sound_find ("level_up"));
1732 sprintf (buf, "You are now level %d.", op->level); 1636 sprintf (buf, "You are now level %d.", op->level);
1637 }
1638
1733 if (who) 1639 if (who)
1734 new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf); 1640 new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
1735 } 1641 }
1736 player_lvl_adj (who, op); /* To increase more levels */
1737 } 1642 }
1643
1738 else if (op->level > 1 && op->stats.exp < level_exp (op->level, who->expmul)) 1644 while (op->level > 1 && op->stats.exp < level_exp (op->level, who->expmul))
1739 { 1645 {
1646 changed = true;
1647
1740 op->level--; 1648 op->level--;
1741 who->update_stats (); 1649
1742 if (op->type != PLAYER) 1650 if (op->type != PLAYER)
1743 { 1651 {
1744 sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name); 1652 sprintf (buf, "You are now level %d in the %s skill.", op->level, &op->name);
1745 new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf); 1653 new_draw_info (NDI_UNIQUE | NDI_RED, 0, who, buf);
1746 } 1654 }
1747 player_lvl_adj (who, op); /* To decrease more levels */ 1655 }
1656
1657 if (changed)
1748 } 1658 {
1749 1659 who->update_stats ();
1660 esrv_update_stats (who->contr);
1750 /* check if the spell data has changed */ 1661 /* check if the spell data has changed */
1751 esrv_update_stats (who->contr);
1752 esrv_update_spells (who->contr); 1662 esrv_update_spells (who->contr);
1663 }
1753} 1664}
1754 1665
1755/* 1666/*
1756 * Returns how much experience is needed for a player to become 1667 * Returns how much experience is needed for a player to become
1757 * the given level. level should really never exceed max_level 1668 * the given level. level should really never exceed max_level
… …
1760sint64 1671sint64
1761level_exp (int level, double expmul) 1672level_exp (int level, double expmul)
1762{ 1673{
1763 if (level > settings.max_level) 1674 if (level > settings.max_level)
1764 return (sint64) (expmul * levels[settings.max_level]); 1675 return (sint64) (expmul * levels[settings.max_level]);
1676
1765 return (sint64) (expmul * levels[level]); 1677 return (sint64) (expmul * levels[level]);
1766} 1678}
1767 1679
1768/* 1680/*
1769 * Ensure that the permanent experience requirements in an exp object are met. 1681 * Ensure that the permanent experience requirements in an exp object are met.
… …
1806 sint64 limit, exp_to_add; 1718 sint64 limit, exp_to_add;
1807 int i; 1719 int i;
1808 1720
1809 /* prevents some forms of abuse. */ 1721 /* prevents some forms of abuse. */
1810 if (op->contr->braced) 1722 if (op->contr->braced)
1811 exp = exp / 5; 1723 exp /= 5;
1812 1724
1813 /* Try to find the matching skill. 1725 /* Try to find the matching skill.
1814 * We do a shortcut/time saving mechanism first - see if it matches 1726 * We do a shortcut/time saving mechanism first - see if it matches
1815 * chosen_skill. This means we don't need to search through 1727 * chosen_skill. This means we don't need to search through
1816 * the players inventory. 1728 * the players inventory.
1817 */ 1729 */
1818 if (skill_name) 1730 if (skill_name)
1819 { 1731 {
1820 if (op->chosen_skill && op->chosen_skill->type == SKILL && !strcmp (skill_name, op->chosen_skill->skill)) 1732 if (op->chosen_skill && op->chosen_skill->type == SKILL && !strcmp (skill_name, op->chosen_skill->skill))
… …
1951 del_exp = check_exp_loss (tmp, (sint64) (tmp->stats.exp * fraction)); 1863 del_exp = check_exp_loss (tmp, (sint64) (tmp->stats.exp * fraction));
1952 tmp->stats.exp -= del_exp; 1864 tmp->stats.exp -= del_exp;
1953 player_lvl_adj (op, tmp); 1865 player_lvl_adj (op, tmp);
1954 } 1866 }
1955 } 1867 }
1868
1956 if (flag != SK_SUBTRACT_SKILL_EXP) 1869 if (flag != SK_SUBTRACT_SKILL_EXP)
1957 { 1870 {
1958 del_exp = check_exp_loss (op, exp); 1871 del_exp = check_exp_loss (op, exp);
1959 op->stats.exp -= del_exp; 1872 op->stats.exp -= del_exp;
1960 player_lvl_adj (op, NULL); 1873 player_lvl_adj (op, NULL);
1961 } 1874 }
1962} 1875}
1963
1964
1965 1876
1966/* change_exp() - changes experience to a player/monster. This 1877/* change_exp() - changes experience to a player/monster. This
1967 * does bounds checking to make sure we don't overflow the max exp. 1878 * does bounds checking to make sure we don't overflow the max exp.
1968 * 1879 *
1969 * The exp passed is typically not modified much by this function - 1880 * The exp passed is typically not modified much by this function -
1970 * it is assumed the caller has modified the exp as needed. 1881 * it is assumed the caller has modified the exp as needed.
1971 * skill_name is the skill that should get the exp added. 1882 * skill_name is the skill that should get the exp added.
1972 * flag is what to do if player doesn't have the skill. 1883 * flag is what to do if player doesn't have the skill.
1973 * these last two values are only used for players. 1884 * these last two values are only used for players.
1974 */ 1885 */
1975
1976void 1886void
1977change_exp (object *op, sint64 exp, const char *skill_name, int flag) 1887change_exp (object *op, sint64 exp, const char *skill_name, int flag)
1978{ 1888{
1979
1980#ifdef EXP_DEBUG 1889#ifdef EXP_DEBUG
1981 LOG (llevDebug, "change_exp() called for %s, exp = %" PRId64 "\n", query_name (op), exp); 1890 LOG (llevDebug, "change_exp() called for %s, exp = %" PRId64 "\n", query_name (op), exp);
1982#endif 1891#endif
1983 1892
1984 /* safety */ 1893 /* safety */
… …
2025 else 1934 else
2026 /* note that when you lose exp, it doesn't go against 1935 /* note that when you lose exp, it doesn't go against
2027 * a particular skill, so we don't need to pass that 1936 * a particular skill, so we don't need to pass that
2028 * along. 1937 * along.
2029 */ 1938 */
2030 subtract_player_exp (op, FABS (exp), skill_name, flag); 1939 subtract_player_exp (op, abs (exp), skill_name, flag);
2031
2032 } 1940 }
2033} 1941}
2034 1942
2035/* Applies a death penalty experience, the size of this is defined by the 1943/* Applies a death penalty experience, the size of this is defined by the
2036 * settings death_penalty_percentage and death_penalty_levels, and by the 1944 * settings death_penalty_percentage and death_penalty_levels, and by the
2037 * amount of permenent experience, whichever gives the lowest loss. 1945 * amount of permenent experience, whichever gives the lowest loss.
2038 */ 1946 */
2039
2040void 1947void
2041apply_death_exp_penalty (object *op) 1948apply_death_exp_penalty (object *op)
2042{ 1949{
2043 object *tmp; 1950 object *tmp;
2044 sint64 loss; 1951 sint64 loss;
… …
2066 player_lvl_adj (op, tmp); 1973 player_lvl_adj (op, tmp);
2067 } 1974 }
2068 1975
2069 percentage_loss = op->stats.exp * settings.death_penalty_ratio / 100; 1976 percentage_loss = op->stats.exp * settings.death_penalty_ratio / 100;
2070 level_loss = op->stats.exp - levels[MAX (0, op->level - settings.death_penalty_level)]; 1977 level_loss = op->stats.exp - levels[MAX (0, op->level - settings.death_penalty_level)];
1978
2071 if (level_loss < 0) 1979 if (level_loss < 0)
2072 level_loss = 0; 1980 level_loss = 0;
2073 loss = check_exp_loss (op, MIN (level_loss, percentage_loss)); 1981 loss = check_exp_loss (op, MIN (level_loss, percentage_loss));
2074 1982
2075 op->stats.exp -= loss; 1983 op->stats.exp -= loss;

Diff Legend

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