class.c
1 /* ************************************************************************ 2 * File: class.c Part of CircleMUD * 3 * Usage: Source file for class-specific code * 4 * * 5 * All rights reserved. See license.doc for complete information. * 6 * * 7 * Copyright (C) 1993, 94 by the Trustees of the Johns Hopkins University * 8 * CircleMUD is based on DikuMUD, Copyright (C) 1990, 1991. * 9 ************************************************************************ */ 10 11 /* 12 * This file attempts to concentrate most of the code which must be changed 13 * in order for new classes to be added. If you're adding a new class, 14 * you should go through this entire file from beginning to end and add 15 * the appropriate new special cases for your new class. 16 */ 17 18 19 20 #include "conf.h" 21 #include "sysdep.h" 22 23 #include "structs.h" 24 #include "db.h" 25 #include "utils.h" 26 #include "spells.h" 27 #include "interpreter.h" 28 #include "constants.h" 29 30 extern int siteok_everyone; 31 32 /* local functions */ 33 void snoop_check(struct char_data *ch); 34 int parse_class(char arg); 35 bitvector_t find_class_bitvector(const char *arg); 36 byte saving_throws(int class_num, int type, int level); 37 int thaco(int class_num, int level); 38 void roll_real_abils(struct char_data *ch); 39 void do_start(struct char_data *ch); 40 int backstab_mult(int level); 41 int invalid_class(struct char_data *ch, struct obj_data *obj); 42 int level_exp(int chclass, int level); 43 const char *title_male(int chclass, int level); 44 const char *title_female(int chclass, int level); 45 46 /* Names first */ 47 48 const char *class_abbrevs[] = { 49 "Mu", 50 "Cl", 51 "Th", 52 "Wa", 53 "\n" 54 }; 55 56 57 const char *pc_class_types[] = { 58 "Magic User", 59 "Cleric", 60 "Thief", 61 "Warrior", 62 "\n" 63 }; 64 65 66 /* The menu for choosing a class in interpreter.c: */ 67 const char *class_menu = 68 "\r\n" 69 "Select a class:\r\n" 70 " [C]leric\r\n" 71 " [T]hief\r\n" 72 " [W]arrior\r\n" 73 " [M]agic-user\r\n"; 74 75 76 77 /* 78 * The code to interpret a class letter -- used in interpreter.c when a 79 * new character is selecting a class and by 'set class' in act.wizard.c. 80 */ 81 82 int parse_class(char arg) 83 { 84 arg = LOWER(arg); 85 86 switch (arg) { 87 case 'm': return CLASS_MAGIC_USER; 88 case 'c': return CLASS_CLERIC; 89 case 'w': return CLASS_WARRIOR; 90 case 't': return CLASS_THIEF; 91 default: return CLASS_UNDEFINED; 92 } 93 } 94 95 /* 96 * bitvectors (i.e., powers of two) for each class, mainly for use in 97 * do_who and do_users. Add new classes at the end so that all classes 98 * use sequential powers of two (1 << 0, 1 << 1, 1 << 2, 1 << 3, 1 << 4, 99 * 1 << 5, etc.) up to the limit of your bitvector_t, typically 0-31. 100 */ 101 bitvector_t find_class_bitvector(const char *arg) 102 { 103 size_t rpos, ret = 0; 104 105 for (rpos = 0; rpos < strlen(arg); rpos++) 106 ret |= (1 << parse_class(arg[rpos])); 107 108 return (ret); 109 } 110 111 112 /* 113 * These are definitions which control the guildmasters for each class. 114 * 115 * The first field (top line) controls the highest percentage skill level 116 * a character of the class is allowed to attain in any skill. (After 117 * this level, attempts to practice will say "You are already learned in 118 * this area." 119 * 120 * The second line controls the maximum percent gain in learnedness a 121 * character is allowed per practice -- in other words, if the random 122 * die throw comes out higher than this number, the gain will only be 123 * this number instead. 124 * 125 * The third line controls the minimu percent gain in learnedness a 126 * character is allowed per practice -- in other words, if the random 127 * die throw comes out below this number, the gain will be set up to 128 * this number. 129 * 130 * The fourth line simply sets whether the character knows 'spells' 131 * or 'skills'. This does not affect anything except the message given 132 * to the character when trying to practice (i.e. "You know of the 133 * following spells" vs. "You know of the following skills" 134 */ 135 136 #define SPELL 0 137 #define SKILL 1 138 139 /* #define LEARNED_LEVEL 0 % known which is considered "learned" */ 140 /* #define MAX_PER_PRAC 1 max percent gain in skill per practice */ 141 /* #define MIN_PER_PRAC 2 min percent gain in skill per practice */ 142 /* #define PRAC_TYPE 3 should it say 'spell' or 'skill'? */ 143 144 int prac_params[4][NUM_CLASSES] = { 145 /* MAG CLE THE WAR */ 146 { 95, 95, 85, 80 }, /* learned level */ 147 { 100, 100, 12, 12 }, /* max per practice */ 148 { 25, 25, 0, 0 }, /* min per practice */ 149 { SPELL, SPELL, SKILL, SKILL }, /* prac name */ 150 }; 151 152 153 /* 154 * ...And the appropriate rooms for each guildmaster/guildguard; controls 155 * which types of people the various guildguards let through. i.e., the 156 * first line shows that from room 3017, only MAGIC_USERS are allowed 157 * to go south. 158 * 159 * Don't forget to visit spec_assign.c if you create any new mobiles that 160 * should be a guild master or guard so they can act appropriately. If you 161 * "recycle" the existing mobs that are used in other guilds for your new 162 * guild, then you don't have to change that file, only here. 163 */ 164 struct guild_info_type guild_info[] = { 165 166 /* Midgaard */ 167 { CLASS_MAGIC_USER, 3017, SCMD_SOUTH }, 168 { CLASS_CLERIC, 3004, SCMD_NORTH }, 169 { CLASS_THIEF, 3027, SCMD_EAST }, 170 { CLASS_WARRIOR, 3021, SCMD_EAST }, 171 172 /* Brass Dragon */ 173 { -999 /* all */ , 5065, SCMD_WEST }, 174 175 /* this must go last -- add new guards above! */ 176 { -1, NOWHERE, -1} 177 }; 178 179 180 181 /* 182 * Saving throws for: 183 * MCTW 184 * PARA, ROD, PETRI, BREATH, SPELL 185 * Levels 0-40 186 * 187 * Do not forget to change extern declaration in magic.c if you add to this. 188 */ 189 190 byte saving_throws(int class_num, int type, int level) 191 { 192 switch (class_num) { 193 case CLASS_MAGIC_USER: 194 switch (type) { 195 case SAVING_PARA: /* Paralyzation */ 196 switch (level) { 197 case 0: return 90; 198 case 1: return 70; 199 case 2: return 69; 200 case 3: return 68; 201 case 4: return 67; 202 case 5: return 66; 203 case 6: return 65; 204 case 7: return 63; 205 case 8: return 61; 206 case 9: return 60; 207 case 10: return 59; 208 case 11: return 57; 209 case 12: return 55; 210 case 13: return 54; 211 case 14: return 53; 212 case 15: return 53; 213 case 16: return 52; 214 case 17: return 51; 215 case 18: return 50; 216 case 19: return 48; 217 case 20: return 46; 218 case 21: return 45; 219 case 22: return 44; 220 case 23: return 42; 221 case 24: return 40; 222 case 25: return 38; 223 case 26: return 36; 224 case 27: return 34; 225 case 28: return 32; 226 case 29: return 30; 227 case 30: return 28; 228 case 31: return 0; 229 case 32: return 0; 230 case 33: return 0; 231 case 34: return 0; 232 case 35: return 0; 233 case 36: return 0; 234 case 37: return 0; 235 case 38: return 0; 236 case 39: return 0; 237 case 40: return 0; 238 default: 239 log("SYSERR: Missing level for mage paralyzation saving throw."); 240 break; 241 } 242 case SAVING_ROD: /* Rods */ 243 switch (level) { 244 case 0: return 90; 245 case 1: return 55; 246 case 2: return 53; 247 case 3: return 51; 248 case 4: return 49; 249 case 5: return 47; 250 case 6: return 45; 251 case 7: return 43; 252 case 8: return 41; 253 case 9: return 40; 254 case 10: return 39; 255 case 11: return 37; 256 case 12: return 35; 257 case 13: return 33; 258 case 14: return 31; 259 case 15: return 30; 260 case 16: return 29; 261 case 17: return 27; 262 case 18: return 25; 263 case 19: return 23; 264 case 20: return 21; 265 case 21: return 20; 266 case 22: return 19; 267 case 23: return 17; 268 case 24: return 15; 269 case 25: return 14; 270 case 26: return 13; 271 case 27: return 12; 272 case 28: return 11; 273 case 29: return 10; 274 case 30: return 9; 275 case 31: return 0; 276 case 32: return 0; 277 case 33: return 0; 278 case 34: return 0; 279 case 35: return 0; 280 case 36: return 0; 281 case 37: return 0; 282 case 38: return 0; 283 case 39: return 0; 284 case 40: return 0; 285 default: 286 log("SYSERR: Missing level for mage rod saving throw."); 287 break; 288 } 289 case SAVING_PETRI: /* Petrification */ 290 switch (level) { 291 case 0: return 90; 292 case 1: return 65; 293 case 2: return 63; 294 case 3: return 61; 295 case 4: return 59; 296 case 5: return 57; 297 case 6: return 55; 298 case 7: return 53; 299 case 8: return 51; 300 case 9: return 50; 301 case 10: return 49; 302 case 11: return 47; 303 case 12: return 45; 304 case 13: return 43; 305 case 14: return 41; 306 case 15: return 40; 307 case 16: return 39; 308 case 17: return 37; 309 case 18: return 35; 310 case 19: return 33; 311 case 20: return 31; 312 case 21: return 30; 313 case 22: return 29; 314 case 23: return 27; 315 case 24: return 25; 316 case 25: return 23; 317 case 26: return 21; 318 case 27: return 19; 319 case 28: return 17; 320 case 29: return 15; 321 case 30: return 13; 322 case 31: return 0; 323 case 32: return 0; 324 case 33: return 0; 325 case 34: return 0; 326 case 35: return 0; 327 case 36: return 0; 328 case 37: return 0; 329 case 38: return 0; 330 case 39: return 0; 331 case 40: return 0; 332 default: 333 log("SYSERR: Missing level for mage petrification saving throw."); 334 break; 335 } 336 case SAVING_BREATH: /* Breath weapons */ 337 switch (level) { 338 case 0: return 90; 339 case 1: return 75; 340 case 2: return 73; 341 case 3: return 71; 342 case 4: return 69; 343 case 5: return 67; 344 case 6: return 65; 345 case 7: return 63; 346 case 8: return 61; 347 case 9: return 60; 348 case 10: return 59; 349 case 11: return 57; 350 case 12: return 55; 351 case 13: return 53; 352 case 14: return 51; 353 case 15: return 50; 354 case 16: return 49; 355 case 17: return 47; 356 case 18: return 45; 357 case 19: return 43; 358 case 20: return 41; 359 case 21: return 40; 360 case 22: return 39; 361 case 23: return 37; 362 case 24: return 35; 363 case 25: return 33; 364 case 26: return 31; 365 case 27: return 29; 366 case 28: return 27; 367 case 29: return 25; 368 case 30: return 23; 369 case 31: return 0; 370 case 32: return 0; 371 case 33: return 0; 372 case 34: return 0; 373 case 35: return 0; 374 case 36: return 0; 375 case 37: return 0; 376 case 38: return 0; 377 case 39: return 0; 378 case 40: return 0; 379 default: 380 log("SYSERR: Missing level for mage breath saving throw."); 381 break; 382 } 383 case SAVING_SPELL: /* Generic spells */ 384 switch (level) { 385 case 0: return 90; 386 case 1: return 60; 387 case 2: return 58; 388 case 3: return 56; 389 case 4: return 54; 390 case 5: return 52; 391 case 6: return 50; 392 case 7: return 48; 393 case 8: return 46; 394 case 9: return 45; 395 case 10: return 44; 396 case 11: return 42; 397 case 12: return 40; 398 case 13: return 38; 399 case 14: return 36; 400 case 15: return 35; 401 case 16: return 34; 402 case 17: return 32; 403 case 18: return 30; 404 case 19: return 28; 405 case 20: return 26; 406 case 21: return 25; 407 case 22: return 24; 408 case 23: return 22; 409 case 24: return 20; 410 case 25: return 18; 411 case 26: return 16; 412 case 27: return 14; 413 case 28: return 12; 414 case 29: return 10; 415 case 30: return 8; 416 case 31: return 0; 417 case 32: return 0; 418 case 33: return 0; 419 case 34: return 0; 420 case 35: return 0; 421 case 36: return 0; 422 case 37: return 0; 423 case 38: return 0; 424 case 39: return 0; 425 case 40: return 0; 426 default: 427 log("SYSERR: Missing level for mage spell saving throw."); 428 break; 429 } 430 default: 431 log("SYSERR: Invalid saving throw type."); 432 break; 433 } 434 break; 435 case CLASS_CLERIC: 436 switch (type) { 437 case SAVING_PARA: /* Paralyzation */ 438 switch (level) { 439 case 0: return 90; 440 case 1: return 60; 441 case 2: return 59; 442 case 3: return 48; 443 case 4: return 46; 444 case 5: return 45; 445 case 6: return 43; 446 case 7: return 40; 447 case 8: return 37; 448 case 9: return 35; 449 case 10: return 34; 450 case 11: return 33; 451 case 12: return 31; 452 case 13: return 30; 453 case 14: return 29; 454 case 15: return 27; 455 case 16: return 26; 456 case 17: return 25; 457 case 18: return 24; 458 case 19: return 23; 459 case 20: return 22; 460 case 21: return 21; 461 case 22: return 20; 462 case 23: return 18; 463 case 24: return 15; 464 case 25: return 14; 465 case 26: return 12; 466 case 27: return 10; 467 case 28: return 9; 468 case 29: return 8; 469 case 30: return 7; 470 case 31: return 0; 471 case 32: return 0; 472 case 33: return 0; 473 case 34: return 0; 474 case 35: return 0; 475 case 36: return 0; 476 case 37: return 0; 477 case 38: return 0; 478 case 39: return 0; 479 case 40: return 0; 480 default: 481 log("SYSERR: Missing level for cleric paralyzation saving throw."); 482 break; 483 } 484 case SAVING_ROD: /* Rods */ 485 switch (level) { 486 case 0: return 90; 487 case 1: return 70; 488 case 2: return 69; 489 case 3: return 68; 490 case 4: return 66; 491 case 5: return 65; 492 case 6: return 63; 493 case 7: return 60; 494 case 8: return 57; 495 case 9: return 55; 496 case 10: return 54; 497 case 11: return 53; 498 case 12: return 51; 499 case 13: return 50; 500 case 14: return 49; 501 case 15: return 47; 502 case 16: return 46; 503 case 17: return 45; 504 case 18: return 44; 505 case 19: return 43; 506 case 20: return 42; 507 case 21: return 41; 508 case 22: return 40; 509 case 23: return 38; 510 case 24: return 35; 511 case 25: return 34; 512 case 26: return 32; 513 case 27: return 30; 514 case 28: return 29; 515 case 29: return 28; 516 case 30: return 27; 517 case 31: return 0; 518 case 32: return 0; 519 case 33: return 0; 520 case 34: return 0; 521 case 35: return 0; 522 case 36: return 0; 523 case 37: return 0; 524 case 38: return 0; 525 case 39: return 0; 526 case 40: return 0; 527 default: 528 log("SYSERR: Missing level for cleric rod saving throw."); 529 break; 530 } 531 case SAVING_PETRI: /* Petrification */ 532 switch (level) { 533 case 0: return 90; 534 case 1: return 65; 535 case 2: return 64; 536 case 3: return 63; 537 case 4: return 61; 538 case 5: return 60; 539 case 6: return 58; 540 case 7: return 55; 541 case 8: return 53; 542 case 9: return 50; 543 case 10: return 49; 544 case 11: return 48; 545 case 12: return 46; 546 case 13: return 45; 547 case 14: return 44; 548 case 15: return 43; 549 case 16: return 41; 550 case 17: return 40; 551 case 18: return 39; 552 case 19: return 38; 553 case 20: return 37; 554 case 21: return 36; 555 case 22: return 35; 556 case 23: return 33; 557 case 24: return 31; 558 case 25: return 29; 559 case 26: return 27; 560 case 27: return 25; 561 case 28: return 24; 562 case 29: return 23; 563 case 30: return 22; 564 case 31: return 0; 565 case 32: return 0; 566 case 33: return 0; 567 case 34: return 0; 568 case 35: return 0; 569 case 36: return 0; 570 case 37: return 0; 571 case 38: return 0; 572 case 39: return 0; 573 case 40: return 0; 574 default: 575 log("SYSERR: Missing level for cleric petrification saving throw."); 576 break; 577 } 578 case SAVING_BREATH: /* Breath weapons */ 579 switch (level) { 580 case 0: return 90; 581 case 1: return 80; 582 case 2: return 79; 583 case 3: return 78; 584 case 4: return 76; 585 case 5: return 75; 586 case 6: return 73; 587 case 7: return 70; 588 case 8: return 67; 589 case 9: return 65; 590 case 10: return 64; 591 case 11: return 63; 592 case 12: return 61; 593 case 13: return 60; 594 case 14: return 59; 595 case 15: return 57; 596 case 16: return 56; 597 case 17: return 55; 598 case 18: return 54; 599 case 19: return 53; 600 case 20: return 52; 601 case 21: return 51; 602 case 22: return 50; 603 case 23: return 48; 604 case 24: return 45; 605 case 25: return 44; 606 case 26: return 42; 607 case 27: return 40; 608 case 28: return 39; 609 case 29: return 38; 610 case 30: return 37; 611 case 31: return 0; 612 case 32: return 0; 613 case 33: return 0; 614 case 34: return 0; 615 case 35: return 0; 616 case 36: return 0; 617 case 37: return 0; 618 case 38: return 0; 619 case 39: return 0; 620 case 40: return 0; 621 default: 622 log("SYSERR: Missing level for cleric breath saving throw."); 623 break; 624 } 625 case SAVING_SPELL: /* Generic spells */ 626 switch (level) { 627 case 0: return 90; 628 case 1: return 75; 629 case 2: return 74; 630 case 3: return 73; 631 case 4: return 71; 632 case 5: return 70; 633 case 6: return 68; 634 case 7: return 65; 635 case 8: return 63; 636 case 9: return 60; 637 case 10: return 59; 638 case 11: return 58; 639 case 12: return 56; 640 case 13: return 55; 641 case 14: return 54; 642 case 15: return 53; 643 case 16: return 51; 644 case 17: return 50; 645 case 18: return 49; 646 case 19: return 48; 647 case 20: return 47; 648 case 21: return 46; 649 case 22: return 45; 650 case 23: return 43; 651 case 24: return 41; 652 case 25: return 39; 653 case 26: return 37; 654 case 27: return 35; 655 case 28: return 34; 656 case 29: return 33; 657 case 30: return 32; 658 case 31: return 0; 659 case 32: return 0; 660 case 33: return 0; 661 case 34: return 0; 662 case 35: return 0; 663 case 36: return 0; 664 case 37: return 0; 665 case 38: return 0; 666 case 39: return 0; 667 case 40: return 0; 668 default: 669 log("SYSERR: Missing level for cleric spell saving throw."); 670 break; 671 } 672 default: 673 log("SYSERR: Invalid saving throw type."); 674 break; 675 } 676 break; 677 case CLASS_THIEF: 678 switch (type) { 679 case SAVING_PARA: /* Paralyzation */ 680 switch (level) { 681 case 0: return 90; 682 case 1: return 65; 683 case 2: return 64; 684 case 3: return 63; 685 case 4: return 62; 686 case 5: return 61; 687 case 6: return 60; 688 case 7: return 59; 689 case 8: return 58; 690 case 9: return 57; 691 case 10: return 56; 692 case 11: return 55; 693 case 12: return 54; 694 case 13: return 53; 695 case 14: return 52; 696 case 15: return 51; 697 case 16: return 50; 698 case 17: return 49; 699 case 18: return 48; 700 case 19: return 47; 701 case 20: return 46; 702 case 21: return 45; 703 case 22: return 44; 704 case 23: return 43; 705 case 24: return 42; 706 case 25: return 41; 707 case 26: return 40; 708 case 27: return 39; 709 case 28: return 38; 710 case 29: return 37; 711 case 30: return 36; 712 case 31: return 0; 713 case 32: return 0; 714 case 33: return 0; 715 case 34: return 0; 716 case 35: return 0; 717 case 36: return 0; 718 case 37: return 0; 719 case 38: return 0; 720 case 39: return 0; 721 case 40: return 0; 722 default: 723 log("SYSERR: Missing level for thief paralyzation saving throw."); 724 break; 725 } 726 case SAVING_ROD: /* Rods */ 727 switch (level) { 728 case 0: return 90; 729 case 1: return 70; 730 case 2: return 68; 731 case 3: return 66; 732 case 4: return 64; 733 case 5: return 62; 734 case 6: return 60; 735 case 7: return 58; 736 case 8: return 56; 737 case 9: return 54; 738 case 10: return 52; 739 case 11: return 50; 740 case 12: return 48; 741 case 13: return 46; 742 case 14: return 44; 743 case 15: return 42; 744 case 16: return 40; 745 case 17: return 38; 746 case 18: return 36; 747 case 19: return 34; 748 case 20: return 32; 749 case 21: return 30; 750 case 22: return 28; 751 case 23: return 26; 752 case 24: return 24; 753 case 25: return 22; 754 case 26: return 20; 755 case 27: return 18; 756 case 28: return 16; 757 case 29: return 14; 758 case 30: return 13; 759 case 31: return 0; 760 case 32: return 0; 761 case 33: return 0; 762 case 34: return 0; 763 case 35: return 0; 764 case 36: return 0; 765 case 37: return 0; 766 case 38: return 0; 767 case 39: return 0; 768 case 40: return 0; 769 default: 770 log("SYSERR: Missing level for thief rod saving throw."); 771 break; 772 } 773 case SAVING_PETRI: /* Petrification */ 774 switch (level) { 775 case 0: return 90; 776 case 1: return 60; 777 case 2: return 59; 778 case 3: return 58; 779 case 4: return 58; 780 case 5: return 56; 781 case 6: return 55; 782 case 7: return 54; 783 case 8: return 53; 784 case 9: return 52; 785 case 10: return 51; 786 case 11: return 50; 787 case 12: return 49; 788 case 13: return 48; 789 case 14: return 47; 790 case 15: return 46; 791 case 16: return 45; 792 case 17: return 44; 793 case 18: return 43; 794 case 19: return 42; 795 case 20: return 41; 796 case 21: return 40; 797 case 22: return 39; 798 case 23: return 38; 799 case 24: return 37; 800 case 25: return 36; 801 case 26: return 35; 802 case 27: return 34; 803 case 28: return 33; 804 case 29: return 32; 805 case 30: return 31; 806 case 31: return 0; 807 case 32: return 0; 808 case 33: return 0; 809 case 34: return 0; 810 case 35: return 0; 811 case 36: return 0; 812 case 37: return 0; 813 case 38: return 0; 814 case 39: return 0; 815 case 40: return 0; 816 default: 817 log("SYSERR: Missing level for thief petrification saving throw."); 818 break; 819 } 820 case SAVING_BREATH: /* Breath weapons */ 821 switch (level) { 822 case 0: return 90; 823 case 1: return 80; 824 case 2: return 79; 825 case 3: return 78; 826 case 4: return 77; 827 case 5: return 76; 828 case 6: return 75; 829 case 7: return 74; 830 case 8: return 73; 831 case 9: return 72; 832 case 10: return 71; 833 case 11: return 70; 834 case 12: return 69; 835 case 13: return 68; 836 case 14: return 67; 837 case 15: return 66; 838 case 16: return 65; 839 case 17: return 64; 840 case 18: return 63; 841 case 19: return 62; 842 case 20: return 61; 843 case 21: return 60; 844 case 22: return 59; 845 case 23: return 58; 846 case 24: return 57; 847 case 25: return 56; 848 case 26: return 55; 849 case 27: return 54; 850 case 28: return 53; 851 case 29: return 52; 852 case 30: return 51; 853 case 31: return 0; 854 case 32: return 0; 855 case 33: return 0; 856 case 34: return 0; 857 case 35: return 0; 858 case 36: return 0; 859 case 37: return 0; 860 case 38: return 0; 861 case 39: return 0; 862 case 40: return 0; 863 default: 864 log("SYSERR: Missing level for thief breath saving throw."); 865 break; 866 } 867 case SAVING_SPELL: /* Generic spells */ 868 switch (level) { 869 case 0: return 90; 870 case 1: return 75; 871 case 2: return 73; 872 case 3: return 71; 873 case 4: return 69; 874 case 5: return 67; 875 case 6: return 65; 876 case 7: return 63; 877 case 8: return 61; 878 case 9: return 59; 879 case 10: return 57; 880 case 11: return 55; 881 case 12: return 53; 882 case 13: return 51; 883 case 14: return 49; 884 case 15: return 47; 885 case 16: return 45; 886 case 17: return 43; 887 case 18: return 41; 888 case 19: return 39; 889 case 20: return 37; 890 case 21: return 35; 891 case 22: return 33; 892 case 23: return 31; 893 case 24: return 29; 894 case 25: return 27; 895 case 26: return 25; 896 case 27: return 23; 897 case 28: return 21; 898 case 29: return 19; 899 case 30: return 17; 900 case 31: return 0; 901 case 32: return 0; 902 case 33: return 0; 903 case 34: return 0; 904 case 35: return 0; 905 case 36: return 0; 906 case 37: return 0; 907 case 38: return 0; 908 case 39: return 0; 909 case 40: return 0; 910 default: 911 log("SYSERR: Missing level for thief spell saving throw."); 912 break; 913 } 914 default: 915 log("SYSERR: Invalid saving throw type."); 916 break; 917 } 918 break; 919 case CLASS_WARRIOR: 920 switch (type) { 921 case SAVING_PARA: /* Paralyzation */ 922 switch (level) { 923 case 0: return 90; 924 case 1: return 70; 925 case 2: return 68; 926 case 3: return 67; 927 case 4: return 65; 928 case 5: return 62; 929 case 6: return 58; 930 case 7: return 55; 931 case 8: return 53; 932 case 9: return 52; 933 case 10: return 50; 934 case 11: return 47; 935 case 12: return 43; 936 case 13: return 40; 937 case 14: return 38; 938 case 15: return 37; 939 case 16: return 35; 940 case 17: return 32; 941 case 18: return 28; 942 case 19: return 25; 943 case 20: return 24; 944 case 21: return 23; 945 case 22: return 22; 946 case 23: return 20; 947 case 24: return 19; 948 case 25: return 17; 949 case 26: return 16; 950 case 27: return 15; 951 case 28: return 14; 952 case 29: return 13; 953 case 30: return 12; 954 case 31: return 11; 955 case 32: return 10; 956 case 33: return 9; 957 case 34: return 8; 958 case 35: return 7; 959 case 36: return 6; 960 case 37: return 5; 961 case 38: return 4; 962 case 39: return 3; 963 case 40: return 2; 964 case 41: return 1; /* Some mobiles. */ 965 case 42: return 0; 966 case 43: return 0; 967 case 44: return 0; 968 case 45: return 0; 969 case 46: return 0; 970 case 47: return 0; 971 case 48: return 0; 972 case 49: return 0; 973 case 50: return 0; 974 default: 975 log("SYSERR: Missing level for warrior paralyzation saving throw."); 976 break; 977 } 978 case SAVING_ROD: /* Rods */ 979 switch (level) { 980 case 0: return 90; 981 case 1: return 80; 982 case 2: return 78; 983 case 3: return 77; 984 case 4: return 75; 985 case 5: return 72; 986 case 6: return 68; 987 case 7: return 65; 988 case 8: return 63; 989 case 9: return 62; 990 case 10: return 60; 991 case 11: return 57; 992 case 12: return 53; 993 case 13: return 50; 994 case 14: return 48; 995 case 15: return 47; 996 case 16: return 45; 997 case 17: return 42; 998 case 18: return 38; 999 case 19: return 35; 1000 case 20: return 34; 1001 case 21: return 33; 1002 case 22: return 32; 1003 case 23: return 30; 1004 case 24: return 29; 1005 case 25: return 27; 1006 case 26: return 26; 1007 case 27: return 25; 1008 case 28: return 24; 1009 case 29: return 23; 1010 case 30: return 22; 1011 case 31: return 20; 1012 case 32: return 18; 1013 case 33: return 16; 1014 case 34: return 14; 1015 case 35: return 12; 1016 case 36: return 10; 1017 case 37: return 8; 1018 case 38: return 6; 1019 case 39: return 5; 1020 case 40: return 4; 1021 case 41: return 3; 1022 case 42: return 2; 1023 case 43: return 1; 1024 case 44: return 0; 1025 case 45: return 0; 1026 case 46: return 0; 1027 case 47: return 0; 1028 case 48: return 0; 1029 case 49: return 0; 1030 case 50: return 0; 1031 default: 1032 log("SYSERR: Missing level for warrior rod saving throw."); 1033 break; 1034 } 1035 case SAVING_PETRI: /* Petrification */ 1036 switch (level) { 1037 case 0: return 90; 1038 case 1: return 75; 1039 case 2: return 73; 1040 case 3: return 72; 1041 case 4: return 70; 1042 case 5: return 67; 1043 case 6: return 63; 1044 case 7: return 60; 1045 case 8: return 58; 1046 case 9: return 57; 1047 case 10: return 55; 1048 case 11: return 52; 1049 case 12: return 48; 1050 case 13: return 45; 1051 case 14: return 43; 1052 case 15: return 42; 1053 case 16: return 40; 1054 case 17: return 37; 1055 case 18: return 33; 1056 case 19: return 30; 1057 case 20: return 29; 1058 case 21: return 28; 1059 case 22: return 26; 1060 case 23: return 25; 1061 case 24: return 24; 1062 case 25: return 23; 1063 case 26: return 21; 1064 case 27: return 20; 1065 case 28: return 19; 1066 case 29: return 18; 1067 case 30: return 17; 1068 case 31: return 16; 1069 case 32: return 15; 1070 case 33: return 14; 1071 case 34: return 13; 1072 case 35: return 12; 1073 case 36: return 11; 1074 case 37: return 10; 1075 case 38: return 9; 1076 case 39: return 8; 1077 case 40: return 7; 1078 case 41: return 6; 1079 case 42: return 5; 1080 case 43: return 4; 1081 case 44: return 3; 1082 case 45: return 2; 1083 case 46: return 1; 1084 case 47: return 0; 1085 case 48: return 0; 1086 case 49: return 0; 1087 case 50: return 0; 1088 default: 1089 log("SYSERR: Missing level for warrior petrification saving throw."); 1090 break; 1091 } 1092 case SAVING_BREATH: /* Breath weapons */ 1093 switch (level) { 1094 case 0: return 90; 1095 case 1: return 85; 1096 case 2: return 83; 1097 case 3: return 82; 1098 case 4: return 80; 1099 case 5: return 75; 1100 case 6: return 70; 1101 case 7: return 65; 1102 case 8: return 63; 1103 case 9: return 62; 1104 case 10: return 60; 1105 case 11: return 55; 1106 case 12: return 50; 1107 case 13: return 45; 1108 case 14: return 43; 1109 case 15: return 42; 1110 case 16: return 40; 1111 case 17: return 37; 1112 case 18: return 33; 1113 case 19: return 30; 1114 case 20: return 29; 1115 case 21: return 28; 1116 case 22: return 26; 1117 case 23: return 25; 1118 case 24: return 24; 1119 case 25: return 23; 1120 case 26: return 21; 1121 case 27: return 20; 1122 case 28: return 19; 1123 case 29: return 18; 1124 case 30: return 17; 1125 case 31: return 16; 1126 case 32: return 15; 1127 case 33: return 14; 1128 case 34: return 13; 1129 case 35: return 12; 1130 case 36: return 11; 1131 case 37: return 10; 1132 case 38: return 9; 1133 case 39: return 8; 1134 case 40: return 7; 1135 case 41: return 6; 1136 case 42: return 5; 1137 case 43: return 4; 1138 case 44: return 3; 1139 case 45: return 2; 1140 case 46: return 1; 1141 case 47: return 0; 1142 case 48: return 0; 1143 case 49: return 0; 1144 case 50: return 0; 1145 default: 1146 log("SYSERR: Missing level for warrior breath saving throw."); 1147 break; 1148 } 1149 case SAVING_SPELL: /* Generic spells */ 1150 switch (level) { 1151 case 0: return 90; 1152 case 1: return 85; 1153 case 2: return 83; 1154 case 3: return 82; 1155 case 4: return 80; 1156 case 5: return 77; 1157 case 6: return 73; 1158 case 7: return 70; 1159 case 8: return 68; 1160 case 9: return 67; 1161 case 10: return 65; 1162 case 11: return 62; 1163 case 12: return 58; 1164 case 13: return 55; 1165 case 14: return 53; 1166 case 15: return 52; 1167 case 16: return 50; 1168 case 17: return 47; 1169 case 18: return 43; 1170 case 19: return 40; 1171 case 20: return 39; 1172 case 21: return 38; 1173 case 22: return 36; 1174 case 23: return 35; 1175 case 24: return 34; 1176 case 25: return 33; 1177 case 26: return 31; 1178 case 27: return 30; 1179 case 28: return 29; 1180 case 29: return 28; 1181 case 30: return 27; 1182 case 31: return 25; 1183 case 32: return 23; 1184 case 33: return 21; 1185 case 34: return 19; 1186 case 35: return 17; 1187 case 36: return 15; 1188 case 37: return 13; 1189 case 38: return 11; 1190 case 39: return 9; 1191 case 40: return 7; 1192 case 41: return 6; 1193 case 42: return 5; 1194 case 43: return 4; 1195 case 44: return 3; 1196 case 45: return 2; 1197 case 46: return 1; 1198 case 47: return 0; 1199 case 48: return 0; 1200 case 49: return 0; 1201 case 50: return 0; 1202 default: 1203 log("SYSERR: Missing level for warrior spell saving throw."); 1204 break; 1205 } 1206 default: 1207 log("SYSERR: Invalid saving throw type."); 1208 break; 1209 } 1210 default: 1211 log("SYSERR: Invalid class saving throw."); 1212 break; 1213 } 1214 1215 /* Should not get here unless something is wrong. */ 1216 return 100; 1217 } 1218 1219 /* THAC0 for classes and levels. (To Hit Armor Class 0) */ 1220 int thaco(int class_num, int level) 1221 { 1222 switch (class_num) { 1223 case CLASS_MAGIC_USER: 1224 switch (level) { 1225 case 0: return 100; 1226 case 1: return 20; 1227 case 2: return 20; 1228 case 3: return 20; 1229 case 4: return 19; 1230 case 5: return 19; 1231 case 6: return 19; 1232 case 7: return 18; 1233 case 8: return 18; 1234 case 9: return 18; 1235 case 10: return 17; 1236 case 11: return 17; 1237 case 12: return 17; 1238 case 13: return 16; 1239 case 14: return 16; 1240 case 15: return 16; 1241 case 16: return 15; 1242 case 17: return 15; 1243 case 18: return 15; 1244 case 19: return 14; 1245 case 20: return 14; 1246 case 21: return 14; 1247 case 22: return 13; 1248 case 23: return 13; 1249 case 24: return 13; 1250 case 25: return 12; 1251 case 26: return 12; 1252 case 27: return 12; 1253 case 28: return 11; 1254 case 29: return 11; 1255 case 30: return 11; 1256 case 31: return 10; 1257 case 32: return 10; 1258 case 33: return 10; 1259 case 34: return 9; 1260 default: 1261 log("SYSERR: Missing level for mage thac0."); 1262 } 1263 case CLASS_CLERIC: 1264 switch (level) { 1265 case 0: return 100; 1266 case 1: return 20; 1267 case 2: return 20; 1268 case 3: return 20; 1269 case 4: return 18; 1270 case 5: return 18; 1271 case 6: return 18; 1272 case 7: return 16; 1273 case 8: return 16; 1274 case 9: return 16; 1275 case 10: return 14; 1276 case 11: return 14; 1277 case 12: return 14; 1278 case 13: return 12; 1279 case 14: return 12; 1280 case 15: return 12; 1281 case 16: return 10; 1282 case 17: return 10; 1283 case 18: return 10; 1284 case 19: return 8; 1285 case 20: return 8; 1286 case 21: return 8; 1287 case 22: return 6; 1288 case 23: return 6; 1289 case 24: return 6; 1290 case 25: return 4; 1291 case 26: return 4; 1292 case 27: return 4; 1293 case 28: return 2; 1294 case 29: return 2; 1295 case 30: return 2; 1296 case 31: return 1; 1297 case 32: return 1; 1298 case 33: return 1; 1299 case 34: return 1; 1300 default: 1301 log("SYSERR: Missing level for cleric thac0."); 1302 } 1303 case CLASS_THIEF: 1304 switch (level) { 1305 case 0: return 100; 1306 case 1: return 20; 1307 case 2: return 20; 1308 case 3: return 19; 1309 case 4: return 19; 1310 case 5: return 18; 1311 case 6: return 18; 1312 case 7: return 17; 1313 case 8: return 17; 1314 case 9: return 16; 1315 case 10: return 16; 1316 case 11: return 15; 1317 case 12: return 15; 1318 case 13: return 14; 1319 case 14: return 14; 1320 case 15: return 13; 1321 case 16: return 13; 1322 case 17: return 12; 1323 case 18: return 12; 1324 case 19: return 11; 1325 case 20: return 11; 1326 case 21: return 10; 1327 case 22: return 10; 1328 case 23: return 9; 1329 case 24: return 9; 1330 case 25: return 8; 1331 case 26: return 8; 1332 case 27: return 7; 1333 case 28: return 7; 1334 case 29: return 6; 1335 case 30: return 6; 1336 case 31: return 5; 1337 case 32: return 5; 1338 case 33: return 4; 1339 case 34: return 4; 1340 default: 1341 log("SYSERR: Missing level for thief thac0."); 1342 } 1343 case CLASS_WARRIOR: 1344 switch (level) { 1345 case 0: return 100; 1346 case 1: return 20; 1347 case 2: return 19; 1348 case 3: return 18; 1349 case 4: return 17; 1350 case 5: return 16; 1351 case 6: return 15; 1352 case 7: return 14; 1353 case 8: return 14; 1354 case 9: return 13; 1355 case 10: return 12; 1356 case 11: return 11; 1357 case 12: return 10; 1358 case 13: return 9; 1359 case 14: return 8; 1360 case 15: return 7; 1361 case 16: return 6; 1362 case 17: return 5; 1363 case 18: return 4; 1364 case 19: return 3; 1365 case 20: return 2; 1366 case 21: return 1; 1367 case 22: return 1; 1368 case 23: return 1; 1369 case 24: return 1; 1370 case 25: return 1; 1371 case 26: return 1; 1372 case 27: return 1; 1373 case 28: return 1; 1374 case 29: return 1; 1375 case 30: return 1; 1376 case 31: return 1; 1377 case 32: return 1; 1378 case 33: return 1; 1379 case 34: return 1; 1380 default: 1381 log("SYSERR: Missing level for warrior thac0."); 1382 } 1383 default: 1384 log("SYSERR: Unknown class in thac0 chart."); 1385 } 1386 1387 /* Will not get there unless something is wrong. */ 1388 return 100; 1389 } 1390 1391 1392 /* 1393 * Roll the 6 stats for a character... each stat is made of the sum of 1394 * the best 3 out of 4 rolls of a 6-sided die. Each class then decides 1395 * which priority will be given for the best to worst stats. 1396 */ 1397 void roll_real_abils(struct char_data *ch) 1398 { 1399 int i, j, k, temp; 1400 ubyte table[6]; 1401 ubyte rolls[4]; 1402 1403 for (i = 0; i < 6; i++) 1404 table[i] = 0; 1405 1406 for (i = 0; i < 6; i++) { 1407 1408 for (j = 0; j < 4; j++) 1409 rolls[j] = rand_number(1, 6); 1410 1411 temp = rolls[0] + rolls[1] + rolls[2] + rolls[3] - 1412 MIN(rolls[0], MIN(rolls[1], MIN(rolls[2], rolls[3]))); 1413 1414 for (k = 0; k < 6; k++) 1415 if (table[k] < temp) { 1416 temp ^= table[k]; 1417 table[k] ^= temp; 1418 temp ^= table[k]; 1419 } 1420 } 1421 1422 ch->real_abils.str_add = 0; 1423 1424 switch (GET_CLASS(ch)) { 1425 case CLASS_MAGIC_USER: 1426 ch->real_abils.intel = table[0]; 1427 ch->real_abils.wis = table[1]; 1428 ch->real_abils.dex = table[2]; 1429 ch->real_abils.str = table[3]; 1430 ch->real_abils.con = table[4]; 1431 ch->real_abils.cha = table[5]; 1432 break; 1433 case CLASS_CLERIC: 1434 ch->real_abils.wis = table[0]; 1435 ch->real_abils.intel = table[1]; 1436 ch->real_abils.str = table[2]; 1437 ch->real_abils.dex = table[3]; 1438 ch->real_abils.con = table[4]; 1439 ch->real_abils.cha = table[5]; 1440 break; 1441 case CLASS_THIEF: 1442 ch->real_abils.dex = table[0]; 1443 ch->real_abils.str = table[1]; 1444 ch->real_abils.con = table[2]; 1445 ch->real_abils.intel = table[3]; 1446 ch->real_abils.wis = table[4]; 1447 ch->real_abils.cha = table[5]; 1448 break; 1449 case CLASS_WARRIOR: 1450 ch->real_abils.str = table[0]; 1451 ch->real_abils.dex = table[1]; 1452 ch->real_abils.con = table[2]; 1453 ch->real_abils.wis = table[3]; 1454 ch->real_abils.intel = table[4]; 1455 ch->real_abils.cha = table[5]; 1456 if (ch->real_abils.str == 18) 1457 ch->real_abils.str_add = rand_number(0, 100); 1458 break; 1459 } 1460 ch->aff_abils = ch->real_abils; 1461 } 1462 1463 1464 /* Some initializations for characters, including initial skills */ 1465 void do_start(struct char_data *ch) 1466 { 1467 GET_LEVEL(ch) = 1; 1468 GET_EXP(ch) = 1; 1469 1470 set_title(ch, NULL); 1471 roll_real_abils(ch); 1472 1473 GET_MAX_HIT(ch) = 10; 1474 GET_MAX_MANA(ch) = 100; 1475 GET_MAX_MOVE(ch) = 82; 1476 1477 switch (GET_CLASS(ch)) { 1478 1479 case CLASS_MAGIC_USER: 1480 break; 1481 1482 case CLASS_CLERIC: 1483 break; 1484 1485 case CLASS_THIEF: 1486 SET_SKILL(ch, SKILL_SNEAK, 10); 1487 SET_SKILL(ch, SKILL_HIDE, 5); 1488 SET_SKILL(ch, SKILL_STEAL, 15); 1489 SET_SKILL(ch, SKILL_BACKSTAB, 10); 1490 SET_SKILL(ch, SKILL_PICK_LOCK, 10); 1491 SET_SKILL(ch, SKILL_TRACK, 10); 1492 break; 1493 1494 case CLASS_WARRIOR: 1495 break; 1496 } 1497 1498 advance_level(ch); 1499 mudlog(BRF, MAX(LVL_IMMORT, GET_INVIS_LEV(ch)), TRUE, "%s advanced to level %d", GET_NAME(ch), GET_LEVEL(ch)); 1500 1501 GET_HIT(ch) = GET_MAX_HIT(ch); 1502 GET_MANA(ch) = GET_MAX_MANA(ch); 1503 GET_MOVE(ch) = GET_MAX_MOVE(ch); 1504 1505 GET_COND(ch, THIRST) = 24; 1506 GET_COND(ch, FULL) = 24; 1507 GET_COND(ch, DRUNK) = 0; 1508 1509 if (siteok_everyone) 1510 SET_BIT(PLR_FLAGS(ch), PLR_SITEOK); 1511 } 1512 1513 1514 1515 /* 1516 * This function controls the change to maxmove, maxmana, and maxhp for 1517 * each class every time they gain a level. 1518 */ 1519 void advance_level(struct char_data *ch) 1520 { 1521 int add_hp, add_mana = 0, add_move = 0, i; 1522 1523 add_hp = con_app[GET_CON(ch)].hitp; 1524 1525 switch (GET_CLASS(ch)) { 1526 1527 case CLASS_MAGIC_USER: 1528 add_hp += rand_number(3, 8); 1529 add_mana = rand_number(GET_LEVEL(ch), (int)(1.5 * GET_LEVEL(ch))); 1530 add_mana = MIN(add_mana, 10); 1531 add_move = rand_number(0, 2); 1532 break; 1533 1534 case CLASS_CLERIC: 1535 add_hp += rand_number(5, 10); 1536 add_mana = rand_number(GET_LEVEL(ch), (int)(1.5 * GET_LEVEL(ch))); 1537 add_mana = MIN(add_mana, 10); 1538 add_move = rand_number(0, 2); 1539 break; 1540 1541 case CLASS_THIEF: 1542 add_hp += rand_number(7, 13); 1543 add_mana = 0; 1544 add_move = rand_number(1, 3); 1545 break; 1546 1547 case CLASS_WARRIOR: 1548 add_hp += rand_number(10, 15); 1549 add_mana = 0; 1550 add_move = rand_number(1, 3); 1551 break; 1552 } 1553 1554 ch->points.max_hit += MAX(1, add_hp); 1555 ch->points.max_move += MAX(1, add_move); 1556 1557 if (GET_LEVEL(ch) > 1) 1558 ch->points.max_mana += add_mana; 1559 1560 if (IS_MAGIC_USER(ch) || IS_CLERIC(ch)) 1561 GET_PRACTICES(ch) += MAX(2, wis_app[GET_WIS(ch)].bonus); 1562 else 1563 GET_PRACTICES(ch) += MIN(2, MAX(1, wis_app[GET_WIS(ch)].bonus)); 1564 1565 if (GET_LEVEL(ch) >= LVL_IMMORT) { 1566 for (i = 0; i < 3; i++) 1567 GET_COND(ch, i) = (char) -1; 1568 SET_BIT(PRF_FLAGS(ch), PRF_HOLYLIGHT); 1569 } 1570 1571 snoop_check(ch); 1572 save_char(ch); 1573 } 1574 1575 1576 /* 1577 * This simply calculates the backstab multiplier based on a character's 1578 * level. This used to be an array, but was changed to be a function so 1579 * that it would be easier to add more levels to your MUD. This doesn't 1580 * really create a big performance hit because it's not used very often. 1581 */ 1582 int backstab_mult(int level) 1583 { 1584 if (level <= 0) 1585 return 1; /* level 0 */ 1586 else if (level <= 7) 1587 return 2; /* level 1 - 7 */ 1588 else if (level <= 13) 1589 return 3; /* level 8 - 13 */ 1590 else if (level <= 20) 1591 return 4; /* level 14 - 20 */ 1592 else if (level <= 28) 1593 return 5; /* level 21 - 28 */ 1594 else if (level < LVL_IMMORT) 1595 return 6; /* all remaining mortal levels */ 1596 else 1597 return 20; /* immortals */ 1598 } 1599 1600 1601 /* 1602 * invalid_class is used by handler.c to determine if a piece of equipment is 1603 * usable by a particular class, based on the ITEM_ANTI_{class} bitvectors. 1604 */ 1605 int invalid_class(struct char_data *ch, struct obj_data *obj) 1606 { 1607 if (OBJ_FLAGGED(obj, ITEM_ANTI_MAGIC_USER) && IS_MAGIC_USER(ch)) 1608 return TRUE; 1609 1610 if (OBJ_FLAGGED(obj, ITEM_ANTI_CLERIC) && IS_CLERIC(ch)) 1611 return TRUE; 1612 1613 if (OBJ_FLAGGED(obj, ITEM_ANTI_WARRIOR) && IS_WARRIOR(ch)) 1614 return TRUE; 1615 1616 if (OBJ_FLAGGED(obj, ITEM_ANTI_THIEF) && IS_THIEF(ch)) 1617 return TRUE; 1618 1619 return FALSE; 1620 } 1621 1622 1623 /* 1624 * SPELLS AND SKILLS. This area defines which spells are assigned to 1625 * which classes, and the minimum level the character must be to use 1626 * the spell or skill. 1627 */ 1628 void init_spell_levels(void) 1629 { 1630 /* MAGES */ 1631 spell_level(SPELL_MAGIC_MISSILE, CLASS_MAGIC_USER, 1); 1632 spell_level(SPELL_DETECT_INVIS, CLASS_MAGIC_USER, 2); 1633 spell_level(SPELL_DETECT_MAGIC, CLASS_MAGIC_USER, 2); 1634 spell_level(SPELL_CHILL_TOUCH, CLASS_MAGIC_USER, 3); 1635 spell_level(SPELL_INFRAVISION, CLASS_MAGIC_USER, 3); 1636 spell_level(SPELL_INVISIBLE, CLASS_MAGIC_USER, 4); 1637 spell_level(SPELL_ARMOR, CLASS_MAGIC_USER, 4); 1638 spell_level(SPELL_BURNING_HANDS, CLASS_MAGIC_USER, 5); 1639 spell_level(SPELL_LOCATE_OBJECT, CLASS_MAGIC_USER, 6); 1640 spell_level(SPELL_STRENGTH, CLASS_MAGIC_USER, 6); 1641 spell_level(SPELL_SHOCKING_GRASP, CLASS_MAGIC_USER, 7); 1642 spell_level(SPELL_SLEEP, CLASS_MAGIC_USER, 8); 1643 spell_level(SPELL_LIGHTNING_BOLT, CLASS_MAGIC_USER, 9); 1644 spell_level(SPELL_BLINDNESS, CLASS_MAGIC_USER, 9); 1645 spell_level(SPELL_DETECT_POISON, CLASS_MAGIC_USER, 10); 1646 spell_level(SPELL_COLOR_SPRAY, CLASS_MAGIC_USER, 11); 1647 spell_level(SPELL_ENERGY_DRAIN, CLASS_MAGIC_USER, 13); 1648 spell_level(SPELL_CURSE, CLASS_MAGIC_USER, 14); 1649 spell_level(SPELL_POISON, CLASS_MAGIC_USER, 14); 1650 spell_level(SPELL_FIREBALL, CLASS_MAGIC_USER, 15); 1651 spell_level(SPELL_CHARM, CLASS_MAGIC_USER, 16); 1652 spell_level(SPELL_ENCHANT_WEAPON, CLASS_MAGIC_USER, 26); 1653 spell_level(SPELL_CLONE, CLASS_MAGIC_USER, 30); 1654 1655 /* CLERICS */ 1656 spell_level(SPELL_CURE_LIGHT, CLASS_CLERIC, 1); 1657 spell_level(SPELL_ARMOR, CLASS_CLERIC, 1); 1658 spell_level(SPELL_CREATE_FOOD, CLASS_CLERIC, 2); 1659 spell_level(SPELL_CREATE_WATER, CLASS_CLERIC, 2); 1660 spell_level(SPELL_DETECT_POISON, CLASS_CLERIC, 3); 1661 spell_level(SPELL_DETECT_ALIGN, CLASS_CLERIC, 4); 1662 spell_level(SPELL_CURE_BLIND, CLASS_CLERIC, 4); 1663 spell_level(SPELL_BLESS, CLASS_CLERIC, 5); 1664 spell_level(SPELL_DETECT_INVIS, CLASS_CLERIC, 6); 1665 spell_level(SPELL_BLINDNESS, CLASS_CLERIC, 6); 1666 spell_level(SPELL_INFRAVISION, CLASS_CLERIC, 7); 1667 spell_level(SPELL_PROT_FROM_EVIL, CLASS_CLERIC, 8); 1668 spell_level(SPELL_POISON, CLASS_CLERIC, 8); 1669 spell_level(SPELL_GROUP_ARMOR, CLASS_CLERIC, 9); 1670 spell_level(SPELL_CURE_CRITIC, CLASS_CLERIC, 9); 1671 spell_level(SPELL_SUMMON, CLASS_CLERIC, 10); 1672 spell_level(SPELL_REMOVE_POISON, CLASS_CLERIC, 10); 1673 spell_level(SPELL_WORD_OF_RECALL, CLASS_CLERIC, 12); 1674 spell_level(SPELL_EARTHQUAKE, CLASS_CLERIC, 12); 1675 spell_level(SPELL_DISPEL_EVIL, CLASS_CLERIC, 14); 1676 spell_level(SPELL_DISPEL_GOOD, CLASS_CLERIC, 14); 1677 spell_level(SPELL_SANCTUARY, CLASS_CLERIC, 15); 1678 spell_level(SPELL_CALL_LIGHTNING, CLASS_CLERIC, 15); 1679 spell_level(SPELL_HEAL, CLASS_CLERIC, 16); 1680 spell_level(SPELL_CONTROL_WEATHER, CLASS_CLERIC, 17); 1681 spell_level(SPELL_SENSE_LIFE, CLASS_CLERIC, 18); 1682 spell_level(SPELL_HARM, CLASS_CLERIC, 19); 1683 spell_level(SPELL_GROUP_HEAL, CLASS_CLERIC, 22); 1684 spell_level(SPELL_REMOVE_CURSE, CLASS_CLERIC, 26); 1685 1686 /* THIEVES */ 1687 spell_level(SKILL_SNEAK, CLASS_THIEF, 1); 1688 spell_level(SKILL_PICK_LOCK, CLASS_THIEF, 2); 1689 spell_level(SKILL_BACKSTAB, CLASS_THIEF, 3); 1690 spell_level(SKILL_STEAL, CLASS_THIEF, 4); 1691 spell_level(SKILL_HIDE, CLASS_THIEF, 5); 1692 spell_level(SKILL_TRACK, CLASS_THIEF, 6); 1693 1694 /* WARRIORS */ 1695 spell_level(SKILL_KICK, CLASS_WARRIOR, 1); 1696 spell_level(SKILL_RESCUE, CLASS_WARRIOR, 3); 1697 spell_level(SKILL_TRACK, CLASS_WARRIOR, 9); 1698 spell_level(SKILL_BASH, CLASS_WARRIOR, 12); 1699 } 1700 1701 1702 /* 1703 * This is the exp given to implementors -- it must always be greater 1704 * than the exp required for immortality, plus at least 20,000 or so. 1705 */ 1706 #define EXP_MAX 10000000 1707 1708 /* Function to return the exp required for each class/level */ 1709 int level_exp(int chclass, int level) 1710 { 1711 if (level > LVL_IMPL || level < 0) { 1712 log("SYSERR: Requesting exp for invalid level %d!", level); 1713 return 0; 1714 } 1715 1716 /* 1717 * Gods have exp close to EXP_MAX. This statement should never have to 1718 * changed, regardless of how many mortal or immortal levels exist. 1719 */ 1720 if (level > LVL_IMMORT) { 1721 return EXP_MAX - ((LVL_IMPL - level) * 1000); 1722 } 1723 1724 /* Exp required for normal mortals is below */ 1725 1726 switch (chclass) { 1727 1728 case CLASS_MAGIC_USER: 1729 switch (level) { 1730 case 0: return 0; 1731 case 1: return 1; 1732 case 2: return 2500; 1733 case 3: return 5000; 1734 case 4: return 10000; 1735 case 5: return 20000; 1736 case 6: return 40000; 1737 case 7: return 60000; 1738 case 8: return 90000; 1739 case 9: return 135000; 1740 case 10: return 250000; 1741 case 11: return 375000; 1742 case 12: return 750000; 1743 case 13: return 1125000; 1744 case 14: return 1500000; 1745 case 15: return 1875000; 1746 case 16: return 2250000; 1747 case 17: return 2625000; 1748 case 18: return 3000000; 1749 case 19: return 3375000; 1750 case 20: return 3750000; 1751 case 21: return 4000000; 1752 case 22: return 4300000; 1753 case 23: return 4600000; 1754 case 24: return 4900000; 1755 case 25: return 5200000; 1756 case 26: return 5500000; 1757 case 27: return 5950000; 1758 case 28: return 6400000; 1759 case 29: return 6850000; 1760 case 30: return 7400000; 1761 /* add new levels here */ 1762 case LVL_IMMORT: return 8000000; 1763 } 1764 break; 1765 1766 case CLASS_CLERIC: 1767 switch (level) { 1768 case 0: return 0; 1769 case 1: return 1; 1770 case 2: return 1500; 1771 case 3: return 3000; 1772 case 4: return 6000; 1773 case 5: return 13000; 1774 case 6: return 27500; 1775 case 7: return 55000; 1776 case 8: return 110000; 1777 case 9: return 225000; 1778 case 10: return 450000; 1779 case 11: return 675000; 1780 case 12: return 900000; 1781 case 13: return 1125000; 1782 case 14: return 1350000; 1783 case 15: return 1575000; 1784 case 16: return 1800000; 1785 case 17: return 2100000; 1786 case 18: return 2400000; 1787 case 19: return 2700000; 1788 case 20: return 3000000; 1789 case 21: return 3250000; 1790 case 22: return 3500000; 1791 case 23: return 3800000; 1792 case 24: return 4100000; 1793 case 25: return 4400000; 1794 case 26: return 4800000; 1795 case 27: return 5200000; 1796 case 28: return 5600000; 1797 case 29: return 6000000; 1798 case 30: return 6400000; 1799 /* add new levels here */ 1800 case LVL_IMMORT: return 7000000; 1801 } 1802 break; 1803 1804 case CLASS_THIEF: 1805 switch (level) { 1806 case 0: return 0; 1807 case 1: return 1; 1808 case 2: return 1250; 1809 case 3: return 2500; 1810 case 4: return 5000; 1811 case 5: return 10000; 1812 case 6: return 20000; 1813 case 7: return 40000; 1814 case 8: return 70000; 1815 case 9: return 110000; 1816 case 10: return 160000; 1817 case 11: return 220000; 1818 case 12: return 440000; 1819 case 13: return 660000; 1820 case 14: return 880000; 1821 case 15: return 1100000; 1822 case 16: return 1500000; 1823 case 17: return 2000000; 1824 case 18: return 2500000; 1825 case 19: return 3000000; 1826 case 20: return 3500000; 1827 case 21: return 3650000; 1828 case 22: return 3800000; 1829 case 23: return 4100000; 1830 case 24: return 4400000; 1831 case 25: return 4700000; 1832 case 26: return 5100000; 1833 case 27: return 5500000; 1834 case 28: return 5900000; 1835 case 29: return 6300000; 1836 case 30: return 6650000; 1837 /* add new levels here */ 1838 case LVL_IMMORT: return 7000000; 1839 } 1840 break; 1841 1842 case CLASS_WARRIOR: 1843 switch (level) { 1844 case 0: return 0; 1845 case 1: return 1; 1846 case 2: return 2000; 1847 case 3: return 4000; 1848 case 4: return 8000; 1849 case 5: return 16000; 1850 case 6: return 32000; 1851 case 7: return 64000; 1852 case 8: return 125000; 1853 case 9: return 250000; 1854 case 10: return 500000; 1855 case 11: return 750000; 1856 case 12: return 1000000; 1857 case 13: return 1250000; 1858 case 14: return 1500000; 1859 case 15: return 1850000; 1860 case 16: return 2200000; 1861 case 17: return 2550000; 1862 case 18: return 2900000; 1863 case 19: return 3250000; 1864 case 20: return 3600000; 1865 case 21: return 3900000; 1866 case 22: return 4200000; 1867 case 23: return 4500000; 1868 case 24: return 4800000; 1869 case 25: return 5150000; 1870 case 26: return 5500000; 1871 case 27: return 5950000; 1872 case 28: return 6400000; 1873 case 29: return 6850000; 1874 case 30: return 7400000; 1875 /* add new levels here */ 1876 case LVL_IMMORT: return 8000000; 1877 } 1878 break; 1879 } 1880 1881 /* 1882 * This statement should never be reached if the exp tables in this function 1883 * are set up properly. If you see exp of 123456 then the tables above are 1884 * incomplete -- so, complete them! 1885 */ 1886 log("SYSERR: XP tables not set up correctly in class.c!"); 1887 return 123456; 1888 } 1889 1890 1891 /* 1892 * Default titles of male characters. 1893 */ 1894 const char *title_male(int chclass, int level) 1895 { 1896 if (level <= 0 || level > LVL_IMPL) 1897 return "the Man"; 1898 if (level == LVL_IMPL) 1899 return "the Implementor"; 1900 1901 switch (chclass) { 1902 1903 case CLASS_MAGIC_USER: 1904 switch (level) { 1905 case 1: return "the Apprentice of Magic"; 1906 case 2: return "the Spell Student"; 1907 case 3: return "the Scholar of Magic"; 1908 case 4: return "the Delver in Spells"; 1909 case 5: return "the Medium of Magic"; 1910 case 6: return "the Scribe of Magic"; 1911 case 7: return "the Seer"; 1912 case 8: return "the Sage"; 1913 case 9: return "the Illusionist"; 1914 case 10: return "the Abjurer"; 1915 case 11: return "the Invoker"; 1916 case 12: return "the Enchanter"; 1917 case 13: return "the Conjurer"; 1918 case 14: return "the Magician"; 1919 case 15: return "the Creator"; 1920 case 16: return "the Savant"; 1921 case 17: return "the Magus"; 1922 case 18: return "the Wizard"; 1923 case 19: return "the Warlock"; 1924 case 20: return "the Sorcerer"; 1925 case 21: return "the Necromancer"; 1926 case 22: return "the Thaumaturge"; 1927 case 23: return "the Student of the Occult"; 1928 case 24: return "the Disciple of the Uncanny"; 1929 case 25: return "the Minor Elemental"; 1930 case 26: return "the Greater Elemental"; 1931 case 27: return "the Crafter of Magics"; 1932 case 28: return "the Shaman"; 1933 case 29: return "the Keeper of Talismans"; 1934 case 30: return "the Archmage"; 1935 case LVL_IMMORT: return "the Immortal Warlock"; 1936 case LVL_GOD: return "the Avatar of Magic"; 1937 case LVL_GRGOD: return "the God of Magic"; 1938 default: return "the Mage"; 1939 } 1940 break; 1941 1942 case CLASS_CLERIC: 1943 switch (level) { 1944 case 1: return "the Believer"; 1945 case 2: return "the Attendant"; 1946 case 3: return "the Acolyte"; 1947 case 4: return "the Novice"; 1948 case 5: return "the Missionary"; 1949 case 6: return "the Adept"; 1950 case 7: return "the Deacon"; 1951 case 8: return "the Vicar"; 1952 case 9: return "the Priest"; 1953 case 10: return "the Minister"; 1954 case 11: return "the Canon"; 1955 case 12: return "the Levite"; 1956 case 13: return "the Curate"; 1957 case 14: return "the Monk"; 1958 case 15: return "the Healer"; 1959 case 16: return "the Chaplain"; 1960 case 17: return "the Expositor"; 1961 case 18: return "the Bishop"; 1962 case 19: return "the Arch Bishop"; 1963 case 20: return "the Patriarch"; 1964 /* no one ever thought up these titles 21-30 */ 1965 case LVL_IMMORT: return "the Immortal Cardinal"; 1966 case LVL_GOD: return "the Inquisitor"; 1967 case LVL_GRGOD: return "the God of good and evil"; 1968 default: return "the Cleric"; 1969 } 1970 break; 1971 1972 case CLASS_THIEF: 1973 switch (level) { 1974 case 1: return "the Pilferer"; 1975 case 2: return "the Footpad"; 1976 case 3: return "the Filcher"; 1977 case 4: return "the Pick-Pocket"; 1978 case 5: return "the Sneak"; 1979 case 6: return "the Pincher"; 1980 case 7: return "the Cut-Purse"; 1981 case 8: return "the Snatcher"; 1982 case 9: return "the Sharper"; 1983 case 10: return "the Rogue"; 1984 case 11: return "the Robber"; 1985 case 12: return "the Magsman"; 1986 case 13: return "the Highwayman"; 1987 case 14: return "the Burglar"; 1988 case 15: return "the Thief"; 1989 case 16: return "the Knifer"; 1990 case 17: return "the Quick-Blade"; 1991 case 18: return "the Killer"; 1992 case 19: return "the Brigand"; 1993 case 20: return "the Cut-Throat"; 1994 /* no one ever thought up these titles 21-30 */ 1995 case LVL_IMMORT: return "the Immortal Assasin"; 1996 case LVL_GOD: return "the Demi God of thieves"; 1997 case LVL_GRGOD: return "the God of thieves and tradesmen"; 1998 default: return "the Thief"; 1999 } 2000 break; 2001 2002 case CLASS_WARRIOR: 2003 switch(level) { 2004 case 1: return "the Swordpupil"; 2005 case 2: return "the Recruit"; 2006 case 3: return "the Sentry"; 2007 case 4: return "the Fighter"; 2008 case 5: return "the Soldier"; 2009 case 6: return "the Warrior"; 2010 case 7: return "the Veteran"; 2011 case 8: return "the Swordsman"; 2012 case 9: return "the Fencer"; 2013 case 10: return "the Combatant"; 2014 case 11: return "the Hero"; 2015 case 12: return "the Myrmidon"; 2016 case 13: return "the Swashbuckler"; 2017 case 14: return "the Mercenary"; 2018 case 15: return "the Swordmaster"; 2019 case 16: return "the Lieutenant"; 2020 case 17: return "the Champion"; 2021 case 18: return "the Dragoon"; 2022 case 19: return "the Cavalier"; 2023 case 20: return "the Knight"; 2024 /* no one ever thought up these titles 21-30 */ 2025 case LVL_IMMORT: return "the Immortal Warlord"; 2026 case LVL_GOD: return "the Extirpator"; 2027 case LVL_GRGOD: return "the God of war"; 2028 default: return "the Warrior"; 2029 } 2030 break; 2031 } 2032 2033 /* Default title for classes which do not have titles defined */ 2034 return "the Classless"; 2035 } 2036 2037 2038 /* 2039 * Default titles of female characters. 2040 */ 2041 const char *title_female(int chclass, int level) 2042 { 2043 if (level <= 0 || level > LVL_IMPL) 2044 return "the Woman"; 2045 if (level == LVL_IMPL) 2046 return "the Implementress"; 2047 2048 switch (chclass) { 2049 2050 case CLASS_MAGIC_USER: 2051 switch (level) { 2052 case 1: return "the Apprentice of Magic"; 2053 case 2: return "the Spell Student"; 2054 case 3: return "the Scholar of Magic"; 2055 case 4: return "the Delveress in Spells"; 2056 case 5: return "the Medium of Magic"; 2057 case 6: return "the Scribess of Magic"; 2058 case 7: return "the Seeress"; 2059 case 8: return "the Sage"; 2060 case 9: return "the Illusionist"; 2061 case 10: return "the Abjuress"; 2062 case 11: return "the Invoker"; 2063 case 12: return "the Enchantress"; 2064 case 13: return "the Conjuress"; 2065 case 14: return "the Witch"; 2066 case 15: return "the Creator"; 2067 case 16: return "the Savant"; 2068 case 17: return "the Craftess"; 2069 case 18: return "the Wizard"; 2070 case 19: return "the War Witch"; 2071 case 20: return "the Sorceress"; 2072 case 21: return "the Necromancress"; 2073 case 22: return "the Thaumaturgess"; 2074 case 23: return "the Student of the Occult"; 2075 case 24: return "the Disciple of the Uncanny"; 2076 case 25: return "the Minor Elementress"; 2077 case 26: return "the Greater Elementress"; 2078 case 27: return "the Crafter of Magics"; 2079 case 28: return "Shaman"; 2080 case 29: return "the Keeper of Talismans"; 2081 case 30: return "Archwitch"; 2082 case LVL_IMMORT: return "the Immortal Enchantress"; 2083 case LVL_GOD: return "the Empress of Magic"; 2084 case LVL_GRGOD: return "the Goddess of Magic"; 2085 default: return "the Witch"; 2086 } 2087 break; 2088 2089 case CLASS_CLERIC: 2090 switch (level) { 2091 case 1: return "the Believer"; 2092 case 2: return "the Attendant"; 2093 case 3: return "the Acolyte"; 2094 case 4: return "the Novice"; 2095 case 5: return "the Missionary"; 2096 case 6: return "the Adept"; 2097 case 7: return "the Deaconess"; 2098 case 8: return "the Vicaress"; 2099 case 9: return "the Priestess"; 2100 case 10: return "the Lady Minister"; 2101 case 11: return "the Canon"; 2102 case 12: return "the Levitess"; 2103 case 13: return "the Curess"; 2104 case 14: return "the Nunne"; 2105 case 15: return "the Healess"; 2106 case 16: return "the Chaplain"; 2107 case 17: return "the Expositress"; 2108 case 18: return "the Bishop"; 2109 case 19: return "the Arch Lady of the Church"; 2110 case 20: return "the Matriarch"; 2111 /* no one ever thought up these titles 21-30 */ 2112 case LVL_IMMORT: return "the Immortal Priestess"; 2113 case LVL_GOD: return "the Inquisitress"; 2114 case LVL_GRGOD: return "the Goddess of good and evil"; 2115 default: return "the Cleric"; 2116 } 2117 break; 2118 2119 case CLASS_THIEF: 2120 switch (level) { 2121 case 1: return "the Pilferess"; 2122 case 2: return "the Footpad"; 2123 case 3: return "the Filcheress"; 2124 case 4: return "the Pick-Pocket"; 2125 case 5: return "the Sneak"; 2126 case 6: return "the Pincheress"; 2127 case 7: return "the Cut-Purse"; 2128 case 8: return "the Snatcheress"; 2129 case 9: return "the Sharpress"; 2130 case 10: return "the Rogue"; 2131 case 11: return "the Robber"; 2132 case 12: return "the Magswoman"; 2133 case 13: return "the Highwaywoman"; 2134 case 14: return "the Burglaress"; 2135 case 15: return "the Thief"; 2136 case 16: return "the Knifer"; 2137 case 17: return "the Quick-Blade"; 2138 case 18: return "the Murderess"; 2139 case 19: return "the Brigand"; 2140 case 20: return "the Cut-Throat"; 2141 /* no one ever thought up these titles 21-30 */ 2142 case LVL_IMMORT: return "the Immortal Assasin"; 2143 case LVL_GOD: return "the Demi Goddess of thieves"; 2144 case LVL_GRGOD: return "the Goddess of thieves and tradesmen"; 2145 default: return "the Thief"; 2146 } 2147 break; 2148 2149 case CLASS_WARRIOR: 2150 switch(level) { 2151 case 1: return "the Swordpupil"; 2152 case 2: return "the Recruit"; 2153 case 3: return "the Sentress"; 2154 case 4: return "the Fighter"; 2155 case 5: return "the Soldier"; 2156 case 6: return "the Warrior"; 2157 case 7: return "the Veteran"; 2158 case 8: return "the Swordswoman"; 2159 case 9: return "the Fenceress"; 2160 case 10: return "the Combatess"; 2161 case 11: return "the Heroine"; 2162 case 12: return "the Myrmidon"; 2163 case 13: return "the Swashbuckleress"; 2164 case 14: return "the Mercenaress"; 2165 case 15: return "the Swordmistress"; 2166 case 16: return "the Lieutenant"; 2167 case 17: return "the Lady Champion"; 2168 case 18: return "the Lady Dragoon"; 2169 case 19: return "the Cavalier"; 2170 case 20: return "the Lady Knight"; 2171 /* no one ever thought up these titles 21-30 */ 2172 case LVL_IMMORT: return "the Immortal Lady of War"; 2173 case LVL_GOD: return "the Queen of Destruction"; 2174 case LVL_GRGOD: return "the Goddess of war"; 2175 default: return "the Warrior"; 2176 } 2177 break; 2178 } 2179 2180 /* Default title for classes which do not have titles defined */ 2181 return "the Classless"; 2182 } 2183