def test_dice_pool__should_be_created_from_list(): dice_list = [ Douse1(), Douse1(), Douse2(), ] dice_pool = dce.DicePool.from_dice_list(dice_list) assert dice_pool.get_probability_distribution().as_dict[ dce.RolledDicePool.from_rolled_dice_list( rolled_dice_list=[ dse.RolledDouse( douse=Douse1(), symbol=Sym1(), ), dse.RolledDouse( douse=Douse1(), symbol=Sym1(), ), dse.RolledDouse( douse=Douse2(), symbol=Sym1(), ) ] ) ] == fractions.Fraction(4, 27), 'Proper probability calculation'
def test_add_rolled_dice_pool__dice_pools(): rolled_dice_pool_1 = dce.RolledDicePool( rolled_dice_counter=collections.Counter( [ dse.RolledDouse( douse=Douse1(), symbol=Sym1(), ), dse.RolledDouse( douse=Douse1(), symbol=Sym2(), ), ] ) ) rolled_dice_pool_2 = dce.RolledDicePool( rolled_dice_counter=collections.Counter( [ dse.RolledDouse( douse=Douse2(), symbol=Sym1(), ), dse.RolledDouse( douse=Douse1(), symbol=Sym2(), ), ] ) ) rolled_dice = rolled_dice_pool_1 + rolled_dice_pool_2 assert len(rolled_dice.rolled_dice_counter) == 3
def test_convert_surge__on_douse(): douse = att_dse.WhiteAttackDouse() assert actions.convert_all_surges_to_crit.on(douse).as_dict[ dse.RolledDouse( douse=douse, symbol=sym.Crit() ) ] == fractions.Fraction(2, 8) assert actions.convert_all_surges_to_crit.on(douse).as_dict[ dse.RolledDouse( douse=douse, symbol=sym.Surge() ) ] == fractions.Fraction(0, 8)
def test_convert_surge__on_rolled_dice_pool__no_surge(): rolled_dice_pool = dce.RolledDicePool.from_rolled_dice_list( [ dse.RolledDouse( douse=att_dse.BlackAttackDouse(), symbol=sym.Blank(), ), dse.RolledDouse( douse=att_dse.RedAttackDouse(), symbol=sym.Hit(), ), ] ) assert actions.convert_all_surges_to_crit.on(rolled_dice_pool) == rolled_dice_pool
def test_roll__douse(): douse = att_dse.BlackAttackDouse() rerolled_douse = rll.Roll(roll_policy=rll_pol.RollPolicyAttack()).on(douse) crit_prob = fractions.Fraction(1, 8) * fractions.Fraction(3, 2) assert rerolled_douse.as_dict[dse.RolledDouse(douse, sym.Crit())] == crit_prob hit_prob = fractions.Fraction(3, 8) * fractions.Fraction(3, 2) assert rerolled_douse.as_dict[dse.RolledDouse(douse, sym.Hit())] == hit_prob blank_prob = fractions.Fraction(3, 8) * fractions.Fraction(1, 2) assert rerolled_douse.as_dict[dse.RolledDouse(douse, sym.Blank())] == blank_prob
def test_count_single_rolled_douse(): rolled_douse = dse.RolledDouse( douse=Douse1(), symbol=Sym1(), ) assert CountSymbols().on(rolled_douse) == syms.Symbols.from_symbols_list( [Sym1()])
def on( self, object_: Union[st_state.StochasticState, st_object.StochasticObject, pd.ProbabilityDistribution, ], ) -> Union[sym.Symbol, syms.Symbols, dse.RolledDouse, dce.RolledDicePool, pd.ProbabilityDistribution]: if isinstance(object_, sym.Symbol): if self.conversion_policy.is_convertible(object_): self.mark_conversion() return self.conversion_target else: return object_ if isinstance(object_, syms.Symbols): symbols_sorted = sorted( object_.symbols_counter.elements(), key=self.conversion_policy.get_symbol_conversion_priority, ) symbols_converted = [] for symbol in symbols_sorted: symbol_converted = self.on( symbol) if self.can_convert else symbol symbols_converted.append(symbol_converted) return syms.Symbols.from_symbols_list(symbols_converted) if isinstance(object_, dse.RolledDouse): symbol_after = self.on(object_.symbol) if symbol_after not in object_.douse.get_sides(): raise ValueError( f'Conversion {self} cannot be applied to {object_}, because it does not have target ' f'side') if self.conversion_target not in object_.douse.get_sides(): logging.warning( f'Conversion of wrong type {self} applied to {object_}.') return dse.RolledDouse( douse=object_.douse, symbol=symbol_after, ) if isinstance(object_, dce.RolledDicePool): rolled_dice_sorted = sorted( object_.rolled_dice_counter.elements(), key=self.conversion_policy.get_douse_conversion_priority, ) rolled_dice_converted = [] for rolled_douse in rolled_dice_sorted: symbol_converted = self.on( rolled_douse) if self.can_convert else rolled_douse rolled_dice_converted.append(symbol_converted) if isinstance(object_, dce_att.RolledDicePoolAttack): return dce_att.RolledDicePoolAttack.from_rolled_dice_list( rolled_dice_list=rolled_dice_converted, n_surge_tokens=object_.n_surge_tokens, n_aim_tokens=object_.n_aim_tokens, ) else: return dce.RolledDicePool.from_rolled_dice_list( rolled_dice_converted) return super().on(object_)
def test_convert_surge__on_rolled_douse__surge__wrong_conversion(): rolled_douse = dse.RolledDouse( douse=att_dse.BlackAttackDouse(), symbol=sym.Surge(), ) with pytest.raises(ValueError): actions.convert_all_surges_to_block.on(rolled_douse)
def test_roll__rolled_dice_pool__aim__red_dice(symbols_before, symbols_after, prob): rolled_dice_pool = dce.RolledDicePool.from_rolled_dice_list([ dse.RolledDouse( douse=att_dse.RedAttackDouse(), symbol=symbol, ) for symbol in symbols_before ]) rerolled_dice_pool = dce.RolledDicePool.from_rolled_dice_list([ dse.RolledDouse( douse=att_dse.RedAttackDouse(), symbol=symbol, ) for symbol in symbols_after ]) aim = rll.Roll( roll_policy=rll_pol.RollPolicyAttack(), roll_limit=2, ) reroll_prob_dist_dict = aim.copy().on(rolled_dice_pool).as_dict assert reroll_prob_dist_dict[rerolled_dice_pool] == prob
def test_add_rolled_dice_pool__dice_pool_and_new_douse(): appended_douse = dse.RolledDouse( douse=Douse2(), symbol=Sym2(), ) rolled_dice = dce.RolledDicePool( rolled_dice_counter=collections.Counter( [ dse.RolledDouse( douse=Douse1(), symbol=Sym1(), ), dse.RolledDouse( douse=Douse1(), symbol=Sym2(), ), ] ) ) + appended_douse assert len(rolled_dice.rolled_dice_counter) == 3 assert rolled_dice.rolled_dice_counter[appended_douse] == 1
def test_count_rolled_dice(): rolled_dice_pool = dce.RolledDicePool.from_rolled_dice_list([ dse.RolledDouse( douse=Douse1(), symbol=Sym1(), ), dse.RolledDouse( douse=Douse1(), symbol=Sym2(), ), dse.RolledDouse( douse=Douse2(), symbol=Sym1(), ) ]) symbols = syms.Symbols.from_symbols_list([ Sym1(), Sym1(), Sym2(), ]) assert CountSymbols().on(rolled_dice_pool) == symbols
def test_rolled_douse__should_implement_equal(): rolled_douse_1_sym_1 = dse.RolledDouse( douse=Douse1(), symbol=Sym1(), ) rolled_douse_1_sym_2 = dse.RolledDouse( douse=Douse1(), symbol=Sym2(), ) rolled_douse_2_sym_1 = dse.RolledDouse( douse=Douse2(), symbol=Sym1(), ) rolled_douse_2_sym_2 = dse.RolledDouse( douse=Douse2(), symbol=Sym2(), ) assert rolled_douse_1_sym_1 == dse.RolledDouse( douse=Douse1(), symbol=Sym1(), ) assert rolled_douse_2_sym_2 == dse.RolledDouse( douse=Douse2(), symbol=Sym2(), ) assert rolled_douse_1_sym_1 != rolled_douse_1_sym_2 assert rolled_douse_1_sym_1 != rolled_douse_2_sym_1
def test_rolled_douse__should_implement_hash(): assert len( collections.Counter( [ dse.RolledDouse( douse=Douse1(), symbol=Sym1(), ), dse.RolledDouse( douse=Douse1(), symbol=Sym1(), ), dse.RolledDouse( douse=Douse1(), symbol=Sym2(), ), dse.RolledDouse( douse=Douse2(), symbol=Sym1(), ), ] ) ) == 3
def test_add_rolled_dice_pool__dice_pool_and_dice_pool_with_tokens(): rolled_dice_pool_1 = dce.RolledDicePool( rolled_dice_counter=collections.Counter([ dse.RolledDouse( douse=Douse1(), symbol=Sym1(), ), dse.RolledDouse( douse=Douse1(), symbol=Sym2(), ), ])) rolled_dice_pool_2 = dce_toks.RolledDicePoolWithTokens( rolled_dice_counter=collections.Counter([ dse.RolledDouse( douse=Douse2(), symbol=Sym1(), ), dse.RolledDouse( douse=Douse1(), symbol=Sym2(), ), ]), tokens=toks.Tokens.from_tokens_list([ tok.Token(), tok.Token(), ])) rolled_dice = rolled_dice_pool_1 + rolled_dice_pool_2 assert len(rolled_dice.rolled_dice_counter) == 3 assert len(rolled_dice.tokens) == 2 rolled_dice = rolled_dice_pool_2 + rolled_dice_pool_1 assert len(rolled_dice.tokens) == 2 rolled_dice = rolled_dice_pool_2 + rolled_dice_pool_2 assert len(rolled_dice.tokens) == 4
sym.Crit(), ]))) def test_convert_symbols__conversion_order__symbols(n_converts, symbols, symbols_target): conversion = conv_syms.ConvertSymbols( conversion_policy=conv_pol.ConversionPolicyAttackAnyToCrit(), conversion_limit=n_converts, ) assert conversion.on(syms.Symbols.from_symbols_list( symbols)) == syms.Symbols.from_symbols_list(symbols_target) @pytest.mark.parametrize( "conversion_policy, n_converts, rolled_dice, rolled_dice_target", ( (conv_pol.ConversionPolicyAttackAnyToCrit(), 2, [ dse.RolledDouse(att_dse.RedAttackDouse(), sym.Blank()), dse.RolledDouse(att_dse.BlackAttackDouse(), sym.Surge()), dse.RolledDouse(att_dse.WhiteAttackDouse(), sym.Hit()), ], [ dse.RolledDouse(att_dse.RedAttackDouse(), sym.Crit()), dse.RolledDouse(att_dse.BlackAttackDouse(), sym.Crit()), dse.RolledDouse(att_dse.WhiteAttackDouse(), sym.Hit()), ]), (conv_pol.ConversionPolicyAttackAnyToCrit(), 1, [ dse.RolledDouse(att_dse.RedAttackDouse(), sym.Blank()), dse.RolledDouse(att_dse.BlackAttackDouse(), sym.Surge()), dse.RolledDouse(att_dse.WhiteAttackDouse(), sym.Hit()), ], [ dse.RolledDouse(att_dse.RedAttackDouse(), sym.Crit()), dse.RolledDouse(att_dse.BlackAttackDouse(), sym.Surge()), dse.RolledDouse(att_dse.WhiteAttackDouse(), sym.Hit()),
def test_roll__rolled_douse(policy, douse_cls, symbol, target_prob_dist): rolled_douse = dse.RolledDouse( douse=douse_cls(), symbol=symbol, ) assert rll.Roll(roll_policy=policy, ).on(rolled_douse) == target_prob_dist
def test_convert_surge__on_dice_pool(): dice_pool = dce.DicePool.from_dice_list( [ att_dse.WhiteAttackDouse(), att_dse.RedAttackDouse(), att_dse.BlackAttackDouse(), ] ) result_all_surge = dce.RolledDicePool.from_rolled_dice_list( [ dse.RolledDouse( douse=att_dse.WhiteAttackDouse(), symbol=sym.Surge() ), dse.RolledDouse( douse=att_dse.BlackAttackDouse(), symbol=sym.Surge() ), dse.RolledDouse( douse=att_dse.RedAttackDouse(), symbol=sym.Surge() ), ] ) assert dice_pool.get_probability_distribution().as_dict[result_all_surge] == fractions.Fraction( numerator=1, denominator=8 ** 3, ), "No conversion sanity check." result_all_hit = dce.RolledDicePool.from_rolled_dice_list( [ dse.RolledDouse( douse=att_dse.WhiteAttackDouse(), symbol=sym.Hit() ), dse.RolledDouse( douse=att_dse.BlackAttackDouse(), symbol=sym.Hit() ), dse.RolledDouse( douse=att_dse.RedAttackDouse(), symbol=sym.Hit() ), ] ) assert dice_pool.get_probability_distribution().as_dict[result_all_hit] == fractions.Fraction( numerator=1 * 3 * 5, denominator=8 ** 3, ), "No conversion sanity check." dice_pool_converted_to_hit_prob_dist = actions.convert_all_surges_to_hit.on(dice_pool) assert dice_pool_converted_to_hit_prob_dist.as_dict[result_all_surge] == 0 assert dice_pool_converted_to_hit_prob_dist.as_dict[result_all_hit] == fractions.Fraction( numerator=2 * 4 * 6, denominator=8 ** 3, ) dice_pool_converted_to_hit_prob_dist = actions.convert_all_surges_to_crit.on(dice_pool) assert dice_pool_converted_to_hit_prob_dist.as_dict[result_all_surge] == 0 assert dice_pool_converted_to_hit_prob_dist.as_dict[result_all_hit] == fractions.Fraction( numerator=1 * 3 * 5, denominator=8 ** 3, )
def test_convert_surge__on_rolled_douse__no_surge(): rolled_douse = dse.RolledDouse( douse=att_dse.WhiteAttackDouse(), symbol=sym.Crit(), ) assert actions.convert_all_surges_to_hit.on(rolled_douse) == rolled_douse
def test_convert_surge__on_rolled_douse__surge(): rolled_douse = dse.RolledDouse( douse=att_dse.RedAttackDouse(), symbol=sym.Surge(), ) assert actions.convert_all_surges_to_crit.on(rolled_douse).symbol == sym.Crit()
import pytest from legion_dice_probs import actions from legion_dice_probs.stochastic_objects import douse as dse from legion_dice_probs.stochastic_objects import attack_douse as att_dse from legion_dice_probs.stochastic_states import symbol as sym from legion_dice_probs.stochastic_states import symbols as syms from prob_dist_api import probability_distribution as pd @pytest.mark.parametrize( "output, prob", ( ( dse.RolledDouse(douse=att_dse.BlackAttackDouse(), symbol=sym.Blank()), fractions.Fraction(3, 8) * fractions.Fraction(1, 2), # 3 / 16 ), ( dse.RolledDouse(douse=att_dse.BlackAttackDouse(), symbol=sym.Surge()), fractions.Fraction(1, 8) * fractions.Fraction(1, 2), # 1 / 16 ), ( dse.RolledDouse(douse=att_dse.BlackAttackDouse(), symbol=sym.Hit()), fractions.Fraction(3, 8) * (1 + fractions.Fraction(1, 2)), # 9 / 16 ), ( dse.RolledDouse(douse=att_dse.BlackAttackDouse(), symbol=sym.Crit()), fractions.Fraction(1, 8) * (1 + fractions.Fraction(1, 2)), # 3 / 16 ), )
rll_pol.RollPolicyAttack(), att_dse.WhiteAttackDouse, sym.Blank(), att_dse.WhiteAttackDouse().get_probability_distribution(), ), ( rll_pol.RollPolicyAttack(), att_dse.BlackAttackDouse, sym.Surge(), att_dse.BlackAttackDouse().get_probability_distribution(), ), ( rll_pol.RollPolicyAttackBlanksOnly(), att_dse.RedAttackDouse, sym.Surge(), dse.RolledDouse(att_dse.RedAttackDouse(), sym.Surge()).get_probability_distribution(), ), ( rll_pol.RollPolicyAttackCritFish(), att_dse.RedAttackDouse, sym.Hit(), att_dse.RedAttackDouse().get_probability_distribution(), ), )) def test_roll__rolled_douse(policy, douse_cls, symbol, target_prob_dist): rolled_douse = dse.RolledDouse( douse=douse_cls(), symbol=symbol, ) assert rll.Roll(roll_policy=policy, ).on(rolled_douse) == target_prob_dist