def _generate_actions_description(self, full_gdy_path):
# load a simple griddly env with each tile printed
loader = GriddlyLoader()
grid = loader.load_game(full_gdy_path)
action_mappings = grid.get_action_input_mappings()
sphinx_string = ''
for action_name, action_details in action_mappings.items():
sphinx_string += f'{action_name}\n'
sphinx_string += '^' * len(action_name) + '\n\n'
if 'Relative' in action_details and action_details['Relative']:
sphinx_string += ':Relative: The actions are calculated relative to the object being controlled.\n\n'
if 'Internal' in action_details and action_details['Internal']:
sphinx_string += ':Internal: This action can only be called from other actions, not by the player.\n\n'
sphinx_string += f'.. list-table:: \n :header-rows: 1\n\n'
sphinx_string += ' * - Action Id\n - Mapping\n'
for action_id, details in sorted(action_details['InputMappings'].items()):
description = details['Description'] if 'Description' in details else ''
sphinx_string += f' * - {action_id}\n - {description}\n'
sphinx_string += '\n\n'
return sphinx_string
def _generate_object_tile_images(self, objects, doc_path, game_name,
gdy_file):
# img/sokoban-wall-x.png
tile_images = defaultdict(dict)
# load a simple griddly env with each tile printed
loader = GriddlyLoader()
renderer = RenderToFile()
level_string = ''
for i, object in enumerate(objects):
if 'MapCharacter' in object:
name = object['Name']
level_string += f'{object["MapCharacter"]} '
for observer_type in self._observer_types:
grid = loader.load_game(gdy_file)
player_count = grid.get_player_count()
tileSize = grid.get_tile_size()
game = grid.create_game(observer_type)
players = []
for p in range(player_count):
players.append(game.register_player(f'P{p}', observer_type))
observer_type_string = self._get_observer_type_string(
observer_type)
game.init()
grid.load_level_string(f'{level_string}\n')
game.reset()
rendered_sprite_map = np.array(game.observe(), copy=False)
i = 0
for object in objects:
if 'MapCharacter' in object:
name = object['Name']
relative_image_path = os.path.join(
'img',
f'{game_name.replace(" ", "_")}-object-{observer_type_string}-{name}.png'
)
doc_image_path = os.path.join(doc_path,
relative_image_path)
single_sprite = rendered_sprite_map[:, i *
tileSize:i * tileSize +
tileSize, :]
tile_images[observer_type_string][
name] = relative_image_path
renderer.render(single_sprite, doc_image_path)
i += 1
# We are creating loads of game instances. this forces the release of vulkan resources before the python GC
game.release()
return tile_images
def __init__(self, yaml_file=None, level=0, global_observer_type=gd.ObserverType.SPRITE_2D,
player_observer_type=gd.ObserverType.SPRITE_2D, max_steps=None, image_path=None, shader_path=None,
gdy=None, game=None):
"""
Currently only supporting a single player (player 1 as defined in the environment yaml
:param yaml_file:
:param level:
:param global_observer_type: the render mode for the global renderer
:param player_observer_type: the render mode for the players
"""
super(GymWrapper, self).__init__()
# Set up multiple render windows so we can see what the AIs see and what the game environment looks like
self._renderWindow = {}
# If we are loading a yaml file
if yaml_file is not None:
self._is_clone = False
loader = GriddlyLoader(image_path, shader_path)
self.gdy = loader.load(yaml_file)
self.game = self.gdy.create_game(global_observer_type)
if max_steps is not None:
self.gdy.set_max_steps(max_steps)
if level is not None:
self.game.load_level(level)
# if we are loading a copy of the game
elif gdy is not None and game is not None:
self._is_clone = True
self.gdy = gdy
self.game = game
self._players = []
self.player_count = self.gdy.get_player_count()
self._global_observer_type = global_observer_type
self._player_observer_type = []
for p in range(self.player_count):
self._players.append(self.game.register_player(f'Player {p + 1}', player_observer_type))
self._player_observer_type.append(player_observer_type)
self._player_last_observation = []
self._global_last_observation = None
self._enable_history = False
self.game.init(self._is_clone)
def _generate_level_data(self, game_name, num_levels, doc_path, yaml_string):
# load a simple griddly env with each tile printed
loader = GriddlyLoader()
renderer = RenderToFile()
level_images = defaultdict(dict)
level_sizes = {}
supported_observer_types = []
for observer_type in self._observer_types:
grid = loader.load_string(yaml_string)
try:
game = grid.create_game(observer_type)
except ValueError as e:
self._logger.debug(f'Skipping observer type {observer_type} for environment {game_name}')
continue
supported_observer_types.append(observer_type)
players = []
for p in range(grid.get_player_count()):
players.append(game.register_player(f'P{p}', observer_type))
game.init()
for level in range(num_levels):
observer_type_string = self._get_observer_yaml_key(observer_type)
grid.load_level(level)
game.reset()
rendered_level = np.array(game.observe(), copy=False)
relative_image_path = os.path.join('img',
f'{game_name.replace(" ", "_")}-level-{observer_type_string}-{level}.png')
doc_image_path = os.path.join(doc_path, relative_image_path)
renderer.render(rendered_level, doc_image_path)
level_images[observer_type_string][level] = relative_image_path
level_sizes[level] = {'width': grid.get_width(), 'height': grid.get_height()}
# We are creating loads of game instances. this forces the release of vulkan resources before the python GC
game.release()
return level_images, level_sizes, supported_observer_types
def __init__(self,
yaml_file,
level=0,
global_observer_type=gd.ObserverType.SPRITE_2D,
player_observer_type=gd.ObserverType.SPRITE_2D,
max_steps=None,
image_path=None,
shader_path=None):
"""
Currently only supporting a single player (player 1 as defined in the environment yaml
:param yaml_file:
:param level:
:param global_observer_type: the render mode for the global renderer
:param player_observer_type: the render mode for the players
"""
super(GymWrapper, self).__init__()
# Set up multiple render windows so we can see what the AIs see and what the game environment looks like
self._renderWindow = {}
loader = GriddlyLoader(image_path, shader_path)
self._grid = loader.load_game(yaml_file)
self._grid.load_level(level)
self._players = []
self.player_count = self._grid.get_player_count()
if max_steps is not None:
self._grid.set_max_steps(max_steps)
self.game = self._grid.create_game(global_observer_type)
self._global_observer_type = global_observer_type
self._player_observer_type = []
for p in range(1, self.player_count + 1):
self._players.append(
self.game.register_player(f'Player {p}', player_observer_type))
self._player_observer_type.append(player_observer_type)
self._last_observation = {}
self.game.init()
def _generate_level_images(self, game_name, num_levels, doc_path,
full_gdy_path):
# load a simple griddly env with each tile printed
loader = GriddlyLoader()
renderer = RenderToFile()
level_images = defaultdict(dict)
for observer_type in self._observer_types:
grid = loader.load_game(full_gdy_path)
game = grid.create_game(observer_type)
players = []
for p in range(grid.get_player_count()):
players.append(game.register_player(f'P{p}', observer_type))
game.init()
for level in range(num_levels):
observer_type_string = self._get_observer_type_string(
observer_type)
grid.load_level(level)
game.reset()
rendered_level = np.array(game.observe(), copy=False)
relative_image_path = os.path.join(
'img',
f'{game_name.replace(" ", "_")}-level-{observer_type_string}-{level}.png'
)
doc_image_path = os.path.join(doc_path, relative_image_path)
renderer.render(rendered_level, doc_image_path)
level_images[observer_type_string][level] = relative_image_path
# We are creating loads of game instances. this forces the release of vulkan resources before the python GC
game.release()
return level_images
import sys
import os
import numpy as np
# The griddy lib is in the build directory when built so add it and then import
from griddly import gd, GriddlyLoader
from griddly.RenderTools import RenderToFile
if __name__ == '__main__':
loader = GriddlyLoader()
game_description = loader.load_game('resources/ztest.yaml')
# grid = gdy_description.load_level(0)
grid = game_description.create_level(5, 5)
renderWindow = RenderToFile()
for x in range(0, 5):
for y in range(0, 5):
grid.add_object(1, x, y, "ghost")
for x in range(1, 4):
for y in range(1, 4):
grid.add_object(1, x, y, "floor")
game = grid.create_game(gd.ObserverType.SPRITE_2D)
# Create a player
player1 = game.register_player('Bob', gd.ObserverType.VECTOR)
def _generate_object_tile_images(self, game_description, yaml_string, doc_path, game_name):
# img/sokoban-wall-x.png
tile_images = defaultdict(dict)
# load a simple griddly env with each tile printed
loader = GriddlyLoader()
renderer = RenderToFile()
debug_renderer = RenderWindow(320,480)
objects = game_description['Objects']
level_string = ''
for i, object in enumerate(objects):
if 'MapCharacter' in object:
name = object['Name']
level_string += f'{object["MapCharacter"]} '
supported_observer_types = []
for observer_type in self._observer_types:
grid = loader.load_string(yaml_string)
player_count = grid.get_player_count()
try:
game = grid.create_game(observer_type)
except ValueError as e:
self._logger.debug(f'Skipping observer type {observer_type} for environment {game_name}')
continue
supported_observer_types.append(observer_type)
players = []
for p in range(player_count):
players.append(game.register_player(f'P{p}', observer_type))
observer_type_string = self._get_observer_yaml_key(observer_type)
environment = game_description['Environment']
if 'Observers' in environment and observer_type_string in environment['Observers']:
observer_config = environment['Observers'][observer_type_string]
if 'TileSize' in observer_config:
tileSize = observer_config['TileSize']
if isinstance(tileSize, int):
tileSize = [tileSize, tileSize]
else:
tileSize = [24, 24]
if 'TileOffsetY' in observer_config:
tileOffsetY = observer_config['TileOffsetY']
else:
tileOffsetY = 0
else:
tileSize = [24, 24]
game.init()
if observer_type == gd.ObserverType.ISOMETRIC:
level_string = level_string.replace(' ', '.')
grid.load_level_string(f'{level_string}\n')
game.reset()
rendered_sprite_map = np.array(game.observe(), copy=False)
i = 0
for object in objects:
if 'MapCharacter' in object:
name = object['Name']
relative_image_path = os.path.join('img',
f'{game_name.replace(" ", "_")}-object-{observer_type_string}-{name}.png')
doc_image_path = os.path.join(doc_path, relative_image_path)
if observer_type == gd.ObserverType.ISOMETRIC:
tilePosX = i * int(tileSize[0])
tilePosY = i * int(tileSize[1]-32)
single_sprite = rendered_sprite_map[
:,
tilePosX:tilePosX + tileSize[0],
tilePosY:tilePosY + tileSize[1]
]
#debug_renderer.render(single_sprite)
else:
single_sprite = rendered_sprite_map[:, i * tileSize[0]:i * tileSize[0] + tileSize[0], ]
tile_images[observer_type_string][name] = relative_image_path
renderer.render(single_sprite, doc_image_path)
i += 1
# We are creating loads of game instances. this forces the release of vulkan resources before the python GC
game.release()
return tile_images, supported_observer_types
from timeit import default_timer as timer
import numpy as np
import gym
from griddly import gd, GriddlyLoader
from griddly.RenderTools import VideoRecorder
if __name__ == '__main__':
loader = GriddlyLoader()
observer_type = gd.ObserverType.SPRITE_2D
game_description = loader.load_game('RTS/basicRTS.yaml')
grid = game_description.load_level(1)
game = grid.create_game(observer_type)
player1 = game.register_player(f'Player 1', observer_type)
player2 = game.register_player(f'Player 2', observer_type)
game.init()
defined_action_count = grid.get_defined_actions_count()
player_count = grid.get_player_count()
start = timer()
frames = 0
fps_samples = []
import sys
import os
import numpy as np
# The griddy lib is in the build directory when built so add it and then import
from griddly import gd, GriddlyLoader
from griddly.RenderTools import RenderToFile
if __name__ == '__main__':
loader = GriddlyLoader()
grid = loader.load_game('resources/ztest.yaml')
# grid = gdy_description.load_level(0)
grid.create_level(5, 5)
renderWindow = RenderToFile()
for x in range(0, 5):
for y in range(0, 5):
grid.add_object(1, x, y, "ghost")
for x in range(1, 4):
for y in range(1, 4):
grid.add_object(1, x, y, "floor")
game = grid.create_game(gd.ObserverType.SPRITE_2D)
# Create a player
player1 = game.register_player('Bob', gd.ObserverType.VECTOR)
import numpy as np
from griddly import gd, GriddlyLoader
from griddly.RenderTools import RenderToFile
if __name__ == '__main__':
loader = GriddlyLoader()
game_description = loader.load_game('resources/bg_tiling.yaml')
grid = game_description.load_level(0)
renderWindow = RenderToFile()
game = grid.create_game(gd.ObserverType.SPRITE_2D)
# Create a player
player1 = game.register_player('Bob', gd.ObserverType.VECTOR)
game.init()
observation = np.array(game.reset(), copy=False)
renderWindow.render(observation, "bg_test.png")
import numpy as np
from timeit import default_timer as timer
from griddly import gd, GriddlyLoader
from griddly.RenderTools import RenderWindow
window = None
if __name__ == '__main__':
renderWindow = RenderWindow(500, 500)
loader = GriddlyLoader()
grid = loader.load_game('RTS/basicRTS.yaml')
grid.load_level(1)
game = grid.create_game(gd.ObserverType.SPRITE_2D)
action_input_mappings = grid.get_action_input_mappings()
action_definition_count = len(action_input_mappings)
available_action_input_mappings = {}
action_names = []
for k, mapping in sorted(action_input_mappings.items()):
if not mapping['Internal']:
available_action_input_mappings[k] = mapping
action_names.append(k)
# Create a player
player1 = game.register_player('Bob', gd.ObserverType.SPRITE_2D)
import numpy as np
from timeit import default_timer as timer
from griddly import gd, GriddlyLoader
from griddly.RenderTools import RenderWindow
window = None
if __name__ == '__main__':
loader = GriddlyLoader()
grid = loader.load_game('Single-Player/Mini-Grid/minigrid-doggo.yaml')
game = grid.create_game(gd.ObserverType.SPRITE_2D)
# Create a player
player1 = game.register_player('Bob', gd.ObserverType.BLOCK_2D)
game.init()
renderWindow = RenderWindow(700, 700)
start = timer()
frames = 0
# Player objects have the same interface as gym environments
for l in range(0, 5):
grid.load_level(l)
game.reset()
import numpy as np
from timeit import default_timer as timer
from griddly import gd, GriddlyLoader
from griddly.RenderTools import RenderWindow
window = None
if __name__ == '__main__':
loader = GriddlyLoader()
grid = loader.load_game('Single-Player/GVGAI/spider-nest.yaml')
game = grid.create_game(gd.ObserverType.ISOMETRIC)
#grid.set_max_steps(100)
# Create a player
player1 = game.register_player('Bob', gd.ObserverType.ISOMETRIC)
game.init()
renderWindow = RenderWindow(1200, 500)
start = timer()
frames = 0
# Player objects have the same interface as gym environments
for l in range(0, 5000):
import numpy as np
from griddly import gd, GriddlyLoader
from griddly.RenderTools import RenderToFile
if __name__ == '__main__':
loader = GriddlyLoader()
grid = loader.load_game('resources/bg_tiling.yaml')
grid.load_level(0)
renderWindow = RenderToFile()
game = grid.create_game(gd.ObserverType.SPRITE_2D)
# Create a player
player1 = game.register_player('Bob', gd.ObserverType.VECTOR)
game.init()
observation = np.array(game.reset(), copy=False)
renderWindow.render(observation, "bg_test.png")