import random
from collections import defaultdict

def d6():
    return random.randint(1,6)

def xdnk(x,n):
    best = 0
    for k in range(x):
        roll = random.randint(1,n)
        if best < roll:
            best = roll
    return best

def testxdnk(rolls):
    totals = defaultdict(int)
    for r in range(rolls):
        totals[xdnk(2,6)] += 1
    for i in range(1,7):
        print(i, totals[i])

def calcKeep(rolls):
    for d in range(1,5):
        total = 0
        for i in range(rolls):
            total += xdnk(d,6)
        print(d, total/rolls)

def calcStructure(rolls):
    results = []
    for i in range(4):
        results.append(defaultdict(int))
    for i in range(rolls):
        for d in range(4):
            high = 6
            ones = 0
            for x in range(d+1):
                roll = d6()
                if high > roll:
                    high = roll
                if roll == 1:
                    ones += 1
            if ones >= 2:
                results[d]['destroyed'] += 1
                break
            if high >= 5:
                results[d]['impaired'] += 1
            elif high >= 2:
                results[d]['trauma'] += 1
            elif high == 1:
                if d == 0:
                    results[d]['stunned'] += 1
                elif d == 1:
                    if random.randint(1,20) < 10:
                        results[d]['destroyed'] += 1
                        break
                elif d >= 2:
                    results[d]['destroyed'] += 1
                    break
            if d == 3:
                results[d]['critical'] += 1
    totals = [0]*4
    for i in range(4):
        print(i+1)
        total = 0
        for k,n in results[i].items():
            print(k,n/rolls*100)
            total += n/rolls*100
            if k != 'critical':
                totals[i] += n
        #print(total)
    for i in range(4):
        print(i+1)
        for k,n in results[i].items():
            print(k,n/totals[i]*100)

def calcAccuracy(rolls, target, diceNumber=3, minus=False):
    hits = 0
    for n in range(rolls):
        roll = random.randint(1,20)
        if not minus:
            roll += xdnk(diceNumber,6)
        else:
            roll -= xdnk(diceNumber,6)
        if roll >= target:
            hits += 1
    print(hits/rolls*100)

def batchAccuracy(rolls):
    for n in range(1,21):
        print('--', n)
        for i in range(3,0, -1):
            calcAccuracy(rolls, n, i, True)
        for i in range(0,4):
            calcAccuracy(rolls, n, i, False)


def dragoncrit(rolls):
    score = 0
    for i in range(rolls):
        roll = random.randint(1,20) + 3 + random.randint(1,6)
        if roll >= 20:
            score += 1
    print("Crit Chance:", score/rolls*100)

def critdamage(d, a, rolls):
    score = 0
    for i in range(rolls):
        rollList = sorted(random.randint(1,6) for r in range(d*2))
        score += sum(rollList[d:]) + a
    print("Average damage:", score/rolls)

def ultraStruct2(rolls):
    dead = 0
    check = 0
    for i in range(rolls):
        dice = [[random.randint(1,6) for r in range(2)] for s in range(2)]
        if sum(dice[0]) == 2 and sum(dice[1]) == 2:
            dead += 1
        elif 1 in dice[0] and 1 in dice[1]:
            check += 1
    print(f'Dead:{dead/rolls*100} Checks:{check/rolls*100}')

def combatDrill(numDice, bonusDamage, rolls):
    damage = 0
    heat = 0
    for i in range(rolls):
        dice = [random.randint(1,6) for r in range(numDice)]
        bonusDice = 0
        while 1 in dice:
            dice.sort(reverse=True)
            dice.pop()
            dice = dice + [random.randint(1,6) for r in range(2)]
            heat += 1
            bonusDice += 1
        dice.sort(reverse=True)
        damage += sum( dice[ :numDice + bonusDice] )
    print(f'Damage:{damage/rolls} Heat:{heat/rolls}')

def combatDrillCrit(numDice, bonusDamage, rolls):
    damage = 0
    heat = 0
    for i in range(rolls):
        dice = [random.randint(1,6) for r in range(numDice)]
        bonusDice = 0
        while 1 in dice:
            dice.sort(reverse=True)
            dice.pop()
            dice = dice + [random.randint(1,6) for r in range(2)]
            heat += 1
            bonusDice += 1
        dice.sort(reverse=True)
        damage += sum( dice[ :int(numDice/2) + bonusDice] )
    print(f'Damage:{damage/rolls} Heat:{heat/rolls}')

def combatDrillWeakCrit(numDice, bonusDamage, rolls):
    damage = 0
    heat = 0
    for i in range(rolls):
        dice = [random.randint(1,6) for r in range(numDice)]
        dice.sort(reverse=True)
        dice = dice[:int(numDice/2)]
        while 1 in dice:
            dice.sort(reverse=True)
            dice.pop()
            dice = dice + [random.randint(1,6) for r in range(2)]
            heat += 1
        damage += sum(dice)
    print(f'Damage:{damage/rolls} Heat:{heat/rolls}')

#testxdnk(1000000)
#calcKeep(1000)
#calcStructure(1000000)
#calcAccuracy(10000, 10, 1, True)
#batchAccuracy(10000)
#dragoncrit(10000)
#critdamage(7, 3, 10000)
#ultraStruct2(1000000)
combatDrillCrit(8, 0, 1000000)
combatDrillWeakCrit(8, 0, 1000000)
combatDrill(4,0,1000000)