コード例 #1
0
def add_possible_orders_to_saved_game(saved_game):
    """ Adds possible_orders for each phase of the saved game """
    if saved_game['map'].startswith('standard'):
        for phase in saved_game['phases']:
            game = Game(map_name=saved_game['map'], rules=saved_game['rules'])
            game.set_state(phase['state'])
            phase['possible_orders'] = game.get_all_possible_orders()
    return saved_game
コード例 #2
0
ファイル: render.py プロジェクト: zhanpengfang/research
def render_saved_game(saved_game, output_dir, prefix=''):
    """ Renders a specific saved game
        :param saved_game: The saved game to render
        :param output_dir: The output directory where to save the rendering
        :param prefix: An optional prefix to add before the game id
    """
    if prefix:
        output_dir = os.path.join(output_dir, prefix + '_' + saved_game['id'])
    else:
        output_dir = os.path.join(output_dir, saved_game['id'])
    nb_phases = len(saved_game['phases'])
    svg_count = 0

    # Checking if already generated
    # Otherwise, regenerating completely
    if os.path.exists(output_dir):
        nb_svg = len([
            os.path.join(output_dir, file) for file in os.listdir(output_dir)
            if file[-4:] == '.svg'
        ])
        if nb_svg == 2 * nb_phases:
            print('Rendered {} (Skipped)'.format(saved_game['id']))
            return
        shutil.rmtree(output_dir, ignore_errors=True)
    os.makedirs(output_dir, exist_ok=True)

    # Creating a Game to replay all orders, and a new Game object per phase to validate
    entire_game = Game()
    if saved_game['phases']:
        entire_game.set_state(saved_game['phases'][0]['state'])

    # Rendering
    for phase in saved_game['phases']:
        phase_game = Game()

        # Setting state
        state = phase['state']
        phase_game.set_state(state)
        entire_game.note = phase_game.note

        # Setting orders
        phase_game.clear_orders()
        orders = phase['orders']
        for power_name in orders:
            phase_game.set_orders(power_name, orders[power_name])
            entire_game.set_orders(power_name, orders[power_name])

        # Validating that we are at the same place
        for power_name in orders:
            assert sorted(phase_game.get_units(power_name)) == sorted(
                entire_game.get_units(power_name))
            assert sorted(phase_game.get_centers(power_name)) == sorted(
                entire_game.get_centers(power_name))

        # Rendering with and without orders
        with open(os.path.join(output_dir, '%03d%s' % (svg_count, '.svg')),
                  'w') as file:
            file.write(entire_game.render(incl_orders=False))
        svg_count += 1
        with open(os.path.join(output_dir, '%03d%s' % (svg_count, '.svg')),
                  'w') as file:
            file.write(entire_game.render(incl_orders=True))

        # Processing (for entire game)
        svg_count += 1
        entire_game.process()

    print('Rendered {}'.format(saved_game['id']))