def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): # Create a graphical window, with some extra space. window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=window_width, height=window_height, title=title) # Create a paddle. self.paddle = GRect(paddle_width, paddle_height) self.window.add(self.paddle, (self.window.width - paddle_width) / 2, self.window.height - paddle_offset - paddle_height) self.paddle.filled = True self.paddle.fill_color = 'blue' self.paddle.color = 'blue' # Center a filled ball in the graphical window. self.ball = GOval(ball_radius * 2, ball_radius * 2) self.ball.filled = True self.reset_ball() # Default initial velocity for the ball. self.__dx = 0 self.__dy = 0 self.switch = False # Initialize our mouse listeners. onmouseclicked(self.game_start) onmousemoved(self.move_paddle) # Draw bricks. by = 0 for i in range(brick_rows): bx = 0 for j in range(brick_cols): self.brick = GRect(brick_width, brick_height) self.brick.filled = True if i < brick_cols / 5: self.brick.fill_color = 'red' elif brick_cols / 5 <= i < brick_cols / 5 * 2: self.brick.fill_color = 'orange' elif brick_cols / 5 * 2 <= i < brick_cols / 5 * 3: self.brick.fill_color = 'yellow' elif brick_cols / 5 * 3 <= i < brick_cols / 5 * 4: self.brick.fill_color = 'green' else: self.brick.fill_color = 'blue' self.window.add(self.brick, bx, brick_offset+by) bx += brick_width + brick_spacing by += brick_height + brick_spacing # scoreboard self.earned_score = 0 self.total_score = brick_cols * brick_rows self.scoreboard = GLabel(f'score: {self.earned_score}/{self.total_score}', x=10, y=30) self.scoreboard.font = 'courier-20' self.window.add(self.scoreboard)
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout', __dy=INITIAL_Y_SPEED): # Create a graphical window, with some extra space. self.window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing self.window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=self.window_width, height=self.window_height, title=title) # Create a paddle. self.paddle = GRect(width=paddle_width, height=paddle_height, x=(self.window_width-paddle_width)/2, y=(self.window_height-paddle_offset-paddle_height)) self.paddle.filled = True self.paddle.color = '#513743' self.paddle.fill_color = '#513743' self.window.add(self.paddle) self.life_label = GLabel('● ● ●') self.life_label.font = '-15' self.life_label.color = '#c53d43' self.score_label = GLabel('score: 0') self.score_label.font = '-15' self.score_label.color = '#455765' self.brick_rows = BRICK_ROWS self.brick_cols = BRICK_COLS # Initialize our mouse listeners. onmousemoved(self.reset_paddle_location) # Draw bricks. self.create_bricks()
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): # Create a graphical window, with some extra space. self.window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing self.window_height = brick_offset + 3 * ( brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=self.window_width, height=self.window_height, title=title) # Create a paddle. self.pw = paddle_width self.ph = paddle_height self.paddle = GRect(self.pw, self.ph, x=(self.window_width - self.pw) / 2, y=self.window_height - paddle_offset) self.paddle.filled = True self.window.add(self.paddle) # Center a filled ball in the graphical window. self.bra = ball_radius * 2 self.ball = GOval(self.bra, self.bra) self.ball.filled = True self.window.add(self.ball, (self.window_width - self.bra) / 2, (self.window_height - self.bra) / 2) # Default initial velocity for the ball. self.__dx = 0 self.__dy = 0 # Initialize our mouse listeners. onmousemoved(self.paddle_move) onmouseclicked(self.ball_move) # Draw bricks. self.build_bricks() self.score = 0 self.score_text = GLabel('Score: ' + str(self.score)) self.score_text.font = '-15-bold' self.window.add(self.score_text, 0, self.window_height) self.lives_text = GLabel('Lives: ' + str(3)) self.lives_text.font = '-15-bold' self.window.add(self.lives_text, self.window_width - 80, self.window_height)
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): # Create a graphical window, with some extra space window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=window_width, height=window_height, title=title) self.paddle_offset = PADDLE_OFFSET self.ball_r = BALL_RADIUS # Create a paddle self.paddle = GRect(paddle_width, paddle_height, x=(window_width-paddle_width)/2, y=window_height-paddle_offset-paddle_height) self.paddle.filled = True self.paddle.fill_color = 'blue' self.window.add(self.paddle) # Center a filled ball in the graphical window self.first_ball = GOval(ball_radius*2, ball_radius*2, x=(window_width-ball_radius)/2, y=(window_height-ball_radius)/2) self.first_ball.filled = True self.first_ball.fill_color = 'black' self.window.add(self.first_ball) self.initial_x = (window_width-ball_radius)/2 self.initial_y = (window_height-ball_radius)/2 # Default initial velocity for the ball self.__dx = random.randint(1, MAX_X_SPEED) self.__dy = INITIAL_Y_SPEED if random.random() > 0.5: self.__dx = -self.__dx # Initialize our mouse listeners self.activate = False self.crash_is_paddle = False self.crash_is_brick = False self.point_count = 0 onmousemoved(self.paddle_move) onmouseclicked(self.ball_start) # Draw bricks for y_pos in range(0, (BRICK_HEIGHT+BRICK_SPACING)*BRICK_ROWS-BRICK_SPACING, BRICK_HEIGHT+BRICK_SPACING): for x_pos in range(0, (BRICK_WIDTH+BRICK_SPACING)*BRICK_COLS-BRICK_SPACING, BRICK_WIDTH+BRICK_SPACING): self.brick = GRect(BRICK_WIDTH, BRICK_HEIGHT) self.brick.filled = True if y_pos < BRICK_HEIGHT+BRICK_SPACING * 2 + 1: self.brick.fill_color = 'red' elif y_pos < (BRICK_HEIGHT+BRICK_SPACING) * 4: self.brick.fill_color = 'orange' elif y_pos < (BRICK_HEIGHT+BRICK_SPACING) * 6: self.brick.fill_color = 'yellow' elif y_pos < (BRICK_HEIGHT+BRICK_SPACING) * 8: self.brick.fill_color = 'green' elif y_pos < (BRICK_HEIGHT+BRICK_SPACING) * 10: self.brick.fill_color = 'blue' else: self.brick.fill_color = 'black' self.window.add(self.brick, x=x_pos, y=y_pos)
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): # Create a graphical window, with some extra space window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=window_width, height=window_height, title='Breakout') # Element score label self.score = 0 self.score_label = GLabel('Score: ' + str(self.score)) # Element for game winning self.win_show = GLabel('Create by Mike Lin', x=100, y=100) self.win_show2 = GLabel('March 20 stanCode SC101', x=135, y=115) # Create a paddle self.paddle = GRect(paddle_width, paddle_height, x=(window_width - paddle_width) / 2, y=window_height - paddle_offset) self.window.add(self.paddle) self.paddle.filled = True # Center a filled ball in the graphical window self.ball = GOval(2 * ball_radius, 2 * ball_radius, x=window_width / 2 - ball_radius, y=window_height / 2 - ball_radius) self.ball_x = window_width / 2 - ball_radius self.ball_y = window_height / 2 - ball_radius # Default initial velocity for the ball self.__dx = 0 self.__dy = 0 # Other variables self.total_bricks = 0 # Initialize our mouse listeners onmousemoved( self.paddle_move) # using own method must add 'self.' in the front onmouseclicked(self.clicked) self.draw_bricks_and_ball()
def main(): opening() life_ui.font = "-15" score_ui.font = "-15" w.add(life_ui, x=w.width - life_ui.width, y=w.height - life_ui.height) w.add(score_ui, x=0, y=w.height - score_ui.height) onmousemoved(mouse_move) onmouseclicked(main_game)
def main(): window.add(rect) rect.filled = True rect.color = COLOR rect.fill_color = COLOR onmousemoved(reset_position) onmouseclicked(my_punch) onmousedragged(draw)
def main(): """ This program will prepare canvas for drawing circle and line, while listening to onmouseclicked and onmousemove events. """ prepare_canvas() onmouseclicked(click_event) onmousemoved(move_event)
def main(): """ This program will set attribute to the ball and add ball instance on window, while listening to onmouseclicked and onmousemoved events. """ ball_setting() onmouseclicked(click_event) onmousemoved(move_event)
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): # Create a graphical window, with some extra space. window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=window_width, height=window_height, title=title) # Create a paddle. self.pof = paddle_offset self.paddle = GRect(paddle_width, paddle_height) self.paddle.filled = True self.window.add(self.paddle, (window_width - self.paddle.width) / 2, window_height - self.pof) # Center a filled ball in the graphical window. self.ball = GOval(2 * ball_radius, 2 * ball_radius) self.ball.filled = True self.window.add(self.ball, self.window.width / 2 - self.ball.width / 2, self.window.height / 2) self.initial_x = self.window.width / 2 - self.ball.width / 2 self.initial_y = self.window.height / 2 # Default initial velocity for the ball. self.__dx = 0 self.__dy = 0 self.set_speed() self.get_dx() self.get_dy() # Initialize our mouse listeners. self.click = False onmousemoved(self.paddle_follow) onmouseclicked(self.start) # Draw bricks. self.br = brick_rows self.bc = brick_cols self.sp = brick_spacing self.of = brick_offset self.set_brick() # self.check() # self.rest_ball() self.total = self.br * self.bc
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): num_bricks = 100 # Create a graphical window, with some extra space. window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=window_width, height=window_height, title=title) self.paddle = GRect(paddle_width, paddle_height, x=(window_width - paddle_width)/2, y = window_height - \ paddle_offset) # initializing the paddle self.paddle.filled = True self.paddle.fill_color = 'black' self.window.add(self.paddle) # initializing the ball self.ball = GOval(width=ball_radius * 2, height=ball_radius * 2, x=window_width / 2 - BALL_RADIUS, y=window_height / 2 - BALL_RADIUS) self.ball.filled = True self.ball.fill_color = 'black' self.window.add(self.ball) # initial velocity self.vx = 0 self.vy = INITIAL_Y_SPEED # draw bricks self.draw_bricks() # number of lives left self.num_lives = 3 # running? big question mark self.running = False # brick count self.brick_count = 100 # mouse listeners onmouseclicked(self.start) onmousemoved(self.move_paddle)
def start(self, e): """ Start the game :param e: event :return: None """ onmousemoved(self.paddle_move) onmouseclicked(self.click) self.window.remove(self.icon)
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): # Create a graphical window, with some extra space window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=window_width, height=window_height, title='Breakout') # Create a paddle self.paddle = GRect(paddle_width, paddle_height, x=(window_width-paddle_width)/2, y=window_height-paddle_offset) self.window.add(self.paddle) self.paddle.filled = True # Center a filled ball in the graphical window self.ball = GOval(2*ball_radius, 2*ball_radius, x=window_width/2 - ball_radius, y=window_height/2 - ball_radius) self.window.add(self.ball) self.ball.filled = True self.ball_x = window_width/2 - ball_radius self.ball_y = window_height/2 - ball_radius # Default initial velocity for the ball self.__dx = 0 self.__dy = 0 # Other variables self.total_bricks = 0 self.__start = False # Initialize our mouse listeners onmousemoved(self.paddle_move) # using own method must add 'self.' in the front onmouseclicked(self.clicked) # Draw bricks color_num = BRICK_COLS/5 for i in range(BRICK_ROWS): for j in range(BRICK_COLS): if j // color_num == 0: color = 'red' elif j // color_num == 1: color = 'orange' elif j // color_num == 2: color = 'yellow' elif j // color_num == 3: color = 'green' else: color = 'blue' bricks = GRect(BRICK_WIDTH, BRICK_HEIGHT) self.window.add(bricks, x=0+i*(BRICK_WIDTH+BRICK_SPACING), y=BRICK_OFFSET+j*(BRICK_HEIGHT+BRICK_SPACING)) bricks.filled = True bricks.fill_color = color self.total_bricks += 1
def handle_click(self, _): """ This function will execute if a click on the mouse. After a single click, the game will start, and any clicks can no longer affect the game. :param _: Detects a click on the mouse. :return: self.count """ self.window.remove(self.click2start) self.is_game_started = True onmousemoved(self.paddle_move)
def __init__(self, window_object): self.window = window_object # initialize bar self.slide_bar = GRect(WINDOW_DIM - 2 * BAR_OFFSET, BAR_WIDTH, x=BAR_OFFSET, y=WINDOW_DIM - BAR_OFFSET) self.slide_bar.filled = True self.slide_bar.fill_color = 'darksage' self.window.add(self.slide_bar) # initialize orb self.slider_orb = GOval(BALL_RADIUS * 2, BALL_RADIUS * 2, x=WINDOW_DIM - 2 * BAR_OFFSET, y=WINDOW_DIM - BAR_OFFSET - BALL_RADIUS / 2) self.slider_orb.filled = True self.slider_orb.fill_color = 'mediumturquoise' self.window.add(self.slider_orb) # initialize blank fractal self.fractal = GImage.from_file('white_600_400.png') # initialize description label self.description_1 = GLabel("Click to start animation.", 40, 40) self.description_1.x = self.window.width / 2 - self.description_1.\ width / 2 self.description_1.y = self.window.height - 2*self.description_1.\ height + 5 self.window.add(self.description_1) self.description_2 = GLabel( "Move the slider in order to see the progression of the Julia set fractal pattern.", 40, 40) self.description_2.x = self.window.width / 2 - self.description_2.width / 2 self.description_2.y = self.window.height - self.description_2.height + 5 self.window.add(self.description_2) # initialize title self.title = GImage.from_file('title.PNG') self.title.x = (self.window.width - self.title.width) / 2 self.title.y = 10 self.window.add(self.title) # initialize slider ratio (to measure progression) self.slider_ratio = 0 # add mouse listeners onmouseclicked(self.start_sequence) onmousemoved(self.zoom_fractal) # initialize run statement self.running = False
def __init__(self, ball_radius = BALL_RADIUS, paddle_width = PADDLE_WIDTH, paddle_height = PADDLE_HEIGHT, paddle_offset = PADDLE_OFFSET, brick_rows = BRICK_ROWS, brick_cols = BRICK_COLS, brick_width = BRICK_WIDTH, brick_height = BRICK_HEIGHT, brick_offset = BRICK_OFFSET, brick_spacing = BRICK_SPACING, title='Breakout'): # Create a graphical window, with some extra space window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=window_width, height=window_height, title=title) # Create a paddle self.paddle_touch = 0 # (0:untouch paddle; 1: touch paddle) # self.paddle = GRect(paddle_width, paddle_height) self.paddle = GRect(paddle_width, paddle_height) # Test width "430" self.paddle.filled = True self.window.add(self.paddle, x=(window_width-paddle_width)/2, y=window_height-paddle_offset) # Center a filled ball in the graphical window self.ball_radius = ball_radius self.remove_succ = 0 # (0: untouch bricks; 1: touch bricks) self.ball = GOval(ball_radius*2, ball_radius*2) self.ball.filled = True self.window.add(self.ball, x=(window_width-ball_radius)/2, y=(window_height-ball_radius)/2) # Default initial velocity for the ball self.__dy = INITIAL_Y_SPEED self.__dx = random.randint(1, MAX_X_SPEED+1) if random.random() > 0.5: self.__dx = -self.__dx # Initialize our mouse listeners self.switch = 0 # This variable controls if the game start or not. (1:start, 0: unstart) onmouseclicked(self.click_m) onmousemoved(self.move_m) # Draw bricks self.sum_bricks = brick_rows * brick_cols self.bricks_remove = 0 # record how many bricks were removed brick_spacing = (window_width - (brick_width*brick_rows))/(brick_rows-1) position_height = brick_offset for i in range(brick_cols): position_width = 0 for j in range(brick_rows): bricks = GRect(brick_width, brick_height) bricks.filled = True self.window.add(bricks, x=position_width, y=position_height) position_width += (brick_spacing + brick_width) position_height += (brick_spacing + brick_height) # The following variables are used to control user's life or die self.dead = 0 # (0: still life; 1: die)
def __init__(self, ball_radius = BALL_RADIUS, paddle_width = PADDLE_WIDTH, paddle_height = PADDLE_HEIGHT, paddle_offset = PADDLE_OFFSET, brick_rows = BRICK_ROWS, brick_cols = BRICK_COLS, brick_width = BRICK_WIDTH, brick_height = BRICK_HEIGHT, brick_offset = BRICK_OFFSET, brick_spacing = BRICK_SPACING, title='Breakout'): self.b_r = brick_rows self.b_c = brick_cols self.b_w = brick_width self.b_h = brick_height self.b_o = brick_offset self.b_s = brick_spacing self.b_amount = brick_rows * brick_cols self.ball_r = ball_radius self.paddle_o = paddle_offset # Create a graphical window, with some extra space. self.brick = GRect(brick_width, brick_height) window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=window_width, height=window_height, title=title) # create an image self.img = GImage('luv.png') self.reset_img() # Create a paddle. self.paddle = GRect(paddle_width, paddle_height) self.paddle.filled = True self.paddle.fill_color = 'coral' self.paddle.color = 'coral' self.window.add(self.paddle, (self.window.width-self.paddle.width)/2, \ (self.window.height-paddle_offset)) # Draw bricks. self.add_bricks() # Center a filled ball in the graphical window. self.ball = GOval(ball_radius * 2, ball_radius * 2) self.ball.filled = True self.ball.fill_color = 'royalblue' self.ball.color = 'royalblue' self.window.add(self.ball, (self.window.width - self.ball.width) / 2, (self.window.height - self.ball.height) / 2) # Default initial velocity for the ball. self.__dy = 0 self.__dx = 0 self.ball_velocity() # Initialize our mouse listeners.h onmousemoved(self.paddle_move)
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): self.__dx = 0 self.__dy = 0 self.paddle_height = paddle_height self.paddle_width = paddle_width self.paddle_offset = paddle_offset self.count = 0 # Create a graphical window, with some extra space. self.window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing self.window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=self.window_width, height=self.window_height, title=title) # Create a paddle. self.paddle = GRect(paddle_width, paddle_height) self.window.add(self.paddle, 0.5 * self.window_width - 0.5 * paddle_width, \ self.window_height - paddle_offset - paddle_height) self.paddle.filled = True # Center a filled ball in the graphical window. self.ball = GOval(2 * ball_radius, 2 * ball_radius) self.window.add(self.ball, 0.5 * self.window_width - ball_radius, 0.5 * self.window_height - ball_radius) self.ball.filled = True # Default initial velocity for the ball. # Initialize our mouse listeners. onmousemoved(self.move) onmouseclicked(self.start) # Draw bricks. n = brick_offset m = 0 color = ['red', 'orange', 'yellow', 'green', 'blue'] for i in range(brick_rows): n += brick_height + brick_spacing for j in range(brick_cols): m = j * (brick_width + brick_spacing) brick = GRect(brick_width, brick_height) brick.filled = True brick.fill_color = color[i // 2] # why cannot use else at the end? self.window.add(brick, m, n) self.original_x = 0.5 * self.window_width - ball_radius self.original_y = 0.5 * self.window_height - ball_radius
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): # Instance Variable self.__game_status = False self.life_icon_list = [] self.__monster_list = [] self.__monster_dict = {} # Create a graphical window, with some extra space. window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 2.5 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=window_width, height=window_height, title=title) # Draw bricks as a monster. color = ['0xFFABAB', '0xFFE5B5', '0xFFFF45', '0xB5FFB5 ', '0xC2C2FF'] for row in range(brick_rows): for col in range(brick_cols): monster = Monster(brick_width, brick_height, x=col * (brick_width + brick_spacing), y=row * (brick_height + brick_spacing), hp=MONSTER_HP*(BRICK_ROWS-row)) monster.body.fill_color = color[row] self.__monster_list.append(monster.body) self.__monster_dict[monster.body] = monster self.window.add(monster.body) self.window.add(monster.l_eye) self.window.add(monster.r_eye) self.window.add(monster.hp_label) # Create a paddle. self.paddle = GRect(paddle_width, paddle_height) self.paddle.filled = True self.paddle.fill_color = 'black' self.window.add(self.paddle, x=(self.window.width-self.paddle.width)/2, y=self.window.height-paddle_offset) # Create score board self.score = 0 self.score_label = GLabel(f'Score: {self.score}') self.score_label.font = '-20' self.window.add(self.score_label, x=0, y=self.window.height) # Center a filled ball in the graphical window as a hero. self.ball_radius = ball_radius self.hero = Hero(ball_radius * 2, ball_radius * 2) self.hero.body.filled = True self.hero.body.fill_color = 'black' self.set_hero_position() # Default initial velocity for the ball. self.__dx = 0 self.__dy = 0 # Initialize our mouse listeners. onmousemoved(self.set_paddle) onmouseclicked(self.game_start)
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): # Create a graphical window, with some extra space window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=window_width, height=window_height, title=title) # Create a paddle self.paddle = GRect(paddle_width, paddle_height) self.paddle.filled = True self.window.add(self.paddle, (self.window.width - self.paddle.width) / 2, (self.window.height - self.paddle.height - paddle_offset)) # Center a filled ball in the graphical window self.ball = GOval(ball_radius * 2, ball_radius * 2) self.ball.filled = True self.window.add(self.ball, (self.window.width - self.ball.width) / 2, (self.window.height - self.ball.height) / 2) self.move = False # Set move so the ball won't be influenced by clicks # Default initial velocity for the ball self.__dx = random.randint(1, MAX_X_SPEED) if random.random() > 0.5: self.__dx = -self.__dx self.__dy = INITIAL_Y_SPEED # Initialize our mouse listeners onmouseclicked(self.start) onmousemoved(self.paddle_move) self.paddle_offset = PADDLE_OFFSET # Set paddle_offset as an attribute so it can be used in methods self.row = brick_rows # Count the number of rows self.col = brick_cols # Count the number of columns # Draw bricks y = brick_offset for i in range(brick_rows): x = 0 # Put position x in for loop to reset the x value at every row for j in range(brick_cols): self.rect = GRect(brick_width, brick_height) self.rect.filled = True color = ['red', 'red', 'orange', 'orange', 'yellow', 'yellow', 'green', 'green', 'blue', 'blue'] self.rect.fill_color = color[i] self.window.add(self.rect, x, y) x += (brick_width + brick_spacing) y += (brick_height + brick_spacing)
def start_game(self, m): """ The game will triggered by this method once player click the mouse. :param m: mouse position in (x,y) expression. """ if not self.is_game_over: if self.mouse_click: print('Game already start.') else: self.mouse_click = True print('Game started') onmousemoved(self.__paddle_move) else: print('There\'s no chance left')
def check_game_start(self, mouse): """ once the user click the mouse, the game will start that the function will give the ball velocity to move. once the ball is out of the window, the user have to click the mouse again to drop the ball. """ if self.ball.x == self.original_x and self.ball.y == self.original_y: onmousemoved(self.paddle_move) self.window.remove(self.start_label) # give the ball velocity if self.__dx == 0: self.__dy = INITIAL_Y_SPEED self.__dx = random.randint(1, MAX_X_SPEED) if random.random() > 0.5: self.__dx = -self.__dx print(f'{self.__dy}')
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): # Create a graphical window, with some extra space. window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=window_width, height=window_height, title=title) # Create a paddle. self.paddle = GRect(paddle_width, paddle_height, x=(window_width - paddle_width) / 2, y=window_height - paddle_offset) self.paddle.filled = True self.window.add(self.paddle) # Center a filled ball in the graphical window. self.ball = GOval(ball_radius * 2, ball_radius * 2, x=window_width / 2 - ball_radius, y=window_height / 2 - ball_radius) self.window.add(self.ball) self.ball.filled = True # Default initial velocity for the ball. random_x = random.randint(1, MAX_X_SPEED) self.__vx = random_x if random.random() > 0.5: self.__vx = -self.__vx self.__vy = INITIAL_Y_SPEED # Initialize our mouse listeners. self.moved = onmousemoved(self.move_paddle) self.__is_gaming = False # Draw bricks. for i in range(brick_rows): for j in range(brick_cols): self.bricks = GRect(brick_width, brick_height, x=+j * (brick_width + brick_spacing), y=brick_offset + i * (brick_height + brick_spacing)) self.bricks.filled = True self.set_brick_color(self.bricks, i, j) self.window.add(self.bricks)
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): # Create a graphical window, with some extra space. self.window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing self.window_height = brick_offset + 3 * ( brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=self.window_width, height=self.window_height, title=title) # create score label self.score = 0 self.score_label = GLabel("Score: " + str(self.score)) self.score_label.font = "Comic Sans MS-20-bold" self.window.add(self.score_label, 0, self.window_height - self.score_label.height) # create three hit points self.point1 = GOval(ball_radius * 2, ball_radius * 2, x=self.window_width - ball_radius * 3, y=self.window_height - self.window_height * 0.06) self.point2 = GOval(ball_radius * 2, ball_radius * 2, x=self.window_width - ball_radius * 6, y=self.window_height - self.window_height * 0.06) self.point3 = GOval(ball_radius * 2, ball_radius * 2, x=self.window_width - ball_radius * 9, y=self.window_height - self.window_height * 0.06) self.point1.filled = True self.point2.filled = True self.point3.filled = True self.point1.color = "white" self.point2.color = "white" self.point3.color = "white" self.point1.fill_color = "salmon" self.point2.fill_color = "salmon" self.point3.fill_color = "salmon" self.window.add(self.point1) self.window.add(self.point2) self.window.add(self.point3) # create a paddle self.paddle = GRect(paddle_width, paddle_height) self.paddle.filled = True self.window.add(self.paddle, x=(self.window_width - paddle_width) / 2, y=self.window_height - paddle_offset - paddle_height) # center a filled ball in the graphical window self.ball = GOval(ball_radius * 2, ball_radius * 2, x=(self.window_width / 2 - ball_radius), y=(self.window_height / 2 - ball_radius)) self.ball.filled = True self.window.add(self.ball) # default initial velocity for the ball self.__dx = random.randint(1, MAX_X_SPEED) self.__dy = INITIAL_Y_SPEED self.reset_dx() # Initialize our mouse listeners. self.running = False onmouseclicked(self.start_running) onmousemoved(self.reset_paddle_position) # Draw bricks. for i in range(brick_cols): x_position = 0 x_position += (brick_width + brick_spacing) * i for j in range(brick_rows): y_position = brick_offset y_position += (brick_height + brick_spacing) * j self.bricks = GRect(brick_width, brick_height) # coloring self.bricks.filled = True self.bricks.color = "white" if j == 0 or j == 1: self.bricks.fill_color = "black" elif j == 2 or j == 3: self.bricks.fill_color = "navy" elif j == 4 or j == 5: self.bricks.fill_color = "steelblue" elif j == 6 or j == 7: self.bricks.fill_color = "skyblue" else: self.bricks.fill_color = "lightblue" self.window.add(self.bricks, x=x_position, y=y_position) self.bricks_num = brick_cols * brick_rows
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): # Create a graphical window, with some extra space self.__window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing self.__window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.__window = GWindow(width=self.__window_width, height=self.__window_height, title=title) # Create a paddle self.__paddle = GRect(paddle_width, paddle_height) self.__paddle.filled = True self.__window.add(self.__paddle, self.__window.width / 2 - self.__paddle.width / 2, self.__window.height - paddle_offset) # Center a filled ball in the graphical window self.__ball = GOval(ball_radius * 2, ball_radius * 2) self.__ball.filled = True self.__window.add(self.__ball, self.__window.width / 2 - self.__ball.width / 2, self.__window.height / 2 + self.__ball.height / 2) # Default initial velocity for the ball self.__dx = 0 self.__dy = 0 # Initialize our mouse listeners self.__restart_game = False self.__game_start = False onmouseclicked(self.click_event) onmousemoved(self.move_event) # Draw bricks self.__brick_rows = brick_rows self.__brick_cols = brick_cols self.__brick_width = brick_width self.__brick_height = brick_height self.__brick_spacing = brick_spacing self.__brick_offset = brick_offset self.__brick_nums = 0 self.set_bricks(self.__brick_rows, self.__brick_cols, self.__brick_width, self.__brick_height, self.__brick_spacing, self.__brick_offset) # Prepare label self.__score = 0 self.__top_score = 0 self.__game_end_label = GLabel("GAME OVER") self.__game_end_label.font = "Verdana-17" self.__game_end_label.color = (150, 0, 0) self.__score_label = GLabel("Your Score : " + str(self.__score)) self.__score_label.font = "Verdana-15" self.__score_label.color = (100, 100, 100) self.__top_score_label = GLabel("Top Score : " + str(self.__top_score)) self.__top_score_label.font = "Verdana-15" self.__top_score_label.color = (100, 100, 100) self.__hint_label = GLabel("Click to Start") self.__hint_label.font = "Verdana-15" self.__hint_label.color = (100, 100, 100) self.__window.add(self.__game_end_label, self.__window.width / 2 - self.__game_end_label.width / 2, 0) self.__window.add(self.__score_label, 0, self.__score_label.height) self.__window.add(self.__top_score_label, self.__window.width - self.__top_score_label.width, self.__top_score_label.height) self.__window.add(self.__hint_label, self.__window.width / 2 - self.__hint_label.width / 2, self.__window.height / 2 + self.__ball.height / 2 + self.__ball.height + self.__hint_label.height * 4) self.__life_point_text = "" for i in range(3): self.__life_point_text += "❤" self.__life_point_label = GLabel(self.__life_point_text) self.__life_point_label.font = "-22" self.__life_point_label.color = (150, 0, 0) self.__window.add(self.__life_point_label, self.__window.width - self.__life_point_label.width, self.__window.height)
def main(): window.add(line) rect.filled = True rect.fill_color = 'blue' # onmousedragged(draw) onmousemoved(reset_position)
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): self.pw = paddle_width # Class variable to store paddle width. self.ph = paddle_height # Class variable to store paddle height. self.pos = paddle_offset # Class variable to store paddle offset. self.br = ball_radius # Class variable to store ball radius. self.brk_row = brick_rows # Class variable to store the number of brick rows. self.brk_col = brick_cols # Class variable to store the number of brick columns. self.click = 1 # Class variable as a switch to control game status, where 1 equals to game termination. self.brick_count = 0 # Class variable to store the number of bricks being eliminated. self.score = 0 # Class variable to store the score of the game. # Create a graphical window, with some extra space. window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=window_width, height=window_height, title=title) self.wh = window_height # Class variable to store window height. self.ww = window_width # Class variable to store window width. # Create a label to show the score. self.label_s = GLabel('Scores: ' + str(self.score), x=2, y=window_height - 2) self.label_s.font = '-10' self.window.add(self.label_s) # Create a paddle. self.paddle = GRect(width=paddle_width, height=paddle_height, x=(window_width - paddle_width) / 2, y=window_height - paddle_offset - paddle_height) self.paddle.filled = True self.paddle.fill_color = 'black' self.paddle.color = 'black' self.window.add(self.paddle) # Center a filled ball in the graphical window. self.ball = GOval(ball_radius * 2, ball_radius * 2) self.ball.filled = True self.ball.fill_color = 'black' self.ball.color = 'black' self.set_ball( ) # Method to set ball place at initial, details shown as below. self.window.add(self.ball) # Method to set initial velocity of the ball, details shown as below. self.set_ball_velocity() # Initialize mouse listeners. onmousemoved(self.paddle_location ) # Method to move paddle while moving the mouse. onmouseclicked( self.game_start ) # Method to control game status while clicking the mouse. # Draw bricks with different colors, which is determined ny the number of rows. for i in range(brick_cols): for j in range(brick_rows): self.brick = GRect(brick_width, brick_height, x=i * (brick_width + brick_spacing), y=j * (brick_height + brick_spacing) + BRICK_OFFSET) self.brick.filled = True if j % 10 == 0 or j % 10 == 1: self.brick.fill_color = 'Red' self.brick.color = 'Red' elif j % 10 == 2 or j % 10 == 3: self.brick.fill_color = 'Orange' self.brick.color = 'Orange' elif j % 10 == 4 or j % 10 == 5: self.brick.fill_color = 'Yellow' self.brick.color = 'Yellow' elif j % 10 == 6 or j % 10 == 7: self.brick.fill_color = 'Green' self.brick.color = 'Green' else: self.brick.fill_color = 'Blue' self.brick.color = 'Blue' self.window.add(self.brick)
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): # Create a graphical window, with some extra space. window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.game_start = False self.window = GWindow(width=window_width, height=window_height, title=title) # Create a paddle. self.paddle = GRect(width=paddle_width, height=paddle_height) self.paddle.filled = True self.paddle_offset = paddle_offset self.window.add(self.paddle, (window_width - paddle_width) / 2, window_height - paddle_offset) # Center a filled ball in the graphical window. self.ball = GOval(ball_radius * 2, ball_radius * 2) self.ball.filled = True self.window.add(self.ball, window_width / 2 - ball_radius, window_height / 2 - ball_radius) # Default initial velocity for the ball. self.__dy = 0 self.__dx = 0 # Calculate times of removing brick self.count = 0 # Draw bricks. self.brick_rows = brick_rows self.brick_cols = brick_cols for i in range(self.brick_rows): for j in range(self.brick_cols): self.brick = GRect(brick_width, brick_height) self.brick.filled = True if j == 0 or j == 1: color = 'red' elif j == 2 or j == 3: color = 'gold' elif j == 4 or j == 5: color = 'yellow' elif j == 6 or j == 7: color = 'green' else: color = 'blue' self.brick.fill_color = color self.brick.color = color self.window.add(self.brick, (brick_spacing + brick_width) * i, (brick_spacing + brick_height) * j + brick_offset) # Initialize our mouse listeners. onmousemoved(self.paddle_move) onmouseclicked(self.initialize_velocity)
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): # only three lives self.num_lives = NUM_LIVES # win img self.img = GImage('WIN!!.png') # Create a graphical window, with some extra space. window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=window_width, height=window_height, title=title) # Start button self.button_back = GRect(250, 50) self.button_back.filled = True self.button_back.fill_color = 'darkgrey' self.window.add(self.button_back, x=(self.window.width - self.button_back.width) // 2, y=352.5) self.button = GRect(250, 50) self.button.filled = True self.button.fill_color = 'grey' self.window.add(self.button, x=(self.window.width - self.button.width) // 2, y=350) self.button_word = GLabel('CLICK TO START') self.button_word.font = '-30' self.window.add(self.button_word, x=(self.window.width - self.button_word.width) // 2, y=350 + self.button_word.height + 10) # Create a paddle. self.paddle = GRect(paddle_width, paddle_height, x=(window_width - paddle_width) // 2, y=window_height - paddle_offset) self.paddle.filled = True self.window.add(self.paddle) # Center a filled ball in the graphical window. self.ball = GOval(ball_radius * 2, ball_radius * 2, x=window_width // 2 - ball_radius, y=window_height // 2 - ball_radius) self.ball.filled = True self.window.add(self.ball) # Default initial velocity for the ball. self.__dx = self.set_ball_x_velocity() self.__dy = INITIAL_Y_SPEED # Initialize our mouse listeners. onmouseclicked(self.start) onmousemoved(self.control_paddle) # the switch of the game self.start = False # Score board. self.score = 0 self.score_label = GLabel('Score: ' + str(self.score)) self.score_label.font = '-22' self.window.add(self.score_label, x=0, y=self.score_label.height + 5) # how many lives self.life1 = GLabel('❤️') self.life1.font = '-20' self.window.add(self.life1, self.window.width - self.life1.width, self.life1.height + 7) self.life2 = GLabel('❤️') self.life2.font = '-20' self.window.add(self.life2, self.window.width - self.life2.width * 2, self.life2.height + 7.35) self.life3 = GLabel('❤️') self.life3.font = '-20' self.window.add(self.life3, self.window.width - self.life3.width * 3, self.life3.height + 7.35) # Draw bricks. x = 0 # to change row space = 0 self.change = 0 self.color = 'red' # 5 colors for i in range(brick_rows // 2): # each color 2 rows for j in range(2): # x bricks for k in range(brick_cols): self.brick = GRect(brick_width, brick_height, x=0 + x, y=brick_offset + space) x += (brick_width + brick_spacing) self.brick.filled = True self.brick.fill_color = self.color self.brick.color = self.color self.window.add(self.brick) x = 0 space += (brick_height + brick_spacing) self.change_color()
def __init__(self, ball_radius=BALL_RADIUS, paddle_width=PADDLE_WIDTH, paddle_height=PADDLE_HEIGHT, paddle_offset=PADDLE_OFFSET, brick_rows=BRICK_ROWS, brick_cols=BRICK_COLS, brick_width=BRICK_WIDTH, brick_height=BRICK_HEIGHT, brick_offset=BRICK_OFFSET, brick_spacing=BRICK_SPACING, title='Breakout'): self.__ball_radius = ball_radius self.__paddle_width = paddle_width self.__paddle_height = paddle_height self.__paddle_offset = paddle_offset self.__brick_rows = brick_rows self.__brick_cols = brick_cols self.__brick_width = brick_width self.__brick_height = brick_height self.__brick_offset = brick_offset self.__brick_spacing = brick_spacing # Create a graphical window, with some extra space. window_width = brick_cols * (brick_width + brick_spacing) - brick_spacing window_height = brick_offset + 3 * (brick_rows * (brick_height + brick_spacing) - brick_spacing) self.window = GWindow(width=window_width, height=window_height, title=title) # Create a paddle. self.paddle = GRect(self.__paddle_width, self.__paddle_height, x=(self.window.width - paddle_width) / 2, y=(self.window.height - paddle_height - self.__paddle_offset)) self.paddle.filled = True self.window.add(self.paddle) # Center a filled ball in the graphical window. self.ball = GOval(self.__ball_radius * 2, self.__ball_radius * 2, x=self.window.width / 2 - self.__ball_radius, y=self.window.height / 2 - self.__ball_radius) self.ball.filled = True self.window.add(self.ball) # Default initial velocity for the ball. self._dy = INITIAL_Y_SPEED self._dx = random.randint(1, MAX_X_SPEED) if (random.random() > 0.5): self._dx = -self._dx # Initialize our mouse listeners. onmousemoved(self.paddle_move) onmouseclicked(self.ball_start) self.start = False # Draw bricks for i in range(self.__brick_rows): for j in range(self.__brick_cols): self.bricks = GRect( self.__brick_width, self.__brick_height, x=j * (self.__brick_width + self.__brick_spacing), y=self.__brick_offset + i * (self.__brick_height + self.__brick_spacing)) self.bricks.filled = True if i % 10 == 0 or i % 10 == 1: self.bricks.fill_color = 'red' elif i % 10 == 2 or i % 10 == 3: self.bricks.fill_color = 'orange' elif i % 10 == 4 or i % 10 == 5: self.bricks.fill_color = 'yellow' elif i % 10 == 6 or i % 10 == 7: self.bricks.fill_color = 'green' elif i % 10 == 8 or i % 10 == 9: self.bricks.fill_color = 'blue' self.window.add(self.bricks)