def __init__(self, size):
self.background = pygame.Surface(size) # make a background surface
self.background = self.background.convert()
self.background.fill((0, 0, 0))
font = pygame.font.Font(None, 40)
self.score = Score(font)
self.walls = [Wall((10, 10), (790, 20)), Wall((10, 580), (790, 590))]
self.bats = []
control_scheme_1 = ControlScheme()
control_scheme_1.up = K_w
control_scheme_1.down = K_s
control_scheme_2 = ControlScheme()
control_scheme_2.up = K_UP
control_scheme_2.down = K_DOWN
self.bats.append(Bat((10, 200), control_scheme_1))
self.bats.append(Bat((780, 200), control_scheme_2))
self.ball = Ball((400, 300))
def __init__(self, name, side, engine, speed=1):
self.name = name
self._score = Score()
self.engine = engine
self.side = side
self.pad = Pad(self.side, speed, self.engine)
if self.is_at_left():
self.goal = Goal(790, self)
else:
self.goal = Goal(0, self)
def main(screen):
# create the cast {key: tag, value: list}
cast = {}
x = int(constants.MAX_X / 2)
y = int(constants.MAX_Y - 1)
position = Point(x, y)
paddle = Player()
paddle.set_position(position)
cast["paddle"] = [paddle]
cast["brick"] = []
for x in range(5, 75):
for y in range(2, 6):
position = Point(x, y)
brick = Brick()
brick.set_text("*")
brick.set_position(position)
cast["brick"].append(brick)
x = int(constants.MAX_X / 2)
y = int(constants.MAX_Y / 2)
position = Point(x, y)
velocity = Point(1, -1)
ball = Ball()
ball.set_text("@")
ball.set_position(position)
ball.set_starting_position(position)
ball.set_velocity(velocity)
cast["ball"] = [ball]
score = Score()
score.set_position(Point(4, 0))
cast["score"] = [score]
lives = Lives()
lives.set_position(Point(67, 0))
cast["lives"] = [lives]
# create the script {key: tag, value: list}
script = {}
input_service = InputService(screen)
output_service = OutputService(screen)
control_actors_action = ControlActorsAction(input_service)
move_actors_action = MoveActorsAction()
handle_collisions_acition = HandleCollisionsAction()
draw_actors_action = DrawActorsAction(output_service)
script["input"] = [control_actors_action]
script["update"] = [move_actors_action, handle_collisions_acition]
script["output"] = [draw_actors_action]
# start the game
director = Director(cast, script)
director.start_game()
def __init__(self, input_service, output_service):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self.buffer = Buffer()
self._input_service = input_service
self._keep_playing = True
self._output_service = output_service
self._score = Score()
self._words = Word()
def __init__(self, input_service, output_service):
"""Class constructor
Args:
self (Director): An instance of director
"""
self._input_service = input_service
self._keep_playing = True
self._output_service = output_service
self._score = Score()
self._word = WordActor()
self.user_word = Actor()
self.user_word._position._y = constants.MAX_Y + 1
def start_watch(self, level):
self.dj.enter_level()
self.load_level(level)
self.state = "RUNNING"
self.moves = 0
self.auto_speed = 0
self.solver_failed = False
self.move_num = Score([1256, 45])
self.display_hint = False
self.startSolved()
if not self.solver_failed:
self.solve_timer = Timer(1.5)
self.display_hint = True
def start_normal(self, level):
self.display_hint = False
self.dj.enter_level()
self.load_level(level)
self.state = "RUNNING"
self.moves = 0
self.selected = -1
'''
solver_thread = Thread(target=self.update_hint)
solver_thread.start()
'''
self.saved_moves = []
self.move_num = Score([1256, 45])
self.undo_num = Score([1256, 115])
def __init__(self, input_service, output_service):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self._word = Word()
self._input_service = input_service
self._keep_playing = True
self._output_service = output_service
self._score = Score()
self._speed = Speed()
self._guess = Guess()
self._actor = Actor()
self.correct = 0
def initialize_game_elements():
"""
Creates all class instances needed for the game, then saves all instances into a dictionary
:return: type: dict
A dictionary containing all the class instances needed for the game to function
"""
# Initialize first & second base
base1 = Base(0, DISPLAY_HEIGHT - Base.height)
base2 = Base(Base.width, DISPLAY_HEIGHT - Base.height)
# Initialize bird
bird = Bird((DISPLAY_WIDTH / 2) - Bird.width, DISPLAY_HEIGHT / 2)
# Initialize pipes
pipe1 = Pipe(DISPLAY_WIDTH * 2)
pipe2 = Pipe(pipe1.x + Pipe.interval)
# Initialize score
score = Score()
return {
"base": [base1, base2],
"bird": bird,
"pipe": [pipe1, pipe2],
"score": score
}
def load_next_level(self):
level_number = 2
self.cast = {}
player = Player()
self.cast['player'] = [player]
items = Items()
self.cast['items'] = [items]
background = BackgroundMaker(self.cast)
maps = MapMaker(self.cast, level_number)
score = Score()
self.cast["score"] = [score]
self.script = {}
self.output_services = OutputServices()
self.input_service = InputServices(self.cast)
self.gravity_engine = Gravity(self.cast)
handle_collisions = DoCollisionsAction(self.cast, self)
screen_scrolling = ScreenScrollAction()
control_actors = ControlActorsAction(self.input_service,
self.gravity_engine)
do_outputs = DrawActorsAction(self.output_services, screen_scrolling)
do_updates = DoUpdatesAction(self.gravity_engine)
self.script["input"] = [control_actors]
self.script["update"] = [
do_updates, handle_collisions, screen_scrolling
]
self.script["output"] = [do_outputs]
def __init__(self, input_service, output_service):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self._input_service = input_service
self._output_service = output_service
self._buffer = Buffer()
self._word = Word('test')
self._current_words = []
self._text_words = []
self._inputted_letter = ''
self._score = Score()
self._keep_playing = True
def __play_round(self, players=list):
"""Runs a round of play and returns a winner.
Args:
self (Director): an instance of Director.
players (list): a list of player names.
"""
code = self._board.generate_code()
self._player = Player(players)
self._score = Score(players)
self.__stop_round = False
while not self.__stop_round:
for player in players:
if len(players) > 1:
self._console.confirm_start(player)
history = self._player.get_moves(player)
stats = self._score.get_stats(player)
guess, elapsed = self._console.play_turn(
player, code, history, stats)
self._score.record_turn(elapsed, player)
while not self._board.validate_guess(guess):
stats = self._score.get_stats(player)
guess, elapsed = self._console.play_turn(player,
code,
history,
stats,
redo=True)
self._score.record_turn(elapsed, player)
if guess == code:
stats = self._score.get_stats(player)
self._score.update_board(player, stats)
self.__end_round(player, stats)
self.__stop_round = True
self._console.restart_menu()
break
hint = self._board.create_hint(code, guess)
self._console.show_hint(hint)
move_hint = (guess, hint)
self._player.record_move(player, move_hint)
def __init__(self, input_service, output_service):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self.words = []
for x in range(5): #Generates 5 word actors
newWord = Word()
self.words.append(newWord)
self._input_service = input_service
self._keep_playing = True
self._output_service = output_service
self._score = Score()
self._userinput = UserInput()
self._timer = Timer()
def main(screen):
# create the cast {key: tag, value: list}
cast = {}
x = int(constants.MAX_X / 2)
y = int(constants.MAX_Y - 1)
position = Point(x, y)
paddle = Actor()
paddle.set_text("===========") # 11 wide
paddle.set_position(position)
cast["paddle"] = [paddle]
cast["brick"] = []
for x in range(5, 75, 3):
for y in range(2, 8, 1):
position = Point(x, y)
brick = Actor()
brick.set_text("##")
brick.set_position(position)
cast["brick"].append(brick)
x = int(constants.MAX_X / 2)
y = int(constants.MAX_Y / 2)
position = Point(x, y)
velocity = Point(1, -1)
ball = Actor()
ball.set_text("@")
ball.set_position(position)
ball.set_velocity(velocity)
cast["ball"] = [ball]
#Add points for broken bricks
score = Score()
cast["score"] = [score]
# create the script {key: tag, value: list}
script = {}
input_service = InputService(screen)
output_service = OutputService(screen)
control_actors_action = ControlActorsAction(input_service)
move_actors_action = MoveActorsAction()
handle_collisions_acition = HandleCollisionsAction()
draw_actors_action = DrawActorsAction(output_service)
script["input"] = [control_actors_action]
script["update"] = [move_actors_action, handle_collisions_acition]
script["output"] = [draw_actors_action]
# start the game
director = Director(cast, script)
director.start_game()
def __init__(self, input_ser, output_ser):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self._input_service = input_ser
self._output_service = output_ser
self._keep_playing = True
self._player = Player()
self._words = []
self._score = Score()
for item in range(5):
self._words.append(Word())
def __init__(self):
init()
font.init()
display.set_caption(TITLE)
key.set_repeat()
self.playing = False
self.screen = display.set_mode((WIDTH, HEIGHT))
self.clock = time.Clock()
self.dt = self.clock.tick(FPS) / 1000
self.labels = list()
self.infos = list()
self.all_sprites = Group()
self.adventure = Home(self)
self.camera = Camera(self.adventure.map.width, self.adventure.map.height)
self.score = Score("Renato")
self.game_over = False
class PongGame:
def __init__(self, size):
self.background = pygame.Surface(size) # make a background surface
self.background = self.background.convert()
self.background.fill((0, 0, 0))
font = pygame.font.Font(None, 40)
self.score = Score(font)
self.walls = [Wall((10, 10), (790, 20)), Wall((10, 580), (790, 590))]
self.bats = []
control_scheme_1 = ControlScheme()
control_scheme_1.up = K_w
control_scheme_1.down = K_s
control_scheme_2 = ControlScheme()
control_scheme_2.up = K_UP
control_scheme_2.down = K_DOWN
self.bats.append(Bat((10, 200), control_scheme_1))
self.bats.append(Bat((780, 200), control_scheme_2))
self.ball = Ball((400, 300))
def process_event(self, event):
for bat in self.bats:
bat.process_event(event)
def update(self, time_delta):
for bat in self.bats:
bat.update(time_delta)
self.ball.update(time_delta, self.bats, self.walls)
if self.ball.position[0] < 0:
self.ball.reset()
self.score.increase_player_2_score()
elif self.ball.position[0] > 800:
self.ball.reset()
self.score.increase_player_1_score()
def draw(self, surface):
surface.blit(self.background, (0, 0))
for wall in self.walls:
wall.render(surface)
for bat in self.bats:
bat.render(surface)
self.ball.render(surface)
self.score.render(surface)
def __init__(self):
"""Initalize the Window class
Args:
self (Window): an instance of Window
Contributors:
Reed Hunsaker
Isabel Aranguren
"""
super().__init__(constants.X_CONSTANT, constants.Y_CONSTANT,
constants.TITLE)
self.master_volume = constants.DEFAULT_VOLUME
self.score = Score()
self.start_view = MainView()
self.background_music = arcade.Sound(constants.MAIN_SCREEN_SOUND)
self.background_music.play(self.master_volume, loop=True)
class Player:
def __init__(self, name, side, engine, speed=1):
self.name = name
self._score = Score()
self.engine = engine
self.side = side
self.pad = Pad(self.side, speed, self.engine)
if self.is_at_left():
self.goal = Goal(790, self)
else:
self.goal = Goal(0, self)
def win_point(self):
self._score.win_point()
def handle(self, event):
self.pad.handle(event)
def points(self):
return self._score.points()
def partials(self):
return self._score.partials()
def new_set(self):
self._score.new_set()
def win_set(self):
self._score.win_set()
def sets(self):
return self._score.sets()
def is_at_left(self):
return self.side == 'left'
def beats(self, other):
return self.points() > other.points()
def __init__(self):
""" Declares variables for the GameView class
Args:
self (Gameview): an instance of Gameview
Contributors:
Reed Hunsaker
Adrianna Lund
Isabel Aranguren
Jordan McIntyre
Juliano Nascimiento
"""
super().__init__()
self._score = Score()
self.texture = arcade.load_texture(constants.BACKGROUND)
self.game_ending = False
self.name = ""
# physics engines
self.physics_engine = None
self.physics_engine2 = None
self.physics_engine3 = None
self.physics_engine4 = None
# sprite lists
self.bullet_list = None
self.explosions_list = None
self.explosion_texture_list = []
# sounds
self.powerup_sound = arcade.load_sound(constants.POWERUPS_SOUND)
self.powerdown_sound = arcade.load_sound(constants.POWERDOWN_SOUND)
self.tank_explode = arcade.load_sound(constants.EXPLOSION_SOUND)
# explosion details
self.columns = 16
self.count = 8
self.sprite_width = 256
self.sprite_height = 256
self.file_name = ":resources:images/spritesheets/explosion.png"
self.explosion_texture_list = arcade.load_spritesheet(
self.file_name, self.sprite_width, self.sprite_height,
self.columns, self.count)
class Director:
"""A code template for a person who directs the game. The responsibility of
this class of objects is to control the sequence of play.
Stereotype:
Controller
Attributes:
food (Food): The snake's target.
input_service (InputService): The input mechanism.
keep_playing (boolean): Whether or not the game can continue.
output_service (OutputService): The output mechanism.
score (Score): The current score.
snake (Snake): The player or snake.
"""
def __init__(self, input_service, output_service):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self._buffer = Buffer()
self._input_service = input_service
self._keep_playing = True
self._output_service = output_service
self._score = Score()
self._words = Words()
self._slow = 0
def start_game(self):
"""Starts the game loop to control the sequence of play.
Args:
self (Director): an instance of Director.
"""
while self._keep_playing:
self._get_inputs()
self._do_updates()
self._do_outputs()
sleep(constants.FRAME_LENGTH)
def _get_inputs(self):
"""Gets the inputs at the beginning of each round of play. In this case,
that means getting the desired direction and moving the snake.
Args:
self (Director): An instance of Director.
"""
self._buffer.add_letter(letter)
letter = self._input_service.get_letter()
self._words.move_words()
def _do_updates(self):
"""Updates the important game information for each round of play. In
this case, that means checking for a collision and updating the score.
Args:
self (Director): An instance of Director.
"""
self._add_new_words()
self._handle_matching_words()
def _do_outputs(self):
"""Outputs the important game information for each round of play. In
this case, that means checking if there are stones left and declaring
the winner.
Args:
self (Director): An instance of Director.
"""
self._output_service.clear_screen()
self._output_service.draw_actor(self._buffer)
self._output_service.draw_actors(self._words.get_all())
self._output_service.draw_actor(self._score)
self._output_service.flush_buffer()
def _handle_body_collision(self): #Not sure with this reference help
"""Handles collisions between the snake's head and body. Stops the game
if there is one.
Args:
self (Director): An instance of Director.
"""
head = self._snake.get_head()
body = self._snake.get_body()
for segment in body:
if head.get_position().equals(segment.get_position()):
self._keep_playing = False
break
def _handle_food_collision(self): #See comment above.
"""Handles collisions between the snake's head and the food. Grows the
snake, updates the score and moves the food if there is one.
Args:
self (Director): An instance of Director.
"""
head = self._snake.get_head()
if head.get_position().equals(self._food.get_position()):
points = self._food.get_points()
for n in range(points):
self._snake.grow_tail()
self._score.add_points(points)
self._food.reset()
class UI:
def __init__(self):
self.state = "MAINMENU"
self.algorithm = 0
self.hint_available = True
self.auto_solving = False
self.paused = False
self.auto_speed = 0
self.init_screen()
self.load_other()
self.build_menu()
self.build_main_menu()
self.build_setting_menu()
self.build_music_player()
self.build_end_screen()
self.timer = Timer(mouse_timeout)
self.active = True
# Init functions
def init_screen(self):
self.screen = pygame.display.set_mode((screen_width, screen_height))
def build_menu(self):
self.menu = GameMenu(levels)
def build_music_player(self):
self.dj = MusicPlayer()
def build_main_menu(self):
self.main_menu = Menu()
def build_setting_menu(self):
self.settings = SettingsMenu()
def build_end_screen(self):
self.end_screen = EndScreen()
# Load functions
def load_bg(self):
self.bg = pygame.image.load('assets/img/lab.jpg')
def load_level(self, num):
if hasattr(self, 'curGame'):
del self.cur_game
level = copy.deepcopy(levels[str(num)])
self.cur_game = Game(level)
self.create_game()
def load_tubes(self, num):
self.flasks = pygame.sprite.Group()
def load_other(self):
self.load_bg()
self.load_quit()
self.load_undo()
self.load_move_count()
self.load_undo_count()
self.load_hint()
self.load_auto_solve()
def load_auto_solve(self):
self.load_speed()
self.load_pause()
self.load_algorithm_fail()
def load_speed(self):
speed_holder = pygame.image.load("assets/img/holders/speedHolder.png")
value_holder = pygame.image.load("assets/img/holders/prevNext.png")
font = pygame.font.SysFont("Arial", 45)
font2 = pygame.font.SysFont("Arial", 40)
speed = text_to_sprite("Speed", speed_holder, (230, 230, 230),
[1075, 125], font)
point_five = text_to_sprite("x0.5", value_holder, (230, 230, 230),
[1250, 137.5], font2)
normal = text_to_sprite("x1", value_holder, (230, 230, 230),
[1250, 137.5], font2)
x2 = text_to_sprite("x2", value_holder, (230, 230, 230), [1250, 137.5],
font2)
x4 = text_to_sprite("x4", value_holder, (230, 230, 230), [1250, 137.5],
font2)
x8 = text_to_sprite("x8", value_holder, (230, 230, 230), [1250, 137.5],
font2)
self.speed_holder = pygame.sprite.GroupSingle(speed)
self.speeds = []
self.speeds.append(pygame.sprite.GroupSingle(normal))
self.speeds.append(pygame.sprite.GroupSingle(x2))
self.speeds.append(pygame.sprite.GroupSingle(x4))
self.speeds.append(pygame.sprite.GroupSingle(x8))
self.speeds.append(pygame.sprite.GroupSingle(point_five))
def load_pause(self):
holder = pygame.image.load("assets/img/holders/speedHolder.png")
font = pygame.font.SysFont("Arial", 40)
pause = text_to_sprite("Pause", holder, (230, 230, 230), [1075, 225],
font)
resume = text_to_sprite("Resume", holder, (230, 230, 230), [1075, 225],
font)
self.pauseButton = pygame.sprite.GroupSingle(pause)
self.resumeButton = pygame.sprite.GroupSingle(resume)
def load_undo(self):
undo_img = load_sprite("assets/img/buttons/undo.png")
undo_img.rect.left = 1250
undo_img.rect.top = 200
self.undoB = pygame.sprite.GroupSingle(undo_img)
def load_quit(self):
quit_img = load_sprite("assets/img/buttons/menu.png")
quit_img.rect.left = 20
quit_img.rect.top = 20
self.quit = pygame.sprite.GroupSingle(quit_img)
def load_move_count(self):
move_holder = load_sprite("assets/img/holders/numberBox.png")
move_holder.rect.left, move_holder.rect.top = [1250, 50]
self.moveHolder = pygame.sprite.GroupSingle(move_holder)
move_count = load_sprite("assets/img/holders/moveCount.png")
move_count.rect.left, move_count.rect.top = [1000, 45]
self.moveCount = pygame.sprite.GroupSingle(move_count)
def load_undo_count(self):
undo_holder = load_sprite("assets/img/holders/numberBox.png")
undo_holder.rect.left, undo_holder.rect.top = [1250, 120]
self.undoHolder = pygame.sprite.GroupSingle(undo_holder)
undo_count = load_sprite("assets/img/holders/undoCount.png")
undo_count.rect.left, undo_count.rect.top = [1000, 115]
self.undoCount = pygame.sprite.GroupSingle(undo_count)
def load_hint(self):
hint_up = load_sprite("assets/img/arrow_up.png")
self.hint_up = pygame.sprite.GroupSingle(hint_up)
hint_down = load_sprite("assets/img/arrow_down.png")
self.hint_down = pygame.sprite.GroupSingle(hint_down)
hint_b = load_sprite("assets/img/buttons/hint.png")
hint_b.rect.left, hint_b.rect.top = [1250, 280]
self.hint_b = pygame.sprite.GroupSingle(hint_b)
hint_no = load_sprite("assets/img/buttons/no-hint.png")
hint_no.rect.left, hint_no.rect.top = [1250, 280]
self.hint_no = pygame.sprite.GroupSingle(hint_no)
def load_algorithm_fail(self):
self.solver_failed = False
holder = pygame.image.load("assets/img/holders/failHolder.png")
font = pygame.font.SysFont("Arial", 40)
alg_fail = text_to_sprite(
"Algorithm couldn't reach a solution in due time", holder,
(230, 230, 230), [300, 400], font)
self.alg_fail = pygame.sprite.GroupSingle(alg_fail)
## Draw functions
def draw_screen(self):
self.screen.blit(self.bg, (0, 0))
def draw_main_menu(self):
self.main_menu.draw(self.screen)
def draw_game_menu(self):
self.menu.draw(self.screen)
def draw_settings_menu(self):
self.settings.draw(self.screen)
def draw_quit(self):
self.quit.draw(self.screen)
def draw_undo(self):
self.undoB.draw(self.screen)
def draw_flasks(self):
for flask in self.tubes:
flask.draw(self.screen)
def draw_hint(self):
if self.hint_available:
self.hint_b.draw(self.screen)
else:
self.hint_no.draw(self.screen)
def draw_solved_hint(self):
if self.display_hint:
self.hint_up.draw(self.screen)
self.hint_down.draw(self.screen)
def drawMoveCount(self):
self.moveCount.draw(self.screen)
self.moveHolder.draw(self.screen)
self.move_num.draw(self.screen)
def drawUndoCount(self):
self.undoCount.draw(self.screen)
self.undoHolder.draw(self.screen)
self.undo_num.draw(self.screen)
def drawRun(self):
if self.auto_solving:
self.draw_watch()
else:
self.draw_play()
def draw_watch(self):
self.draw_solved_hint()
self.draw_flasks()
self.draw_quit()
self.drawMoveCount()
self.draw_speed()
self.draw_pause()
if self.solver_failed:
self.alg_fail.draw(self.screen)
def draw_play(self):
self.draw_hint()
self.draw_solved_hint()
self.draw_flasks()
self.draw_quit()
self.draw_undo()
self.drawMoveCount()
self.drawUndoCount()
def draw_pause(self):
if self.paused:
self.resumeButton.draw(self.screen)
else:
self.pauseButton.draw(self.screen)
def draw_end(self):
if self.auto_solving:
self.end_screen.draw_solved(self.screen, self.move_num.score)
else:
self.end_screen.draw(self.screen, self.move_num.score,
self.undo_num.score)
def draw_speed(self):
self.speed_holder.draw(self.screen)
self.speeds[self.auto_speed].draw(self.screen)
# Collision functions
def check_flasks_cols(self, mouse_pos):
i = 0
for tube in self.tubes:
if tube.check_mouse_col(mouse_pos):
return i
i += 1
return -1
def check_quit(self, mouse_pos):
return self.quit.sprite.rect.collidepoint(mouse_pos)
def check_undo(self, mouse_pos):
return self.undoB.sprite.rect.collidepoint(mouse_pos)
def check_hint(self, mouse_pos):
return self.hint_b.sprite.rect.collidepoint(mouse_pos)
def check_run_cols(self, mouse_pos):
select = self.check_flasks_cols(mouse_pos)
if select > -1:
self.make_move(select)
if self.check_completed():
self.end_game()
elif self.check_undo(mouse_pos):
self.undo()
elif self.check_quit(mouse_pos):
self.return_to_menu()
elif self.check_hint(mouse_pos):
'''solver_thread = Thread(target=self.update_hint)
solver_thread.start()'''
self.update_hint()
self.display_hint = True
self.dj.click_hint()
def check_solve_cols(self, mouse_pos):
if self.check_quit(mouse_pos):
self.return_to_menu()
self.check_speed(mouse_pos)
self.check_pause(mouse_pos)
def check_speed(self, mouse_pos):
if self.solver_failed:
return
if self.speeds[self.auto_speed].sprite.rect.collidepoint(mouse_pos):
self.auto_speed += 1
if self.auto_speed > 4:
self.auto_speed = 0
self.solve_timer.update_timer(1.5)
elif self.auto_speed == 1:
self.solve_timer.update_timer(0.75)
elif self.auto_speed == 2:
self.solve_timer.update_timer(0.375)
elif self.auto_speed == 3:
self.solve_timer.update_timer(0.19)
elif self.auto_speed == 4:
self.solve_timer.update_timer(3)
def check_pause(self, mouse_pos):
if self.solver_failed:
return
if self.paused:
if self.resumeButton.sprite.rect.collidepoint(mouse_pos):
self.paused = False
self.solve_timer.start_timer()
else:
if self.pauseButton.sprite.rect.collidepoint(mouse_pos):
self.paused = True
def check_back_to_menu(self, mouse_pos):
if self.end_screen.check_back_col(mouse_pos):
self.return_to_menu()
# Checking functions
def check_completed(self):
for tube in self.tubes:
if not tube.check_done():
return False
return True
def check_mouse_timeout(self, mouse):
if (mouse):
if (self.timer.check_timer()):
self.timer.start_timer()
return True
return False
# Run functions
def run(self):
self.draw_screen()
if self.state == "MAINMENU":
self.run_main_menu()
elif self.state == "SETTINGS":
self.run_settings_menu()
elif self.state == "GAMEMENU":
self.run_game_menu()
elif self.state == "RUNNING":
self.run_level()
elif self.state == "END":
self.run_end()
def run_main_menu(self):
self.draw_main_menu()
mouse = pygame.mouse.get_pressed()[0]
if self.check_mouse_timeout(mouse):
select = self.main_menu.check_menu_cols()
if select == 0:
self.active = False
elif select == 1:
self.auto_solving = False
self.level_selection()
elif select == 2:
self.auto_solving = True
self.level_selection()
elif select == 3:
self.settings_menu()
def run_game_menu(self):
self.draw_game_menu()
mouse = pygame.mouse.get_pressed()[0]
if self.check_mouse_timeout(mouse):
select = self.menu.check_menu_cols()
if select == 0:
self.return_to_main_menu()
elif select > 0:
self.start_game(select)
elif select == -2:
self.dj.clicked_button()
def run_settings_menu(self):
self.draw_settings_menu()
mouse = pygame.mouse.get_pressed()[0]
if self.check_mouse_timeout(mouse):
select = self.settings.check_menu_cols()
if select == 0:
self.return_to_main_menu()
elif select == 1:
self.dj.switch_sfx()
elif select == 2:
self.dj.switch_music()
elif select > 2:
self.algorithm = select - 3
def run_level(self):
self.drawRun()
mouse = pygame.mouse.get_pressed()[0]
if self.check_mouse_timeout(mouse):
mouse_pos = pygame.mouse.get_pos()
if self.auto_solving:
self.check_solve_cols(mouse_pos)
else:
self.check_run_cols(mouse_pos)
if self.auto_solving and not self.solver_failed:
if self.solve_timer.check_timer() and not self.paused:
self.play_solved()
def run_end(self):
self.draw_end()
mouse = pygame.mouse.get_pressed()[0]
if self.check_mouse_timeout(mouse):
mouse_pos = pygame.mouse.get_pos()
self.check_back_to_menu(mouse_pos)
# Level functions
def create_game(self):
if hasattr(self, 'tubes'):
del self.tubes
self.tubes = []
x = 50
y = 650
for tube in self.cur_game.tubes:
flask = Flask(tube, [x, y])
self.tubes.append(flask)
x += 112
def start_game(self, level):
if self.auto_solving:
self.start_watch(level)
else:
self.start_normal(level)
def start_watch(self, level):
self.dj.enter_level()
self.load_level(level)
self.state = "RUNNING"
self.moves = 0
self.auto_speed = 0
self.solver_failed = False
self.move_num = Score([1256, 45])
self.display_hint = False
self.startSolved()
if not self.solver_failed:
self.solve_timer = Timer(1.5)
self.display_hint = True
def start_normal(self, level):
self.display_hint = False
self.dj.enter_level()
self.load_level(level)
self.state = "RUNNING"
self.moves = 0
self.selected = -1
'''
solver_thread = Thread(target=self.update_hint)
solver_thread.start()
'''
self.saved_moves = []
self.move_num = Score([1256, 45])
self.undo_num = Score([1256, 115])
def return_to_main_menu(self):
self.state = "MAINMENU"
def level_selection(self):
self.state = "GAMEMENU"
def return_to_menu(self):
self.dj.in_menu()
self.state = "GAMEMENU"
self.selected = -1
def settings_menu(self):
self.state = "SETTINGS"
def end_game(self):
self.state = "END"
self.selected = -1
# Game functions
def make_move(self, tube):
if tube == self.selected:
self.deselect()
elif self.selected >= 0:
if self.cur_game.move_ball(self.selected, tube):
self.successful_move(tube)
else:
self.select(tube)
def successful_move(self, tube):
self.move_num.increase_score()
ball = self.tubes[self.selected].remove_ball()
if self.tubes[tube].add_ball(ball):
self.dj.complete_tube()
self.saved_moves.append([self.selected, tube])
'''
solver_thread = Thread(target=self.update_hint)
solver_thread.start()
'''
self.deselect()
self.display_hint = False
def undo(self):
if self.saved_moves:
self.undo_num.increase_score()
self.move_num.decrease_score()
last_move = self.saved_moves.pop()
self.undo_move(last_move)
def undo_move(self, move):
self.cur_game.move_ball(move[1], move[0])
ball = self.tubes[move[1]].remove_ball()
self.tubes[move[0]].add_ball(ball)
'''
solver_thread = Thread(target=self.update_hint)
solver_thread.start()
'''
@timeout(20)
def get_result(self, init_state):
if self.algorithm == 0:
return solver(init_state, Algorithm.A_STAR, 30)
elif self.algorithm == 1:
return solver(init_state, Algorithm.GREEDY, 30)
elif self.algorithm == 2:
return solver(init_state, Algorithm.DFS, 60)
elif self.algorithm == 3:
return solver(init_state, Algorithm.BFS, 15)
elif self.algorithm == 4:
return ids(init_state, 60)
def startSolved(self):
init_state = Node(self.cur_game)
try:
result = self.get_result(init_state)
if result[1] is None:
self.solver_failed = True
self.display_hint = False
self.hide_hint_arrows()
return
self.display_hint = True
self.solvedPath = result[0].path(result[1])
self.curNode = 0
except:
self.solver_failed = True
self.display_hint = False
self.hide_hint_arrows()
def play_solved(self):
move = self.get_next_move()
if move[0] == -2:
self.end_game()
return
self.cur_game.move_ball(move[0], move[1])
self.watch_move(move)
self.curNode += 1
next_move = self.get_next_move()
if next_move[0] != -2:
self.update_hint_arrows(next_move)
else:
self.hide_hint_arrows()
def watch_move(self, move):
self.move_num.increase_score()
ball = self.tubes[move[0]].remove_ball()
if self.tubes[move[1]].add_ball(ball):
self.dj.complete_tube()
# Select/Deselect flasks
def deselect(self):
self.tubes[self.selected].select()
self.selected = -1
def select(self, tube):
self.tubes[tube].select()
self.selected = tube
# Hint functions
def update_hint(self):
init_state = Node(self.cur_game)
result = solver(init_state, Algorithm.A_STAR, 30)
if result[1] is None:
self.hint_available = False
self.hide_hint_arrows()
return
path = result[0].path(result[1])
if len(path) > 1:
self.hint_available = True
hint = self.find_differences(path[1])
self.update_hint_arrows(hint)
def update_hint_arrows(self, hint):
self.hint_up.sprite.rect.left = self.tubes[hint[0]].coords[0] + 5
self.hint_up.sprite.rect.top = self.tubes[hint[0]].coords[1] - 130
self.hint_down.sprite.rect.left = self.tubes[hint[1]].coords[0] + 5
self.hint_down.sprite.rect.top = self.tubes[hint[1]].coords[1] - 130
def hide_hint_arrows(self):
self.hint_up.sprite.rect.left = 8000
self.hint_up.sprite.rect.top = 8000
self.hint_down.sprite.rect.left = 8000
self.hint_down.sprite.rect.top = 8000
def find_differences(self, node):
tube_from = -1
tube_to = -1
game1 = self.cur_game
game2 = node.gamestate
for i in range(0, len(game2.tubes)):
if len(game1.tubes[i].balls) > len(game2.tubes[i].balls):
tube_from = i
elif len(game1.tubes[i].balls) < len(game2.tubes[i].balls):
tube_to = i
if (tube_from != -1 and tube_to != -1):
return [tube_from, tube_to]
return [tube_from, tube_to]
def get_next_move(self):
if (self.curNode == len(self.solvedPath) - 1):
return [-2, -2]
node1 = self.solvedPath[self.curNode]
node2 = self.solvedPath[self.curNode + 1]
tube_from = -1
tube_to = -1
game1 = node1.gamestate
game2 = node2.gamestate
for i in range(0, len(game2.tubes)):
if len(game1.tubes[i].balls) > len(game2.tubes[i].balls):
tube_from = i
elif len(game1.tubes[i].balls) < len(game2.tubes[i].balls):
tube_to = i
if (tube_from != -1 and tube_to != -1):
return [tube_from, tube_to]
return [tube_from, tube_to]
class Director:
"""A code template for a person who directs the game. The responsibility of
this class of objects is to control the sequence of play.
Stereotype:
Controller
Attributes:
keep_playing (boolean): Whether or not the game can continue.
board (Board): An instance of the class of objects known as Board.
console (Console): An instance of the Console class of objects.
helper (Helper): An instance of the class of objects known as Helper.
move (Move): An instance of the class of objects known as Move.
player (Player): An instance of the class of objects known as Player.
roster (Roster): An instance of the class of objects known as Roster.
"""
def __init__(self):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self.__stop_round = False
self._board = Board()
self._console = Console()
def run_game(self):
"""Starts the game loop to control the sequence of play.
Args:
self (Director): an instance of Director.
"""
while not self._console.ask_stop_game():
players = self._console.menu()
if not self._console.ask_stop_game():
self.__play_round(players)
print("\n" * 15)
self._console.clear_screen()
def __play_round(self, players=list):
"""Runs a round of play and returns a winner.
Args:
self (Director): an instance of Director.
players (list): a list of player names.
"""
code = self._board.generate_code()
self._player = Player(players)
self._score = Score(players)
self.__stop_round = False
while not self.__stop_round:
for player in players:
if len(players) > 1:
self._console.confirm_start(player)
history = self._player.get_moves(player)
stats = self._score.get_stats(player)
guess, elapsed = self._console.play_turn(
player, code, history, stats)
self._score.record_turn(elapsed, player)
while not self._board.validate_guess(guess):
stats = self._score.get_stats(player)
guess, elapsed = self._console.play_turn(player,
code,
history,
stats,
redo=True)
self._score.record_turn(elapsed, player)
if guess == code:
stats = self._score.get_stats(player)
self._score.update_board(player, stats)
self.__end_round(player, stats)
self.__stop_round = True
self._console.restart_menu()
break
hint = self._board.create_hint(code, guess)
self._console.show_hint(hint)
move_hint = (guess, hint)
self._player.record_move(player, move_hint)
def __end_round(self, winner=str, stats=tuple):
"""Announces the winner and ends the round
Args:
self (Director): an instance of Director.
winner (list): name of the victor.
stats (tuple): Tuple of total round points and playtime of player.
"""
self._console.clear_screen()
points, time = stats
print("\n" * 15)
self._console.cool_print(f' {winner} wins!')
print()
self._console.cool_print(f' Points: {points} out of 15')
self._console.cool_print(f' Time: {time:.2f} seconds')
input()
def main_game(genomes, config):
gameSpeed = 5
gameOver = False
nets = []
genomes_track = []
snakes = []
for _, genome in genomes:
net = neat.nn.FeedForwardNetwork.create(genome, config)
nets.append(net)
snake_initial_coord = unique_coords(snakes)
snakes.append(Snake(snake_initial_coord, gameSpeed))
genome.fitness = 0
genomes_track.append(genome)
#snake = Snake((int(BOARD_ROWS / 2), int(BOARD_COLS / 2)), gameSpeed)
tile_coord = unique_coords(snakes)
tile = Tile(tile_coord)
board = Board(screen)
score = Score(screen)
#last_obstacle = pygame.sprite.Group()
while not gameOver:
for event in pygame.event.get():
if event.type == QUIT:
gameOver = True
quit()
if event.type == KEYDOWN:
if event.key == K_UP:
for snake in snakes:
snake.move_up()
if event.key == K_DOWN:
for snake in snakes:
snake.move_down()
if event.key == K_RIGHT:
for snake in snakes:
snake.move_right()
if event.key == K_LEFT:
for snake in snakes:
snake.move_left()
for snake in snakes:
snake.update()
check_collide(snakes, tile, genomes_track, nets)
if tile.is_dead():
score.update()
#snake.eat_tile()
tile_coord = unique_coords(snakes)
tile = Tile(tile_coord)
if len(snakes) == 0:
gameOver = True
quit()
board.clean_board()
for snake in snakes:
board.display_snake(snake.get_body())
board.display_tile(tile.get_coord())
update_fitness(snakes, tile, genomes_track, nets)
if pygame.display.get_surface() != None:
screen.fill(BG_COLOR)
board.draw()
score.draw()
pygame.display.update()
clock.tick(FPS)
class Director:
"""A code template for a person who directs the game. The responsibility of
this class of objects is to control the sequence of play.
Stereotype:
Controller
Attributes:
input_service (InputService): The input mechanism.
keep_playing (boolean): Whether or not the game can continue.
output_service (OutputService): The output mechanism.
score (Score): The current score.
userinput (UserInput): The users input.
timer (Timer): The remaining time left.
"""
def __init__(self, input_service, output_service):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self.words = []
for x in range(5): #Generates 5 word actors
newWord = Word()
self.words.append(newWord)
self._input_service = input_service
self._keep_playing = True
self._output_service = output_service
self._score = Score()
self._userinput = UserInput()
self._timer = Timer()
def start_game(self):
"""Starts the game loop to control the sequence of play.
Args:
self (Director): an instance of Director.
"""
while self._keep_playing:
self._get_inputs()
self._do_updates()
self._do_outputs()
sleep(constants.FRAME_LENGTH)
def _get_inputs(self):
"""Gets the inputs at the beginning of each round of play. In this case,
that means checking the letters the user types.
Args:
self (Director): An instance of Director.
"""
self.input_letter = self._input_service.get_letter()
def _do_updates(self):
"""Updates the important game information for each round of play. In
this case, that means checking the words for correctness and subtracting
time.
Args:
self (Director): An instance of Director.
"""
self._move_words()
self._handle_letter_input()
self._check_words()
self._timer.subtract_time()
self._timer.check_time()
def _do_outputs(self):
"""Outputs the important game information for each round of play. In
this case, that means drawing everything to the screen.
Args:
self (Director): An instance of Director.
"""
self._output_service.clear_screen()
self._output_service.draw_actors(self.words)
self._output_service.draw_actor(self._timer)
self._output_service.draw_actor(self._userinput)
self._output_service.draw_actor(self._score)
self._output_service.flush_buffer()
def _check_words(self):
"""Handles the checking of words as they are typed.
Args:
self (Director): An instance of Director.
"""
for x in range(5):
if self._userinput.check_word == self.words[x]._word:
self._score.add_points(self.words[x]._points)
self.words[x].reset()
self._userinput._clear_letters()
def _move_words(self):
"""Handles moving the words around the screen.
Args:
self (Director): An instance of Director.
"""
for x in range(len(self.words)):
self.words[x].move_next()
def _handle_letter_input(self):
"""Handles adding letters to an array as they are typed.
Args:
self (Director): An instance of Director.
"""
if self.input_letter == "":
pass
elif self.input_letter == "*":
self._userinput._clear_letters()
else:
self._userinput._add_letter(self.input_letter)
def play(category):
""" Play the blindtest itself, save and show score and ask a rating for the project."""
# Get Category
try:
category = Category.get(id=category)
except Exception:
print("Impossible de récupérer la catégorie dans la base de données.")
# Execute rest of code only if category exists
if category is not None:
# Convert musics from this category to a list
musics = list(category.musics)
# Generate a shuffled list
shuffled_musics = list(musics)
shuffle(shuffled_musics)
# Initialize score
points = 0
# Generate a string with the non-shuffled list of musics
musics_list = ""
for music in musics:
musics_list = musics_list + ("\n\t%i %s" % (reduce_id(music.id), music.name))
# Play musics one by one and ask user what music is it
for i, music in enumerate(shuffled_musics):
# Define the right answer
answer = reduce_id(music.id)
# Initialize user_input
user_input = None
# Show answers list
print("Propositions :%s\n" % musics_list)
# Play music
music_to_play = Music(music)
# Execute code only if the music exists
if music_to_play is not None:
if music_to_play.is_exists():
music_to_play.play()
# Ask user for the answer
while user_input is None:
user_input = input("Votre réponse : ")
try:
user_input = int(user_input)
except ValueError:
print(settings.errors['NOT_A_NUMBER'])
if user_input in range(1, 11):
if user_input == answer:
print("Votre réponse était JUSTE.")
points = points + 1
else:
print("Votre réponse était FAUSSE.")
else:
user_input = None
print("Veuillez entrer un nombre entre 1 et 10.")
# Save and show score
score = Score(points)
score.save()
score.show()
# Ask for a rating
thanks()
# Go back to main menu
menus.main()
def play(category):
""" Play the blindtest itself, save and show score and ask a rating for the project."""
# Get Category
try:
category = Category.get(id=category)
except Exception:
print("Impossible de récupérer la catégorie dans la base de données.")
# Execute rest of code only if category exists
if category is not None:
# Convert musics from this category to a list
musics = list(category.musics)
# Generate a shuffled list
shuffled_musics = list(musics)
shuffle(shuffled_musics)
# Initialize score
points = 0
# Generate a string with the non-shuffled list of musics
musics_list = ""
for music in musics:
musics_list = musics_list + ("\n\t%i %s" %
(reduce_id(music.id), music.name))
# Play musics one by one and ask user what music is it
for i, music in enumerate(shuffled_musics):
# Define the right answer
answer = reduce_id(music.id)
# Initialize user_input
user_input = None
# Show answers list
print("Propositions :%s\n" % musics_list)
# Play music
music_to_play = Music(music)
# Execute code only if the music exists
if music_to_play is not None:
if music_to_play.is_exists():
music_to_play.play()
# Ask user for the answer
while user_input is None:
user_input = input("Votre réponse : ")
try:
user_input = int(user_input)
except ValueError:
print(settings.errors['NOT_A_NUMBER'])
if user_input in range(1, 11):
if user_input == answer:
print("Votre réponse était JUSTE.")
points = points + 1
else:
print("Votre réponse était FAUSSE.")
else:
user_input = None
print("Veuillez entrer un nombre entre 1 et 10.")
# Save and show score
score = Score(points)
score.save()
score.show()
# Ask for a rating
thanks()
# Go back to main menu
menus.main()
class Arena(object):
database = None
event_settings = None
displays = None
match_aborted = False
last_ds_packet_time = 0
blue_realtime_score = 0
red_realtime_score = 0
alliance_stations = {}
tba_client = None
match_start_time = 0
last_match_time_sec = 0
match_time_sec = 0
red_score = Score()
blue_score = Score()
current_sound = None
driverstation_listener = None
driverstation_udp_packet_listener = None
## Arena constructor
# @param db_path Filepath to the database file
# @param ws_server Websocket server object
def __init__(self, db_path, ws_server):
self.database = Database(db_path)
self.ws = ws_server
# Set up alliance stations
self.alliance_stations["R1"] = AllianceStation()
self.alliance_stations["R2"] = AllianceStation()
self.alliance_stations["R3"] = AllianceStation()
self.alliance_stations["B1"] = AllianceStation()
self.alliance_stations["B2"] = AllianceStation()
self.alliance_stations["B3"] = AllianceStation()
self.match_state = MatchState.pre_match
self.last_match_time = 0
self.last_match_state = -1
self.audience_display_mode = "blank"
self.alliance_station_display_mode = "match"
## Function that starts the field
def Run(self):
# listen for driverstations
self.driverstation_listener = Thread(target=ListenForDriverstations,
args=(self, None))
self.driverstation_listener.start()
# Listen for DS UDP packets
self.driverstation_udp_packet_listener = Thread(
target=ListenForDsUdpPackets, args=(self, None))
self.driverstation_udp_packet_listener.start()
notice("Arena has started")
while True:
self.Update()
time.sleep(arena_loop_period_ms / 1000)
## Function for retreving the assigned station of a specified team
# @param team_id Team number
# @return Station id for team
def GetAssignedAllianceStation(self, team_id: int):
for station in self.alliance_stations:
if self.alliance_stations[station].team != None and str(
self.alliance_stations[station].team.id) == str(team_id):
return station
return ""
## Manages game states and robot connections
def Update(self):
# print("updating")
auto = False
enabled = False
send_ds_packet = False
match_time_sec = self.MatchTimeSec()
if self.match_state == MatchState.pre_match:
auto = True
enabled = False
elif self.match_state == MatchState.start_match:
self.match_start_time = time.time()
self.last_match_time_sec = -1
auto = True
self.audience_display_mode = "match"
self.alliance_station_display_mode = "match"
# TODO: notify display modes
self.match_state = MatchState.auto_period
enabled = True
send_ds_packet = True
self.current_sound = "auto"
elif self.match_state == MatchState.auto_period:
auto = True
enabled = True
if match_time_sec >= matchtiming.auto_duration_sec:
auto = False
send_ds_packet = True
self.match_state = MatchState.teleop_period
enabled = True
self.current_sound = "teleop"
elif self.match_state == MatchState.teleop_period:
auto = False
enabled = True
if match_time_sec >= matchtiming.auto_duration_sec + matchtiming.teleop_duration_sec:
self.match_state = MatchState.pre_match
auto = False
enabled = False
send_ds_packet = True
self.current_sound = "matchend"
NotifyAll(self.ws, self)
time.sleep(3)
self.audience_display_mode = "blank"
self.alliance_station_display_mode = "logo"
NotifyAll(self.ws, self)
self.last_match_time = match_time_sec
self.last_match_state = self.match_state
if send_ds_packet or (timeMS() -
self.last_ds_packet_time) >= ds_packet_period_ms:
self.SendDsPacket(auto, enabled)
## Get the time to be displayed on the match timer
# @return Match time
def MatchTimeSec(self):
if self.match_state == MatchState.pre_match or self.match_state == MatchState.start_match:
return 0
return (time.time() - self.match_start_time) #+ 130
def SendDsPacket(self, auto: bool, enabled: bool):
for station in self.alliance_stations:
station = self.alliance_stations[station]
dsconn = station.driverstation_connection
if dsconn != None:
dsconn.auto = auto
dsconn.enabled = enabled and not station.estop and not station.bypass
dsconn.estop = station.estop
dsconn.Update(self)
self.last_ds_packet_time = timeMS()
def CheckCanStartMatch(self):
if self.match_state != MatchState.pre_match:
return "Cannot start match while there is a match in progress or with results still pending"
def AssignTeam(self, team_id: int, station: str):
team_id = int(team_id)
if station not in self.alliance_stations:
return "Invalid alliance station"
dsconn = self.alliance_stations[station].driverstation_connection
if dsconn != None and dsconn.team_id == team_id:
return None
if dsconn != None:
dsconn.Close()
self.alliance_stations[station].team = None
self.alliance_stations[station].driverstation_connection = None
if team_id == 0:
self.alliance_stations[station].team = None
return None
team = Team()
team.id = team_id
self.alliance_stations[station].team = team
notice(f"Team {team_id} has been assigned to station {station}")
return None
def ResetMatch(self):
if self.match_state != MatchState.pre_match:
return "Cannot reset a match while it is in progress"
self.match_state = MatchState.pre_match
self.match_aborted = False
self.alliance_stations["R1"].bypass = False
self.alliance_stations["R2"].bypass = False
self.alliance_stations["R3"].bypass = False
self.alliance_stations["B1"].bypass = False
self.alliance_stations["B2"].bypass = False
self.alliance_stations["B3"].bypass = False
def AbortMatch(self):
if self.match_state == MatchState.pre_match:
return "Cannot abort a match that is not running"
self.match_state = MatchState.pre_match
self.match_aborted = True
self.current_sound = "abort"
warn("Match aborted")
def StartMatch(self):
for station in self.alliance_stations:
station = self.alliance_stations[station]
if station.driverstation_connection != None:
dsconn = station.driverstation_connection
SignalMatchStart(dsconn)
if station.team != None and not station.team.has_connected and dsconn.robot_linked:
station.team.has_connected = True
self.match_state = MatchState.start_match
notice("Match has been started")
class Director:
"""A code template for a person who directs the game. The responsibility of
this class of objects is to control the sequence of play.
Stereotype:
Controller
"""
def __init__(self, input_service, output_service):
"""The class constructor.
Args:
self (Director): an instance of Director.
"""
self._input_service = input_service
self._output_service = output_service
self._buffer = Buffer()
self._word = Word('test')
self._current_words = []
self._text_words = []
self._inputted_letter = ''
self._score = Score()
self._keep_playing = True
def start_game(self):
"""
Begins the game cycle
"""
self.setup_game()
while self._keep_playing:
self._get_inputs()
self._do_updates()
self._do_outputs()
sleep(constants.FRAME_LENGTH)
def _get_random_word(self):
"""
This function retrieves a random word from the txt file.
"""
words = open('speed\game\words.txt').read().splitlines()
return random.choice(words)
def _make_words(self):
"""
This function makes word actors with random words pulled from the txt file.
"""
for i in range(random.randint(1, 2)):
word = Word(self._get_random_word())
self._current_words.append(word)
self._text_words.append(word.get_text())
def move_word_list(self, actor_list):
"""
This function takes the list of word actors and moves them all according to their velocity.
"""
for actor in actor_list:
actor.move_next()
def setup_game(self):
"""
Resets the buffer so that it displays correctly at the beginning
"""
self._buffer.reset_buffer()
def _get_inputs(self):
"""
Gets the keystrokes of the player
"""
self._inputted_letter = self._input_service.get_letter()
def _do_updates(self):
"""
With the keystrokes, this function writes the letters to the buffer,
checks if the keystrokes match the moving word actors, and moves the
actors continuely.
"""
if self._inputted_letter:
if self._inputted_letter == '*':
self._buffer.reset_buffer()
else:
self._buffer.set_letter(self._inputted_letter)
if self._buffer.get_text_buffer() != '':
buffer = self._buffer.get_text_buffer()
if 'bombz' in buffer:
self._score.set_score(random.randint(1000, 10000))
self._score.set_text(f'Score : {self._score.get_score()}')
self._text_words.clear()
self._current_words.clear()
self._text_words
for i in self._text_words:
if i in buffer:
self._score.set_word_points(i)
index = self._text_words.index(i)
del self._text_words[index]
del self._current_words[index]
break
self.move_word_list(self._current_words)
def _do_outputs(self):
"""
This function refreshes the asciimatics screen, and adds more words to the screen
if there are less than 15 currently being displayed. It also draws all of the game
components to the screen.
"""
self._output_service.clear_screen()
test = len(self._current_words)
if len(self._current_words) < 15:
self._make_words()
self._output_service.draw_actor(self._score)
self._output_service.draw_actors(self._current_words)
self._output_service.draw_actor(self._buffer)
self._output_service.flush_buffer()
def main_game(genomes, config):
gameSpeed = 4
gameOver = False
gameQuit = False
ground = Ground(screen, -1 * gameSpeed)
score = Score(screen)
nets = []
genomes_track = []
trexs = []
for _, genome in genomes:
net = neat.nn.FeedForwardNetwork.create(genome, config)
nets.append(net)
trexs.append(TRex(screen, 44, 47))
genome.fitness = 0
genomes_track.append(genome)
clouds = pygame.sprite.Group()
cactus = pygame.sprite.Group()
pteros = pygame.sprite.Group()
last_obstacle = pygame.sprite.Group()
Cloud.containers = clouds
Cactus.containers = cactus
Ptero.containers = pteros
while not gameOver:
for event in pygame.event.get():
if event.type == QUIT:
gameOver = True
quit()
if event.type == KEYDOWN:
if event.key == K_SPACE or event.key == K_UP:
for trex in trexs:
trex.jump()
if event.key == K_DOWN:
for trex in trexs:
trex.duck()
if event.type == KEYUP:
for trex in trexs:
trex.no_duck()
check_cactus_collide(cactus, trexs, genomes_track, nets)
check_pteros_collide(pteros, trexs, genomes_track, nets)
create_cactus(cactus, last_obstacle, gameSpeed)
create_ptero(pteros, last_obstacle, gameSpeed)
create_clouds(clouds)
for trex in trexs:
trex.update()
update_fitness(trexs, cactus, pteros, genomes_track, nets)
ground.update()
clouds.update()
cactus.update()
pteros.update()
score.update()
if pygame.display.get_surface() != None:
screen.fill(BG_COLOR)
ground.draw()
clouds.draw(screen)
cactus.draw(screen)
pteros.draw(screen)
score.draw()
for trex in trexs:
trex.draw()
pygame.display.update()
if (score.get_score() > 1000 and gameSpeed == 4) or \
(score.get_score() > 2000 and gameSpeed == 4.5) or \
(score.get_score() > 3000 and gameSpeed == 5) or \
(score.get_score() > 4000 and gameSpeed == 5.5):
gameSpeed += 0.5
ground.set_speed(-1 * gameSpeed)
if len(trexs) == 0:
gameOver = True
clock.tick(FPS)
"""
class Game:
def __init__(self):
init()
font.init()
display.set_caption(TITLE)
key.set_repeat()
self.playing = False
self.screen = display.set_mode((WIDTH, HEIGHT))
self.clock = time.Clock()
self.dt = self.clock.tick(FPS) / 1000
self.labels = list()
self.infos = list()
self.all_sprites = Group()
self.adventure = Home(self)
self.camera = Camera(self.adventure.map.width, self.adventure.map.height)
self.score = Score("Renato")
self.game_over = False
def update_adventure(self, adventure):
self.show_ended_screen()
self.adventure.player.kill()
self.labels = list()
self.infos = list()
self.adventure = adventure
self._update_camera()
self.show_go_screen()
self.score.start_adventure(adventure.level.level_score)
def run(self):
self.playing = True
while self.playing:
self.events()
self.update()
self.draw()
if self.game_over:
break
if self.adventure.finish:
self.show_end_adventure_screen()
break
def update(self):
# update info
self.infos = list()
self.adventure.update()
self.all_sprites.update()
self.camera.update(self.adventure.player)
def draw(self):
if not self.adventure.has_menu:
self.screen.blit(self.adventure.map_image, self.camera.apply_rect(self.adventure.map_rect))
for sprite in self.all_sprites:
self.screen.blit(sprite.image, self.camera.apply(sprite))
for label in self.labels:
self.screen.blit(label.surface, self.camera.apply_rect(label.rect))
for info in self.infos:
self.screen.blit(info.surface, info.rect)
for zombie in self.adventure.zombies:
zombie.draw_health()
display.flip()
def events(self):
events = key_event.get()
if not self.adventure.has_menu:
for event in events:
if event.type == QUIT:
self.__quit__()
if event.type == KEYDOWN:
if event.key == K_ESCAPE:
self.__quit__()
self.adventure.events(events)
def show_start_screen(self):
pass
def show_go_screen(self):
self.update()
start_display = Surface((WIDTH, HEIGHT), SRCALPHA)
for alpha in range(255, 0, -1):
start_display.fill((0, 0, 0, alpha))
self.screen.blit(self.adventure.map_image, self.camera.apply_rect(self.adventure.map_rect))
self.screen.blit(start_display, (0, 0))
display.flip()
time.delay(10)
def show_ended_screen(self):
self.update()
start_display = Surface((WIDTH, HEIGHT), SRCALPHA)
for alpha in range(255):
start_display.fill((0, 0, 0, alpha))
self.screen.blit(self.adventure.map_image, self.camera.apply_rect(self.adventure.map_rect))
self.screen.blit(start_display, (0, 0))
display.flip()
time.delay(10)
def show_game_over_screen(self):
game_over_display = Surface((WIDTH, HEIGHT), SRCALPHA)
game_over_text = Label('Game Over', 'assets/fonts/blocks.ttf', 20, (HEIGHT / 2) - 100, font_size=72)
score_text = Label('For save the score you need finish adventure', 'assets/fonts/future_narrow.ttf', 20,
(HEIGHT / 2) - 120, font_size=24)
return_text = Label('You will return to home', 'assets/fonts/future_narrow.ttf', 20, (HEIGHT / 2) - 160,
font_size=24)
for alpha in range(255):
game_over_display.fill((0, 0, 0, alpha))
self.screen.blit(game_over_display, (0, 0))
self.screen.blit(game_over_text.surface, game_over_text.rect)
self.screen.blit(score_text.surface, score_text.rect)
self.screen.blit(return_text.surface, return_text.rect)
display.flip()
time.delay(10)
def show_end_adventure_screen(self):
end_surface = Surface((WIDTH, HEIGHT), SRCALPHA)
end_text = Label('Good Nice!', 'assets/fonts/blocks.ttf', 20, (HEIGHT / 2) - 100, font_size=72)
score_text = Label(f'Score: {self.score.calculate_score()}', 'assets/fonts/future_narrow.ttf', 20,
(HEIGHT / 2) - 120, font_size=24)
return_text = Label('You will return to home and see you score ranking', 'assets/fonts/future_narrow.ttf', 20,
(HEIGHT / 2) - 160,
font_size=24)
for alpha in range(255):
end_surface.fill((0, 0, 0, alpha))
self.screen.blit(end_surface, (0, 0))
self.screen.blit(end_text.surface, end_text.rect)
self.screen.blit(score_text.surface, score_text.rect)
self.screen.blit(return_text.surface, return_text.rect)
display.flip()
time.delay(10)
def _update_camera(self):
self.camera = Camera(self.adventure.map.width, self.adventure.map.height)
@staticmethod
def __quit__():
quit()
sys.exit()
