def handle_events():
events = pc.get_events()
mouse_pos_x, mouse_pos_y = c_int(),c_int()
pc.SDL_GetMouseState(mouse_pos_x, mouse_pos_y)
MouseController.mouse_input(int(mouse_pos_x.value), int(mouse_pos_y.value))
for a in events:
if a.type == pc.SDL_QUIT:
game_framework.quit()
# ESC 게임 종료
if a.type == pc.SDL_KEYDOWN and a.key == pc.SDLK_ESCAPE:
import TitleScene
game_framework.change_state(TitleScene)
# 마우스 입력
if a.type == pc.SDL_MOUSEBUTTONDOWN and a.button == 1:
MouseController.interact_input(True)
#if a.type == pc.SDL_MOUSEMOTION:
# MouseController.mouse_input(a.x, a.y)
if a.type == pc.SDL_MOUSEBUTTONUP and a.button == 1:
MouseController.interact_input(False)
# 키보드 입력
if a.type == pc.SDL_KEYDOWN:
# print(a.key)
if a.key == 97: # a
KeyController.x -= 1
if KeyController.x < -1:
KeyController.x = -1
Player2.this.move_stair(Player2.KEY_A)
if a.key == 100: # d
KeyController.x += 1
if KeyController.x > 1:
KeyController.x = 1
Player2.this.move_stair(Player2.KEY_D)
if a.key == 115: # s
KeyController.interact_input(True)
Player2.this.move_stair(Player2.KEY_S)
if a.key == 119: # w
Player2.this.move_stair(Player2.KEY_W)
# 카메라 줌 확인용
if a.key == 61:
# View.views[0].cam.size += 0.5
Player2.this.is_die = True
if a.key == 45:
#View.views[0].cam.size -= 0.5
GameManager.game_end(GameManager.KEYUSER)
if a.type == pc.SDL_KEYUP:
if a.key == 97: # a
KeyController.x += 1
if a.key == 100: # d
KeyController.x -= 1
if a.key == 115: # s
KeyController.interact_input(False)
if GameManager.is_paused:
Player2.this.is_paused = True
def __init__(self):
self.IMAGE_HEIGHT = 30
self.IMAGE_WIDTH = 30
BOARD_SIZE = 100
BOARD_SIGMA = 10
self.channels = 3
self.game_list = []
output_size = 30
self.model = Model(self.IMAGE_HEIGHT, self.IMAGE_WIDTH, self.channels,
"Fred", output_size)
self.init_model = Model(self.IMAGE_HEIGHT, self.IMAGE_WIDTH,
self.channels, "Terry", output_size)
self.saved_batches = []
self.MAX_SAVED_BATCH_SIZE = 100
self.saved_batch_index = 1
self.need_reset = False
self.saved_batches_in_use = True
np.random.seed(33127436)
expansion_levels = (15, 18, 30)
self.expanders = []
for expansion_index in range(len(expansion_levels)):
if 0 == expansion_index:
self.expanders.append(
np.random.random_sample(
(expansion_levels[expansion_index], 11)))
else:
self.expanders.append(
np.random.random_sample(
(expansion_levels[expansion_index],
expansion_levels[expansion_index - 1])))
np.random.seed()
self.compressors = []
for expander in self.expanders[::-1]:
self.compressors.append(np.linalg.pinv(expander))
self.game = GameManager(BOARD_SIZE, BOARD_SIGMA)
class Environment:
def __init__(self):
self.game = GameManager(Config.ATARI_GAME, display=Config.PLAY_MODE)
self.current_state = None
self.total_reward = 0
self.reset()
@property
def action_shape(self):
return self.game.env.action_space.shape
@property
def obs_shape(self):
return self.game.env.observation_space.shape
@property
def name(self):
return self.game.env.spec._env_name
def reset(self):
self.total_reward = 0
self.current_state = self.game.reset()
def step(self, action):
observation, reward, done, _ = self.game.step(action)
self.current_state = observation
self.total_reward += reward
return reward, done
def test_GameManagerInputs(self):
"""
Tests GameManager input data prompter and respondents and GET abilities of those props
"""
gameManager = GameManager("Jonathan", ["Omar", "Joey", "Salekh"])
self.assertEqual((str==type(gameManager.get_prompter()[0])), True)
self.assertEqual((list==type(gameManager.get_respondents())), True)
def test_lobby_password(self):
game_manager = GameManager()
game_manager.create_lobby("TEST", password="******")
lobbies = game_manager.get_lobbies_list()
self.assertTrue(lobbies[0]["hasPassword"])
def check_collisions(self):
head_mag = self.get_head_pos()[0]
for obs in Obstacle.current_obstacles:
if obs.is_on_angle(self.y) and obs.get_max_magnitude(
self.y) > head_mag > obs.get_min_magnitude(self.y):
GameManager.game_over()
class Environment:
def __init__(self):
self.game = GameManager(Config.ATARI_GAME, display=Config.PLAY_MODE)
self.nb_frames = Config.STACKED_FRAMES
self.frame_q = Queue(maxsize=self.nb_frames)
self.previous_state = None
self.current_state = None
self.total_reward = 0
self.reset()
@staticmethod
def _rgb2gray(rgb):
return np.dot(rgb[..., :3], [0.299, 0.587, 0.114])
@staticmethod
def _preprocess(image):
image = Environment._rgb2gray(image)
image = misc.imresize(image, [Config.IMAGE_HEIGHT, Config.IMAGE_WIDTH],
'bilinear')
image = image.astype(np.float32) / 128.0 - 1.0
return image
def _get_current_state(self):
if not self.frame_q.full():
return None # frame queue is not full yet.
x_ = np.array(self.frame_q.queue)
x_ = np.transpose(x_, [1, 2, 0]) # move channels
return x_
def _update_frame_q(self, frame):
if self.frame_q.full():
self.frame_q.get()
image = Environment._preprocess(frame)
self.frame_q.put(image)
def get_num_actions(self):
# Updated with action space
return self.game.max_actions
def get_extended_action_space(self):
# Get extended action space
return self.game.acts
def reset(self):
self.total_reward = 0
self.frame_q.queue.clear()
self._update_frame_q(self.game.reset())
self.previous_state = self.current_state = None
def step(self, action):
observation, reward, done, _ = self.game.step(action)
self.total_reward += reward
self._update_frame_q(observation)
self.previous_state = self.current_state
self.current_state = self._get_current_state()
return reward, done
def setUp(self, mock_gm_app):
self.auto_clicker_1 = AutoClickers('Factory', 5.0, 15.0, 0)
self.auto_clicker_2 = AutoClickers('Farm', 10.0, 50.0, 3)
self.auto_clicker_3 = AutoClickers('House', 20.0, 100.0, 5)
self.game_manager = GameManager(auto_clickers=[
self.auto_clicker_1, self.auto_clicker_2, self.auto_clicker_3
])
self.game_manager.app = mock_gm_app
def test_lobby_password_encrypted(self):
game_manager = GameManager()
lobby_key = game_manager.create_lobby("TEST", password="******")
lobby: Lobby = game_manager.get_lobby(lobby_key)
self.assertNotEqual(lobby.password_encrypted, "test")
self.assertTrue(lobby.check_password_correct("test"))
def __init__(self):
self.game = GameManager(Config.DATA_FRAME, display=Config.PLAY_MODE)
# self.nb_frames = Config.STACKED_FRAMES
# self.frame_q = Queue(maxsize=self.nb_frames)
self.previous_state = None
self.current_state = None
self.total_reward = 0
self.reset()
def __init__(self):
self.game = GameManager()
self.nb_frames = Config.STACKED_FRAMES
self.frame_q = Queue(maxsize=self.nb_frames)
self.previous_state = None
self.current_state = None
self.total_reward = 0
self.reset()
class Environment:
def __init__(self, display=Config.SHOW_MODE):
self.game = GameManager(display=display)
self.previous_state = None
self.current_state = None
self.available = None
self.total_reward = 0
self.envs_mean = None
self.envs_std = None
self.num_steps = 0
self.state_mean = 0
self.state_std = 0
self.alpha = 0.9999
self.num_steps = 0
#self.reset()
def get_num_actions(self):
return self.game.get_num_actions()
def get_num_states(self):
return self.game.get_num_state()
def _observation(self, observation):
self.num_steps += 1
self.state_mean = self.state_mean * self.alpha + \
observation.mean() * (1 - self.alpha)
self.state_std = self.state_std * self.alpha + \
observation.std() * (1 - self.alpha)
unbiased_mean = self.state_mean / (1 - pow(self.alpha, self.num_steps))
unbiased_std = self.state_std / (1 - pow(self.alpha, self.num_steps))
return (observation - unbiased_mean) / (unbiased_std + 1e-8)
def reset(self):
self.total_reward = 0
observation, available = self.game.reset()
self.previous_state = self.current_state = None
self.current_state = process_frame(observation)
return self.current_state, available
def step(self, action):
observation, reward, done, available, envs_mean, envs_std = self.game.step(
action)
self.available = available
self.total_reward += reward
self.envs_mean = envs_mean
self.envs_std = envs_std
self.previous_state = self.current_state
self.current_state = process_frame(observation)
# self.current_state = self._observation(process_frame(observation))
return self.current_state, reward, done, available, envs_mean, envs_std
def test_lobby_create(self):
game_manager = GameManager()
lobby_key = game_manager.create_lobby("TEST")
lobbies = game_manager.get_lobbies_list()
self.assertTrue(len(lobbies) == 1)
self.assertEqual(lobbies[0]["key"], lobby_key)
self.assertEqual(lobbies[0]["name"], "TEST")
def main():
global player
print "Loading..."
pname = ""
# Load player data if exists
if os.path.isfile(playerDataFile):
with open(playerDataFile, 'rb') as d:
player = pickle.load(d)
if os.path.isfile(gameDataFile):
with open(gameDataFile, 'rb') as d:
board = pickle.load(d)
call(["clear"])
print "+" + "-" * 86 + "+"
print "| BBBB A TTTTTT TTTTTT LL EEEEE SSSSS HH HH IIIIII PPPPPP |"
print "| B B A A TT TT LL EE SSS HH HH II PP P |"
print "| B B AAAAA TT TT LL EEE SSS HHHHHH II PPPPPP |"
print "| B B AA AA TT TT LL EE SS HH HH II PP |"
print "| BBBB AA AA TT TT LLLLLL EEEEE SSSSS HH HH IIIIII PP |"
print "+" + "-" * 86 + "+\n"
if player == "":
print "Please create a player!"
name = raw_input("Your name > ")
player = Player(name)
with open('./.playerdata.bpydata', 'wb') as d:
pickle.dump(player, d)
manager = GameManager(player)
while True:
choice = mainMenu()
if choice == 1:
call(["clear"])
manager.play()
elif choice == 2:
call(["clear"])
print(player)
raw_input()
call(["clear"])
elif choice == 3:
player.setupPlayer()
manager.updatePlayer(player)
else:
player.save()
break
def test_gamemanager_query_get(self):
gameManager = GameManager("Jonathan", ["Omar", "Joey", "Salekh"])
q = gameManager.get_suggestions("dogfish")
# Check that the keys() of answers received correspond to the respondents
del q['Jonathan']
del q['if_valid']
self.assertEqual(sorted(q.keys()),sorted(gameManager.get_respondents()))
# Check to see if suggestions are shuffled:
p1, p2, p3 = q.keys()
self.assertEqual( (q[p1] != q[p2] != q[p3]), True)
def test_lobby_random_salt(self):
game_manager = GameManager()
all_keys = []
for i in range(10):
lobby_key = game_manager.create_lobby("TEST{}".format(i))
all_keys.append(lobby_key)
# remove duplicates with set, it should be equal
removed_duplicates = list(set(all_keys))
self.assertEqual(sorted(all_keys), sorted(removed_duplicates))
def game_loop():
manager = GameManager()
while manager.game_state != GameState.PAUSED:
# handle quit
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
manager.update()
def testRegisterUsers(self):
example = [[1 for i in range(10)] for j in range(10)]
hall = Hallway((14, 5), (20, 5), [])
zHall = Hallway((14, 14), (20, 10), [(17, 14), (17, 10)])
room = Room(example, (5, 5))
room2 = Room(example, (20, 5))
floor = Floor([room, room2], [hall, zHall])
game = GameState([floor])
gm = GameManager(game)
gm.register_player_user(self.LocalPlayer1)
gm.register_player_user(self.LocalPlayer2)
self.assertEqual(2, len(gm.ID_to_user_character))
def test_check_password_correct(self):
game_manager = GameManager()
lobby_key = game_manager.create_lobby("TEST", password="******")
lobby: Lobby = game_manager.get_lobby(lobby_key)
# password is encrypted
self.assertNotEqual(lobby.password_encrypted, "test")
# correct password is working and others are not
self.assertTrue(lobby.check_password_correct("test"))
self.assertFalse(lobby.check_password_correct("test1"))
self.assertFalse(lobby.check_password_correct("1234"))
def start_screen(window):
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
GameManager.close()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_p:
return
window.fill(0)
pygame.display.flip()
def main():
args = parse_arguments()
if args.Terminal:
game = GameManager()
game.start()
else:
game = Gui()
game.start()
game.stop()
class Environment:
def __init__(self):
self.game = GameManager(Config.ATARI_GAME, display=Config.PLAY_MODE)
self.nb_frames = Config.STACKED_FRAMES
self.frame_q = Queue(maxsize=self.nb_frames)
self.previous_state = None
self.current_state = None
self.total_reward = 0
self.reset()
@staticmethod
def _rgb2gray(rgb):
return np.dot(rgb[..., :3], [0.299, 0.587, 0.114])
@staticmethod
def _preprocess(image):
image = Environment._rgb2gray(image)
image = misc.imresize(image, [Config.IMAGE_HEIGHT, Config.IMAGE_WIDTH], 'bilinear')
image = image.astype(np.float32) / 128.0 - 1.0
return image
def _get_current_state(self):
if not self.frame_q.full():
return None # frame queue is not full yet.
x_ = np.array(self.frame_q.queue, dtype=np.float32)
return x_
def _update_frame_q(self, frame):
if self.frame_q.full():
self.frame_q.get()
image = Environment._preprocess(frame)
self.frame_q.put(image)
def get_num_actions(self):
return self.game.env.action_space.n
def reset(self):
self.total_reward = 0
self.frame_q.clear()
self._update_frame_q(self.game.reset())
self.previous_state = self.current_state = None
def step(self, action):
observation, reward, done, _ = self.game.step(action)
self.total_reward += reward
self._update_frame_q(observation)
self.previous_state = self.current_state
self.current_state = self._get_current_state()
return reward, done
class Environment:
def __init__(self):
self.game = GameManager(Config.SC2_MAP_NAME, image_size=Config.IMAGE_SIZE)
self.nb_frames = Config.STACKED_FRAMES
self.frame_q = Queue(maxsize=self.nb_frames)
self.previous_state = None
self.current_state = None
self.total_reward = 0
self.reset()
def _get_current_state(self):
if not self.frame_q.full():
raise Exception("Current state should not be None")
return None # frame queue is not full yet.
x_ = self.frame_q.queue[0]
return x_
def _update_frame_q(self, observation):
if self.frame_q.full():
self.frame_q.get()
# print (observation["screen"])
self.frame_q.put(observation)
def get_num_actions(self):
num_actions = dict()
num_actions["base_action"] = len(actions.FUNCTIONS)
for act_type in actions.TYPES:
if act_type.name in ("screen", "screen2", "minimap"):
num_actions[act_type.name] = (self.game.image_size, self.game.image_size)
else:
num_actions[act_type.name] = act_type.sizes[0]
return num_actions
def reset(self):
self.total_reward = 0
self.frame_q.queue.clear()
self._update_frame_q(self.game.reset())
self.previous_state = None
self.current_state = self._get_current_state()
def step(self, action):
observation, reward, done, _ = self.game.step(action)
self.total_reward += reward
# self._update_frame_q(observation)
self.previous_state = self.current_state.copy()
self.current_state = observation
return reward, done
def __init__(self, display=Config.SHOW_MODE):
self.game = GameManager(display=display)
self.previous_state = None
self.current_state = None
self.available = None
self.total_reward = 0
self.envs_mean = None
self.envs_std = None
self.num_steps = 0
self.state_mean = 0
self.state_std = 0
self.alpha = 0.9999
self.num_steps = 0
def test_lobby_random_salt(self):
game_manager = GameManager()
lobby_key1 = game_manager.create_lobby("TEST1", password="******")
lobby_key2 = game_manager.create_lobby("TEST2", password="******")
lobby1: Lobby = game_manager.get_lobby(lobby_key1)
lobby2: Lobby = game_manager.get_lobby(lobby_key2)
# each lobby has different salt, passwords are the same but encrypted values are not
self.assertNotEqual(lobby1.salt, lobby2.salt)
self.assertNotEqual(lobby1.password_encrypted,
lobby2.password_encrypted)
# both lobbies have same password
self.assertTrue(lobby1.check_password_correct("test"))
self.assertTrue(lobby2.check_password_correct("test"))
def __init__(self, discrete=True):
global locker
global global_port
locker.acquire(True)
this_port = global_port
global_port += 1
locker.release()
#self.client = AirSimClient(port=this_port)
#self.client.confirmConnection()
#self.client.enableApiControl(True)
#self.client.armDisarm(True)
self.log_file = open('logs.txt', 'w')
self.acc_file = open('accs.txt', 'w')
self.episodes = 0
self.fps = 60
self.max_iter = 15 * self.fps
self.t = np.matrix([10.0, 0.0, 0.0])
self.o = np.matrix([0.0, 0.0, 0.0])
self.c = np.matrix([0.0, 0.0, 0.0])
self.v = np.matrix([0.0, 0.0, 0.0])
self.v_t = np.matrix([0.0, 0.0, 0.0])
self.r = np.matrix([0.0, 0.0, 0.0])
self.queue_len = 4
self.coord_queue = None
self.width = 256
self.height = 144
self.image = None
self.iteration = 0
#self._render()
self.current_state = self._get_obs()
self.reset()
self.viewer = None
self.discrete = discrete
if self.discrete:
self.action_space = spaces.Discrete(27)
self.observation_space = spaces.Box(
low=np.zeros(self.current_state.shape),
high=np.zeros(self.current_state.shape) + 1)
else:
self.action_space = spaces.Box(-1, 1, shape=(4, ))
self.observation_space = spaces.Box(
low=np.zeros(self.current_state.shape),
high=np.zeros(self.current_state.shape) + 1)
self.current_state = None
self.nb_frames = Config.STACKED_FRAMES
self.frame_q = Queue(maxsize=self.nb_frames)
self.previous_state = None
self.current_state = None
self.total_reward = 0
self.game = GameManager('AirSim',
display=Config.PLAY_MODE,
custom_env=self)
self._seed()
def main():
"""
The condition will defined if you want start in terminal,
with the module GameManager or
with in graphic version with the module Gui.
To allow you to choose the version in shell,
a argument "-g" is adding for the graphic version.
"""
laby = Labyrinth('labyrinth.txt')
if args.gui:
gui = Gui(laby)
gui.launch_game()
else:
gamer = GameManager(laby)
gamer.launch_game()
def __init__(self, s_width, s_height, setup):
"""
Initialize the game starting in main menu
Args:
s_width (int): screen_width
s_width (int): screen_height
setup (Setup[]): list of setup options:
Desktop: default option. in this mode everything is controlled by keyboard
Arcade: prevents user from quiting the game from ui and changing key bindings
in this mode both the game and ui are controlled by joysticks
Windowed: default option. Uses s_width and s_height to determine screen dimensions
Fullscreen: ignores s_width and s_height args and enables fullscreen (duh)
"""
pygame.init()
pygame.font.init()
self.arcade = False
fullscreen = False
for opt in setup:
if opt == Setup.Arcade:
self.arcade = True
elif opt == Setup.Fullscreen:
fullscreen = True
self.joysticks = [
pygame.joystick.Joystick(x)
for x in range(pygame.joystick.get_count())
]
for j in self.joysticks:
j.init()
self.display = Display((s_width, s_height), fullscreen)
self.clock = pygame.time.Clock()
self.FPS = 60
self.ui = UI(self.display)
if self.arcade:
if len(self.joysticks) == 0:
print(
"=================== plug in the controller ==================="
)
exit(1)
self.ui.enable_arcade_mode()
self.selected_speed = "speed Medium"
self.game_manager = GameManager(self.display, self.ui,
GameMode.EatToGrow, GameState.Menu)
def test_create_room(self):
g = GameManager()
username = '******'
socket = 'socket'
g.create_room(username, socket)
self.assertEquals(socket in g.socket_to_room, True)
self.assertEquals(g.socket_to_username[socket], username)
reason = 'user is already a part of a room'
expected = (socket, {
'type': 'Created',
'room_name': g.socket_to_room[socket],
'usernames': [username],
'status': 'failed',
'reason': reason
})
self.assertEquals(g.create_room(username, socket), expected)
def test_GameManagerQueryGet():
"""
Here we test the GameManager get_suggestions method
We expect to see four answers (response from server) that are shuffled
If they are not shuffled answers we will throw an error.
"""
gameManager = GameManager("Jonathan", ["Omar", "Joey", "Salekh"])
q = gameManager.get_suggestions("dogfish")
# Check that the keys() of answers received correspond to the respondents
del q['Jonathan']
del q['if_valid']
assert (sorted(q.keys()) == sorted(gameManager.get_respondents()))
# Check to see if suggestions are shuffled:
p1, p2, p3 = q.keys()
assert (q[p1] != q[p2] != q[p3])
def make_objs():
global victory_img, background
background = DrawObj()
if GameManager.get_winning_player_idx() == GameManager.MOUSEUSER:
background.load_img("img/leewin.png")
else:
background.load_img("img/enemywin.png")
if GameManager.mouseuser_ui is not None:
victory_img = DrawObj()
if GameManager.get_winning_player_idx() == GameManager.MOUSEUSER:
victory_img.imgs = GameManager.mouseuser_ui.imgs
else:
victory_img.imgs = GameManager.keyuser_ui.imgs
background.pos = np.array(background.get_halfsize())
def __init__(self):
self.game = GameManager(Config.ATARI_GAME, display=Config.PLAY_MODE)
self.nb_frames = Config.STACKED_FRAMES
self.frame_q = Queue(maxsize=self.nb_frames)
self.previous_state = None
self.current_state = None
self.total_reward = 0
self.reset()
class Environment:
def __init__(self):
self.game = GameManager()
self.nb_frames = Config.STACKED_FRAMES
self.frame_q = Queue(maxsize=self.nb_frames)
self.previous_state = None
self.current_state = None
self.total_reward = 0
self.reset()
# @staticmethod
# def _rgb2gray(rgb):
# return np.dot(rgb[..., :3], [0.299, 0.587, 0.114])
#
# @staticmethod
# def _preprocess(image):
# image = Environment._rgb2gray(image)
# image = misc.imresize(image, [Config.IMAGE_HEIGHT, Config.IMAGE_WIDTH], 'bilinear')
# image = image.astype(np.float32) / 128.0 - 1.0
# return image
#
def _get_current_state(self):
# if not self.frame_q.full():
# return None # frame queue is not full yet.
# x_ = np.array(self.frame_q.queue)
# x_ = np.transpose(x_, [1, 2, 0]) # move channels
return self.game.env.getstate_3()
#
# def _update_frame_q(self, frame):
# if self.frame_q.full():
# self.frame_q.get()
# image = Environment._preprocess(frame)
# self.frame_q.put(image)
def get_num_actions(self):
return N_A
def reset(self):
self.total_reward = 0
self.frame_q.queue.clear()
#self._update_frame_q(self.game.reset())
self.previous_state = self.current_state = None
return self.game.env.getstate_3()
def step(self, action):
observation, reward, done = self.game.step(action)
self.total_reward += reward
#self._update_frame_q(observation)
self.previous_state = self.current_state
self.current_state = self._get_current_state()
return reward, done
def begin_game(self, level, cheat):
# To avoid the timer from beginning early
first_time = True
self.game_running = True
# Create the game manager
self.manager = GameManager(self, level, cheat)
# If we got shut off before we began (level error)
if not self.game_running:
return
# Press P to pause
self.pause = False
while self.game_running:
if first_time:
actual_tick = 0
first_time = False
self.clock.tick(60)
else:
actual_tick = self.clock.tick(60)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit(0)
if event.type == pygame.KEYDOWN:
if event.key == 32:
self.manager.player_shoot()
if event.key in [112, 80]:
self.pause = not self.pause
if not self.pause:
# Update the logical part
self.manager.update_elements(actual_tick)
if self.game_running:
# And the graphical part
self.update_graphics()
pygame.display.update()
class MatchingGame:
def __init__(self):
# Set up a clock for managing the frame rate.
self.clock = pygame.time.Clock()
self.game = GameManager()
self.game.startGame(4)
def set_paused(self, paused):
self.paused = paused
# Called to save the state of the game to the Journal.
def write_file(self, file_path):
pass
# Called to load the state of the game from the Journal.
def read_file(self, file_path):
pass
# The main game loop.
def run(self):
self.running = True
screen = pygame.display.get_surface()
while self.running:
# Pump PyGame messages.
for event in pygame.event.get():
if event.type == pygame.QUIT:
return
elif event.type == pygame.VIDEORESIZE:
pygame.display.set_mode(event.size, pygame.RESIZABLE)
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT:
self.direction = -1
elif event.key == pygame.K_RIGHT:
self.direction = 1
elif event.type == pygame.MOUSEBUTTONUP:
x, y = pygame.mouse.get_pos()
self.game.onClick(screen, x, y)
# Clear Display
screen.fill((128, 128, 128)) # 255 for white
self.game.draw(screen)
# Flip Display
pygame.display.flip()
# Try to stay at 30 FPS
self.clock.tick(30)
class GameWindow(object):
WIN_IMAGE = pygame.image.load("res/game_over/win.png")
LOSE_IMAGE = pygame.image.load("res/game_over/lose.png")
def __init__(self, parent):
# For drawing
self.screen = parent.screen
# To avoid having to make another button function
self.button = parent.make_button
# Runs at 60 FPS
self.clock = pygame.time.Clock()
# Font type of the enemy queue counter
self.type_font = pygame.font.SysFont("arial", 10)
def begin_game(self, level, cheat):
# To avoid the timer from beginning early
first_time = True
self.game_running = True
# Create the game manager
self.manager = GameManager(self, level, cheat)
# If we got shut off before we began (level error)
if not self.game_running:
return
# Press P to pause
self.pause = False
while self.game_running:
if first_time:
actual_tick = 0
first_time = False
self.clock.tick(60)
else:
actual_tick = self.clock.tick(60)
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit(0)
if event.type == pygame.KEYDOWN:
if event.key == 32:
self.manager.player_shoot()
if event.key in [112, 80]:
self.pause = not self.pause
if not self.pause:
# Update the logical part
self.manager.update_elements(actual_tick)
if self.game_running:
# And the graphical part
self.update_graphics()
pygame.display.update()
def update_graphics(self):
# Draw the game area background
pygame.draw.rect(self.screen, (124, 124, 124), (0, 0, 640, 576))
# The enemy queue counter
pygame.draw.rect(self.screen, (206, 174, 125), (640, 0, 160, 576))
# And a button to return to the main menu
self.button("Main menu", (640, 526, 160, 50), ((42, 120, 35), (27, 77, 23)), funcion=self.return_menu)
# We ask the manager for the elements
elements = self.manager.elements
for block in elements["blocks"]:
self.screen.blit(block.image, block.rect)
for hole in elements["holes"]:
self.screen.blit(hole.image, hole.rect)
for enemy in elements["enemies"]:
self.screen.blit(enemy.image, enemy.rect)
self.screen.blit(elements["player"].image, elements["player"].rect)
self.screen.blit(elements["heart"].image, elements["heart"].rect)
for explosion in elements["explosions"]:
self.screen.blit(explosion.image, explosion.rect)
for bala in elements["bullets"]:
self.screen.blit(bala.image, bala.rect)
self.update_counter()
def game_over(self, we_won):
if we_won:
self.screen.blit(self.WIN_IMAGE, (0,0))
else:
self.screen.blit(self.LOSE_IMAGE, (0,0))
pygame.display.update()
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
exit(0)
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_RETURN:
self.return_menu()
running = False
def return_menu(self):
self.game_running = False
def update_counter(self):
self.enemies = self.manager.enemy_count()
self.screen.blit(self.type_font.render("Enemies left on queue", 1, (0,0,0)), (645, 10))
self.screen.blit(self.type_font.render("Weak: {}".format(self.enemies[0]), 1, (0,0,0)), (650, 30))
self.screen.blit(self.type_font.render("Med: {}".format(self.enemies[1]), 1, (0,0,0)), (650, 50))
self.screen.blit(self.type_font.render("Strong: {}".format(self.enemies[2]), 1, (0,0,0)), (650, 70))
def __init__(self):
# Set up a clock for managing the frame rate.
self.clock = pygame.time.Clock()
self.game = GameManager()
self.game.startGame(4)
class GraphicBoard(QtGui.QWidget):
push_letter_first = QtCore.Signal(Coordinates)
push_letter_second = QtCore.Signal(Coordinates)
choose_letter_first = QtCore.Signal(CellLetter)
choose_letter_second = QtCore.Signal(CellLetter)
commit_word_first = QtCore.Signal()
commit_word_second = QtCore.Signal()
quit = QtCore.Signal()
give_up_first = QtCore.Signal()
give_up_second = QtCore.Signal()
def __init__(self, width, height, parent):
super(GraphicBoard, self).__init__()
self.__width__ = width
self.__height__ = height
self.__language__ = None
lang_list = ['Russian', 'English']
game_lang, flag2 = QtGui.QInputDialog.getItem(self, 'Choose language of the game', 'Выберите язык игры', lang_list)
if game_lang == 'Russian':
self.__language__ = RussianLanguage()
else:
self.__language__ = EnglishLanguage()
self.table_layout = QtGui.QGridLayout()
self.buttons = list()
for i in range(height):
tmp_button_list = list()
for j in range(width):
tmp_button = ButtonCell(self.__language__)
tmp_button.connect_to_panel(self)
self.table_layout.addWidget(tmp_button, i, j)
tmp_button_list.append(tmp_button)
self.buttons.append(tmp_button_list)
self.game_panel = QtGui.QHBoxLayout()
self.game_board_panel = QtGui.QVBoxLayout()
self.game_board_panel.addLayout(self.table_layout)
self.word_panel = QtGui.QHBoxLayout()
self.current_word = QtGui.QLabel('')
self.commit_button = QtGui.QPushButton('Enter!')
self.commit_give_up = QtGui.QPushButton('Give up')
self.word_panel.addWidget(self.commit_give_up)
self.word_panel.addWidget(self.current_word)
self.word_panel.addWidget(self.commit_button)
self.game_board_panel.addLayout(self.word_panel)
self.first_player_score = QtGui.QLabel('0', self)
self.first_player_words = QtGui.QListWidget(self)
self.first_player_panel = QtGui.QVBoxLayout()
self.first_player_panel.addWidget(self.first_player_score)
self.first_player_panel.addWidget(self.first_player_words)
self.second_player_score = QtGui.QLabel('0', self)
self.second_player_words = QtGui.QListWidget(self)
self.second_player_panel = QtGui.QVBoxLayout()
self.second_player_panel.addWidget(self.second_player_score)
self.second_player_panel.addWidget(self.second_player_words)
self.game_panel.addLayout(self.first_player_panel)
self.game_panel.addLayout(self.game_board_panel)
self.game_panel.addLayout(self.second_player_panel)
self.setLayout(self.game_panel)
players, flag = QtGui.QInputDialog.getInt(self, 'Enter number of players', 'Введите число игроков', 1, 1, 2)
if players == 2:
self.__game_manager__ = GameManager(self.__language__, width=width, height=height, players_number=players)
else:
list_levels = ['EASY', 'MEDIUM', 'HARD', 'HARDEST']
level = QtGui.QInputDialog.getItem(self, 'Choose level', 'Выберите сложность', list_levels)
self.__game_manager__ = GameManager(self.__language__, width, height, players, level[0])
self.connect_to_players(self.__game_manager__.get_first_player(),
self.__game_manager__.get_second_player())
self.__game_manager__.get_first_player().connect_to_interface(self)
self.__game_manager__.get_second_player().connect_to_interface(self)
word = self.__game_manager__.get_first_word()
for i in range(width):
self.buttons[height//2][i].setText(word[i])
self.buttons[height//2][i].setMenu(None)
self.commit_button.clicked.connect(self.on_commit_button_clicked)
self.commit_give_up.clicked.connect(self.on_commit_give_up_clicked)
self.__game_manager__.game_ended.connect(self.finish_game)
self.quit.connect(parent.reset_field)
@QtCore.Slot()
def on_cell_pushed(self):
x_sender = 0
y_sender = 0
for i in range(self.__height__):
for j in range(self.__width__):
if self.sender() == self.buttons[i][j]:
x_sender = i
y_sender = j
send_letter = Coordinates(x_sender, y_sender)
if self.__game_manager__.get_current_player() == 1:
self.push_letter_first.emit(send_letter)
else:
self.push_letter_second.emit(send_letter)
@QtCore.Slot(str)
def on_cell_chosen(self, letter):
x_sender = 0
y_sender = 0
for i in range(self.__height__):
for j in range(self.__width__):
if self.sender() == self.buttons[i][j]:
x_sender = i
y_sender = j
send_letter = CellLetter(x_sender, y_sender, letter)
if self.__game_manager__.get_current_player() == 1:
self.choose_letter_first.emit(send_letter)
else:
self.choose_letter_second.emit(send_letter)
@QtCore.Slot(Coordinates)
def after_cell_pushed(self, coordinates: Coordinates):
self.current_word.setText(self.current_word.text() +
self.buttons[coordinates.x][coordinates.y].text())
@QtCore.Slot(CellLetter)
def after_cell_chosen(self, coordinates: CellLetter):
self.buttons[coordinates.x][coordinates.y].setMenu(None)
self.buttons[coordinates.x][coordinates.y].setText(coordinates.letter)
@QtCore.Slot(str)
def after_word_committed(self, word):
self.current_word.setText(None)
if self.sender() == self.__game_manager__.get_first_player():
self.first_player_words.addItem(word)
score = self.__game_manager__.get_first_player().get_score()
self.first_player_score.setText(str(score))
else:
self.second_player_words.addItem(word)
score = self.__game_manager__.get_second_player().get_score()
self.second_player_score.setText(str(score))
self.run_step()
@QtCore.Slot(Coordinates)
def on_player_reset_word(self, coordinates: Coordinates):
self.buttons[coordinates.x][coordinates.y].create_menu()
self.buttons[coordinates.x][coordinates.y].setText('')
self.current_word.setText('')
@QtCore.Slot()
def on_commit_button_clicked(self):
if self.__game_manager__.get_current_player() == 1:
self.commit_word_first.emit()
else:
self.commit_word_second.emit()
@QtCore.Slot()
def on_commit_give_up_clicked(self):
if self.__game_manager__.get_current_player() == 1:
self.give_up_first.emit()
else:
self.give_up_second.emit()
@QtCore.Slot(str)
def finish_game(self, message):
box = QtGui.QMessageBox(self)
box.setText(message)
ok_button = box.addButton(QtGui.QMessageBox.Ok)
box.exec_()
if box.clickedButton() == ok_button:
self.quit.emit()
def connect_to_players(self, player1: Player, player2: Player):
self.choose_letter_first.connect(player1.on_letter_chosen)
self.push_letter_first.connect(player1.on_letter_pushed)
self.choose_letter_second.connect(player2.on_letter_chosen)
self.push_letter_second.connect(player2.on_letter_pushed)
self.commit_word_first.connect(player1.on_word_committed)
self.commit_word_second.connect(player2.on_word_committed)
self.give_up_first.connect(player1.send_end)
self.give_up_second.connect(player2.send_end)
def run_step(self):
self.__game_manager__.run_game()
def __init__(self, width, height, parent):
super(GraphicBoard, self).__init__()
self.__width__ = width
self.__height__ = height
self.__language__ = None
lang_list = ['Russian', 'English']
game_lang, flag2 = QtGui.QInputDialog.getItem(self, 'Choose language of the game', 'Выберите язык игры', lang_list)
if game_lang == 'Russian':
self.__language__ = RussianLanguage()
else:
self.__language__ = EnglishLanguage()
self.table_layout = QtGui.QGridLayout()
self.buttons = list()
for i in range(height):
tmp_button_list = list()
for j in range(width):
tmp_button = ButtonCell(self.__language__)
tmp_button.connect_to_panel(self)
self.table_layout.addWidget(tmp_button, i, j)
tmp_button_list.append(tmp_button)
self.buttons.append(tmp_button_list)
self.game_panel = QtGui.QHBoxLayout()
self.game_board_panel = QtGui.QVBoxLayout()
self.game_board_panel.addLayout(self.table_layout)
self.word_panel = QtGui.QHBoxLayout()
self.current_word = QtGui.QLabel('')
self.commit_button = QtGui.QPushButton('Enter!')
self.commit_give_up = QtGui.QPushButton('Give up')
self.word_panel.addWidget(self.commit_give_up)
self.word_panel.addWidget(self.current_word)
self.word_panel.addWidget(self.commit_button)
self.game_board_panel.addLayout(self.word_panel)
self.first_player_score = QtGui.QLabel('0', self)
self.first_player_words = QtGui.QListWidget(self)
self.first_player_panel = QtGui.QVBoxLayout()
self.first_player_panel.addWidget(self.first_player_score)
self.first_player_panel.addWidget(self.first_player_words)
self.second_player_score = QtGui.QLabel('0', self)
self.second_player_words = QtGui.QListWidget(self)
self.second_player_panel = QtGui.QVBoxLayout()
self.second_player_panel.addWidget(self.second_player_score)
self.second_player_panel.addWidget(self.second_player_words)
self.game_panel.addLayout(self.first_player_panel)
self.game_panel.addLayout(self.game_board_panel)
self.game_panel.addLayout(self.second_player_panel)
self.setLayout(self.game_panel)
players, flag = QtGui.QInputDialog.getInt(self, 'Enter number of players', 'Введите число игроков', 1, 1, 2)
if players == 2:
self.__game_manager__ = GameManager(self.__language__, width=width, height=height, players_number=players)
else:
list_levels = ['EASY', 'MEDIUM', 'HARD', 'HARDEST']
level = QtGui.QInputDialog.getItem(self, 'Choose level', 'Выберите сложность', list_levels)
self.__game_manager__ = GameManager(self.__language__, width, height, players, level[0])
self.connect_to_players(self.__game_manager__.get_first_player(),
self.__game_manager__.get_second_player())
self.__game_manager__.get_first_player().connect_to_interface(self)
self.__game_manager__.get_second_player().connect_to_interface(self)
word = self.__game_manager__.get_first_word()
for i in range(width):
self.buttons[height//2][i].setText(word[i])
self.buttons[height//2][i].setMenu(None)
self.commit_button.clicked.connect(self.on_commit_button_clicked)
self.commit_give_up.clicked.connect(self.on_commit_give_up_clicked)
self.__game_manager__.game_ended.connect(self.finish_game)
self.quit.connect(parent.reset_field)
