def __init__(self, exit_on_game_over=False):
self.actions = ActionFactory(self)
self.deck1 = []
self.deck2 = []
self.players = []
self.sides = [[], []]
self.active_player = 0
self.exit_on_game_over = exit_on_game_over
self.winner = None
def load_config(self, xml_document):
"""Parses the XML config file"""
try:
root = ET.fromstring(xml_document)
except UnicodeEncodeError:
root = ET.fromstring(xml_document.encode('utf-8'))
#
# Find organization node
#
self.organization = (root.findall('organization') + [None])[0]
#
# Find (first) deviceconfig node
#
self.devicecfg = root.find('configurations/deviceConfiguration')
#
# Read reporting config and initialize reporter
#
try:
reporting = next(
iter(
filter(
lambda n: int(n.get('type', '0')) ==
SW2_PALADIN_REPORT_HANDLER_CLOUD,
self.devicecfg.findall('reporting/handlers/handler'))))
except StopIteration:
reporting = None
self.reporter = PaladinCloudReporter(reporting, self.devicecfg,
self.organization)
self.resources = load_resources(
self.devicecfg.findall('customization/resources/resource'))
#
# Create actions
#
factory = ActionFactory(self)
self.actions = [
factory.create(a) for a in self.devicecfg.findall('actions/action')
]
def parse(self,stream):
self.actions = []
while stream.peek('uintle:8') != 0:
action_code = datatypes.UI8(stream)
action_length = 0
if action_code > 0x7F:
action_length = datatypes.UI16(stream)
action_stream = stream.read('bits:{0}'.format(action_length*8))
self.actions.append(ActionFactory.new_action(action_stream,
action_code,
action_length))
def parse(self,stream):
self.sprite_id = stream.read('uintle:16')
self.actions = []
while stream.peek('uintle:8') != 0:
action_code = stream.read('uintle:8')
action_length = 0
if action_code > 0x7F:
action_length = stream.read('uintle:16')
action_stream = stream.read('bits:{0}'.format(action_length*8))
self.actions.append(ActionFactory.new_action(action_stream,
action_code,
action_length))
class Game:
player = Player()
computer = Player()
scanner = Scanner()
rounds = 0
actionFactory = ActionFactory()
def run(self):
self.rounds = self.scanner.readRoundNumber()
if self.rounds == False:
self.run()
return False
i = 0
while i < int(self.rounds):
print("Make your choice for round " + str(i) + ": ")
action = self.scanner.readActionName()
if action != False:
self.player.currentAction = self.actionFactory.createAction(
action)
self.computer.currentAction = self.actionFactory.getRandomAction(
)
result = self.player.currentAction.attack(
self.player.currentAction, self.computer.currentAction)
if result == True:
self.player.score += 1
if result == False:
self.computer.score += 1
i += 1
self.showResults()
def showResults(self):
if self.player.score > self.computer.score:
print("Result: You won " + str(self.player.score) +
" time(s), your opponent won " + str(self.computer.score) +
" time(s). You win!")
if self.player.score < self.computer.score:
print("Result: You won " + str(self.player.score) +
" time(s), your opponent won " + str(self.computer.score) +
" time(s). Your oponnent wins!")
if self.player.score == self.computer.score:
print("Result: You won " + str(self.player.score) +
" time(s), your opponent won " + str(self.computer.score) +
" time(s). It's a tie!")
def __init__(self,stream,swf_version):
self.event_flags = ClipEventFlags(stream,swf_version)
self.action_record_size = stream.read('uintle:32')
initial_bytepos = stream.bytepos
if hasattr(self.event_flags,"clip_event_key_press") and self.event_flags.clip_event_key_press == True:
self.key_code = stream.read('uintle:8')
self.actions = []
while stream.bytepos < initial_bytepos + self.action_record_size:
action_code = stream.read('uintle:8')
action_length = 0
if action_code > 0x7F:
action_length = stream.read('uintle:16')
action_stream = stream.read('bits:{0}'.format(action_length*8))
self.actions.append(ActionFactory.new_action(action_stream,
action_code,
action_length) )
class Board:
def __init__(self, exit_on_game_over=False):
self.actions = ActionFactory(self)
self.deck1 = []
self.deck2 = []
self.players = []
self.sides = [[], []]
self.active_player = 0
self.exit_on_game_over = exit_on_game_over
self.winner = None
def initialize_game(self):
initializer = DeckInitializer()
self.deck1 = initializer.make_std_deck()
self.deck2 = initializer.make_std_deck()
p1_starts = self._player1_starts()
self.active_player = 0 if p1_starts else 1
self.players = [
Player(id=1, deck=self.deck1, hand=Hand(self.deck1), starts=p1_starts),
Player(id=2, deck=self.deck2, hand=Hand(self.deck2), starts=not p1_starts)
]
self.sides = [[initializer.create_hero('jaina')], [initializer.create_hero('jaina')]]
def _player1_starts(self):
return random() < 0.5
def play_minion(self, index):
self.execute_action(self.actions.play_minion(index))
def cast_spell(self, card_idx, target_idx, safe=False):
self.execute_action(self.actions.cast_spell(card_idx, target_idx, safe))
def end_turn(self, safe=False):
self.execute_action(self.actions.end_turn(safe))
def active_draw_card(self, card_idx):
self.execute_action(self.actions.draw(card_idx))
def attack(self, atk_idx, def_idx, safe=False):
self.execute_action(self.actions.attack(atk_idx, def_idx, safe))
def execute_action(self, action):
action.execute()
def change_active_player(self):
self.active_player = self.get_other_idx()
def get_active_hand(self):
return self.get_active_player().hand
def get_other_hand(self):
return self.get_other_player().hand
def get_active_deck(self):
return self.get_active_player().deck
def get_other_deck(self):
return self.get_other_player().deck
def get_active_idx(self):
return self.active_player
def get_other_idx(self):
return 1 if self.active_player == 0 else 0
def get_active_side(self):
return self.sides[self.get_active_idx()]
def get_other_side(self):
return self.sides[self.get_other_idx()]
def get_active_player(self):
return self.players[self.get_active_idx()]
def get_other_player(self):
return self.players[self.get_other_idx()]
def game_loop(self):
pass
def game_over(self, active):
self.winner = active+1
if self.exit_on_game_over:
print(str(self))
print('Player #{} won!'.format(active+1))
sys.exit(self.winner)
def is_game_over(self):
return self.winner is not None
def __str__(self):
board_str = ''
for player in self.players:
board_str += str(player) + '\n'
i = 1
board_str += '\n\n'
for side in self.sides:
board_str += 'SIDE OF PLAYER #{}:\n'.format(i)
i += 1
for card in side:
board_str += '{}\n'.format(card)
return board_str
# A class that prints A 'x' times
class PrintA(Aktion):
def __init__(self):
super().__init__()
def __act__(self, times):
print("A".join(['' for i in range(times + 1)]))
# A class that prints B 'x' times
class PrintB(Aktion):
def __init__(self):
super().__init__()
self.retryin = []
def __act__(self, times):
print("B".join(['' for i in range(times + 1)]))
if __name__ == "__main__":
factory = ActionFactory()
factory.register(PrintA)
factory.register(PrintB)
plan = ExecutionPlan("simple_actions.json")
plan.run()
import json
import boto3
import re
from actions import ActionFactory
from actions import Action
from utils import Utils
from decision_node import decision_node
from decision_tree import decision_tree
from decision_tree_map import decision_tree_map
from bot_init import BotInitialize
dynamodb = boto3.client('dynamodb')
d_tree_map_by_file_name = {}
actionFactory = ActionFactory()
def get_decision_node(root, path):
d2 = Utils().get_decision_node(root, path, 0)
return d2
def update_call_status(callId, callStatus):
keyRequest = {"callId": {'N': str(callId)}}
updateExpression = "SET callStatus=:statusValue"
expressionAttributes = {':statusValue': {'S': callStatus}}
dynamodb.update_item(TableName='callTriggerTable',
Key=keyRequest,
ExpressionAttributeValues=expressionAttributes,
UpdateExpression=updateExpression)
class GenerateB(Aktion):
def __init__(self):
super().__init__()
self.retryin = []
def __act__(self, times):
return "B".join(['' for i in range(times+1)])
class ConcatSrt(Aktion):
def __init__(self):
super().__init__()
def __act__(self, items, times=1):
result = "".join([i for i in items])
result = result.join(['' for i in range(times+1)])
print(result)
if __name__ == "__main__":
factory = ActionFactory()
factory.register(GenerateA)
factory.register(GenerateB)
factory.register(ConcatSrt)
plan = ExecutionPlan(r"chain_actions.json")
plan.run()
def on_event(self, event, extension):
_LOGGER_.debug("KeywordQueryEventListener executing")
arguments_or_empty: str = event.get_query().get_argument() or ""
arguments: list = arguments_or_empty.split()
return RenderResultListAction(
ActionFactory(arguments, extension.db).create().execute())
def __init__(self, board):
self.board = board
self.actions = ActionFactory(board)
self.reviewer = BoardReviewer(board)
class Analyzer:
def __init__(self, board):
self.board = board
self.actions = ActionFactory(board)
self.reviewer = BoardReviewer(board)
def generate_actions(self):
if self.board.is_game_over():
return []
all_actions = []
all_actions.extend(self.generate_playing_minions())
all_actions.extend(self.generate_attacks())
all_actions.extend(self.generate_casting_spells())
all_actions.extend(self.generate_ending_turn())
# all_actions.extend(self.generate_card_draw())
return all_actions
def grade_board(self):
return self.reviewer.grade_board()
def generate_playing_minions(self):
player = self.board.get_active_player()
active_side = self.board.get_active_side()
actions = []
for idx, card in enumerate(player.hand.cards):
if card.cost <= player.mana:
if card.type == 'minion':
if len(active_side) < 7:
actions.append(self.actions.play_minion(idx))
return actions
def generate_ending_turn(self):
return [self.actions.end_turn()]
def generate_attacks(self):
active_side = self.board.get_active_side()
other_side = self.board.get_other_side()
actions = []
for idx, minion in enumerate(active_side):
# Skip the hero
if idx == 0: continue
if minion.can_attack:
taunts = [c for c in other_side if c.taunt]
for enemyidx, enemy in enumerate(other_side):
if taunts:
if enemy.taunt:
actions.append(self.actions.attack(idx, enemyidx))
else:
actions.append(self.actions.attack(idx, enemyidx))
return actions
def generate_casting_spells(self):
active_player = self.board.get_active_player()
other_side = self.board.get_other_side()
actions = []
for cardidx, card in enumerate(active_player.hand.cards):
if card.type != 'spell': continue
if card.cost > active_player.mana: continue
for enemyidx, _ in enumerate(other_side):
actions.append(self.actions.cast_spell(cardidx, enemyidx))
return actions
def generate_card_draw(self):
deck = self.board.get_active_deck()
card_scores = [self.reviewer.grade_card(c) for c in deck.cards]
max_score_idx = card_scores.index(max(card_scores))
return [self.actions.draw(max_score_idx)]
