def _roll_d100(chance_of_success: int) -> bool:
    return int(random.random() * 100) <= chance_of_success

def init_physical_traits(self, parents: tuple=()):
    inherit_chance = game.config["cat_generation"]["physical_trait_inherit_chance"]
    self_gen_chance = game.config["cat_generation"]["physical_trait_chance"]

    trait_categories = [
        Pelt.physical_trait_teeth,
        Pelt.physical_trait_ear_type,
        Pelt.physical_trait_ear_fold,
        Pelt.physical_trait_headfur,
        Pelt.physical_trait_cheekfur,
        Pelt.physical_trait_mane,
        Pelt.physical_trait_fur_type,
        Pelt.physical_trait_muzzle_type,
        Pelt.physical_trait_body_type,
        Pelt.physical_trait_size
    ]

    actual_parents = [p for p in parents if p]

    # Gather up the parental traits
    par_traits = set()
    for p in actual_parents:
        par_traits.add(p.pelt.physical_trait_1)
        par_traits.add(p.pelt.physical_trait_2)
        par_traits.add(p.pelt.physical_trait_hidden)

    # Remove any None values from par_traits
    par_traits.discard(None)

    # Now we try to inherit traits from parents
    if par_traits:
        # Check for conflicting traits from the same category
        # Select one of the conflicting traits to keep
        for category in trait_categories:
            clash_traits = par_traits.intersection(category)
            if len(clash_traits) > 1:
                chosen_trait = random.choice(list(clash_traits))
                par_traits = par_traits.difference(clash_traits)
                par_traits.add(chosen_trait)


        # Randomly select physical_trait_1 and physical_trait_2 from par_traits
        if _roll_d100(inherit_chance):
            self.physical_trait_1 = random.choice(list(par_traits))
            par_traits.remove(self.physical_trait_1)

            # Try again for a second!
            if par_traits and _roll_d100(inherit_chance):
                self.physical_trait_2 = random.choice(list(par_traits))
                par_traits.remove(self.physical_trait_2)

        # Try to inherit a hidden trait regardless of the above, if there are any left
        # +25% chance of any remaining genes being inherited as hidden
        if par_traits and _roll_d100(inherit_chance - 25):
            self.physical_trait_hidden = random.choice(list(par_traits))

    # If we didn't inherit traits, we attempt self generation
    if not self.physical_trait_1:
        trait_pool = [(trait, category) for category in trait_categories for trait in category]

        if _roll_d100(self_gen_chance):
            # We get one trait!
            selected_trait, category = random.choice(trait_pool)
            self.physical_trait_1 = selected_trait

            # Try for a second trait, much less likely
            if _roll_d100(0.1 * self_gen_chance):
                # If we get a second trait, it can't be from the same category
                remaining_traits = [t for t, c in trait_pool if c != category]
                self.physical_trait_2 = random.choice(remaining_traits)