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
