Exemple #1
0
 def mainloop(self):
     print "MAIN LOOP"
     # satan machine for game
     while self.state is not QUIT:
         if self.state == MENU:
             print "MAIN MENU"
             options = [menu.Item("CBZT"),
                        menu.Item(" "),
                        menu.Option(SINGLEPLAYER,"SINGLE PLAYER",True),
                        menu.Option(MULTIPLAYER,"MULTIPLAYER"),
                        menu.Option(INSTRUCTIONS,"INSTRUCTIONS"),
                        menu.Option(QUIT,"QUIT")]
             self.state = menu.launch(self.screen,options)
         elif self.state == SINGLEPLAYER:
             print "SINGLE PLAYER GAME"
             try:
                 singleplayer.SinglePlayer(self.screen)
             except EndGame, e:
                 print e.msg
                 self.state = MENU
         elif self.state == MULTIPLAYER:
             print "MULTIPLAYER MENU"
             options = [menu.Item("MULTIPLAYER"),
                        menu.Item(" "),
                        menu.Option(MULTIPLAYER_LOCAL,"LOCAL",True),
                        #menu.Option(HOST,"HOST",True),
                        #menu.Option(CONNECT,"CONNECT"),
                        menu.Option(MENU,"MAIN MENU")]
             self.state = menu.launch(self.screen,options)
Exemple #2
0
def play(fps):
    # Set the width and height of the window
    width, height = 640, 480
    # Create the window
    screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)
    # Set pressed keys
    keys = [False, False, False, False]
    # Set player position
    playerpos=[100,100]
    # Make an list for the accuracy
    acc=[0,0]
    # Make an list for where the arrows are
    arrows=[]
    # Set the timer for spawning badgers
    badtimer=100
    badtimer1=0
    # Make an list for where the badgers are
    badguys=[[800,100]]
    # Set your health value
    healthvalue=194
    # Set the wait times
    waitforexit=0
    waitforarrows=0
    waitforballoons=0
    waitforballoons2=2
    # Set displaying balloon on/off
    balloon1display = False
    balloon2display = False
    # Set start ticks
    startticks = pygame.time.get_ticks()
    # Set title
    pygame.display.set_caption("Bunny and Badgers")
    
    # Load images
    # Load the players image
    player = pygame.image.load("resources/images/dude.png").convert_alpha()
    # Load the background image
    grass = pygame.image.load("resources/images/grass.png").convert()
    # Load the image of the castles
    castle = pygame.image.load("resources/images/castle.png").convert_alpha()
    # Load the image for the arrows
    arrow = pygame.image.load("resources/images/bullet.png").convert_alpha()
    # Load the image for the badgers
    badguyimg1 = pygame.image.load("resources/images/badguy.png").convert_alpha()
    badguyimg2 = pygame.image.load("resources/images/badguy2.png").convert_alpha()
    badguyimg3 = pygame.image.load("resources/images/badguy3.png").convert_alpha()
    badguyimg4 = pygame.image.load("resources/images/badguy4.png").convert_alpha()
    badguyimg = badguyimg1
    # Load the overlays
    greenoverlay = pygame.image.load("resources/images/greenoverlay.png").convert_alpha()
    redoverlay = pygame.image.load("resources/images/redoverlay.png").convert_alpha()
    # Load the healthbar images
    healthbar = pygame.image.load("resources/images/healthbar.png").convert_alpha()
    health = pygame.image.load("resources/images/health.png").convert_alpha()
    # Load the text balloons
    balloon1 = pygame.image.load("resources/images/balloon1.png").convert_alpha()
    balloon2 = pygame.image.load("resources/images/balloon2.png").convert_alpha()
    
    # Set positions
    castle1 = (0,height/16)
    castle2 = (0,height/3.5)
    castle3 = (0,height/2)
    castle4 = (0,height/1.4)

    # Create a clock
    clock = pygame.time.Clock()
    
    # Keep looping through
    running = 1
    exitcode = 0
    while running:            
        badtimer-=1
        # Draw the background
        for x in range(width/grass.get_width()+1):
            for y in range(height/grass.get_height()+1):
                screen.blit(grass,(x*100,y*100))
        # Draw the castles
        screen.blit(castle, castle1)
        screen.blit(castle, castle2)
        screen.blit(castle, castle3)
        screen.blit(castle, castle4)
        # Set player position and rotation
        if True:
            position = pygame.mouse.get_pos()
            angle = math.atan2(position[1]-(playerpos[1]+32),position[0]-(playerpos[0]+26))
            playerrot = pygame.transform.rotate(player, 360-angle*57.29)
            playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
            screen.blit(playerrot, playerpos1)

        # Draw arrows
        for bullet in arrows:
            index=0
            velx=math.cos(bullet[0])*10
            vely=math.sin(bullet[0])*10
            bullet[1]+=velx
            bullet[2]+=vely
            if bullet[1]<-64 or bullet[1]>width or bullet[2]<-64 or bullet[2]>height:
                arrows.pop(index)
            index+=1
            for projectile in arrows:
                arrow1 = pygame.transform.rotate(arrow, 360-projectile[0]*57.29)
                screen.blit(arrow1, (projectile[1], projectile[2]))

        # Change the image of the badgers
        if badguyimg == badguyimg1:
            badguyimg = badguyimg2
        elif badguyimg == badguyimg2:
            badguyimg = badguyimg3
        elif badguyimg == badguyimg3:
            badguyimg = badguyimg4
        elif badguyimg == badguyimg4:
            badguyimg = badguyimg1

        # Draw badgers
        if badtimer==0:
            badheight1 = height/9.6
            badheight2 = height/1.1
            badheight = random.randint(int(badheight1), int(badheight2))
            badguys.append([width, badheight])
            badtimer=100-(badtimer1*2)
            if badtimer1>=35:
                badtimer1=35
            else:
                badtimer1+=5
        index=0
        for badguy in badguys:
            if badguy[0]<-64:
                badguys.pop(index)
            badguy[0]-=7
            # Attack castle
            badrect=pygame.Rect(badguyimg.get_rect())
            badrect.top=badguy[1]
            badrect.left=badguy[0]
            if badrect.left<64:
                healthvalue -= random.randint(5,20)
                badguys.pop(index)
            # Check for collisions
            index1=0
            for bullet in arrows:
                bullrect=pygame.Rect(arrow.get_rect())
                bullrect.left=bullet[1]
                bullrect.top=bullet[2]
                if badrect.colliderect(bullrect):
                    acc[0]+=1
                    badguys.pop(index)
                    arrows.pop(index1)
                index1+=1
            # Next bad guy
            index+=1
        # Draw badgers
        for badguy in badguys:
            screen.blit(badguyimg, badguy)
        # Draw clock
        font = pygame.font.Font("freesansbold.ttf", 24)
        survivedtext = font.render(str((90000-pygame.time.get_ticks()+startticks)/60000)+":"+str((90000-pygame.time.get_ticks()+startticks)/1000%60).zfill(2), True, (0,0,0))
        textRect = survivedtext.get_rect()
        textRect.topright=[width-5, 5]
        screen.blit(survivedtext, textRect)
        # Draw health bar
        screen.blit(healthbar, (5,5))
        for health1 in range(healthvalue):
            screen.blit(health, (health1+8,8))
        # Loop through the events
        for event in pygame.event.get():
            if event.type == pygame.KEYDOWN:
                # Move up
                if event.key in (K_w, K_UP):
                    keys[0]=True
                # Move left
                elif event.key in (K_a, K_LEFT):
                    keys[1]=True
                # Move down
                elif event.key in (K_s, K_DOWN):
                    keys[2]=True
                # Move right
                elif event.key in (K_d, K_RIGHT):
                    keys[3]=True
                # Quit by pressing back
                elif event.key==K_AC_BACK:
                    menu.launch()
            if event.type == pygame.KEYUP:
                # Move up
                if event.key in (K_w, K_UP):
                    keys[0]=False
                # Move left
                elif event.key in (K_a, K_LEFT):
                    keys[1]=False
                # Move down
                elif event.key in (K_s, K_DOWN):
                    keys[2]=False
                # Move right
                elif event.key in (K_d, K_RIGHT):
                    keys[3]=False
            # Check if you pressed a mouse button for shooting arrows
            if event.type==pygame.MOUSEBUTTONDOWN:
                if waitforarrows == 0:
                    position=pygame.mouse.get_pos()
                    acc[1]+=1
                    arrows.append([math.atan2(position[1]-(playerpos1[1]+32),position[0]-(playerpos1[0]+26)),playerpos1[0]+32,playerpos1[1]+32])
                    # Set wait time for arrows in frames
                    waitforarrows=15
                    if waitforballoons2:
                        waitforballoons2-=1
                    else:
                        # Choose balloon
                        balloonnr = random.randint(1, 2)
                        if balloonnr == 1:
                            balloon1display = True
                        elif balloonnr == 2:
                            balloon2display = True
                        waitforballoons2=2
        if waitforarrows:
            waitforarrows-=1
            waitforballoons = waitforarrows
        # Display balloon
        if waitforballoons:
            waitforballoons-=1
            if balloon1display:
                screen.blit(balloon1, (playerpos[0]+10, playerpos[1]-60))
            elif balloon2display:
                screen.blit(balloon2, (playerpos[0]+10, playerpos[1]-60))
        else:
            balloon1display = False
            balloon2display = False
    
        # Move player
        # Up
        if keys[0]:
            playerpos[1]-=5
        # Down
        elif keys[2]:
            playerpos[1]+=5
        # Left
        if keys[1]:
            playerpos[0]-=5
        # Right
        elif keys[3]:
            playerpos[0]+=5

        # Win/Lose check
        # Win
        if (pygame.time.get_ticks()-startticks)>=90000:
            running=0
            exitcode=1
        # Lose
        if healthvalue<=0:
            running=0
            exitcode=0
        if acc[1]!=0:
            accuracy=acc[0]*1.0/acc[1]*100
        else:
            accuracy=0

        # Flip the display
        pygame.display.flip()

        # Lock fps
        clock.tick(fps)

    # Win/lose display        
    # Lose
    if exitcode==0:
        # Initialize the font
        pygame.font.init()
        # Set font
        font = pygame.font.Font("freesansbold.ttf", 24)
        bigfont = pygame.font.Font("freesansbold.ttf", 48)
        # Render text
        gameover = bigfont.render("Game over!", True, (255,0,0))
        gameoverRect = gameover.get_rect()
        gameoverRect.centerx = screen.get_rect().centerx
        gameoverRect.centery = screen.get_rect().centery-24
        text = font.render("Accuracy: "+str(accuracy)+"%", True, (255,0,0))
        textRect = text.get_rect()
        textRect.centerx = screen.get_rect().centerx
        textRect.centery = screen.get_rect().centery+24
        # Draw red overlay
        for x in range(width/redoverlay.get_width()+1):
            for y in range(height/redoverlay.get_height()+1):
                screen.blit(redoverlay,(x*100,y*100))
        # Draw text
        screen.blit(gameover, gameoverRect)
        screen.blit(text, textRect)
    # Win
    else:
        # Initialize the font
        pygame.font.init()
        # Set font
        font = pygame.font.Font("freesansbold.ttf", 24)
        bigfont = pygame.font.Font("freesansbold.ttf", 48)
        # Render text
        youwin = bigfont.render("You win!", True, (0,255,0))
        youwinRect = youwin.get_rect()
        youwinRect.centerx = screen.get_rect().centerx
        youwinRect.centery = screen.get_rect().centery-24
        text = font.render("Accuracy: "+str(accuracy)+"%", True, (0,255,0))
        textRect = text.get_rect()
        textRect.centerx = screen.get_rect().centerx
        textRect.centery = screen.get_rect().centery+24
        # Draw green overlay
        for x in range(width/greenoverlay.get_width()+1):
            for y in range(height/greenoverlay.get_height()+1):
                screen.blit(greenoverlay,(x*100,y*100))
        # Draw text
        screen.blit(youwin, youwinRect)
        screen.blit(text, textRect)
    # Exit automatic when the game is stopped
    while 1:
        waitforexit+=1
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
        if waitforexit == 1000:
            menu.launch()
        # Update the screen
        pygame.display.flip()
Exemple #3
0
            self.age = 0

    def update(self, target_list, same_species_list):
        self.procreate(same_species_list)
        self.decide(target_list)
        Predator.update(self)
        self.image.fill((int(50 + 205*(1 - self.age / PREDATOR_LIFE_TIME)), 
                         0, 0))

# Initialize PyGame
pygame.init()
pygame.display.set_caption(GAME_TITLE)
screen = pygame.display.set_mode([SCREEN_WIDTH, SCREEN_HEIGHT])

# Launches an introductory menu 
menu.launch(screen)

fish_list = pygame.sprite.Group()
predator_list = pygame.sprite.Group()

for i in range(N_FISH_START):
    fish = Fish()
    fish_list.add(fish)

for i in range(N_PREDATOR_START):
    if np.random.uniform() > 0.5:
        predator = Dolphin()
    else:
        predator = Shark()
    predator_list.add(predator)
def play():

    detector = dlib.get_frontal_face_detector()

    # Set the width and height of the window
    width, height = int(pygame.display.Info().current_w), int(pygame.display.Info().current_h)

    # Create the window
    screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)

    # Initial camera
    cap = cv2.VideoCapture(0) # or 1
    imRawWidth = cap.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)
    imRawHeight = cap.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)
    imWidth = 1080 #640 #360
    imHeight = 960 #480 #240
    cap.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, imWidth)
    cap.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, imHeight)

    #imWidth = imRawWidth
    #imHeight = imRawHeight

    # Set playing time
    gaming_time = 90000

    # Set level state
    level = 0
    moving_speed = [5,7,9] # original: [3,5,7]
    score_factor = [1,2,3]
    candy_size_factor = [0.7,0.5,0.3]
    shit_size_factor = [0.2,0.3,0.4]  # [0.2,0.3,0.5]
    leveltxt = ['EASY','HARD','CRAZY!!!']
    # Make an list for the accuracy
    acc=[0,0,0]
    loss=[0,0,0]
    _color=(255,0,0)
    # Set your health value
    healthvalue=[194,194,194] # 194
    blood_loss=20 

    # Set pressed keys
    keys = [False, False, False, False]
    # Flag for change player skin
    playerbadflag = 0
    # Make an list for where the arrows are
    arrows=[]
    # Set the timer for spawning badgers
    badtimer=100
    badtimer1=0
    candytimer=100
    candytimer1=0
    # Make an list for where the badgers are
    badguys=[[800,100]]
    candies=[[800,100]]
    # Set the wait times
    waitforexit=0
    waitforarrows=3 # 0
    waitforballoons=0
    waitforballoons2=2
    # Set displaying balloon on/off
    balloon1display = False
    balloon2display = False

    # Initialize the mixer (for sound)
    pygame.mixer.init()
    # Set title
    pygame.display.set_caption("Candy Mountain")
   
    # Load images
    # Load the background image
    grass = pygame.image.load("resources/images/BckGnd.jpg") #grass.png") # add at front
    grass = pygame.transform.scale(grass, (width, height))
    # Load the image of the castles
    castle = pygame.image.load("resources/images/castle.png")
    # Load the image for the arrows
    arrow = pygame.image.load("resources/images/bullet.png")
    # Load the image for the badgers
    badguyimg = pygame.image.load("resources/images/poopoo.png") #badguy.png")
    # Load the image for the candies
    candyimg = pygame.image.load("resources/images/candy.png") #badguy.png")
    # Load the overlays
    greenoverlay = pygame.image.load("resources/images/Win.jpg") #greenoverlay.png")
    redoverlay = pygame.image.load("resources/images/GameOver.jpg") #redoverlay.png")
    greenoverlay = pygame.transform.scale(greenoverlay, (width, height))
    redoverlay = pygame.transform.scale(redoverlay, (width, height))
    # Load the healthbar images
    healthbar = pygame.image.load("resources/images/healthbar.png")
    health = pygame.image.load("resources/images/health.png")
    # Load the text balloons
    balloon1 = pygame.image.load("resources/images/balloon1.png")
    balloon2 = pygame.image.load("resources/images/balloon2.png")
    
    # Load audio
    hit = pygame.mixer.Sound("resources/audio/explode.wav")
    enemy = pygame.mixer.Sound("resources/audio/ohShit.wav") #enemy.wav")
    candySound = pygame.mixer.Sound("resources/audio/candy.wav")
    shoot = pygame.mixer.Sound("resources/audio/shoot.wav")
    takePicture = pygame.mixer.Sound("resources/audio/takePic.wav")
    loseGame = pygame.mixer.Sound("resources/audio/loseGame.wav")
    winGame = pygame.mixer.Sound("resources/audio/winGame.wav")
    # Set the audio volume
    hit.set_volume(0.40)
    enemy.set_volume(0.60)
    candySound.set_volume(0.40)
    shoot.set_volume(0.40)
    takePicture.set_volume(0.60)
    loseGame.set_volume(0.60)
    winGame.set_volume(0.60)
    # Set the background music
    pygame.mixer.music.load('resources/audio/mix90.mp3') #level_easy.mp3') #background.mp3')
    pygame.mixer.music.set_volume(0.50)

    
    # Set positions
    castle1 = (2*width/16, height-150)    #castle1 = (0,height/16)
    castle2 = (6*width/16, height-150)    #castle2 = (0,height/3.5)
    castle3 = (10*width/16, height-150)    #castle3 = (0,height/2)
    castle4 = (14*width/16, height-150)    #castle4 = (0,height/1.4)

    # Set display mode
    prevFS = settings.getFullscreen()
    if settings.getFullscreen() == True:
        screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN)
    elif settings.getFullscreen() == False:
        screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)

    # Capture frame-by-frame
    setting = 1
    roi = []
    _P,_Q,_R,_S = 0,0,0,0
    while(setting):
        ret, frame = cap.read()
        img = frame.copy()

        gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
        
        # face detection
        faces = detector(img)
        for d in faces:
            #print "left,top,right,bottom:", d.left(), d.top(), d.right(), d.bottom()
            _P,_Q,_R,_S = d.left(), d.top(), d.right()-d.left(), d.bottom()-d.top()
            cv2.rectangle(img,(_P,_Q),(_P+_R,_Q+_S),(255,0,0),2)

        # set up the ROI for tracking
        roi = img[_Q:_Q+_S, _P:_P+_R]

        # Draw the background
        screen.blit(grass,(0,0))
        ba = getFrame(True,cv2.cvtColor(img,cv2.COLOR_BGR2RGB))
        screen.blit(ba,(width/2-400,height/2-300))
        # Flip the display
        pygame.display.flip()
        # Loop through the events
        for event in pygame.event.get():
            # Check if the event is the X button 
            if event.type == pygame.KEYDOWN:
                # select
                if event.key==K_s:
                    takePicture.play()
                    print "Selecting"
                    setting = 0

    # Load the players image
    player = getFrame(True,roi.copy()) #frame.copy())
    playerBad = pygame.image.load("resources/images/shitFaceJustin.png")
    mainChar = player

    # Set player position
    playerpos = [width/2,height/2]
    faceCenter = playerpos

    # Keep looping through
    running = 1
    exitcode = 0
    # Set start ticks
    startticks = pygame.time.get_ticks()
    pygame.mixer.music.play(0, 0.0)
    while running:
        # Capture frame-by-frame
        ret, frame = cap.read()
        img = frame.copy()

        # Detect face
        faces = detector(img)
        for d in faces:
            #print "left,top,right,bottom:", d.left(), d.top(), d.right(), d.bottom()
            _P,_Q,_R,_S = d.left(), d.top(), d.right()-d.left(), d.bottom()-d.top()
        faceCenter=[(_P+_R/2), (_Q+_S/2)]
        #print faceCenter

        # Update player image
        if _P&_Q&_R&_S != 0:
            face = img[_Q:_Q+_S, _P:_P+_R, :]
            #print face.shape
            img2 = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
            if img2 != None:
                player = getFrame(color,img2)


        # Set display mode if changed
        if prevFS != settings.getFullscreen():
            if settings.getFullscreen() == True:
                screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN)
                prevFS = settings.getFullscreen()
            elif settings.getFullscreen() == False:
                screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)
                prevFS = settings.getFullscreen()

           
        badtimer-=2 #1
        candytimer-=1
        # Clear the screen before drawing it again
        screen.fill(0)
        # Draw the background
        screen.blit(grass,(0,0))

        # Draw the castles
        screen.blit(castle, castle1)
        screen.blit(castle, castle2)
        screen.blit(castle, castle3)
        screen.blit(castle, castle4)

        # Set player position and rotation
        position = pygame.mouse.get_pos()
        #angle = math.atan2(position[1]-(playerpos[1]+32),position[0]-(playerpos[0]+26))
        #playerrot = pygame.transform.rotate(player, 360-angle*57.29)
        #playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
        Wplayer = width - (float(faceCenter[0])/imWidth*width) #-playerpos[0])
        Hplayer = float(faceCenter[1])/imHeight*height #-playerpos[1]
        playerpos = [Wplayer, Hplayer]
        #screen.blit(playerrot, playerpos1)
        if playerbadflag == 0:
            mainChar = player
        else:
            mainChar = pygame.transform.scale(playerBad, (_R, _S))
        screen.blit(mainChar, playerpos)

        # Draw arrows
        for bullet in arrows:
            index=0
            velx=math.cos(bullet[0])*30 # *10
            vely=math.sin(bullet[0])*30
            bullet[1]+=velx
            bullet[2]+=vely
            if bullet[1]<-64 or bullet[1]>width or bullet[2]<-64 or bullet[2]>height:
                arrows.pop(index)
            index+=1
            for projectile in arrows:
                arrow1 = pygame.transform.rotate(arrow, 360-projectile[0]*57.29)
                screen.blit(arrow1, (projectile[1], projectile[2]))

        # Draw badgers
        badguyImg = pygame.transform.scale(badguyimg, (int(badguyimg.get_width()*shit_size_factor[level]), int(badguyimg.get_height()*shit_size_factor[level])))
        if badtimer==0:
            badwidth1 = width/5 #9.6
            badwidth2 = 4*width/5 #1.1
            badwidth = random.randint(int(badwidth1), int(badwidth2))
            badguys.append([badwidth, 0]) # ([badwidth, height])
            badtimer=100-(badtimer1*2)
            if badtimer1>=35:
                badtimer1=35
            else:
                badtimer1+=5 #random.randint(3,7) #5
        index=0
        for badguy in badguys:
            if badguy[1]<-64: # if badguy reached, pop out
                badguys.pop(index)
            badguy[1]+=moving_speed[level] # move badguy
            # Attack castle
            badrect=pygame.Rect(badguyImg.get_rect())
            badrect.top=badguy[1]
            badrect.left=badguy[0]
            if badrect.top>height-64: # top<64
                hit.play()
                badguys.pop(index)
            # Check for collisions
            index1=0
            # bullet collisions
            for bullet in arrows:
                bullrect=pygame.Rect(arrow.get_rect())
                bullrect.left=bullet[1]
                bullrect.top=bullet[2]
                if badrect.colliderect(bullrect):
                    hit.play() #enemy.play()
                    #acc[level]+=1
                    badguys.pop(index)
                    arrows.pop(index1)
                index1+=1
            # main char. collisions
            mainrect=pygame.Rect(mainChar.get_rect())
            mainrect.left=playerpos[0]
            mainrect.top=playerpos[1]
            if badrect.colliderect(mainrect):
                enemy.play()
                playerbadflag = 1
                #loss[level]+=1
                healthvalue[level] -= blood_loss #random.randint(5,20)
                badguys.pop(index)
            # Next bad guy
            index+=1

        # Draw badgers
        for badguy in badguys:
            screen.blit(badguyImg, badguy)


        # Draw candies
        candyImg = pygame.transform.scale(candyimg, (int(candyimg.get_width()*candy_size_factor[level]), int(candyimg.get_height()*candy_size_factor[level])))
        if candytimer==0:
            loss[level] += 1 
            candywidth1 = width/5#9.6
            candywidth2 = 4*width/5#1.1
            candywidth = random.randint(int(candywidth1), int(candywidth2))
            candies.append([candywidth, 0]) # ([candywidth, height])
            candytimer=100-(candytimer1*2)
            if candytimer1>=35:
                candytimer1=35
            else:
                candytimer1+= 5#random.randint(3,7) # 5
            #print str((gaming_time-pygame.time.get_ticks()+startticks)/1000%60)
            #print candytimer
        index=0
        for candy in candies:
            if candy[1]<-64: # if candy reached, pop out
                candies.pop(index)
            candy[1]+=moving_speed[level] # move candy
            # Attack castle
            candyrect=pygame.Rect(candyImg.get_rect())
            candyrect.top=candy[1]
            candyrect.left=candy[0]
            if candyrect.top>height+64: # top<64
                hit.play()
                healthvalue[level] -=  blood_loss  #random.randint(5,20)
                candies.pop(index)
            # Check for collisions
            index1=0
            # bullet collisions
            for bullet in arrows:
                bullrect=pygame.Rect(arrow.get_rect())
                bullrect.left=bullet[1]
                bullrect.top=bullet[2]
                if candyrect.colliderect(bullrect):
                    candySound.play()
                    healthvalue[level] -= blood_loss  #random.randint(5,20)
                    candies.pop(index)
                    arrows.pop(index1)
                index1+=1
            # main char. collisions
            mainrect=pygame.Rect(mainChar.get_rect())
            mainrect.left=playerpos[0]
            mainrect.top=playerpos[1]
            if candyrect.colliderect(mainrect):
                candySound.play()
                if loss[level] - 1 >= 0:
                    acc[level]+=1
                    loss[level]-=1
                playerbadflag = 0
                candies.pop(index)
            # Next bad guy
            index+=1

        # Draw badgers
        for candy in candies:
            screen.blit(candyImg, candy)

        # Draw clock, score and level
        font = pygame.font.Font("freesansbold.ttf", 48)
        font2 = pygame.font.Font("freesansbold.ttf", 56)
        survivedtext = font.render(str((gaming_time-pygame.time.get_ticks()+startticks)/60000)+":"+str((gaming_time-pygame.time.get_ticks()+startticks)/1000%60).zfill(2), True, (0,0,0))
        scoretext = font.render("Score: "+str(acc[level])+" x " + str(score_factor[level]) + " = " + str(acc[level]*score_factor[level]), True, (0,0,0))
        lvtext = font.render("Level: "+ leveltxt[level], True, (0,0,0))
        textRect = survivedtext.get_rect()
        textRect2 = scoretext.get_rect()
        textRect3 = lvtext.get_rect()
        textRect.topright=[width-120, 5] # width-5 ,5
        textRect2.topright=[width-120, 55] # width-5 ,5
        textRect3.topleft=[20, 55] # width-5 
        screen.blit(survivedtext, textRect)
        screen.blit(scoretext, textRect2)
        screen.blit(lvtext, textRect3)

        # Draw health bar
        screen.blit(healthbar, (5,5))
        for health1 in range(healthvalue[level]):
            screen.blit(health, (health1+8,8))

        # Loop through the events
        for event in pygame.event.get():
            # Check if the event is the X button 
            if event.type==pygame.QUIT:
                # If it is stop the music and go back to the main menu
                pygame.mixer.music.stop()
                cap.release()
                cv2.destroyAllWindows()
                menu.launch()
            if event.type == pygame.KEYDOWN:
                # Move up
                if event.key==K_w:
                    keys[0]=True
                elif event.key==K_UP:
                    keys[0]=True
                # Move left
                elif event.key==K_a:
                    keys[1]=True
                elif event.key==K_LEFT:
                    keys[1]=True
                # Move down
                elif event.key==K_s:
                    keys[2]=True
                elif event.key==K_DOWN:
                    keys[2]=True
                # Move right
                elif event.key==K_d:
                    keys[3]=True
                elif event.key==K_RIGHT:
                    keys[3]=True
                # Quit by pressing escape
                elif event.key==K_ESCAPE:
                    pygame.mixer.music.stop()
                    cap.release()
                    cv2.destroyAllWindows()
                    menu.launch()
                # Fullscreen by pressing F4
                elif event.key==K_F4:
                    settings.changeFullscreen()
            if event.type == pygame.KEYUP:
                # Move up
                if event.key==pygame.K_w:
                    keys[0]=False
                elif event.key==pygame.K_UP:
                    keys[0]=False
                # Move left
                elif event.key==pygame.K_a:
                    keys[1]=False
                elif event.key==pygame.K_LEFT:
                    keys[1]=False
                # Move down
                elif event.key==pygame.K_s:
                    keys[2]=False
                elif event.key==pygame.K_DOWN:
                    keys[2]=False
                # Move right
                elif event.key==pygame.K_d:
                    keys[3]=False
                elif event.key==pygame.K_RIGHT:
                    keys[3]=False

            # Check if you pressed a mouse button for shooting arrows
            if event.type==pygame.MOUSEBUTTONDOWN:
                if waitforarrows == 0:
                    shoot.play()
                    position=pygame.mouse.get_pos()
                    arrows.append([math.atan2(position[1]-(playerpos[1]+32),position[0]-(playerpos[0]+26)),playerpos[0]+32,playerpos[1]+32])
                    # Set wait time for arrows in frames
                    waitforarrows=15 # 15
                    if waitforballoons2:
                        waitforballoons2-=1
                    else:
                        # Choose balloon
                        balloonnr = random.randint(1, 2)
                        if balloonnr == 1:
                            balloon1display = True
                        elif balloonnr == 2:
                            balloon2display = True
                        waitforballoons2=2
        if waitforarrows:
            waitforarrows-=1
            waitforballoons = waitforarrows
        # Display balloon
        if waitforballoons:
            waitforballoons-=1
            if balloon1display:
                screen.blit(balloon1, (playerpos[0]+10, playerpos[1]-60))
            elif balloon2display:
                screen.blit(balloon2, (playerpos[0]+10, playerpos[1]-60))
        else:
            balloon1display = False
            balloon2display = False
    
   
        # Move player
        # Up
        if keys[0]:
            playerpos[1]-=10 # 5
        # Down
        elif keys[2]:
            playerpos[1]+=10
        # Left
        if keys[1]:
            playerpos[0]-=10
        # Right
        elif keys[3]:
            playerpos[0]+=10

    
        # Win/Lose check
        # Win
        past_time = (pygame.time.get_ticks()-startticks)
        if past_time>=gaming_time: # 90000
            running=0
            exitcode=1
        elif past_time>=gaming_time/3 and level == 0: # for simplicity, didn't add "and past_time<2*gaming_time/3"
            level = 1
            badtimer=1
            candytimer=1
            for candy in candies:
                candies.pop(0)
            for badguy in badguys:
                badguys.pop(0)
        elif past_time>=2*gaming_time/3 and level == 1:
            level = 2
            badtimer=1
            candytimer=1
            for candy in candies:
                candies.pop(0)
            for badguy in badguys:
                badguys.pop(0)

        # Lose
        if healthvalue[level]<=0:
            running=0
            exitcode=0

        # Final scores
        if running == 0:
            Score1 = "Easy: "+str(acc[0])+" x " + str(score_factor[0]) + " = " + str(acc[0]*score_factor[0])
            Score2 = "Hard: "+str(acc[1])+" x " + str(score_factor[1]) + " = " + str(acc[1]*score_factor[1])
            Score3 = "Crazy: "+str(acc[2])+" x " + str(score_factor[2]) + " = " + str(acc[2]*score_factor[2])

        #if acc[1]!=0:
        #    accuracy=acc[0]*1.0/acc[1]*100
        #else:
        #    accuracy=0

        # Flip the display
        pygame.display.flip()

    # Stop the music
    pygame.mixer.music.stop()

    # Win/lose display        
    # Lose
    if exitcode==0:
        # Change the text color
        _color = (255,255,255)
        # Draw red overlay
        screen.blit(redoverlay,(0, 0))
        loseGame.play()
    # Win
    else:
        _color = (255,0,0)
        # Draw green overlay
        screen.blit(greenoverlay,(0, 0))
        winGame.play()

    # Initialize the font
    pygame.font.init()
    # Set font
    font = pygame.font.Font("freesansbold.ttf", 48) # 24
    bigfont = pygame.font.Font("freesansbold.ttf", 56) # 48

    # Render text
    text1 = bigfont.render("Score:", True, _color)
    text2 = font.render(Score1, True, _color)
    text3 = font.render(Score2, True, _color)
    text4 = font.render(Score3, True, _color)

    textRect1 = text1.get_rect()
    textRect2 = text2.get_rect()
    textRect3 = text3.get_rect()
    textRect4 = text4.get_rect()

    textRect1.centerx = screen.get_rect().centerx-width/3
    textRect1.centery = screen.get_rect().centery+60
    textRect2.centerx = screen.get_rect().centerx-width/3
    textRect2.centery = screen.get_rect().centery+110
    textRect3.centerx = screen.get_rect().centerx-width/3
    textRect3.centery = screen.get_rect().centery+160
    textRect4.centerx = screen.get_rect().centerx-width/3
    textRect4.centery = screen.get_rect().centery+210

    # Draw text
    screen.blit(text1, textRect1)
    screen.blit(text2, textRect2)
    screen.blit(text3, textRect3)
    screen.blit(text4, textRect4)

    print "ACC: " + str(acc)
    print "LOSS: " + str(loss)

    # Exit automatic when the game is stopped
    while 1:
        waitforexit+=1
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                loseGame.stop()
                winGame.stop()
                cap.release()
                cv2.destroyAllWindows()
                pygame.quit()
                sys.exit()
        if waitforexit == 1500:
            loseGame.stop()
            winGame.stop()
            cap.release()
            cv2.destroyAllWindows()
            menu.launch()
        # Update the screen
        pygame.display.flip()
def play():

    detector = dlib.get_frontal_face_detector()

    # Set the width and height of the window
    width, height = int(pygame.display.Info().current_w), int(
        pygame.display.Info().current_h)

    # Create the window
    screen = pygame.display.set_mode((width, height),
                                     pygame.HWSURFACE | pygame.DOUBLEBUF)

    # Initial camera
    cap = cv2.VideoCapture(0)  # or 1
    imRawWidth = cap.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)
    imRawHeight = cap.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)
    imWidth = 1080  #640 #360
    imHeight = 960  #480 #240
    cap.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, imWidth)
    cap.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, imHeight)

    #imWidth = imRawWidth
    #imHeight = imRawHeight

    # Set playing time
    gaming_time = 90000

    # Set level state
    level = 0
    moving_speed = [5, 7, 9]  # original: [3,5,7]
    score_factor = [1, 2, 3]
    candy_size_factor = [0.7, 0.5, 0.3]
    shit_size_factor = [0.2, 0.3, 0.4]  # [0.2,0.3,0.5]
    leveltxt = ['EASY', 'HARD', 'CRAZY!!!']
    # Make an list for the accuracy
    acc = [0, 0, 0]
    loss = [0, 0, 0]
    _color = (255, 0, 0)
    # Set your health value
    healthvalue = [194, 194, 194]  # 194
    blood_loss = 20

    # Set pressed keys
    keys = [False, False, False, False]
    # Flag for change player skin
    playerbadflag = 0
    # Make an list for where the arrows are
    arrows = []
    # Set the timer for spawning badgers
    badtimer = 100
    badtimer1 = 0
    candytimer = 100
    candytimer1 = 0
    # Make an list for where the badgers are
    badguys = [[800, 100]]
    candies = [[800, 100]]
    # Set the wait times
    waitforexit = 0
    waitforarrows = 3  # 0
    waitforballoons = 0
    waitforballoons2 = 2
    # Set displaying balloon on/off
    balloon1display = False
    balloon2display = False

    # Initialize the mixer (for sound)
    pygame.mixer.init()
    # Set title
    pygame.display.set_caption("Candy Mountain")

    # Load images
    # Load the background image
    grass = pygame.image.load(
        "resources/images/BckGnd.jpg")  #grass.png") # add at front
    grass = pygame.transform.scale(grass, (width, height))
    # Load the image of the castles
    castle = pygame.image.load("resources/images/castle.png")
    # Load the image for the arrows
    arrow = pygame.image.load("resources/images/bullet.png")
    # Load the image for the badgers
    badguyimg = pygame.image.load("resources/images/poopoo.png")  #badguy.png")
    # Load the image for the candies
    candyimg = pygame.image.load("resources/images/candy.png")  #badguy.png")
    # Load the overlays
    greenoverlay = pygame.image.load(
        "resources/images/Win.jpg")  #greenoverlay.png")
    redoverlay = pygame.image.load(
        "resources/images/GameOver.jpg")  #redoverlay.png")
    greenoverlay = pygame.transform.scale(greenoverlay, (width, height))
    redoverlay = pygame.transform.scale(redoverlay, (width, height))
    # Load the healthbar images
    healthbar = pygame.image.load("resources/images/healthbar.png")
    health = pygame.image.load("resources/images/health.png")
    # Load the text balloons
    balloon1 = pygame.image.load("resources/images/balloon1.png")
    balloon2 = pygame.image.load("resources/images/balloon2.png")

    # Load audio
    hit = pygame.mixer.Sound("resources/audio/explode.wav")
    enemy = pygame.mixer.Sound("resources/audio/ohShit.wav")  #enemy.wav")
    candySound = pygame.mixer.Sound("resources/audio/candy.wav")
    shoot = pygame.mixer.Sound("resources/audio/shoot.wav")
    takePicture = pygame.mixer.Sound("resources/audio/takePic.wav")
    loseGame = pygame.mixer.Sound("resources/audio/loseGame.wav")
    winGame = pygame.mixer.Sound("resources/audio/winGame.wav")
    # Set the audio volume
    hit.set_volume(0.40)
    enemy.set_volume(0.60)
    candySound.set_volume(0.40)
    shoot.set_volume(0.40)
    takePicture.set_volume(0.60)
    loseGame.set_volume(0.60)
    winGame.set_volume(0.60)
    # Set the background music
    pygame.mixer.music.load(
        'resources/audio/mix90.mp3')  #level_easy.mp3') #background.mp3')
    pygame.mixer.music.set_volume(0.50)

    # Set positions
    castle1 = (2 * width / 16, height - 150)  #castle1 = (0,height/16)
    castle2 = (6 * width / 16, height - 150)  #castle2 = (0,height/3.5)
    castle3 = (10 * width / 16, height - 150)  #castle3 = (0,height/2)
    castle4 = (14 * width / 16, height - 150)  #castle4 = (0,height/1.4)

    # Set display mode
    prevFS = settings.getFullscreen()
    if settings.getFullscreen() == True:
        screen = pygame.display.set_mode(
            (width, height),
            pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN)
    elif settings.getFullscreen() == False:
        screen = pygame.display.set_mode((width, height),
                                         pygame.HWSURFACE | pygame.DOUBLEBUF)

    # Capture frame-by-frame
    setting = 1
    roi = []
    _P, _Q, _R, _S = 0, 0, 0, 0
    while (setting):
        ret, frame = cap.read()
        img = frame.copy()

        gray_img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

        # face detection
        faces = detector(img)
        for d in faces:
            #print "left,top,right,bottom:", d.left(), d.top(), d.right(), d.bottom()
            _P, _Q, _R, _S = d.left(), d.top(
            ), d.right() - d.left(), d.bottom() - d.top()
            cv2.rectangle(img, (_P, _Q), (_P + _R, _Q + _S), (255, 0, 0), 2)

        # set up the ROI for tracking
        roi = img[_Q:_Q + _S, _P:_P + _R]

        # Draw the background
        screen.blit(grass, (0, 0))
        ba = getFrame(True, cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
        screen.blit(ba, (width / 2 - 400, height / 2 - 300))
        # Flip the display
        pygame.display.flip()
        # Loop through the events
        for event in pygame.event.get():
            # Check if the event is the X button
            if event.type == pygame.KEYDOWN:
                # select
                if event.key == K_s:
                    takePicture.play()
                    print "Selecting"
                    setting = 0

    # Load the players image
    player = getFrame(True, roi.copy())  #frame.copy())
    playerBad = pygame.image.load("resources/images/shitFaceJustin.png")
    mainChar = player

    # Set player position
    playerpos = [width / 2, height / 2]
    faceCenter = playerpos

    # Keep looping through
    running = 1
    exitcode = 0
    # Set start ticks
    startticks = pygame.time.get_ticks()
    pygame.mixer.music.play(0, 0.0)
    while running:
        # Capture frame-by-frame
        ret, frame = cap.read()
        img = frame.copy()

        # Detect face
        faces = detector(img)
        for d in faces:
            #print "left,top,right,bottom:", d.left(), d.top(), d.right(), d.bottom()
            _P, _Q, _R, _S = d.left(), d.top(
            ), d.right() - d.left(), d.bottom() - d.top()
        faceCenter = [(_P + _R / 2), (_Q + _S / 2)]
        #print faceCenter

        # Update player image
        if _P & _Q & _R & _S != 0:
            face = img[_Q:_Q + _S, _P:_P + _R, :]
            #print face.shape
            img2 = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
            if img2 != None:
                player = getFrame(color, img2)

        # Set display mode if changed
        if prevFS != settings.getFullscreen():
            if settings.getFullscreen() == True:
                screen = pygame.display.set_mode(
                    (width, height),
                    pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN)
                prevFS = settings.getFullscreen()
            elif settings.getFullscreen() == False:
                screen = pygame.display.set_mode(
                    (width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)
                prevFS = settings.getFullscreen()

        badtimer -= 2  #1
        candytimer -= 1
        # Clear the screen before drawing it again
        screen.fill(0)
        # Draw the background
        screen.blit(grass, (0, 0))

        # Draw the castles
        screen.blit(castle, castle1)
        screen.blit(castle, castle2)
        screen.blit(castle, castle3)
        screen.blit(castle, castle4)

        # Set player position and rotation
        position = pygame.mouse.get_pos()
        #angle = math.atan2(position[1]-(playerpos[1]+32),position[0]-(playerpos[0]+26))
        #playerrot = pygame.transform.rotate(player, 360-angle*57.29)
        #playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
        Wplayer = width - (float(faceCenter[0]) / imWidth * width
                           )  #-playerpos[0])
        Hplayer = float(faceCenter[1]) / imHeight * height  #-playerpos[1]
        playerpos = [Wplayer, Hplayer]
        #screen.blit(playerrot, playerpos1)
        if playerbadflag == 0:
            mainChar = player
        else:
            mainChar = pygame.transform.scale(playerBad, (_R, _S))
        screen.blit(mainChar, playerpos)

        # Draw arrows
        for bullet in arrows:
            index = 0
            velx = math.cos(bullet[0]) * 30  # *10
            vely = math.sin(bullet[0]) * 30
            bullet[1] += velx
            bullet[2] += vely
            if bullet[1] < -64 or bullet[1] > width or bullet[
                    2] < -64 or bullet[2] > height:
                arrows.pop(index)
            index += 1
            for projectile in arrows:
                arrow1 = pygame.transform.rotate(arrow,
                                                 360 - projectile[0] * 57.29)
                screen.blit(arrow1, (projectile[1], projectile[2]))

        # Draw badgers
        badguyImg = pygame.transform.scale(
            badguyimg, (int(badguyimg.get_width() * shit_size_factor[level]),
                        int(badguyimg.get_height() * shit_size_factor[level])))
        if badtimer == 0:
            badwidth1 = width / 5  #9.6
            badwidth2 = 4 * width / 5  #1.1
            badwidth = random.randint(int(badwidth1), int(badwidth2))
            badguys.append([badwidth, 0])  # ([badwidth, height])
            badtimer = 100 - (badtimer1 * 2)
            if badtimer1 >= 35:
                badtimer1 = 35
            else:
                badtimer1 += 5  #random.randint(3,7) #5
        index = 0
        for badguy in badguys:
            if badguy[1] < -64:  # if badguy reached, pop out
                badguys.pop(index)
            badguy[1] += moving_speed[level]  # move badguy
            # Attack castle
            badrect = pygame.Rect(badguyImg.get_rect())
            badrect.top = badguy[1]
            badrect.left = badguy[0]
            if badrect.top > height - 64:  # top<64
                hit.play()
                badguys.pop(index)
            # Check for collisions
            index1 = 0
            # bullet collisions
            for bullet in arrows:
                bullrect = pygame.Rect(arrow.get_rect())
                bullrect.left = bullet[1]
                bullrect.top = bullet[2]
                if badrect.colliderect(bullrect):
                    hit.play()  #enemy.play()
                    #acc[level]+=1
                    badguys.pop(index)
                    arrows.pop(index1)
                index1 += 1
            # main char. collisions
            mainrect = pygame.Rect(mainChar.get_rect())
            mainrect.left = playerpos[0]
            mainrect.top = playerpos[1]
            if badrect.colliderect(mainrect):
                enemy.play()
                playerbadflag = 1
                #loss[level]+=1
                healthvalue[level] -= blood_loss  #random.randint(5,20)
                badguys.pop(index)
            # Next bad guy
            index += 1

        # Draw badgers
        for badguy in badguys:
            screen.blit(badguyImg, badguy)

        # Draw candies
        candyImg = pygame.transform.scale(
            candyimg, (int(candyimg.get_width() * candy_size_factor[level]),
                       int(candyimg.get_height() * candy_size_factor[level])))
        if candytimer == 0:
            loss[level] += 1
            candywidth1 = width / 5  #9.6
            candywidth2 = 4 * width / 5  #1.1
            candywidth = random.randint(int(candywidth1), int(candywidth2))
            candies.append([candywidth, 0])  # ([candywidth, height])
            candytimer = 100 - (candytimer1 * 2)
            if candytimer1 >= 35:
                candytimer1 = 35
            else:
                candytimer1 += 5  #random.randint(3,7) # 5
            #print str((gaming_time-pygame.time.get_ticks()+startticks)/1000%60)
            #print candytimer
        index = 0
        for candy in candies:
            if candy[1] < -64:  # if candy reached, pop out
                candies.pop(index)
            candy[1] += moving_speed[level]  # move candy
            # Attack castle
            candyrect = pygame.Rect(candyImg.get_rect())
            candyrect.top = candy[1]
            candyrect.left = candy[0]
            if candyrect.top > height + 64:  # top<64
                hit.play()
                healthvalue[level] -= blood_loss  #random.randint(5,20)
                candies.pop(index)
            # Check for collisions
            index1 = 0
            # bullet collisions
            for bullet in arrows:
                bullrect = pygame.Rect(arrow.get_rect())
                bullrect.left = bullet[1]
                bullrect.top = bullet[2]
                if candyrect.colliderect(bullrect):
                    candySound.play()
                    healthvalue[level] -= blood_loss  #random.randint(5,20)
                    candies.pop(index)
                    arrows.pop(index1)
                index1 += 1
            # main char. collisions
            mainrect = pygame.Rect(mainChar.get_rect())
            mainrect.left = playerpos[0]
            mainrect.top = playerpos[1]
            if candyrect.colliderect(mainrect):
                candySound.play()
                if loss[level] - 1 >= 0:
                    acc[level] += 1
                    loss[level] -= 1
                playerbadflag = 0
                candies.pop(index)
            # Next bad guy
            index += 1

        # Draw badgers
        for candy in candies:
            screen.blit(candyImg, candy)

        # Draw clock, score and level
        font = pygame.font.Font("freesansbold.ttf", 48)
        font2 = pygame.font.Font("freesansbold.ttf", 56)
        survivedtext = font.render(
            str((gaming_time - pygame.time.get_ticks() + startticks) / 60000) +
            ":" + str((gaming_time - pygame.time.get_ticks() + startticks) /
                      1000 % 60).zfill(2), True, (0, 0, 0))
        scoretext = font.render(
            "Score: " + str(acc[level]) + " x " + str(score_factor[level]) +
            " = " + str(acc[level] * score_factor[level]), True, (0, 0, 0))
        lvtext = font.render("Level: " + leveltxt[level], True, (0, 0, 0))
        textRect = survivedtext.get_rect()
        textRect2 = scoretext.get_rect()
        textRect3 = lvtext.get_rect()
        textRect.topright = [width - 120, 5]  # width-5 ,5
        textRect2.topright = [width - 120, 55]  # width-5 ,5
        textRect3.topleft = [20, 55]  # width-5
        screen.blit(survivedtext, textRect)
        screen.blit(scoretext, textRect2)
        screen.blit(lvtext, textRect3)

        # Draw health bar
        screen.blit(healthbar, (5, 5))
        for health1 in range(healthvalue[level]):
            screen.blit(health, (health1 + 8, 8))

        # Loop through the events
        for event in pygame.event.get():
            # Check if the event is the X button
            if event.type == pygame.QUIT:
                # If it is stop the music and go back to the main menu
                pygame.mixer.music.stop()
                cap.release()
                cv2.destroyAllWindows()
                menu.launch()
            if event.type == pygame.KEYDOWN:
                # Move up
                if event.key == K_w:
                    keys[0] = True
                elif event.key == K_UP:
                    keys[0] = True
                # Move left
                elif event.key == K_a:
                    keys[1] = True
                elif event.key == K_LEFT:
                    keys[1] = True
                # Move down
                elif event.key == K_s:
                    keys[2] = True
                elif event.key == K_DOWN:
                    keys[2] = True
                # Move right
                elif event.key == K_d:
                    keys[3] = True
                elif event.key == K_RIGHT:
                    keys[3] = True
                # Quit by pressing escape
                elif event.key == K_ESCAPE:
                    pygame.mixer.music.stop()
                    cap.release()
                    cv2.destroyAllWindows()
                    menu.launch()
                # Fullscreen by pressing F4
                elif event.key == K_F4:
                    settings.changeFullscreen()
            if event.type == pygame.KEYUP:
                # Move up
                if event.key == pygame.K_w:
                    keys[0] = False
                elif event.key == pygame.K_UP:
                    keys[0] = False
                # Move left
                elif event.key == pygame.K_a:
                    keys[1] = False
                elif event.key == pygame.K_LEFT:
                    keys[1] = False
                # Move down
                elif event.key == pygame.K_s:
                    keys[2] = False
                elif event.key == pygame.K_DOWN:
                    keys[2] = False
                # Move right
                elif event.key == pygame.K_d:
                    keys[3] = False
                elif event.key == pygame.K_RIGHT:
                    keys[3] = False

            # Check if you pressed a mouse button for shooting arrows
            if event.type == pygame.MOUSEBUTTONDOWN:
                if waitforarrows == 0:
                    shoot.play()
                    position = pygame.mouse.get_pos()
                    arrows.append([
                        math.atan2(position[1] - (playerpos[1] + 32),
                                   position[0] - (playerpos[0] + 26)),
                        playerpos[0] + 32, playerpos[1] + 32
                    ])
                    # Set wait time for arrows in frames
                    waitforarrows = 15  # 15
                    if waitforballoons2:
                        waitforballoons2 -= 1
                    else:
                        # Choose balloon
                        balloonnr = random.randint(1, 2)
                        if balloonnr == 1:
                            balloon1display = True
                        elif balloonnr == 2:
                            balloon2display = True
                        waitforballoons2 = 2
        if waitforarrows:
            waitforarrows -= 1
            waitforballoons = waitforarrows
        # Display balloon
        if waitforballoons:
            waitforballoons -= 1
            if balloon1display:
                screen.blit(balloon1, (playerpos[0] + 10, playerpos[1] - 60))
            elif balloon2display:
                screen.blit(balloon2, (playerpos[0] + 10, playerpos[1] - 60))
        else:
            balloon1display = False
            balloon2display = False

        # Move player
        # Up
        if keys[0]:
            playerpos[1] -= 10  # 5
        # Down
        elif keys[2]:
            playerpos[1] += 10
        # Left
        if keys[1]:
            playerpos[0] -= 10
        # Right
        elif keys[3]:
            playerpos[0] += 10

        # Win/Lose check
        # Win
        past_time = (pygame.time.get_ticks() - startticks)
        if past_time >= gaming_time:  # 90000
            running = 0
            exitcode = 1
        elif past_time >= gaming_time / 3 and level == 0:  # for simplicity, didn't add "and past_time<2*gaming_time/3"
            level = 1
            badtimer = 1
            candytimer = 1
            for candy in candies:
                candies.pop(0)
            for badguy in badguys:
                badguys.pop(0)
        elif past_time >= 2 * gaming_time / 3 and level == 1:
            level = 2
            badtimer = 1
            candytimer = 1
            for candy in candies:
                candies.pop(0)
            for badguy in badguys:
                badguys.pop(0)

        # Lose
        if healthvalue[level] <= 0:
            running = 0
            exitcode = 0

        # Final scores
        if running == 0:
            Score1 = "Easy: " + str(acc[0]) + " x " + str(
                score_factor[0]) + " = " + str(acc[0] * score_factor[0])
            Score2 = "Hard: " + str(acc[1]) + " x " + str(
                score_factor[1]) + " = " + str(acc[1] * score_factor[1])
            Score3 = "Crazy: " + str(acc[2]) + " x " + str(
                score_factor[2]) + " = " + str(acc[2] * score_factor[2])

        #if acc[1]!=0:
        #    accuracy=acc[0]*1.0/acc[1]*100
        #else:
        #    accuracy=0

        # Flip the display
        pygame.display.flip()

    # Stop the music
    pygame.mixer.music.stop()

    # Win/lose display
    # Lose
    if exitcode == 0:
        # Change the text color
        _color = (255, 255, 255)
        # Draw red overlay
        screen.blit(redoverlay, (0, 0))
        loseGame.play()
    # Win
    else:
        _color = (255, 0, 0)
        # Draw green overlay
        screen.blit(greenoverlay, (0, 0))
        winGame.play()

    # Initialize the font
    pygame.font.init()
    # Set font
    font = pygame.font.Font("freesansbold.ttf", 48)  # 24
    bigfont = pygame.font.Font("freesansbold.ttf", 56)  # 48

    # Render text
    text1 = bigfont.render("Score:", True, _color)
    text2 = font.render(Score1, True, _color)
    text3 = font.render(Score2, True, _color)
    text4 = font.render(Score3, True, _color)

    textRect1 = text1.get_rect()
    textRect2 = text2.get_rect()
    textRect3 = text3.get_rect()
    textRect4 = text4.get_rect()

    textRect1.centerx = screen.get_rect().centerx - width / 3
    textRect1.centery = screen.get_rect().centery + 60
    textRect2.centerx = screen.get_rect().centerx - width / 3
    textRect2.centery = screen.get_rect().centery + 110
    textRect3.centerx = screen.get_rect().centerx - width / 3
    textRect3.centery = screen.get_rect().centery + 160
    textRect4.centerx = screen.get_rect().centerx - width / 3
    textRect4.centery = screen.get_rect().centery + 210

    # Draw text
    screen.blit(text1, textRect1)
    screen.blit(text2, textRect2)
    screen.blit(text3, textRect3)
    screen.blit(text4, textRect4)

    print "ACC: " + str(acc)
    print "LOSS: " + str(loss)

    # Exit automatic when the game is stopped
    while 1:
        waitforexit += 1
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                loseGame.stop()
                winGame.stop()
                cap.release()
                cv2.destroyAllWindows()
                pygame.quit()
                sys.exit()
        if waitforexit == 1500:
            loseGame.stop()
            winGame.stop()
            cap.release()
            cv2.destroyAllWindows()
            menu.launch()
        # Update the screen
        pygame.display.flip()
Exemple #6
0
def play():
    cnt = 0
    dec = False
    eclipse = 0
    dececc = False
    # Define varibale for Level
    isLevelOne = True
    # Define variables for freeze power
    timeForFreezePower = False
    freezePowerSent = False
    freezepowercord = []
    freezePower = False
    freezeTimer = 10
    # Define variables for bullet power
    timeForBulletPower = False
    bulletPowerSent = False
    bulletpowercord = []
    bulletPower = False
    bulletTimer = 10
    # Define variables for danger power
    timeForDangerPower = False
    dangerPowerSent = False
    dangerpowercord = []
    dangerPower = False
    dangerTimer = 10
    # Set the width and height of the window
    width, height = int(pygame.display.Info().current_w), int(pygame.display.Info().current_h)
    # Create the window
    screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)
    # Initialize the joystick module
    pygame.joystick.init()
    # Check if there are any joysticks
    joystick_count = pygame.joystick.get_count()
    # If there are any joysticks, initialize the first one, else quit the joystick module
    if joystick_count:
        joystick = pygame.joystick.Joystick(0)
        joystick.init()
        JS = True
        # Set joystick position
        if JS:
            stick0 = "right"
    else:
        pygame.joystick.quit()
        JS = False
    # Set pressed keys
    keys = [False, False, False, False]
    JSkeys = [False, False, False, False]
    # Set player position
    playerpos=[100,100]
    # Make an list for the accuracy
    acc=[0,0]
    # Make an list for where the arrows are
    arrows=[]
    # Set the timer for spawning badgers
    badtimer=100
    badtimer1=0
    # Make an list for where the badgers are
    badguys=[[800,100]]
    # Set your health value
    healthvalue=194
    # Set the wait times
    waitforexit=0
    waitforarrows=0
    waitforballoons=0
    waitforballoons2=2
    # Set displaying balloon on/off
    balloon1display = False
    balloon2display = False
    # Set start ticks
    startticks = pygame.time.get_ticks()
    # Initialize the mixer (for sound)
    pygame.mixer.init()
    # Set title
    pygame.display.set_caption("Galaxy Wars")
    
    # Load images
    # Load the players image
    player = pygame.image.load("resources/images/dude.png")
    # Load the power  freeze image
    power_freeze = pygame.image.load("resources/images/power_freeze.png")
    # Load thunder image
    thunder = pygame.image.load("resources/images/thunder.png")
    # Load backgrounds
    bgmorning = pygame.image.load("resources/images/bgmorning.jpg")
    # Load the power bullet image
    power_bullet = pygame.image.load("resources/images/power_bullet.png")
    # Load the power danger image
    power_danger = pygame.image.load("resources/images/power_danger.png")
    # Green Bullet
    bullet_green = pygame.image.load("resources/images/bullet_green.png")
    # Load the background image
    bgmain = pygame.image.load("resources/images/starfield.png")
    # Red Sun level 1
    sunred = pygame.image.load("resources/images/SunRed.png")
    # Blue Sun Danger
    sunblue = pygame.image.load("resources/images/SunBlue.png")
    # Load the image of the castles
    castle = pygame.image.load("resources/images/castle.png")
    # Load the image for the arrows
    arrow = pygame.image.load("resources/images/bullet.png")
    # Load the image for the badgers
    badguyimg1 = pygame.image.load("resources/images/badguy.png")
    badguyimg = badguyimg1
    # Load the overlays
    greenoverlay = pygame.image.load("resources/images/greenoverlay.png")
    redoverlay = pygame.image.load("resources/images/redoverlay.png")
    # Load the healthbar images
    healthbar = pygame.image.load("resources/images/healthbar.png")
    health = pygame.image.load("resources/images/health.png")
    # Load the text balloons
    balloon1 = pygame.image.load("resources/images/balloon1.png")
    balloon2 = pygame.image.load("resources/images/balloon2.png")
    
    # Load audio
    hit = pygame.mixer.Sound("resources/audio/explode.wav")
    enemy = pygame.mixer.Sound("resources/audio/enemy.wav")
    shoot = pygame.mixer.Sound("resources/audio/shoot.wav")
    # Set the audio volume
    hit.set_volume(0.15)
    enemy.set_volume(0.15)
    shoot.set_volume(0.15)
    # Set the background music
    pygame.mixer.music.load('resources/audio/background.mp3')
    pygame.mixer.music.play(-1, 0.0)
    pygame.mixer.music.set_volume(0.30)
    
    # Set positions
    castle1 = (0,height/16)
    castle2 = (0,height/3.5)
    castle3 = (0,height/2)
    castle4 = (0,height/1.4)

    # Set display mode
    prevFS = settings.getFullscreen()
    if settings.getFullscreen() == True:
        screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN)
    elif settings.getFullscreen() == False:
        screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)
    
    # Keep looping through
    running = 1
    exitcode = 0
    while running:
        # Set display mode if changed
        if prevFS != settings.getFullscreen():
            if settings.getFullscreen() == True:
                screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN)
                prevFS = settings.getFullscreen()
            elif settings.getFullscreen() == False:
                screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)
                prevFS = settings.getFullscreen()

        # Set joystick buttons, if there are any
        if JS:
            buttonUP = joystick.get_button(4)
            buttonRIGHT = joystick.get_button(5)
            buttonDOWN = joystick.get_button(6)
            buttonLEFT = joystick.get_button(7)
            buttonX = joystick.get_button(14)
            stick0a = joystick.get_axis(0)
            stick0b = joystick.get_axis(1)
            
        # Check for stick0's position
        if JS:
            if stick0a <= -0.5 and stick0b <= -0.5:
                stick0 = "leftup"
            elif stick0a <= -0.5 and stick0b >= 0.5:
                stick0 = "leftdown"
            elif stick0a >= 0.5 and stick0b <= -0.5:
                stick0 = "rightup"
            elif stick0a >= 0.5 and stick0b >= 0.5:
                stick0 = "rightdown"
            elif stick0a <= -0.5:
                stick0 = "left"
            elif stick0a >= 0.5:
                stick0 = "right"
            elif stick0b <= -0.5:
                stick0 = "up"
            elif stick0b >= 0.5:
                stick0 = "down"
            
        badtimer-=1
        # Clear the screen before drawing it again
        screen.fill(0)
        # Draw the background
        if isLevelOne:
            screen.blit(bgmorning, (0, 0))
        else:
            screen.blit(bgmain, (0,0))
        if acc[0] > 25:
            isLevelOne = False
        if dangerPower and isLevelOne == False:
            eclipse += 10
            if eclipse > 100:
                screen.blit(sunblue, (width // 2, 0))
            else:
                screen.blit(sunred, (width // 2, 0))
            if eclipse % 20 == 0:
                screen.blit(thunder, (width // 2, 0))
            if eclipse > 200:
                eclipse = 0
        else:
            screen.blit(sunred, (width // 2, 0))

        # Draw the castles
        screen.blit(castle, castle1)
        screen.blit(castle, castle2)
        screen.blit(castle, castle3)
        screen.blit(castle, castle4)
        # Set player position and rotation

        if JS == False:
            position = pygame.mouse.get_pos()
            angle = math.atan2(position[1]-(playerpos[1]+32),position[0]-(playerpos[0]+26))
            playerrot = pygame.transform.rotate(player, 360-angle*57.29)
            playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
            screen.blit(playerrot, playerpos1)
        elif JS == True:
            if stick0 == "left":
                playerrot = pygame.transform.rotate(player, 180)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "right":
                playerrot = pygame.transform.rotate(player, 0)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "up":
                playerrot = pygame.transform.rotate(player, 90)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "down":
                playerrot = pygame.transform.rotate(player, 270)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "leftup":
                playerrot = pygame.transform.rotate(player, 135)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "leftdown":
                playerrot = pygame.transform.rotate(player, 225)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "rightup":
                playerrot = pygame.transform.rotate(player, 45)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "rightdown":
                playerrot = pygame.transform.rotate(player, 315)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)

        
        # Draw arrows
        for bullet in arrows:
            index=0
            velx = 0
            vely = 0
            if bulletPower and dangerPower is False:
                velx=math.cos(bullet[0])*30
                vely=math.sin(bullet[0])*30
            elif dangerPower is False:
                velx=math.cos(bullet[0])*20
                vely=math.sin(bullet[0])*20
            elif dangerPower:
                velx=math.cos(bullet[0])*10
                vely=math.sin(bullet[0])*10
            bullet[1]+=velx
            bullet[2]+=vely
            if bullet[1]<-64 or bullet[1]>width or bullet[2]<-64 or bullet[2]>height:
                arrows.pop(index)
            index+=1
            for projectile in arrows:
                arrow1 = pygame.transform.rotate(arrow, 360-projectile[0]*57.29)
                bullet_green1 = pygame.transform.rotate(bullet_green, 360-projectile[0]*57.29)
                if bulletPower:
                    screen.blit(bullet_green1, (projectile[1], projectile[2]))
                else:
                    screen.blit(arrow1, (projectile[1], projectile[2]))
        # Draw badguys
        if badtimer==0:
            badheight1 = height/9.6
            badheight2 = height/1.1
            badheight = random.randint(int(badheight1), int(badheight2))
            badguys.append([width, badheight])
            badtimer=100-(badtimer1*2)
            if badtimer1>=35:
                badtimer1=35
            else:
                badtimer1+=5
        index=0
        for badguy in badguys:
            if badguy[0]<-64:
                badguys.pop(index)
            if freezePower is False and dangerPower is False:
                badguy[0]-=7
                if cnt < 30 and dec is False:
                    badguy[1] += 7
                    cnt += 1
                else:
                    dec = True
                    cnt -= 1
                    badguy[1] -= 7
                    if cnt is 0:
                        dec = False
            elif dangerPower:
                badguy[0] -= 20
                xx = random.randint(0, 1)
                if cnt < 30 and dec is False:
                    if xx == 1:
                        badguy[1] += 7
                    cnt += 1
                else:
                    dec = True
                    cnt -= 1
                    if xx == 1:
                        badguy[1] -= 7
                    if cnt is 0:
                        dec = False
            # Attack castle
            badrect=pygame.Rect(badguyimg.get_rect())
            badrect.top=badguy[1]
            badrect.left=badguy[0]
            if badrect.left<64:
                hit.play()
                healthvalue -= random.randint(5,20)
                badguys.pop(index)
            # Check for collisions
            index1=0
            for bullet in arrows:
                bullrect=pygame.Rect(arrow.get_rect())
                bullrect.left=bullet[1]
                bullrect.top=bullet[2]
                if badrect.colliderect(bullrect):
                    enemy.play()
                    acc[0]+=1
                    if acc[0] % 3 == 0 and isLevelOne == False:
                        timeForDangerPower = True
                    else:
                        timeForDangerPower = False
                    if acc[0] % 5 == 0:
                        timeForFreezePower = True
                    else:
                        timeForFreezePower = False
                    if acc[0] % 7 == 0:
                        timeForBulletPower = True
                    else:
                        timeForBulletPower = False
                    badguys.pop(index)
                    if bulletPower == False:
                        arrows.pop(index1)
                index1+=1
            # Next bad guy
            index+=1
        # Draw badgers
        for badguy in badguys:
            screen.blit(badguyimg, badguy)

        # Draw power if power sent is true
        if dangerPowerSent:
            dangerpowercord[0] -= 7
            screen.blit(power_danger, dangerpowercord)
            if dangerpowercord[0] < 0:
                dangerPowerSent = False

        if bulletPowerSent:
            bulletpowercord[0] -= 7
            screen.blit(power_bullet, bulletpowercord)
            if bulletpowercord[0] < 0:
                bulletPowerSent = False

        if freezePowerSent:
            freezepowercord[0] -= 7
            screen.blit(power_freeze, freezepowercord)
            if freezepowercord[0] < 0:
                freezePowerSent = False

        if timeForDangerPower and dangerPowerSent == False:
            powerheight1 = height/9.6
            powerheight2 = height/1.1
            powerheight = random.randint(int(powerheight1), int(powerheight2))
            dangerpowercord = [width, playerpos[1]]
            print "dangerPowerSent"
            dangerPowerSent = True
            timeForDangerPower = False
            screen.blit(power_danger, dangerpowercord)

        if timeForBulletPower and bulletPowerSent == False:
            powerheight1 = height/9.6
            powerheight2 = height/1.1
            powerheight = random.randint(int(powerheight1), int(powerheight2))
            bulletpowercord = [width, powerheight]
            print "bulletPowerSent"
            bulletPowerSent = True
            timeForBulletPower = False
            screen.blit(power_bullet, bulletpowercord)


        if timeForFreezePower and freezePowerSent == False:
            powerheight1 = height/9.6
            powerheight2 = height/1.1
            powerheight = random.randint(int(powerheight1), int(powerheight2))
            freezepowercord = [width, powerheight]
            print "freezePowerSent"
            freezePowerSent = True
            timeForFreezePower = False
            screen.blit(power_freeze, freezepowercord)

        if dangerPower:
            dangerTimer += 10
            if dangerTimer > 2000:
                dangerPower = False
                dangerTimer = 0

        if bulletPower:
            bulletTimer += 10
            if bulletTimer > 2000:
                bulletPower = False
                bulletTimer = 0

        if freezePower:
            freezeTimer += 10
            if freezeTimer > 1000:
                freezePower = False
                freezeTimer = 0

        # Check if power is Taken
        if dangerPowerSent:
            dangerpowerRect = pygame.Rect(power_danger.get_rect())
            playerRect = pygame.Rect(player.get_rect())
            dangerpowerRect.top = dangerpowercord[1]
            dangerpowerRect.left = dangerpowercord[0]
            playerRect.top = playerpos[1]
            playerRect.left = playerpos[0]
            if dangerpowerRect.colliderect(playerRect):
                dangerPower = True
                dangerPowerSent = False

        if bulletPowerSent:
            bullpowerRect = pygame.Rect(power_bullet.get_rect())
            playerRect = pygame.Rect(player.get_rect())
            bullpowerRect.top = bulletpowercord[1]
            bullpowerRect.left = bulletpowercord[0]
            playerRect.top = playerpos[1]
            playerRect.left = playerpos[0]
            if bullpowerRect.colliderect(playerRect):
                bulletPower = True
                bulletPowerSent = False


        if freezePowerSent:
            powerRect = pygame.Rect(power_freeze.get_rect())
            playerRect = pygame.Rect(player.get_rect())
            powerRect.top = freezepowercord[1]
            powerRect.left = freezepowercord[0]
            playerRect.top = playerpos[1]
            playerRect.left = playerpos[0]
            if powerRect.colliderect(playerRect):
                freezePower = True
                print "Collision Detected"
                freezePowerSent = False

        # Draw clock
        font = pygame.font.Font("freesansbold.ttf", 24)
        survivedtext = font.render(str("Score: " + str(acc[0])) , True, (255,0,0))
        leveltext = ""
        if isLevelOne:
            leveltext= font.render(str("Level: 1") , True, (0,0,255))
        else:
            leveltext= font.render(str("Level: 2") , True, (0,0,255))
        levelrect = leveltext.get_rect()
        levelrect.topleft = [250, 5]
        screen.blit(leveltext, levelrect)
        textRect = survivedtext.get_rect()
        textRect.topright=[width-5, 5]
        screen.blit(survivedtext, textRect)
        # Draw health bar
        screen.blit(healthbar, (5,5))
        for health1 in range(healthvalue):
            screen.blit(health, (health1+8,8))
        # Loop through the events
        for event in pygame.event.get():
            # Check if the event is the X button 
            if event.type==pygame.QUIT:
                # If it is stop the music and go back to the main menu
                pygame.mixer.music.stop()
                menu.launch()
            if event.type == pygame.KEYDOWN:
                # Move up
                if event.key==K_w:
                    keys[0]=True
                elif event.key==K_UP:
                    keys[0]=True
                # Move left
                elif event.key==K_a:
                    keys[1]=True
                elif event.key==K_LEFT:
                    keys[1]=True
                # Move down
                elif event.key==K_s:
                    keys[2]=True
                elif event.key==K_DOWN:
                    keys[2]=True
                # Move right
                elif event.key==K_d:
                    keys[3]=True
                elif event.key==K_RIGHT:
                    keys[3]=True
                # Quit by pressing escape
                elif event.key==K_ESCAPE:
                    pygame.mixer.music.stop()
                    menu.launch()
                # Fullscreen by pressing F4
                elif event.key==K_F4:
                    settings.changeFullscreen()
                elif event.key==pygame.K_SPACE:
                    if waitforarrows == 0:
                        shoot.play()
                        position=pygame.mouse.get_pos()
                        acc[1]+=1
                        arrows.append([math.atan2(position[1]-(playerpos1[1]+32),position[0]-(playerpos1[0]+26)),playerpos1[0]+32,playerpos1[1]+32])
                        # Set wait time for arrows in frames
                        waitforarrows=15
                        if waitforballoons2:
                            waitforballoons2-=1
                        else:
                            # Choose balloon
                            balloonnr = random.randint(1, 2)
                            if balloonnr == 1:
                                balloon1display = True
                            elif balloonnr == 2:
                                balloon2display = True
                            waitforballoons2=2
            if event.type == pygame.KEYUP:
                # Move up
                if event.key==pygame.K_w:
                    keys[0]=False
                elif event.key==pygame.K_UP:
                    keys[0]=False
                # Move left
                elif event.key==pygame.K_a:
                    keys[1]=False
                elif event.key==pygame.K_LEFT:
                    keys[1]=False
                # Move down
                elif event.key==pygame.K_s:
                    keys[2]=False
                elif event.key==pygame.K_DOWN:
                    keys[2]=False
                # Move right
                elif event.key==pygame.K_d:
                    keys[3]=False
                elif event.key==pygame.K_RIGHT:
                    keys[3]=False
        if waitforarrows:
            waitforarrows-=1
            waitforballoons = waitforarrows
        # Display balloon
        if waitforballoons:
            waitforballoons-=1
            if balloon1display:
                screen.blit(balloon1, (playerpos[0]+10, playerpos[1]-60))
            elif balloon2display:
                screen.blit(balloon2, (playerpos[0]+10, playerpos[1]-60))
        else:
            balloon1display = False
            balloon2display = False
    
        # Check if there are any joysticks
        if JS:
            # Check if UP is pressed
            if buttonUP:
                JSkeys[0]=True
            # Check if RIGHT is pressed
            elif buttonRIGHT:
                JSkeys[3]=True
            # Check if DOWN is pressed
            elif buttonDOWN:
                JSkeys[2]=True
            # Check if LEFT is pressed
            elif buttonLEFT:
                JSkeys[1]=True
            else:
                JSkeys[0]=False
                JSkeys[1]=False
                JSkeys[2]=False
                JSkeys[3]=False
            # Check of X is pressed
            if buttonX:
                if waitforarrows == 0:
                    shoot.play()
                    acc[1]+=1
                    if stick0 == "left":
                        arrows.append([3,playerpos1[0]+32,playerpos1[1]+32])
                    elif stick0 == "right":
                        arrows.append([0,playerpos1[0]+32,playerpos1[1]+32])
                    elif stick0 == "up":
                        arrows.append([-1.5,playerpos1[0]+32,playerpos1[1]+32])
                    elif stick0 == "down":
                        arrows.append([1.5,playerpos1[0]+32,playerpos1[1]+32])
                    elif stick0 == "leftup":
                        arrows.append([-2.25,playerpos1[0]+32,playerpos1[1]+32])
                    elif stick0 == "leftdown":
                        arrows.append([2.25,playerpos1[0]+32,playerpos1[1]+32])
                    elif stick0 == "rightup":
                        arrows.append([-0.75,playerpos1[0]+32,playerpos1[1]+32])
                    elif stick0 == "rightdown":
                        arrows.append([0.75,playerpos1[0]+32,playerpos1[1]+32])
                    # Set wait time for arrows in frames
                    waitforarrows=15
                    if waitforballoons2:
                        waitforballoons2-=1
                    else:
                        # Choose balloon
                        balloonnr = random.randint(1, 2)
                        if balloonnr == 1:
                            balloon1display = True
                        elif balloonnr == 2:
                            balloon2display = True
                        waitforballoons2=2        
        # Move player
        # Up
        if keys[0]:
            playerpos[1]-=5
        # Down
        elif keys[2]:
            playerpos[1]+=5
        # Left
        if keys[1]:
            playerpos[0]-=5
        # Right
        elif keys[3]:
            playerpos[0]+=5
        # Move player with JoyStick
        # Up
        if JSkeys[0]:
            playerpos[1]-=5
        # Down
        elif JSkeys[2]:
            playerpos[1]+=5
        # Left
        if JSkeys[1]:
            playerpos[0]-=5
        # Right
        elif JSkeys[3]:
            playerpos[0]+=5
    
        # Win/Lose check
        # Win
        
        # Lose
        if healthvalue<=0:
            running=0
            exitcode=0
        if acc[1]!=0:
            accuracy=acc[0]*1.0/acc[1]*100
        else:
            accuracy=0
        # Flip the display
        pygame.display.flip()
    # Stop the music
    pygame.mixer.music.stop()
    # Win/lose display        
    # Lose
    if exitcode==0:
        # Initialize the font
        pygame.font.init()
        # Set font
        font = pygame.font.Font("freesansbold.ttf", 24)
        bigfont = pygame.font.Font("freesansbold.ttf", 48)
        # Render text
        gameover = bigfont.render("Game over!", True, (255,0,0))
        gameoverRect = gameover.get_rect()
        gameoverRect.centerx = screen.get_rect().centerx
        gameoverRect.centery = screen.get_rect().centery-24
        text = font.render("Accuracy: "+str(accuracy)+"%", True, (255,0,0))
        textRect = text.get_rect()
        textRect.centerx = screen.get_rect().centerx
        textRect.centery = screen.get_rect().centery+24
        # Draw red overlay
        for x in range(width/redoverlay.get_width()+1):
            for y in range(height/redoverlay.get_height()+1):
                screen.blit(redoverlay,(x*100,y*100))
        # Draw text
        screen.blit(gameover, gameoverRect)
        screen.blit(text, textRect)
    # Win
    else:
        # Initialize the font
        pygame.font.init()
        # Set font
        font = pygame.font.Font("freesansbold.ttf", 24)
        bigfont = pygame.font.Font("freesansbold.ttf", 48)
        # Render text
        youwin = bigfont.render("You win!", True, (0,255,0))
        youwinRect = youwin.get_rect()
        youwinRect.centerx = screen.get_rect().centerx
        youwinRect.centery = screen.get_rect().centery-24
        text = font.render("Accuracy: "+str(accuracy)+"%", True, (0,255,0))
        textRect = text.get_rect()
        textRect.centerx = screen.get_rect().centerx
        textRect.centery = screen.get_rect().centery+24
        # Draw green overlay
        for x in range(width/greenoverlay.get_width()+1):
            for y in range(height/greenoverlay.get_height()+1):
                screen.blit(greenoverlay,(x*100,y*100))
        # Draw text
        screen.blit(youwin, youwinRect)
        screen.blit(text, textRect)
    # Exit automatic when the game is stopped
    while 1:
        waitforexit+=1
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
        if waitforexit == 1000:
            menu.launch()
        # Update the screen
        pygame.display.flip()
Exemple #7
0
def launch():
    # Initialize pygame
    pygame.init()

    # Set the width and height of the window
    width, height = pygame.display.Info().current_w, pygame.display.Info().current_h

    # Create the window
    screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)

    # Set the window title
    pygame.display.set_caption("JoyStick Testing Module")

    # Loop until the user clicks the close button.
    done = False

    # Used to manage how fast the screen updates
    clock = pygame.time.Clock()

    # Initialize the joysticks
    pygame.joystick.init()

    # Get ready to print
    textPrint = TextPrint()

    # Set display mode
    prevFS = settings.getFullscreen()
    if settings.getFullscreen() == True:
        screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN)
    elif settings.getFullscreen() == False:
        screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)

    # -------- Main Program Loop -----------
    while True:
        # Set display mode if changed
        if prevFS != settings.getFullscreen():
            if settings.getFullscreen() == True:
                screen = pygame.display.set_mode(
                    (width, height), pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN
                )
                prevFS = settings.getFullscreen()
            elif settings.getFullscreen() == False:
                screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)
                prevFS = settings.getFullscreen()

        # EVENT PROCESSING STEP
        for event in pygame.event.get():  # User did something
            # Check if the event is the X button
            if event.type == pygame.QUIT:
                # If it is go back to the main menu
                menu.launch()
            # Check if a key is pressed
            elif event.type == pygame.KEYDOWN:
                # If pressed esc go back to the menu
                if event.key == K_ESCAPE:
                    menu.launch()

            # Possible joystick actions: JOYAXISMOTION JOYBALLMOTION JOYBUTTONDOWN JOYBUTTONUP JOYHATMOTION
            if event.type == pygame.JOYBUTTONDOWN:
                print("Joystick button pressed.")
            if event.type == pygame.JOYBUTTONUP:
                print("Joystick button released.")

        # DRAWING STEP
        # First, clear the screen to white. Don't put other drawing commands
        # above this, or they will be erased with this command.
        screen.fill(WHITE)
        textPrint.reset()

        # Get count of joysticks
        joystick_count = pygame.joystick.get_count()

        textPrint.Print(screen, "Number of joysticks: {}".format(joystick_count))
        textPrint.indent()

        # For each joystick:
        for i in range(joystick_count):
            joystick = pygame.joystick.Joystick(i)
            joystick.init()

            textPrint.Print(screen, "Joystick {}".format(i))
            textPrint.indent()

            # Get the name from the OS for the controller/joystick
            name = joystick.get_name()
            textPrint.Print(screen, "Joystick name: {}".format(name))

            # Usually axis run in pairs, up/down for one, and left/right for
            # the other.
            axes = joystick.get_numaxes()
            textPrint.Print(screen, "Number of axes: {}".format(axes))
            textPrint.indent()

            for i in range(axes):
                axis = joystick.get_axis(i)
                textPrint.Print(screen, "Axis {} value: {:>6.3f}".format(i, axis))
            textPrint.unindent()

            buttons = joystick.get_numbuttons()
            textPrint.Print(screen, "Number of buttons: {}".format(buttons))
            textPrint.indent()

            for i in range(buttons):
                button = joystick.get_button(i)
                textPrint.Print(screen, "Button {:>2} value: {}".format(i, button))
            textPrint.unindent()

            # Hat switch. All or nothing for direction, not like joysticks.
            # Value comes back in an array.
            hats = joystick.get_numhats()
            textPrint.Print(screen, "Number of hats: {}".format(hats))
            textPrint.indent()

            for i in range(hats):
                hat = joystick.get_hat(i)
                textPrint.Print(screen, "Hat {} value: {}".format(i, str(hat)))
            textPrint.unindent()

            textPrint.unindent()

        # ALL CODE TO DRAW SHOULD GO ABOVE THIS COMMENT

        # Go ahead and update the screen with what we've drawn.
        pygame.display.flip()

        # Limit to 20 frames per second
        clock.tick(20)
Exemple #8
0
def play(fps):
    # Set the width and height of the window
    width, height = int(pygame.display.Info().current_w), int(pygame.display.Info().current_h)
    # Create the window
    screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)
    # Initialize the joystick module
    pygame.joystick.init()
    # Check if there are any joysticks
    joystick_count = pygame.joystick.get_count()
    # If there are any joysticks, initialize the first one, else quit the joystick module
    if joystick_count:
        joystick = pygame.joystick.Joystick(0)
        joystick.init()
        JS = True
        # Set joystick position
        if JS:
            stick0 = "right"
    else:
        pygame.joystick.quit()
        JS = False
    # Set pressed keys
    keys = [False, False, False, False]
    JSkeys = [False, False, False, False]
    # Set player position
    playerpos=[100,100]
    # Make an list for the accuracy
    acc=[0,0]
    # Make an list for where the arrows are
    arrows=[]
    # Set the timer for spawning badgers
    badtimer=100
    badtimer1=0
    # Make an list for where the badgers are
    badguys=[[800,100]]
    # Set your health value
    healthvalue=194
    # Set the wait times
    waitforexit=0
    waitforarrows=0
    waitforballoons=0
    waitforballoons2=2
    # Set displaying balloon on/off
    balloon1display = False
    balloon2display = False
    # Set start ticks
    startticks = pygame.time.get_ticks()
    # Initialize the mixer (for sound)
    pygame.mixer.init()
    # Set title
    pygame.display.set_caption("Bunny and Badgers")
    
    # Load images
    # Load the players image
    player = pygame.image.load("resources/images/dude.png").convert_alpha()
    # Load the background image
    grass = pygame.image.load("resources/images/grass.png").convert()
    # Load the image of the castles
    castle = pygame.image.load("resources/images/castle.png").convert_alpha()
    # Load the image for the arrows
    arrow = pygame.image.load("resources/images/bullet.png").convert_alpha()
    # Load the image for the badgers
    badguyimg1 = pygame.image.load("resources/images/badguy.png").convert_alpha()
    badguyimg2 = pygame.image.load("resources/images/badguy2.png").convert_alpha()
    badguyimg3 = pygame.image.load("resources/images/badguy3.png").convert_alpha()
    badguyimg4 = pygame.image.load("resources/images/badguy4.png").convert_alpha()
    badguyimg = badguyimg1
    # Load the overlays
    greenoverlay = pygame.image.load("resources/images/greenoverlay.png").convert_alpha()
    redoverlay = pygame.image.load("resources/images/redoverlay.png").convert_alpha()
    # Load the healthbar images
    healthbar = pygame.image.load("resources/images/healthbar.png").convert_alpha()
    health = pygame.image.load("resources/images/health.png").convert_alpha()
    # Load the text balloons
    balloon1 = pygame.image.load("resources/images/balloon1.png").convert_alpha()
    balloon2 = pygame.image.load("resources/images/balloon2.png").convert_alpha()
    
    # Load audio
    hit = pygame.mixer.Sound("resources/audio/explode.wav")
    enemy = pygame.mixer.Sound("resources/audio/enemy.wav")
    shoot = pygame.mixer.Sound("resources/audio/shoot.wav")
    # Set the audio volume
    hit.set_volume(0.15)
    enemy.set_volume(0.15)
    shoot.set_volume(0.15)
    # Set the background music
    pygame.mixer.music.load("resources/audio/background.mp3")
    pygame.mixer.music.play(-1, 0.0)
    pygame.mixer.music.set_volume(0.30)
    
    # Set positions
    castle1 = (0,height/16)
    castle2 = (0,height/3.5)
    castle3 = (0,height/2)
    castle4 = (0,height/1.4)

    # Set display mode
    prevFS = settings.getFullscreen()
    if settings.getFullscreen() == True:
        screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN)
    elif settings.getFullscreen() == False:
        screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)

    # Create a clock
    clock = pygame.time.Clock()
    
    # Keep looping through
    running = 1
    exitcode = 0
    while running:
        # Set display mode if changed
        if prevFS != settings.getFullscreen():
            if settings.getFullscreen() == True:
                screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN)
                prevFS = settings.getFullscreen()
            elif settings.getFullscreen() == False:
                screen = pygame.display.set_mode((width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)
                prevFS = settings.getFullscreen()

        # Set joystick buttons, if there are any
        if JS:
            buttonUP = joystick.get_button(4)
            buttonRIGHT = joystick.get_button(5)
            buttonDOWN = joystick.get_button(6)
            buttonLEFT = joystick.get_button(7)
            buttonX = joystick.get_button(14)
            stick0a = joystick.get_axis(0)
            stick0b = joystick.get_axis(1)
            
        # Check for stick0's position
        if JS:
            if stick0a <= -0.5 and stick0b <= -0.5:
                stick0 = "leftup"
            elif stick0a <= -0.5 and stick0b >= 0.5:
                stick0 = "leftdown"
            elif stick0a >= 0.5 and stick0b <= -0.5:
                stick0 = "rightup"
            elif stick0a >= 0.5 and stick0b >= 0.5:
                stick0 = "rightdown"
            elif stick0a <= -0.5:
                stick0 = "left"
            elif stick0a >= 0.5:
                stick0 = "right"
            elif stick0b <= -0.5:
                stick0 = "up"
            elif stick0b >= 0.5:
                stick0 = "down"
            
        badtimer-=1
        # Draw the background
        for x in range(width/grass.get_width()+1):
            for y in range(height/grass.get_height()+1):
                screen.blit(grass,(x*100,y*100))
        # Draw the castles
        screen.blit(castle, castle1)
        screen.blit(castle, castle2)
        screen.blit(castle, castle3)
        screen.blit(castle, castle4)
        # Set player position and rotation
        if JS == False:
            position = pygame.mouse.get_pos()
            angle = numpy.arctan2(position[1]-(playerpos[1]+32),position[0]-(playerpos[0]+26))
            playerrot = pygame.transform.rotate(player, 360-angle*57.29)
            playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
            screen.blit(playerrot, playerpos1)
        elif JS == True:
            if stick0 == "left":
                playerrot = pygame.transform.rotate(player, 180)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "right":
                playerrot = pygame.transform.rotate(player, 0)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "up":
                playerrot = pygame.transform.rotate(player, 90)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "down":
                playerrot = pygame.transform.rotate(player, 270)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "leftup":
                playerrot = pygame.transform.rotate(player, 135)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "leftdown":
                playerrot = pygame.transform.rotate(player, 225)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "rightup":
                playerrot = pygame.transform.rotate(player, 45)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "rightdown":
                playerrot = pygame.transform.rotate(player, 315)
                playerpos1 = (playerpos[0]-playerrot.get_rect().width/2, playerpos[1]-playerrot.get_rect().height/2)
                screen.blit(playerrot, playerpos1)

        # Draw arrows
        for bullet in arrows:
            index=0
            velx=numpy.cos(bullet[0])*10
            vely=numpy.sin(bullet[0])*10
            bullet[1]+=velx
            bullet[2]+=vely
            if bullet[1]<-64 or bullet[1]>width or bullet[2]<-64 or bullet[2]>height:
                arrows.pop(index)
            index+=1
            for projectile in arrows:
                arrow1 = pygame.transform.rotate(arrow, 360-projectile[0]*57.29)
                screen.blit(arrow1, (projectile[1], projectile[2]))

        # Change the image of the badgers
        if badguyimg == badguyimg1:
            badguyimg = badguyimg2
        elif badguyimg == badguyimg2:
            badguyimg = badguyimg3
        elif badguyimg == badguyimg3:
            badguyimg = badguyimg4
        elif badguyimg == badguyimg4:
            badguyimg = badguyimg1

        # Draw badgers
        if badtimer==0:
            badheight1 = height/9.6
            badheight2 = height/1.1
            badheight = numpy.random.randint(int(badheight1), int(badheight2)+1)
            badguys.append([width, badheight])
            badtimer=100-(badtimer1*2)
            if badtimer1>=35:
                badtimer1=35
            else:
                badtimer1+=5
        index=0
        for badguy in badguys:
            if badguy[0]<-64:
                badguys.pop(index)
            badguy[0]-=7
            # Attack castle
            badrect=pygame.Rect(badguyimg.get_rect())
            badrect.top=badguy[1]
            badrect.left=badguy[0]
            if badrect.left<64:
                hit.play()
                healthvalue -= numpy.random.randint(5,21)
                badguys.pop(index)
            # Check for collisions
            index1=0
            for bullet in arrows:
                bullrect=pygame.Rect(arrow.get_rect())
                bullrect.left=bullet[1]
                bullrect.top=bullet[2]
                if badrect.colliderect(bullrect):
                    enemy.play()
                    acc[0]+=1
                    badguys.pop(index)
                    arrows.pop(index1)
                index1+=1
            # Next bad guy
            index+=1
        # Draw badgers
        for badguy in badguys:
            screen.blit(badguyimg, badguy)
        # Draw clock
        font = pygame.font.Font("freesansbold.ttf", 24)
        survivedtext = font.render(str((90000-pygame.time.get_ticks()+startticks)/60000)+":"+str((90000-pygame.time.get_ticks()+startticks)/1000%60).zfill(2), True, (0,0,0))
        textRect = survivedtext.get_rect()
        textRect.topright=[width-5, 5]
        screen.blit(survivedtext, textRect)
        # Draw health bar
        screen.blit(healthbar, (5,5))
        for health1 in range(healthvalue):
            screen.blit(health, (health1+8,8))
        # Loop through the events
        for event in pygame.event.get():
            # Check if the event is the X button 
            if event.type==pygame.QUIT:
                # If it is stop the music and go back to the main menu
                pygame.mixer.music.stop()
                menu.launch()
            if event.type == pygame.KEYDOWN:
                # Move up
                if event.key in (K_w, K_UP):
                    keys[0]=True
                # Move left
                elif event.key in (K_a, K_LEFT):
                    keys[1]=True
                # Move down
                elif event.key in (K_s, K_DOWN):
                    keys[2]=True
                # Move right
                elif event.key in (K_d, K_RIGHT):
                    keys[3]=True
                # Quit by pressing escape
                elif event.key==K_ESCAPE:
                    pygame.mixer.music.stop()
                    menu.launch()
                # Fullscreen by pressing F4
                elif event.key==K_F4:
                    settings.changeFullscreen()
            if event.type == pygame.KEYUP:
                # Move up
                if event.key in (K_w, K_UP):
                    keys[0]=False
                # Move left
                elif event.key in (K_a, K_LEFT):
                    keys[1]=False
                # Move down
                elif event.key in (K_s, K_DOWN):
                    keys[2]=False
                # Move right
                elif event.key in (K_d, K_RIGHT):
                    keys[3]=False
            # Check if you pressed a mouse button for shooting arrows
            if event.type==pygame.MOUSEBUTTONDOWN:
                if waitforarrows == 0:
                    shoot.play()
                    position=pygame.mouse.get_pos()
                    acc[1]+=1
                    arrows.append([numpy.arctan2(position[1]-(playerpos1[1]+32),position[0]-(playerpos1[0]+26)),playerpos1[0]+32,playerpos1[1]+32])
                    # Set wait time for arrows in frames
                    waitforarrows=15
                    if waitforballoons2:
                        waitforballoons2-=1
                    else:
                        # Choose balloon
                        balloonnr = numpy.random.randint(1, 3)
                        if balloonnr == 1:
                            balloon1display = True
                        elif balloonnr == 2:
                            balloon2display = True
                        waitforballoons2=2
        if waitforarrows:
            waitforarrows-=1
            waitforballoons = waitforarrows
        # Display balloon
        if waitforballoons:
            waitforballoons-=1
            if balloon1display:
                screen.blit(balloon1, (playerpos[0]+10, playerpos[1]-60))
            elif balloon2display:
                screen.blit(balloon2, (playerpos[0]+10, playerpos[1]-60))
        else:
            balloon1display = False
            balloon2display = False
    
        # Check if there are any joysticks
        if JS:
            # Check if UP is pressed
            if buttonUP:
                JSkeys[0]=True
            # Check if RIGHT is pressed
            elif buttonRIGHT:
                JSkeys[3]=True
            # Check if DOWN is pressed
            elif buttonDOWN:
                JSkeys[2]=True
            # Check if LEFT is pressed
            elif buttonLEFT:
                JSkeys[1]=True
            else:
                JSkeys[0]=False
                JSkeys[1]=False
                JSkeys[2]=False
                JSkeys[3]=False
            # Check of X is pressed
            if buttonX:
                if waitforarrows == 0:
                    shoot.play()
                    acc[1]+=1
                    if stick0 == "left":
                        arrows.append([3,playerpos1[0]+32,playerpos1[1]+32])
                    elif stick0 == "right":
                        arrows.append([0,playerpos1[0]+32,playerpos1[1]+32])
                    elif stick0 == "up":
                        arrows.append([-1.5,playerpos1[0]+32,playerpos1[1]+32])
                    elif stick0 == "down":
                        arrows.append([1.5,playerpos1[0]+32,playerpos1[1]+32])
                    elif stick0 == "leftup":
                        arrows.append([-2.25,playerpos1[0]+32,playerpos1[1]+32])
                    elif stick0 == "leftdown":
                        arrows.append([2.25,playerpos1[0]+32,playerpos1[1]+32])
                    elif stick0 == "rightup":
                        arrows.append([-0.75,playerpos1[0]+32,playerpos1[1]+32])
                    elif stick0 == "rightdown":
                        arrows.append([0.75,playerpos1[0]+32,playerpos1[1]+32])
                    # Set wait time for arrows in frames
                    waitforarrows=15
                    if waitforballoons2:
                        waitforballoons2-=1
                    else:
                        # Choose balloon
                        balloonnr = numpy.random.randint(1, 3)
                        if balloonnr == 1:
                            balloon1display = True
                        elif balloonnr == 2:
                            balloon2display = True
                        waitforballoons2=2        
        # Move player
        # Up
        if keys[0]:
            playerpos[1]-=5
        # Down
        elif keys[2]:
            playerpos[1]+=5
        # Left
        if keys[1]:
            playerpos[0]-=5
        # Right
        elif keys[3]:
            playerpos[0]+=5
        # Move player with JoyStick
        # Up
        if JSkeys[0]:
            playerpos[1]-=5
        # Down
        elif JSkeys[2]:
            playerpos[1]+=5
        # Left
        if JSkeys[1]:
            playerpos[0]-=5
        # Right
        elif JSkeys[3]:
            playerpos[0]+=5
    
        # Win/Lose check
        # Win
        if (pygame.time.get_ticks()-startticks)>=90000:
            running=0
            exitcode=1
        # Lose
        if healthvalue<=0:
            running=0
            exitcode=0
        if acc[1]!=0:
            accuracy=acc[0]*1.0/acc[1]*100
        else:
            accuracy=0

        # Flip the display
        pygame.display.flip()

        # Lock fps
        clock.tick(fps)

    # Stop the music
    pygame.mixer.music.stop()
    # Win/lose display        
    # Lose
    if exitcode==0:
        # Initialize the font
        pygame.font.init()
        # Set font
        font = pygame.font.Font("freesansbold.ttf", 24)
        bigfont = pygame.font.Font("freesansbold.ttf", 48)
        # Render text
        gameover = bigfont.render("Game over!", True, (255,0,0))
        gameoverRect = gameover.get_rect()
        gameoverRect.centerx = screen.get_rect().centerx
        gameoverRect.centery = screen.get_rect().centery-24
        text = font.render("Accuracy: "+str(accuracy)+"%", True, (255,0,0))
        textRect = text.get_rect()
        textRect.centerx = screen.get_rect().centerx
        textRect.centery = screen.get_rect().centery+24
        # Draw red overlay
        for x in range(width/redoverlay.get_width()+1):
            for y in range(height/redoverlay.get_height()+1):
                screen.blit(redoverlay,(x*100,y*100))
        # Draw text
        screen.blit(gameover, gameoverRect)
        screen.blit(text, textRect)
    # Win
    else:
        # Initialize the font
        pygame.font.init()
        # Set font
        font = pygame.font.Font("freesansbold.ttf", 24)
        bigfont = pygame.font.Font("freesansbold.ttf", 48)
        # Render text
        youwin = bigfont.render("You win!", True, (0,255,0))
        youwinRect = youwin.get_rect()
        youwinRect.centerx = screen.get_rect().centerx
        youwinRect.centery = screen.get_rect().centery-24
        text = font.render("Accuracy: "+str(accuracy)+"%", True, (0,255,0))
        textRect = text.get_rect()
        textRect.centerx = screen.get_rect().centerx
        textRect.centery = screen.get_rect().centery+24
        # Draw green overlay
        for x in range(width/greenoverlay.get_width()+1):
            for y in range(height/greenoverlay.get_height()+1):
                screen.blit(greenoverlay,(x*100,y*100))
        # Draw text
        screen.blit(youwin, youwinRect)
        screen.blit(text, textRect)
    # Exit automatic when the game is stopped
    while 1:
        waitforexit+=1
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
        if waitforexit == 1000:
            menu.launch()
        # Update the screen
        pygame.display.flip()
Exemple #9
0
def game():
	import pygame, sys, pygame.mixer
	from pygame.locals import *
	import common_pygame
	import enemy
	import load_resources
	import random
	import ship
	import background
	import hud
	import bonus
	import menu
	import effects
	import particles
	import smoke
	import lasers
	import input
	import lib.eztext 
	import scoreboard

	pygame = common_pygame.pygame
	screen= common_pygame.screen
	clock = common_pygame.clock



	#dictionnaries that will contain all our needed resources
	sounds = dict()
	single_sprites = dict()
	sprite_sequences = dict()

	#create the menu ( we create it here in order to let the menu object read the configuration,
	#to set the correct screen size

	menu=menu.Menu()
	#fill up our dictionnaries
	(sounds, single_sprites, sprite_sequences) = load_resources.load_resources(pygame)

	#sprite proprieties being used later
	laser_height = single_sprites['sprite_laser.png'].get_height()
	laser_width = single_sprites['sprite_laser.png'].get_width()
	#lasershoot_width =  single_sprites['sprite_lasershoot.png'].get_width()
	#lasershoot_height =  single_sprites['sprite_lasershoot.png'].get_height()


	
	#the ship's laser list
	laserlist = list()

	lasershoot = 7

	tinyfont = pygame.font.Font(None, 16)
	font = pygame.font.Font(None,32)
	font2 = pygame.font.Font(None, 150)

	background = background.BackGen(single_sprites)



	hud= hud.Hud(single_sprites, menu, sounds)
	#start the menu
	menu.init2(single_sprites, sounds, background, hud)
	menu.launch(0)


	ship = ship.Ship(single_sprites, sounds, menu, sprite_sequences )
	ship.setWeapon(1)

	ship_top = screen.get_height()-ship.height
	ship_left = screen.get_width()/2 - ship.width/2

	decal_laser_ship_x = (ship.width /2)
	coord_laser_ship_y = -40
	
	
	#the enemy laser system
	lasers = lasers.Lasers(single_sprites, ship)

	enemy_list = list()

	compteur = 0
	countdown=0
	#to know if it's ok to shoot
	compteur_shoot=int(0)
	nbAsteroids=0
	#current_sprite=0

	it=0

	#bonus processing
	scoreBonus=bonus.Bonus(sounds, menu)

	thegame=True
	level =-1
	spawnedBoss=False
	while thegame:
		compteur_shoot=compteur_shoot+1
		
		#every 2 minutes, level up
		if compteur%(30*60)==0:
			level=level+1
		#level 1 : 3 enemies every 3 seconds
		if level==1:
			if compteur%(3*20)==0:
				
				boolrand = bool(random.getrandbits(1))
				for i in range(1):
					enemy_list.append(enemy.Enemy( single_sprites, sprite_sequences , sounds,
					i*80+250+60*int(boolrand), -single_sprites['sprite_enemy.png'].get_height(),boolrand \
					, 0, menu))
				#print (enemy_list[0].nbAsteroids)
		if level==2:
			if compteur%(2*60)==0:
				
				boolrand = bool(random.getrandbits(1))
				for i in range(6):
					enemy_list.append(enemy.Enemy( single_sprites, sprite_sequences , sounds,
					i*80+190+60*int(boolrand), -single_sprites['sprite_enemy.png'].get_height(),boolrand \
					, 0, menu))
				#print (enemy_list[0].nbAsteroids)
		if level==3 and not spawnedBoss:
			enemy_list.append(enemy.Enemy( single_sprites, sprite_sequences , sounds, 
			400-single_sprites['boss1.png'].get_width()/2, -single_sprites['boss1.png'].get_height(),1 ,\
			 2, menu))
			spawnedBoss=True
			#if compteur%(1*60)==0:
				
				#boolrand = bool(random.getrandbits(1))
				#for i in range(9):
					#enemy_list.append(enemy.Enemy( single_sprites, sprite_sequences , sounds,
					#i*80+80+60*int(boolrand), -single_sprites['sprite_enemy.png'].get_height(),boolrand , 0, menu))
				#print (enemy_list[0].nbAsteroids)
				
		#new asteroids
		#if ((len(enemy_list)==0) or enemy_list[0].nbAsteroids<=2) and compteur%150==0:
		if compteur%150==0:
			boolrand = bool(random.getrandbits(1))
			enemy_list.append(enemy.Enemy( single_sprites, sprite_sequences , sounds,
				random.randrange(0, screen.get_width()), -32,boolrand , 1, menu))
			enemy_list[0].nbAsteroids=enemy_list[0].nbAsteroids+1
			#if (len(enemy_list)>=0):
				#print(
				
		compteur = compteur +1 
		background.updatecompteur()
		
		
		clock.tick_busy_loop(30)
		screen.fill((0,0,0))

		#blit the stars and the asteroids
		background.blitStars()
		background.blitPlanets()
			#show the fog
		background.blitFog()

		
		mouse_x,mouse_y=pygame.mouse.get_pos()
		for event in pygame.event.get():
			if event.type == pygame.QUIT:
				sys.exit()
			#elif event.type == MOUSEBUTTONDOWN:
				#sounds['laser.wav'].play()
				#laserlist.append( (ship.position_ship_x+ship.width/2 -laser_width/2 ,
				#ship.position_ship_y-laser_height))
				#lasershoot = 7
		if pygame.key.get_pressed()[K_ESCAPE]:
			#launch menu with resume option
			menu.launch(1) 				
		if pygame.key.get_pressed()[K_LEFT]:
			if ship.currentspeed_x >=0:
				ship.currentspeed_x = -5
			if ship.currentspeed_x > -20:
				ship.currentspeed_x = ship.currentspeed_x -1
			
		elif pygame.key.get_pressed()[K_RIGHT]:
			if ship.currentspeed_x <= 0:
				ship.currentspeed_x = 5
			if ship.currentspeed_x < 20:
				ship.currentspeed_x = ship.currentspeed_x +1
		if pygame.key.get_pressed()[K_DOWN]:
			if ship.currentspeed_y <= 0:
				ship.currentspeed_y = 5
			if ship.currentspeed_y < 20:
				ship.currentspeed_y = ship.currentspeed_y +1
		elif pygame.key.get_pressed()[K_UP]:
			if ship.currentspeed_y >= 0:
				ship.currentspeed_y = -5
			if ship.currentspeed_y > -20:
				ship.currentspeed_y = ship.currentspeed_y -1
		
		if 	pygame.key.get_pressed()[K_LEFT] ==0 and pygame.key.get_pressed()[K_RIGHT]==0 \
		and pygame.key.get_pressed()[K_UP] ==0 and pygame.key.get_pressed()[K_DOWN]==0:
			ship.currentspeed_y=0
			ship.currentspeed_x=0
		
		
		#are we shooting ?
		if pygame.key.get_pressed()[K_SPACE]:
			(compteur_shoot, laserlist) =ship.shoot(laserlist,compteur_shoot, laser_width, laser_height)
			
					
		#update the ships position
		ship.updatePosition()
		#blit the right thing
		ship.blit(compteur)
				
		
		
		#blit the laser shot fire
		#if lasershoot >= 0 :
			#screen.blit(single_sprites['sprite_lasershoot.png'],(ship.position_ship_x+ship.width/2 -lasershoot_width/2,
			 #ship.position_ship_y ))
			#lasershoot = lasershoot -1
			
		oldLasers = list()	
		#blit the lasers
		for index in range(len(laserlist)):
			(currentx, currenty, lasertype) = laserlist[index]
			if currenty>=-40:
				#it's a normal laser
				if lasertype==1:
					screen.blit(single_sprites['sprite_laser_light.png'],(currentx-29-32,currenty-22-32))
					screen.blit(single_sprites['sprite_laser.png'],(currentx,currenty))
					currenty = currenty - 15
				#it's a plasma ball
				else :
					screen.blit(single_sprites['ball1_light.png'],(currentx-10,currenty-10))
					screen.blit(single_sprites['ball1.png'],(currentx,currenty))
					currenty = currenty - 20				
				
				laserlist[index]=(currentx,currenty, lasertype)
			else:
				oldLasers.append((currentx,currenty, lasertype))
		#purge old lasers
		for index in range(len(oldLasers)):
			laserlist.remove(oldLasers[index])
			
		deadEnemies=list()
		#blit and process the enemies
		for index in range(len(enemy_list)):
			oldLasers=enemy_list[index].processHit(laserlist, ship)
			enemy_list[index].update(ship, lasers)
			if enemy_list[index].alive==False:
				deadEnemies.append(enemy_list[index])
				#purge old lasers
			for index in range(len(oldLasers)):
				laserlist.remove(oldLasers[index])	
			
		#purge dead enemies
		for index in range(len(deadEnemies)):
			enemy_list.remove(deadEnemies[index])	
		
		
		#blit and process the enemy's lasers
		lasers.update()
		
		
		
				
		#blit the hud		
		level = hud.blit(ship, level)
				
		#process ship hurt
		countdown = ship.processHurt(countdown)

		if (ship.life<=0):
			thegame=False
			#youlost = font2.render("Game over", True, (255,255, 255))
			#presskey = font.render("press any key to quit", True, (255,255, 255))
			#yourscore = font.render("Your score : "+ str(ship.score), True, (255,255, 255))
			youlost = pygame.font.Font("BITSUMIS.TTF",105).render("Game over", True, (255,255, 255))
			presskey = pygame.font.Font("BITSUMIS.TTF",23).render("press escape to quit", True, (255,255, 255))
			yourscore = pygame.font.Font("BITSUMIS.TTF",30).render("Your score : "+ str(ship.score), True, (255,255, 255))
			
			yourname = pygame.font.Font("BITSUMIS.TTF",55).render("Your name : ", True, (255,255, 255))
			
			#play a the explosion sound
			menu.play_sound(sounds['explosion2.wav'])
			#blit the explosion
			screen.blit(sprite_sequences['sprite_explosion_list_asteroid.png'][3],\
			 (ship.position_ship_x-64,ship.position_ship_y-64))
			#fade to red
			effects.fadeToColor(255, 0, 0)
		#scoreBonus.ProcessBonus(ship)
		particles.blitAndUpdate()
		smoke.blitAndUpdate()
		
		pygame.display.flip()

	exitloop = True
	exitcountdown =0
	name = ""
	car = ""
	txtbx = lib.eztext.Input(maxlength=45, color=(255,50,50), prompt='Your name: ')
	txtbx.set_pos( 230,180)
	txtbx.set_font(pygame.font.Font("BITSUMIS.TTF",30))
	nametyped = False
	scoreObj = scoreboard.ScoreBoard()
	
	while exitloop:
		exitcountdown =exitcountdown+ 1
		clock.tick_busy_loop(30)
		screen.fill((0,0,0))
		
		background.updatecompteur()
		background.blitStars()
		background.blitPlanets()
		#show the fog
		background.blitFog()
		screen.blit(youlost, (110,35 ))
		screen.blit(yourscore, (130,150 ))
		#screen.blit(yourname, (180,330 ))
		#screen.blit(pygame.font.Font("BITSUMIS.TTF",55)\
		#.render(name, True, (255,0, 0)), (300, 330))
		screen.blit(presskey, (270,520 ))
		
		#car = str(input.keyInput())
		#if isinstance(car, str):
			#name = name + pygame.key.name(car)
		#print("name : " + name)
		#input.keyInput()
		
		if not nametyped:
			# update txtbx
			txtbx.update(pygame.event.get())
        
        # blit txtbx on the sceen
		#if exitcountdown%20>10:
				#txtbx.draw(screen)
		
		if txtbx.hasTyped() ==False:
			if exitcountdown%20>10:
				txtbx.draw(screen)
		elif nametyped == False:
			txtbx.draw(screen)
		
		
		if exitcountdown==30:
			menu.play_sound(sounds["loser.wav"])
			
		if exitcountdown>=30:
			for event in pygame.event.get():
				if event.type == pygame.QUIT:
					sys.exit()
			if pygame.key.get_pressed()[K_ESCAPE]:
				print("exiting")
				exit()
				exitloop=False
			if pygame.key.get_pressed()[K_RETURN]:
				if not nametyped:
					scoreObj.addScore(ship.score, txtbx.getText())
					nametyped = True
				
 
		scoreObj.printScore()

				

		#if pygame.KEYDOWN:
			#print("exiting")
			#exit()
		pygame.display.flip()
Exemple #10
0
def play():
    cnt = 0
    dec = False
    eclipse = 0
    dececc = False
    # Define varibale for Level
    isLevelOne = True
    # Define variables for freeze power
    timeForFreezePower = False
    freezePowerSent = False
    freezepowercord = []
    freezePower = False
    freezeTimer = 10
    # Define variables for bullet power
    timeForBulletPower = False
    bulletPowerSent = False
    bulletpowercord = []
    bulletPower = False
    bulletTimer = 10
    # Define variables for danger power
    timeForDangerPower = False
    dangerPowerSent = False
    dangerpowercord = []
    dangerPower = False
    dangerTimer = 10
    # Set the width and height of the window
    width, height = int(pygame.display.Info().current_w), int(
        pygame.display.Info().current_h)
    # Create the window
    screen = pygame.display.set_mode((width, height),
                                     pygame.HWSURFACE | pygame.DOUBLEBUF)
    # Initialize the joystick module
    pygame.joystick.init()
    # Check if there are any joysticks
    joystick_count = pygame.joystick.get_count()
    # If there are any joysticks, initialize the first one, else quit the joystick module
    if joystick_count:
        joystick = pygame.joystick.Joystick(0)
        joystick.init()
        JS = True
        # Set joystick position
        if JS:
            stick0 = "right"
    else:
        pygame.joystick.quit()
        JS = False
    # Set pressed keys
    keys = [False, False, False, False]
    JSkeys = [False, False, False, False]
    # Set player position
    playerpos = [100, 100]
    # Make an list for the accuracy
    acc = [0, 0]
    # Make an list for where the arrows are
    arrows = []
    # Set the timer for spawning badgers
    badtimer = 100
    badtimer1 = 0
    # Make an list for where the badgers are
    badguys = [[800, 100]]
    # Set your health value
    healthvalue = 194
    # Set the wait times
    waitforexit = 0
    waitforarrows = 0
    waitforballoons = 0
    waitforballoons2 = 2
    # Set displaying balloon on/off
    balloon1display = False
    balloon2display = False
    # Set start ticks
    startticks = pygame.time.get_ticks()
    # Initialize the mixer (for sound)
    pygame.mixer.init()
    # Set title
    pygame.display.set_caption("Galaxy Wars")

    # Load images
    # Load the players image
    player = pygame.image.load("resources/images/dude.png")
    # Load the power  freeze image
    power_freeze = pygame.image.load("resources/images/power_freeze.png")
    # Load thunder image
    thunder = pygame.image.load("resources/images/thunder.png")
    # Load backgrounds
    bgmorning = pygame.image.load("resources/images/bgmorning.jpg")
    # Load the power bullet image
    power_bullet = pygame.image.load("resources/images/power_bullet.png")
    # Load the power danger image
    power_danger = pygame.image.load("resources/images/power_danger.png")
    # Green Bullet
    bullet_green = pygame.image.load("resources/images/bullet_green.png")
    # Load the background image
    bgmain = pygame.image.load("resources/images/starfield.png")
    # Red Sun level 1
    sunred = pygame.image.load("resources/images/SunRed.png")
    # Blue Sun Danger
    sunblue = pygame.image.load("resources/images/SunBlue.png")
    # Load the image of the castles
    castle = pygame.image.load("resources/images/castle.png")
    # Load the image for the arrows
    arrow = pygame.image.load("resources/images/bullet.png")
    # Load the image for the badgers
    badguyimg1 = pygame.image.load("resources/images/badguy.png")
    badguyimg = badguyimg1
    # Load the overlays
    greenoverlay = pygame.image.load("resources/images/greenoverlay.png")
    redoverlay = pygame.image.load("resources/images/redoverlay.png")
    # Load the healthbar images
    healthbar = pygame.image.load("resources/images/healthbar.png")
    health = pygame.image.load("resources/images/health.png")
    # Load the text balloons
    balloon1 = pygame.image.load("resources/images/balloon1.png")
    balloon2 = pygame.image.load("resources/images/balloon2.png")

    # Load audio
    hit = pygame.mixer.Sound("resources/audio/explode.wav")
    enemy = pygame.mixer.Sound("resources/audio/enemy.wav")
    shoot = pygame.mixer.Sound("resources/audio/shoot.wav")
    # Set the audio volume
    hit.set_volume(0.15)
    enemy.set_volume(0.15)
    shoot.set_volume(0.15)
    # Set the background music
    pygame.mixer.music.load('resources/audio/background.mp3')
    pygame.mixer.music.play(-1, 0.0)
    pygame.mixer.music.set_volume(0.30)

    # Set positions
    castle1 = (0, height / 16)
    castle2 = (0, height / 3.5)
    castle3 = (0, height / 2)
    castle4 = (0, height / 1.4)

    # Set display mode
    prevFS = settings.getFullscreen()
    if settings.getFullscreen() == True:
        screen = pygame.display.set_mode(
            (width, height),
            pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN)
    elif settings.getFullscreen() == False:
        screen = pygame.display.set_mode((width, height),
                                         pygame.HWSURFACE | pygame.DOUBLEBUF)

    # Keep looping through
    running = 1
    exitcode = 0
    while running:
        # Set display mode if changed
        if prevFS != settings.getFullscreen():
            if settings.getFullscreen() == True:
                screen = pygame.display.set_mode(
                    (width, height),
                    pygame.HWSURFACE | pygame.DOUBLEBUF | pygame.FULLSCREEN)
                prevFS = settings.getFullscreen()
            elif settings.getFullscreen() == False:
                screen = pygame.display.set_mode(
                    (width, height), pygame.HWSURFACE | pygame.DOUBLEBUF)
                prevFS = settings.getFullscreen()

        # Set joystick buttons, if there are any
        if JS:
            buttonUP = joystick.get_button(4)
            buttonRIGHT = joystick.get_button(5)
            buttonDOWN = joystick.get_button(6)
            buttonLEFT = joystick.get_button(7)
            buttonX = joystick.get_button(14)
            stick0a = joystick.get_axis(0)
            stick0b = joystick.get_axis(1)

        # Check for stick0's position
        if JS:
            if stick0a <= -0.5 and stick0b <= -0.5:
                stick0 = "leftup"
            elif stick0a <= -0.5 and stick0b >= 0.5:
                stick0 = "leftdown"
            elif stick0a >= 0.5 and stick0b <= -0.5:
                stick0 = "rightup"
            elif stick0a >= 0.5 and stick0b >= 0.5:
                stick0 = "rightdown"
            elif stick0a <= -0.5:
                stick0 = "left"
            elif stick0a >= 0.5:
                stick0 = "right"
            elif stick0b <= -0.5:
                stick0 = "up"
            elif stick0b >= 0.5:
                stick0 = "down"

        badtimer -= 1
        # Clear the screen before drawing it again
        screen.fill(0)
        # Draw the background
        if isLevelOne:
            screen.blit(bgmorning, (0, 0))
        else:
            screen.blit(bgmain, (0, 0))
        if acc[0] > 25:
            isLevelOne = False
        if dangerPower and isLevelOne == False:
            eclipse += 10
            if eclipse > 100:
                screen.blit(sunblue, (width // 2, 0))
            else:
                screen.blit(sunred, (width // 2, 0))
            if eclipse % 20 == 0:
                screen.blit(thunder, (width // 2, 0))
            if eclipse > 200:
                eclipse = 0
        else:
            screen.blit(sunred, (width // 2, 0))

        # Draw the castles
        screen.blit(castle, castle1)
        screen.blit(castle, castle2)
        screen.blit(castle, castle3)
        screen.blit(castle, castle4)
        # Set player position and rotation

        if JS == False:
            position = pygame.mouse.get_pos()
            angle = math.atan2(position[1] - (playerpos[1] + 32),
                               position[0] - (playerpos[0] + 26))
            playerrot = pygame.transform.rotate(player, 360 - angle * 57.29)
            playerpos1 = (playerpos[0] - playerrot.get_rect().width / 2,
                          playerpos[1] - playerrot.get_rect().height / 2)
            screen.blit(playerrot, playerpos1)
        elif JS == True:
            if stick0 == "left":
                playerrot = pygame.transform.rotate(player, 180)
                playerpos1 = (playerpos[0] - playerrot.get_rect().width / 2,
                              playerpos[1] - playerrot.get_rect().height / 2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "right":
                playerrot = pygame.transform.rotate(player, 0)
                playerpos1 = (playerpos[0] - playerrot.get_rect().width / 2,
                              playerpos[1] - playerrot.get_rect().height / 2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "up":
                playerrot = pygame.transform.rotate(player, 90)
                playerpos1 = (playerpos[0] - playerrot.get_rect().width / 2,
                              playerpos[1] - playerrot.get_rect().height / 2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "down":
                playerrot = pygame.transform.rotate(player, 270)
                playerpos1 = (playerpos[0] - playerrot.get_rect().width / 2,
                              playerpos[1] - playerrot.get_rect().height / 2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "leftup":
                playerrot = pygame.transform.rotate(player, 135)
                playerpos1 = (playerpos[0] - playerrot.get_rect().width / 2,
                              playerpos[1] - playerrot.get_rect().height / 2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "leftdown":
                playerrot = pygame.transform.rotate(player, 225)
                playerpos1 = (playerpos[0] - playerrot.get_rect().width / 2,
                              playerpos[1] - playerrot.get_rect().height / 2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "rightup":
                playerrot = pygame.transform.rotate(player, 45)
                playerpos1 = (playerpos[0] - playerrot.get_rect().width / 2,
                              playerpos[1] - playerrot.get_rect().height / 2)
                screen.blit(playerrot, playerpos1)
            elif stick0 == "rightdown":
                playerrot = pygame.transform.rotate(player, 315)
                playerpos1 = (playerpos[0] - playerrot.get_rect().width / 2,
                              playerpos[1] - playerrot.get_rect().height / 2)
                screen.blit(playerrot, playerpos1)

        # Draw arrows
        for bullet in arrows:
            index = 0
            velx = 0
            vely = 0
            if bulletPower and dangerPower is False:
                velx = math.cos(bullet[0]) * 30
                vely = math.sin(bullet[0]) * 30
            elif dangerPower is False:
                velx = math.cos(bullet[0]) * 20
                vely = math.sin(bullet[0]) * 20
            elif dangerPower:
                velx = math.cos(bullet[0]) * 10
                vely = math.sin(bullet[0]) * 10
            bullet[1] += velx
            bullet[2] += vely
            if bullet[1] < -64 or bullet[1] > width or bullet[
                    2] < -64 or bullet[2] > height:
                arrows.pop(index)
            index += 1
            for projectile in arrows:
                arrow1 = pygame.transform.rotate(arrow,
                                                 360 - projectile[0] * 57.29)
                bullet_green1 = pygame.transform.rotate(
                    bullet_green, 360 - projectile[0] * 57.29)
                if bulletPower:
                    screen.blit(bullet_green1, (projectile[1], projectile[2]))
                else:
                    screen.blit(arrow1, (projectile[1], projectile[2]))
        # Draw badguys
        if badtimer == 0:
            badheight1 = height / 9.6
            badheight2 = height / 1.1
            badheight = random.randint(int(badheight1), int(badheight2))
            badguys.append([width, badheight])
            badtimer = 100 - (badtimer1 * 2)
            if badtimer1 >= 35:
                badtimer1 = 35
            else:
                badtimer1 += 5
        index = 0
        for badguy in badguys:
            if badguy[0] < -64:
                badguys.pop(index)
            if freezePower is False and dangerPower is False:
                badguy[0] -= 7
                if cnt < 30 and dec is False:
                    badguy[1] += 7
                    cnt += 1
                else:
                    dec = True
                    cnt -= 1
                    badguy[1] -= 7
                    if cnt is 0:
                        dec = False
            elif dangerPower:
                badguy[0] -= 20
                xx = random.randint(0, 1)
                if cnt < 30 and dec is False:
                    if xx == 1:
                        badguy[1] += 7
                    cnt += 1
                else:
                    dec = True
                    cnt -= 1
                    if xx == 1:
                        badguy[1] -= 7
                    if cnt is 0:
                        dec = False
            # Attack castle
            badrect = pygame.Rect(badguyimg.get_rect())
            badrect.top = badguy[1]
            badrect.left = badguy[0]
            if badrect.left < 64:
                hit.play()
                healthvalue -= random.randint(5, 20)
                badguys.pop(index)
            # Check for collisions
            index1 = 0
            for bullet in arrows:
                bullrect = pygame.Rect(arrow.get_rect())
                bullrect.left = bullet[1]
                bullrect.top = bullet[2]
                if badrect.colliderect(bullrect):
                    enemy.play()
                    acc[0] += 1
                    if acc[0] % 3 == 0 and isLevelOne == False:
                        timeForDangerPower = True
                    else:
                        timeForDangerPower = False
                    if acc[0] % 5 == 0:
                        timeForFreezePower = True
                    else:
                        timeForFreezePower = False
                    if acc[0] % 7 == 0:
                        timeForBulletPower = True
                    else:
                        timeForBulletPower = False
                    badguys.pop(index)
                    if bulletPower == False:
                        arrows.pop(index1)
                index1 += 1
            # Next bad guy
            index += 1
        # Draw badgers
        for badguy in badguys:
            screen.blit(badguyimg, badguy)

        # Draw power if power sent is true
        if dangerPowerSent:
            dangerpowercord[0] -= 7
            screen.blit(power_danger, dangerpowercord)
            if dangerpowercord[0] < 0:
                dangerPowerSent = False

        if bulletPowerSent:
            bulletpowercord[0] -= 7
            screen.blit(power_bullet, bulletpowercord)
            if bulletpowercord[0] < 0:
                bulletPowerSent = False

        if freezePowerSent:
            freezepowercord[0] -= 7
            screen.blit(power_freeze, freezepowercord)
            if freezepowercord[0] < 0:
                freezePowerSent = False

        if timeForDangerPower and dangerPowerSent == False:
            powerheight1 = height / 9.6
            powerheight2 = height / 1.1
            powerheight = random.randint(int(powerheight1), int(powerheight2))
            dangerpowercord = [width, playerpos[1]]
            print "dangerPowerSent"
            dangerPowerSent = True
            timeForDangerPower = False
            screen.blit(power_danger, dangerpowercord)

        if timeForBulletPower and bulletPowerSent == False:
            powerheight1 = height / 9.6
            powerheight2 = height / 1.1
            powerheight = random.randint(int(powerheight1), int(powerheight2))
            bulletpowercord = [width, powerheight]
            print "bulletPowerSent"
            bulletPowerSent = True
            timeForBulletPower = False
            screen.blit(power_bullet, bulletpowercord)

        if timeForFreezePower and freezePowerSent == False:
            powerheight1 = height / 9.6
            powerheight2 = height / 1.1
            powerheight = random.randint(int(powerheight1), int(powerheight2))
            freezepowercord = [width, powerheight]
            print "freezePowerSent"
            freezePowerSent = True
            timeForFreezePower = False
            screen.blit(power_freeze, freezepowercord)

        if dangerPower:
            dangerTimer += 10
            if dangerTimer > 2000:
                dangerPower = False
                dangerTimer = 0

        if bulletPower:
            bulletTimer += 10
            if bulletTimer > 2000:
                bulletPower = False
                bulletTimer = 0

        if freezePower:
            freezeTimer += 10
            if freezeTimer > 1000:
                freezePower = False
                freezeTimer = 0

        # Check if power is Taken
        if dangerPowerSent:
            dangerpowerRect = pygame.Rect(power_danger.get_rect())
            playerRect = pygame.Rect(player.get_rect())
            dangerpowerRect.top = dangerpowercord[1]
            dangerpowerRect.left = dangerpowercord[0]
            playerRect.top = playerpos[1]
            playerRect.left = playerpos[0]
            if dangerpowerRect.colliderect(playerRect):
                dangerPower = True
                dangerPowerSent = False

        if bulletPowerSent:
            bullpowerRect = pygame.Rect(power_bullet.get_rect())
            playerRect = pygame.Rect(player.get_rect())
            bullpowerRect.top = bulletpowercord[1]
            bullpowerRect.left = bulletpowercord[0]
            playerRect.top = playerpos[1]
            playerRect.left = playerpos[0]
            if bullpowerRect.colliderect(playerRect):
                bulletPower = True
                bulletPowerSent = False

        if freezePowerSent:
            powerRect = pygame.Rect(power_freeze.get_rect())
            playerRect = pygame.Rect(player.get_rect())
            powerRect.top = freezepowercord[1]
            powerRect.left = freezepowercord[0]
            playerRect.top = playerpos[1]
            playerRect.left = playerpos[0]
            if powerRect.colliderect(playerRect):
                freezePower = True
                print "Collision Detected"
                freezePowerSent = False

        # Draw clock
        font = pygame.font.Font("freesansbold.ttf", 24)
        survivedtext = font.render(str("Score: " + str(acc[0])), True,
                                   (255, 0, 0))
        leveltext = ""
        if isLevelOne:
            leveltext = font.render(str("Level: 1"), True, (0, 0, 255))
        else:
            leveltext = font.render(str("Level: 2"), True, (0, 0, 255))
        levelrect = leveltext.get_rect()
        levelrect.topleft = [250, 5]
        screen.blit(leveltext, levelrect)
        textRect = survivedtext.get_rect()
        textRect.topright = [width - 5, 5]
        screen.blit(survivedtext, textRect)
        # Draw health bar
        screen.blit(healthbar, (5, 5))
        for health1 in range(healthvalue):
            screen.blit(health, (health1 + 8, 8))
        # Loop through the events
        for event in pygame.event.get():
            # Check if the event is the X button
            if event.type == pygame.QUIT:
                # If it is stop the music and go back to the main menu
                pygame.mixer.music.stop()
                menu.launch()
            if event.type == pygame.KEYDOWN:
                # Move up
                if event.key == K_w:
                    keys[0] = True
                elif event.key == K_UP:
                    keys[0] = True
                # Move left
                elif event.key == K_a:
                    keys[1] = True
                elif event.key == K_LEFT:
                    keys[1] = True
                # Move down
                elif event.key == K_s:
                    keys[2] = True
                elif event.key == K_DOWN:
                    keys[2] = True
                # Move right
                elif event.key == K_d:
                    keys[3] = True
                elif event.key == K_RIGHT:
                    keys[3] = True
                # Quit by pressing escape
                elif event.key == K_ESCAPE:
                    pygame.mixer.music.stop()
                    menu.launch()
                # Fullscreen by pressing F4
                elif event.key == K_F4:
                    settings.changeFullscreen()
                elif event.key == pygame.K_SPACE:
                    if waitforarrows == 0:
                        shoot.play()
                        position = pygame.mouse.get_pos()
                        acc[1] += 1
                        arrows.append([
                            math.atan2(position[1] - (playerpos1[1] + 32),
                                       position[0] - (playerpos1[0] + 26)),
                            playerpos1[0] + 32, playerpos1[1] + 32
                        ])
                        # Set wait time for arrows in frames
                        waitforarrows = 15
                        if waitforballoons2:
                            waitforballoons2 -= 1
                        else:
                            # Choose balloon
                            balloonnr = random.randint(1, 2)
                            if balloonnr == 1:
                                balloon1display = True
                            elif balloonnr == 2:
                                balloon2display = True
                            waitforballoons2 = 2
            if event.type == pygame.KEYUP:
                # Move up
                if event.key == pygame.K_w:
                    keys[0] = False
                elif event.key == pygame.K_UP:
                    keys[0] = False
                # Move left
                elif event.key == pygame.K_a:
                    keys[1] = False
                elif event.key == pygame.K_LEFT:
                    keys[1] = False
                # Move down
                elif event.key == pygame.K_s:
                    keys[2] = False
                elif event.key == pygame.K_DOWN:
                    keys[2] = False
                # Move right
                elif event.key == pygame.K_d:
                    keys[3] = False
                elif event.key == pygame.K_RIGHT:
                    keys[3] = False
        if waitforarrows:
            waitforarrows -= 1
            waitforballoons = waitforarrows
        # Display balloon
        if waitforballoons:
            waitforballoons -= 1
            if balloon1display:
                screen.blit(balloon1, (playerpos[0] + 10, playerpos[1] - 60))
            elif balloon2display:
                screen.blit(balloon2, (playerpos[0] + 10, playerpos[1] - 60))
        else:
            balloon1display = False
            balloon2display = False

        # Check if there are any joysticks
        if JS:
            # Check if UP is pressed
            if buttonUP:
                JSkeys[0] = True
            # Check if RIGHT is pressed
            elif buttonRIGHT:
                JSkeys[3] = True
            # Check if DOWN is pressed
            elif buttonDOWN:
                JSkeys[2] = True
            # Check if LEFT is pressed
            elif buttonLEFT:
                JSkeys[1] = True
            else:
                JSkeys[0] = False
                JSkeys[1] = False
                JSkeys[2] = False
                JSkeys[3] = False
            # Check of X is pressed
            if buttonX:
                if waitforarrows == 0:
                    shoot.play()
                    acc[1] += 1
                    if stick0 == "left":
                        arrows.append(
                            [3, playerpos1[0] + 32, playerpos1[1] + 32])
                    elif stick0 == "right":
                        arrows.append(
                            [0, playerpos1[0] + 32, playerpos1[1] + 32])
                    elif stick0 == "up":
                        arrows.append(
                            [-1.5, playerpos1[0] + 32, playerpos1[1] + 32])
                    elif stick0 == "down":
                        arrows.append(
                            [1.5, playerpos1[0] + 32, playerpos1[1] + 32])
                    elif stick0 == "leftup":
                        arrows.append(
                            [-2.25, playerpos1[0] + 32, playerpos1[1] + 32])
                    elif stick0 == "leftdown":
                        arrows.append(
                            [2.25, playerpos1[0] + 32, playerpos1[1] + 32])
                    elif stick0 == "rightup":
                        arrows.append(
                            [-0.75, playerpos1[0] + 32, playerpos1[1] + 32])
                    elif stick0 == "rightdown":
                        arrows.append(
                            [0.75, playerpos1[0] + 32, playerpos1[1] + 32])
                    # Set wait time for arrows in frames
                    waitforarrows = 15
                    if waitforballoons2:
                        waitforballoons2 -= 1
                    else:
                        # Choose balloon
                        balloonnr = random.randint(1, 2)
                        if balloonnr == 1:
                            balloon1display = True
                        elif balloonnr == 2:
                            balloon2display = True
                        waitforballoons2 = 2
        # Move player
        # Up
        if keys[0]:
            playerpos[1] -= 5
        # Down
        elif keys[2]:
            playerpos[1] += 5
        # Left
        if keys[1]:
            playerpos[0] -= 5
        # Right
        elif keys[3]:
            playerpos[0] += 5
        # Move player with JoyStick
        # Up
        if JSkeys[0]:
            playerpos[1] -= 5
        # Down
        elif JSkeys[2]:
            playerpos[1] += 5
        # Left
        if JSkeys[1]:
            playerpos[0] -= 5
        # Right
        elif JSkeys[3]:
            playerpos[0] += 5

        # Win/Lose check
        # Win

        # Lose
        if healthvalue <= 0:
            running = 0
            exitcode = 0
        if acc[1] != 0:
            accuracy = acc[0] * 1.0 / acc[1] * 100
        else:
            accuracy = 0
        # Flip the display
        pygame.display.flip()
    # Stop the music
    pygame.mixer.music.stop()
    # Win/lose display
    # Lose
    if exitcode == 0:
        # Initialize the font
        pygame.font.init()
        # Set font
        font = pygame.font.Font("freesansbold.ttf", 24)
        bigfont = pygame.font.Font("freesansbold.ttf", 48)
        # Render text
        gameover = bigfont.render("Game over!", True, (255, 0, 0))
        gameoverRect = gameover.get_rect()
        gameoverRect.centerx = screen.get_rect().centerx
        gameoverRect.centery = screen.get_rect().centery - 24
        text = font.render("Accuracy: " + str(accuracy) + "%", True,
                           (255, 0, 0))
        textRect = text.get_rect()
        textRect.centerx = screen.get_rect().centerx
        textRect.centery = screen.get_rect().centery + 24
        # Draw red overlay
        for x in range(width / redoverlay.get_width() + 1):
            for y in range(height / redoverlay.get_height() + 1):
                screen.blit(redoverlay, (x * 100, y * 100))
        # Draw text
        screen.blit(gameover, gameoverRect)
        screen.blit(text, textRect)
    # Win
    else:
        # Initialize the font
        pygame.font.init()
        # Set font
        font = pygame.font.Font("freesansbold.ttf", 24)
        bigfont = pygame.font.Font("freesansbold.ttf", 48)
        # Render text
        youwin = bigfont.render("You win!", True, (0, 255, 0))
        youwinRect = youwin.get_rect()
        youwinRect.centerx = screen.get_rect().centerx
        youwinRect.centery = screen.get_rect().centery - 24
        text = font.render("Accuracy: " + str(accuracy) + "%", True,
                           (0, 255, 0))
        textRect = text.get_rect()
        textRect.centerx = screen.get_rect().centerx
        textRect.centery = screen.get_rect().centery + 24
        # Draw green overlay
        for x in range(width / greenoverlay.get_width() + 1):
            for y in range(height / greenoverlay.get_height() + 1):
                screen.blit(greenoverlay, (x * 100, y * 100))
        # Draw text
        screen.blit(youwin, youwinRect)
        screen.blit(text, textRect)
    # Exit automatic when the game is stopped
    while 1:
        waitforexit += 1
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
        if waitforexit == 1000:
            menu.launch()
        # Update the screen
        pygame.display.flip()
Exemple #11
0
#!/usr/bin/env python2
import menu

# Launch menu
menu.launch()
Exemple #12
0
import menu

# Launch menu
menu.launch()
Exemple #13
0
                menu.Option(MULTIPLAYER_LOCAL,"LOCAL",True),
                #menu.Option(HOST,"HOST",True),
                #menu.Option(CONNECT,"CONNECT"),
                menu.Option(MENU,"MAIN MENU")]
     self.state = menu.launch(self.screen,options)
 elif self.state == MULTIPLAYER_LOCAL:
     print "MULTIPLAYER LOCAL"
     try:
         multiplayer.MultiPlayerLocal(self.screen)
     except EndGame, e:
         print e.msg
         self.state = MENU
 elif self.state == HOST:
     print "HOST GAME"
     options = [menu.Option(MULTIPLAYER,"BACK")]
     self.state = menu.launch(self.screen,options)
 elif self.state == CONNECT:
     print "CONNECT TO GAME"
     options = [menu.Option(MULTIPLAYER,"BACK")]
     self.state = menu.launch(self.screen,options)
 elif self.state == INSTRUCTIONS:
     print "INSTRUCTIONS"
     options = [menu.Item("    CONTROLS     "),
                menu.Item(" "),
                menu.Item("    PLAYER 1     "),
                menu.Item("      UP : W     "),
                menu.Item("    DOWN : S     "),
                menu.Item(" "),
                menu.Item("    PLAYER 2     "),
                menu.Item("  UP : UP ARROW  "),
                menu.Item("DOWN : DOWN ARROW"),
Exemple #14
0
    pygame.display.flip()


BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
RED = (255, 192, 203)
BLUE = (176, 196, 222)
YELLOW = (218, 165, 32)

# Initialize Pygame
pygame.init()
pygame.display.set_caption(GAME_TITLE)
screen = pygame.display.set_mode((300, 300))

# Launch the menu and receives instructions over which player starts first
HUMAN_STARTS = menu.launch(screen)

# Launch the game
running = True
while running:

    # AI makes the first move if it starts first
    if not HUMAN_STARTS:
        AI = Player(CODE_PLAYER_1)
        Human = Player(CODE_PLAYER_2)
        board.decide(greedy=True)
    else:
        AI = Player(CODE_PLAYER_2)
        Human = Player(CODE_PLAYER_1)

    # Update the screen
Exemple #15
0
import streamlit as st
import menu as main_menu

if __name__ == "__main__":
    #create the dashboard heading
    st.title('STN Project')
    st.markdown('## Simulate news spreading info over a social network')
    st.markdown('Using data gathered from twitter and simulated')
    st.markdown('<-- Open side menu to run functionalities')

    main_menu.launch()