class Revisao: """Calsse que executa o programa criado na aula de revisão.""" def setup(self, width, height, bg=color.BLACK): self.window = Window(width, height) self.objects = [] self.background = bg def add_object(self, object): self.objects.append(object) def run(self): clock = pygame.time.Clock() running = True while running: # handle events for evt in pygame.event.get(): if evt.type == pygame.QUIT: running = False continue # update objects for obj in self.objects: obj.update(self.window.size) # clear window. self.window.clear(self.background) # draw objects for obj in self.objects: self.window.draw(obj) # update window self.window.update() # ensure maximum speed clock.tick(240)
def main(screen): # setup the basic syntax for text files text_syntax = SyntaxClass("basic") text_syntax.add("character", r".") text_syntax.add("word", r" ") text_syntax.add("sentance", r"\.") # make the main window mainwin = Window(screen, FileBuffer(open("README.markdown"))) mainwin.render() # the event loop while True: event = screen.getch() if event == ord("q"): break if event == ord("e"): mainwin.clear() if event == ord("r"): mainwin.render() if event == ord("f"): mainwin.addstr("X") if event == ord("w"): mainwin.rmove(0, -1) if event == ord("a"): mainwin.rmove(-1, 0) if event == ord("s"): mainwin.rmove(0, +1) if event == ord("d"): mainwin.rmove(+1, 0) if event == ord("x"): mainwin.here() def find(syntaxname): return lambda t, x, y: text_syntax.find(syntaxname, t, x, y) if event == ord("c"): mainwin.movef(find("character")) if event == ord("v"): mainwin.movef(find("word"))
class Game: def __init__(self): self.window_width = 640 self.window_height = 480 self.window = Window("WORMS BITCH", self.window_width, self.window_height) self.event = Event() self.main_scene = MainScene(self) self.clock = pygame.time.Clock() self.delta = 0 self.end = False # Set this attribute to True ton end the game. def update(self): self.update_delta() self.event.update() if self.event.exit: self.end = True self.main_scene.update(self.event) def draw(self): self.window.clear() self.main_scene.draw() self.window.update() def update_delta(self): self.delta = self.clock.tick(60) def exit(self): pass
class GlutWindow(object): def __init__(self, width, height, title): super(GlutWindow, self).__init__() self.width = width self.height = height self.title = title self.texture_id = 0 self.vertices = None self.pixels = np.zeros(self.width * self.height) self.window = Window(self.width, self.height, self.pixels) self.setup() def mouse_event(self, button, state, x, y): self.window.mouse_event(button, state, x, y) def key_event(self, key, key_is_down, x, y): key = ord(key) self.window.key_event(key, key_is_down) def key_down(self, key, x, y): self.key_event(key, True, x, y) def key_up(self, key, x, y): self.key_event(key, False, x, y) def setup(self): self.setup_glut() self.setup_gl() def setup_glut(self): # glutInit(sys.argv) glutInit() glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA) glutInitWindowSize(self.width, self.height) glutCreateWindow(self.title) glutDisplayFunc(self.show) glutMouseFunc(self.mouse_event) glutKeyboardFunc(self.key_down) glutKeyboardUpFunc(self.key_up) # glutSetKeyRepeat(GLUT_KEY_REPEAT_ON) def setup_gl(self): glEnable(GL_BLEND) glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA) glClearColor(0, 0, 0, 1) glViewport(0, 0, self.width, self.height) self.texture_id = glGenTextures(1) glEnable(GL_TEXTURE_2D) glBindTexture(GL_TEXTURE_2D, self.texture_id) # glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE) # glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST) glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.width, self.height, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, self.pixels) self.vertices = [ # (u, v), (x, y, z) (0, 0), (-1, -1, 0), (1, 0), (1, -1, 0), (1, 1), (1, 1, 0), (0, 1), (-1, 1, 0), ] def update(self, dt=100): # clear self.clear() # update delta = dt / 1000.0 self.window.update(delta) # draw self.window.draw() # show glutPostRedisplay() glutTimerFunc(dt, self.update, dt) def run(self): self.update() glutMainLoop() def clear(self): glClear(GL_COLOR_BUFFER_BIT) self.window.clear() def show(self): # update texture and render glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, self.width, self.height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, self.pixels) vertices = self.vertices glBegin(GL_QUADS) for i in range(0, 4 * 2, 2): glTexCoord2f(*vertices[i]) glVertex3f(*vertices[i + 1]) glEnd() glutSwapBuffers()
class SnakeGame: """ A simple structure for a Snake-like game. Attributes: ----------------- window : Window The main window of the game. Makes sure that the implementation is visible to the user. snake_size : tuple(int, int) The size of the snake. snake : Snake The controllable snake. current_movement : Callable One of the four directional functions from the Snake class. Saved for convenience and used to call movement on the snake-attribute. fruit_coordinates : list(int, int) The positional coordinates of the fruit that the snake is to eat. fruit_size : tuple(int, int) The size of the fruit. running : bool Used to control the state of the game. If false, the player has either exited or lost the game. last_update_time : int If the difference between this and a clock check is above 150 the method update_movement is called and this attribute updated. Methods: ----------------- handle_keydown(event): Function to handle user input events incoming from the underlying pygame module. draw(): Draw the game to the screen. move_fruit(): Randomly moves the fruit until it does not collide with the snake anymore. Used after the fruit is picked up. fruit_pickup(): Used to control if the snake is able to pick up the fruit. If the snake is able to pick the fruit up, the snake will grow and the fruit will be moved to a new position. check_if_inside_window(): Used to control whether the snake is inside the boundaries of the screen or not. If the snake is not inside the boundaries, the game is over. run_game_logic(): The main function used to run the game logic. Makes sure that all other functions are called as they should. game_loop(): The entry point of the game. Clears the screen, runs the game logic, and make sure that the screen is presented at the end. update_move(): Function to update the movement and control if the snake collides with itself. """ #pylint: disable=no-member def __init__(self, background_colour, width, height): """Initialize the game. The parameters are passed on to the init function of Window Parameters: ------------------------------------------ colour : list(int, int, int) A triple of values between 0 and 255 indicating the r, g, b value of the rectangle top_left : tuple(int, int) The x- and y-coordinates for the top left corner of the rectangle size : tuple(int, int) The width and height of the rectangle """ self.window = Window(background_colour, width, height) self.snake_size = (30, 30) self.snake = Snake((width//2, height//2), self.snake_size, (75, 75, 75)) self.current_movement = Snake.move_up self.fruit_coordinates = (0, 0) self.fruit_size = (30, 30) self.running = True self.last_update_time = pygame.time.get_ticks() def handle_keydown(self, event): """Handle key input from the user. Check if the key pressed is any of the keys used to control the snake, that is any of the WASD-keys or the arrow keys, or ESC for quiting the game. If any of the WASD-keys or arrow keys are pressed, change direction of the snake to the appropiate direction. Parameters: event : pygame.event An event containing a pressed key. """ pressed_key = event.key if pressed_key in (pygame.K_a, pygame.K_LEFT): self.current_movement = Snake.move_left elif pressed_key in (pygame.K_d, pygame.K_RIGHT): self.current_movement = Snake.move_right elif pressed_key in (pygame.K_w, pygame.K_UP): self.current_movement = Snake.move_up elif pressed_key in (pygame.K_s, pygame.K_DOWN): self.current_movement = Snake.move_down elif pressed_key == pygame.K_ESCAPE: self.running = False def draw(self): """Makes sure all the components of the game are presented on the screen.""" self.window.draw_rect( (255, 0, 0), self.fruit_coordinates, self.fruit_size ) for part in self.snake: coordinates = part.get_coordinates() size = part.get_size() colour = part.get_colour() self.window.draw_rect( colour, coordinates, size ) def move_fruit(self): """ Randomly moves the fruit until it does not collide with the snake anymore. Used after the fruit is picked up. """ while True: screen_size = (self.window.width(), self.window.height()) new_x = randrange(0, screen_size[0] - self.fruit_size[0], self.fruit_size[0]) new_y = randrange(0, screen_size[1] - self.fruit_size[1], self.fruit_size[1]) self.fruit_coordinates = (new_x, new_y) position_ok = True if self.snake.check_collision(self.fruit_coordinates, self.fruit_size): position_ok = False if position_ok: break def fruit_pickup(self): """ Used to control if the snake is able to pick up the fruit. If the snake is able to pick the fruit up, the snake will grow and the fruit will be moved to a new position. """ if self.snake.check_collision_with_fruit(self.fruit_coordinates, self.fruit_size): self.move_fruit() self.snake.grow() def is_inside_window(self): """ Used to control whether the snake is inside the boundaries of the screen or not. If the snake is not inside the boundaries, the game is over. Return: bool True: Inside window False: Not inside window """ screen_size = (self.window.width(), self.window.height()) if self.snake.inside_bounds( (0, 0), (screen_size[0] - self.snake_size[0], screen_size[1] - self.snake_size[1])): return True return False def update_move(self): """ Function to update the movement and control if the snake collides with itself. Called through a pygame registered event. """ self.current_movement(self.snake) if self.snake.check_collision_with_self() or not self.is_inside_window(): self.running = False def run_game_logic(self): """ The entry point of the game. Clears the screen, runs the game logic, and make sure that the screen is presented at the end. """ for event in pygame.event.get(): if event.type == pygame.QUIT: self.running = False elif event.type == pygame.KEYDOWN: self.handle_keydown(event) time_since_update = pygame.time.get_ticks() - self.last_update_time if time_since_update > 150: self.last_update_time = pygame.time.get_ticks() self.update_move() self.fruit_pickup() self.draw() def game_loop(self): """ The main loop of the game. Will continue to play until running is set to false. """ self.running = True while self.running: self.window.clear() self.run_game_logic() pygame.display.flip()
def start_client(sc, origin, pubkey, subkey, channel): global MSG_CURSOR global AUTO_PUBLISH # Set locale encoding import locale locale.setlocale(locale.LC_ALL, '') code = locale.getpreferredencoding() MAXY, MAXX = sc.getmaxyx() curses.use_default_colors() curses.init_pair(1, curses.COLOR_WHITE, COLOR_DEFAULT) curses.init_pair(2, curses.COLOR_CYAN, COLOR_DEFAULT) curses.init_pair(3, curses.COLOR_YELLOW, COLOR_DEFAULT) curses.init_pair(4, curses.COLOR_MAGENTA, COLOR_DEFAULT) # Check for min terminal height if MAXY < 46: sc.addstr(0, 0, "Your terminal window is too small. Please make it taller and try again. Press any key to continue...", curses.color_pair(3)) sc.getch() return 1 draw_header(sc, origin, pubkey, subkey, channel) # Draw winows sub_win = Window(sc, HEADER_LINES + 1, SUB_WINDOW_LINES, "Messages:") presence_win = Window(sc, HEADER_LINES + SUB_LINES + PUB_LINES + 1, PRESENCE_LINES, "Presence:") history_win = Window(sc, HISTORY_Y, HISTORY_LINES, "History:") # Draw Subscribe controls sc.addstr(SUB_Y, 22, "Scroll", curses.color_pair(1)) sc.addch(SUB_Y, 29, curses.ACS_UARROW, curses.color_pair(2)) sc.addch(SUB_Y, 31, curses.ACS_DARROW, curses.color_pair(2)) # Draw history controls sc.addstr(HISTORY_Y, 10, "Refresh", curses.color_pair(1)) sc.addstr(HISTORY_Y, 18, "(h)", curses.color_pair(2)) sc.addstr(HISTORY_Y, 22, "Scroll", curses.color_pair(1)) sc.addstr(HISTORY_Y, 29, "(j)", curses.color_pair(2)) sc.addstr(HISTORY_Y, 33, "(k)", curses.color_pair(2)) # Draw publish controls sc.addstr(PUB_Y, 0, "Publish: Re-Publish last", curses.color_pair(1)) sc.addstr(PUB_Y, 9, "(Ctrl-G)", curses.color_pair(2)) sc.addstr(PUB_Y, 34, "(r)", curses.color_pair(2)) auto_publish_state(sc, "info") pub_win, pub_text = draw_pubbox(sc) # Setup stdscr sc.refresh() sub_win.refresh() pub_win.refresh() presence_win.refresh() history_win.refresh() logger = threading.Thread(target=message_log, args=(sub_win,)) logger.daemon=True logger.start() log_parser = threading.Thread(target=parse_logs, args=(sc,)) log_parser.daemon = True log_parser.start() subscriber = threading.Thread(target=subscribe, args=(origin, subkey, channel)) subscriber.daemon = True subscriber.start() presence_thread = threading.Thread(target=presence, args=(origin, subkey, channel, presence_win)) presence_thread.daemon = True presence_thread.start() history(origin, subkey, channel, history_win) while True: cmd = sc.getch() if cmd == ord('q'): break # Clear windows elif cmd == ord('c'): sub_win.clear() history_win.clear() presence_win.clear() elif cmd == ord('p'): #TODO: redrawing all is overkill pub_win, pub_text = draw_pubbox(sc) publish(origin, pubkey, subkey, channel, pub_text.edit()) # Re-publish elif cmd == ord('r'): publish(origin, pubkey, subkey, channel, pub_text.gather()) # Subscribe pane scrolling elif cmd == curses.KEY_UP: sub_win.scroll(-1) elif cmd == curses.KEY_DOWN: sub_win.scroll(1) # Auto publishing elif cmd == ord('a'): auto_publish_state(sc, "editing") sc.refresh() text = pub_text.edit() loop_timer = LoopTimer(5.0, publish, args=(origin, pubkey, subkey, channel, text)) loop_timer.start() auto_publish_state(sc, "publishing") ch = sc.getch() loop_timer.cancel() loop_timer = None auto_publish_state(sc, "info") # History controls elif cmd == ord('h'): history(origin, subkey, channel, history_win) elif cmd == ord('j'): history_win.scroll(1) elif cmd == ord('k'): history_win.scroll(-1) return 1
class Game: win_width = 1450 win_height = 800 def __init__(self): self.win = Window((Game.win_width, Game.win_height)) self.sky = Sky(Game.win_width, Game.win_height) self.platform = Platform(Game.win_width, 96, Game.win_height - 96 - 30) self.dino = None self.enemy_velocity = 250 self.score = 0 self.create_handlers() self.enemies = [] def create_handlers(self): self.win.add_handler('w', lambda x: self.jump()) self.win.add_handler('W', lambda x: self.jump()) self.win.add_handler('<space>', lambda x: self.reset()) def reset(self): if not self.dino.alive: self.dino.alive = True self.enemies = [] self.score = 0 self.enemy_velocity = 250 def jump(self): if self.dino: self.dino.jump() @property def window_is_open(self): return self.win.open def check_collision_with_ground(self): if not (self.dino.y + self.dino.height >= self.platform.y): return self.dino.y = self.platform.y - self.dino.height self.dino.reset_force() self.dino.allow_jump() def update_dino(self, dt: float): if not self.dino: return self.dino.tick(dt) self.check_collision_with_ground() def remove_enemies(self): for enemy in self.enemies: if enemy.x + enemy.width < 0: self.enemies.remove(enemy) else: return def move_enemies(self, dt: float): delta = -dt * self.enemy_velocity for enemy in self.enemies: enemy.move(delta) def tick_enemies(self, dt: float): for enemy in self.enemies: enemy.tick(dt) def update_enemies(self, dt: float): self.move_enemies(dt) self.tick_enemies(dt) self.remove_enemies() def update_score(self, dt: float): self.score += dt * 10 def update_platform(self, dt: float): delta = -dt * self.enemy_velocity self.platform.move(delta) def update(self, dt: float): self.update_dino(dt) self.update_enemies(dt) self.update_score(dt) self.update_platform(dt) self.sky.tick(dt) def tick(self, timedelta: float): if self.dino.alive: self.update(timedelta) self.draw() def display_score(self): c = self.win.canvas c.create_text(c.winfo_width() - 10, 20, text=f'Score: {int(self.score)}', anchor=tkinter.E, font=("Purisa", 24)) def display_game_over(self): c = self.win.canvas c.create_text(c.winfo_width() // 2, c.winfo_height() // 2, text='Game Over', font=("Purisa", 80)) c.create_text(c.winfo_width() // 2, c.winfo_height() // 2 + 60, text='Press space to play again', font=("Purisa", 25)) def draw(self): self.win.clear() self.win.draw(self.sky) self.win.draw(self.platform) for enemy in self.enemies: self.win.draw(enemy) if self.dino: self.win.draw(self.dino) if not self.dino.alive: self.display_game_over() self.display_score() self.win.update() def change_ground(self, path): self.platform.load_sprite(path) def add_player(self, dino: Dino): self.dino = dino def add_enemy(self, enemy): self.enemies.append(enemy) def increase_speed(self): self.enemy_velocity += 100
class Pong(Game): """Implements the pong game.""" def __init__(self, player1, player2): """Initialize the game.""" Game.__init__(self) self.__ball = GameBall(400, 300, 10) self.__restart_ball() self.__paddles = [Paddle((20, 150), (5, 260), (200, 200, 200)), Paddle((20, 150), (775, 260), (200, 200, 200))] self.window = Window(800, 600) self.window.set_title("Pong") self.add_object(self.__ball) for p in self.__paddles: self.add_object(p) self.__scores = [0, 0] self.digits = [Text(i, 48) for i in range(10)] def __restart_ball(self): self.__ball.position = (400, 300) self.__ball.movement = (choice([-0.5, 0.5]), choice([-0.5, 0.5])) def __ball_collision(self): c = collider.wall_circle_collision(self.window.bounds, self.__ball.bounds) dx, dy = self.__ball.movement dy *= -1 if {Wall.NORTH, Wall.SOUTH} & c else 1 # paddles sx = -1 if dx < 0 else 1 for p in self.__paddles: if collider.circle_rect_colision(self.__ball.bounds, p.bounds): dx = -1 * sx * (abs(dx) + 0.1) self.__ball.movement = (dx, dy) # walls if Wall.WEST in c: self.__scores[0] += 1 self.__restart_ball() if Wall.EAST in c: self.__scores[1] += 1 self.__restart_ball() def __paddle_collision(self): for p in self.__paddles: dx, dy = p.movement if collider.wall_rect_collision(self.window.bounds, p.bounds): dy *= -1 p.movement = (dx, dy) def _update(self): """Update objects.""" self.__ball_collision() self.__paddle_collision() Game._update(self) def _draw(self): self.window.clear() third = self.window.width // 3 for i, s in enumerate(self.__scores): x = (2 - i)*third for c in str(s): d = self.digits[int(c)] d.position = (x, 5) x += d.rect.width + 2 self.window.draw(d) Game._draw(self, False)
def main(): random.seed(time.time()) # Initialise colorama init() # Clear screen print(chr(27) + '[2j') print('\033c') print('\x1bc') # Get terminal size (ncols, nlines) = shutil.get_terminal_size() # Initialise screen screen = Window(0, 1, ncols, nlines - 1, f"{config.bkgd} ") # Initialise keyboard kb = KBHit() # Create and draw the paddle paddle = Paddle(((ncols - 1) - config.paddle["dim"][0]) // 2, nlines - 4, screen) last_update = 0 start = time.time() score = 0 lives = 3 curr_level = 1 # List to store shooters shooters = [None, None] while curr_level <= 3: # Create and draw bricks boss = None if curr_level == 1: bricks, powerups = levels.level_one(screen) elif curr_level == 2: bricks, powerups = levels.level_two(screen) elif curr_level == 3: bricks, powerups = levels.level_three(screen) boss = Boss(ncols // 2, 5, screen) else: sys.exit() if lives == 0: break while lives: # Reset paddle location paddle.x = ((ncols - 1) - config.paddle["dim"][0]) // 2 paddle.powerup = None # Create and draw the ball balls = [ Ball(random.randrange(paddle.x, paddle.x + paddle.width), nlines - 5, list(config.ball["speed"]), 1, screen) ] # List to store bullets bullets = [] shoot_paddle = [0] # List to store bombs bombs = [] tick = 0 while len(balls): if (time.time() - last_update > config.tick_interval): tick += 1 for i in range(ncols): print(f"{Cursor.POS(1+i, 1)}{Back.BLACK} ", end='') statusline = f"{Cursor.POS(1, 1)}Level: {curr_level} " statusline += f"Score: {score} " statusline += f"Time: {int(time.time() - start)} " statusline += f"Lives: {lives} " statusline += f"Shoot Paddle: {int(shoot_paddle[0] * config.tick_interval)} " if boss: statusline += "Boss Health: [" for i in range(0, boss.health, 10): statusline += "•" for i in range(0, 100 - boss.health, 10): statusline += " " statusline += "]" print(statusline, end='') last_update = time.time() change_level = False direction = 0 if kb.kbhit(): c = kb.getch() if ord(c) == 27: sys.exit(0) if c == 'a': direction = -1 elif c == 'd': direction = 1 elif c == ' ': # Activate balls for ball in balls: ball.paused = False elif c == '1' or c == '2' or c == '3': curr_level = int(c) if curr_level != 3 else 4 change_level = True break # Create new bullets if needed shoot_paddle[0] = max(0, shoot_paddle[0] - 1) if shoot_paddle[0] and shoot_paddle[0] % config.bullet[ "rate"] == 0: bullets.append( Bullet(max(paddle.x, 0), paddle.y, config.bullet["speed"], screen)) bullets.append( Bullet( min(paddle.x + paddle.width, screen.get_screen_size()[1] - 1), paddle.y, config.bullet["speed"], screen)) # Create bomb if needed if boss and tick % config.bomb["rate"] == 0: bombs.append( Bomb(boss.x + 5, boss.y + 3, config.bomb["speed"], screen)) # Create shooters if needed if shoot_paddle[0] and not shooters[0]: shooters[0] = Object(paddle.x, paddle.y - 1, 1, 1, config.paddle["color"], screen) if shoot_paddle[0] and not shooters[1]: shooters[1] = Object(paddle.x + paddle.width - 1, paddle.y - 1, 1, 1, config.paddle["color"], screen) # Create brick layer on boss level if health is 50 if boss and boss.health == 80 and not boss.done[0]: bricks.append([]) brick_count = screen.get_screen_size()[1] // \ (config.brick["dim"][0] + 5) for i in range(brick_count): bricks[1].append( Brick(i * (config.brick["dim"][0] + 5), 9, 1, screen)) boss.done[0] = True # Create brick layer on boss level if health is 20 if boss and boss.health == 20 and not boss.done[1]: brick_count = screen.get_screen_size()[1] // \ (config.brick["dim"][0] + 5) bricks.append([]) for i in range(brick_count): bricks[2].append( Brick(i * (config.brick["dim"][0] + 5), 13, 1, screen)) boss.done[1] = True # Clear screen screen.clear() # Move the paddle paddle.move(direction, balls) # Move the powerups to_delete = [] for powerup in powerups: object = None if powerup.type == "paddle": object = paddle elif powerup.type == "ball": object = balls else: object = shoot_paddle if not powerup.move(paddle, object, tick): to_delete.append(powerup) powerups = [ powerup for powerup in powerups if powerup not in to_delete ] # Move the ball to_delete = [] for ball in balls: delete, d_score = ball.move(bricks, paddle, boss) if not delete: to_delete.append(ball) score += d_score balls = [ball for ball in balls if ball not in to_delete] # Delete shooters if powerup is over if shoot_paddle[0] == 0: shooters = [None, None] # Move the bullets to_delete = [] for bullet in bullets: delete, d_score = bullet.move(bricks) if not delete: to_delete.append(bullet) score += d_score bullets = [ bullet for bullet in bullets if bullet not in to_delete ] # Move the bombs to_delete = [] lose_life = False for bomb in bombs: delete, lose_life = bomb.move(paddle) if not delete: to_delete.append(bomb) if lose_life: break if lose_life: break bombs = [bomb for bomb in bombs if bomb not in to_delete] # Move the boss if boss: boss.move(paddle.x + paddle.width // 2) # Move the shooter if shooters[0]: shooters[0].x = paddle.x if shooters[1]: shooters[1].x = paddle.x + paddle.width - 1 # Update bricks for layer in bricks: for brick in layer: brick.rainbow(tick) # Don't move bricks on boss level if curr_level < 3: brick.move(tick) if brick.y + brick.height > paddle.y: sys.exit() brick.update() # Update paddle paddle.update() # Update shooters for shooter in shooters: if shooter: shooter.update() # Update powerups for powerup in powerups: powerup.update() # Update ball for ball in balls: ball.update() # Update bullets for bullet in bullets: bullet.update() # Update bombs for bomb in bombs: bomb.update() # Boss update if boss: boss.update() screen.draw() # Check if all breackable bricks are broken on non boss levels if curr_level < 3: change_level = True for layer in bricks: for brick in layer: if brick._strength != 4: change_level = False break if not change_level: break else: if boss.health <= 0: change_level = True if change_level: curr_level += 1 break if change_level: break lives -= 1
# return self.x + 0.5 * self.width n, a, b = map(int, input().split()) a1 = a2 = a rect = Rectangle(randint(15, 95), randint(15, 800), a, b) square = Square(randint(15, 95), randint(15, 800), a1) circle = Circle(randint(15, 95), randint(15, 800), a2) shapes = [rect, square, circle] velocity = randint(4, 10) while not window.closed: # frame start start = time() window.clear() # clear window before redraw # redraw frame for num in range(n): alt = randint(0, 2) shapes[alt].x += velocity if shapes[alt].right() > window.width: velocity = -4 elif shapes[alt].left() < 0: velocity = 4 elif shapes[alt].top() > 0: velocity = 4 elif shapes[alt].bottom() < window.width: velocity = -4 rect.draw()