639 lines
18 KiB
Python
639 lines
18 KiB
Python
# battle.py
|
|
#
|
|
# A set of classes and convenience functions
|
|
# for representing a D&D 4e battle
|
|
#
|
|
# future features:
|
|
# * down combatants go into a separate list
|
|
|
|
from dice import Dice
|
|
import easyinput
|
|
|
|
# data about the battle - includes combatant list, etc
|
|
class Battle():
|
|
def __init__(self):
|
|
self.combatant_hash = {}
|
|
self.groups = []
|
|
self.wait_list = {}
|
|
self.current = None
|
|
self.round = None
|
|
|
|
|
|
def __str__(self):
|
|
ret = ''
|
|
if self.is_started():
|
|
ret = 'Battle underway, currently on round {}\n\n'.format(self.round)
|
|
else:
|
|
ret = 'Battle not yet started\n\n'
|
|
|
|
ret = ret + self.format_combatants()
|
|
|
|
return ret
|
|
|
|
|
|
def is_started(self):
|
|
return self.current != None
|
|
|
|
|
|
def add_group(self, group):
|
|
# If battle is already going, need to know
|
|
# where in the init order the new mooks go
|
|
if self.is_started():
|
|
if group.is_solo_group() and group.members[0].pc:
|
|
group.set_init(easyinput.input_int('Initiative for {}'.format(group.name)))
|
|
else:
|
|
group.roll_init()
|
|
|
|
added = False
|
|
for i in range(len(self.groups)):
|
|
if group.init > self.groups[i].init:
|
|
self.groups.insert(i, group)
|
|
added = True
|
|
break
|
|
|
|
if not added:
|
|
self.groups.append(group)
|
|
else:
|
|
self.groups.append(group)
|
|
|
|
for i, c in group.members.items():
|
|
self.combatant_hash[i] = c
|
|
|
|
|
|
def get_current_group(self):
|
|
if self.current != None:
|
|
return self.groups[self.current]
|
|
else:
|
|
return None
|
|
|
|
|
|
# If you're in a multi-member group, the first
|
|
# member of the group gets returned.
|
|
def get_current_combatant(self):
|
|
if self.current != None:
|
|
return self.groups[self.current].get_member_by_pos(0)
|
|
else:
|
|
return None
|
|
|
|
|
|
def get_combatant(self, index):
|
|
if index in self.combatant_hash:
|
|
return self.combatant_hash[index]
|
|
else:
|
|
return None
|
|
|
|
|
|
def choose_combatant(self):
|
|
print self.format_combatants()
|
|
index = easyinput.input_int('choose combatant')
|
|
if index not in self.combatant_hash:
|
|
print 'Error: {} is not a valid index'.format(index)
|
|
return self.choose_combatant()
|
|
return self.combatant_hash[index]
|
|
|
|
|
|
def begin(self):
|
|
if self.is_started():
|
|
print "Error: battle is already running"
|
|
|
|
for g in self.groups:
|
|
if g.is_solo_group() and g.get_member_by_pos(0).pc:
|
|
g.set_init(easyinput.input_int('Initiative for {}'.format(g.name)))
|
|
else:
|
|
g.roll_init()
|
|
|
|
self.groups.sort(reverse=True, key=lambda group: group.init)
|
|
self.current = 0
|
|
|
|
print '\nInitiative Roster:\n'
|
|
for g in self.groups:
|
|
print '{} ({})'.format(g.name, g.init)
|
|
print ''
|
|
|
|
self.next_round()
|
|
self.get_current_group().begin_turn()
|
|
|
|
|
|
# Returns a formatted string with all of the combatants
|
|
def format_combatants(self):
|
|
ret = 'Combatants\n==========\n'
|
|
|
|
for g in self.groups:
|
|
if g.is_solo_group():
|
|
ret = ret + '{}\n'.format(g.get_member_by_pos(0))
|
|
else:
|
|
ret = ret + '{}:\n'.format(g.name)
|
|
for c in g.members.values():
|
|
ret = ret + ' {}\n'.format(c)
|
|
|
|
if self.wait_list:
|
|
ret = ret + '\nWait List\n=========\n'
|
|
for c in self.wait_list.values():
|
|
ret = ret + '{}\n'.format(c)
|
|
|
|
return ret.rstrip()
|
|
|
|
|
|
# Returns a formatted string with just the current group
|
|
def format_current_group(self):
|
|
if self.validate_started():
|
|
return self.validate_started()
|
|
|
|
g = self.groups[self.current]
|
|
if g.is_solo_group():
|
|
return '{}'.format(g.members[0].format_full_info())
|
|
else:
|
|
ret = '{}\n'.format(g.name)
|
|
for c in g.members.values():
|
|
ret = ret + ' {}\n'.format(c)
|
|
return ret.rstrip()
|
|
|
|
|
|
# Fixme - if someone is waited/unwaited, both them and the person
|
|
# after them may have begin_turn() and/or end_turn() called more than once
|
|
def next_combatant(self, same_index = False):
|
|
if self.validate_started():
|
|
print self.validate_started()
|
|
return
|
|
|
|
g = self.get_current_group()
|
|
g.end_turn()
|
|
|
|
if not same_index:
|
|
self.current += 1
|
|
|
|
if self.current >= len(self.groups):
|
|
self.current = 0
|
|
self.next_round()
|
|
|
|
g = self.get_current_group()
|
|
g.begin_turn()
|
|
|
|
|
|
def next_round(self):
|
|
if self.round == None:
|
|
self.round = 1
|
|
else:
|
|
self.round += 1
|
|
|
|
# Decrement all timed conditions
|
|
for c in self.combatant_hash.values():
|
|
c.tick_conditions()
|
|
|
|
print 'Beginning round {}.'.format(self.round)
|
|
|
|
|
|
def validate_started(self):
|
|
if not self.is_started():
|
|
return 'Error: you can only run this command after starting the battle.'
|
|
return None
|
|
|
|
|
|
def wait(self, index):
|
|
v = self.validate_started()
|
|
if v:
|
|
print v
|
|
return
|
|
|
|
if index in self.wait_list:
|
|
print '{} is already waiting.'.format(self.wait_list[index])
|
|
else:
|
|
c = None
|
|
i = 0
|
|
for group in self.groups:
|
|
c = group.remove_member(index)
|
|
if c:
|
|
if len(group.members) == 0:
|
|
del self.groups[i]
|
|
break
|
|
i += 1
|
|
|
|
if c:
|
|
self.wait_list[index] = c
|
|
print '{} is now in the wait list.'.format(c)
|
|
self.next_combatant(same_index = True)
|
|
else:
|
|
print 'Error: Failed to find combatant {}.'.format(index)
|
|
|
|
|
|
def unwait(self, index):
|
|
v = self.validate_started()
|
|
if v:
|
|
print v
|
|
return
|
|
|
|
if index in self.wait_list:
|
|
c = self.wait_list[index]
|
|
del self.wait_list[index]
|
|
self.groups.insert(self.current, CombatGroup(c.name, {c.index: c}, 0))
|
|
print '{} is no longer waiting.'.format(c)
|
|
self.next_combatant(same_index = True)
|
|
else:
|
|
if index in self.combatant_hash:
|
|
print '{} is not waiting'.format(self.combatant_hash[index])
|
|
else:
|
|
print "Error: Failed to find combatant {}".format(index)
|
|
|
|
|
|
|
|
class CombatGroup():
|
|
# What we're mostly getting here is a definition of the *members*
|
|
# of the group... then we build them all and stick them in
|
|
# the group
|
|
@classmethod
|
|
def from_input(cls):
|
|
name = easyinput.input_str("name")
|
|
hp = easyinput.input_int('hp')
|
|
init_mod = easyinput.input_int('init mod', 0)
|
|
ap = easyinput.input_int('action points', 0)
|
|
surges = easyinput.input_int('healing surges', 0)
|
|
|
|
recharges = []
|
|
while True:
|
|
data = []
|
|
data = easyinput.input_str("recharge", default='').split(',')
|
|
if len(data) == 2:
|
|
recharge = {}
|
|
recharge['name'] = data[0]
|
|
recharge['value'] = int(data[1])
|
|
recharge['used'] = False
|
|
recharges.append(recharge)
|
|
else:
|
|
break
|
|
|
|
count = easyinput.input_int('count', 1)
|
|
|
|
# Now make the combatants...
|
|
members = {}
|
|
for i in range(count):
|
|
c = Combatant(name, hp, pc=False, surges=surges, ap=ap, sw=0, recharges=recharges)
|
|
members[c.index] = c
|
|
|
|
if count > 1:
|
|
name = name + 's'
|
|
|
|
return CombatGroup(name, members, init_mod)
|
|
|
|
|
|
def __init__(self, name, members, init_mod=0):
|
|
self.name = name
|
|
self.members = members
|
|
self.init_mod = init_mod
|
|
self.init = 0
|
|
|
|
|
|
def roll_init(self):
|
|
d = Dice.from_str('1d20+{}'.format(self.init_mod))
|
|
self.set_init(d.roll()['total'])
|
|
|
|
|
|
def set_init(self, init):
|
|
self.init = init
|
|
|
|
|
|
def add_member(self, c):
|
|
self.members[c.index] = c
|
|
|
|
|
|
# Removes the member from the group and returns her
|
|
def remove_member(self, index):
|
|
if index not in self.members:
|
|
return None
|
|
|
|
c = self.members[index]
|
|
del self.members[index]
|
|
return c
|
|
|
|
|
|
def get_member(self, index):
|
|
if index in self.members:
|
|
return self.members[index]
|
|
else:
|
|
return None
|
|
|
|
|
|
def get_member_by_pos(self, pos):
|
|
if pos >= len(self.members):
|
|
return None
|
|
else:
|
|
return self.members.values()[pos]
|
|
|
|
|
|
def is_solo_group(self):
|
|
return len(self.members) == 1
|
|
|
|
|
|
def begin_turn(self):
|
|
print '{} {} initiative.'.format(self.name, ['has', 'have'][len(self.members) != 1])
|
|
|
|
for c in self.members.values():
|
|
c.begin_turn()
|
|
|
|
|
|
def end_turn(self):
|
|
for c in self.members.values():
|
|
c.end_turn()
|
|
|
|
|
|
|
|
class Combatant():
|
|
next_index = 0
|
|
|
|
def __init__(self, name, hp, pc=False, init_mod=0, surges=0, ap=0, sw=0, recharges=[]):
|
|
self.name = name
|
|
self.max_hp = hp
|
|
self.hp = self.max_hp
|
|
self.temp_hp = 0
|
|
self.pc = pc
|
|
self.surges = surges
|
|
self.ap = ap
|
|
self.sw = sw
|
|
self.conditions = {}
|
|
self.index = Combatant.next_index
|
|
self.next_condition_index = 0
|
|
Combatant.next_index += 1
|
|
|
|
self.recharges = {}
|
|
recharge_index = 0
|
|
for r in recharges:
|
|
r['index'] = recharge_index
|
|
r['just_used'] = False
|
|
self.recharges[recharge_index] = r
|
|
recharge_index += 1
|
|
|
|
|
|
def __str__(self):
|
|
return "{}: {} ({})".format(self.index, self.name, self.format_health_summary())
|
|
|
|
|
|
# cond_type can be 's' or 't', for 'save' or 'timed'. If it is 't', condition expires at the end of the players turn
|
|
# 'duration' rounds from now
|
|
def add_condition(self, name, cond_type, duration=None, end_type='e'):
|
|
condition = {}
|
|
condition['name'] = name
|
|
condition['cond_type'] = cond_type
|
|
condition['duration'] = duration
|
|
condition['end_type'] = end_type
|
|
condition['index'] = self.next_condition_index
|
|
if cond_type == 'timed' and duration == None:
|
|
print 'Error: specified a timed condition with no duration.'
|
|
return
|
|
self.conditions[self.next_condition_index] = condition
|
|
self.next_condition_index += 1
|
|
|
|
|
|
# Removes a condition, prints a message about it, and returns a copy of the condition
|
|
def remove_condition(self, index):
|
|
if index not in self.conditions:
|
|
print "Error: invalid condition index."
|
|
return None
|
|
|
|
c = self.conditions.pop(index)
|
|
print '{} is no longer affected by {}.'.format(self, c['name'])
|
|
|
|
return c
|
|
|
|
|
|
def choose_condition(self):
|
|
if not len(self.conditions):
|
|
print '{} has no conditions.'.format(self)
|
|
return None
|
|
|
|
print self.format_condition_summary()
|
|
index = easyinput.input_int('choice')
|
|
|
|
if index not in self.conditions:
|
|
print 'Error: {} is not a valid index'.format(index)
|
|
return self.choose_condition()
|
|
|
|
return self.conditions[index]
|
|
|
|
|
|
def tick_conditions(self):
|
|
for c in self.conditions.values():
|
|
if c['cond_type'] == 't':
|
|
c['duration'] -= 1
|
|
|
|
|
|
def begin_turn(self):
|
|
for c in self.conditions.values():
|
|
if c['cond_type'] == 't' and c['end_type'] == 's':
|
|
if c['duration'] <= 0:
|
|
self.remove_condition(c['index'])
|
|
else:
|
|
print '{} is still affected by {} ({} round{} left).'.format(self, c['name'], c['duration'], 's'[c['duration']==1:])
|
|
|
|
|
|
def end_turn(self):
|
|
for c in self.conditions.values():
|
|
if c['cond_type'] == 's':
|
|
r = None
|
|
if self.pc:
|
|
print '{}: save against {}.'.format(self, c['name'])
|
|
r = easyinput.input_int('saving throw')
|
|
else:
|
|
save_die = Dice.from_str('1d20')
|
|
r = save_die.roll()['total']
|
|
|
|
if r >= 10:
|
|
self.remove_condition(c['index'])
|
|
print '{} successfully saved against {}.'.format(self, c['name'])
|
|
else:
|
|
print '{} failed a save against {}.'.format(self, c['name'])
|
|
|
|
elif c['cond_type'] == 't' and c['end_type'] == 'e':
|
|
if c['duration'] <= 0:
|
|
self.remove_condition(c['index'])
|
|
else:
|
|
print '{} is still affected by {} ({} round{} left).'.format(self, c['name'], c['duration'], 's'[c['duration']==1:])
|
|
|
|
for r in self.recharges.values():
|
|
if r['used']:
|
|
if r['just_used']:
|
|
r['just_used'] = False
|
|
continue
|
|
|
|
# Roll to recharge
|
|
d = Dice.from_str('1d6')
|
|
n = d.roll()['total']
|
|
if n >= r['value']:
|
|
r['used'] = False
|
|
print '{} can use {} again!'.format(self, r['name'])
|
|
|
|
|
|
def damage(self, amount):
|
|
was_bloodied = self.is_bloodied()
|
|
|
|
if self.temp_hp > 0:
|
|
self.temp_hp -= amount
|
|
if self.temp_hp < 0:
|
|
amount = abs(self.temp_hp)
|
|
self.temp_hp = 0
|
|
|
|
self.hp -= amount
|
|
|
|
print '{} took {} points of damage.'.format(self, amount)
|
|
|
|
if self.is_down():
|
|
print '{} is down!'.format(self)
|
|
elif self.is_bloodied() and not was_bloodied:
|
|
print '{} is bloodied!'.format(self)
|
|
|
|
|
|
def heal(self, amount):
|
|
was_down = self.is_down()
|
|
was_bloodied = self.is_bloodied()
|
|
|
|
if self.hp < 0:
|
|
self.hp = 0
|
|
|
|
amount_healed = amount
|
|
if self.hp + amount_healed > self.max_hp:
|
|
amount_healed = self.max_hp - self.hp
|
|
|
|
self.hp += amount_healed
|
|
|
|
if was_down:
|
|
print '{} regains consciousness.'.format(self)
|
|
|
|
print '{} regained {} hit points.'.format(self, amount_healed)
|
|
|
|
if was_bloodied and not self.is_bloodied():
|
|
print '{} is no longer bloodied.'.format(self)
|
|
elif was_bloodied and self.is_bloodied():
|
|
print '{} is still bloodied.'.format(self)
|
|
|
|
|
|
def add_temp_hp(self, amount):
|
|
self.temp_hp += amount
|
|
|
|
print '{} gained {} temporary hit points.'.format(self, amount)
|
|
|
|
|
|
def use_surge(self, heal=True):
|
|
if self.surges <= 0:
|
|
print '{} has no healing surges.'.format(self)
|
|
return
|
|
|
|
self.surges -= 1
|
|
noheal = ''
|
|
if not heal:
|
|
noheal = " (but didn't regain hit points)"
|
|
print '{} spent a healing surge{}.'.format(self, noheal)
|
|
|
|
if heal:
|
|
self.heal(self.max_hp / 4)
|
|
|
|
|
|
def use_second_wind(self):
|
|
if self.sw <= 0:
|
|
print "{} doesn't have a second wind.".format(self)
|
|
return
|
|
|
|
self.surges -= 1
|
|
|
|
print '{} got their second wind!'.format(self)
|
|
|
|
# Now the actual effects of the SW
|
|
self.use_surge()
|
|
self.add_condition('Second Wind (+2 all def)', 't', 1)
|
|
|
|
|
|
def use_recharge_power(self, index):
|
|
if index not in self.recharges:
|
|
print "Error: Invalid recharge index"
|
|
return
|
|
|
|
self.recharges[index]['used'] = True
|
|
self.recharges[index]['just_used'] = True
|
|
|
|
|
|
def choose_recharge_power(self):
|
|
if not len(self.recharges):
|
|
print '{} has no rechargable powers.'.format(self)
|
|
return None
|
|
|
|
print self.format_recharge_summary()
|
|
index = easyinput.input_int('choice')
|
|
|
|
if index not in self.recharges:
|
|
print 'Error: {} is not a valid index'.format(index)
|
|
return self.choose_recharge_power()
|
|
|
|
return self.recharges[index]
|
|
|
|
|
|
def is_bloodied(self):
|
|
return self.hp <= self.max_hp / 2
|
|
|
|
|
|
def is_down(self):
|
|
return self.hp <= 0
|
|
|
|
|
|
def format_full_info(self):
|
|
return """{name}
|
|
{separator}
|
|
index: {index}
|
|
hp: {hp}/{max_hp}
|
|
temp hp: {temp_hp}
|
|
surges: {surge}
|
|
ap: {ap}
|
|
sw: {sw}
|
|
conditions:
|
|
{conditions}
|
|
recharge powers:
|
|
{recharge}""".format(index=self.index, name=self.name, hp=self.hp, max_hp=self.max_hp, temp_hp=self.temp_hp, surge=self.surges, ap=self.ap, sw=self.sw, conditions=self.format_condition_summary(' '), recharge=self.format_recharge_summary(' '), separator='='*len(self.name))
|
|
|
|
|
|
def format_health_summary(self):
|
|
bloodied = ''
|
|
temp_info = ''
|
|
if self.is_bloodied():
|
|
bloodied = ', bloodied'
|
|
if len(self.conditions):
|
|
bloodied = bloodied + ', '
|
|
|
|
if self.temp_hp > 0:
|
|
temp_info = ', {} temp hp'.format(self.temp_hp)
|
|
|
|
return '{} hp{}{}{}'.format(self.hp, temp_info, bloodied, ', '.join([x['name'] for x in self.conditions.values()]))
|
|
|
|
|
|
def format_condition_summary(self, initial=''):
|
|
summary = ''
|
|
for (index, c) in self.conditions.items():
|
|
type_string = ''
|
|
if c['cond_type'] == 's':
|
|
type_string = 'Save Ends'
|
|
elif c['cond_type'] == 't':
|
|
type_string = '{} Round{}'.format(c['duration'], 's'[ c['duration']==1: ] )
|
|
summary = summary + '{}{}: {} ({})\n'.format(initial, index, c['name'], type_string)
|
|
|
|
return summary.rstrip()
|
|
|
|
def format_recharge_summary(self, initial):
|
|
summary = ''
|
|
for (index, r) in self.recharges.items():
|
|
summary = summary + '{}{}: {} (Recharge: {}, Available: {})\n'.format(initial, index, r['name'], r['value'], ['Yes', 'No'][ r['used'] ])
|
|
return summary.rstrip()
|
|
|
|
|
|
|
|
|
|
# Data parsing helper function
|
|
# Modelled on the data_input functions in easyinput
|
|
def do_combatant_select(battle, data):
|
|
c = None
|
|
|
|
if len(data) >= 1:
|
|
c = battle.get_combatant(int(data[0]))
|
|
if not c:
|
|
print 'Error: Invalid combatant index.'
|
|
else:
|
|
c = battle.get_current_combatant()
|
|
if not c:
|
|
print 'Error: Battle not started and no combatant specified.'
|
|
|
|
return c
|