(C++) Doom RNG calculator

#include <stdio.h>
#include <string>
#include <iostream>

unsigned char rndtable[256] = {
    0,   8, 109, 220, 222, 241, 149, 107,  75, 248, 254, 140,  16,  66 ,
    74,  21, 211,  47,  80, 242, 154,  27, 205, 128, 161,  89,  77,  36 ,
    95, 110,  85,  48, 212, 140, 211, 249,  22,  79, 200,  50,  28, 188 ,
    52, 140, 202, 120,  68, 145,  62,  70, 184, 190,  91, 197, 152, 224 ,
    149, 104,  25, 178, 252, 182, 202, 182, 141, 197,   4,  81, 181, 242 ,
    145,  42,  39, 227, 156, 198, 225, 193, 219,  93, 122, 175, 249,   0 ,
    175, 143,  70, 239,  46, 246, 163,  53, 163, 109, 168, 135,   2, 235 ,
    25,  92,  20, 145, 138,  77,  69, 166,  78, 176, 173, 212, 166, 113 ,
    94, 161,  41,  50, 239,  49, 111, 164,  70,  60,   2,  37, 171,  75 ,
    136, 156,  11,  56,  42, 146, 138, 229,  73, 146,  77,  61,  98, 196 ,
    135, 106,  63, 197, 195,  86,  96, 203, 113, 101, 170, 247, 181, 113 ,
    80, 250, 108,   7, 255, 237, 129, 226,  79, 107, 112, 166, 103, 241 ,
    24, 223, 239, 120, 198,  58,  60,  82, 128,   3, 184,  66, 143, 224 ,
    145, 224,  81, 206, 163,  45,  63,  90, 168, 114,  59,  33, 159,  95 ,
    28, 139, 123,  98, 125, 196,  15,  70, 194, 253,  54,  14, 109, 226 ,
    71,  17, 161,  93, 186,  87, 244, 138,  20,  52, 123, 251,  26,  36 ,
    17,  46,  52, 231, 232,  76,  31, 221,  84,  37, 216, 165, 212, 106 ,
    197, 242,  98,  43,  39, 175, 254, 145, 190,  84, 118, 222, 187, 136 ,
    120, 163, 236, 249
};

int prndindex = 0;

// Argument bitfield
// Bit 0 = Display rolls;
// Bit 1 = Display average;
// Bit 2 = Lowest roll, highest roll;
unsigned char arguments = 0b00000000;

struct RNGObject
{
        int base, max, roll, look;
};

int P_Random (void)
{
    prndindex = (prndindex+1)&0xff;
    return rndtable[prndindex];
}


double brute_prob(int base, int to, int rolls, int dresult)
{
        int success = 0;
        int rollsum = 0;
        int average = 0;
        unsigned int lowroll  = 0xFFFFFFFF;
        unsigned int highroll = 0;
        for(int i = 0; i < 256; i++)
        {
                for(int i = 0; i < rolls; i++) rollsum += base * ( (P_Random()%to) + 1 );
                if(arguments & 1) printf("[%i] Rolled: %d \n", i, rollsum);
                if(rollsum <  lowroll) lowroll = rollsum;
                if(rollsum > highroll) highroll = rollsum;
                if( rollsum < dresult ) success ++;
                average += rollsum;
                rollsum = 0;
        }
        if(arguments & 2) printf("Average Roll: %f\n", (double)average / 256.0 );
        if(arguments & 1<<2)
        {
                printf("Lowest : %d\n",  lowroll);
                printf("Highest: %d\n", highroll);
        }
        return ( (double)success / 256.0 ) * 100.0;
}


// Parse RNG formula input, split at semi-colons.
RNGObject Parse_FInput(std::string* input)
{
        int output[4] = {0,0,0,0};
        int index = 0;
        size_t pos;
        while( (pos = input->find(".")) != -1 )
        {
                output[index] = strtol(input->substr(0,pos).c_str(),NULL,10);
                index++;
                input->erase(0,pos+1);
                if(index > 2) break;
        }
        output[index] = strtol(input->c_str(),NULL,10);

        // DOOM Defaults
        if(output[1] == 0) output[1] = 8;
        if(output[2] == 0) output[2] = 1;

        // Process Arguments
        for(pos = input->find("-"); pos != -1;)
        {
                std::string args = input->substr(pos+1,input->length());
                for(int i = 0; i < args.length(); i++)
                {
                        arguments |= 1 << ( (*(args.c_str()+i) - '0') - 1 );
                }
                break;
        }
        return (RNGObject) { output[0], output[1], output[2], output[3] };
}


int main( int argc, char* argv[] )
{

        printf("Formula key -> Base Damage . Maximum Roll . Number of Rolls . Less Than? \n ");
        printf("Arguments -> Add a '-' at the end of the formula followed by some argument bits.\n\n");
        printf("Enter random formula: ");
        std::string formula;
        std::getline(std::cin, formula);
        RNGObject rngobj = Parse_FInput(&formula);
        double result = brute_prob(rngobj.base,rngobj.max,rngobj.roll,rngobj.look);
        if( rngobj.look              ) printf("Means of probability: %f \n", result );
        if(!rngobj.look && !arguments) printf("No output to give, did you possibly forget to include -1?\n");
        return 0;
}