Gacha Probability Calculator

class Gacha:
    def __init__(self, rate_r, rate_ssr, rate_target, guarantee, pity):
        self.rate_r = rate_r
        self.rate_ssr = rate_ssr
        self.rate_target = rate_target
        self.guarantee = guarantee
        self.pity = pity
        self.limit = -1

    def __init__(self):
        self.hi3rd_expansion()

    def set_limit(self,limit):
        self.limit = limit

    def prob(self,table,state,pulls):

        if state.are_all_targets_acquired():
            return [1,0]

        if pulls == self.limit:
            return [0,0]

        if state.get_tuple() in table:
            return table[state.get_tuple()]

        if self.pity == state.pity_counter+1:
            pity_state = state.copy()
            pity_state.got_target()
            val = self.prob(table,pity_state,pulls+1)
            table[state.get_tuple()] = val
            return [val[0],val[1]+1]

        if self.guarantee == state.guarantee_counter+1:
            val = [0,0]

            brag_state = state.copy()
            brag_state.got_target()
            temp_val = self.prob(table,brag_state,pulls+1)
            brag_mult = self.rate_target/self.rate_ssr
            val[0] += temp_val[0]*brag_mult
            val[1] += (temp_val[1]+1)*brag_mult

            salt_state = state.copy()
            salt_state.got_salt()
            temp_val = self.prob(table,salt_state,pulls+1)
            salt_mult = 1-brag_mult
            val[0] += temp_val[0]*salt_mult
            val[1] += (temp_val[1]+1)*salt_mult

            table[state.get_tuple()] = val
            return val

        val = [0,0]

        brag_state = state.copy()
        brag_state.got_target()
        temp_val = self.prob(table,brag_state,pulls+1)
        brag_mult = self.rate_target
        val[0] += temp_val[0]*brag_mult
        val[1] += (temp_val[1]+1)*brag_mult

        salt_state = state.copy()
        salt_state.got_salt()
        temp_val = self.prob(table,salt_state,pulls+1)
        salt_mult = self.rate_ssr - self.rate_target
        val[0] += temp_val[0]*salt_mult
        val[1] += (temp_val[1]+1)*salt_mult

        uber_salt_state = state.copy()
        uber_salt_state.got_uber_salt()
        temp_val = self.prob(table,uber_salt_state,pulls+1)
        uber_salt_mult = self.rate_r
        val[0] += temp_val[0]*uber_salt_mult
        val[1] += (temp_val[1]+1)*uber_salt_mult

        table[state.get_tuple()] = val
        return val

    def hi3rd_expansion(self):
        self.rate_r = 0.85
        self.rate_ssr = 0.15
        self.rate_target = 0.015
        self.guarantee = 10
        self.pity = 100
        self.limit = -1


class State:
    def __init__(self, guarantee_counter, pity_counter):
        self.guarantee_counter = guarantee_counter
        self.pity_counter = pity_counter
        self.targets_counter = 0
        self.targets_goal = 1

    def are_all_targets_acquired(self):
        return self.targets_counter == self.targets_goal

    def reset_counter(self):
        self.guarantee_counter = 0
        self.pity_counter = 0

    def copy(self):
        copied_state = State(self.guarantee_counter, self.pity_counter)
        copied_state.targets_counter = self.targets_counter
        copied_state.targets_goal = self.targets_goal
        return copied_state

    def got_target(self):
        self.targets_counter += 1
        self.reset_counter()

    def got_salt(self):
        self.guarantee_counter = 0
        self.pity_counter += 1

    def got_uber_salt(self):
        self.guarantee_counter += 1
        self.pity_counter += 1

    def get_tuple(self):
        return (self.guarantee_counter, self.pity_counter, self.targets_counter)

def prob_table():
    gacha = Gacha()
    init_state = State(0,0)
    table = {}
    for i in range(20):
        for j in range(5):
            table.clear()
            gacha.set_limit(i*5+j+1)
            val = gacha.prob(table,init_state,0)[0]
            print("%3i : %5.4f " % (i*5+j+1,val), end=" ")
        print(" ")