def __init__(self):
super(Asteroids, self).__init__()
self.ship = Ship(GameEngine.display_width / 2, GameEngine.display_height / 2)
self.asteroids = []
self.time = 0
self.score = 0
GameEngine.change_caption("Asteroids")
def __init__(self):
super(Snake, self).__init__()
self.snake = [[19, 15], [20, 15], [20, 15], [20, 15]]
self.direction = 180
self.apple = Apple()
self.score = 0
GameEngine.change_mode(640, 480)
GameEngine.change_caption("Snake")
def new_game():
print 'new game'
new_game_engine = GameEngine()
new_game_engine.gen_new_word()
new_definition = new_game_engine.word_obj.definition
session.attributes["game_engine"] = jsonpickle.encode(new_game_engine)
return question("This is a new game. The first definition is...... " +
new_definition)
def new_game():
""" Start a new game, if the user is authenticated. """
if 'user_id' not in session:
return redirect(url_for('index'))
user_id = session['user_id']
game_builder = GameBuilder(g.database_service).for_user(user_id)
# TODO Maybe programatically pick a game to play
player_id = save_internet_game(game_builder)
session['player_id'] = player_id
game_engine = GameEngine(g.database_service, player_id)
return jsonify(prompt=game_engine.prompt())
def draw(self):
GameEngine.game_display.fill((0, 0, 0))
GameEngine.game_display.blit(utils.rot_center(self.ship.image, self.ship.angle),
(self.ship.rect.x, self.ship.rect.y))
for bullet in self.ship.bullets:
GameEngine.game_display.blit(bullet.image, (bullet.rect.x, bullet.rect.y))
for asteroid in self.asteroids:
GameEngine.game_display.blit(
pygame.transform.scale(asteroid.image, (25 * asteroid.size, 25 * asteroid.size)),
(asteroid.rect.x, asteroid.rect.y))
GameEngine.display_data(100, 20, self.score, GameEngine.font, (255, 255, 255))
super().draw()
def step_game():
""" Take one step through the game. """
if 'player_id' not in session:
return redirect(url_for('index'))
game_engine = GameEngine(g.database_service, session['player_id'])
if game_engine.game_is_over():
return jsonify(prompt='You beat the game!')
user_input = request.form['userInput']
result = game_engine.step(user_input)
if game_engine.game_is_over():
return jsonify(prompt=result + '\nCongrats, you fulfilled the objective!')
return jsonify(prompt=result)
def main():
modes = {
'cheater': False
}
if len(argv) > 1:
for arg in argv:
if arg == '--cheater':
modes['cheater'] = True
ge = GameEngine(modes)
while 1:
if ge.handle_events() == -1:
return
ge.do_play()
def handle_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
GameEngine.quit()
keypresses = pygame.key.get_pressed()
if keypresses[pygame.K_UP] != 0:
if self.direction != 90:
self.direction = -90
if keypresses[pygame.K_LEFT] != 0:
if self.direction != 0:
self.direction = 180
if keypresses[pygame.K_RIGHT] != 0:
if self.direction != 180:
self.direction = 0
if keypresses[pygame.K_DOWN] != 0:
if self.direction != -90:
self.direction = 90
def handle_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
GameEngine.quit()
keypresses = pygame.key.get_pressed()
if keypresses[pygame.K_LEFT] != 0:
self.ship.angle = (self.ship.angle + 5) % 360
if keypresses[pygame.K_RIGHT] != 0:
self.ship.angle = (self.ship.angle - 5) % 360
if keypresses[pygame.K_UP] != 0:
self.ship.acceleration = 6
if self.ship.firing == 0 and keypresses[pygame.K_SPACE] != 0:
self.ship.firing = 4
self.ship.bullets.append(Bullet(self.ship.rect.x + 15, self.ship.rect.y + 17, self.ship.angle))
if self.ship.warp == 0 and (keypresses[pygame.K_LSHIFT] != 0 or keypresses[pygame.K_RSHIFT] != 0):
self.ship.warp = 20
self.ship.rect.x = random.randint(0, GameEngine.display_width)
self.ship.rect.y = random.randint(0, GameEngine.display_height)
def main():
image = None
n = None
if len(argv) == 3:
for i in range(1, 3):
if argv[i][:4] == '--n=':
n = argv[i][4:]
else:
image = argv[i]
if (image is None) or (n is None):
print "usage: pyzzle --n=<number> image_file"
exit()
ge = GameEngine(image, n)
while 1:
if ge.handle_events() == -1:
return
ge.do_play()
def evaluate(self, n_playout):
'''
Evaluate AI model
'''
player = EvaluationPlayer(ai=self.ai)
if self.verbose:
starttime = time.time()
print("Evaluating...", end="")
scores = list()
for i in range(n_playout):
gameengine = GameEngine(Nx=self.Nx,
Ny=self.Ny,
player=player,
timeperiod=0.5,
is_selfplay=False)
gameengine.start()
while gameengine.update():
pass
score = gameengine.get_score()
scores.append(score)
score = np.mean(scores)
if self.verbose:
endtime = time.time()
print("End: Run Time {0:.2f}s".format(endtime - starttime))
return score
def start(self):
'''
Start a game for AI model
'''
n_mcts = 1000
if self.verbose:
starttime = time.time()
print("Self-playing...", end="")
gameengine = GameEngine(Nx=self.Nx,
Ny=self.Ny,
player=self.player,
timeperiod=0.5,
is_selfplay=True)
gameengine.start()
while gameengine.update():
pass
if self.verbose:
endtime = time.time()
print("End: Run Time {0:.2f}s".format(endtime - starttime))
data = gameengine.get_data()
data = self.__geometry_operators(data)
return data
def update(self):
gameover = False
self.score = len(self.snake) - 4
for index, s in enumerate(self.snake[-1:0:-1]):
s[0], s[1] = [
self.snake[len(self.snake) - 2 - index][0],
self.snake[len(self.snake) - 2 - index][1]
]
self.snake[0][0] += int(math.cos(math.radians(self.direction)))
self.snake[0][1] += int(math.sin(math.radians(self.direction)))
if self.snake[0] == [self.apple.x, self.apple.y]:
self.snake.append([self.snake[-1][0], self.snake[-1][1]])
self.apple.reseed(self.snake)
for s in self.snake[1:]:
if s == self.snake[0]:
gameover = True
if 0 <= self.snake[0][0] < 40 and 0 <= self.snake[0][1] < 30:
pass
else:
gameover = True
if gameover == True:
GameEngine.display_data(320, 220, "Game Over!", GameEngine.font,
(255, 255, 255))
super().draw()
time.sleep(1)
GameEngine.display_data(320, 260 + 20,
"Your score was: " + str(self.score),
GameEngine.font, (255, 255, 255))
super().draw()
time.sleep(2)
self.exit()
GameEngine.change_state(games.menu.Menu())
super().update(15)
def draw(self):
GameEngine.game_display.fill((0, 0, 0))
GameEngine.display_data(400, 125, "Classic Games in Python",
GameEngine.font, (255, 255, 255))
GameEngine.display_data(400, 400, "Asteroids", GameEngine.font,
(255, 255, 255))
GameEngine.display_data(400, 440, "Snake", GameEngine.font,
(255, 255, 255))
super().draw()
def handle_events(self):
pos = (0, 0)
for event in pygame.event.get():
if event.type == pygame.QUIT:
GameEngine.quit()
if event.type == pygame.MOUSEBUTTONUP:
pos = pygame.mouse.get_pos()
if 360 < pos[0] < 440 and 395 < pos[1] < 405:
GameEngine.change_state(games.asteroids.Asteroids())
elif 360 < pos[0] < 440 and 435 < pos[1] < 445:
GameEngine.change_state(games.snake.Snake())
def setUp(self):
self.database = FakeDatabaseService()
self.test_room = Room('The Test Room',
'In this room, you see a Pythonista writing unittest test cases',
id=2)
self.production_room = Room('The Production Room',
'You see a production server running a web app', id=5)
self.player_id = 6
self.test_exit = Exit(name='West',
description='The west exit', from_room=self.test_room.get_id(),
to_room=self.production_room.get_id(), locked=False, id=7)
self.test_item = ExitUnlockingItem(name='TPS Report',
description='A testing specification',
use_message='You read the report',
owned_by_player=None,
in_room=self.test_room.get_id(),
locked=False, unlocks_exit=7, id=9)
self.game_engine = GameEngine(self.database, self.player_id)
def exit(self):
GameEngine.change_mode(GameEngine.display_width,
GameEngine.display_height)
GameEngine.change_caption("Classic Games in Python")
def new_session():
engine = GameEngine()
engine.gen_new_word()
session.attributes["game_engine"] = jsonpickle.encode(engine)
print "session started"
def draw(self):
GameEngine.game_display.fill((0, 0, 0))
GameEngine.display_data(400, 125, "Game Engine", GameEngine.font,
(255, 255, 255))
super().draw()
def handle_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
GameEngine.quit()
class GameEngineTest(unittest.TestCase):
def setUp(self):
self.database = FakeDatabaseService()
self.test_room = Room('The Test Room',
'In this room, you see a Pythonista writing unittest test cases',
id=2)
self.production_room = Room('The Production Room',
'You see a production server running a web app', id=5)
self.player_id = 6
self.test_exit = Exit(name='West',
description='The west exit', from_room=self.test_room.get_id(),
to_room=self.production_room.get_id(), locked=False, id=7)
self.test_item = ExitUnlockingItem(name='TPS Report',
description='A testing specification',
use_message='You read the report',
owned_by_player=None,
in_room=self.test_room.get_id(),
locked=False, unlocks_exit=7, id=9)
self.game_engine = GameEngine(self.database, self.player_id)
def test_prompt_for_player(self):
self.database.stub_add_player_occupied_room(self.player_id, self.test_room)
prompt = self.game_engine.prompt()
self.assertTrue(self.test_room.get_name() in prompt)
def add_test_room_and_test_exit(self):
self.database.stub_add_player_occupied_room(self.player_id, self.test_room)
self.database.stub_add_room_exit(self.test_room.get_id(), self.test_exit)
def test_exits_displayed(self):
self.add_test_room_and_test_exit()
prompt = self.game_engine.prompt()
self.assertTrue(self.test_exit.get_name() in prompt)
def test_items_displayed(self):
self.add_test_room_and_test_exit()
self.database.stub_add_item_to_room(self.test_item, self.test_room.get_id())
prompt = self.game_engine.prompt()
self.assertTrue(self.test_item.get_name() in prompt)
def test_possible_actions_displays_exit(self):
self.add_test_room_and_test_exit()
actions = self.game_engine.possible_actions()
exit_actions = [action for action in actions if 'exit' in action]
self.assertEquals(1, len(exit_actions))
self.assertTrue(self.test_exit.get_name() in exit_actions[0])
def test_possible_actions_displays_items_that_the_player_has(self):
self.add_test_room_and_test_exit()
self.database.stub_add_item_to_player(self.test_item, self.player_id)
actions = self.game_engine.possible_actions()
item_actions = [action for action in actions if 'use' in action]
self.assertEquals(1, len(item_actions))
item_action = item_actions[0]
self.assertTrue(self.test_item.get_name() in item_action)
def add_test_room_exit_and_item_to_room(self):
self.add_test_room_and_test_exit()
self.database.stub_add_item_to_room(self.test_item, self.test_room.get_id())
def test_possible_actions_displays_takeable_items(self):
self.add_test_room_exit_and_item_to_room()
actions = self.game_engine.possible_actions()
take_actions = [action for action in actions if 'take' in action]
self.assertEquals(1, len(take_actions))
take_action = take_actions[0]
self.assertTrue(self.test_item.get_name() in take_action)
def test_step_move_through_exit_changes_room(self):
self.add_test_room_and_test_exit()
self.database.stub_add_room(self.production_room)
self.game_engine.step('exit ' + self.test_exit.get_name())
self.assertEquals(self.production_room.get_id(),
self.database.players_to_room_ids[self.player_id])
def test_step_does_not_change_room_if_exit_locked(self):
self.test_exit.locked = True
self.add_test_room_and_test_exit()
self.game_engine.step('exit ' + self.test_exit.get_name())
self.assertEquals(self.test_room.get_id(),
self.database.players_to_rooms[self.player_id].get_id())
def test_step_take_item(self):
self.add_test_room_exit_and_item_to_room()
self.game_engine.step('take ' + self.test_item.get_name())
self.assertTrue(self.test_item not in \
self.database.rooms_to_items[self.test_room.get_id()])
self.assertTrue(self.test_item in \
self.database.players_to_items[self.player_id])
def test_step_take_item_does_nothing_if_item_doesnt_exist(self):
self.add_test_room_exit_and_item_to_room()
self.game_engine.step('take NonExistentItem')
self.assertTrue(self.test_item in \
self.database.rooms_to_items[self.test_room.get_id()])
self.assertFalse('NonExistentItem' in \
self.database.players_to_items[self.player_id])
def test_step_use_item_to_unlock_exit(self):
self.add_test_room_exit_and_item_to_room()
# self.test_item is set in setUp to unlock self.test_exit
self.test_exit.locked = True
self.game_engine.step('take ' + self.test_item.get_name())
self.game_engine.step('use ' + self.test_item.get_name())
self.assertFalse(self.test_exit.locked)
self.assertTrue(self.test_item not in \
self.database.players_to_items[self.player_id])
def test_step_use_item_fails_if_nothing_to_unlock(self):
self.add_test_room_exit_and_item_to_room()
self.test_exit.locked = True
self.test_item.unlocks_exit = 45 # Not self.test_exit
self.game_engine.step('take ' + self.test_item.get_name())
self.game_engine.step('use ' + self.test_item.get_name())
self.assertTrue(self.test_exit.locked)
self.assertTrue(self.test_item in \
self.database.players_to_items[self.player_id])
def test_step_use_item_to_unlock_item(self):
self.add_test_room_exit_and_item_to_room()
self.test_item.locked = True
key = ItemUnlockingItem(
name='Key to the TPS report drawer',
description='A metal key',
use_message='You put the key in the lock and turned it',
owned_by_player=None,
in_room=self.test_room.get_id(),
locked=False,
unlocks_item=self.test_item.get_id(),
id=19)
self.database.stub_add_item_to_room(key, self.test_room.get_id())
self.game_engine.step('take ' + key.get_name())
self.game_engine.step('use ' + key.get_name())
self.assertFalse(self.test_item.locked)
def exit(self):
GameEngine.change_caption("Classic Games in Python")
def update(self):
self.ship.rect.x -= self.ship.acceleration * math.sin(math.radians(self.ship.angle))
self.ship.rect.y -= self.ship.acceleration * math.cos(math.radians(self.ship.angle))
self.ship.acceleration = max(self.ship.acceleration - .1, 0)
self.ship.warp = max(self.ship.warp - .5, 0)
self.ship.firing = max(self.ship.firing - .5, 0)
if self.ship.rect.x > GameEngine.display_width:
self.ship.rect.x = 0
if self.ship.rect.x < 0:
self.ship.rect.x = GameEngine.display_width
if self.ship.rect.y > GameEngine.display_height:
self.ship.rect.y = 0
if self.ship.rect.y < 0:
self.ship.rect.y = GameEngine.display_height
if random.randint(0, 100) > 97:
if random.random() > 0.5:
if random.random() > 0.5:
self.asteroids.append(
Asteroid(0, random.randint(0, GameEngine.display_height), random.randint(0, 360), 3))
else:
self.asteroids.append(
Asteroid(GameEngine.display_width, random.randint(0, GameEngine.display_height),
random.randint(0, 360), 3))
else:
if random.random() > 0.5:
self.asteroids.append(
Asteroid(random.randint(0, GameEngine.display_width), 0, random.randint(0, 360), 3))
else:
self.asteroids.append(
Asteroid(random.randint(0, GameEngine.display_width), GameEngine.display_height,
random.randint(0, 360), 3))
for bullet in self.ship.bullets:
bullet.rect.x -= 9 * math.sin(math.radians(bullet.angle))
bullet.rect.y -= 9 * math.cos(math.radians(bullet.angle))
if bullet.rect.x < 0 or bullet.rect.x > GameEngine.display_width:
self.ship.bullets.remove(bullet)
elif bullet.rect.y < 0 or bullet.rect.y > GameEngine.display_height:
self.ship.bullets.remove(bullet)
else:
for asteroid in self.asteroids:
if abs(bullet.rect.x - asteroid.rect.x) < 12.5 * asteroid.size and abs(
bullet.rect.y - asteroid.rect.y) < 12.5 * asteroid.size:
self.score = int(self.score + 300 / asteroid.size)
try:
self.asteroids.remove(asteroid)
except ValueError:
pass
try:
self.ship.bullets.remove(bullet)
except ValueError:
pass
if asteroid.size > 1:
self.asteroids += [
Asteroid(asteroid.rect.x, asteroid.rect.y, random.randint(0, 360), asteroid.size - 1),
Asteroid(asteroid.rect.x, asteroid.rect.y, random.randint(0, 360), asteroid.size - 1)]
for asteroid in self.asteroids:
asteroid.rect.x -= 4 / asteroid.size * math.sin(math.radians(asteroid.angle))
asteroid.rect.y -= 4 / asteroid.size * math.cos(math.radians(asteroid.angle))
if asteroid.rect.x > GameEngine.display_width:
asteroid.rect.x = 0
if asteroid.rect.x < 0:
asteroid.rect.x = GameEngine.display_width
if asteroid.rect.y > GameEngine.display_height:
asteroid.rect.y = 0
if asteroid.rect.y < 0:
asteroid.rect.y = GameEngine.display_height
if abs(self.ship.rect.x - asteroid.rect.x) < 15 * asteroid.size and abs(
self.ship.rect.y - asteroid.rect.y) < 15 * asteroid.size:
GameEngine.display_data(GameEngine.display_width / 2, GameEngine.display_height / 2 - 20, "Game Over!",
GameEngine.font, (255, 255, 255))
super().draw()
time.sleep(1)
GameEngine.display_data(GameEngine.display_width / 2, GameEngine.display_height / 2 + 20,
"Your score was: " + str(self.score), GameEngine.font, (255, 255, 255))
super().draw()
time.sleep(2)
self.exit()
GameEngine.change_state(games.menu.Menu())
super().update(50)
