def __init__(self, center, bound, pwm, controller: PlayerController, player_turret: Turret, missile_turret: Turret, life_turret: Turret): super().__init__(center, bound, pwm) ''' INIT PLAYER ''' self.player_turret = player_turret self.player = Player(bound, bound, pwm, player_turret, controller) self.player.laser.on() ''' INIT MISSILE ''' self.missile_turret = missile_turret self.missile = NPC(pwm, missile_turret) self.missile.laser.on() ''' INIT LIFE COUNTER ''' self.life_turret = life_turret self.life_counter = NPC(pwm, life_turret) self.life_pos = int(center + bound / 2) # Put life counter out of bounds self.life_counter.set_servo( int(center - bound / 2) - 10, int(center + bound / 2)) self.life_counter.laser.on() self.life_distance = int(bound / self.lives)
class Maze(Game): def __init__( self, center, bound, pwm, controller: PlayerController, player_turret: Turret, ): super().__init__(center, bound, pwm) self.player = Player(bound, bound, pwm, player_turret, controller, initial_x=415, initial_y=415, x_center=375, y_center=375) self.player.laser.on() def play_on(self): self.playing = True binding = {} prev_time = 0 while self.playing: curr_time = time.time() if curr_time - prev_time >= self.time_rate: prev_time = curr_time x, y = self.player.manual_servo(**binding) binding = WALLS.check_collision(x, y)
def prepare_game(board_file: str, players: List[discord.User], channel: discord.TextChannel) -> MonopolyCore.Monopoly: players_class = [] for player in players: players_class.append(Player.Player(player)) board = Board.Board(board_file) return MonopolyCore.Monopoly(monopoly_bot, channel, players_class, board)
def run(width, height, num_bombs): pygame.init() game = Game(width, height, num_bombs) player = Player() win = pygame.display.set_mode((width * 32, height * 32)) running = True while running: events = pygame.event.get() for event in events: if event.type == pygame.QUIT: running = False pygame.quit() quit() player.update(events, game) game.draw(win)
def test_add_cash(self): p = Player.Player('0,0') p.add_cash(100) expected = 100 self.assertEqual(expected, p.get_cash()) p.add_cash(-1) expected = 100 self.assertEqual(expected, p.get_cash())
def main(): game = Game() ship_x = 330 ship_y = 500 ship_width = 32 ship_height = 32 player_ship = Player(ship_x, ship_y, ship_width, ship_height, ship) game.init() game.play(player_ship)
def __init__( self, center, bound, pwm, controller: PlayerController, player_turret: Turret, ): super().__init__(center, bound, pwm) self.player = Player(bound, bound, pwm, player_turret, controller, initial_x=415, initial_y=415, x_center=375, y_center=375) self.player.laser.on()
def __init__(self, center, bound, pwm, player_1_controller, player_2_controller, player_1_turret, player_2_turret, npc_turret): super().__init__(center, bound, pwm) self.player_1 = Player(bound, bound, pwm, player_1_turret, player_1_controller, no_x=True, fixed_x=int(center + bound / 2)) self.player_2 = Player(bound, bound, pwm, player_2_turret, player_2_controller, no_x=True, fixed_x=int(center - bound / 2)) self.ball = NPC(pwm, npc_turret) self.bounce = None
def test_use_cash(self): p = Player.Player('100,0') p.use_cash(101) expected = 100 self.assertEqual(expected, p.get_cash()) p.use_cash(-1) self.assertEqual(expected, p.get_cash()) p.use_cash(99) expected = 1 self.assertEqual(expected, p.get_cash())
def test_determine_winner(self): gameRunner = GameRunner.GameRunner() dealer = Dealer.Dealer() player = Player.Player(500) dealer_cards = [('Clubs', '5'), ('Clubs', '6'), ('Clubs', 'Queen')] player_cards = [('Clubs', '4'), ('Clubs', '5'), ('Clubs', 'Queen')] dealer.cards = dealer_cards player.cards = player_cards gameRunner.determine_winner(dealer, player, 50)
def test_use_compost(self): p = Player.Player('0,100') p.use_compost(101) expected = 100 self.assertEqual(expected, p.get_compost()) p.use_compost(-1) self.assertEqual(expected, p.get_compost()) p.use_compost(99) expected = 1 self.assertEqual(expected, p.get_compost())
def create_new_game(): global game_objects game_objects = [ Player.Player("", create_new=True), Apple.Apple("", create_new=True), Beet.Beet("", create_new=True), Carrot.Carrot("", create_new=True), Grape.Grape("", create_new=True), Pineapple.Pineapple("", create_new=True), Potato.Potato("", create_new=True), Rutabaga.Rutabaga("", create_new=True), Watermelon.Watermelon("", create_new=True) ] update_display_information() display_game_frame()
def load_game(): global game_objects with open(path.join(getcwd(), '..', 'txt-files', 'load_state'), 'r') as file: data = file.read().split('\n') game_objects = [ Player.Player(data[0]), Apple.Apple(data[1]), Beet.Beet(data[2]), Carrot.Carrot(data[3]), Grape.Grape(data[4]), Pineapple.Pineapple(data[5]), Potato.Potato(data[6]), Rutabaga.Rutabaga(data[7]), Watermelon.Watermelon(data[8]) ] update_display_information() display_game_frame()
def testSettlementPieceAvailable(self): """ Test that settlement building function doesn't allow building if player doesn't have settlement pieces to build with """ # Create game player_1 = Player(randomAction) player_2 = Player(randomAction) player_3 = Player(randomAction) player_4 = Player(randomAction) game_manager = GameManager([player_1, player_2, player_3, player_4]) game_manager.turn_counter = 7 # Give player 1 enough resources player_1.resource_cards = [4] * 5 # Give player_1 0 settlement pieces player_1.building_pieces[1] = 0 self.assertEqual(game_manager.buildSettlement(player_1, 5), False)
def testCorrectResources(self): """ Test that settlement building function doesn't allow building if player doesn't have enough resources """ # Create game player_1 = Player(randomAction) player_2 = Player(randomAction) player_3 = Player(randomAction) player_4 = Player(randomAction) game_manager = GameManager([player_1, player_2, player_3, player_4]) game_manager.turn_counter = 7 # Give player 1 0 resources player_1.resource_cards = [0] * 5 self.assertEqual(game_manager.buildSettlement(player_1, 5), False)
def testHasResources(self): """ Test hasResources function """ # Initialise player player = Player(randomAction) # Player with no resources requiring one of each type self.assertEqual(player.hasResources([1, 1, 1, 1, 1]), False) # Player with no resources requiring 4 resources self.assertEqual(player.hasResources([1, 1, 1, 0, 1]), False) # Player with enough resources player.resource_cards = [2, 2, 2, 2, 2] self.assertEqual(player.hasResources([1, 1, 1, 0, 1]), True)
def testOccupiedNode(self): """ Test that settlement building function doesn't allow building on already occupied node """ # Create game player_1 = Player(randomAction) player_2 = Player(randomAction) player_3 = Player(randomAction) player_4 = Player(randomAction) game_manager = GameManager([player_1, player_2, player_3, player_4]) game_manager.turn_counter = 7 # Give player 1 enough resources for building settlement player_1.resource_cards = [3] * 5 # 1st test another player with settlement on node 5 game_manager.game_board.nodes[5].settlement = [0, 1, 0, 0] self.assertEqual(game_manager.buildSettlement(player_1, 5), False) # 1st test another player with city on node 7 game_manager.game_board.nodes[7].city = [0, 1, 0, 0] self.assertEqual(game_manager.buildSettlement(player_1, 7), False)
def main(): # CONSTANTS IMAGE_SIZE = 100 settings = Settings() # Initialise settings object SCREEN_WIDTH, SCREEN_HEIGHT = settings.width, settings.height FLOOR_HEIGHT = SCREEN_HEIGHT * settings.floor_height_percentage PLAYER_START_X = 0.25 * SCREEN_WIDTH PLAYER_START_Y = FLOOR_HEIGHT display = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) pygame.init() clock = pygame.time.Clock() pygame.display.set_caption('Burrito Man') event = Event() # Initialise the event handler player = Player(PLAYER_START_X, PLAYER_START_Y, FLOOR_HEIGHT) # Initialise the player floor = Floor(display, SCREEN_WIDTH, SCREEN_HEIGHT, FLOOR_HEIGHT) physics = Physics() level = Level(display, SCREEN_WIDTH, SCREEN_HEIGHT, settings.floor_height_percentage) timer = Timer(display, GREEN, BLACK) display.fill(BLACK) # Generate obstacles obstacle_list = level.generateObstacles(obstacle_num=4) # Work out where the finish line should be (300px after last obstacle) end_coord = level.createEnd(obstacle_list) # Game loop while True: display.fill(BLACK) event.update(pygame.event.get(), player, obstacle_list) pygame.draw.rect(display, RED, player.rect) # display.blit(player.image, player.rect) # draw player floor.draw() timer.render(100, 100, pygame.time.get_ticks()) # draw all Obstacles in obstacle_list for obst in obstacle_list: # Draw the finish line as a vertical white line level.drawFinish(end_coord, player.world_scroll) obst.update(player.world_scroll) obst.draw() player.vertical_a = physics.calculate_vertical_acceleration( player, floor) player.vertical_velocity = physics.calculate_vertical_velocity( player, floor) # Update player y position player.rect.y = player.y + player.vertical_velocity if player.jumpAttempt is True: player.jump() # player.jump_animation() pygame.display.update() clock.tick(60) # opt arg: limit framerate; otherwise, unlimited print("\n###Debugging###") debug_statements( { "msg": "FPS", "args": round(clock.get_fps()) }, { "msg": "World scroll", "args": player.world_scroll }, { "msg": "Distance to finish", "args": round(end_coord[0] - player.world_scroll - 250, 2) }, { "msg": "Player touching floor", "args": physics.on_obj(player, floor) }, { "msg": "Vertical acceleration of player", "args": round(player.vertical_a, 2) }, { "msg": "Vertical velocity of player", "args": round(player.vertical_velocity, 2) }, )
class Pong(Game): """ Two players swat a ball back and forth. """ ''' PLAYER INFO ''' paddle_length = 15 ''' BALL INFO ''' ball_rate = 2 resetting = False skip_frame = False laser_blink = False reset_time = 0 reset_rate = 1 ''' GAME INFO ''' win_points = 10 def __init__(self, center, bound, pwm, player_1_controller, player_2_controller, player_1_turret, player_2_turret, npc_turret): super().__init__(center, bound, pwm) self.player_1_turret = player_1_turret self.player_2_turret = player_2_turret self.npc_turret = npc_turret self.player_1 = Player(bound, bound, pwm, player_1_turret, player_1_controller, no_x=True, fixed_x=int(center + bound / 2)) self.player_2 = Player(bound, bound, pwm, player_2_turret, player_2_controller, no_x=True, fixed_x=int(center - bound / 2)) self.ball = NPC(pwm, npc_turret) self.bounce = None def play_on(self): player_1_points = 0 player_2_points = 0 self.playing = True self.ball.laser.on() self.player_1.laser.on() self.player_2.laser.on() # vertical_hit = False # horizontal_hit = False while self.playing: if player_1_points == self.win_points: self.win(1) elif player_2_points == self.win_points: self.win(2) # pi/2 cone facing either player if random.randint(0, 1): angle = random.uniform(-0.785, 0.785) else: angle = random.uniform(2.355, 3.925) ball = self.make_ball(rate=self.ball_rate, angle=angle) prev_time = 0 while self.playing: self.curr_time = time.time() if self.curr_time - prev_time >= self.time_rate: if not self.resetting: xs, ys = ball.__next__() else: xs = self.center ys = self.center prev_time = self.curr_time x_1, y_1 = self.player_1.set_servo() x_2, y_2 = self.player_2.set_servo() x_1_hit = xs > 415 x_2_hit = xs < 320 y_1_hit = fabs(y_1 - ys) <= self.paddle_length y_2_hit = fabs(y_2 - ys) <= self.paddle_length # Player 1 or 2 lose if not y_1_hit and x_1_hit: player_2_points += 1 self.resetting = True self.reset_time = time.time() break elif not y_2_hit and x_2_hit: player_1_points += 1 self.resetting = True self.reset_time = time.time() break else: top_hit = ys >= (self.center + self.bound / 2) bottom_hit = ys <= (self.center - self.bound / 2) # Player hit if (y_1_hit and x_1_hit) or (y_2_hit and x_2_hit): self.bounce.vertical_hit(random_bounce=True) self.bounce.rate += 0.1 # Top or bottom wall hit elif top_hit or bottom_hit: self.bounce.horizontal_hit() self.handle_ball_resetting() def handle_ball_resetting(self): """ Handles all player info after firing, such as laser blinking :return: """ if self.resetting: if not self.skip_frame: self.skip_frame = True if self.laser_blink: self.ball.laser.on() else: self.ball.laser.off() self.laser_blink = not self.laser_blink else: self.skip_frame = False if self.curr_time - self.reset_time > self.reset_rate: self.resetting = False self.ball.laser.on() def make_ball(self, angle=2, rate=2): self.bounce = Bounce(self.center, self.center, angle, rate) ball_servo = self.ball.follow_path(self.bounce.data()) # Let the servos get into position. Yes, yield twice ball_servo.__next__() ball_servo.__next__() return ball_servo def win(self, player): if player == 1: del self.player_1.laser center = int(self.center + self.bound / 2) npc = NPC(self.pwm, self.player_1_turret) else: del self.player_2.laser center = int(self.center - self.bound / 2) npc = NPC(self.pwm, self.player_2_turret) circle = Circle(center, 375, 25, 0, 2) data = npc.follow_path(circle.data()) data.__next__() data.__next__() npc.laser.on() spin_spin = 0 prev_time = 0 while self.playing: self.curr_time = time.time() if self.curr_time - prev_time >= self.time_rate * 3: prev_time = self.curr_time data.__next__() spin_spin += 1 if spin_spin == 100: self.playing = False
def main(): global player player = Player.Player(db.connection, '/app/src/music')
def initializeGame(): #Incase you want to initialize more than the player at startup mainGuy = Player.Player(1000, 200, 10, 10,[]) return mainGuy
import time from src.GameManager import * from src.Player import * player_1 = Player(randomAction) player_2 = Player(randomAction) player_3 = Player(randomAction) player_4 = Player(randomAction) game_manager = GameManager([player_1, player_2, player_3, player_4]) start_time = time.time() game_manager.startGame() end_time = time.time() print(end_time - start_time)
def test_analyze_response_hit_response(self): dealer = self.dealer player = Player('George') player.response = 'hit' response = dealer.analyze_response(player) self.assertIsInstance(response, Card)
def test_analyze_response_stay_response(self): dealer = self.dealer player = Player('George') player.response = 'stay' response = dealer.analyze_response(player) self.assertIsNone(response)
class Pong(Game): """ Two players swat a ball back and forth. """ ''' PLAYER INFO ''' paddle_length = 10 x_hit = 0 ''' BALL INFO ''' ball_rate = 2 resetting = False skip_frame = False laser_blink = False reset_time = 0 reset_rate = 1 def __init__(self, center, bound, pwm, player_1_controller, player_2_controller, player_1_turret, player_2_turret, npc_turret): super().__init__(center, bound, pwm) self.player_1 = Player(bound, bound, pwm, player_1_turret, player_1_controller, no_x=True, fixed_x=int(center + bound / 2)) self.player_2 = Player(bound, bound, pwm, player_2_turret, player_2_controller, no_x=True, fixed_x=int(center - bound / 2)) self.ball = NPC(pwm, npc_turret) self.bounce = None def play_on(self): player_1_points = 0 player_2_points = 0 self.playing = True self.ball.laser.on() self.player_1.laser.on() self.player_2.laser.on() # vertical_hit = False # horizontal_hit = False while self.playing: ball = self.make_ball(self.ball_rate) prev_time = 0 # xs, ys = ball.send((horizontal_hit, vertical_hit)) while self.playing: self.curr_time = time.time() if self.curr_time - prev_time >= self.time_rate: if not self.resetting: # xs, ys = ball.send((horizontal_hit, vertical_hit)) xs, ys = ball.__next__() else: xs = self.center ys = self.center prev_time = self.curr_time x_1, y_1 = self.player_1.set_servo() x_2, y_2 = self.player_2.set_servo() x_1_hit = fabs(x_1 - xs) <= self.x_hit x_2_hit = fabs(x_2 - xs) <= self.x_hit y_1_hit = fabs(y_1 - ys) <= self.paddle_length y_2_hit = fabs(y_2 - ys) <= self.paddle_length # Player 1 or 2 lose if not y_1_hit and x_1_hit: player_2_points += 1 self.resetting = True self.reset_time = time.time() break elif not y_2_hit and x_2_hit: player_1_points += 1 self.resetting = True self.reset_time = time.time() break else: top_hit = ys >= (self.center + self.bound / 2) bottom_hit = ys <= (self.center - self.bound / 2) # Player hit if (y_1_hit and x_1_hit) or (y_2_hit and x_2_hit): # vertical_hit = True self.bounce.vertical_hit() # horizontal_hit = False self.bounce.rate += 0.1 # Top or bottom wall hit elif top_hit or bottom_hit: # vertical_hit = False # horizontal_hit = True self.bounce.horizontal_hit() # else: # vertical_hit = False # horizontal_hit = False # if not self.resetting: # xs, ys = ball.send((horizontal_hit, # vertical_hit)) self.handle_ball_resetting() def handle_ball_resetting(self): """ Handles all player info after firing, such as laser blinking :return: """ if self.resetting: if not self.skip_frame: self.skip_frame = True if self.laser_blink: self.ball.laser.on() else: self.ball.laser.off() self.laser_blink = not self.laser_blink else: self.skip_frame = False if self.curr_time - self.reset_time > self.reset_rate: self.resetting = False self.ball.laser.on() def make_ball(self, angle=2, rate=2): self.bounce = Bounce(self.center, self.center, angle, rate) ball_servo = self.ball.follow_path(self.bounce.data()) # Let the servos get into position. Yes, yield twice ball_servo.__next__() ball_servo.send((False, False)) return ball_servo
from src.Player import * from src.Deck import Deck from src.Game import Game print('\n' * 10) print('Welcome to the Casino Royale\'s high roller blackjack table, ' 'please enter your starting chip amount!') try: chips = int(input('Chips: ')) except ValueError: print('You have crashed the game bad boy') exit(1) my_player = Player(chips, [], 0) my_deck = Deck() my_dealer = Dealer([]) game = Game() who = 0 play_again = True game_options = { 1: 'Raise Bet', 2: 'Hit me', 3: 'Stop', 4: 'Check_hand', 5: 'Check total chips', 6: 'Cash out' } while play_again:
class Maze(Game): """ Find your way to the end! """ ''' GAME INFO ''' # TOUCHDOWN endzone = [[0, 16], [0, 16]] lose_time = 360 def __init__( self, center, bound, pwm, controller: PlayerController, player_turret: Turret, ): super().__init__(center, bound, pwm) self.player_turret = player_turret self.player = Player(bound, bound, pwm, player_turret, controller, initial_x=415, initial_y=415, x_center=375, y_center=375) self.player.laser.on() def play_on(self): self.playing = True binding = {} prev_time = 0 start_time = time.time() while self.playing: curr_time = time.time() if curr_time - prev_time >= self.time_rate: prev_time = curr_time x, y = self.player.manual_servo(**binding) binding = WALLS.check_collision(x, y) centered_x = x - self.center + self.bound / 2 centered_y = y - self.center + self.bound / 2 # Check if the player scored the winning goal!!! if self.endzone[0][0] <= centered_x <= self.endzone[0][1] and \ self.endzone[1][0] <= centered_y <= self.endzone[1][1]: self.win() self.playing = False if curr_time - start_time >= self.lose_time: self.playing = False def win(self): # Free up the GPIO pin del self.player.laser npc = NPC(self.pwm, self.player_turret) radius = 20 rate = 0.1 circle = Circle(375, 375, radius, 0, rate) data = npc.follow_path(circle.data()) data.__next__() data.__next__() npc.laser.on() for _ in range(0, 600): if _ % 100 == 0: circle.clockwise = False data.__next__()
class MissileDefense(Game): """ The player must aim and shoot at missile raining down on a peaceful city. """ ''' GAME INFO ''' curr_time = 0 ''' PLAYER INFO ''' # Delay until the player can fire again player_attack_rate = 1 # Size of player attack bomb_radius = 10 player_fired = False fire_time = 0 skip_frame = False laser_blink = False ''' MISSILE INFO ''' # How long to delay until the missile comes alive missile_delay = 1 # How much to increase the missile speed per success rate_increase = 0.1 ''' LIVES INFO ''' lives = 10 life_pos = 0 def __init__(self, center, bound, pwm, controller: PlayerController, player_turret: Turret, missile_turret: Turret, life_turret: Turret): super().__init__(center, bound, pwm) ''' INIT PLAYER ''' self.player = Player(bound, bound, pwm, player_turret, controller) self.player.laser.on() ''' INIT MISSILE ''' self.missile = NPC(pwm, missile_turret) self.missile.laser.on() ''' INIT LIFE COUNTER ''' self.life_counter = NPC(pwm, life_turret) self.life_pos = int(center + bound / 2) # Put life counter out of bounds self.life_counter.set_servo( int(center - bound / 2) - 10, int(center + bound / 2)) self.life_counter.laser.on() self.life_distance = int(bound / self.lives) def play_on(self): self.playing = True hit = False lose = False prev_time = 0 player_score = 0 missile_rate = 1 missile = self.make_missile() missile_respawn = False respawn_time = time.time() while self.playing: if hit: player_score += 1 missile_rate += self.rate_increase if lose: self.lives -= 1 self.life_pos -= self.life_distance self.life_counter.set_servo( int(self.center - self.bound / 2) - 10, self.life_pos) if hit or lose: hit = False lose = False self.missile.laser.off() missile = self.make_missile(missile_rate) missile_respawn = True respawn_time = time.time() # Win/lose conditions if player_score == 10: pass elif self.lives == 0: pass self.curr_time = time.time() if self.curr_time - prev_time >= self.time_rate: prev_time = self.curr_time p_x, p_y = self.player.set_servo() if not missile_respawn: try: m_x, m_y = missile.__next__() except StopIteration: lose = True else: if not self.player_fired and self.player.firing(): self.player_fired = True self.fire_time = time.time() dist_2_bomb = sqrt((m_y - p_y)**2 + (m_x - p_x)**2) if dist_2_bomb <= self.bomb_radius: hit = True else: if self.curr_time - respawn_time > self.missile_delay: missile_respawn = False self.missile.laser.on() self.handle_player_firing() def handle_player_firing(self): """ Handles all player info after firing, such as laser blinking :return: """ if self.player_fired: if not self.skip_frame: self.skip_frame = True if self.laser_blink: self.player.laser.on() else: self.player.laser.off() self.laser_blink = not self.laser_blink else: self.skip_frame = False if self.curr_time - self.fire_time > self.player_attack_rate: self.player_fired = False self.player.laser.on() def make_missile(self, rate=1) -> Generator: """ Creates a new random missile :param rate: :return: """ y_low = int(self.center - self.bound / 2) y_high = int(self.center + self.bound / 2) x_start = random.randint(y_low, y_high) # Since the controllers can't reach the corners, restrict them x_end = random.randint(y_low + 20, y_high - 20) path = Line(x_start, y_high, x_end, y_low, rate) missile = self.missile.follow_path(path.data()) # Let the servos get into position. Yield once for init, yield again to move servos missile.__next__() missile.__next__() return missile
class MissileDefense(Game): """ The player must aim and shoot at missile raining down on a peaceful city. """ ''' GAME INFO ''' curr_time = 0 num_missiles = 20 ''' PLAYER INFO ''' # Delay until the player can fire again player_attack_rate = 1 # Size of player attack bomb_radius = 15 player_fired = False fire_time = 0 skip_frame = False laser_blink = False ''' MISSILE INFO ''' # How long to delay until the missile comes alive missile_delay = 1 # How much to increase the missile speed per success rate_increase = 0.1 ''' LIVES INFO ''' lives = 10 life_pos = 0 def __init__(self, center, bound, pwm, controller: PlayerController, player_turret: Turret, missile_turret: Turret, life_turret: Turret): super().__init__(center, bound, pwm) ''' INIT PLAYER ''' self.player_turret = player_turret self.player = Player(bound, bound, pwm, player_turret, controller) self.player.laser.on() ''' INIT MISSILE ''' self.missile_turret = missile_turret self.missile = NPC(pwm, missile_turret) self.missile.laser.on() ''' INIT LIFE COUNTER ''' self.life_turret = life_turret self.life_counter = NPC(pwm, life_turret) self.life_pos = int(center + bound / 2) # Put life counter out of bounds self.life_counter.set_servo( int(center - bound / 2) - 10, int(center + bound / 2)) self.life_counter.laser.on() self.life_distance = int(bound / self.lives) def play_on(self): self.playing = True hit = False lose = False prev_time = 0 missile_rate = 1 missile = self.make_missile() missile_respawn = False respawn_time = time.time() while self.playing: if hit: missile_rate += self.rate_increase elif lose: self.lives -= 1 self.life_pos -= self.life_distance self.life_counter.set_servo( int(self.center - self.bound / 2) - 10, self.life_pos) if hit or lose: self.num_missiles -= 1 hit = False lose = False self.missile.laser.off() missile = self.make_missile(missile_rate) missile_respawn = True respawn_time = time.time() # Win/lose conditions. Check lose first in case of lives=missiles=0 if self.lives == 0: self.lose() break elif self.num_missiles == 0: self.win() break self.curr_time = time.time() if self.curr_time - prev_time >= self.time_rate: prev_time = self.curr_time p_x, p_y = self.player.set_servo() if not missile_respawn: try: m_x, m_y = missile.__next__() except StopIteration: lose = True else: if not self.player_fired and self.player.firing(): self.player_fired = True self.fire_time = time.time() dist_2_bomb = sqrt((m_y - p_y)**2 + (m_x - p_x)**2) if dist_2_bomb <= self.bomb_radius: hit = True else: if self.curr_time - respawn_time > self.missile_delay: missile_respawn = False self.missile.laser.on() self.handle_player_firing() def handle_player_firing(self): """ Handles all player info after firing, such as laser blinking :return: """ if self.player_fired: if not self.skip_frame: self.skip_frame = True if self.laser_blink: self.player.laser.on() else: self.player.laser.off() self.laser_blink = not self.laser_blink else: self.skip_frame = False if self.curr_time - self.fire_time > self.player_attack_rate: self.player_fired = False self.player.laser.on() def make_missile(self, rate=1, npc: NPC = None) -> Generator: """ Creates a new random missile :param rate: :param npc: :return: """ y_low = int(self.center - self.bound / 2) y_high = int(self.center + self.bound / 2) x_start = random.randint(y_low, y_high) # Since the controllers can't reach the corners, restrict them x_end = random.randint(y_low + 15, y_high - 15) if self.num_missiles > 5: path = Line(x_start, y_high, x_end, y_low, rate) else: # Last five missiles get cray-cray path = Corkscrew(x_start, y_high, x_end, y_low, 10, 0, 1, rate) if npc is None: missile = self.missile.follow_path(path.data()) else: missile = npc.follow_path(path.data()) # Let the servos get into position. Yield once for init, yield again to move servos missile.__next__() missile.__next__() return missile def win(self): """ "We're in the endgame now" - Wizard guy. :return: """ # Free up the GPIO pin del self.player.laser del self.missile.laser del self.life_counter.laser npc1 = NPC(self.pwm, self.player_turret) npc2 = NPC(self.pwm, self.missile_turret) npc3 = NPC(self.pwm, self.life_turret) radius = 20 rate = 0.1 circle1 = Circle(415, 375, radius, 0, rate) circle2 = Circle(375, 375, radius, 0, rate) circle3 = Circle(335, 375, radius, 0, rate, clockwise=False) data1 = npc1.follow_path(circle1.data()) data1.__next__() data1.__next__() npc1.laser.on() data2 = npc2.follow_path(circle2.data()) data2.__next__() data2.__next__() npc2.laser.on() data3 = npc3.follow_path(circle3.data()) data3.__next__() data3.__next__() npc3.laser.on() for _ in range(0, 400): if _ % 100 == 0: circle3.clockwise = False data1.__next__() data2.__next__() data3.__next__() def lose(self): """ "Did we just lose?" - Sun-Count. :return: """ # Free up the GPIO pin del self.player.laser del self.missile.laser del self.life_counter.laser npc1 = NPC(self.pwm, self.player_turret) npc2 = NPC(self.pwm, self.missile_turret) npc3 = NPC(self.pwm, self.life_turret) npc1.laser.on() npc2.laser.on() npc3.laser.on() rate = 2 m1 = self.make_missile(rate, npc1) m2 = self.make_missile(rate, npc2) m3 = self.make_missile(rate, npc3) prev_time = 0 num_losers = 15 while True: if num_losers == 0: break self.curr_time = time.time() if self.curr_time - prev_time >= self.time_rate: prev_time = self.curr_time try: m1.__next__() except StopIteration: m1 = self.make_missile(rate, npc1) num_losers -= 1 try: m2.__next__() except StopIteration: m2 = self.make_missile(rate, npc2) num_losers -= 1 try: m3.__next__() except StopIteration: m3 = self.make_missile(rate, npc3) num_losers -= 1