def __init__(self,
model_config,
game_config,
player1_model=None,
player1_mode='model_training',
player2_model=None,
player2_mode='random',
model_dir='.'):
self.model_config = model_config
self.game_config = game_config
self.device = torch.device(
'cuda:0') if torch.cuda.is_available() else torch.device('cpu')
self.player1_mode = player1_mode
self.player2_mode = player2_mode
self.player1_model = player1_model
self.player2_model = player2_model
if player1_mode.startswith('model'):
if player1_model is None:
self.player1_model = GameModel(game_config)
self.player1_model.to(self.device)
if player2_mode.startswith('model'):
if player2_model is None:
self.player2_model = GameModel(game_config)
self.player2_model.to(self.device)
self.model_dir = model_dir
self.vis = Visdom(env=self.model_config.model_name)
def main():
model = GameModel()
view = GameView(800, 600)
controller = GameController(model, view)
# ---
while (True):
controller.update()
def __init__(self):
self.game = GameModel()
self.game.king_captured = self.king_captured
self.game.init()
self.game.mode = 'play'
self.game.add_message = print
self.net_engine = NetEngine(self.game)
self.init_net_engine_socket()
def __init__(self, **kwargs):
super(Game, self).__init__(**kwargs)
self.game_model = GameModel()
self.game_model.king_captured = self.king_captured
self.game_model.on_message.append(self.update_label)
self.net_engine = NetEngine(self.game_model)
self.score = [0, 0]
self.board_view = BoardView(self.game_model)
self.add_widget(self.board_view)
self.game_model.on_init.append(self.board_view.reset)
self.info_pane = BoxLayout(orientation='vertical', size_hint_min_y=500)
self.add_widget(self.info_pane)
row_args = {'size_hint': (1, 0), 'size_hint_min_y': 70}
if not env.is_mobile:
self.info_pane.add_widget(WrappedLabel(halign='center', text=self.game_title, **row_args))
self.button_pane = BoxLayout(orientation='vertical', size_hint=(1, .4))
self.info_pane.add_widget(self.button_pane)
self.button_pane.add_widget(WrappedButton(
halign='center',
text='Tutorial: How to play',
on_press=self.start_tutorial))
self.button_pane.add_widget(WrappedButton(
halign='center',
text='Start Game' if env.is_mobile else 'Start Game: Play with friends',
on_press=self.start_game))
self.score_label = WrappedLabel(
halign='center',
**row_args)
self.info_pane.add_widget(self.score_label)
self.label = WrappedLabel(halign='center', valign='bottom')
self.info_pane.add_widget(self.label)
self.text_input = TextInput(
multiline=False,
text_validate_unfocus=env.is_mobile,
**row_args)
self.text_input.bind(on_text_validate=self.handle_text_input)
if not env.is_mobile:
def steal_focus(*_args):
if not self.text_input.focus:
self.text_input.focus = True
self.text_input.bind(focus=steal_focus)
self.info_pane.add_widget(self.text_input)
self.game_model.add_message('')
self.game_model.add_message(self.game_title if env.is_mobile else 'Welcome to Chess 2!')
self.bind(size=self.resized)
Clock.schedule_interval(self.on_clock, 1/30)
def main():
pygame.init()
event_manager = EventManager()
game_model = GameModel(event_manager)
keyboard_controller = KeyboardController(event_manager)
time_controller = TimeController(event_manager)
game_view = GameView(
event_manager, game_model,
time_controller) # sollte von GameModel aufgemacht werden
time_controller.run()
def main():
pygame.init()
pygame.display.set_caption("The 15 Puzzle")
win = pygame.display.set_mode((WIN_WIDTH, WIN_HEIGHT))
clock = pygame.time.Clock()
event_manager = EventManager()
game_board = GameModel()
game_view = GameView(win)
spinner = CPUSpinnerController(event_manager, clock)
game_controller = GameController(game_board, game_view)
event_manager.registerListener(TickEvent(), game_controller)
event_manager.registerListener(QuitEvent(), spinner)
spinner.run()
pygame.quit()
def __init__(self):
self.__model = GameModel()
self.__sprites = pg.sprite.Group()
self.__attacks = pg.sprite.Group()
self.__view = GameView(self.__model.player,
self.__model.level,
self.__sprites,
self.__attacks)
self.__player = self.__model.player
self.__level = self.__model.level
self.__clock = pg.time.Clock()
# inicializa os modulos do pygame e retorna uma tupla com resultados
self.__modules = pg.init()
self.__running = True
self.__menu = True
self.__game_over = False
self.__start_playing = False
self.__win = False
def get_newgame():
'''returns the game scene'''
scene = Scene()
# model
model = GameModel()
# controller
controller = GameController(model)
# view
view = GameView(model)
# set controller in model
model.set_controller(controller)
# add controller
scene.add(controller, z=1, name="controller")
# add view
#scene.add(BackgroundLayer(), z=0, name="background")
scene.add(view, z=2, name="view")
return scene
from game_model import GameModel, GameState, ActionProperties, GameAction, Game
from graph_model import GraphModel
from pg import ppo
import numpy as np
import tensorflow as tf
n_blocks = 4
max_moves = 20
block_names = [chr(i+65) for i in range(n_blocks)]
blocks_world = GameModel(
global_enums={'filler': [0]},
object_enums={'label': block_names},
action_enums={'move': {'on_top_of': ActionProperties(n_nodes=2),
'to_table': ActionProperties(n_nodes=1)}},
edge_enums={'position': ['above', 'below'], 'role': ['from', 'to']})
class BlocksWorldGame(Game):
"""Basic blocks world game"""
def __init__(self):
self._stacks = []
shuffled = [name for name in block_names]
random.shuffle(shuffled)
for name in shuffled:
maximum = len(self._stacks)
i = random.randrange(maximum+1)
if i == maximum:
from fireplace import cards
from fireplace.game import Game
from fireplace.exceptions import GameOver
from hearthstone.enums import CardClass
from agent import HearthStoneGod
from game_model import GameModel
cards.db.initialize('zhCN')
if __name__ == "__main__":
model_data = torch.load('./models/model1.1/105_0.99.pth',
map_location='cpu')
game_config = model_data['game_config']
game_model = GameModel(game_config)
deck1 = [c[1] for c in game_config.card_config.cards_list[1:] * 4]
player1 = HearthStoneGod('Player1',
deck1,
CardClass.MAGE.default_hero,
game_config,
mode='manual')
deck2 = [c[1] for c in game_config.card_config.cards_list[1:] * 4]
player2 = HearthStoneGod('Player2',
deck2,
CardClass.MAGE.default_hero,
game_config,
game_model=game_model,
mode='model_play')
from controller import BasicController, UserController
from ai_controller import AIController
from game_model import GameModel
from view import GameView
if __name__ == '__main__':
model = GameModel(board_size=30)
view = GameView(model.board_size)
# controller = UserController(model, view)
controller = AIController(model, view, delay=0)
controller.play()
def main():
# MVC pattern (Model View Controller)
model = GameModel()
controller = GameController(model)
view = GameView(model, controller)
def __init__(self):
pygame.init()
self.__GameModel = GameModel(self)
self.__GameView = GameView(self, self.__GameModel)
self.__sounds = Sound()
import csv
from game_model import GameModel
from board import Board
games = []
WHITE = "white"
BLACK = "black"
with open('games.csv') as csvfile:
gamereader = csv.reader(csvfile)
for row in gamereader:
game = GameModel(row)
games.append(game)
for game in games:
white_turn = True
board = Board()
moves = game.moves.split(" ")
for move in moves:
if white_turn:
board.execute_move(move, WHITE, True)
else:
board.execute_move(move, BLACK, True)
def main():
pygame.init()
screen = pygame.display.set_mode((800, 600))
pygame.display.set_caption("SlippyPants")
game = GameModel("levels/graphic_test.json", 800, 600)
game.run(screen)
def _build_new_game(self):
self.model = GameModel()
self.sprites = pg.sprite.LayeredDirty()
self.enc = EncounterRenderer(self.model, (0, 100, 800, 500))
self.hud = Hud(self.model, (0, 0, 800, 100))
