def draw_checkerboard(self):
     for i in range(self.cell_amt):
         for j in range(self.cell_amt):
             if (i % 2 == 0) ^ (j % 2 == 0):
                 cr = Rect((i * self.cell_size[0], j * self.cell_size[1]),
                           self.cell_size)
                 draw_rect(self.play_surf, self.cell_colour, cr)
Exemple #2
0
 def draw(self):
     surface = BasicFrame.draw(self)
     if not self.pressed:
         draw_rect(surface, self.dark, Rect((0, 0), self.size), self.thick)
     else:
         draw_rect(surface, self.light, Rect((0, 0), self.size), self.thick)
     return surface
Exemple #3
0
 def draw(self, window):
   window.blit(self.image, (self.x, self.y))
   if self.activated:
     draw_rect(window, (0, 0, 0), (self.x, self.y, self.image.get_width(), self.image.get_height()), 2)
   else:
     draw_rect(window, (150, 150, 150), (self.x, self.y, self.image.get_width(), self.image.get_height()), 2)
   window.blit(self.small_block_image, ((self.x + self.image.get_width() // 2) - self.small_block_image.get_width() // 2, (self.y + self.image.get_height() // 2) - self.small_block_image.get_height() // 2))
 def draw(self):
     surface = BasicFrame.draw(self)
     if self.pressed:
         draw_rect(surface, self.dark, Rect((0, 0), self.size), self.thick+2)
     elif self.hovered:
         draw_rect(surface, self.dark, Rect((0, 0), self.size), self.thick)
     return surface
Exemple #5
0
    def loop_hook(self):
        if self.mouse_pressed:
            if self.point_buffer % 1 == 0:
                self.points[self.point_buffer] = Vector2(mouse_pos())
                self.quad.insert_point(self.point_buffer,
                                       self.points[self.point_buffer])
            self.point_buffer += 1

        if self.rect_selection is not None:
            self.select_points()
            rect_size = Vector2(mouse_pos()) - self.rect_selection
            draw_rect(
                self.canvas, (20, 250, 40),
                Rect(self.rect_selection.x, self.rect_selection.y, rect_size.x,
                     rect_size.y), 1)

        # self.canvas.lock()
        self.quad.draw(self.canvas)
        for point in self.points:
            if point in self.selected_points:
                color = (220, 255, 100)
            else:
                color = (120, 120, 120)
            circle(self.canvas, color, self.points[point], 3)
        # self.canvas.lock()

        print('pts: %i | sel. pts: %i | FPS: %.2f' % (len(
            self.points), len(self.selected_points), self.clock.get_fps()))
 def draw(self):
     surface = BasicFrame.draw(self)
     if not self.pressed:
         draw_rect(surface, self.dark, Rect((0, 0), self.size), self.thick)
     else:
         draw_rect(surface, self.light, Rect((0, 0), self.size), self.thick)
     return surface
Exemple #7
0
def stretched_circle(surface: Surface, rect: Rect, colour: Colour):
    rounded_rect(surface, rect, colour, min(rect.width, rect.height) * .5)
    r = rect.copy()
    r.width -= r.height
    r.x += r.height / 2
    r.height += 2
    r.y -= 1
    draw_rect(surface, colour, r)
Exemple #8
0
    def draw(self, canvas: Surface):
        draw_rect(
            canvas, (255, 255, 255),
            Rect(self.top_left.x, self.top_left.y, self.width, self.height), 1)

        if self.subdivided:
            self.top_left_quad.draw(canvas)
            self.bottom_left_quad.draw(canvas)
            self.top_right_quad.draw(canvas)
            self.bottom_right_quad.draw(canvas)
Exemple #9
0
 def image(self):
     width = self.parent.rect.width
     height = Constants.HP_BAR_HEIGHT
     img = Surface((width, height))
     img.fill(Constants.INERT)
     damage = int(self.hit_points / self.max * width)
     draw_rect(img, Constants.DAMAGE, Rect(0, 0, damage, height))
     health = int(self.parent.hit_points / self.max * width)
     draw_rect(img, Constants.HP, Rect(0, 0, health, height))
     return img
Exemple #10
0
    def loop(self):
        DEBUG = config.getboolean('display', 'debug')

        draw_interval = 1 / float(self.target_fps)
        tick_fps = self.target_fps
        draw_timer = 0
        tick = self.clock.tick
        main_surface = self.main_surface
        fps_display_acc = 0
        get_fps = self.clock.get_fps
        poll_event = event.poll

        while len(self.scene_stack) > 0:
            events = list()
            e = poll_event()
            while e:
                events.append(e)
                if e.type == QUIT:
                    while len(self.scene_stack) > 0:
                        self.pop_scene()
                    sys.exit()
                e = poll_event()

            delta = tick(tick_fps)
            fps = get_fps()

            fps_display_acc += delta
            if fps_display_acc >= 10000:
                set_caption("FPS ::: %.4f" % fps)
                fps_display_acc = 0

            self.current_scene.update_events()
            self.current_scene.update(delta, events)

            draw_timer += delta
            if draw_timer >= draw_interval:
                if DEBUG:
                    main_surface.fill((0, 0, 0))

                draw_timer -= draw_interval
                self.current_scene.clear(main_surface)
                dirty = self.current_scene.draw(main_surface)

                if DEBUG:
                    for rect in dirty:
                        draw_rect(main_surface, (0, 255, 0), rect, 1)
                        flip()
                else:
                    update(dirty)
Exemple #11
0
    def loop(self):
        DEBUG = config.getboolean('display', 'debug')

        draw_interval = 1 / float(self.target_fps)
        tick_fps = self.target_fps
        draw_timer = 0
        tick = self.clock.tick
        main_surface = self.main_surface
        fps_display_acc = 0
        get_fps = self.clock.get_fps
        poll_event = event.poll

        while len(self.scene_stack) > 0:
            events = list()
            e = poll_event()
            while e:
                events.append(e)
                if e.type == QUIT:
                    while len(self.scene_stack) > 0:
                        self.pop_scene()
                    sys.exit()
                e = poll_event()

            delta = tick(tick_fps)
            fps = get_fps()

            fps_display_acc += delta
            if fps_display_acc >= 10000:
                set_caption("FPS ::: %.4f" % fps)
                fps_display_acc = 0

            self.current_scene.update_events()
            self.current_scene.update(delta, events)

            draw_timer += delta
            if draw_timer >= draw_interval:
                if DEBUG:
                    main_surface.fill((0, 0, 0))

                draw_timer -= draw_interval
                self.current_scene.clear(main_surface)
                dirty = self.current_scene.draw(main_surface)

                if DEBUG:
                    for rect in dirty:
                        draw_rect(main_surface, (0, 255, 0), rect, 1)
                        flip()
                else:
                    update(dirty)
    def _redraw_screen(self):
        """Redraws the screen."""
        # fill background with window color
        self._screen.fill(WINDOW_COLOR)

        # draw label
        self._screen.blit(self._label, SHOTS_LABEL_POSITION)

        # draw paddle and ball
        draw_rect(self._screen, self._paddle.color, self._paddle)
        draw_circle(self._screen, self._ball.color, self._ball.center,
                    self._ball.radius)

        # update whole screen
        flip_screen()
    def _draw_game_over_screen(self):
        """Draws the game over screen."""
        # fill background with window color
        self._screen.fill(WINDOW_COLOR)

        # draw label
        self._screen.blit(self._label, SHOTS_LABEL_POSITION)

        # draw game over label
        self._screen.blit(GAME_OVER_LABEL, GAME_OVER_LABEL_POSITION)

        # draw paddles
        draw_rect(self._screen, self._paddle.color, self._paddle)

        # update whole screen
        flip_screen()
Exemple #14
0
 def draw(self,surface,color):
     """
     Draw a series of rectangles on a Surface.
     """
     def get_green(i):
         val = 30
         # the color should never go below 10 green
         val = max(val, 255-255*(i))
         # the color should start bright green, and decrease 
         # in intensity with each segment
         return val
     for i, seg in enumerate(self._render()):
         # get an index and a Rectangle representing a Segment
         fraction = i/len(self.segments)
         color = (0, get_green(fraction), 0)
         # get the color we want to use on this Segment
         draw_rect(surface, color, seg)
Exemple #15
0
    def display(self):
        pygame.event.pump()
        screen = self.screen
        borders = [pygame.Rect(b[0], b[1], b[2], b[3]) for b in self.m.borders]
        pellets = [pygame.Rect(p[0], p[1], p[2], p[3]) for p in self.m.pellets]
        b = self.m.mybox
        myrect = pygame.Rect(b[0], b[1], b[2], b[3])
        screen.fill((0, 0, 64))  # dark blue

        for player in self.m.players.items():
            name = player[0]
            if name != self.m.myname:
                draw_rect(screen, (255, 0, 0), player[1])  # red
            else:
                draw_rect(screen, (0, 191, 255), player[1])  # deep sky blue

        [pygame.draw.rect(screen, (255, 192, 203), p) for p in pellets]  # pink
        [pygame.draw.rect(screen, (0, 191, 255), b) for b in borders]  # red
        pygame.display.update()
 def render(self, target):
     target.fill(self.bg_colour)
     
     lerped_fill_colour = self.fill_colour_min.lerp(self.fill_colour_max,
                                                    self.lerp_n)
     lerped_circ_colour = self.circ_colour_min.lerp(self.circ_colour_max,
                                                    self.lerp_n)
     lerped_rect_colour = self.circ_colour_min.lerp(self.circ_colour_max,
                                                    1 - self.lerp_n)
     if self.circs_are_close():
         target.fill((255, 0, 0))
     else:
         target.fill(lerped_fill_colour)
     
     actual_circ_colour = ((255, 0, 0)
                           if self.circs_are_close()
                           else lerped_circ_colour)
     actual_rect_colour = ((255, 0, 0)
                           if self.circs_are_close()
                           else lerped_rect_colour)
     
     target.blit(self.play_surf, self.play_rect)
     self.fruit.render(target)
     
     circ_pos_tuple = tuple(self.get_lerped_circ_pos())
     neg_circ_pos = (circ_pos_tuple[0],
                     self.circ_pos_max[1] - circ_pos_tuple[1])
     
     draw_circle(target, actual_circ_colour,
                 circ_pos_tuple, self.circ_radius)
     draw_rect(target, actual_rect_colour,
               Rect((circ_pos_tuple[0] - self.circ_radius // 2,
                     circ_pos_tuple[1] - self.circ_radius // 2),
                    (self.circ_radius, self.circ_radius)))
     draw_circle(target, actual_circ_colour,
                 neg_circ_pos, self.circ_radius)
     draw_rect(target, actual_rect_colour,
               Rect((neg_circ_pos[0] - self.circ_radius // 2,
                     neg_circ_pos[1] - self.circ_radius // 2),
                    (self.circ_radius, self.circ_radius)))
     target.blit(self.text, (90, 90))
Exemple #17
0
 def draw(self, window):
     self.time_2 = int(time())
     draw_rect(window, self.color,
               (self.x, self.y, self.width, self.height))
     y = self.y
     for line in self.lines:
         line_render = self.font.render(line, True, (200, 200, 200))
         window.blit(line_render, (
             self.x, y +
             (self.letter_example.get_height() - line_render.get_height())))
         y += self.letter_example.get_height()
     self.draw_line = self.time_2 - self.time_1 in range(1)
     if self.draw_line:
         draw_line(window, (255, 255, 255),
                   (self.x + line_render.get_width(),
                    y - self.letter_example.get_height() + 3),
                   (self.x + line_render.get_width(),
                    (y - self.letter_example.get_height() + 3) + 35), 2)
     else:
         if not self.time_2 - self.time_1 in range(1, 2):
             self.time_1 = int(time())
Exemple #18
0
    def _redraw_screen(self):
        """Redraws the screen."""
        # fill background with window color
        self._screen.fill(WINDOW_COLOR)

        # draw labels
        self._screen.blit(self._label1, SCORE1_LABEL_POSITION)
        self._screen.blit(self._label2, SCORE2_LABEL_POSITION)

        # draw net
        draw_dashed_line(self._screen, NET_COLOR, (NET_X, 0),
                         (NET_X, WINDOW_HEIGHT))

        # draw paddles and ball
        draw_rect(self._screen, self._paddle1.color, self._paddle1)
        draw_rect(self._screen, self._paddle2.color, self._paddle2)
        draw_circle(self._screen, self._ball.color, self._ball.center,
                    self._ball.radius)

        # update whole screen
        flip_screen()
Exemple #19
0
    def _draw_game_over_screen(self):
        """Draws the game over screen."""
        # fill background with window color
        self._screen.fill(WINDOW_COLOR)

        # draw labels
        self._screen.blit(self._label1, SCORE1_LABEL_POSITION)
        self._screen.blit(self._label2, SCORE2_LABEL_POSITION)

        # draw game over label
        winner = '1' if self._score1 > self._score2 else '2'
        winner_label = FONT.render('PLAYER {} WON'.format(winner), True,
                                   FONT_COLOR)
        self._screen.blit(winner_label, WINNER_LABEL_POSITION)

        # draw paddles
        draw_rect(self._screen, self._paddle1.color, self._paddle1)
        draw_rect(self._screen, self._paddle2.color, self._paddle2)

        # update whole screen
        flip_screen()
Exemple #20
0
def draw_piece(surf, color, left, top, width, height, size):
    padding_factor = 0.025
    shadow_factor = 0.085
    margin_factor = 0.05

    base_color = color
    margin_color = darken_color(color, 0.8)
    bottom_color = darken_color(color, 0.4)

    # Applying padding
    padding = int(size * padding_factor)
    left, top = left + padding, top + padding
    width, height = width - 2 * padding, height - 2 * padding
    size = size - 2 * padding

    # Applying shadow effect
    shadow = int(size * shadow_factor)
    top_rect = (left, top, width - shadow, height - shadow)
    bottom_rect = (left + shadow, top + shadow, width - shadow,
                   height - shadow)

    draw_rect(surf, bottom_color, bottom_rect)
    draw_rect(surf, base_color, top_rect)

    # Draw margins
    draw_rect(surf, margin_color, top_rect, int(size * margin_factor))
Exemple #21
0
    def display(self):
        pygame.event.pump()
        screen = self.screen
        borders = [pygame.Rect(b[0], b[1], b[2], b[3]) for b in self.m.borders]
        pellets = [pygame.Rect(p[0], p[1], p[2], p[3]) for p in self.m.pellets]
        if self.m.players:
            b = self.m.players[self.m.myname]
            myrect = pygame.Rect(b[0], b[1], b[2], b[3])
        screen.fill((0, 0, 64))  # dark blue

        if self.m.players:
            pygame.draw.rect(screen, (0, 191, 255), myrect)  # Deep Sky Blue
        [pygame.draw.rect(screen, (255, 192, 203), p) for p in pellets]  # pink
        [pygame.draw.rect(screen, (0, 191, 255), b) for b in borders]  # red

        if self.m.players:
            for name, p in self.m.players.items():
                if name != self.m.myname:
                    draw_rect(screen, (255, 0, 0), p)  # red
            if self.m.myname:
                draw_rect(screen, (0, 191, 255), self.m.players[self.m.myname])  # deep sky blue

        pygame.display.update()
Exemple #22
0
def rounded_rect(surface: Surface, rect: Rect, colour: Colour,
                 corner_radius: int):
    ''' Draw a rectangle with rounded corners.
    Would prefer this: 
        pygame.draw.rect(surface, colour, rect, border_radius=corner_radius)
    but this option is not yet supported in my version of pygame so do it ourselves.

    We use anti-aliased circles to make the corners smoother
    '''
    if rect.width < 2 * corner_radius or rect.height < 2 * corner_radius:
        raise ValueError(
            f"Both height (rect.height) and width (rect.width) must be > 2 * corner radius ({corner_radius})"
        )

    corner_radius = int(corner_radius)

    # need to use anti aliasing circle drawing routines to smooth the corners
    circle(surface, rect.left + corner_radius, rect.top + corner_radius,
           corner_radius, colour)
    circle(surface, rect.right - corner_radius - 1, rect.top + corner_radius,
           corner_radius, colour)
    circle(surface, rect.left + corner_radius, rect.bottom - corner_radius - 1,
           corner_radius, colour)
    circle(surface, rect.right - corner_radius - 1,
           rect.bottom - corner_radius - 1, corner_radius, colour)

    rect_tmp = Rect(rect)

    rect_tmp.width -= 2 * corner_radius
    rect_tmp.center = rect.center
    draw_rect(surface, colour, rect_tmp)

    rect_tmp.width = rect.width
    rect_tmp.height -= 2 * corner_radius
    rect_tmp.center = rect.center
    draw_rect(surface, colour, rect_tmp)
 def display(self):
     self.screen.fill((0, 0, 64))  # dark blue
     [draw_rect(self.screen, (0, 191, 255), b) for b in model.borders]  # deep sky blue 
     [draw_rect(self.screen, (255, 192, 203), p) for p in model.pellets]  # shrimp
     for name, p in model.players.items():
         if name != model.myname:
             draw_rect(self.screen, (255, 0, 0), p)  # red
     if model.myname:
         draw_rect(self.screen, (0, 191, 255), model.players[model.myname])  # deep sky blue
        
     update_pygame_display()
        
     self.clock.tick(50)  # frames per second, independent of server frame rate
Exemple #24
0
 def draw(self):
     draw_rect(self.filed.surface,
               self.obj.color if self.obj else CELLS_COLOR,
               (self.x, self.y, self.width, self.height))
Exemple #25
0
 def draw(self, surface, color):
     """
     Draw this obstacle on a Surface.
     """
     draw_rect(surface, color, self.render())
Exemple #26
0
                 client.do_send({'msg_type': 'die'})
             else:  # eat if bigger
                 players[name] = None  # None until server sends his new box
                 client.do_send({'msg_type': 'eat_player',
                                 'target': name})
 
 # check for collisions with pellets     
 if mybox:  # may have been Noned by colliding with another player        
     pe_idx = mybox.collidelist(pellets)
     if pe_idx != -1:  # ate a pellet: grow, and replace a pellet
         client.do_send({'msg_type': 'eat_pellet',
                         'pellet_index': pe_idx})
 
 # draw everything
 screen.fill((0, 0, 64))  # dark blue
 [draw_rect(screen, (0, 191, 255), b) for b in borders]  # deep sky blue 
 [draw_rect(screen, (255, 192, 203), p) for p in pellets]  # shrimp
 for name, hisbox in players.items():  # draw other players
     if name != myname and hisbox:
         if mybox and hisbox.width < mybox.width:
             color = 0, 255, 0  # smaller than me: green
         else:
             color = 255, 0, 0  # bigger or same size: red
         draw_rect(screen, color, hisbox)
         # anti-aliased, black
         text = font.render(str(hisbox.width), 1, (0, 0, 0))  
         screen.blit(text, hisbox)
 if mybox:  # draw me if I'm alive
     draw_rect(screen, (0, 191, 255), mybox)  # Deep Sky Blue
     text = font.render(str(mybox.width), 1, (0, 0, 0))  # anti-alias, black
     screen.blit(text, mybox)
Exemple #27
0
 def show(self, window):
     """Paints a black box at x, y to sx, sy"""
     # probably needs to be overloaded, just paints a black box
     draw_rect(window, colors.black, (self.x, self.y, self.sx, self.sy))
Exemple #28
0
 def draw_racket(self):
     self.racket = draw_rect(self.screen, self.color, self.rect)
Exemple #29
0
 def __init__(self, screen, color, pos_x, pos_y):
     self.screen = screen
     self.color = color
     self.rect = Rect(pos_x, pos_y, self.size_x, self.size_y)
     self.move_step = self.move_step
     self.racket = draw_rect(self.screen, self.color, self.rect)
Exemple #30
0
                 client.do_send({'msg_type': 'die'})
             else:  # eat if bigger
                 players[name] = None  # None until server sends their new box
                 client.do_send({'msg_type': 'eat_player',
                                 'target': name})
 
 # check for collisions with pellets     
 if mybox:  # may have been Noned by colliding with another player        
     pe_idx = mybox.collidelist(pellets)
     if pe_idx != -1:  # ate a pellet: grow, and replace a pellet
         client.do_send({'msg_type': 'eat_pellet',
                         'pellet_index': pe_idx})
 
 # draw everything
 screen.fill((0, 0, 64))  # dark blue
 [draw_rect(screen, (0, 191, 255), b) for b in borders]  # deep sky blue 
 [draw_rect(screen, (255, 192, 203), p) for p in pellets]  # shrimp
 for name, theirbox in players.items():  # draw other players
     if name != myname and theirbox:
         if mybox and theirbox.width < mybox.width:
             color = 0, 255, 0  # smaller than me: green
         else:
             color = 255, 0, 0  # bigger or same size: red
         draw_rect(screen, color, theirbox)
         # anti-aliased, black
         text = font.render(str(theirbox.width), 1, (0, 0, 0))  
         screen.blit(text, theirbox)
 if mybox:  # draw me if I'm alive
     draw_rect(screen, (0, 191, 255), mybox)  # Deep Sky Blue
     text = font.render(str(mybox.width), 1, (0, 0, 0))  # anti-alias, black
     screen.blit(text, mybox)
Exemple #31
0
 def draw(self, canvas):
     draw_rect(canvas, self.color,
               (self.x, self.y, self.brush_size, self.brush_size))
Exemple #32
0
            if key == K_ESCAPE:
                exit()
            elif key in valid_inputs:
                if key == K_UP:
                    dx, dy = 0, -1
                elif key == K_DOWN:
                    dx, dy = 0, 1
                elif key == K_LEFT:
                    dx, dy = -1, 0
                elif key == K_RIGHT:
                    dx, dy = 1, 0
                msg = {'input': valid_inputs[key]}
                client.do_send(msg)

    # draw everything
    screen.fill((0, 0, 64))  # dark blue
    [draw_rect(screen, (0, 191, 255), b) for b in borders]  # deep sky blue
    [draw_rect(screen, (255, 192, 203), p) for p in pellets]  # shrimp
    for name, p in players.items():
        if name != myname:
            draw_rect(screen, (255, 0, 0), p)  # red
    if myname and myname in players.keys():
        if counter % 2 == 0:
            players[myname].move_ip(dx, dy)  # update position
        draw_rect(screen, (0, 191, 255), players[myname])  # deep sky blue

    update_pygame_display()

    counter += 1
    clock.tick(50)  # frames per second, independent of server frame rate
Exemple #33
0
	def draw(self, toolbar):
		draw_rect(toolbar, self.color, (self.x, self.y, self.width, self.height))
		draw_circle(toolbar, (self.color[0] - 40, self.color[1] - 40, self.color[2] - 40), (self.circle_x, self.circle_y), self.circle_radius)
Exemple #34
0
while 1:
    
    poll()  # push and pull network messages

    # send valid inputs to the server
    for event in get_pygame_events():  
        if event.type == QUIT:
            exit()
        if event.type == KEYDOWN:
            key = event.key
            if key == K_ESCAPE:
                exit()
            elif key in valid_inputs:
                msg = {'input': valid_inputs[key]}
                client.do_send(msg)
    
    # draw everything
    screen.fill((0, 0, 64))  # dark blue
    [draw_rect(screen, (0, 191, 255), b) for b in borders]  # deep sky blue 
    [draw_rect(screen, (255, 192, 203), p) for p in pellets]  # shrimp
    for name, p in players.items():
        if name != myname:
            draw_rect(screen, (255, 0, 0), p)  # red
    if myname:
        draw_rect(screen, (0, 191, 255), players[myname])  # deep sky blue
    
    update_pygame_display()
    
    clock.tick(50)  # frames per second, independent of server frame rate