Code in python

I need to know how to merge code 1 and code 2 into one united code mainly to display the score health bar and the lives

the draw function was turned into a sprite calling the image Sandy

Code 1

import pygame, sys from pygame.locals import * import random import math

# Colors BLACK = (0, 0, 0) WHITE = (255, 255, 255) GREEN = (0, 255, 0) RED = (255, 0, 0) BLUE = (0, 0, 255) PINK = (255, 170, 255) HEAD_B = (153,76,0) CREAM = (242,242,234) L_GREY = (224,224,224) N_ORANGE = (204,102,0) N2_ORANGE = (255,204,153)

def draw(screen): pi = 3.141592653 #tail pygame.draw.ellipse(screen,HEAD_B,[290,320,50,100]) pygame.draw.ellipse(screen,HEAD_B,[276,350,40,60]) #Helmet pygame.draw.circle(screen, BLACK, [360,300],40,3) #Head pygame.draw.ellipse(screen,HEAD_B,[330,300,60,30]) #Mouth pygame.draw.ellipse(screen,RED,[350,315,20,10]) #Cheeks pygame.draw.arc(screen,BLACK,[368,310,15,10],pi,2*pi) pygame.draw.arc(screen,BLACK,[338,310,15,10],pi,2*pi) #Main head pygame.draw.ellipse(screen,HEAD_B,[335,275,50,40]) #Eyes pygame.draw.circle(screen,BLACK,[350,294],7,7) pygame.draw.circle(screen,WHITE,[350,295],7) pygame.draw.circle(screen,BLACK,[350,295],3) pygame.draw.circle(screen,BLACK,[370,294],7,7) pygame.draw.circle(screen,WHITE,[370,295],7) pygame.draw.circle(screen,BLACK,[370,295],3) #Eyelashes pygame.draw.arc(screen,BLACK,[365,275,20,30],5*pi/6,pi) pygame.draw.arc(screen,BLACK,[368,275,20,30],5*pi/6,pi) pygame.draw.arc(screen,BLACK,[372,275,20,30],5*pi/6,pi) pygame.draw.arc(screen,BLACK,[330,270,20,30],0,pi/4) pygame.draw.arc(screen,BLACK,[325,275,20,30],0,pi/3) #Nose pygame.draw.ellipse(screen,PINK,[355,300,10,9]) #Ears pygame.draw.circle(screen,HEAD_B,[340,280],10) pygame.draw.circle(screen,HEAD_B,[380,280],10) pygame.draw.arc(screen,BLACK,[372,275,15,10],0,7*pi/12) pygame.draw.arc(screen,BLACK,[335,275,15,10],5*pi/12,7*pi/6) #neck pygame.draw.rect(screen,HEAD_B,[354,329,12,8]) #body pygame.draw.rect(screen,CREAM,[325,340,80,90]) #bodyoutline pygame.draw.rect(screen,BLACK,[324,339,80,90],5) #body inside pygame.draw.circle(screen,BLACK,[360,347],7,3) pygame.draw.line(screen,BLACK,[360,352],[368,360],3) pygame.draw.line(screen,BLACK,[356,352],[350,360],3) pygame.draw.line(screen,BLACK,[350,360],[368,360],3) pygame.draw.arc(screen,BLACK,[355,361,15,10],pi/2,3*pi/2) pygame.draw.arc(screen,BLACK,[351,371,15,10],0,pi/2) pygame.draw.arc(screen,BLACK,[351,371,15,10],3*pi/2,2*pi) pygame.draw.rect(screen,BLACK,[382,353,20,20],5) #left leg pygame.draw.rect(screen,CREAM,[335,430,22,40]) pygame.draw.rect(screen,BLACK,[335,430,22,40],5) #right leg pygame.draw.rect(screen,CREAM,[373,430,22,40]) pygame.draw.rect(screen,BLACK,[373,430,22,40],5) #left shoe pygame.draw.rect(screen,BLACK,[331,470,30,25]) pygame.draw.rect(screen,BLACK,[315,477,40,18]) pygame.draw.rect(screen,L_GREY,[315,490,46,5]) pygame.draw.ellipse(screen,RED,[350,473,7,10]) #right shoe pygame.draw.rect(screen,BLACK,[370,470,30,25]) pygame.draw.rect(screen,BLACK,[377,477,40,18]) pygame.draw.rect(screen,L_GREY,[370,490,47,5]) pygame.draw.ellipse(screen,RED,[375,473,7,10]) #left hand pygame.draw.ellipse(screen,L_GREY,[485,317,35,30]) pygame.draw.ellipse(screen,L_GREY,[493,308,10,15]) #right hand pygame.draw.ellipse(screen,L_GREY,[205,320,35,30]) pygame.draw.ellipse(screen,L_GREY,[218,310,10,15]) #left arm pygame.draw.rect(screen,CREAM,[406,350,50,27]) pygame.draw.rect(screen,BLACK,[406,350,50,27],5) pygame.draw.polygon(screen, BLACK, [[275,350], [275,375], [230,350],[230,325]], 9) pygame.draw.polygon(screen, CREAM, [[275,350], [275,375], [230,350],[230,325]]) #right arm pygame.draw.rect(screen,CREAM,[272,350,50,27]) pygame.draw.rect(screen,BLACK,[272,350,50,27],5) pygame.draw.polygon(screen, BLACK, [[490,322],[500,350], [457,377], [457,350]], 9) pygame.draw.polygon(screen, CREAM, [[490,322],[500,350], [457,377], [457,350]]) #net pygame.draw.polygon(screen, N2_ORANGE, [[550,200],[580,240], [530,260]]) pygame.draw.line(screen,N_ORANGE,[550,200],[510,320],10)

def display(score): font = pygame.font.Font(None,40) scoretext=font.render("Score:"+str(score), 1, (255,255,255)) screen.blit(scoretext,(500,457))

def texts(lives): font = pygame.font.Font(None,40) scoretext=font.render("Lives:"+str(lives), 1, (255,255,255)) screen.blit(scoretext,(50,457))

def health_bar(player_health): if player_health > 75:

player_health_color = GREEN elif player_health > 50: player_health_color = WHITE else: player_health_color = RED #Drawling a rectangle at the top left conner of screen to display healthbar pygame.draw.rect(screen, player_health_color,(20,25, player_health, 25)) class Jellyfish(pygame.sprite.Sprite): """ This class represents the ball that moves in a circle. """ def __init__(self, color, width, height): """ Constructor that create's the ball's image. """ super().__init__() self.image = pygame.Surface([width, height]) self.image.fill(WHITE) self.image.set_colorkey(WHITE)

pygame.draw.ellipse(self.image, color, [0,0, width, height]) pygame.draw.line(self.image, color, [0 ,0 ],[600,600],5)

self.rect = self.image.get_rect() # The "center" the sprite will orbit self.center_x = 0 self.center_y = 0 # Current angle in radians self.angle = 0 # How far away from the center to orbit, in pixels self.radius = 0 # How fast to orbit, in radians per frame self.speed = 0.05 def update(self): """ Update the ball's position. """ # Calculate a new x, y self.rect.x = self.radius * math.sin(self.angle) + self.center_x self.rect.y = self.radius * math.cos(self.angle) + self.center_y # Increase the angle in prep for the next round. self.angle += self.speed class Player(pygame.sprite.Sprite): """ Class to represent the player. """ def __init__(self, color, width, height): """ Create the player image. """ super().__init__() self.image = pygame.Surface([width, height]) self.image.fill(color) self.rect = self.image.get_rect() def update(self): """Set the user to be where the mouse is. """ pos = pygame.mouse.get_pos() self.rect.x = pos[0] self.rect.y = pos[1] # Initialize Pygame pygame.init() # Set the height and width of the screen SCREEN_WIDTH = 700 SCREEN_HEIGHT = 500 screen = pygame.display.set_mode([SCREEN_WIDTH, SCREEN_HEIGHT]) #Player will start will 100% health player_health = 100

pygame.display.set_caption('Fishing Underwater!') # This is a list of 'sprites.' Each block in the program is # added to this list. The list is managed by a class called 'Group.' jellyfish_list = pygame.sprite.Group() # This is a list of every sprite. All blocks and the player block as well. all_sprites_list = pygame.sprite.Group() for i in range(10): # This represents a block jellyfish = Jellyfish(PINK, 20, 15) # Set a random center location for the block to orbit jellyfish.center_x = random.randrange(SCREEN_WIDTH) jellyfish.center_y = random.randrange(SCREEN_HEIGHT) # Random radius from 10 to 200 jellyfish.radius = random.randrange(10, 200) # Random start angle from 0 to 2pi jellyfish.angle = random.random() * 2 * math.pi # radians per frame jellyfish.speed = 0.010 # Add the block to the list of objects jellyfish_list.add(jellyfish) all_sprites_list.add(jellyfish) # Create a RED player block player = Player(RED, 20, 15) all_sprites_list.add(player) # Loop until the user clicks the close button. done = False # Used to manage how fast the screen updates clock = pygame.time.Clock() score = 0 lives = 0

#Current Level level = 1

#everytime you click down a wet fart sound will play #https://freesound.org/people/DoubleDeanArt/sounds/94989/ #pygame.mixer.init() #click_sound=pygame.mixer.sound("bad-chili-fart.wav ")

#Adding background image background_image = pygame.image.load("spongebobbackground.jpg").convert() background_image.set_colorkey(BLACK)

#buble animation bubble_list=[] for i in range (50): x = random.randrange(0, 900) y = random.randrange(0, 700) bubble_list.append( [x,y] )

#Intro Intructions font = pygame.font.Font(None,46)#font we will use to display intro

display_instructions = True instruction_page = 1

while not done and display_instructions: for event in pygame.event.get(): if event.type == pygame.QUIT: done=True if event.type == pygame.MOUSEBUTTONDOWN: instruction_page += 1 if instruction_page == 3: display_instructions = False #I would like to add sandy hook on the intro. screen.blit(background_image, [0,0] )

if instruction_page == 1: #Draw instruction for pg1 draw(screen) text = font.render("Welcome to Fishing Under Water!", True, WHITE) screen.blit(text, [10,10])

text = font.render("Your character is Sandy Hook!", True, WHITE) screen.blit(text, [10,40]) #Draw instruction for pg2 if instruction_page == 2: draw(screen) text = font.render("Your objective is to clear the sea of all the JellyFish", True, WHITE) screen.blit(text, [10,10])

text = font.render("Kill as many JellyFish as possible and win the high score!", True, WHITE) screen.blit(text, [10,40])

clock.tick(60)

pygame.display.flip()

# -------- Main Program Loop ----------- while not done: for event in pygame.event.get(): if event.type == pygame.QUIT: done = True all_sprites_list.update() # Set The background screen.blit(background_image, [0,0]) # See if the player block has collided with anything. jellyfish_hit_list = pygame.sprite.spritecollide(player, jellyfish_list, True)

# Check the list of collisions. for jellyfish in jellyfish_hit_list: score += 1 print( score )

# Loop for bubbles animation for item in bubble_list: item[1] -=1 pygame.draw.circle(screen, BLACK, item, 10,3)

if item[1] < 0: item[1] = 700 # Draw all the spites all_sprites_list.draw(screen)

#call score display(score)

#call lives function texts(lives) #call healthbar health_bar(player_health) # Go ahead and update the screen with what we've drawn. pygame.display.flip() # Limit to 60 frames per second clock.tick(60) pygame.quit()

Code 2

""" Final Project Professor Sun 4/25/18 """ import pygame, sys from pygame.locals import * import random import math

# Define some colors BLACK = (0, 0, 0) WHITE = (255, 255, 255) GREEN = (0, 255, 0) RED = (255, 0, 0) BLUE = (0, 0, 255) PINK = (255, 170, 255) HEAD_B = (153,76,0) CREAM = (242,242,234) L_GREY = (224,224,224) N_ORANGE = (204,102,0) N2_ORANGE = (255,204,153)

SCREEN_WIDTH = 700 SCREEN_HEIGHT = 500

class Player(pygame.sprite.Sprite): # -- Methods def __init__(self,filename): """ Constructor function """ # Call the parent's constructor super().__init__() # Create an image of the block, and fill it with a color. # This could also be an image loaded from the disk. self.image = pygame.image.load("Sandy.png").convert() self.image.set_colorkey(WHITE) # Set a referance to the image rect. self.rect = self.image.get_rect()

score = 0 lives = 3 player_health = 100 # Set speed vector of player self.change_x = 0 self.change_y = 0 # List of sprites we can bump against

self.level = None

def update(self): """ Move the player. """ # Gravity self.calc_grav() # Move left/right self.rect.x += self.change_x # See if we hit anything block_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False) for block in block_hit_list: # If we are moving right, # set our right side to the left side of the item we hit if self.change_x > 0: self.rect.right = block.rect.left elif self.change_x < 0: # Otherwise if we are moving left, do the opposite. self.rect.left = block.rect.right # Move up/down self.rect.y += self.change_y # Check and see if we hit anything block_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False) for block in block_hit_list: # Reset our position based on the top/bottom of the object. if self.change_y > 0: self.rect.bottom = block.rect.top elif self.change_y < 0: self.rect.top = block.rect.bottom # Stop our vertical movement self.change_y = 0 def calc_grav(self): """ Calculate effect of gravity. """ if self.change_y == 0: self.change_y = 1 else: self.change_y += .35 # See if we are on the ground. if self.rect.y >= SCREEN_HEIGHT - self.rect.height and self.change_y >= 0: self.change_y = 0 self.rect.y = SCREEN_HEIGHT - self.rect.height def jump(self): """ Called when user hits 'jump' button. """ # move down a bit and see if there is a platform below us. # Move down 2 pixels because it doesn't work well if we only move down # 1 when working with a platform moving down. self.rect.y += 2 platform_hit_list = pygame.sprite.spritecollide(self, self.level.platform_list, False) self.rect.y -= 2 # If it is ok to jump, set our speed upwards if len(platform_hit_list) > 0 or self.rect.bottom >= SCREEN_HEIGHT: self.change_y = -10 # Player-controlled movement: def go_left(self): """ Called when the user hits the left arrow. """ self.change_x = -6 def go_right(self): """ Called when the user hits the right arrow. """ self.change_x = 6 def stop(self): """ Called when the user lets off the keyboard. """ self.change_x = 0 class Platform(pygame.sprite.Sprite): """ Platform the user can jump on """ def __init__(self, width, height): """ Platform constructor. Assumes constructed with user passing in an array of 5 numbers like what's defined at the top of this code. """ super().__init__() self.image = pygame.Surface([width, height]) self.image.fill(BLUE) self.rect = self.image.get_rect()

class MovingPlatform(Platform): """ This is a fancier platform that can actually move. """ change_x = 0 change_y = 0 boundary_top = 0 boundary_bottom = 0 boundary_left = 0 boundary_right = 0 player = None level = None def update(self): """ Move the platform. If the player is in the way, it will shove the player out of the way. This does NOT handle what happens if a platform shoves a player into another object. Make sure moving platforms have clearance to push the player around or add code to handle what happens if they don't. """ # Move left/right self.rect.x += self.change_x # See if we hit the player hit = pygame.sprite.collide_rect(self, self.player) if hit: # We did hit the player. Shove the player around and # assume he/she won't hit anything else. # If we are moving right, set our right side # to the left side of the item we hit if self.change_x < 0: self.player.rect.right = self.rect.left else: # Otherwise if we are moving left, do the opposite. self.player.rect.left = self.rect.right # Move up/down self.rect.y += self.change_y # Check and see if we the player hit = pygame.sprite.collide_rect(self, self.player) if hit: # We did hit the player. Shove the player around and # assume he/she won't hit anything else. # Reset our position based on the top/bottom of the object. if self.change_y < 0: self.player.rect.bottom = self.rect.top else: self.player.rect.top = self.rect.bottom # Check the boundaries and see if we need to reverse # direction. if self.rect.bottom > self.boundary_bottom or self.rect.top < self.boundary_top: self.change_y *= -1 cur_pos = self.rect.x - self.level.world_shift if cur_pos < self.boundary_left or cur_pos > self.boundary_right: self.change_x *= -1

class Level(object): """ This is a generic super-class used to define a level. Create a child class for each level with level-specific info. """ def __init__(self, player): """ Constructor. Pass in a handle to player. Needed for when moving platforms collide with the player. """ self.platform_list = pygame.sprite.Group() self.enemy_list = pygame.sprite.Group() self.player = player

# Background image self.background = None # How far this world has been scrolled left/right self.world_shift = 0 # Update everythign on this level def update(self): """ Update everything in this level.""" self.platform_list.update() self.enemy_list.update() def draw(self, screen): """ Draw everything on this level. """ screen.fill(BLUE) screen.blit(self.background,(0,0)) # Draw all the sprite lists that we have self.platform_list.draw(screen) self.enemy_list.draw(screen) def shift_world(self, shift_x): """ When the user moves left/right and we need to scroll everything: """ # Keep track of the shift amount self.world_shift += shift_x # Go through all the sprite lists and shift for platform in self.platform_list: platform.rect.x += shift_x for enemy in self.enemy_list: enemy.rect.x += shift_x # Create platforms for the level class Level_01(Level): """ Definition for level 1. """ def __init__(self, player): """ Create level 1. """ # Call the parent constructor Level.__init__(self, player)

self.background = pygame.image.load("fields.jpg").convert() self.background.set_colorkey(WHITE) self.level_limit = -1000 # Array with width, height, x, and y of platform level = [[150, 50, 600, 400], [150, 50, 800, 250], [150, 50, 1000,350], [150, 50, 1500,350]] # Go through the array above and add platforms for platform in level: block = Platform(platform[0], platform[1]) block.rect.x = platform[2] block.rect.y = platform[3] block.player = self.player self.platform_list.add(block) # Create platforms for the level class Level_02(Level): """ Definition for level 2. """ def __init__(self, player): """ Create level 1. """ # Call the parent constructor Level.__init__(self, player) self.background = pygame.image.load("fields.jpg").convert() self.background.set_colorkey(WHITE) self.level_limit = -2000 # Array with type of platform, and x, y location of the platform. level = [[210, 30, 650, 350], [210, 30, 1050, 250], [210, 30, 1650, 250], [210, 30, 2000, 400]] # Go through the array above and add platforms for platform in level: block = Platform(platform[0], platform[1]) block.rect.x = platform[2] block.rect.y = platform[3] block.player = self.player self.platform_list.add(block)

# Add a custom moving platform block = MovingPlatform(50, 70) block.rect.x = 1400 block.rect.y = 300 block.boundary_top = 100 block.boundary_bottom = 500 block.change_y = -1 block.player = self.player block.level = self self.platform_list.add(block) # Create platforms for the level class Level_03(Level): """ Definition for level 2. """ def __init__(self, player): """ Create level 1. """ # Call the parent constructor Level.__init__(self, player) self.background = pygame.image.load("fields.jpg").convert() self.background.set_colorkey(WHITE) self.level_limit = -2000

# Add a custom moving platform block = MovingPlatform(50, 50) block.rect.x = 650 block.rect.y = 350 block.boundary_top = 100 block.boundary_bottom = 500 block.change_y = -2 block.player = self.player block.level = self self.platform_list.add(block)

# Add a custom moving platform block = MovingPlatform(300, 50) block.rect.x = 1050 block.rect.y = 250 block.boundary_left = 800 block.boundary_right =1100 block.change_x = 2 block.player = self.player block.level = self self.platform_list.add(block)

# Add a custom moving platform block = MovingPlatform(300, 50) block.rect.x = 1500 block.rect.y = 300 block.boundary_top = 100 block.boundary_bottom = 500 block.change_y = -4 block.player = self.player block.level = self self.platform_list.add(block)

# Add a custom moving platform block = MovingPlatform(250, 100) block.rect.x = 2000 block.rect.y = 250 block.boundary_top = 100 block.boundary_bottom = 500 block.change_y = 1 block.player = self.player block.level = self self.platform_list.add(block)

class Jellyfish(pygame.sprite.Sprite): """ This class represents the ball that moves in a circle. """ def __init__(self, color, width, height): """ Constructor that create's the ball's image. """ super().__init__() self.image = pygame.Surface([width, height]) self.image.fill(WHITE) self.image.set_colorkey(WHITE)

pygame.draw.ellipse(self.image, color, [0,0, width, height]) pygame.draw.line(self.image, color, [0 ,0 ],[500,400],5)

self.rect = self.image.get_rect() # The "center" the sprite will orbit self.center_x = 0 self.center_y = 0 # Current angle in radians self.angle = 90 # How far away from the center to orbit, in pixels self.radius = 0 # How fast to orbit, in radians per frame self.speed = 0.10 def update(self): """ Update the ball's position. """ # Calculate a new x, y self.rect.x = self.radius * math.sin(self.angle) + self.center_x self.rect.y = self.radius * math.cos(self.angle) + self.center_y

# Increase the angle in prep for the next round. self.angle += self.speed def main(): """ Main Program """ pygame.init()

# Set the width and height of the screen [width, height]

SCREEN_WIDTH = 700 SCREEN_HEIGHT = 500 screen = pygame.display.set_mode([SCREEN_WIDTH, SCREEN_HEIGHT])

pygame.display.set_caption("Fishing Underwater") # Create the player player = Player("Sandy") # Create all the levels level_list = [] level_list.append(Level_01(player)) level_list.append(Level_02(player)) level_list.append(Level_03(player)) # Set the current level current_level_no = 0 current_level = level_list[current_level_no] active_sprite_list = pygame.sprite.Group() player.level = current_level player.rect.x = 0 player.rect.y = SCREEN_HEIGHT - player.rect.height active_sprite_list.add(player) # This is a list of 'sprites.' Each block in the program is # added to this list. The list is managed by a class called 'Group.' jellyfish_list = pygame.sprite.Group() # This is a list of every sprite. All blocks and the player block as well. all_sprites_list = pygame.sprite.Group() for i in range(10): # This represents a block jellyfish = Jellyfish(PINK, 30,20 ) # Set a random center location for the block to orbit jellyfish.center_x = random.randrange(SCREEN_WIDTH) jellyfish.center_y = random.randrange(SCREEN_HEIGHT) # Random radius from 10 to 200 jellyfish.radius = random.randrange(150, 200) # Random start angle from 0 to 2pi jellyfish.angle = random.random() * 2 * math.pi # radians per frame jellyfish.speed = 0.008 # Add the block to the list of objects jellyfish_list.add(jellyfish) all_sprites_list.add(jellyfish)

all_sprites_list.add(player) # Loop until the user clicks the close button. done = False # Used to manage how fast the screen updates clock = pygame.time.Clock()

score = 0 lives = 0 #everytime you click down a wet fart sound will play #https://freesound.org/people/DoubleDeanArt/sounds/94989/ #pygame.mixer.init() #click_sound=pygame.mixer.sound("bad-chili-fart.wav ")

# -------- Main Program Loop ----------- while not done: # --- Main event loop for event in pygame.event.get(): if event.type == pygame.QUIT: done = True if event.type == pygame.KEYDOWN: if event.key == pygame.K_LEFT: player.go_left() if event.key == pygame.K_RIGHT: player.go_right() if event.key == pygame.K_UP: player.jump() if event.type == pygame.KEYUP: if event.key == pygame.K_LEFT and player.change_x < 0: player.stop() if event.key == pygame.K_RIGHT and player.change_x > 0: player.stop() # Update the player. active_sprite_list.update() # Update items in the level current_level.update() # If the player gets near the right side, shift the world left (-x) if player.rect.right >= 500: diff = player.rect.right - 500 player.rect.right = 500 current_level.shift_world(-diff) # If the player gets near the left side, shift the world right (+x) if player.rect.left <= 120: diff = 120 - player.rect.left player.rect.left = 120 current_level.shift_world(diff) # If the player gets to the end of the level, go to the next level current_position = player.rect.x + current_level.world_shift if current_position < current_level.level_limit: player.rect.x = 120 if current_level_no < len(level_list)-1: current_level_no += 1 current_level = level_list[current_level_no] player.level = current_level

# See if the player block has collided with anything. jellyfish_hit_list = pygame.sprite.spritecollide(player, jellyfish_list, True) # Check the list of collisions. for jellyfish in jellyfish_hit_list: score += 1 print( score )

all_sprites_list.update() current_level.draw(screen) all_sprites_list.draw(screen) # Go ahead and update the screen with what we've drawn. pygame.display.flip() # Limit to 60 frames per second clock.tick(60) pygame.quit() if __name__ == "__main__": main()