def main(): filePath = sys.argv[1] with open(filePath, 'r') as openFile: fileData = openFile.readlines() openFile.close() gameInfo = [line.strip() for line in fileData] currentBoard = [] pieces = [] currentPlayer = gameInfo[0] algToUse = gameInfo[1] dLimit = int(gameInfo[2]) for line in gameInfo[3:11]: line = [newLine.strip() for newLine in line.split(',')] for obj in line: if obj != '0': pieces.append(obj) line = list(line) currentBoard.append(line) currentBoard = np.asarray(currentBoard) piecesPos = collections.defaultdict(list) starPos = [] circPos = [] for index, value in np.ndenumerate(currentBoard): if value in pieces: piecesPos[value].append(index) initialState = StateHandler(currentBoard, False) game = GameController(currentPlayer, algToUse, dLimit, initialState, pieces) game.Start()
def __init__(self, learning_rate=1e-4, width=256, height=128, time_steps=4, actions=3 , conv_kernels=[[16,16],[8,8]], conv_strides=[[8,8],[4,4]], conv_channels=[16,32], dense_channels=[256] , save_dir='model/'): # used to control the game self.gc = GameController() # used to predict values of state params = { 'LEARNING_RATE': learning_rate, 'WIDTH': width, 'HEIGHT':height, 'TIME_STEPS': time_steps, 'ACTIONS': actions, 'CONV_KERNELS': conv_kernels, 'CONV_STRIDES': conv_strides, 'CONV_CHANNELS': conv_channels, 'DENSE_CHANNELS': dense_channels, 'SAVE_DIR': save_dir } self.net = Net(params) # action map maps action keys to functions of the form () -> () self.actionMap = { 0: self.gc.go_left, 1: self.gc.stop, 2: self.gc.go_right } # policy is a function of the form (state) -> (action) self.policy = self.best_action
def __init__(self): pygame.init() self.clock = pygame.time.Clock() self.SCREEN_UPDATE = pygame.USEREVENT self.speed = 110 self.speed_up = 80 pygame.time.set_timer(self.SCREEN_UPDATE, self.speed) self.controller = GameController() self.running, self.playing = True, False self.UPKEY, self.DOWNKEY, self.START, self.BACK = False, False, False, False self.SIZE = CELL_SIZE * NO_OF_CELLS self.display = pygame.Surface((self.SIZE, self.SIZE)) self.window = pygame.display.set_mode((self.SIZE, self.SIZE)) self.font_name = 'SquareAntiqua-Bold.ttf' self.main_menu = MainMenu(self) self.GA = GAMenu(self, self.controller) self.curr_menu = self.main_menu self.load_model = False self.view_path = False
def __playOnline(self): while True: if self.waiting: break message = {'type': servconst.GAME_SEARCH_MESSAGE} self.protocol.send(message) # wait for response from server try: while True: print 'wait' msg = self.protocol.receive() msg = Protocol.toDictionary(msg) print 'got', msg if msg['type'] == servconst.GAME_SEARCH_MESSAGE: if msg['permit'] is -1: # forbid print '>>> Could not find an opponent. Please try again later.' elif msg['permit'] is 0: # wait print '>>> Waiting for an opponent.' continue else: # allow self.board.place(x=BOARD_POSITION[0], y=BOARD_POSITION[1]) controller = GameController(self.board) controller.connect(self.protocol, self.board) TkinterScheduler.perform(self.root, self.__removeEnterButton) except Exception: pass
def play(self): # Intro message print("Welcome to Escape the Island! A game of survival...") while (self.playing): newGame = GameController() newGame.play() self.save_max_number_of_days(newGame.days) self.number_of_games_played += 1 self.playing = self.ask_to_play_again()
def start_wof(self, player_list: list, wheel: object, words: object): self.wheel = wheel self.words = words self.player_list = player_list print(self.phrase) #Instantiate Game Controller self.gameController = GameController(self.phrase, wheel, words, self.dict_char, self) for i in itertools.count(): turn = i % 3 self.turn(player_list[turn])
class AppManager: """ this class is the manager of the whole app, define interface between user of the app (developer) and what this app do. simply this class manages the communication between 4 main classes (VideoSequence, HandDetector, GestureDetector, GameController)""" TAG = "AppManager" def __init__(self, output=True, debug=False, feeding=False): Logger.debug = debug Logger.out = output self.vs = Vs().start() self.hd = Hd(self.vs.getFrames("BGR")[-2]) self.gd = Gd() #self.gc = AsyncControlRepeater(Gc(ConfigReader.default()), maxBufferSize=1).start() self.gc = Gc(ConfigReader.default(), feeding=feeding) self.feeding = feeding def showAllImages(self): currFrame = self.vs.getFrames("BGR")[0] # bgModel = self.hd.getBackgroundModel() # skinBgModel = self.hd.getSkinBackgroundModel() images, titles = self.hd.getState() showImages(images, titles) showImages((currFrame, ), ('Camera', )) def step(self): startT = getTickCount() #* capturing e1 = getTickCount() frames = self.vs.process() Logger.GeneralLogger.o(timeMessage("frame process", e1), tag="TIME") #* detection e1 = getTickCount() self.hd.detect(frames("gray"), frames("BGR")[0]) Logger.GeneralLogger.o(timeMessage("hand detection", e1), tag="TIME") #* recognition e1 = getTickCount() gesture, center = self.gd.recognize(self.hd.roi, self.hd.finalOut) Logger.GeneralLogger.o("{} detected in {}".format(gesture, center), tag=self.TAG) Logger.GeneralLogger.o(timeMessage("gesture recognition", e1), tag="TIME") endT = getTickCount() #* controlling self.gc.control(gesture, center, (endT - startT) / getTickFrequency()) #self.gc.addGstRecognition(gesture, center) e1 = getTickCount() Logger.ImageLogger.o(self.vs.getFrames("BGR")[0], 'camera') Logger.GeneralLogger.o(timeMessage("imshow the image itself", e1), tag="TIME")
def __init__(self, output=True, debug=False, feeding=False): Logger.debug = debug Logger.out = output self.vs = Vs().start() self.hd = Hd(self.vs.getFrames("BGR")[-2]) self.gd = Gd() #self.gc = AsyncControlRepeater(Gc(ConfigReader.default()), maxBufferSize=1).start() self.gc = Gc(ConfigReader.default(), feeding=feeding) self.feeding = feeding
class game(): def __init__(self, phrase: str): self.vowel = const.VOWEL self.consonant = const.CONSONANT self.phrase = phrase print(self.phrase) self.reveal = re.sub('[A-Za-z]', "_ ", self.phrase) print(self.reveal) self.pattern = r'[a-zA-Z]' self.success_choice = r'[1-3]' self.char_location() self.player_list = None self.gameController = None #dict_char in instance variable idx for each character def char_location(self): unique_char = set(self.phrase) self.dict_char = {} for each_char in unique_char: self.dict_char[each_char] = [ index for index, char in enumerate(self.phrase) if char == each_char ] def start_wof(self, player_list: list, wheel: object, words: object): self.wheel = wheel self.words = words self.player_list = player_list print(self.phrase) #Instantiate Game Controller self.gameController = GameController(self.phrase, wheel, words, self.dict_char, self) for i in itertools.count(): turn = i % 3 self.turn(player_list[turn]) def turn(self, player): print(f"{player.name}'s turn!") print(f"Balance: ${player.balance}") return self.gameController.play(player) def game_end(self, player): print(f"Congratulations {player.name} you have won!") self.words.reveal_all(self.dict_char) self.player_list.sort(key=lambda x: x.balance, reverse=True) print("========Score Board========") for player in self.player_list: print(player.name + ": " + str(player.balance)) print("Game will close in 15 seconds") time.sleep(15) sys.exit()
def __init__(self, size, init_fruits=None, init_pos=None, draw_settings=None, default_direction=Direction.LEFT): self.size = size self.game_controller = GameController(default_direction) if init_fruits is None: init_fruits = get_init_fruits(size) if init_pos is None: init_pos = get_init_pos(size) self.game_map = GameMap(size, init_fruits, init_pos) if draw_settings is None: draw_settings = DrawGameSettings() self.game_drawer = GameDrawer(self.game_map, draw_settings)
class Game(): def __init__(self, gui = False): self.score = 0 self.done = False self.gui = gui self.gc = GameController() def start(self): return self.gc.generate_observations() def step(self, game_action): if self.gc.done == True: self.end_game() self.gc.player.ChangeDirection(game_action) self.done = self.gc.Move() self.score = self.gc.Score() self.gc.done = self.done if self.gui: self.gc.Draw() return self.gc.generate_observations()
def get_newgame(): scene = Scene() model = GameModel() controller = GameController(model) # 视图 hud = HUD() view = GameView(model, hud) # 模型中的控制器 model.set_controller(controller) # 添加控制器 scene.add(controller, z=1, name="controller") scene.add(hud, z=3, name="hud") scene.add(view, z=2, name="view") return scene
def get_newgame(): scene = Scene() model = GameModel() controller = GameController(model) # view hud = HUD() view = GameView(model, hud) # set controller in model model.set_controller(controller) # add controller scene.add(controller, z=1, name="controller") scene.add(hud, z=3, name="hud") scene.add(view, z=2, name="view") return scene
def initialize(self): self.parent.title("cundy crash") self.parent.grid_rowconfigure(1, weight=1) self.parent.grid_columnconfigure(1, weight=1) self.frame = Tk.Frame(self.parent) self.frame.pack(fill=Tk.X, padx=5, pady=5) scoreTextLabel = Label(self.frame, text="Score:") scoreTextLabel.grid(row=0, column=0) self.scoreLabel = Label(self.frame) self.scoreLabel.grid(row=0, column=1) self.gameButtons = GameButtons() self.field = self.gameButtons.getFields() self.buttonIds = [] fieldFiller = FieldFiller(self.field, self.buttonIds) self.gameController = GameController(self.scoreLabel, fieldFiller) for i in range(0, self.field.shape[0]): for j in range(0, self.field.shape[1]): for image in Images: if (self.gameButtons.getField(i, j) == image.getNumber()): self.originalImage = Image.open(image.getPath()) self.photoImage = ImageTk.PhotoImage( self.originalImage) self.button = Tk.Button( self.frame, image=self.photoImage, command=lambda i=i, j=j: self.gameController. buttonClicked(i, j), borderwidth=0, highlightthickness=0) self.button.image = self.photoImage self.buttonIds.append(self.button) self.button.grid(row=i + 1, column=j) fieldFiller.field = self.field fieldFiller.buttonIds = self.buttonIds
def get_newgame(level = 1): status.score = 0 status.level = level scene = Scene() model = GameModel(hud_offset=director.window.get_size()[0]-800) #MAGIC original width controller = GameController(model) # view hud = HUD() view = GameView(model, hud) # set controller in model model.set_controller(controller) # add controller scene.add(controller, z=1, name="controller") scene.add(hud, z=3, name="hud") scene.add(view, z=2, name="view") return scene
class Game: def __init__(self, size, init_fruits=None, init_pos=None, draw_settings=None, default_direction=Direction.LEFT): self.size = size self.game_controller = GameController(default_direction) if init_fruits is None: init_fruits = get_init_fruits(size) if init_pos is None: init_pos = get_init_pos(size) self.game_map = GameMap(size, init_fruits, init_pos) if draw_settings is None: draw_settings = DrawGameSettings() self.game_drawer = GameDrawer(self.game_map, draw_settings) def play(self, delay=0.4): while True: direction = self.game_controller.determine() try: self.game_map.move(direction) except CutYourselfException: raise GameOverException except BoundException: raise GameOverException time.sleep(delay) os.system('clear') self.game_drawer.draw()
def __init__(self): # # ─── DECLARE GAME SETTINGS ─────────────────────────────────────── # self.game_settings = {} self.game_settings['window_dimension'] = 720 self.game_settings['tile_dimension'] = 46 # # ─── CREATE ROOT WINDOW ────────────────────────────────────────── # self.root = Tk() self.root.title("Z-Sweeper") self.root.resizable(False, False) self.root.protocol("WM_DELETE_WINDOW", self.on_closing) while (True): # # ─── DISPLAY MAIN MENU AND POPULATE GAME SETTINGS ──────────────── # self.main_menu = MainMenu(self.root, self.game_settings) self.root.mainloop() # # ─── CREATE THE GAME BOARD ─────────────────────────────────────── # self.game_board = Board(self.game_settings['game_mode'], self.game_settings['game_difficulty'], self.game_settings['game_size']) self.game_controller = GameController(self.game_board) self.view = View(self.game_board, self.game_controller, self.root, self.game_settings) self.root.mainloop()
def main(): pygame.init() #Setting up the screen screen = pygame.display.set_mode(SCREEN_SIZE) pygame.display.set_caption('TOP DOWN SHOOTER') icon = pygame.image.load(ICON_FILE).convert() pygame.display.set_icon(icon) pygame.mouse.set_visible(False) clock = pygame.time.Clock() game_controller = GameController(SCREEN_SIZE) mouse_id = game_controller.add_entity(MouseCursor()) player_id = game_controller.add_entity(Player()) game_controller.add_entity(CircleCollide()) bullets = [] #main game loop running = True while running: clock.tick(FPS) #event catching for event in pygame.event.get(): if event.type == pygame.QUIT: running = False if event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: running = False #RUN CONTROLLER keys = pygame.key.get_pressed() mouse_btns = pygame.mouse.get_pressed() if mouse_btns[0]: add_bullet(bullets, game_controller, player_id) game_controller.control(keys, mouse_btns) game_controller.collide() game_controller.collide_walls() game_controller.apply_physics(clock.get_time()) player_to_mouse = pygame.mouse.get_pos( ) - game_controller.components['body'][player_id].position game_controller.components['body'][mouse_id].position = Vector2D( 0, 0) + pygame.mouse.get_pos() game_controller.components['body'][ player_id].rotation = player_to_mouse.angle_from_vector() #rendering screen.fill(BLACK) game_controller.render(screen) pygame.display.flip() pygame.quit()
from GameController import GameController import time controller = GameController() print("Select window to send keypresses to in 3 seconds") time.sleep(3) controller.set_window_to_focus() while True: controller.restart() time.sleep(0.25) controller.go_left() time.sleep(0.25) controller.stop() time.sleep(0.25) controller.go_right() time.sleep(0.25)
def main(): gameCont = GameController() #set up a game controller/ gameCont.playGame() #play the game.
""" main py file to run the game """ import sys import pygame sys.path.append('./Controller') sys.path.append('./Model') sys.path.append('./View') from MainController import MainController from GameController import GameController from GameView import GameView from MenuView import MenuView if __name__ == '__main__': GameController(GameView()) MainController(MenuView()).run() for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit()
from CompBot import CompBot from UserBot import UserBot from GameController import GameController userbot = UserBot() compbot = CompBot() gc = GameController(userbot, compbot) gc.play()
#!/usr/bin/env python3 import argparse from GameController import GameController PARSER = argparse.ArgumentParser() PARSER.add_argument("control_port", type=int, help="Communications port for Player 1 binding") PARSER.add_argument("client_port", type=int, help="Communications port for Player 1 binding") PARSER.add_argument("--private", help="Flag for private lobby", action='store_true') ARGS = PARSER.parse_args() game_controller = GameController(ARGS.control_port, ARGS.client_port, private=ARGS.private)
from GameController import GameController if __name__ == '__main__': gc = GameController() while True: gc.GetInput() gc.Draw() gc.Move() gc.Score()
__author__ = 'cjduffett' from GameController import GameController sizes = ["small", "large"] for size in sizes: G = GameController() G.readInputFile("A-" + size + "-practice.in") G.solve() G.writeOutputFile("A-" + size + "-practice.out") # for
def __init__(self): Thread.__init__(self) self.running = False self.controller = GameController(True, self.score_callback)
import discord import asyncio import sys from FilmFileHandler import FilmFileHandler from GameController import GameController fh = FilmFileHandler() if (sys.argv[1] == 'run'): client = discord.Client() films = fh.readSerializedFilms() gc = GameController(films) @client.event async def on_ready(): print('Logged in as') print(client.user.name) print(client.user.id) print('------') @client.event async def on_message(message): print("-------------------") print(message.author.name) if (message.channel.is_private): print("in private channel") else: print("in " + message.channel.server.name + ":" + message.channel.name) print("-------------------") print(message.content)
async def startGame(self, ctx, *args): voice = ctx.message.author.voice if voice == None: await ctx.send(':x: You must to be in a Voice Channel') return # if not gameController.playing: authorId = ctx.message.author.guild.id if self.bot.gcDict.get(authorId) is None: self.bot.gcDict[authorId] = gc.GameController() ctr = self.bot.gcDict.get(authorId) print(self.bot.gcDict) if len(args) > 0: if args[0] == "True": ctr.setFlash(True) elif args[0] == "False": ctr.setFlash(False) else: e = discord.Embed( title= ':x: Invalid argument, if you wanna play with Flash use ``!start-game True``', colour=discord.Colour(0xff3232)) await ctx.send("", embed=e) return await ctx.send( f'{ctx.message.author.name} has started a Carecaca Game') await ctx.send("Preparing room...") # members = ctx.message.guild.members guild = ctx.guild # Text Channels will agrupate in category 'Players' main_category = await guild.create_category_channel("Players") # Get the people in a voice channel and server id voice_channel = voice.channel members = voice_channel.members # Creating roles and assigm them to Player index = 0 playersMsg = "" for member in members: if member.name == "Carecaca-bot": continue # if member.status != discord.Status.offline: else: index += 1 role_name = "player-" + str(index) playersMsg += str(role_name) + ": " + \ str(member.name) + "\n" channel_name = role_name await self.create_role(ctx, member, guild, role_name, mentionable=True, colour=discord.Colour(0x09c48c)) await self.manage_text_channel(ctx, channel_name, "add", main_category) await self.set_permission_text_channel( ctx, channel_name, role_name, main_category) e = discord.Embed( title= ':white_check_mark: Room is ready, please join to your Text Channel\n' + 'Assigned rooms: \n' + playersMsg, colour=discord.Colour(0x09c48c)) await ctx.send('', embed=e) ctr.initGame() await self.msgStatus(ctx) else: await ctx.send(':x: There is a game already')
state.insert(6, 0) state.insert(7, 0) state.insert(8, 0) state.insert(9, 0) state.insert(10, 0) state.insert(11, 2) state.insert(12, 1) state.insert(13, 2) state.insert(14, 2) state.insert(15, 0) state.insert(16, 0) state.insert(17, 0) state.insert(18, -2) state.insert(19, -1) state.insert(20, -2) state.insert(21, -2) state.insert(22, 0) state.insert(23, 0) state.insert(24, 0) state.insert(25, 0) state.insert(26, 0) state.insert(27, 0) # 1 home state.insert(28, 0) # 1 jail state.insert(29, 9999) gc = GameController() #gc.setCustomBoardState(state, 1) gc.gameLoop()
class GameThread(Thread): def __init__(self): Thread.__init__(self) self.running = False self.controller = GameController(True, self.score_callback) def start(self): self.running = True super(GameThread, self).start() def run(self): lastFrameTime = time.time() result = None datared = 0 datablue = 0 datagreen = 0 while self.running: currentTime = time.time() dt = currentTime - lastFrameTime lastFrameTime = currentTime calibratedY = -1 # if not motion_thread.calibrating: datagreen = q_camera_read_green.get() if motion_thread.calibrating: databluetemp = q_camera_read_blue.get() dataredtemp = q_camera_read_red.get() if dataredtemp is not None: datared = dataredtemp if databluetemp is not None: datablue = databluetemp # else: # print "calibrated blue=" + str(datablue) + ", red=" + str(datared) if datagreen is not None and datablue is not None and datared is not None: print("red" + str(datared) + " blue" + str(datablue) + "green" + str(datagreen)) if datablue < 0: datablue = 0 if datagreen < datablue: datagreen = datablue if datagreen > datared: datagreen = datared datagreen -= datablue if (datared - datablue) > 0: calibratedY = 1 - (1 / (datared - datablue)) * datagreen self.controller.loop(dt, calibratedY) def cmdStart(self): motion_thread.calibrating = False self.controller.start() def cmdStop(self): self.controller.stop() def cmdReset(self): self.controller.reset() def score_callback(self, player): print "score_callback" if not q_spi_write.full(): print "queue not full" if player: print "putting in r queue" q_spi_write.put("r", block=False) else: print "putting in l queue" q_spi_write.put("l", block=False) else: print "queue full" def get_gamestate(self): return self.controller.get_gamestate() def shutdown(self): self.running = False self.controller.stop()
from GameController import GameController env = GameController() input_player1 = [None] * 4 input_player1[0] = 0 input_player1[1] = 0 input_player1[2] = 0 input_player1[3] = 0 input_player2 = [None] * 4 input_player2[0] = 7 input_player2[1] = 0 input_player2[2] = 0 input_player2[3] = 0 while (True): env.next_frame(input_player1, input_player2)
def run_game(self, player_config, hotseat): handle = GameController(self.presentation, GameAbstraction(), player_config, hotseat) return handle.play_game()
def main(): pygame.init() #Setting up the screen screen = pygame.display.set_mode(SCREEN_SIZE) pygame.display.set_caption('TOP DOWN SHOOTER') icon = pygame.image.load(ICON_FILE).convert() pygame.display.set_icon(icon) pygame.mouse.set_visible(False) clock = pygame.time.Clock() game_controller = GameController(SCREEN_SIZE) mouse_id = game_controller.add_entity(MouseCursor()) player_id = game_controller.add_entity(Player()) game_controller.add_entity(CircleCollide()) bullets = [] #main game loop running = True while running: clock.tick(FPS) #event catching for event in pygame.event.get(): if event.type == pygame.QUIT: running = False if event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: running = False #RUN CONTROLLER keys = pygame.key.get_pressed() mouse_btns = pygame.mouse.get_pressed() if mouse_btns[0]: add_bullet(bullets, game_controller, player_id) game_controller.control(keys, mouse_btns) game_controller.collide() game_controller.collide_walls() game_controller.apply_physics(clock.get_time()) player_to_mouse=pygame.mouse.get_pos()-game_controller.components['body'][player_id].position game_controller.components['body'][mouse_id].position = Vector2D(0, 0) + pygame.mouse.get_pos() game_controller.components['body'][player_id].rotation=player_to_mouse.angle_from_vector() #rendering screen.fill(BLACK) game_controller.render(screen) pygame.display.flip() pygame.quit()