home *** CD-ROM | disk | FTP | other *** search
/ Hall of Fame / HallofFameCDROM.cdr / proglc / mor4873s.lzh / CREATE.C < prev    next >
C/C++ Source or Header  |  1988-11-01  |  12KB  |  503 lines
  1. #include <stdio.h>
  2.  
  3. #include "constant.h"
  4. #include "config.h"
  5. #include "types.h"
  6. #include "externs.h"
  7.  
  8. #ifdef USG
  9. #include <string.h>
  10. #else
  11. #include <strings.h>
  12. #endif
  13.  
  14. #ifdef sun   /* correct SUN stupidity in the stdio.h file */
  15. char *sprintf();
  16. #endif
  17.  
  18. #ifdef USG
  19. unsigned sleep();
  20. #endif
  21.  
  22. #ifdef ultrix
  23. void sleep();
  24. #endif
  25.  
  26. /* Generates character's stats                -JWT-    */
  27. byteint get_stat()
  28. {
  29.   register byteint i;
  30.  
  31.   i = randint(4) + randint(4) + randint(4) + 5;
  32.   return(i);
  33. }
  34.  
  35.  
  36. /* Changes stats by given amount                -JWT-    */
  37. byteint change_stat(cur_stat, amount)
  38. byteint cur_stat;
  39. int amount;
  40. {
  41.   register int i;
  42.  
  43.   if (amount < 0)
  44.     for (i = 0; i > amount; i--)
  45.       cur_stat = de_statp(cur_stat);
  46.   else
  47.     for (i = 0; i < amount; i++)
  48.       cur_stat = in_statp(cur_stat);
  49.   return(cur_stat);
  50. }
  51.  
  52.  
  53. /* generate all stats and modify for race... needed in a separate module so
  54.    looping of character selection would be allowed     -RGM- */
  55. void get_stats ()
  56. {
  57.   register player_type *p_ptr;
  58.   register race_type *r_ptr;
  59.  
  60.   p_ptr = &py;
  61.   r_ptr = &race[p_ptr->misc.prace];
  62.   p_ptr->stats.str    = get_stat();
  63.   p_ptr->stats.intel  = get_stat();
  64.   p_ptr->stats.wis    = get_stat();
  65.   p_ptr->stats.dex    = get_stat();
  66.   p_ptr->stats.con    = get_stat();
  67.   p_ptr->stats.chr    = get_stat();
  68.   p_ptr->stats.str    = change_stat(p_ptr->stats.str, r_ptr->str_adj);
  69.   p_ptr->stats.intel  = change_stat(p_ptr->stats.intel, r_ptr->int_adj);
  70.   p_ptr->stats.wis    = change_stat(p_ptr->stats.wis, r_ptr->wis_adj);
  71.   p_ptr->stats.dex    = change_stat(p_ptr->stats.dex, r_ptr->dex_adj);
  72.   p_ptr->stats.con    = change_stat(p_ptr->stats.con, r_ptr->con_adj);
  73.   p_ptr->stats.chr    = change_stat(p_ptr->stats.chr, r_ptr->chr_adj);
  74.   p_ptr->stats.cstr   = p_ptr->stats.str;
  75.   p_ptr->stats.cint   = p_ptr->stats.intel;
  76.   p_ptr->stats.cwis   = p_ptr->stats.wis;
  77.   p_ptr->stats.cdex   = p_ptr->stats.dex;
  78.   p_ptr->stats.ccon   = p_ptr->stats.con;
  79.   p_ptr->stats.cchr   = p_ptr->stats.chr;
  80.   p_ptr->misc.srh    = r_ptr->srh;
  81.   p_ptr->misc.bth    = r_ptr->bth;
  82.   p_ptr->misc.bthb   = r_ptr->bthb;
  83.   p_ptr->misc.fos    = r_ptr->fos;
  84.   p_ptr->misc.stl    = r_ptr->stl;
  85.   p_ptr->misc.save   = r_ptr->bsav;
  86.   p_ptr->misc.hitdie = r_ptr->bhitdie;
  87.   p_ptr->misc.lev    = 1;
  88.   p_ptr->misc.ptodam = todam_adj();
  89.   p_ptr->misc.ptohit = tohit_adj();
  90.   p_ptr->misc.ptoac  = 0;
  91.   p_ptr->misc.pac    = toac_adj();
  92.   p_ptr->misc.expfact = r_ptr->b_exp;
  93.   p_ptr->flags.see_infra = r_ptr->infra;
  94. }
  95.  
  96.  
  97. /* Allows player to select a race            -JWT-    */
  98. int choose_race()
  99. {
  100.   register int j, k;
  101.   int l, m;
  102.   char s;
  103.   int exit_flag;
  104.   char tmp_str[80];
  105.   register player_type *p_ptr;
  106.   register race_type *r_ptr;
  107.   int res;
  108.  
  109.   j = 0;
  110.   k = 0;
  111.   l = 2;
  112.   m = 21;
  113.   clear_screen(20, 0);
  114. /*  help is unimplemented */
  115. /*  prt("Choose a race (? for Help):", 20, 2); */
  116.   prt("Choose a race:", 20, 2);
  117.   do
  118.     {
  119.       (void) sprintf(tmp_str, "%c) %s", k+97, race[j].trace);
  120.       put_buffer(tmp_str, m, l);
  121.       k++;
  122.       l += 15;
  123.       if (l > 70)
  124.     {
  125.       l = 2;
  126.       m++;
  127.     }
  128.       j++;
  129.     }
  130.   while (j < MAX_RACES);
  131.   /* clear race string */
  132.   py.misc.race[0] = '\0';
  133.   move_cursor (20, 18);
  134.   exit_flag = FALSE;
  135.   do
  136.     {
  137.       inkey(&s);
  138.       j = s - 97;
  139.       if ((j < MAX_RACES) && (j >= 0))
  140.     {
  141.       p_ptr = &py;
  142.       r_ptr = &race[j];
  143.       p_ptr->misc.prace  = j;
  144.       (void) strcpy(p_ptr->misc.race, r_ptr->trace);
  145.       get_stats();                  /* We don't need the code twice. */
  146.       exit_flag = TRUE;             /* so use function get_stats -RGM- */
  147.       res = TRUE;
  148.       put_buffer(py.misc.race, 3, 14);
  149.     }
  150.     }
  151.   while (!exit_flag);
  152.   return(res);
  153. }
  154.  
  155.  
  156. /* Will print the history of a character            -JWT-    */
  157. print_history()
  158. {
  159.   register int i;
  160.  
  161.   put_buffer("Character Background", 13, 27);
  162.   for(i = 0; i < 5; i++)
  163.     put_buffer(py.misc.history[i], i+14, 4);
  164. }
  165.  
  166.  
  167. /* Get the racial history, determines social class    -RAK-    */
  168. /* Assumptions:    Each race has init history beginning at     */
  169. /*        (race-1)*3+1                    */
  170. /*        All history parts are in ascending order    */
  171. get_history()
  172. {
  173.   int hist_ptr, cur_ptr, test_roll;
  174.   register int start_pos, end_pos, cur_len;
  175.   int line_ctr, new_start, social_class;
  176.   char history_block[400];
  177.   vtype tmp_str;
  178.   int flag;
  179.   register background_type *b_ptr;
  180. int i = 0;
  181.  
  182.   /* Get a block of history text                */
  183.   hist_ptr = py.misc.prace*3 + 1;
  184.   history_block[0] = '\0';
  185.   social_class = randint(4);
  186.   cur_ptr = 0;
  187.   do
  188.     {
  189.       flag = FALSE;
  190.       do
  191.     {
  192.       if (background[cur_ptr].chart == hist_ptr)
  193.         {
  194.           test_roll = randint(100);
  195.           while (test_roll > background[cur_ptr].roll)
  196.         cur_ptr++;
  197.           b_ptr = &background[cur_ptr];
  198.           (void) strcat(history_block, b_ptr->info);
  199.           social_class += b_ptr->bonus;
  200.           if (hist_ptr > b_ptr->next)
  201.         cur_ptr = 0;
  202.           hist_ptr = b_ptr->next;
  203.           flag = TRUE;
  204.         }
  205.       else
  206.         cur_ptr++;
  207.     }
  208.       while (!flag);
  209.     }
  210.   while (hist_ptr >= 1);
  211.  
  212.   /* Process block of history text for pretty output    */
  213.   start_pos = 0;
  214.   end_pos   = strlen(history_block) - 1;
  215.   line_ctr  = 0;
  216.   flag = FALSE;
  217.   while (history_block[end_pos] == ' ')
  218.     end_pos--;
  219.   do
  220.     {
  221.       while (history_block[start_pos] == ' ')
  222.     start_pos++;
  223.       cur_len = end_pos - start_pos + 1;
  224.       if (cur_len > 70)
  225.     {
  226.       cur_len = 70;
  227.       while (history_block[start_pos+cur_len-1] != ' ')
  228.         cur_len--;
  229.       new_start = start_pos + cur_len;
  230.       while (history_block[start_pos+cur_len-1] == ' ')
  231.         cur_len--;
  232.     }
  233.       else
  234.     flag = TRUE;
  235.       (void) strncpy(tmp_str, &history_block[start_pos], cur_len);
  236.       tmp_str[cur_len] = '\0';
  237.       (void) strcpy(py.misc.history[line_ctr], tmp_str);
  238.       line_ctr++;
  239.       start_pos = new_start;
  240.     }
  241.   while (!flag);
  242.  
  243.   /* Compute social class for player            */
  244.   if (social_class > 100)
  245.     social_class = 100;
  246.   else if (social_class < 1)
  247.     social_class = 1;
  248.   py.misc.sc = social_class;
  249. }
  250.  
  251.  
  252. /* Gets the character's sex                -JWT-    */
  253. int get_sex()
  254. {
  255.   char s;
  256.   int exit_flag;
  257.   int sex;
  258.  
  259.   py.misc.sex[0] = '\0';
  260.   clear_screen(20, 0);
  261. /* help is unimplemented */
  262. /*  prt("Choose a sex (? for Help):", 20, 2); */
  263.   prt("Choose a sex:", 20, 2);
  264.   prt("m) Male       f) Female", 21, 2);
  265.   move_cursor (20, 16);
  266.   do
  267.     {
  268.       inkey(&s);
  269.       switch(s)
  270.     {
  271.     case 'f': case 'F':
  272.       (void) strcpy(py.misc.sex, "Female");
  273.       prt(py.misc.sex, 4, 14);
  274.       exit_flag = TRUE;
  275.       sex = TRUE;
  276.       break;
  277.     case 'm': case 'M':
  278.       (void) strcpy(py.misc.sex, "Male");
  279.       prt(py.misc.sex, 4, 14);
  280.       exit_flag = TRUE;
  281.       sex = TRUE;
  282.       break;
  283.     default:
  284.       sex = FALSE;
  285.       exit_flag = FALSE;
  286.       break;
  287.     }
  288.     }
  289.   while (!exit_flag);
  290.   return(sex);
  291. }
  292.  
  293.  
  294. /* Computes character's age, height, and weight        -JWT-    */
  295. get_ahw()
  296. {
  297.   register int i;
  298.  
  299.   i = py.misc.prace;
  300.   py.misc.age = race[i].b_age + randint((int)race[i].m_age);
  301.   switch(py.misc.sex[0])
  302.     {
  303.     case 'F': case 'f':
  304.       py.misc.ht = randnor((int)race[i].f_b_ht, (int)race[i].f_m_ht);
  305.       py.misc.wt = randnor((int)race[i].f_b_wt, (int)race[i].f_m_wt);
  306.       break;
  307.     case 'M': case 'm':
  308.       py.misc.ht = randnor((int)race[i].m_b_ht, (int)race[i].m_m_ht);
  309.       py.misc.wt = randnor((int)race[i].m_b_wt, (int)race[i].m_m_wt);
  310.       break;
  311.     }
  312.   py.misc.disarm = race[i].b_dis + todis_adj();
  313. }
  314.  
  315.  
  316. /* Gets a character class                -JWT-    */
  317. int get_class()
  318. {
  319.   register int i, j;
  320.   int k, l, m;
  321.   int cl[MAX_CLASS];
  322.   char s;
  323.   int exit_flag;
  324.   int res;
  325.   register struct misc *m_ptr;
  326.   register player_type *p_ptr;
  327.   char tmp_str[80];
  328.  
  329.   for (j = 0; j < MAX_CLASS; j++)
  330.     cl[j] = 0;
  331.   i = py.misc.prace;
  332.   j = 0;
  333.   k = 0;
  334.   l = 2;
  335.   m = 21;
  336.   clear_screen(20, 0);
  337. /* help is unimplemented */
  338. /* prt("Choose a class (? for Help):", 20, 2); */
  339.   prt("Choose a class:", 20, 2);
  340.   do
  341.     {
  342.       if (race[i].tclass & bit_array[j])
  343.     {
  344.       (void) sprintf(tmp_str, "%c) %s", k+97, class[j].title);
  345.       put_buffer(tmp_str, m, l);
  346.       cl[k] = j;
  347.       l += 15;
  348.       if (l > 70)
  349.         {
  350.           l = 2;
  351.           m++;
  352.         }
  353.       k++;
  354.     }
  355.       j++;
  356.     }
  357.   while (j < MAX_CLASS);
  358.   py.misc.pclass = 0;
  359.   move_cursor (20, 19);
  360.   exit_flag = FALSE;
  361.   do
  362.     {
  363.       inkey(&s);
  364.       j = s - 97;
  365.       if ((j < k) && (j >= 0))
  366.     {
  367.       (void) strcpy(py.misc.tclass, class[cl[j]].title);
  368.       py.misc.pclass = cl[j];
  369.       exit_flag = TRUE;
  370.       res = TRUE;
  371.       clear_screen(20, 0);
  372.       put_buffer(py.misc.tclass, 5, 14);
  373.  
  374.       /* Adjust the stats for the class adjustment        -RAK-    */
  375.       p_ptr = &py;
  376.       p_ptr->stats.str  = change_stat(p_ptr->stats.str,
  377.                      class[p_ptr->misc.pclass].madj_str);
  378.       p_ptr->stats.intel= change_stat(p_ptr->stats.intel,
  379.                      class[p_ptr->misc.pclass].madj_int);
  380.       p_ptr->stats.wis  = change_stat(p_ptr->stats.wis,
  381.                      class[p_ptr->misc.pclass].madj_wis);
  382.       p_ptr->stats.dex  = change_stat(p_ptr->stats.dex,
  383.                      class[p_ptr->misc.pclass].madj_dex);
  384.       p_ptr->stats.con  = change_stat(p_ptr->stats.con,
  385.                      class[p_ptr->misc.pclass].madj_con);
  386.       p_ptr->stats.chr  = change_stat(p_ptr->stats.chr,
  387.                      class[p_ptr->misc.pclass].madj_chr);
  388.       p_ptr->stats.cstr = p_ptr->stats.str;
  389.       p_ptr->stats.cint = p_ptr->stats.intel;
  390.       p_ptr->stats.cwis = p_ptr->stats.wis;
  391.       p_ptr->stats.cdex = p_ptr->stats.dex;
  392.       p_ptr->stats.ccon = p_ptr->stats.con;
  393.       p_ptr->stats.cchr = p_ptr->stats.chr;
  394.       p_ptr->misc.ptodam = todam_adj();    /* Real values        */
  395.       p_ptr->misc.ptohit = tohit_adj();
  396.       p_ptr->misc.ptoac  = toac_adj();
  397.       p_ptr->misc.pac    = 0;
  398.       p_ptr->misc.dis_td = p_ptr->misc.ptodam; /* Displayed values    */
  399.       p_ptr->misc.dis_th = p_ptr->misc.ptohit;
  400.       p_ptr->misc.dis_tac= p_ptr->misc.ptoac;
  401.       p_ptr->misc.dis_ac = p_ptr->misc.pac;
  402.  
  403.       /* now set misc stats, do this after setting stats because
  404.          of con_adj() for hitpoints */
  405.       m_ptr = &py.misc;
  406.       m_ptr->hitdie += class[m_ptr->pclass].adj_hd;
  407.       m_ptr->mhp = con_adj() + m_ptr->hitdie;
  408.       m_ptr->chp = (double)m_ptr->mhp;
  409.       m_ptr->bth += class[m_ptr->pclass].mbth;
  410.       m_ptr->bthb += class[m_ptr->pclass].mbthb;    /*RAK*/
  411.       m_ptr->srh += class[m_ptr->pclass].msrh;
  412.       m_ptr->disarm += class[m_ptr->pclass].mdis;
  413.       m_ptr->fos += class[m_ptr->pclass].mfos;
  414.       m_ptr->stl += class[m_ptr->pclass].mstl;
  415.       m_ptr->save += class[m_ptr->pclass].msav;
  416.       (void) strcat(m_ptr->title, player_title[m_ptr->pclass][0]);
  417.       m_ptr->expfact += class[m_ptr->pclass].m_exp;
  418.  
  419.     }
  420.     }
  421.   while (!exit_flag);
  422.   return(res);
  423. }
  424.  
  425.  
  426. get_money()
  427. {
  428.   register int tmp;
  429.   register struct stats *p_ptr;
  430.   register struct misc *m_ptr;
  431.  
  432.   p_ptr = &py.stats;
  433.   tmp = p_ptr->cstr + p_ptr->cint + p_ptr->cwis +
  434.     p_ptr->cdex + p_ptr->ccon + p_ptr->cchr;
  435.   m_ptr = &py.misc;
  436.   m_ptr->au = m_ptr->sc*6 + randint(25) + 325;    /* Social Class adj    */
  437.   m_ptr->au = m_ptr->au - tmp;            /* Stat adj        */
  438.   m_ptr->au = m_ptr->au + p_ptr->cchr;        /* Charisma adj    */
  439.   if (m_ptr->au < 80)  m_ptr->au = 80;        /* Minimum        */
  440. }
  441.  
  442.  
  443. /* ---------- M A I N  for Character Creation Routine ---------- */
  444. /*                            -JWT-    */
  445. create_character()
  446. {
  447.   char s;
  448.   register int exit_flag = 1;
  449.  
  450.   put_character();
  451.   (void) choose_race();
  452.   (void) get_sex();
  453.  
  454.   /* here we start a loop giving a player a choice of characters -RGM- */
  455.   get_stats ();
  456.   get_history();
  457.   get_ahw();
  458.   put_character();
  459.   print_history();
  460.   put_misc1();
  461.   put_stats();
  462.   exit_flag = 1;
  463.   do
  464.     {
  465.       prt("Hit space to reroll or ESC to accept characteristics: ", 20, 2);
  466.       inkey(&s);
  467.       switch (s)
  468.     {
  469.     case 27:
  470.       exit_flag = 0;
  471.       break;
  472.     case ' ':
  473.       get_stats ();
  474.       get_history();
  475.       get_ahw();
  476.       put_character();
  477.       print_history();
  478.       put_misc1();
  479.       put_stats();
  480. #ifdef SLOW
  481.       (void) sleep (0);
  482. #endif      
  483.       break;
  484.     default:
  485.       break;
  486.     }
  487.     }               /* done with stats generation */
  488.   while (exit_flag == 1);
  489.  
  490.   (void) get_class();
  491.   get_money();
  492.   put_stats();
  493.   put_misc2();
  494.   put_misc3();
  495.   get_name();
  496.  
  497.   /* This delay may be reduced, but is recommended to keep players    */
  498.   /* from continuously rolling up characters, which can be VERY    */
  499.   /* expensive CPU wise.                        */
  500.   pause_exit(23, PLAYER_EXIT_PAUSE);
  501. }
  502.  
  503.