Ticket #938: md_938.patch

File md_938.patch, 29.2 KB (added by Marble Dice, 11 years ago)

Adds new birth CMD to finalize birth options immediately after roller selection

  • .c

    old new  
    2929 * To follow the code, start at player_birth towards the bottom of 
    3030 * the file - that is the only external entry point to the functions 
    3131 * defined here. 
    32  *  
     32 * 
    3333 * Player (in the Angband sense of character) birth is modelled as a 
    3434 * a series of commands from the UI to the game to manipulate the 
    3535 * character and corresponding events to inform the UI of the outcomes 
     
    3737 * 
    3838 * The current aim of this section is that after any birth command 
    3939 * is carried out, the character should be left in a playable state. 
    40  * In particular, this means that if a savefile is supplied, the  
     40 * In particular, this means that if a savefile is supplied, the 
    4141 * character will be set up according to the "quickstart" rules until 
    4242 * another race or class is chosen, or until the stats are reset by 
    4343 * the UI. 
    4444 * 
    45  * Once the UI signals that the player is happy with the character, the  
    46  * game does housekeeping to ensure the character is ready to start the  
    47  * game (clearing the history log, making sure options are set, etc)  
     45 * Once the UI signals that the player is happy with the character, the 
     46 * game does housekeeping to ensure the character is ready to start the 
     47 * game (clearing the history log, making sure options are set, etc) 
    4848 * before returning control to the game proper. 
    4949 */ 
    5050 
     
    665665                        /* Reset stats */ 
    666666                        p_ptr->stat_cur[i] = p_ptr->stat_max[i] = p_ptr->stat_birth[i] = stats[i]; 
    667667                } 
    668                  
     668 
    669669                /* Fixed stat maxes */ 
    670670                else 
    671671                { 
    672672                        /* Obtain a "bonus" for "race" and "class" */ 
    673673                        int bonus = rp_ptr->r_adj[i] + cp_ptr->c_adj[i]; 
    674                          
     674 
    675675                        /* Apply the racial/class bonuses */ 
    676676                        p_ptr->stat_cur[i] = p_ptr->stat_max[i] = 
    677677                                modify_stat_value(stats[i], bonus); 
    678678                } 
    679679        } 
    680          
     680 
    681681        /* Gold is inversely proportional to cost */ 
    682682        if (OPT(birth_money)) 
    683683                p_ptr->au = 500; 
     
    711711        } 
    712712 
    713713        /* Use the new "birth stat" values to work out the "other" 
    714            stat values (i.e. after modifiers) and tell the UI things have  
     714           stat values (i.e. after modifiers) and tell the UI things have 
    715715           changed. */ 
    716716        recalculate_stats(stats, *points_left); 
    717         event_signal_birthpoints(points_spent, *points_left);    
     717        event_signal_birthpoints(points_spent, *points_left); 
    718718} 
    719719 
    720720static bool buy_stat(int choice, int stats[A_MAX], int points_spent[A_MAX], int *points_left) 
     
    725725                /* Get the cost of buying the extra point (beyond what 
    726726                   it has already cost to get this far). */ 
    727727                int stat_cost = birth_stat_costs[stats[choice] + 1]; 
    728                  
     728 
    729729                if (stat_cost <= *points_left) 
    730730                { 
    731731                        stats[choice]++; 
    732732                        points_spent[choice] += stat_cost; 
    733733                        *points_left -= stat_cost; 
    734                          
     734 
    735735                        /* Tell the UI the new points situation. */ 
    736736                        event_signal_birthpoints(points_spent, *points_left); 
    737                          
     737 
    738738                        /* Recalculate everything that's changed because 
    739739                           the stat has changed, and inform the UI. */ 
    740740                        recalculate_stats(stats, *points_left); 
    741                          
     741 
    742742                        return TRUE; 
    743                 }                
     743                } 
    744744        } 
    745745 
    746746        /* Didn't adjust stat. */ 
     
    748748} 
    749749 
    750750 
    751 static bool sell_stat(int choice, int stats[A_MAX], int points_spent[A_MAX],  
     751static bool sell_stat(int choice, int stats[A_MAX], int points_spent[A_MAX], 
    752752                                          int *points_left) 
    753753{ 
    754754        /* Must be a valid stat, and we can't "sell" stats below the base of 10. */ 
    755755        if (!(choice >= A_MAX || choice < 0) && (stats[choice] > 10)) 
    756756        { 
    757757                int stat_cost = birth_stat_costs[stats[choice]]; 
    758                  
     758 
    759759                stats[choice]--; 
    760760                points_spent[choice] -= stat_cost; 
    761761                *points_left += stat_cost; 
    762                  
     762 
    763763                /* Tell the UI the new points situation. */ 
    764764                event_signal_birthpoints(points_spent, *points_left); 
    765                  
     765 
    766766                /* Recalculate everything that's changed because 
    767767                   the stat has changed, and inform the UI. */ 
    768768                recalculate_stats(stats, *points_left); 
    769769 
    770770                return TRUE; 
    771         }                                
     771        } 
    772772 
    773773        /* Didn't adjust stat. */ 
    774774        return FALSE; 
     
    783783 * 
    784784 * 0. buy base STR 17 
    785785 * 1. if possible buy adj DEX of 18/10 
    786  * 2. spend up to half remaining points on each of spell-stat and con,  
    787  *    but only up to max base of 16 unless a pure class  
     786 * 2. spend up to half remaining points on each of spell-stat and con, 
     787 *    but only up to max base of 16 unless a pure class 
    788788 *    [mage or priest or warrior] 
    789  * 3. If there are any points left, spend as much as possible in order  
    790  *    on DEX, non-spell-stat, CHR.  
     789 * 3. If there are any points left, spend as much as possible in order 
     790 *    on DEX, non-spell-stat, CHR. 
    791791 */ 
    792 static void generate_stats(int stats[A_MAX], int points_spent[A_MAX],  
     792static void generate_stats(int stats[A_MAX], int points_spent[A_MAX], 
    793793                                                   int *points_left) 
    794794{ 
    795795        int step = 0; 
     
    807807                switch (step) 
    808808                { 
    809809                        /* Buy base STR 17 */ 
    810                         case 0:                          
     810                        case 0: 
    811811                        { 
    812812                                if (!maxed[A_STR] && stats[A_STR] < 17) 
    813813                                { 
     
    848848 
    849849                                        maxed[A_DEX] = FALSE; 
    850850                                } 
    851                                  
     851 
    852852                                step++; 
    853853                        } 
    854854 
    855                         /*  
    856                          * Spend up to half remaining points on each of spell-stat and  
    857                          * con, but only up to max base of 16 unless a pure class  
     855                        /* 
     856                         * Spend up to half remaining points on each of spell-stat and 
     857                         * con, but only up to max base of 16 unless a pure class 
    858858                         * [mage or priest or warrior] 
    859859                         */ 
    860860                        case 3: 
     
    866866                                        while (!maxed[cp_ptr->spell_stat] && 
    867867                                                   (pure || stats[cp_ptr->spell_stat] < 16) && 
    868868                                                   points_spent[cp_ptr->spell_stat] < points_trigger) 
    869                                         {                                                
     869                                        { 
    870870                                                if (!buy_stat(cp_ptr->spell_stat, stats, points_spent, 
    871871                                                                          points_left)) 
    872872                                                { 
     
    875875 
    876876                                                if (points_spent[cp_ptr->spell_stat] > points_trigger) 
    877877                                                { 
    878                                                         sell_stat(cp_ptr->spell_stat, stats, points_spent,  
     878                                                        sell_stat(cp_ptr->spell_stat, stats, points_spent, 
    879879                                                                          points_left); 
    880880                                                        maxed[cp_ptr->spell_stat] = TRUE; 
    881881                                                } 
     
    885885                                while (!maxed[A_CON] && 
    886886                                           (pure || stats[A_CON] < 16) && 
    887887                                           points_spent[A_CON] < points_trigger) 
    888                                 {                                                
     888                                { 
    889889                                        if (!buy_stat(A_CON, stats, points_spent,points_left)) 
    890890                                        { 
    891891                                                maxed[A_CON] = TRUE; 
    892892                                        } 
    893                                          
     893 
    894894                                        if (points_spent[A_CON] > points_trigger) 
    895895                                        { 
    896896                                                sell_stat(A_CON, stats, points_spent, points_left); 
    897897                                                maxed[A_CON] = TRUE; 
    898898                                        } 
    899899                                } 
    900                                  
     900 
    901901                                step++; 
    902902                                break; 
    903903                        } 
    904904 
    905                         /*  
    906                          * If there are any points left, spend as much as possible in  
    907                          * order on DEX, non-spell-stat, CHR.  
     905                        /* 
     906                         * If there are any points left, spend as much as possible in 
     907                         * order on DEX, non-spell-stat, CHR. 
    908908                         */ 
    909909                        case 4: 
    910                         {                                
     910                        { 
    911911                                int next_stat; 
    912912 
    913913                                if (!maxed[A_DEX]) 
     
    980980        p_ptr->player_hp[0] = p_ptr->hitdie; 
    981981 
    982982        /* Roll for age/height/weight */ 
    983         get_ahw();                                       
     983        get_ahw(); 
    984984 
    985985        get_history(); 
    986986} 
     
    10021002        get_bonuses(); 
    10031003} 
    10041004 
    1005  
    10061005/* 
    10071006 * Create a new character. 
    10081007 * 
     
    10291028         */ 
    10301029        birther prev = { 0, 0, 0, 0, 0, 0, 0, 0, {0}, "" }; 
    10311030 
    1032         /*  
     1031        /* 
    10331032         * If quickstart is allowed, we store the old character in this, 
    10341033         * to allow for it to be reloaded if we step back that far in the 
    10351034         * birth process. 
    10361035         */ 
    10371036        birther quickstart_prev = {0, 0, 0, 0, 0, 0, 0, 0, {0}, "" }; 
    10381037 
    1039         /*  
    1040          * If there's a quickstart character, store it for later use.  
     1038        /* 
     1039         * If there's a quickstart character, store it for later use. 
    10411040         * If not, default to whatever the first of the choices is. 
    10421041         */ 
    10431042        if (quickstart_allowed) 
     
    10621061                success = int_to_roman((roman_to_int(buf) + 1), buf, 
    10631062                        (sizeof(op_ptr->full_name) - (buf - 
    10641063                        (char *)&op_ptr->full_name))); 
    1065                          
     1064 
    10661065                if (!success) msg_print("Sorry, could not deal with suffix"); 
    10671066        } 
    1068          
     1067 
    10691068 
    10701069        /* We're ready to start the interactive birth process. */ 
    10711070        event_signal_flag(EVENT_ENTER_BIRTH, quickstart_allowed); 
    10721071 
    1073         /*  
     1072        /* 
    10741073         * Loop around until the UI tells us we have an acceptable character. 
    10751074         * Note that it is possible to quit from inside this loop. 
    10761075         */ 
     
    10871086                } 
    10881087                else if (cmd.command == CMD_CHOOSE_SEX) 
    10891088                { 
    1090                         p_ptr->psex = cmd.args[0].choice;  
     1089                        p_ptr->psex = cmd.args[0].choice; 
    10911090                        generate_player(); 
    10921091                } 
    10931092                else if (cmd.command == CMD_CHOOSE_RACE) 
     
    11081107                        generate_stats(stats, points_spent, &points_left); 
    11091108                        rolled_stats = FALSE; 
    11101109                } 
     1110                else if (cmd.command == CMD_FINALIZE_OPTIONS) 
     1111                { 
     1112                        /* Set adult options from birth options */ 
     1113                        for (i = OPT_BIRTH; i < OPT_CHEAT; i++) 
     1114                        { 
     1115                                op_ptr->opt[OPT_ADULT + (i - OPT_BIRTH)] = op_ptr->opt[i]; 
     1116                        } 
     1117 
     1118                        /* Reset score options from cheat options */ 
     1119                        for (i = OPT_CHEAT; i < OPT_ADULT; i++) 
     1120                        { 
     1121                                op_ptr->opt[OPT_SCORE + (i - OPT_CHEAT)] = op_ptr->opt[i]; 
     1122                        } 
     1123                } 
    11111124                else if (cmd.command == CMD_BUY_STAT) 
    11121125                { 
    11131126                        /* .choice is the stat to buy */ 
     
    11381151 
    11391152                        /* Get a new character */ 
    11401153                        get_stats(stats); 
    1141                          
     1154 
    11421155                        /* Roll for gold */ 
    11431156                        get_money(stats); 
    11441157 
     
    11841197                else if (cmd.command == CMD_NAME_CHOICE) 
    11851198                { 
    11861199                        /* Set player name */ 
    1187                         my_strcpy(op_ptr->full_name, cmd.args[0].string,  
     1200                        my_strcpy(op_ptr->full_name, cmd.args[0].string, 
    11881201                                          sizeof(op_ptr->full_name)); 
    1189                          
     1202 
    11901203                        string_free((void *) cmd.args[0].string); 
    1191                          
     1204 
    11921205                        /* Don't change savefile name.  If the UI 
    11931206                           wants it changed, they can do it. XXX (Good idea?) */ 
    11941207                        process_player_name(FALSE); 
     
    11971210                else if (cmd.command == CMD_HELP) 
    11981211                { 
    11991212                        char buf[80]; 
    1200                          
     1213 
    12011214                        strnfmt(buf, sizeof(buf), "birth.txt"); 
    12021215                        screen_save(); 
    12031216                        show_file(buf, NULL, 0, 0); 
    12041217                        screen_load(); 
    12051218                } 
    1206                 else if (cmd.command == CMD_QUIT)  
     1219                else if (cmd.command == CMD_QUIT) 
    12071220                { 
    12081221                        quit(NULL); 
    12091222                } 
    12101223        } 
    12111224 
    12121225        roll_hp(); 
    1213  
    1214         /* Set adult options from birth options */ 
    1215         for (i = OPT_BIRTH; i < OPT_CHEAT; i++) 
    1216         { 
    1217                 op_ptr->opt[OPT_ADULT + (i - OPT_BIRTH)] = op_ptr->opt[i]; 
    1218         } 
    1219  
    1220         /* Reset score options from cheat options */ 
    1221         for (i = OPT_CHEAT; i < OPT_ADULT; i++) 
    1222         { 
    1223                 op_ptr->opt[OPT_SCORE + (i - OPT_CHEAT)] = op_ptr->opt[i]; 
    1224         } 
    12251226 
    12261227        squelch_birth_init(); 
    12271228 
  • .c

    old new  
    5656        { CMD_CHOOSE_SEX, { arg_CHOICE, arg_END }, NULL, FALSE }, 
    5757        { CMD_CHOOSE_RACE, { arg_CHOICE, arg_END }, NULL, FALSE }, 
    5858        { CMD_CHOOSE_CLASS, { arg_CHOICE, arg_END }, NULL, FALSE }, 
     59        { CMD_FINALIZE_OPTIONS, { arg_CHOICE, arg_END }, NULL, FALSE }, 
    5960        { CMD_BUY_STAT, { arg_CHOICE, arg_END }, NULL, FALSE }, 
    6061        { CMD_SELL_STAT, { arg_CHOICE, arg_END }, NULL, FALSE }, 
    6162        { CMD_RESET_STATS, { arg_CHOICE, arg_END }, NULL, FALSE }, 
     
    133134 
    134135                if (!repeat_prev_allowed) return 1; 
    135136 
    136                 /* If we're repeating a command, we duplicate the previous command  
     137                /* If we're repeating a command, we duplicate the previous command 
    137138                   in the next command "slot". */ 
    138139                if (cmd_prev < 0) cmd_prev = CMD_QUEUE_SIZE - 1; 
    139                  
     140 
    140141                if (cmd_queue[cmd_prev].command != CMD_NULL) 
    141142                        cmd_queue[cmd_head] = cmd_queue[cmd_prev]; 
    142143        } 
     
    145146        cmd_head++; 
    146147        if (cmd_head == CMD_QUEUE_SIZE) cmd_head = 0; 
    147148 
    148         return 0;        
     149        return 0; 
    149150} 
    150151 
    151152/* 
     
    156157errr cmd_get(cmd_context c, game_command *cmd, bool wait) 
    157158{ 
    158159        /* If there are no commands queued, ask the UI for one. */ 
    159         if (cmd_head == cmd_tail)  
     160        if (cmd_head == cmd_tail) 
    160161                cmd_get_hook(c, wait); 
    161162 
    162163        /* If we have a command ready, set it and return success. */ 
     
    187188        return -1; 
    188189} 
    189190 
    190 /*  
    191  * Inserts a command in the queue to be carried out.  
     191/* 
     192 * Inserts a command in the queue to be carried out. 
    192193 */ 
    193194errr cmd_insert(cmd_code c, ...) 
    194195{ 
     
    204205 
    205206        cmd.command = c; 
    206207 
    207         for (j = 0; (game_cmds[idx].arg_type[j] != arg_END &&  
     208        for (j = 0; (game_cmds[idx].arg_type[j] != arg_END && 
    208209                                 j < N_ELEMENTS(game_cmds[idx].arg_type)); j++) 
    209210        { 
    210211                switch (game_cmds[idx].arg_type[j]) 
     
    220221                                cmd.args[j].string = string_make(va_arg(vp, const char *)); 
    221222                                break; 
    222223                        } 
    223                          
     224 
    224225                        case arg_DIRECTION: 
    225226                        case arg_TARGET: 
    226227                        { 
    227228                                cmd.args[j].direction = va_arg(vp, int); 
    228229                                break; 
    229230                        } 
    230                          
     231 
    231232                        case arg_POINT: 
    232233                        { 
    233234                                cmd.args[j].point.y = va_arg(vp, int); 
    234235                                cmd.args[j].point.x = va_arg(vp, int); 
    235236                                break; 
    236237                        } 
    237                          
     238 
    238239                        case arg_ITEM: 
    239240                        { 
    240241                                cmd.args[j].item = va_arg(vp, int); 
    241242                                break; 
    242243                        } 
    243                          
     244 
    244245                        case arg_NUMBER: 
    245246                        { 
    246247                                cmd.args[j].number = va_arg(vp, int); 
     
    266267 * 
    267268 * When a command is executed, the user has the option to request that 
    268269 * it be repeated by the UI setting p_ptr->command_arg.  If the command 
    269  * permits repetition, then it calls this function to set  
     270 * permits repetition, then it calls this function to set 
    270271 * p_ptr->command_rep to make it repeat until an interruption. 
    271272 */ 
    272273static void allow_repeated_command(void) 
     
    275276        { 
    276277                /* Set repeat count */ 
    277278                p_ptr->command_rep = p_ptr->command_arg - 1; 
    278                  
     279 
    279280                /* Redraw the state */ 
    280281                p_ptr->redraw |= (PR_STATE); 
    281                  
     282 
    282283                /* Cancel the arg */ 
    283284                p_ptr->command_arg = 0; 
    284285        } 
    285286} 
    286287 
    287 /*  
     288/* 
    288289 * Request a game command from the uI and carry out whatever actions 
    289290 * go along with it. 
    290291 */ 
     
    300301 
    301302                if (idx == -1) return; 
    302303 
    303                 /* Do some sanity checking on those arguments that might have  
     304                /* Do some sanity checking on those arguments that might have 
    304305                   been declared as "unknown", such as directions and targets. */ 
    305306                switch (cmd.command) 
    306307                { 
     
    321322                                        if (!get_rep_dir(&cmd.args[0].direction)) 
    322323                                                return; 
    323324                                } 
    324                                  
     325 
    325326                                break; 
    326327                        } 
    327                          
    328                          
    329                         /*  
    330                          * These take an item number and a  "target" as arguments,  
    331                          * though a target isn't always actually needed, so we'll  
     328 
     329 
     330                        /* 
     331                         * These take an item number and a  "target" as arguments, 
     332                         * though a target isn't always actually needed, so we'll 
    332333                         * only prompt for it via callback if the item being used needs it. 
    333334                         */ 
    334335                        case CMD_USE_WAND: 
     
    357358 
    358359                                break; 
    359360                        } 
    360                          
     361 
    361362                        /* This takes a choice and a direction. */ 
    362363                        case CMD_CAST: 
    363364                        { 
     
    374375 
    375376                                if (get_target && !get_aim_dir(&cmd.args[1].direction)) 
    376377                                                return; 
    377                                  
     378 
    378379                                break; 
    379380                        } 
    380381 
    381                         default:  
     382                        default: 
    382383                        { 
    383384                /* I can see the point of the compiler warning, but still... */ 
    384385                                break; 
    385386                        } 
    386387                } 
    387                  
     388 
    388389                if (game_cmds[idx].repeat_allowed) 
    389390                        allow_repeated_command(); 
    390391 
  • .h

    old new  
    88{ 
    99        CMD_NULL = 0,   /* A "do nothing" command so that there's something 
    1010                                           UIs can use as a "no command yet" sentinel. */ 
    11         /*  
    12          * Splash screen commands  
     11        /* 
     12         * Splash screen commands 
    1313         */ 
    1414        CMD_LOADFILE, 
    1515        CMD_NEWGAME, 
    1616 
    17         /*  
    18          * Birth commands  
     17        /* 
     18         * Birth commands 
    1919         */ 
    2020        CMD_BIRTH_RESET, 
    2121        CMD_CHOOSE_SEX, 
    2222        CMD_CHOOSE_RACE, 
    2323        CMD_CHOOSE_CLASS, 
     24        CMD_FINALIZE_OPTIONS, 
    2425        CMD_BUY_STAT, 
    2526        CMD_SELL_STAT, 
    2627        CMD_RESET_STATS, 
     
    2930        CMD_NAME_CHOICE, 
    3031        CMD_ACCEPT_CHARACTER, 
    3132 
    32         /*  
     33        /* 
    3334         * The main game commands 
    3435         */ 
    3536        CMD_GO_UP, 
     
    7475        CMD_ENTER_STORE, 
    7576        CMD_ALTER, 
    7677 
    77     /* Store commands */         
     78    /* Store commands */ 
    7879        CMD_SELL, 
    7980        CMD_BUY, 
    8081        CMD_STASH, 
     
    103104#define DIR_UNKNOWN 0 
    104105#define DIR_TARGET 5 
    105106 
    106 enum  
     107enum 
    107108{ 
    108109        REST_TURNS, 
    109110        REST_ALL, 
    110111        REST_ALL_POINTS, 
    111         REST_SOME_POINTS         
     112        REST_SOME_POINTS 
    112113}; 
    113114 
    114115 
    115 typedef union  
     116typedef union 
    116117{ 
    117118        const char *string; 
    118          
     119 
    119120        int choice; 
    120121        int item; 
    121122        int number; 
    122123        int direction; 
    123          
    124         struct  
     124 
     125        struct 
    125126        { 
    126127                int x, y; 
    127128        } point; 
     
    145146        cmd_code command; 
    146147 
    147148        /* Number of times to attempt to repeat command. */ 
    148         int repeat;  
     149        int repeat; 
    149150 
    150151        /* Arguments to the command */ 
    151152        cmd_arg args[CMD_MAX_ARGS]; 
     
    160161/* Inserts a command in the queue to be carried out. */ 
    161162errr cmd_insert_s(game_command *cmd); 
    162163 
    163 /*  
     164/* 
    164165 * Convenience function. 
    165  * Inserts a command with params in the queue to be carried out.  
     166 * Inserts a command with params in the queue to be carried out. 
    166167 */ 
    167168errr cmd_insert(cmd_code c, ...); 
    168169 
  • .c

    old new  
    2828 * This file implements the user interface side of the birth process 
    2929 * for the classic terminal-based UI of Angband. 
    3030 * 
    31  * It models birth as a series of steps which must be carried out in  
     31 * It models birth as a series of steps which must be carried out in 
    3232 * a specified order, with the option of stepping backwards to revisit 
    3333 * past choices. 
    3434 * 
     
    9494        /* Prompt for it */ 
    9595        prt("New character based on previous one:", 0, 0); 
    9696        prt(prompt, Term->hgt - 1, Term->wid / 2 - strlen(prompt) / 2); 
    97          
     97 
    9898        /* Buttons */ 
    9999        button_kill_all(); 
    100100        button_add("[Y]", 'y'); 
    101101        button_add("[N]", 'n'); 
    102102        button_add("[C]", 'c'); 
    103103        redraw_stuff(); 
    104          
     104 
    105105        do 
    106106        { 
    107107                /* Get a key */ 
    108108                ke = inkey_ex(); 
    109                  
     109 
    110110                if (ke.key == 'N' || ke.key == 'n') 
    111111                { 
    112112                        cmd_insert(CMD_BIRTH_RESET, TRUE); 
     
    127127                        next = BIRTH_COMPLETE; 
    128128                } 
    129129        } while (next == BIRTH_QUICKSTART); 
    130          
     130 
    131131        /* Buttons */ 
    132132        button_kill_all(); 
    133133        redraw_stuff(); 
     
    172172   the useful information for the menu - text of the menu items, "help" 
    173173   text, current (or default) selection, and whether random selection 
    174174   is allowed. */ 
    175 struct birthmenu_data  
     175struct birthmenu_data 
    176176{ 
    177177        const char **items; 
    178178        const char *hint; 
     
    191191        c_put_str(attr, data->items[oid], row, col); 
    192192} 
    193193 
    194 /* We defer the choice of actual actions until outside of the menu API  
     194/* We defer the choice of actual actions until outside of the menu API 
    195195   in menu_question(), so this can be a reasonably simple function 
    196196   for when a menu "command" is activated. */ 
    197197static bool birthmenu_handler(char cmd, void *db, int oid) 
     
    210210 
    211211        /* Output to the screen */ 
    212212        text_out_hook = text_out_to_screen; 
    213          
     213 
    214214        /* Indent output */ 
    215215        text_out_indent = RACE_AUX_COL; 
    216216        Term_gotoxy(RACE_AUX_COL, TABLE_ROW); 
    217217 
    218         for (j = 0; j < A_MAX; j++)  
    219         {   
     218        for (j = 0; j < A_MAX; j++) 
     219        { 
    220220                text_out_e("%s%+d\n", stat_names_reduced[j], p_info[i].r_adj[j]); 
    221221        } 
    222          
     222 
    223223        text_out_e("Hit die: %d\n", p_info[i].r_mhp); 
    224224        text_out_e("Experience: %d%%\n", p_info[i].r_exp); 
    225225        text_out_e("Infravision: %d ft", p_info[i].infra * 10); 
    226          
     226 
    227227        /* Reset text_out() indentation */ 
    228228        text_out_indent = 0; 
    229229} 
     
    234234 
    235235        /* Output to the screen */ 
    236236        text_out_hook = text_out_to_screen; 
    237          
     237 
    238238        /* Indent output */ 
    239239        text_out_indent = CLASS_AUX_COL; 
    240240        Term_gotoxy(CLASS_AUX_COL, TABLE_ROW); 
    241241 
    242         for (j = 0; j < A_MAX; j++)  
    243         {   
    244                 text_out_e("%s%+d\n", stat_names_reduced[j], c_info[i].c_adj[j]);  
     242        for (j = 0; j < A_MAX; j++) 
     243        { 
     244                text_out_e("%s%+d\n", stat_names_reduced[j], c_info[i].c_adj[j]); 
    245245        } 
    246246 
    247         text_out_e("Hit die: %d\n", c_info[i].c_mhp);    
     247        text_out_e("Hit die: %d\n", c_info[i].c_mhp); 
    248248        text_out_e("Experience: %d%%", c_info[i].c_exp); 
    249          
     249 
    250250        /* Reset text_out() indentation */ 
    251251        text_out_indent = 0; 
    252252} 
     
    294294{ 
    295295        int i; 
    296296 
    297         const char *roller_choices[MAX_BIRTH_ROLLERS] = {  
    298                 "Point-based",  
    299                 "Standard roller"  
     297        const char *roller_choices[MAX_BIRTH_ROLLERS] = { 
     298                "Point-based", 
     299                "Standard roller" 
    300300        }; 
    301301 
    302302        struct birthmenu_data *mdata; 
     
    305305        init_birth_menu(&sex_menu, MAX_SEXES, p_ptr->psex, &gender_region, TRUE, NULL); 
    306306        mdata = sex_menu.menu_data; 
    307307        for (i = 0; i < MAX_SEXES; i++) 
    308         {        
     308        { 
    309309                mdata->items[i] = sex_info[i].title; 
    310310        } 
    311311        mdata->hint = "Your 'sex' does not have any significant gameplay effects."; 
     
    315315        mdata = race_menu.menu_data; 
    316316 
    317317        for (i = 0; i < z_info->p_max; i++) 
    318         {        
     318        { 
    319319                mdata->items[i] = p_name + p_info[i].name; 
    320320        } 
    321321        mdata->hint = "Your 'race' determines various intrinsic factors and bonuses."; 
     
    325325        mdata = class_menu.menu_data; 
    326326 
    327327        for (i = 0; i < z_info->c_max; i++) 
    328         {        
     328        { 
    329329                mdata->items[i] = c_name + c_info[i].name; 
    330330        } 
    331331        mdata->hint = "Your 'class' determines various intrinsic abilities and bonuses"; 
    332                  
     332 
    333333        /* Roller menu straightforward again */ 
    334334        init_birth_menu(&roller_menu, MAX_BIRTH_ROLLERS, 0, &roller_region, FALSE, NULL); 
    335335        mdata = roller_menu.menu_data; 
    336336        for (i = 0; i < MAX_BIRTH_ROLLERS; i++) 
    337         {        
     337        { 
    338338                mdata->items[i] = roller_choices[i]; 
    339339        } 
    340340        mdata->hint = "Your choice of character generation.  Point-based is recommended."; 
     
    384384        "birth process, '{lightgreen}={/}' for the birth options, '{lightgreen}?{/} " \ 
    385385        "for help, or '{lightgreen}Ctrl-X{/}' to quit." 
    386386 
    387 /* Show the birth instructions on an otherwise blank screen */   
     387/* Show the birth instructions on an otherwise blank screen */ 
    388388static void print_menu_instructions(void) 
    389389{ 
    390390        /* Clear screen */ 
    391391        Term_clear(); 
    392          
     392 
    393393        /* Output to the screen */ 
    394394        text_out_hook = text_out_to_screen; 
    395          
     395 
    396396        /* Indent output */ 
    397397        text_out_indent = QUESTION_COL; 
    398398        Term_gotoxy(QUESTION_COL, HEADER_ROW); 
    399          
     399 
    400400        /* Display some helpful information */ 
    401401        text_out_e(BIRTH_MENU_HELPTEXT); 
    402          
     402 
    403403        /* Reset text_out() indentation */ 
    404404        text_out_indent = 0; 
    405405} 
    406406 
    407 /* Allow the user to select from the current menu, and return the  
     407/* Allow the user to select from the current menu, and return the 
    408408   corresponding command to the game.  Some actions are handled entirely 
    409409   by the UI (displaying help text, for instance). */ 
    410410static enum birth_stage menu_question(enum birth_stage current, menu_type *current_menu, cmd_code choice_command) 
     
    414414        ui_event_data cx; 
    415415 
    416416        enum birth_stage next = BIRTH_RESET; 
    417          
     417 
    418418        /* Print the question currently being asked. */ 
    419419        clear_question(); 
    420420        Term_putstr(QUESTION_COL, QUESTION_ROW, -1, TERM_YELLOW, menu_data->hint); 
     
    427427                cx = menu_select(current_menu, &cursor, EVT_CMD); 
    428428 
    429429                /* As all the menus are displayed in "hierarchical" style, we allow 
    430                    use of "back" (left arrow key or equivalent) to step back in  
     430                   use of "back" (left arrow key or equivalent) to step back in 
    431431                   the proces as well as "escape". */ 
    432432                if (cx.type == EVT_BACK || cx.type == EVT_ESCAPE) 
    433433                { 
    434434                        next = BIRTH_BACK; 
    435435                } 
    436436                /* '\xff' is a mouse selection, '\r' a keyboard one. */ 
    437                 else if (cx.key == '\xff' || cx.key == '\r')  
     437                else if (cx.key == '\xff' || cx.key == '\r') 
    438438                { 
    439439                        if (current == BIRTH_ROLLER_CHOICE) 
    440440                        { 
     441                                cmd_insert(CMD_FINALIZE_OPTIONS); 
     442 
    441443                                if (cursor) 
    442444                                { 
    443445                                        /* Do a first roll of the stats */ 
     
    446448                                } 
    447449                                else 
    448450                                { 
    449                                         /*  
    450                                          * Make sure we've got a point-based char to play with.  
     451                                        /* 
     452                                         * Make sure we've got a point-based char to play with. 
    451453                                         * We call point_based_start here to make sure we get 
    452454                                         * an update on the points totals before trying to 
    453455                                         * display the screen.  The call to CMD_RESET_STATS 
     
    466468                        } 
    467469                } 
    468470                /* '*' chooses an option at random from those the game's provided. */ 
    469                 else if (cx.key == '*' && menu_data->allow_random)  
     471                else if (cx.key == '*' && menu_data->allow_random) 
    470472                { 
    471473                        current_menu->cursor = randint0(current_menu->count); 
    472474                        cmd_insert(choice_command, current_menu->cursor); 
     
    474476                        menu_refresh(current_menu); 
    475477                        next = current + 1; 
    476478                } 
    477                 else if (cx.key == '=')  
     479                else if (cx.key == '=') 
    478480                { 
    479481                        do_cmd_options(); 
    480482                        next = current; 
    481483                } 
    482                 else if (cx.key == KTRL('X'))  
     484                else if (cx.key == KTRL('X')) 
    483485                { 
    484486                        cmd_insert(CMD_QUIT); 
    485487                        next = BIRTH_COMPLETE; 
     
    489491                        do_cmd_help(); 
    490492                } 
    491493        } 
    492          
     494 
    493495        return next; 
    494496} 
    495497 
     
    527529 
    528530        /* Prepare a prompt (must squeeze everything in) */ 
    529531        strnfcat(prompt, sizeof (prompt), &promptlen, "['r' to reroll"); 
    530         if (prev_roll)  
     532        if (prev_roll) 
    531533                strnfcat(prompt, sizeof(prompt), &promptlen, ", 'p' for prev"); 
    532534        strnfcat(prompt, sizeof (prompt), &promptlen, " or 'Enter' to accept]"); 
    533535 
    534536        /* Prompt for it */ 
    535537        prt(prompt, Term->hgt - 1, Term->wid / 2 - promptlen / 2); 
    536          
     538 
    537539        /* Prompt and get a command */ 
    538540        ke = inkey_ex(); 
    539541        ch = ke.key; 
    540542 
    541         if (ch == ESCAPE)  
     543        if (ch == ESCAPE) 
    542544        { 
    543545                button_kill('r'); 
    544546                button_kill('p'); 
     
    547549        } 
    548550 
    549551        /* 'Enter' accepts the roll */ 
    550         if ((ch == '\r') || (ch == '\n'))  
     552        if ((ch == '\r') || (ch == '\n')) 
    551553        { 
    552554                next = BIRTH_NAME_CHOICE; 
    553555        } 
     
    566568        } 
    567569 
    568570        /* Quit */ 
    569         else if (ch == KTRL('X'))  
     571        else if (ch == KTRL('X')) 
    570572        { 
    571573                cmd_insert(CMD_QUIT); 
    572574                next = BIRTH_COMPLETE; 
     
    630632 
    631633        /* Display the costs header */ 
    632634        put_str("Cost", COSTS_ROW - 1, COSTS_COL); 
    633          
     635 
    634636        /* Display the costs */ 
    635637        for (i = 0; i < A_MAX; i++) 
    636638        { 
     
    638640                put_str(format("%4d", stats[i]), COSTS_ROW + i, COSTS_COL); 
    639641                sum += stats[i]; 
    640642        } 
    641          
     643 
    642644        put_str(format("Total Cost: %2d/%2d", sum, data->birthstats.remaining + sum), COSTS_ROW + A_MAX, TOTAL_COL); 
    643645} 
    644646 
     
    657659 
    658660        /* Register handlers for various events - cheat a bit because we redraw 
    659661           the lot at once rather than each bit at a time. */ 
    660         event_add_handler(EVENT_BIRTHPOINTS, point_based_points, NULL);  
    661         event_add_handler(EVENT_STATS, point_based_stats, NULL);         
    662         event_add_handler(EVENT_GOLD, point_based_misc, NULL);   
     662        event_add_handler(EVENT_BIRTHPOINTS, point_based_points, NULL); 
     663        event_add_handler(EVENT_STATS, point_based_stats, NULL); 
     664        event_add_handler(EVENT_GOLD, point_based_misc, NULL); 
    663665} 
    664666 
    665667static void point_based_stop(void) 
    666668{ 
    667         event_remove_handler(EVENT_BIRTHPOINTS, point_based_points, NULL);       
    668         event_remove_handler(EVENT_STATS, point_based_stats, NULL);      
    669         event_remove_handler(EVENT_GOLD, point_based_misc, NULL);        
     669        event_remove_handler(EVENT_BIRTHPOINTS, point_based_points, NULL); 
     670        event_remove_handler(EVENT_STATS, point_based_stats, NULL); 
     671        event_remove_handler(EVENT_GOLD, point_based_misc, NULL); 
    670672} 
    671673 
    672674static enum birth_stage point_based_command(void) 
     
    682684 
    683685        /* Get key */ 
    684686        ch = inkey(); 
    685          
    686         if (ch == KTRL('X'))  
     687 
     688        if (ch == KTRL('X')) 
    687689        { 
    688690                cmd_insert(CMD_QUIT); 
    689691                next = BIRTH_COMPLETE; 
    690692        } 
    691          
     693 
    692694        /* Go back a step, or back to the start of this step */ 
    693         else if (ch == ESCAPE)  
     695        else if (ch == ESCAPE) 
    694696        { 
    695697                next = BIRTH_BACK; 
    696698        } 
    697699 
    698         else if (ch == 'r' || ch == 'R')  
     700        else if (ch == 'r' || ch == 'R') 
    699701        { 
    700702                cmd_insert(CMD_RESET_STATS, FALSE); 
    701703        } 
    702          
     704 
    703705        /* Done */ 
    704         else if ((ch == '\r') || (ch == '\n'))  
     706        else if ((ch == '\r') || (ch == '\n')) 
    705707        { 
    706708                next = BIRTH_NAME_CHOICE; 
    707709        } 
    708710        else 
    709711        { 
    710712                ch = target_dir(ch); 
    711                  
     713 
    712714                /* Prev stat, looping round to the bottom when going off the top */ 
    713715                if (ch == 8) 
    714716                        stat = (stat + A_MAX - 1) % A_MAX; 
    715                  
     717 
    716718                /* Next stat, looping round to the top when going off the bottom */ 
    717719                if (ch == 2) 
    718720                        stat = (stat + 1) % A_MAX; 
    719                  
     721 
    720722                /* Decrease stat (if possible) */ 
    721723                if (ch == 4) 
    722724                { 
    723725                        cmd_insert(CMD_SELL_STAT, stat); 
    724726                } 
    725                  
     727 
    726728                /* Increase stat (if possible) */ 
    727729                if (ch == 6) 
    728730                { 
     
    732734 
    733735        return next; 
    734736} 
    735          
     737 
    736738/* ------------------------------------------------------------------------ 
    737739 * Asking for the player's chosen name. 
    738740 * ------------------------------------------------------------------------ */ 
     
    742744        char name[32]; 
    743745 
    744746        if (get_name(name, sizeof(name))) 
    745         {        
     747        { 
    746748                cmd_insert(CMD_NAME_CHOICE, name); 
    747749                next = BIRTH_FINAL_CONFIRM; 
    748750        } 
     
    766768 
    767769        /* Prompt for it */ 
    768770        prt(prompt, Term->hgt - 1, Term->wid / 2 - strlen(prompt) / 2); 
    769          
     771 
    770772        /* Buttons */ 
    771773        button_kill_all(); 
    772774        button_add("[Continue]", 'q'); 
    773775        button_add("[ESC]", ESCAPE); 
    774776        button_add("[S]", 'S'); 
    775777        redraw_stuff(); 
    776          
     778 
    777779        /* Get a key */ 
    778780        ke = inkey_ex(); 
    779          
     781 
    780782        /* Start over */ 
    781783        if (ke.key == 'S' || ke.key == 's') 
    782784        { 
     
    796798                cmd_insert(CMD_ACCEPT_CHARACTER); 
    797799                next = BIRTH_COMPLETE; 
    798800        } 
    799          
     801 
    800802        /* Buttons */ 
    801803        button_kill_all(); 
    802804        redraw_stuff(); 
     
    815817 * ------------------------------------------------------------------------ */ 
    816818 
    817819/* 
    818  * This is called when we receive a request for a command in the birth  
     820 * This is called when we receive a request for a command in the birth 
    819821 * process. 
    820822 
    821823 * The birth process continues until we send a final character confirmation 
     
    838840                { 
    839841                        cmd_insert(CMD_BIRTH_RESET, TRUE); 
    840842                        roller = BIRTH_RESET; 
    841                          
     843 
    842844                        if (quickstart_allowed) 
    843845                                next = BIRTH_QUICKSTART; 
    844846                        else 
     
    871873                                menu = &race_menu; 
    872874                                command = CMD_CHOOSE_RACE; 
    873875                        } 
    874                          
     876 
    875877                        if (current_stage > BIRTH_RACE_CHOICE) 
    876878                        { 
    877879                                menu_refresh(&race_menu); 
     
    885887                                menu = &roller_menu; 
    886888                                command = CMD_NULL; 
    887889                        } 
    888                          
     890 
    889891                        next = menu_question(current_stage, menu, command); 
    890892 
    891893                        if (next == BIRTH_BACK) 
    892894                                next = current_stage - 1; 
    893895 
    894896                        /* Make sure that the character gets reset before quickstarting */ 
    895                         if (next == BIRTH_QUICKSTART)  
     897                        if (next == BIRTH_QUICKSTART) 
    896898                                next = BIRTH_RESET; 
    897899 
    898900                        break; 
     
    901903                case BIRTH_POINTBASED: 
    902904                { 
    903905                        roller = BIRTH_POINTBASED; 
    904          
     906 
    905907                        if (prev > BIRTH_POINTBASED) 
    906908                                point_based_start(); 
    907909