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()
