Skip to content

Instantly share code, notes, and snippets.

@cbsmith cbsmith/
Last active Sep 11, 2016

What would you like to do?
"""Shadow run attack simulator.
Usage: [--debug] [--limit LIMIT | -6 | --rule_of_six] [--threshold THRESHOLD | --opposed_pool OPPOSED [--opposed_limit OPPOSED_LIMIT]] [--dv DV --stun [--soak SOAK] [--armor ARMOR [--ap AP]]] [--contact] [--once | -o | [--iterations ITERATIONS] [-D | --distribution]] [--multi ATTACKS] [--min DAMAGE] ATTACK_POOL [--debug] [--contact] [-6 | --rule_of_six] --threshold THRESHOLD ATTACK_STRING DAMAGE_STRING SOAK_STRING [--debug] [--contact] [-D | --distribution] [-6 | --rule_of_six] --threshold THRESHOLD ATTACK_STRING DAMAGE_STRING SOAK_STRING ITERATIONS [--debug] [--contact] [-6 | --rule_of_six] ATTACK_STRING DAMAGE_STRING DEFENSE_STRING SOAK_STRING [--debug] [--contact] [-D | --distribution] [-6 | --rule_of_six] ATTACK_STRING DAMAGE_STRING DEFENSE_STRING SOAK_STRING ITERATIONS (-h | --help) (-v | --version)
-6 --rule_of_six rule of six applies
--limit LIMIT attack dice limit
--threshold THRESHOLD threshold for test
--opposed_pool OPPOSED opposed dice pool
--opposed_limit OPPOSED_LIMIT opposed dice limit
--dv DV the damage value of the attack
--soak SOAK defense base soak dice (does not include armor)
--armor ARMOR armor dice
--ap AP armor piercing [default: 0]
--stun dv is stun damage, not physical
--contact if this is a contact only attack [default: False]
--multi ATTACKS split attack over ATTACKS [default: 1]
-o --once simulate a single action only
-D --distribution print the distribution of attacks
--iterations ITERATIONS total iterations to run through [default: 10000]
-h --help show this
-v --version print version
--debug turn on debug printing
--min DAMAGE minimum_damage goal
ATTACK_STRING format is 18[7] meaning 18 dice in the pool, with a limit of 7
DAMAGE_STRING format is 7Pv-4 meaning 7 physical damage, with -4 AP
DEFENSE_STRING format is same as ATTACK_STRING... without a limit it'd just be 18
SOAK_STRING format is 12v3 meaning 12 armor, 3 soak dice or just v3 for the case where there is no armor involved
from functools import total_ordering
from itertools import groupby, chain
import re
from numbers import Number
from sys import argv, stderr, stdout
from warnings import warn
from docopt import docopt
import random
sys_random = random.SystemRandom()
choice, randint = sys_random.choice, sys_random.randint
warn('Could not use SystemRandom; using default random instead', RuntimeWarning)
from random import choice, randint
class InputError(Exception):
"""Exception raised for errors in input
expr -- input expression in which the error occurred
msg -- explanation of the error
def __init__(self, expr, mesg):
self.expr = expr
self.msg = mesg
class Outcome(object):
'Represents the outcome of one or more attacks'
__slots__ = ('hits', 'phys', 'stun', 'misses')
'misses': 'miss',
'hits': 'hit',
'phys': 'phys',
'stun': 'stun'
def __init__(self, misses=0, hits=None, phys=0, stun=0, copy=None):
if copy is None:
assert isinstance(misses, int) and isinstance(phys, int) and isinstance(stun, int)
self.misses = misses
self.phys = phys
self.stun = stun
# if hits is None, set it to an implied value based on damage
if hits is None:
self.hits = 1 if (self.phys > 0 or self.stun > 0) else 0
self.hits = hits
assert isinstance(self.hits, int)
assert misses == 0 and hits is None and phys == 0 and stun == 0
assert isinstance(copy, Outcome)
self.misses = copy.misses
self.hits = copy.hits
self.phys = copy.phys
self.stun = copy.stun
def __iadd__(self, other):
self.misses += other.misses
self.hits += other.hits
self.phys += other.phys
self.stun += other.stun
return self
def __isub__(self, other):
self.misses -= other.misses
self.hits -= other.hits
self.phys -= other.phys
self.stun -= other.stun
return self
def __imul__(self, other):
assert isinstance(other, Number)
self.misses *= other
self.hits *= other
self.phys *= other
self.stun *= other
return self
def __itruediv__(self, other):
assert isinstance(other, Number)
self.misses /= other
self.hits /= other
self.phys /= other
self.stun /= other
return self
def __add__(self, other):
return Outcome(copy=self).__iadd__(other)
def __sub__(self, other):
return Outcome(copy=self).__isub__(other)
def __mul__(self, other):
return Outcome(copy=self).__imul__(other)
def __truediv__(self, other):
return Outcome(copy=self).__itruediv__(other)
def __radd__(self, other):
assert other == 0
return Outcome(copy=self)
def __rsub__(self, other):
assert other == 0
return Outcome() - Outcome(copy=self)
def __rmul__(self, other):
return self.__mul__(other)
def __rtruediv__(self, other):
return self.__truediv__(other)
def singular(attribute):
return Outcome.SINGULAR.get(attribute, attribute)
def __str__(self):
if self.hits > 0 and self.stun == 0 and self.phys == 0:
return '{:>5} {:>4}, no damage'.format(self.hits, 'hit' if self.hits == 1 else 'hits')
answer = ', '.join('{:>5} {:>8}'.format(*x) for x in ((getattr(self, attr), (self.singular(attr) if getattr(self, attr) == 1 else attr)) for attr in self.__slots__) if x[1] == 'miss' or x[0] > 0)
return '{:22}'.format(answer)
def __repr__(self):
return 'Outcome({}, {}, {}, {})'.format(self.misses, self.hits, self.phys, self.stun)
def __lt__(self, other):
if self.phys < other.phys:
return True
if self.phys == other.phys:
if self.stun < other.stun:
return True
if self.stun == other.stun:
if self.hits < other.hits:
return True
if self.hits == other.hits:
return self.misses > other.misses # more misses means overall you did worse
return False
def __eq__(self, other):
return self.misses == other.misses and self.hits == other.hits and self.phys == other.phys and self.stun == other.stun
class Pool(object):
OUTCOMES = (False, False, True) # we could do False, False, False, False, True, True... but that is needlessly inefficient
def __init__(self, dice, limit=None, rule_of_six=False):
if rule_of_six:
assert limit is None
self.dice = int(dice)
self.limit = int(limit) if limit else None
self.rule_of_six = rule_of_six
def hit(self):
return choice(self.OUTCOMES)
def hit_generator(self):
if self.rule_of_six:
dice = self.dice
while dice > 0:
roll = randint(1, 6)
yield roll > 4
if roll != 6:
dice -= 1
for _ in range(self.dice):
yield self.hit()
def hits(self):
hits = sum(1 for hit in self.hit_generator() if hit)
return hits if self.limit is None else min(hits, self.limit)
def split(self, parts=1):
base = self.dice // parts
more_than_base = (base + 1 for _ in range(self.dice % parts))
rest = (base for _ in range(parts - (self.dice % parts)))
return (Pool(dice, self.limit, self.rule_of_six) for dice in chain(more_than_base, rest))
def __str__(self):
return '{}[{}]'.format(self.dice, self.limit) if self.limit else '{}{}'.format(self.dice, '*' if self.rule_of_six else '')
def __repr__(self):
return 'Pool(dice={}, limit={}, rule_of_six={})'.format(self.dice, self.limit, self.rule_of_six)
class FixedThreshold(object):
def __init__(self, threshold):
self.threshold = int(threshold)
def hits(self):
return self.threshold
def __str__(self):
return '({})'.format(self.threshold)
def __repr__(self):
return 'FixedThreshold({})'.format(self.threshold)
class Test(object):
def __init__(self, pool, threshold=None):
self.pool = pool
self.threshold = threshold
def test(self):
hits = self.pool.hits()
return hits if self.threshold is None else hits - self.threshold.hits()
def net_hits(self):
return max(0, self.test())
def __str__(self):
return '{} vs {}'.format(self.pool, self.threshold)
def __repr__(self):
return 'Test(pool={}, threshold={})'.format(repr(self.pool), repr(self.threshold))
class Attack(object):
def __init__(self, test, dv=None, ap=0, stun=False, soak=None, armor=None, contact=False):
self.test = test
self.dv = int(dv) if dv else None
self.stun = stun
self.soak = int(soak) if soak else None
self.armor = int(armor) if armor else None
self.ap = int(ap) if ap else 0 = contact
def damage(self):
hits = self.test.net_hits()
if (hits < 0) or (hits == 0 and not
return Outcome(misses=1)
# if dv is not set, then we're just counting hits vs. not hits
if self.dv is None:
return Outcome(hits=1)
modified_dv = self.dv + hits
if self.soak is None:
return Outcome(stun=modified_dv) if self.stun else Outcome(phys=modified_dv)
stun = self.stun
soak = self.soak
if self.armor is not None:
armor_value = self.armor + self.ap
if armor_value > 0:
if armor_value >= modified_dv:
stun = True
soak += armor_value
soak_pool = Pool(soak)
damage = max(0, modified_dv - soak_pool.hits())
return Outcome(hits=1, stun=damage) if stun else Outcome(hits=1, phys=damage)
def __str__(self):
ap_val = self.ap if self.ap < 0 else ('+' + self.ap if self.ap > 0 else '')
base = '{}{} {}{}{}'.format(self.test,
' contact' if else '',
'S' if self.stun else 'P',
return base + 'soak: {}v{}'.format(self.armor, self.soak) if self.armor or self.soak else base
def __repr__(self):
return 'Attack(test={}, dv={}, ap={}, stun={}, soak={}, armor={}, contact={})'.format(repr(self.test), repr(self.dv), repr(self.ap), repr(self.stun), repr(self.soak), repr(self.armor), repr(
class Simulation(object):
def __init__(self, attacks, iterations=10000, debug=False):
self.attacks = tuple(attacks)
if debug:
stderr.write('Performing {} iterations of [{}]\n'.format(iterations, ', '.join(map(str, self.attacks))))
self.iterations = int(iterations) if iterations else 10000
self.outcome = None
def results(self):
for _ in range(self.iterations):
d = sum(attack.damage() for attack in self.attacks)
assert d.misses != 0 or d.hits != 0
yield d
def distribution(self):
pred = lambda x: (x.phys, x.stun)
results = sorted(self.results(), reverse=True)
for damage, g in groupby(results):
total = sum(1 for _ in g)
yield damage, total
if self.outcome is None:
self.outcome = damage * total
self.outcome += damage * total
def mean(self):
return self.outcome * 1.0 / self.iterations
ATTACK_RE = re.compile(r'^(\d+)(?:\[(\d+)\])?$')
DAMAGE_RE = re.compile(r'^(\d+)(P|S)(?:v((?:\+|-)\d+))?$')
SOAK_RE = re.compile(r'^(\d+)?v(\d+)$')
def get_attack_pool(args):
if args['ATTACK_POOL']:
return Pool(args['ATTACK_POOL'], args['--limit'], args['--rule_of_six'])
elif args['ATTACK_STRING']:
matcher = ATTACK_RE.match(args['ATTACK_STRING'])
if matcher is None:
raise InputError(args['ATTACK_STRING'], 'Invalid Attack String')
limit =
return Pool(, limit or None, args['--rule_of_six'])
raise InputError(' '.join(args), 'No attacker parameters found')
def get_threshold(args):
if args['--threshold']:
return FixedThreshold(args['--threshold'])
if args['--opposed_pool']:
return Pool(args['--opposed_pool'], args['--opposed_limit'])
if args['DEFENSE_STRING']:
matches = DEFENSE_RE.match(args['DEFENSE_STRING'])
if matches is None:
raise InputError(args['DEFENSE_STRING'], 'Invalid Defense String')
limit =
return Pool(, limit or None)
return None
def parse_ap_string(ap_string):
if ap_string[0] == '+':
return int(ap_string[1:])
return -int((ap_string[1:] if ap_string[0] == '-' else ap_string))
def get_tests(args):
attack_pool = get_attack_pool(args)
threshold = get_threshold(args)
multi_attacks = int(args['--multi']) if args['--multi'] else 1
if args['--debug']:
stderr.write('Splitting in to {} attacks\n'.format(multi_attacks))
return (Test(pool, threshold) for pool in attack_pool.split(multi_attacks))
def get_attacks(tests, args):
attack_args = {}
if args['DAMAGE_STRING'] and args['SOAK_STRING']:
matches = DAMAGE_RE.match(args['DAMAGE_STRING'])
if matches is None:
raise InputError(args['DAMAGE_STRING'], 'Invalid Damage String')
assert in ('S', 'P')
attack_args['stun'] = == 'S'
ap_string =
attack_args['ap'] = None if ap_string is None else parse_ap_string(ap_string)
attack_args['dv'] = int(
matches = SOAK_RE.match(args['SOAK_STRING'])
if matches is None:
raise InputError(args['SOAK_STRING'], 'Invalid Soak String')
attack_args['armor'] = None if is None else int(
attack_args['soak'] = int(
attack_args['dv'] = args['--dv']
attack_args['ap'] = parse_ap_string(args['--ap'])
attack_args['stun'] = args['--stun']
attack_args['soak'] = args['--soak']
attack_args['armor'] = args['--armor']
attack_args['contact'] = args['--contact']
for test in tests:
yield Attack(test, **attack_args)
def main(**args):
if args['--debug']:
stderr.write('Args: {}\n'.format(args))
tests = get_tests(args)
attacks = get_attacks(tests, args)
if args['--once']:
for attack in attacks:
simulation = Simulation(attacks, args['--iterations'] or args['ITERATIONS'], args['--debug'])
distribution = simulation.distribution()
min_damage = args['--min']
if min_damage:
min_damage = int(min_damage)
min_outcomes = 0
for outcome, total in distribution:
if min_damage and outcome.phys >= min_damage:
min_outcomes += total
if args['--distribution']:
print('{} for {} or {:>5.2f}%'.format(outcome, total, total * 100.0 / simulation.iterations))
if min_damage:
print('{:>5.2f}% above {}P'.format(min_outcomes * 100.0 / simulation.iterations, min_damage))
print('mean: {}'.format(simulation.mean()))
if __name__ == '__main__':
arguments = docopt(__doc__, version='Rolls 0.0')
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.