terribleDaSoupedUpShokka

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

enum suit {
    NA = 0,
    deathSkullz = 1,
    badMoonz = 2,
} card;

void badMoonzReroll(uint16_t numDice,uint8_t * pResultArray)
{
    uint16_t i;
    uint8_t *pLocal = pResultArray;
    printf("BadMoonz Rerolled: ");
    for(i = 0;i<numDice;i++)
    {
        if(*pLocal == 1)
        {
            *pLocal = rand();
            while(*pLocal > 6)
            {
                *pLocal -= 6;
            }
            printf("%d ",*pLocal);
        }
        pLocal++;
    }
    printf("\r\n");
}

uint8_t deathSkullzReroll(uint16_t numDice,uint8_t * pResultArray,uint8_t maxReRollValue)
{
    uint8_t *pLocal = pResultArray;
    uint8_t localRerollValue = 1;
    uint16_t i;


    while(localRerollValue < maxReRollValue)
    {
        pLocal = pResultArray;
        for(i = 0;i<numDice;i++)
        {
            if(*pLocal == localRerollValue)
            {
                *pLocal = rand();
                while(*pLocal > 6)
                {
                    *pLocal -= 6;
                }

                printf("DeathSkullz Rerolled:  %d\r\n",*pLocal);
                return 1;
            }
            pLocal++;
        }

        localRerollValue++;
    }

    return 0;
}


void rollDice(uint16_t numDice,uint8_t * pResultArray)
{
    uint8_t *pLocal = pResultArray;
    uint16_t i;

    printf("Rolled: ");

    for(i = 0;i<numDice;i++)
    {
        *pLocal = rand();
        while(*pLocal > 6)
        {
            *pLocal -= 6;
        }
        printf("%d ",*pLocal);
        pLocal++;
    }

    printf("\r\n");
}

uint16_t calcSuccess(uint16_t numDice,uint8_t * pResultArray, uint8_t successValue)
{
    uint8_t *pLocal = pResultArray;
    uint16_t i,
             recordedHits = 0;

    for(i = 0;i<numDice;i++)
    {
        if(*pLocal >= successValue)
        {
            recordedHits++;
        }

        pLocal++;
    }
    return recordedHits;
}

uint16_t rollToHit(uint16_t numDice,uint8_t klan,uint8_t successValue,uint8_t moreDakka)
{
    uint8_t resultArray[1000] = {0},resultArrayDakka[1000] = {0};
    uint16_t hits = 0,dakkaDakkaDakkaDice = 0, dakkaDakkaDakkaHits = 0;
    uint8_t deathSkullzRerollUsed = 0;

    //generate hit rolls
    rollDice(numDice,&resultArray[0]);

    if(klan == badMoonz) //reroll 1s
    {
        badMoonzReroll(numDice,&resultArray[0]);
    }

    hits = calcSuccess(numDice,&resultArray[0],successValue);

    if(klan == deathSkullz)
    {
        if(deathSkullzReroll(numDice,&resultArray[0],4)) //Only reroll upto a 4
        {
            deathSkullzRerollUsed = 1; //De we need this reroll
            hits = calcSuccess(numDice,&resultArray[0],successValue);
        }
    }

    //calc dakkadakkadakka shots
    if(moreDakka)
    {
        dakkaDakkaDakkaDice = calcSuccess(numDice,&resultArray[0],5);
    }
    else
    {
        dakkaDakkaDakkaDice = calcSuccess(numDice,&resultArray[0],6);
    }

    if(dakkaDakkaDakkaDice != 0)
    {

        //now roll those extra hits
        rollDice(dakkaDakkaDakkaDice,&resultArrayDakka[0]);

        if(klan == badMoonz) //reroll 1s
        {
            badMoonzReroll(dakkaDakkaDakkaDice,&resultArrayDakka[0]);
        }

        dakkaDakkaDakkaHits = calcSuccess(dakkaDakkaDakkaDice,&resultArrayDakka[0],successValue);

        if(!deathSkullzRerollUsed) //has the reroll been used?
        {
            if(klan == deathSkullz)
            {
                deathSkullzReroll(numDice,&resultArray[0],4); //Only reroll upto a 4
                deathSkullzRerollUsed = 1;
                dakkaDakkaDakkaHits = calcSuccess(numDice,&resultArray[0],successValue);
            }
        }

    }

    return dakkaDakkaDakkaHits + hits;
}

uint16_t rollToWound(uint16_t numDice,uint8_t klan,uint8_t successValue)
{
    uint8_t resultArray[1000] = {0};
    uint16_t wounds = 0;

    //generate wound rolls
    rollDice(numDice,&resultArray[0]);



    if(klan == deathSkullz)
    {
        deathSkullzReroll(numDice,&resultArray[0],4); //Only reroll upto a 4
        wounds = calcSuccess(numDice,&resultArray[0],successValue);
    }

    wounds = calcSuccess(numDice,&resultArray[0],successValue);

    return wounds;

}

uint16_t rollToSave(uint16_t numDice,uint8_t successValue)
{
    uint8_t resultArray[1000] = {0};
    uint16_t saves = 0;

    //generate saves
    rollDice(numDice,&resultArray[0]);

    saves = calcSuccess(numDice,&resultArray[0],successValue);

    return numDice - saves; //We effectively want fails
}

uint16_t rollToDamage(uint16_t numDice,uint8_t klan,uint8_t minSuccessValue)
{
    uint8_t resultArray[1000] = {0};
    uint16_t damage = 0, i = 0;

    //generate damage
    rollDice(numDice,&resultArray[0]);

    if(klan == deathSkullz)
    {
        deathSkullzReroll(numDice,&resultArray[0],minSuccessValue - 1); //Only reroll below min success, rerolling lowest damage first
    }

    for(i = 0;i < numDice; i++)
    {
        damage += resultArray[i];
    }

    return damage;
}

uint8_t calcMortalWounds(uint8_t hits)
{
    uint8_t i, wounds = 0, dice = 0;

    for(i = 0;i < hits;i++)
    {
        rollDice(1,&dice);
        dice = dice / 2;
        wounds += dice;
    }
    return wounds;
}

uint8_t calcWoundValue(uint8_t wepStr, uint8_t targetToughness)
{
    uint8_t woundValue = 4;

    if(wepStr > targetToughness)
    {
        woundValue--;
        if(wepStr >= (targetToughness * 2))
        {
            woundValue--;
        }
    }
    else if(wepStr < targetToughness)
    {
        woundValue++;
        if(wepStr <= (targetToughness / 2))
        {
            woundValue--;
        }
    }

    return woundValue;
}

uint16_t doAttack(uint16_t numDice,uint8_t klan,uint8_t hitValue,uint8_t targetToughness,uint8_t saveValue,uint8_t minDamageValue,uint8_t moreDakka)
{
    uint8_t wepStr[2] = {0}, wepStrSum = 0, woundValue = 0;
    uint16_t result = 0;
    uint16_t mortalWounds = 0;

    rollDice(2,&wepStr[0]);

    wepStrSum = wepStr[0] + wepStr[1];

    result = rollToHit(numDice,klan,hitValue,moreDakka);

    if(wepStrSum> 10) //Mortal wounds for hits?
    {
        mortalWounds = calcMortalWounds(result);
    }

    woundValue = calcWoundValue(wepStrSum,targetToughness);

    result = rollToWound(result,klan,woundValue);

    result = rollToSave(result,saveValue);

    result = rollToDamage(result,klan,minDamageValue);

    return result + mortalWounds;
}


#define KLAN deathSkullz
//#define KLAN badMoonz
//#define KLAN NA
#define HITVALUE 5
#define TARGETTOUGHNESS 7
#define TARGETSAVE     5
#define MINDAMAGEVALUE 3
#define MOREDAKKA 1
#define NUMBEROFFIRINGS 10000

int main(int argc, char *argv[])
{
    uint16_t i;
    uint8_t dice[2] = {0};
    uint32_t subTotal = 0,total = 0;
    double hitFraction = 0;


    for(i = 0;i < NUMBEROFFIRINGS;i++)
    {
        rollDice(2,&dice[0]);
        subTotal = doAttack(dice[0] + dice[1],KLAN,HITVALUE,TARGETTOUGHNESS,TARGETSAVE,MINDAMAGEVALUE,MOREDAKKA);
        printf("Final Hits %d\r\n",subTotal);
        total += subTotal;
    }

    hitFraction = (double)total / NUMBEROFFIRINGS;
    printf("Total wounds %d\r\n",total);
    printf("Average Of %f wounds (including mortal) over %d firings\r\n",hitFraction, NUMBEROFFIRINGS);

    return 0;
}