def unit_leave_battle(battle, context, bv, narrator):
ctarget = context.ctarget
army = ctarget.army
if random.random() < 0.5: # capture chance
state = 'CAPTURED'
Event(battle, "unit_captured", context).activate()
else:
state = 'ESCAPED'
Event(battle, "unit_escaped", context).activate()
ctarget.leave_battle(state)
if not army.is_present():
Event(battle, "army_leave_battle", context={
'ctarget_army': army
}).activate()
else:
# compute morale change from leaving battle
if ctarget.is_commander():
damage = army.morale
else:
damage = 2
Event(
battle, "change_morale",
contexts.Context({
"ctarget_army": army,
"morale_change": -damage
})).activate()
Event(
battle, "change_morale",
contexts.Context({
"ctarget_army": army.other_army(),
"morale_change": damage
})).activate()
def activate(self, *args):
# death handler (should later be "availability" for retreats, etc.)
# most events require actors who are alive; TODO: exceptions?
if any([
not self.context.opt[foo].is_present()
for foo in ACTORS_DICT[self.get_actor_type()]
]): #pylint:disable=blacklisted-name
# TODO: exceptions for things like unit_destroyed or army_destroyed
return
# panic handler
if event_info(self.event_name, "panic_blocked"):
potential_panicker = getattr(
self.context, PRIMARY_ACTOR_DICT[self.get_actor_type()])
if potential_panicker.has_unit_status("panicked"):
Event(self.battle, "activate_status",
contexts.Context({'ctarget': potential_panicker
})).activate('panicked')
return
# narrator handler
# if self.battle.imaginary and self.battle.battlescreen.show_AI: # stupid hack
# testlogger.debug(self.event_name)
# else:
self.battle.narrator.notify(self, *args)
# time to activate this event on the queue; note the event has its own context, battle, etc.
if self.event_func:
self.event_func(self.battle, self.context,
self.battle.battlescreen, self.battle.narrator,
*args)
def duel_accepted(battle, context, bv, narrator):
duelists = [context.csource, context.ctarget]
ourduel = duel.Duel(context, bv, narrator, duelists)
# the Duel also gets the renderer and thus
healths = ourduel.resolve()
# it's not always true there is a winner
has_winner = False
if healths[0] > 0 >= healths[1]:
has_winner = True
winner = context.csource
loser = context.ctarget
elif healths[0] <= 0 < healths[1]:
has_winner = True
winner = context.ctarget
loser = context.csource
newcontext = {"csource": winner, "ctarget": loser}
if has_winner:
Event(battle, "duel_defeated", newcontext).activate()
x = [0, 1]
# this shuffle is important; in the case of a double-ko of e.g. commanders, we do not want to
# favor the first player collapsing first
random.shuffle(x)
for i in x:
if healths[i] <= 0:
Event(
battle, "receive_damage",
contexts.Context({
"damage": duelists[i].size,
"csource": duelists[1 - i],
"ctarget": duelists[i],
"dmgtype": "lost_duel",
"dmglog": ""
})).activate()
def order_change(battle, context, bv, narrator):
ctarget_army = context.ctarget_army
morale_cost = context.morale_cost
Event(
battle,
"change_morale",
contexts.Context({
"ctarget_army": ctarget_army, # losing army
"morale_change": -morale_cost
})).activate()
for u in ctarget_army.present_units():
damage = random.randint(0, 1)
Event(
battle, "receive_damage",
contexts.Context({
"damage": damage,
"ctarget": u,
"dmgtype": "order_change",
"dmglog": ""
})).activate()
def webhook():
# return response
try:
cntxt = contexts.Context(request)
response = cntxt.buildResponse()
pp.pprint(response)
return make_response(jsonify(response))
#return make_response(jsonify(results()))
except Exception as e:
#e = sys.exc_info()[0]
#print(f'-- ERROR --')
#print(sys.exc_info()[1])
pp.pprint(request.get_json())
raise
def change_morale(battle, context, bv, narrator):
ctarget_army = context.ctarget_army
if ctarget_army.morale <= 0:
return
morale_change = context.morale_change
newmorale = ctarget_army.morale + morale_change
newmorale = min(newmorale, battle_constants.MORALE_MAX)
newmorale = max(newmorale, battle_constants.MORALE_MIN)
ctarget_army.morale = newmorale
if ctarget_army.morale <= 0:
Event(battle, "army_collapse_from_morale", context).activate()
for u in tuple(ctarget_army.present_units()):
Event(battle, "unit_leave_battle",
contexts.Context({'ctarget': u})).activate()
def order_yomi_win(battle, context, bv, narrator, csource_army):
ctarget_army = csource_army.other_army()
ycount = csource_army.get_yomi_count()
# TODO currently not used for anything; eventually may be used for different yomi win handling
# morale_dam = ctarget_army.bet_morale_change + ycount
Event(
battle,
"change_morale",
contexts.Context({
"ctarget_army": csource_army, # winning army
"morale_change": ycount
})).activate()
# definitely need this
Event(
battle,
"change_morale",
contexts.Context({
"ctarget_army": ctarget_army, # losing army
"morale_change": -ycount
})).activate()
# must put after to show the difference
Event(battle, "yomi_morale_changed",
contexts.Context({})).activate(csource_army, ctarget_army, ycount)
def indirect_order(battle, context, bv, narrator):
ctarget = context.ctarget
ctarget.order = rps.FinalOrder('I')
enemyunits = ctarget.army.other_army().present_units()
if not enemyunits:
ctarget.targetting = ("defending", ctarget)
return
cnewsource = ctarget # new event
cnewtarget = random.choice(enemyunits)
cnewsource.targetting = ("sneaking", cnewtarget)
newcontext = contexts.Context({
"csource": cnewsource,
"ctarget": cnewtarget
})
Event(battle, "indirect_raid", newcontext).defer("Q_MANUEVER")
def test_duel(debug=False, resize=False,
first_intelligence="PLAYER",
second_intelligence="AI_WIP"):
armies = [army_mysticsoft(0, Colours.CYAN, first_intelligence),
army_bizarro(1, Colours.MAGENTA, second_intelligence)]
automated = (first_intelligence != 'PLAYER') and (second_intelligence != 'PLAYER')
bat = battle.Battle(armies[0], armies[1], debug_mode=debug, automated=automated)
armies[0].units[0].health = 100
armies[1].units[1].health = 100
import events
import contexts
events.duel_accepted(bat, contexts.Context({
'csource':armies[0].units[0],
'ctarget':armies[1].units[1]}), bat.battlescreen, bat.narrator)
return 0
def physical_strike(battle, context, bv, narrator):
""" strike is the singular act of hitting """
csource = context.csource
ctarget = context.ctarget
multiplier = 1
if "vulnerable" in context.opt and context.vulnerable:
multiplier = 2
damage, damlog = _compute_physical_damage(csource,
ctarget,
multiplier=multiplier)
Event(
battle, "receive_damage",
contexts.Context({
"damage": damage,
"csource": csource,
"ctarget": ctarget,
"vulnerable": context["vulnerable"],
"dmglog": damlog
})).activate()
def attack_order(battle, context, bv, narrator):
"""
what we do in a *committed* attack order (we no longer consider statuses, etc;)
"""
ctarget = context.ctarget
ctarget.order = rps.FinalOrder('A')
enemy = ctarget.army.other_army()
enemyunits = enemy.present_units()
if not enemyunits:
ctarget.targetting = ("defending", ctarget)
return
cnewsource = context.ctarget # new event
cnewtarget = random.choice(enemyunits)
cnewsource.targetting = ("marching", cnewtarget)
newcontext = contexts.Context({
"csource": cnewsource,
"ctarget": cnewtarget
})
Event(battle, "march", newcontext).defer("Q_MANUEVER")
def arrow_strike(battle, context, bv, narrator):
csource = context.csource
ctarget = context.ctarget
multiplier = 1
if "vulnerable" in context.opt and context.vulnerable:
multiplier = 2
damage, dmglog = _compute_arrow_damage(csource,
ctarget,
multiplier=multiplier)
Event(
battle, "receive_damage",
contexts.Context({
"damage": damage,
"ctarget": ctarget,
"vulnerable": context["vulnerable"],
"dmgtype": "arrow",
"dmglog": dmglog
})).activate()
if csource.has_unit_status("fire_arrow"):
Event(battle, 'fire_arrow', context).activate()
if csource.has_unit_status("chu_ko_nu"):
Event(battle, 'chu_ko_nu', context).activate()
elif ctarget.has_unit_status("counter_arrow"):
Event(battle, 'counter_arrow', context).activate()
