def on_draw(self): """ Render the screen. """ # This command has to happen before we start drawing arcade.start_render() # Start timing how long this takes draw_start_time = timeit.default_timer() # Draw all the sprites self.sprite_list.draw() # Draw the lines that aren't sprites for line in self.static_lines: body = line.body pv1 = body.position + line.a.rotated(body.angle) pv2 = body.position + line.b.rotated(body.angle) arcade.draw_line(pv1.x, pv1.y, pv2.x, pv2.y, arcade.color.WHITE, 2) # Display timings draw_time = timeit.default_timer() - draw_start_time arcade.draw_text("Processing time: {:.3f}".format(self.time), 20, SCREEN_HEIGHT - 20, arcade.color.BLACK, 12) arcade.draw_text("Drawing time: {:.3f}".format(draw_time), 20, SCREEN_HEIGHT - 40, arcade.color.BLACK, 12)
def on_draw(delta_time): """ Use this function to draw everything to the screen. """ # Start the render. This must happen before any drawing # commands. We do NOT need a stop render command. arcade.start_render() # Draw a rectangle. # For a full list of colors see: # http://pythonhosted.org/arcade/arcade.color.html arcade.draw_rectangle_filled(on_draw.center_x, on_draw.center_y, RECT_WIDTH, RECT_HEIGHT, arcade.color.ALIZARIN_CRIMSON) # Modify rectangles position based on the delta # vector. (Delta means change. You can also think # of this as our speed and direction.) on_draw.center_x += on_draw.delta_x * delta_time on_draw.center_y += on_draw.delta_y * delta_time # Figure out if we hit the edge and need to reverse. if on_draw.center_x < RECT_WIDTH // 2 \ or on_draw.center_x > SCREEN_WIDTH - RECT_WIDTH // 2: on_draw.delta_x *= -1 if on_draw.center_y < RECT_HEIGHT // 2 \ or on_draw.center_y > SCREEN_HEIGHT - RECT_HEIGHT // 2: on_draw.delta_y *= -1
def main(): """ This is the main program. """ # Open the window arcade.open_window("Drawing With Functions", SCREEN_WIDTH, SCREEN_HEIGHT) # Start the render process. This must be done before any drawing commands. arcade.start_render() # Call our drawing functions. draw_background() draw_pine_tree(50, 250) draw_pine_tree(350, 320) draw_bird(70, 500) draw_bird(470, 550) draw_bird(175, 450) draw_bird(525, 475) draw_bird(415, 475) # My drawing of PACMAN arcade.draw_arc_filled(225, 230, 36, 36, arcade.color.YELLOW, 90, 360, -45) # Finish the render. # Nothing will be drawn without this. # Must happen after all draw commands arcade.finish_render() # Keep the window up until someone closes it. arcade.run()
def main(): """ This is the main program. """ # Open the window arcade.open_window("Drawing With Functions", 600, 600) # Start the render process. This must be done before any drawing commands. arcade.start_render() # Call our drawing functions. draw_background() draw_pine_tree(50, 250) draw_pine_tree(350, 320) draw_bird(70, 500) draw_bird(470, 550) # Finish the render. # Nothing will be drawn without this. # Must happen after all draw commands arcade.finish_render() # Keep the window up until someone closes it. arcade.run()
def on_draw(self): """ Render the screen. """ arcade.start_render() self.player.draw()
def draw(dt): """ Use this function to draw everything to the screen. """ # Start the render. This must happen before any drawing # commands. We do NOT need an stop render command. arcade.start_render() # Draw our rectangle arcade.draw_circle_filled(draw.x, draw.y, CIRCLE_RADIUS, arcade.color.BLACK) # Modify rectangles position based on the delta # vector. (Delta means change. You can also think # of this as our speed and direction.) draw.x += draw.delta_x draw.y += draw.delta_y draw.delta_y -= GRAVITY_CONSTANT # Figure out if we hit the left or right edge and need to reverse. if draw.x < CIRCLE_RADIUS and draw.delta_x < 0: draw.delta_x *= -BOUNCINESS elif draw.x > SCREEN_WIDTH - CIRCLE_RADIUS and draw.delta_x > 0: draw.delta_x *= -BOUNCINESS # See if we hit the bottom if draw.y < CIRCLE_RADIUS and draw.delta_y < 0: # If we bounce with a decent velocity, do a normal bounce. # Otherwise we won't have enough time resolution to accurate represent # the bounce and it will bounce forever. So we'll divide the bounciness # by half to let it settle out. if draw.delta_y * -1 > GRAVITY_CONSTANT * 15: draw.delta_y *= -BOUNCINESS else: draw.delta_y *= -BOUNCINESS / 2
def on_draw(self): """ Render the screen. """ # This command should happen before we start drawing. It will clear # the screen to the background color, and erase what we drew last frame. arcade.start_render() # start_x and start_y make the start point for the text. We draw a dot to make it easy too see # the text in relation to its start x and y. start_x = 50 start_y = 450 arcade.draw_point(start_x, start_y, arcade.color.BLUE, 5) arcade.draw_text("Simple line of text in 12 point", start_x, start_y, arcade.color.BLACK, 12) start_x = 50 start_y = 400 arcade.draw_point(start_x, start_y, arcade.color.BLUE, 5) arcade.draw_text("Text anchored 'top' and 'left'.", start_x, start_y, arcade.color.BLACK, 12, anchor_x="left", anchor_y="top") start_y = 350 arcade.draw_point(start_x, start_y, arcade.color.BLUE, 5) arcade.draw_text("14 point multi\nline\ntext", start_x, start_y, arcade.color.BLACK, 14, anchor_y="top") start_y = 450 start_x = 300 arcade.draw_point(start_x, start_y, arcade.color.BLUE, 5) arcade.draw_text("Set of text\nthat\nis centered.", start_x, start_y, arcade.color.BLACK, 14, width=200, align="center", anchor_y="top") start_y = 250 start_x = 300 arcade.draw_point(start_x, start_y, arcade.color.BLUE, 5) arcade.draw_text("Text centered on\na point", start_x, start_y, arcade.color.BLACK, 14, width=200, align="center", anchor_x="center", anchor_y="center") start_y = 150 start_x = 300 arcade.draw_point(start_x, start_y, arcade.color.BLUE, 5) arcade.draw_text("Text rotated on\na point", start_x, start_y, arcade.color.BLACK, 14, width=200, align="center", anchor_x="center", anchor_y="center", rotation=self.text_angle) start_y = 150 start_x = 20 arcade.draw_point(start_x, start_y, arcade.color.BLUE, 5) arcade.draw_text("Sidewarys text", start_x, start_y, arcade.color.BLACK, 14, width=200, align="center", anchor_x="center", anchor_y="center", rotation=90.0) start_y = 20 start_x = 50 arcade.draw_point(start_x, start_y, arcade.color.BLUE, 5) arcade.draw_text("Time elapsed: {:5.1f}".format(self.time_elapsed), start_x, start_y, arcade.color.BLACK, 14)
def on_draw(self): """ Render the screen. """ arcade.start_render() for shape in self.shape_list: shape.draw()
def on_draw(self): """ Render the screen. """ # This command should happen before we start drawing. It will clear # the screen to the background color, and erase what we drew last frame. arcade.start_render()
def on_draw(delta_time): """ Use this function to draw everything to the screen. """ # Start the render. This must happen before any drawing # commands. We do NOT need an stop render command. arcade.start_render() # Draw shapes arcade.draw_all(shapes)
def on_draw(self): """ Render the screen. """ # This command has to happen before we start drawing arcade.start_render() for a in self.object_list: a.draw()
def on_draw(self): """ Render the screen. """ # This command has to happen before we start drawing arcade.start_render() arcade.draw_text("This is a simple template to start your game.", 10, SCREEN_HEIGHT // 2, arcade.color.BLACK, 20)
def on_draw(self): """Render the screen""" arcade.start_render() # Text on screen text = "Press left mouse to make noise" # Render text arcade.draw_text(text, 150, 300, arcade.color.WHITE, 30)
def on_draw(self): """ Render the screen. """ # This command has to happen before we start drawing arcade.start_render() self.object_list.draw() start_x = 20 start_y = 10 arcade.draw_text("Processing time: {:.3f}".format(self.time), start_x, start_y, arcade.color.BLACK, 12)
def on_draw(self): """ Render the screen. """ # This command is necessary before drawing arcade.start_render() # Draw the current position of each snowflake for snowflake in self.snowflake_list: arcade.draw_circle_filled(snowflake.x, snowflake.y, snowflake.size, arcade.color.WHITE)
def on_draw(self): arcade.start_render() self.all_sprites_list.draw() arcade.draw_text("Score: {}".format(self.score), self.ortho_left + 0.01, 9.75, arcade.color.BLACK, 12) grid_color = (0, 0, 255, 127) for y in range(0, 801, 32): arcade.draw_line(0, y, 800, y, grid_color) for x in range(0, 801, 32): arcade.draw_line(x, 0, x, 800, grid_color)
def on_draw(self): """ Render the screen. """ # This command has to happen before we start drawing arcade.start_render() for ball in self.ball_list: arcade.draw_circle_filled(ball.x, ball.y, ball.size, ball.color) # Put the text on the screen. output = "Balls: {}".format(len(self.ball_list)) arcade.draw_text(output, 10, 20, arcade.color.WHITE, 14)
def on_draw(self): """ Render the screen. """ # This command has to happen before we start drawing arcade.start_render() # Draw all the sprites. self.all_sprites_list.draw() # Put the text on the screen. output = "Score: {}".format(self.score) arcade.draw_text(output, 10, 20, arcade.color.WHITE, 14)
def on_draw(self): """ Use this function to draw everything to the screen. """ # Start the render. This must happen before any drawing # commands. We do NOT need an stop render command. arcade.start_render() # Calculate minutes minutes = int(self.total_time) // 60 # Calculate seconds by using a modulus (remainder) seconds = int(self.total_time) % 60 output = "Time: {:02d}:{:02d}".format(minutes, seconds) arcade.draw_text(output, 300, 300, arcade.color.BLACK, 30)
def on_draw(self): """ Render the screen. """ # This command should happen before we start drawing. It will clear # the screen to the background color, and erase what we drew last frame. arcade.start_render() # Draw the circle arcade.draw_circle_filled(self.ball_x_position, SCREEN_HEIGHT // 2, BALL_RADIUS, arcade.color.GREEN) # Draw the text arcade.draw_text("This is a simple template to start your game.", 10, SCREEN_HEIGHT // 2, arcade.color.BLACK, 20)
def on_draw(self): """ Render the screen. """ # This command has to happen before we start drawing arcade.start_render() # Draw all the sprites. self.all_sprites_list.draw() # Put the text on the screen. # Adjust the text position based on the viewport so that we don't # scroll the text too. output = "Score: {}".format(self.score) arcade.draw_text(output, self.view_left + 10, self.view_bottom + 20, arcade.color.WHITE, 14)
def on_draw(self): """ Render the screen. """ # This command should happen before we start drawing. It will clear # the screen to the background color, and erase what we drew last frame. arcade.start_render() #draw Sprites self.all_sprites_list.draw() self.rocket_sprites_list.draw() self.item_sprites_list.draw() if self.invis_activated is False: self.ball_sprite.draw() #draw Text arcade.draw_text("Computer Score: " + str(self.computer_score), 10, SCREEN_HEIGHT - 30, arcade.color.BLACK, 12) arcade.draw_text("Player Score: " + str(self.player_score), 10, 10, arcade.color.BLACK, 12)
def on_draw(self): """ Render the screen. """ # This command has to happen before we start drawing arcade.start_render() if self.current_state == INSTRUCTIONS_PAGE_0: self.draw_instructions_page(0) elif self.current_state == INSTRUCTIONS_PAGE_1: self.draw_instructions_page(1) elif self.current_state == GAME_RUNNING: self.draw_game() else: self.draw_game() self.draw_game_over()
def on_draw(delta_time): arcade.start_render() #Appear in first column arcade.draw_circle_filled(100, 100, 50, arcade.color.YELLOW) #Appear in second column arcade.draw_small_filled_circle(300, 100, arcade.color.YELLOW) arcade.draw_medium_filled_circle(300, 300, arcade.color.YELLOW) arcade.draw_large_filled_circle(300, 500, arcade.color.YELLOW) #Appear in third column arcade.draw_standard_circle(500, 100, arcade.color.YELLOW, "LARGE", "filled") arcade.draw_standard_circle(500, 300, arcade.color.YELLOW, "m", "filled") arcade.draw_standard_circle(500, 500, arcade.color.YELLOW, "small", "filled") #Appear in fourth column arcade.draw_circle_outline(700, 300, 50, arcade.color.YELLOW) arcade.draw_circle(700, 100, 50, arcade.color.YELLOW)
def on_draw(delta_time): """ Use this function to draw everything to the screen. """ # Move the angle of the sweep. on_draw.angle += RADIANS_PER_FRAME # Calculate the end point of our radar sweep. Using math. x = SWEEP_LENGTH * math.sin(on_draw.angle) + CENTER_X y = SWEEP_LENGTH * math.cos(on_draw.angle) + CENTER_Y # Start the render. This must happen before any drawing # commands. We do NOT need an stop render command. arcade.start_render() # Draw the radar line arcade.draw_line(CENTER_X, CENTER_Y, x, y, arcade.color.OLIVE, 2) # Draw the outline of the radar arcade.draw_circle_outline(CENTER_X, CENTER_Y, SWEEP_LENGTH, arcade.color.DARK_GREEN, 3)
def main(): """ This is the main program. """ # Open the window arcade.open_window("Drawing With Loops", SCREEN_WIDTH, SCREEN_HEIGHT) # Start the render process. This must be done before any drawing commands. arcade.start_render() # Call our drawing functions. draw_background() # Loop to draw ten birds in random locations. for bird_count in range(10): # Any random x from 0 to the width of the screen x = random.randrange(0, SCREEN_WIDTH) # Any random y from in the top 2/3 of the screen. # No birds on the ground. y = random.randrange(SCREEN_HEIGHT / 3, SCREEN_HEIGHT - 20) # Draw the bird. draw_bird(x, y) # Draw the top row of trees for x in range(45, SCREEN_WIDTH, 90): draw_pine_tree(x, SCREEN_HEIGHT / 3) # Draw the bottom row of trees for x in range(65, SCREEN_WIDTH, 90): draw_pine_tree(x, (SCREEN_HEIGHT / 3) - 120) # Finish the render. # Nothing will be drawn without this. # Must happen after all draw commands arcade.finish_render() # Keep the window up until someone closes it. arcade.run()
def on_draw(self): """ Render the screen. """ # This command has to happen before we start drawing arcade.start_render() # Draw all the sprites. self.all_sprites_list.draw() # Put the text on the screen. # Adjust the text position based on the viewport so that we don't # scroll the text too. distance = self.view_left + self.player_sprite.right output = "Distance: {}".format(distance) arcade.draw_text(output, self.view_left + 10, self.view_bottom + 20, arcade.color.WHITE, 14) if self.game_over: output = "Game Over" arcade.draw_text(output, self.view_left + 200, self.view_bottom + 200, arcade.color.WHITE, 30)
def on_draw(delta_time): """ Use this function to draw everything to the screen. """ # Start the render. This must happen before any drawing # commands. We do NOT need an stop render command. arcade.start_render() # Draw shapes on_draw.rectangle.draw() on_draw.oval.draw() on_draw.ellipse.draw() on_draw.circle.draw() on_draw.square.draw() arcade.draw_all(shapes) #update shape positions on_draw.rectangle.update() on_draw.oval.update() on_draw.ellipse.update() on_draw.circle.update() on_draw.square.update() arcade.update_all(shapes)
def on_draw(delta_time): """ Use this function to draw everything to the screen. """ # Start the render. This must happen before any drawing # commands. We do NOT need an stop render command. arcade.start_render() # Draw our rectangle arcade.draw_rectangle_filled(on_draw.x, on_draw.y, RECT_WIDTH, RECT_HEIGHT, arcade.color.BLACK) # Modify rectangles position based on the delta # vector. (Delta means change. You can also think # of this as our speed and direction.) on_draw.x += on_draw.delta_x on_draw.y += on_draw.delta_y # Figure out if we hit the edge and need to reverse. if on_draw.x < RECT_WIDTH // 2 or on_draw.x > SCREEN_WIDTH - RECT_WIDTH // 2: on_draw.delta_x *= -1 if on_draw.y < RECT_HEIGHT // 2 or on_draw.y > SCREEN_HEIGHT - RECT_HEIGHT // 2: on_draw.delta_y *= -1
def on_draw(self): """ Render the screen. """ # This command has to happen before we start drawing arcade.start_render() # Draw the grid for row in range(10): for column in range(10): # Figure out what color to draw the box if self.grid[row][column] == 1: color = arcade.color.GREEN else: color = arcade.color.WHITE # Do the math to figure out where the box is x = (MARGIN + WIDTH) * column + MARGIN + WIDTH // 2 y = (MARGIN + HEIGHT) * row + MARGIN + HEIGHT // 2 # Draw the box arcade.draw_rectangle_filled(x, y, WIDTH, HEIGHT, color)
def on_draw(self): arcade.start_render() # Code to draw the screen goes here self.wall_list.draw() self.player_list.draw() self.entities_list.draw()
def on_draw(self): """ Called when it is time to draw the world """ arcade.start_render() self.pic_list.draw() arcade.draw_text(f"Points: {self.points}", 20, 50, arcade.color.WHITE, 14)
def on_draw(self): arcade.start_render() arcade.draw_text("Menu Screen", WIDTH/2, HEIGHT/2, arcade.color.BLACK, font_size=50, anchor_x="center") arcade.draw_text("Click to advance.", WIDTH/2, HEIGHT/2-75, arcade.color.GRAY, font_size=20, anchor_x="center")
def setup(self): ui_manager.purge_ui_elements() arcade.start_render() button = GameViewButton('Play', center_x=650, center_y=400, width=250) ui_manager.add_ui_element(button)
def on_draw(self): """ Called when it is time to draw the world """ arcade.start_render() self.logo_list.draw()
def on_draw(self): arcade.start_render() self.sprites.draw()
def on_draw(self): arcade.start_render() for b in self.ball_list: b.draw()
def on_draw(self): arcade.start_render() self.apple_list.draw() self.snake_list.draw() output = f"Score: {self.score}" arcade.draw_text(output, 10, 20, arcade.color.BLACK, 14)
#!/usr/bin/env python3 import utils, open_color, arcade utils.check_version((3, 7)) # Open the window. Set the window title and dimensions (width and height) arcade.open_window(800, 600, "Smiley Face Example") arcade.set_background_color(open_color.white) # Start the render process. This must be done before any drawing commands. arcade.start_render() face_x, face_y = (400, 300) # Draw the smiley face: # (x,y,radius,color) arcade.draw_circle_filled(face_x, face_y, 100, open_color.yellow_3) # (x,y,radius,color,border_thickness) arcade.draw_circle_outline(face_x + 0, face_y + 0, 100, open_color.black, 4) #(x,y,width,height,color) arcade.draw_ellipse_filled(face_x - 40, face_y + 25, 15, 25, open_color.black) arcade.draw_ellipse_filled(face_x + 40, face_y + 25, 15, 25, open_color.black) arcade.draw_circle_filled(face_x + 45, face_y + 40, 3, open_color.gray_2) arcade.draw_circle_filled(face_x - 35, face_y + 40, 3, open_color.gray_2) #(x,y,width,height,color,start_degrees,end_degrees,border_thickness) arcade.draw_arc_outline(face_x + 0, face_y - 25, 60, 50, open_color.black, 190, 350, 4) # Finish the render
def on_draw(self): arcade.start_render() self.particle_list.draw()
def on_draw(self): arcade.start_render() # Code to draw the screen goes here self.star_liste.draw() self.player_liste.draw() arcade.draw_text("Hallo world",10, SCREEN_HEIGHT -20, arcade.color.WHITE)
def on_draw(self): arcade.start_render() if self.page_number == 0: arcade.draw_circle_filled(50, 50, 500, arcade.color.WHITE) arcade.set_background_color(arcade.color.GRAY) if time() - self.time_check >= 1: self.motion = randint(0, 2) self.time_check = time() pic = [ arcade.load_texture('pics/menu/menu1.png'), arcade.load_texture('pics/menu/menu2.png', ), arcade.load_texture('pics/menu/menu3.png') ] # For menu pic for each_pic in pic: self.set_center(each_pic) arcade.draw_texture_rectangle(pic[self.motion].center_x, pic[self.motion].center_y, texture=pic[self.motion], height=700, width=900) #For 1.3.7 #arcade.draw_text('Press ENTER to start the game', 0, 100, arcade.color.AMETHYST, width=self.width, # font_size=35) arcade.draw_text('Press ENTER to start the game', 0, 100, arcade.color.AMETHYST, font_size=35) arcade.draw_text('Just An Ordinary Dungeon Crawler game', 0, 200, arcade.color.GOLD_FUSION, font_size=50, width=3500) elif self.page_number == -1: self.menu.draw() elif self.page_number == 1: arcade.draw_texture_rectangle(self.bg.center_x, self.bg.center_y, texture=self.bg, height=600, width=800) self.player.draw() self.enemy_type.draw() self.player.attack(self.time_check) self.map.map_component() arcade.draw_text(f'The current level is {self.level}', self.width - 200, self.height - 100, arcade.color.BLACK) arcade.draw_text(f'Current life {self.player.life}', 100, self.height - 100, arcade.color.BLACK) arcade.draw_text(f'Current Money {self.MONEY}', self.width // 2 - 50, self.height - 100, arcade.color.BLACK) self.shield.draw() if self.hurt_status: arcade.draw_rectangle_outline(self.width // 2, self.height // 2, self.width, self.height, arcade.color.RED, 10) if time() - self.hurt_time >= 1.5: self.hurt_status = False elif self.page_number == -3 or self.page_number == -2: tutorial = arcade.load_texture('pics/scene/t2.png') if self.page_number == -2: tutorial = arcade.load_texture('pics/scene/t1.png') self.set_center(tutorial) arcade.draw_texture_rectangle(tutorial.center_x, tutorial.center_y, texture=tutorial, height=600, width=800) elif self.page_number == 3: bonus = arcade.load_texture('pics/game_over/game.png') self.set_center(bonus) arcade.draw_texture_rectangle(bonus.center_x, bonus.center_y, texture=bonus, height=700, width=900) self.dialog.on_draw(self.dialog_status)
def on_draw(self): arcade.start_render()
def on_draw(self): """ Called whenever we need to draw the window. """ arcade.start_render() self.ball.draw()
def on_draw(self): """ Render the screen. """ # This command should happen before we start drawing. It will clear # the screen to the background color, and erase what we drew last frame. arcade.start_render() arcade.draw_text(str(self.fps), 0.97 * SCREEN_WIDTH, 0.97 * SCREEN_HEIGHT, arcade.color.WHITE, 20) if not self.game_finished: arcade.draw_rectangle_filled(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2, 5, SCREEN_HEIGHT, (46, 46, 46)) for ball in self.ball_list: arcade.draw_circle_filled(ball.x, ball.y, ball.radius, ball.colour) for paddle in self.paddles: arcade.draw_rectangle_filled(paddle.x, paddle.y, paddle.width, paddle.height, paddle.colour) self.player1points_texture = points[self.player1points] self.player2points_texture = points[self.player2points] arcade.draw_texture_rectangle( SCREEN_WIDTH // 2 - 50, SCREEN_HEIGHT - 50, self.player1points_texture.width * self.scale, self.player1points_texture.height * self.scale, self.player1points_texture) arcade.draw_texture_rectangle( SCREEN_WIDTH // 2 + 50, SCREEN_HEIGHT - 50, self.player2points_texture.width * self.scale, self.player2points_texture.height * self.scale, self.player2points_texture) if self.player1points == 9: self.win_texture = win_textures[0] arcade.draw_texture_rectangle(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2, self.win_texture.width, self.win_texture.height, self.win_texture) self.game_finished = True if not self.report_written: with open("Results.txt", "a") as f: f.write( "\n{} vs {} on {} at {}. {} won with a score of {} - {}." .format(player1name, player2name, date, time_started, player1name, self.player1points, self.player2points)) self.report_written = True if self.player2points == 9: self.win_texture = win_textures[1] arcade.draw_texture_rectangle(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2, self.win_texture.width, self.win_texture.height, self.win_texture) self.game_finished = True if not self.report_written: with open("Results.txt", "a") as f: f.write( "\n{} vs {} on {} at {}. {} won with a score of {} - {}." .format(player1name, player2name, date, time_started, player2name, self.player1points, self.player2points)) self.report_written = True
def on_draw(self): """ Render the screen. """ arcade.start_render()