def you_win():

    win = True

    while win:
        for event in pygame.event.get():
                #print(event)
                if event.type == pygame.QUIT:
                    pygame.quit()
                    quit()

        gameDisplay.fill(white)
        message_to_screen("You won!",green,-100,size="large")
        message_to_screen("Congratulations!",black,-30)



        button("play Again", 150,500,150,50, green, light_green, action="play")
        button("controls", 350,500,100,50, yellow, light_yellow, action="controls")
        button("quit", 550,500,100,50, red, light_red, action ="quit")


        pygame.display.update()

        clock.tick(15)
Example #2
0
def main():
    image=image_pro()
    game=game_body()
    game.gui_start()
    start,end,score=0,1,0
    speech.say("Welcome to swords")
    speech.say("press any key to begin")
    while end:
          start,end=game.start(),game.end()
          #start=game.start()
          #print end
          while start:
              #profile.run('main()')
              time1 = time.time()
              im,posX,posY=image.image_core()
              game.sword_center_draw(im,posX,posY)
              score=game.game_core(posX,posY)
              time2 = time.time()
              #print ((time2-time1)*1000.0),'sec'
              end=game.end()
              start=end
    ''' option for retry'''
    game.gui_end()
    speech.say("final score is "+str(score))
    cv2.destroyAllWindows()
    pygame.quit ()
Example #3
0
def main_menu():
    global screen

    menu_song = pygame.mixer.music.load(path.join(sound_folder, "menu.ogg"))
    pygame.mixer.music.play(-1)

    title = pygame.image.load(path.join(img_dir, "main.png")).convert()
    title = pygame.transform.scale(title, (WIDTH, HEIGHT), screen)

    screen.blit(title, (0,0))
    pygame.display.update()

    while True:
        ev = pygame.event.poll()
        if ev.type == pygame.KEYDOWN:
            if ev.key == pygame.K_RETURN:
                break
            elif ev.key == pygame.K_q:
                pygame.quit()
                quit()
        else:
            draw_text(screen, "Press [ENTER] To Begin", 30, WIDTH/2, HEIGHT/2)
            draw_text(screen, "or [Q] To Quit", 30, WIDTH/2, (HEIGHT/2)+40)
            pygame.display.update()

    #pygame.mixer.music.stop()
    ready = pygame.mixer.Sound(path.join(sound_folder,'getready.ogg'))
    ready.play()
    screen.fill(BLACK)
    draw_text(screen, "GET READY!", 40, WIDTH/2, HEIGHT/2)
    pygame.display.update()
Example #4
0
def terminate():
    """Function to handle the termination of the game.

    This function will make sure the relevant exit calls have been made.
    """
    pygame.quit()
    sys.exit()
Example #5
0
def loop():
    global CAT_POSITION, MICE
    MICE = [Mouse() for i in range(4)]

    while True:
        for e in pg.event.get():
            if e.type == pg.QUIT:
                pg.quit()
                sys.exit()

        # keyboard logic
        key_pressed = pg.key.get_pressed()
        if key_pressed[pg.K_q] == 1 or key_pressed[pg.K_ESCAPE] == 1:
            pg.event.post(pg.event.Event(pg.QUIT))

        if pg.mouse.get_focused():
            CAT_POSITION = set_cat_after_mouse()

        for mouse in MICE:
            if random.randint(0, 30) == 0:
                mouse.direction = random.randint(0, 3)
            mouse.run_away()

        if len(MICE) > 0 and len(MICE) <= 23 and random.randint(0, 50) == 0:
            new_mouse = Mouse()
            new_mouse.position = MICE[-1].position
            MICE.append(new_mouse)

        draw()
        clock.tick(24)
Example #6
0
    def main_loop(self):
        while 1:
            self.clock.tick(40)
            events = pygame.event.get()
            self.menu.update(events)
            for e in events:
                if e.type == QUIT:
                    pygame.quit()
                    return
                if e.type == KEYDOWN and e.key == K_ESCAPE:
                    pygame.quit()
                    return

            self.screen.blit(self.bg, (0, 0))
            ren = self.font.render("", 1, (255, 255, 255))
            self.screen.blit(ren, (320 - ren.get_width() / 2, 70))

            ren = self.font2.render("SYSTEM-TUX", 1, (255, 255, 255))
            self.screen.blit(ren, (320 - ren.get_width() / 2, 180))

            ren = self.font2.render("Python", 1, (255, 255, 255))
            self.screen.blit(ren, (320 - ren.get_width() / 2, 235))

            self.menu.draw(self.screen)
            pygame.display.flip()
def main():
    """ Main program function. """
    # Initialize Pygame and set up the window
    pygame.init()

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

    pygame.display.set_caption("My Game")
    pygame.mouse.set_visible(False)

    # Create our objects and set the data
    done = False
    clock = pygame.time.Clock()

    # Create an instance of the Game class
    game = Game()

    # Main game loop
    while not done:

        # Process events (keystrokes, mouse clicks, etc)
        done = game.process_events()

        # Update object positions, check for collisions
        game.run_logic()

        # Draw the current frame
        game.display_frame(screen)

        # Pause for the next frame
        clock.tick(60)

    # Close window and exit
    pygame.quit()
Example #8
0
    def run(self):
        self.seconds = 0.0
        self.clearScreen()
        self.delay = 10
        folderName = "random"
        fileIndex = 0

        # print "Hello:"
        while True: 
            self.input(pygame.event.get())
            i = self.curveSet.drawPoints()
            if (self.seconds >= 20000.0) | (i == -1):
                print "Seconds: ", self.seconds
                self.saveScreen(fileIndex, folderName)
                self.clearScreen()
                self.curveSet.selectCurves()
                self.seconds = 0.0
                fileIndex += 1

            pygame.time.wait(self.delay)
            self.seconds = self.seconds + 1.0
            pygame.display.flip()
         
        pygame.quit()   
        pygame.exit()
Example #9
0
def game_intro():
    intro = True
    while intro :
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
                
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_c:
                    intro = False
                if event.key == pygame.K_q:
                    pygame.quit()
                    quit()
                    
        gameDisplay.fill(white)
        message_to_screen("Welcome to Sliter",
                          green,
                          -100,
                          size="large")
        message_to_screen("The objective of the game is to eat red apples",
                          black,
                          -30)
        message_to_screen("The more apples you eat, the longer you get",
                          black,
                          10)
        message_to_screen("if you run into yourself, or the edges, you die!",
                          black,
                          50)
        message_to_screen("Press C to play or Q to quit.",
                          black,
                          180)
        pygame.display.update()
        clock.tick(15)                        
def main():

	pygame.init()
	globals.pygame = pygame # assign global pygame for other modules to reference
	globals.inputs = Inputs(pygame) # assign global inputs for other modules to reference
	update_display_mode() # now that the global display properties have been set up, update the display
	clock = pygame.time.Clock() # clock to tick / manage delta

	entities = [] # contains every object that will be drawn in the game

	entities.append(Entity()) # our testing entity will be the default entity

	loop = True # for controlling the game loop

	while(loop):
		clock.tick(60) # tick the clock with a target 60 fps
		globals.window.fill((255, 255, 255))

		globals.inputs.update() # refresh inputs

		update(entities) # update all entities
		render(entities) # draw all entities

		if(globals.inputs.isKeyDown("space")): toggle_fullscreen() # space bar toggles fullscreen
		if(globals.inputs.isKeyDown("escape")): loop = False # escape key exits game
		if(globals.inputs.isQuitPressed()): loop = False # red 'x' button exits game

		pygame.display.flip() # flip the display, which finally shows our render

	pygame.quit() # unload pygame modules
Example #11
0
    def run(self):
        """The mainloop
        """
        running = True
        while running:
            # handle any events
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False 
                elif event.type == pygame.KEYDOWN:
                    if event.key == pygame.K_ESCAPE:
                        running = False
            # Clean the background
            self.background.fill((255, 255, 255)) # fill background white
            if SHOW_TIME:
                self.playtime += self.clock.tick(self.fps) / 1000.0
                self.draw_text(self.time_font, "FPS: {:6.3} {:6.3} sec.".format(self.clock.get_fps(), self.playtime), (15, self.h - 15))
            # get all game-state from cpp-engine
            
            # update all objects' position, color, etc.
            self.stash_balls()

            # finally, update screen
            pygame.display.flip()
            self.screen.blit(self.background, (0, 0))          
        pygame.quit()
Example #12
0
	def run(self):
		# Main Game Loop
		while self.done == False:
			# Limit FPS of Game Loop
			self.clock.tick(30)
			
			# Check for Events
			for event in pygame.event.get(): 
				# Quit Game
				if event.type == pygame.QUIT:
					printDebug("PyGame.Quit Called.")
					self.done = True
					
			# Clear the Screen
			self.screen.fill(white)
			
			# Try to Draw Background at (0,0)
			if self.background_image != None: 
				self.screen.blit( self.background_image, [0,0])
				
			# Draw all Sprites
			for sprite in self.sprites:
				sprite.render(self.screen)
			
			# Update Display
			pygame.display.flip()
		# End Main Game Loop
			
		# Exit Program
		printDebug("PyGame Exit.")
		pygame.quit()
Example #13
0
def main():
    # change the current directory to the one of the game
    # this is to allow executions like ``python src/tct.py''
    try:
        os.chdir(os.path.abspath(os.path.dirname(sys.argv[0])))
    except IOError as e:
        print(e)
        exit(constants.FILE_ERR)

    # get the command line options; return the option flags
    game_opts = get_parsed_opts()

    # MVC stuff
    event_manager = EventManager()
    gui_view = MainGUIView(event_manager, game_opts)

    # the game manager
    game_manager = GameManager(game_opts)

    # controller which handles the main game loop
    main_controller = MainController(event_manager, gui_view, game_manager)

    # keep running the game until a quit event occurs
    main_controller.run()

    # if control somehow reaches this point close all the pygame subsystems
    pygame.quit()
    safe_exit()
Example #14
0
def mainloop(display, framerate):
    """Runs a pygame / planes main loop.
       framerate is the framerate.
       This must be run in the main thread, otherwise pygame.event will not
       receive any events under MS Windows.
    """

    print("about to start main loop")

    clock = pygame.time.Clock()

    while True:
        events = pygame.event.get()

        for event in events:

            if event.type == pygame.QUIT:
                print("got pygame.QUIT, terminating in mainloop()")
                pygame.quit()
                raise SystemExit

        display.process(events)
        display.update()
        display.render()

        pygame.display.flip()

        # Slow down to framerate given
        #
        clock.tick(framerate)

    return
def main():
    "draw loop"

    # Initial robot state
    origin_x, origin_y = 0.0, 0.0

    arm = DebraArm.DebraArm(l1=L1, l2=L2, flip_x=1)
    arm.inverse_kinematics(RobotSpacePoint(0.99*(L1+L2), 0, 0, 0))
    tool = arm.get_tool()
    joints = arm.get_joints()

    # Draw robot
    origin, p1, p2, p3, z = arm.get_detailed_pos(L3)
    draw_arm(origin, p1, p2, p3, RANGE_MIN, RANGE_MAX)

    pygame.display.update()

    paused = False
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                sys.exit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_p:
                    paused = not paused
            if event.type == pygame.MOUSEBUTTONUP:
                x, y = get_cursor_pos()
                tool_prev = tool
                tool = RobotSpacePoint(x, y, z, GRIPPER_HEADING)

                if MODE == PLAN_JOINT_SPACE:
                    start_time = time.time()
                    pth1, pth2, pz, pth3 = arm.get_path(tool_prev,
                                                        RobotSpacePoint(0,0,0,0),
                                                        tool,
                                                        RobotSpacePoint(0,0,0,0),
                                                        DELTA_T)
                    elapsed_time = time.time() - start_time
                    print('elapsed time: ', elapsed_time)
                else:
                    start_time = time.time()
                    pth1, pth2, pz, pth3, px, py, pz, pgrp = \
                        arm.get_path_xyz(tool_prev, RobotSpacePoint(0,0,0,0),
                                         tool, RobotSpacePoint(0,0,0,0),
                                         DELTA_T, 'all')
                    elapsed_time = time.time() - start_time
                    print('elapsed time: ', elapsed_time)
                    graph_trajectory_xyz(px, py, pz, pgrp)
                    graph_trajectory_joint(pth1, pth2, pth3)

                draw_trajectory(arm, pth1, pth2, pz, pth3, DELTA_T)

        if not paused:
            SCREEN.fill(BLACK)

            origin, p1, p2, p3, z = arm.get_detailed_pos(L3)
            draw_arm(origin, p1, p2, p3, RANGE_MIN, RANGE_MAX)

            pygame.display.update()
Example #16
0
def main():
    pygame.init()
    display = (800, 600)
    pygame.display.set_mode(display, DOUBLEBUF | OPENGL)

    gluPerspective(45, (display[0] / display[1]), 0.1, 50.0)
    glTranslatef(0.0, 0.0, -5)

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_q or event.key == pygame.K_ESCAPE:
                    pygame.quit()
                    quit()
                if event.key == pygame.K_LEFT:
                    glTranslatef(-0.5, 0, 0)
                if event.key == pygame.K_RIGHT:
                    glTranslatef(0.5, 0, 0)
                if event.key == pygame.K_UP:
                    glTranslatef(0, 1, 0)
                if event.key == pygame.K_DOWN:
                    glTranslatef(0, -1, 0)
            if event.type == pygame.MOUSEBUTTONDOWN:
                if event.button == 1:
                    glTranslatef(0, 0, 1.0)
                if event.button == 3:
                    glTranslatef(0, 0, -1.0)

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
        Cube()
        pygame.display.flip()
        pygame.time.wait(10)
Example #17
0
def main():
	width = 800;
	height = 600;
	title = "Swept AABB";

	fps = 60;
	fpsClock = pygame.time.Clock();

	pygame.init();
	displaySurface = pygame.display.set_mode((width, height));
	pygame.display.set_caption(title);

	player = Box(10, 300, 50, 50, 0, 0);
	moveSpeed = 10;
	wall = Box(300, 200, 100, 200, 0, 0);

	gameRunning = True;
	while (gameRunning):
		for event in pygame.event.get():
			if (event.type == QUIT):
				gameRunning = False;

		getInput(player, moveSpeed);
		doCollision(player, wall);
		render(displaySurface, player, wall);

		pygame.display.update();
		fpsClock.tick(fps);

	pygame.quit();
	sys.exit();
Example #18
0
	def checkForEvent(self):
		global selected_mode, voltage_range, resistance_range
		
		for event in pygame.event.get(): # event handling loop
			if event.type == pygame.QUIT or (event.type == KEYUP and event.key == K_ESCAPE):
				pygame.quit()
				sys.exit()
			elif event.type == MOUSEBUTTONDOWN:
				if self.Exit.pressed(pygame.mouse.get_pos()):
					pygame.quit()
					sys.exit()
				elif self.ButtonRaw.pressed(pygame.mouse.get_pos()):
					selected_mode = 0
				elif self.ButtonPercentage.pressed(pygame.mouse.get_pos()):
					selected_mode = 1
				elif self.ButtonVoltage.pressed(pygame.mouse.get_pos()):
					selected_mode = 2
				elif self.ButtonResistance.pressed(pygame.mouse.get_pos()):
					selected_mode = 3
			elif event.type == MOUSEBUTTONUP:	
				if 'click' in self.VoltageInputBox.handleMouseEvent(event):
					pass
				if 'click' in self.ResistanceInputBox.handleMouseEvent(event):
					pass
			elif event.type == KEYUP:
				if self.VoltageInputBox.handleKeyEvent(event):
					voltage_range = int(''.join(self.VoltageInputBox.inputtext))
				if self.ResistanceInputBox.handleKeyEvent(event):
					resistance_range = int(''.join(self.ResistanceInputBox.inputtext))
Example #19
0
 def start(self, race_object):
     self.logger.debug("start in Needles plugin")
     self.logger.debug("race object sent to plugin:")
     self.logger.debug(race_object)
     
     self.race_object = race_object
     self.render()
     
     clock = pygame.time.Clock()
     while True:
       clock.tick(50)
       
       for event in pygame.event.get():
           if event.type == pygame.locals.KEYUP:
               if event.key == pygame.locals.K_ESCAPE:
                   pygame.quit()
                   sys.exit()
               elif event.key == pygame.locals.K_a:
                   if (self.race_object):
                       participant = self.race_object.participants[0]
                       participant.increase_distance()
                       self.logger.debug(self.race_object.participants[0].get_distance())
                       #print self.race_object.elapsed_time()
               elif event.key == pygame.locals.K_s:
                   if (self.race_object):
                       participant = self.race_object.participants[1]
                       participant.increase_distance()
                       self.logger.debug(self.race_object.participants[1].get_distance())
                       #print self.race_object.elapsed_time()
     
       # Clear the screen
       #self.display_surface.fill((0, 0, 0))
       
       self.update()
Example #20
0
File: menu.py Project: kjwilcox/hex
    def __del__(self):
        """ Stuff to do when we are totally done. """

        self.sounds.stop_music()

        # finished with pygame, make sure the window gets closed
        pygame.quit()
Example #21
0
def test():
    pygame.init()
    screen = pygame.display.set_mode((1280, 720))
    width = 1280
    height = 720
    pygame.display.set_caption('Dirty Blitting')
    a = LoadingBar(screen, 'a')
    loop = True
    b = 0
    counter = 0
    while loop and b<100:
        a.update(1)
        time.sleep(.2)
        for event in pygame.event.get():
            if event.type == QUIT:
                    loop = False
            elif event.type == KEYDOWN and event.key == K_ESCAPE:
                    loop = False
        for i in range(3):
            pygame.image.save(screen, "image\image{c}.jpg"
                          .format (c = counter))
            counter += 1
        b+=1
    
    pygame.quit()   
def main():
    must_quit = False
    cursor = 0
    screen = pygame.display.set_mode((640, 480))
    cursor_visible = True
    
    init_mice(screen.get_width(), screen.get_height())
    
    while not must_quit:
        for e in pygame.event.get():
            if e.type == pygame.locals.QUIT:
                must_quit = True
            elif e.type == pygame.locals.KEYDOWN:
                if e.key == pygame.locals.K_ESCAPE:
                    must_quit = True
                elif e.key == pygame.locals.K_g:
                    pygame.event.set_grab(not pygame.event.get_grab())
                elif e.key == pygame.locals.K_s:
                    cursor_visible = not cursor_visible
                    pygame.mouse.set_visible(0)
                elif e.key == pygame.locals.K_r:
                    manymouse.quit()
                    init_mice(screen.get_width(), screen.get_height())
        update_mice(screen.get_width(), screen.get_height())
        draw_mice(screen)
        
    manymouse.quit()
    pygame.quit()
Example #23
0
def event_handler():
	for event in pygame.event.get():
		# if [esc] or [x] pressed...
		if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
			# ... then quit!
			pygame.quit()
			sys.exit() 
Example #24
0
def deadText():
    x=300
    y=350
    length=200
    height=50
    
    font = pygame.font.SysFont("monospace", 120)
    font_small=pygame.font.SysFont("monospace",30)
    
    label=font.render("You Died!", 1,black)
    label_small=font_small.render("Press enter to continue", 1, red)
    
    setDisplay.blit(label, (100,200))
    setDisplay.blit(label_small, (200,350))

    #pygame.draw.rect(setDisplay, black, (x,y,length,height))
    pygame.display.update()
    pygame.time.wait(1000)
    while True:
        for event in pygame.event.get():
            #print event
            if event.type == MOUSEBUTTONDOWN:
                print "click"
                mouseClickRepeat(pygame.mouse.get_pos(),x, y, length, height)
            if event.type == KEYDOWN:
                runGame()
                
            if event.type == QUIT:
                pygame.quit()
                sys.exit()
Example #25
0
 def GetInput(self):
     keystate = pygame.key.get_pressed()
     for event in pygame.event.get():
         if event.type == QUIT or keystate[K_q]:
             pygame.quit(); sys.exit()
     self.player.speed[0] *= 0.995
     self.player.speed[1] *= 0.995
     if self.player.accel > 0.007:
         self.player.accel *= 0.99
     if keystate[K_LEFT]:
         self.player.rot += 1.0
         if self.player.rot > 360:
             self.player.rot = 0
     if keystate[K_RIGHT]:
         self.player.rot -= 1.0
         if self.player.rot < 0:
             self.player.rot = 359
     if keystate[K_UP]:
         self.player.accel += self.player.accel_append;
         self.player.speed[0] += self.player.accel*sin(radians(self.player.rot))
         self.player.speed[1] += self.player.accel*cos(radians(self.player.rot))
     if keystate[K_DOWN]:
         self.player.accel = 0.007
         self.player.speed[0] *= 0.993
         self.player.speed[1] *= 0.993
     if keystate[K_SPACE]:
         if not self.player.fired and not self.player.dead:
             self.player.shoot()
     if keystate[K_ESCAPE]:
         if not self.player.dead:
             self.teleportPlayer()
     if keystate[K_r]:
         self=aGame()
         self.eventLoop()
Example #26
0
def main():
    SCALE = 10 # pixels per meter
    pygame.init()
    screen = pygame.display.set_mode((800,600))
    screenWidth,screenHeight = screen.get_size()
    worldSize = np.array(screen.get_size())/SCALE
    pygame.display.set_caption("Newton World")
    screen.fill((255,255,255))
    pygame.display.flip()
    
    world = NewtonWorld("NewtonWorld",screen,framesPerSecond=40,scale=SCALE)
    
    #square = MouseTracker(world,position=worldSize/2,mass=1)
    #world.add(square)
    
    paddleImage = pygame.Surface((30,120))
    paddleImage.fill(pygame.Color('red'))
    paddle1 = MouseTracker1DOF(world,position=worldSize/2-(38,0),mass=1,image=paddleImage)
    paddle1.set_dof('y')
    world.add(paddle1)
    #paddle2 = MouseTracker1DOF(world,position=worldSize/2+(38,0),mass=1,image=paddleImage)
    #paddle2.set_dof('x')
    #paddle2.set_k(10,100)
    #world.add(paddle2)
   
   
    world.unpause()
    world.run_main_loop()
    pygame.quit()
Example #27
0
def main(version):
    pygame.init()
    with DataFile('settings.json', get_settings, json, False) as settings:
        page = mainmenu.MainMenu()
        text._set_lang(settings['lang'])
        loop(settings, version, page)
    pygame.quit()
def main_menu():
    meh = True
    def broken():
        global meh
        print("this is broken")
    new_game_btn = Button(325, 250, 150, 75, None, green, greenHightlight, black, "Play")
    load_save_game = Button(150, 482, 500, 75, None, green, greenHightlight, black, "Load Save Game")
    mapBtn = Button(175, 366, 450, 75, None, blue, blueHightlight, black, "Map Creator")
    settingsBtn = Button(0, 525, 250, 75, None, black, grey, white, "Settings")
    while meh:

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
        gameDisplay.fill(white)

        new_game_btn.run(mediumFont, create_character)
        # 2 is not broken. Just have to do editor
        mapBtn.run(mediumFont, map_editor)
        settingsBtn.run(mediumFont, none)
        load_save_game.run(mediumFont, none)
        if new_game_btn.is_clicked():
            meh = False

        pygame.display.update()
        clock.tick(30)
Example #29
0
  def handleEvents(self):

    # Handle events, starting with the quit event
    for event in pygame.event.get():
      if event.type == QUIT:
        pygame.quit()
        sys.exit()

      if event.type == KEYDOWN:
        # Find which key was pressed and start moving appropriate bat
        if event.key == K_ESCAPE:
          pygame.quit()
          sys.exit()
        #elif event.key == K_w:
        elif event.key == K_DOWN:
          self.shape.lessSides()
        elif event.key == K_UP:
          self.shape.moreSides()
        elif event.key == K_LEFT:
          self.shape.rotateLeft()
        elif event.key == K_RIGHT:
          self.shape.rotateRight()
        elif event.key == K_SPACE:
          self.surface.fill(colors.BLACK)
        elif event.key == K_a:
          self.shape.colorUp()
        elif event.key == K_z:
          self.shape.colorDn()
Example #30
0
def joystick(timeout=-1):
    running = True
    if timeout != -1:
        timeout = timeout * 1000000
    
    startTime = datetime.datetime.now()
    while running:        
        for event in pygame.event.get():
            if event.type == KEYUP:            
                jPressed = handle_event(event)
                running = False

            if event.type == QUIT:
                pygame.quit()
                quit()
                
            
        
        if timeout != -1:
            endTime = datetime.datetime.now()
            totalTime = endTime - startTime
            
            if totalTime.microseconds >= timeout:
                return "NONE"
        
    return jPressed
Example #31
0
def main():
    # create the grid of cell objects
    grid = []
    for y in range(ROWS):
        for x in range(COLS):
            grid.append(cell(x, y))
    #make the grid
    for box in grid:
        box.show()
    #color in the padding
    pygame.draw.rect(WIN, (243,244,237), pygame.Rect(0,0, WIN_WIDTH, PADDING))

    # PHASE 1 (choosing algorithim) #
    # color, x, y, width, height, font, font_size, text=""
    BFS_button = algorithim_button(BLUE, (WIN_WIDTH / 3 * 1) / 2 - 120, PADDING / 2 - 40, 240, 80, "comicsans", 60, "BFS")
    a_star_button = algorithim_button(BLUE, (WIN_WIDTH / 3 * 2) - (WIN_WIDTH / 3 / 2) - 120, PADDING / 2 - 40, 240, 80, "comicsans", 60, "A*")
    dijkstra_button = algorithim_button(BLUE, (WIN_WIDTH / 3 * 3) - (WIN_WIDTH / 3 / 2) - 120, PADDING / 2 - 40, 240, 80, "comicsans", 60, "dijkstra")

    buttons = [BFS_button, a_star_button, dijkstra_button]
    
    clock = pygame.time.Clock()
    phase_1 = True
    algorithim = ""

    while phase_1:
        BFS_button.draw(WIN)
        a_star_button.draw(WIN)
        dijkstra_button.draw(WIN)
        pygame.display.update()

        # events    
        for event in pygame.event.get():
            coords = pygame.mouse.get_pos()
        
            if event.type == pygame.QUIT:
                pygame.quit()
            if event.type == pygame.MOUSEBUTTONDOWN:
                for button in buttons:
                    if button.isOver(coords):
                        print("clicked the button")
                        button.color = GREEN
                        # Make it green
                        button.draw(WIN)
                        pygame.display.update()

                        algorithim = str(button)
                        print(algorithim)
                        phase_1 = False

            if phase_1 != False:
                if event.type == pygame.MOUSEMOTION:
                    for button in buttons:
                        if button.isOver(coords):
                            button.color = DARKER_BLUE
                        else:
                            button.color = BLUE


    visited = []
    stack = []
    current = grid[0]
    remove_wall = False

    # PHASE 2 (maze generation) #
    phase_2 = True
    while phase_2:
        clock.tick(FPS)

        # events    
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()

        # what happens each frame
        visited.append(current)
        draw_frame(current)
        stack.append(current)

        next_cell, direction = current.pick_next(current, grid, visited)
        last_cell = current

        while next_cell == -1:    
            clock.tick(FPS)
            stack.pop()
            if len(stack) < 1:
                break
            current = stack[len(stack) - 1]
            last_cell = current
            next_cell, direction = current.pick_next(current, grid, visited)
            draw_frame(current)
            #current = last_cell
            
        
        if next_cell != -1:
            current = next_cell
            remove_line(last_cell, current, direction)
        if len(stack) < 1:
            phase_2 = False

    game_pause = True
    while game_pause == True:
        clock.tick(FPS)
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                game_pause = False
Example #32
0
 def on_cleanup(self):
     pygame.quit()
Example #33
0
pygame.time.set_timer(pygame.USEREVENT, 1000)
direction = 1
running = True
while running:
    for event in pygame.event.get():
        #扫描QUIT事件
        if event.type == QUIT:
            running = False
        #扫描KEY事件
        # elif event.type == KEYDOWN:
        #     if event.key == pygame.K_UP:
        #         my_ball.rect.top = my_ball.rect.top - 10
        #     elif event.key == pygame.K_DOWN:
        #         my_ball.rect.top = my_ball.rect.top + 10
        #扫描鼠标事件
        # elif event.type == MOUSEMOTION:
        #     my_ball.rect.center = event.pos
        #扫描定时器
        elif event.type == USEREVENT:
            my_ball.rect.centery = my_ball.rect.centery + (30 * direction)
            if my_ball.rect.top < 0 or my_ball.rect.bottom > screen.get_rect(
            ).bottom:
                direction = -direction

        clock.tick(30)
        screen.blit(background, (0, 0))
        my_ball.move()
        screen.blit(my_ball.image, my_ball.rect)
        pygame.display.flip()
pygame.quit()
Example #34
0
def demo_pygame(file_name,frm):

    # parser the map (it is done here to initialize the
    # window the same size as the map if it is small enough)
    world_map = tiledtmxloader.tmxreader.TileMapParser().parse_decode(file_name)

    # init pygame and set up a screen
    pygame.display.set_caption("tiledtmxloader - " + file_name + \
                                                        " - keys: arrows, 0-9")
    screen_width = min(1024, world_map.pixel_width)
    screen_height = min(768, world_map.pixel_height)
    screen = pygame.display.set_mode((screen_width, screen_height))

    # load the images using pygame
    resources = tiledtmxloader.helperspygame.ResourceLoaderPygame()
    resources.load(world_map)

    # prepare map rendering
    assert world_map.orientation == "orthogonal"

    # renderer
    renderer = tiledtmxloader.helperspygame.RendererPygame()

    #background music
    battlefield_sound = sound.create_music(file_name)
    
    # create hero
    hero_pos_x = 10*32
    hero_pos_y = 41*32
    hero = person.create_person(hero_pos_x, hero_pos_y,'./images/hero_u2.png')
    
    # create enemy sprites
    enm = []
    enm.append(person.create_person(10*32, 3*32,'./images/haabu_d1.png'))
    enm.append(person.create_person(14*32, 3*32,'./images/haabu_d1.png'))
    enm.append(person.create_person(10*32, 7*32,'./images/haabu_d1.png'))
    enm.append(person.create_person(14*32, 7*32,'./images/haabu_d1.png'))

    # create dragon sprite
    dragon = person.create_person(10*32, 27*32,'./images/dragon_d1.png')
    
    # cam_offset is for scrolling
    cam_world_pos_x = 520
    cam_world_pos_y = 1050

    # set initial cam position and size
    renderer.set_camera_position_and_size(cam_world_pos_x, cam_world_pos_y, \
                                        screen_width, screen_height)

    # retrieve the layers
    sprite_layers = tiledtmxloader.helperspygame.get_layers_from_map(resources)

    # filter layers
    sprite_layers = [layer for layer in sprite_layers if not layer.is_object_group]

    # add the hero and enemies the the right layer
    sprite_layers[1].add_sprite(hero)
    sprite_layers[1].add_sprite(dragon)
    i = 0
    for i in range(len(enm)):
        sprite_layers[1].add_sprite(enm[i])
    
    # variables for the main loop
    clock = pygame.time.Clock()
    running = True # to run while loop
    speed = 7  # hero speed 
    mr=ml=md=mu=0  # image variables(change images to show movements of hero)
    
    tic_flag = 0
    drctn='down' # direction where hero facing right now
    life = 1 # to keep track wheather hero is alive or not
    arrow_list = [] # contains a list of arrows (currently on screen)
    arrow_dir = [] # directions of arrows
    enm_dir = [0,0,0,0]
    drag = [dragon]
    dx_dragon = [0]
    image_variable = [0]
    weap_dir = [] # directions of weapons 
    weap_list = [] # contains a list of weapons (currently on screen)
    color_change = 0 # a color variable for dragon
    dy_dragon = [1] # dragon direction
    specialarrow_list = [] # contains a list of specialarrows (currently on screen)
    specialarrow_dir = [] # directions of specialarrows
    dragonimages = ['./images/dragon_d1.png','./images/dragon_d2.png','./images/dragon_d3.png','./images/dragon_u1.png','./images/dragon_u2.png','./images/dragon_u3.png']
    enemyimages = ['./images/haabu_d1.png','./images/haabu_d2.png','./images/haabu_d3.png','./images/haabu_u1.png','./images/haabu_u2.png','./images/haabu_u3.png']
    chk = 0

    HP_ENM = [100.0,100.0,100.0,100.0] # health of enemies
    HP_DRAGON = [100.0] # health of dragon
    SPECIALARROW = 5    
    point_weapon = 1.0   # decrease in health of hero when weapon OR haabu collides with hero  ## HAABU MEANS ENEMY (in HINDI)
    point_arrow = 20.0    # arrow enemy collision
    point_dragon = 5.0    # hero dragon collision
    point_specialarrow = 10.0  # specialarrow hero collision
    haabu_speed = 6
    dragon_speed = 8

    #old variables to restore if hero dies in this map
    savegame=pk.load(open("./save.p","rb"))
    old_xp = savegame['xp']
    old_level = savegame['h_level']
    old_armor = savegame['sheild_hp']
    old_arrow = savegame['arrow_count']

     # interface code
    c_pos=[cam_world_pos_x, cam_world_pos_y]
    interface=menu.create_interface(renderer,sprite_layers,screen,c_pos) 
    hp_sprite=person.create_person(c_pos[0],c_pos[1],'./images/hp_bar.png') # hp bar interface
    l_g=menu.create_l_g(renderer,sprite_layers,screen,c_pos) # level and gold interface
    [hp_sprite,hp]=menu.create_hp_bar(renderer,sprite_layers,screen,hp_sprite,c_pos) 
    xp_sprite=person.create_person(c_pos[0],c_pos[1],'./images/exp_bar.png') # xp interface
    xp_sprite=menu.create_xp_bar(renderer,sprite_layers,screen,xp_sprite,c_pos)
    s_a=menu.create_s_a(renderer,sprite_layers,screen,c_pos)
    f_i=menu.create_f_i(renderer,sprite_layers,screen,c_pos) # arrow,armor,sword interface
    interf_fight=menu.create_interface_fight(renderer,sprite_layers,screen,c_pos)
    spec_interf=menu.create_interface_spec_arrow(renderer,sprite_layers,screen,c_pos)

    d_hp=menu.create_interface_dragon(renderer,sprite_layers,screen,c_pos)
    dhp_sprite=person.create_person(c_pos[0]-400,c_pos[1],'./images/dragon_health.png') #dragon health interface
    dhp_sprite=menu.create_dragon_hp(renderer,sprite_layers,screen,dhp_sprite,c_pos,HP_DRAGON)
    
    # set up timer for fps printing
    pygame.time.set_timer(pygame.USEREVENT, 1000)

    # mainloop
    while running:
        dt = clock.tick(70)
        savegame=pk.load(open("./save.p","rb"))

        # keep adding a group of four enemies after dying previous group
        if len(enm)==0: 
            color_change += 1
            enm.append(person.create_person(10*32, 3*32,'./images/haabu_d1.png'))
            enm.append(person.create_person(14*32, 3*32,'./images/haabu_d1.png'))
            enm.append(person.create_person(10*32, 7*32,'./images/haabu_d1.png'))
            enm.append(person.create_person(14*32, 7*32,'./images/haabu_d1.png'))
            HP_ENM = [100.0,100.0,100.0,100.0]
            enm_dir = [0,0,0,0]
            i = 0
            for i in range(len(enm)):
                sprite_layers[1].add_sprite(enm[i])

        # dragon can be killed only if it is of orange color and only by specialarrows
        # five specialarrows are provided when dragon becomes orange
        if color_change%2==0:
            SPECIALARROW = 0
            chk = 0
            dragonimages = ['./images/dragon_d1.png','./images/dragon_d2.png','./images/dragon_d3.png','./images/dragon_u1.png','./images/dragon_u2.png','./images/dragon_u3.png']
        else:
            if chk == 0: 
                SPECIALARROW = 5
            chk = 1
            dragonimages = ['./images/orange_d1.png','./images/orange_d2.png','./images/orange_d3.png','./images/orange_u1.png','./images/orange_u2.png','./images/orange_u3.png']
            #spec_arrow_interf
            menu.update_s_a(s_a,c_pos,SPECIALARROW)
        # event handling
        for event in pygame.event.get():
            if (event.type == pygame.QUIT):
                running = False
            elif event.type == pygame.KEYDOWN:
                if event.key == pygame.K_w and savegame['arrow_count'] > 0:
                    enemy_attack.create_arrow(arrow_list,arrow_dir,drctn,hero,sprite_layers) # create arrow on pressing 'w'
                    haabu_remove(enm,HP_ENM,sprite_layers,enm_dir)  # remove enemy sprite if health bacomes zero
                    savegame['arrow_count'] -=1 # decrease the arrow count and update in the dictionary
                    pk.dump(savegame,open("./save.p","wb")) # save the changes of dictionary
                elif event.key == pygame.K_a:
                    # attack with sword on pressing 'a'
                    enemy_attack.attack(drctn,hero,enm,HP_ENM)
                    haabu_remove(enm,HP_ENM,sprite_layers,enm_dir)
                elif event.key == pygame.K_s and color_change%2!=0 and SPECIALARROW > 0:
                    # attack with specialarrow on pressing 's'
                    enemy_attack.create_specialarrow(specialarrow_list,specialarrow_dir,drctn,hero,sprite_layers)
                    SPECIALARROW -= 1
                    
                # interface update
                menu.update_lg(l_g,c_pos)
                menu.update_hp_bar(renderer,sprite_layers,screen,hp_sprite,c_pos,0)
                menu.update_xp_bar(renderer,sprite_layers,screen,xp_sprite,c_pos,0)
                menu.update_f_i(f_i,c_pos)
                menu.update_dhp_bar(renderer,sprite_layers,screen,dhp_sprite,c_pos,HP_DRAGON)
                
                if(color_change%2==1):
                    menu.update_s_a(s_a,c_pos,SPECIALARROW)

        # calling hero_move() function for hero's movements
        mov = movements1.hero_move(mr,ml,md,mu,hero_pos_x,hero_pos_y,hero,speed,sprite_layers[3])
        mr = mov[0]
        ml = mov[1]
        md = mov[2]
        mu = mov[3]
        hero_pos_x = mov[4]
        hero_pos_y = mov[5]

        # to detect the direction of hero
        if(mu>1):
            drctn='up'
        elif(mr>1):
            drctn='right'
        elif(md>1):
            drctn='down'
        elif(ml>1):
            drctn='left'

        haabu_move(hero,enm,enm_dir,enemyimages,haabu_speed) # random movement of enemy
        haabu_remove(enm,HP_ENM,sprite_layers,enm_dir)# remove enemy if health of enemy becomes zero
        
        if(color_change%2==0):enemy_attack.create_weapons(weap_list,sprite_layers,drag,weap_dir,dy_dragon,1) # create the weapons only if it is not of orange color
        enemy_attack.remove_weapon(hero,enm,weap_list,weap_dir,point_weapon,sprite_layers)

        # interface update
        menu.update_lg(l_g,c_pos)
        menu.update_hp_bar(renderer,sprite_layers,screen,hp_sprite,c_pos,0)
        menu.update_xp_bar(renderer,sprite_layers,screen,xp_sprite,c_pos,0)
        menu.update_f_i(f_i,c_pos)
        menu.update_dhp_bar(renderer,sprite_layers,screen,dhp_sprite,c_pos,HP_DRAGON)
        
        enemy_attack.move_enemy(drag,[19*32],[1*32],dx_dragon,dragon_speed)# random movement of dragon
        enemy_attack.dir_update(drag,hero,dy_dragon) # direction update of enemy
        enemy_attack.image_update(drag,image_variable,dy_dragon,dragonimages) # image update of enemy

        enemy_attack.remove_arrow(arrow_list,enm,HP_ENM,arrow_dir,sprite_layers,point_arrow) # removes arrow from the screen
        enemy_attack.remove_arrow(specialarrow_list,drag,HP_DRAGON,specialarrow_dir,sprite_layers,point_specialarrow) # removes specialarrow from the screen

        # decrease health of hero if it colldes with dragon
        if pygame.sprite.collide_rect(hero,drag[0]):
            weap_sound = sound.create_soundfx('./sounds/weapon_touch.ogg')
            sound.volume(weap_sound,0.4)
            savegame=pk.load(open("./save.p","rb"))
            savegame['hp'] -= point_dragon
            pk.dump(savegame,open("./save.p","wb"))
            
        # game starts again if player dies
        if savegame['hp'] <= 0:
            sound.stop_soundfx(battlefield_sound)
            savegame['xp'] = old_xp
            savegame['h_level'] = old_level
            savegame['sheild_hp'] = old_armor
            savegame['arrow_count'] = old_arrow
            savegame['hp'] = savegame['max_hp']
            pk.dump(savegame,open("./save.p","wb"))
            menu.update_hp_bar(renderer,sprite_layers,screen,hp_sprite,c_pos,0)
            life = 0
            running = False

        # Game ends!
        # clean the screen!
        if HP_DRAGON[0] <= 0:
            i = 0
            l = len(enm)
            while(i>=0 and i<l):
                sprite_layers[1].remove_sprite(enm[i])
                enm.pop(i)
                l = len(enm)
            i = 0
            l = len(weap_list)
            while(i>=0 and i<l):
                sprite_layers[2].remove_sprite(weap_list[i])
                weap_list.pop(i)
                l = len(weap_list)
            i = 0
            l = len(arrow_list)
            while(i>=0 and i<l):
                sprite_layers[1].remove_sprite(arrow_list[i])
                arrow_list.pop(i)
                l = len(arrow_list)
            i = 0
            l = len(specialarrow_list)
            while(i>=0 and i<l):
                sprite_layers[1].remove_sprite(specialarrow_list[i])
                specialarrow_list.pop(i)
                l = len(specialarrow_list)
            sprite_layers[1].remove_sprite(drag[0])
            render_update(renderer,sprite_layers,screen)
            sound.stop_soundfx(battlefield_sound)
            running = False
            life = 2
            
        # adjust camera according to the hero's position, follow him
        cam_pos_x = hero.rect.centerx
        cam_pos_y = hero.rect.centery
        if hero.rect.centerx <= 520 :
            cam_pos_x = 520
        if hero.rect.centery >=1050:
            cam_pos_y = 1050
        elif hero.rect.centery <=407:
            cam_pos_y = 407
        renderer.set_camera_position(cam_pos_x, cam_pos_y)

        # interface update
        c_pos=(cam_pos_x,cam_pos_y)
        interface.rect.topleft=(c_pos[0]-512,c_pos[1]-384)
        hp_sprite.rect.topleft=(c_pos[0]-400,c_pos[1]-382)
        xp_sprite.rect.topleft=(c_pos[0]-400,c_pos[1]-345)
        l_g.rect.topleft=(c_pos[0]-508,c_pos[1]-381)
        f_i.rect.bottomright=(c_pos[0]+500,c_pos[1]+350)
        interf_fight.rect.bottomright=(c_pos[0]+512,c_pos[1]+384)
        dhp_sprite.rect.midbottom=(c_pos[0],c_pos[1]+350)
        d_hp.rect.midbottom=(c_pos[0],c_pos[1]+350)
        spec_interf.rect.topleft=(c_pos[0]-512,c_pos[1]-240)
        s_a.rect.topleft=(c_pos[0]-540,c_pos[1]-280)

        # clear screen, might be left out if every pixel is redrawn anyway
        screen.fill((0, 0, 0))
        (renderer,sprite_layers,screen) = render_update(renderer,sprite_layers,screen)
        
    if life == 0:
        demo_pygame('./maps/palace_final.tmx',0)
    elif life ==2:
        # Game ends!
        # Quit the window after pressing 'Esc'
        running = True
        ending_sound = sound.create_soundfx('./sounds/ending.ogg')
        sound.volume(ending_sound,1)
        while running :
            for event in pygame.event.get():
                if (event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE ):
                    sound.stop_soundfx(ending_sound)
                    running = False
        pygame.quit()
Example #35
0
        super().__init__()
        self.image = image
        self.width = 30
        self.height = 40
        self.rect = [x,y]
        
    def move(self):
        self.rect = [400, 300]
        
hand = pygame.sprite.Group()
x = 10
for i in range(14):
    hand.add(Tile(tileimg, x, 30))
    x += 50
    
handiteration = hand.sprites()
while playing:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            playing = False
        if event.type == pygame.MOUSEBUTTONDOWN:
            coordinates = pygame.mouse.get_pos()
            if 30 <= coordinates[1] <= 70:
                tileNum = coordinates[0] // 50 - 1
                hand.remove(handiteration[tileNum])
                #handiteration[tileNum].move()
                #hand.add(handiteration[tileNum])
    hand.draw(screen)
    pygame.display.update()
pygame.quit();sys.exit()
Example #36
0
def run(director: Director, run_game_lock: Lock, end_game_lock: Lock,
        human: HumanPlayer, turn_lock: Lock):
    pygame.init()

    pygame.display.set_caption('Clue')
    game_display = pygame.display.set_mode((display_width, display_height))

    manager = pygame_gui.UIManager((display_width, display_height),
                                   'theme.json')

    clock = pygame.time.Clock()
    crashed = False

    # load images
    board_img = pygame.image.load('assets/board.jpg')

    start_button_rect = pygame.Rect(
        ((display_width / 2) - 50, (display_height / 2) - 25), (100, 50))
    start_button = pygame_gui.elements.UIButton(
        relative_rect=start_button_rect, text='Start Game', manager=manager)

    board_surface = pygame.Surface((board_width, display_height))

    player_pieces: List[PlayerPiece] = list(
        map(lambda p: PlayerPiece(p, board_surface), director.players))

    on_end_turn = lambda: end_turn(turn_lock)

    player_roll = PlayerRoll(board_surface, human, on_end_turn)
    log_book_ui = LogBookPanel(manager)
    guess_panel = GuessPanel(manager, display_width, display_height, human,
                             on_end_turn)
    start_turn_menu = StartTurnPanel(manager, display_width, display_height,
                                     player_roll, guess_panel, human)
    match_pick_panel = MatchPickPanel(manager, display_width, display_height,
                                      human, on_end_turn)

    human.on_turn = lambda turn: on_player_turn(
        manager, turn, turn_lock, start_turn_menu, match_pick_panel,
        on_end_turn)

    started = False
    while end_game_lock.locked() is False and not started:
        time_delta = clock.tick(60) / 1000.0

        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                quit_game(end_game_lock, run_game_lock, turn_lock)
                break

            elif event.type == pygame.USEREVENT:
                if event.user_type == pygame_gui.UI_BUTTON_PRESSED:
                    if event.ui_element == start_button:
                        start_button.kill()
                        run_game_lock.release()
                        started = True

            manager.process_events(event)

        game_display.fill(white)

        manager.update(time_delta)
        manager.draw_ui(game_display)

        pygame.display.update()

    if started:
        # start the game
        log_book_ui.show()

        while end_game_lock.locked() is False:
            time_delta = clock.tick(60) / 1000.0

            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    quit_game(end_game_lock, run_game_lock, turn_lock)
                    break

                start_turn_menu.process_events(event)
                log_book_ui.process_events(event)
                player_roll.process_events(event)
                match_pick_panel.process_events(event)
                guess_panel.process_events(event)
                manager.process_events(event)

            game_display.fill(white)

            board_surface.blit(board_img, (0, 0))

            if director.game_status == GameStatus.RUNNING:
                for player in player_pieces:
                    player.draw()

            player_roll.draw()

            game_display.blit(board_surface, (LogBookPanel.PANEL_WIDTH, 0))

            manager.update(time_delta)
            manager.draw_ui(game_display)

            pygame.display.update()

    pygame.quit()
Example #37
0
def main():
    chrash = False
    while not chrash:  #main game loop
        run()
        pygame.quit()
Example #38
0
    XO = 'x'
    draw = False
    game_opening()
    winner = None
    TTT = [[None] * 3, [None] * 3, [None] * 3]
    screen.fill((0, 0, 0), (0, 400, 500, 100))
    reset_message = XO.upper() + " 's turn"
    font = pg.font.SysFont('Arial', 30)
    reset_text = font.render(reset_message, 1, (255, 0, 0))
    screen.blit(reset_text, (width / 3, 425))
    pg.display.update()


# RUNNING OUR GAME FOREVER
game_opening()

# RUNNING THE GAME IN INFINITE LOOP
while (True):
    for event in pg.event.get():
        if event.type == QUIT:
            pg.quit()
            sys.exit()
        elif event.type is MOUSEBUTTONDOWN:
            #THE USER CLICKED, PLACE AN X or O
            userClick()
            if (winner or draw):
                reset_game()
    pg.display.update()
    CLOCK.tick(fps)
Example #39
0
def quit_app():
    """Cleanly closes the camera and the application"""
    camera.close()
    pygame.quit()
    print "You've taken", pics_taken, " pictures. Don't forget to back them up (or they'll be overwritten next time)"
    sys.exit(0)
Example #40
0
 def quit(self):
     pygame.quit()
     sys.exit()
def end_credits(screen):
    """
    Титры и рестарт игры
    :param screen:
    :return:
    """

    screen_r = screen.get_rect()
    font = pygame.font.Font('data/fonts/MidnightMinutes.otf', 36)
    clock = pygame.time.Clock()
    pygame.display.set_caption("Credits")

    smallfont = pygame.font.SysFont(None, 60)
    is_intro = True
    while is_intro:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    is_intro = False
                elif event.key == pygame.K_SPACE:
                    return

        screen.fill((255, 255, 255))
        text = smallfont.render("Press ESC to finish game", True, (0, 0, 0))
        text2 = smallfont.render("Press SPACE to restart", True, (0, 0, 0))
        screen.blit(text, [140, 240])
        screen.blit(text2, [140, 310])
        pygame.display.update()

    credit_list = [" ", " ", "DODGING ROCKS", " ", " ",
                   "DEVELOPMENT", "FOMIN NIKITA", "ROMANOV S***N", " ",
                   "IDEA", "ROMANOV S***N", "FOMIN NIKITA", " ",
                   "TESTING", "FOMIN NIKITA", "ROMANOV S***N", " ",
                   "SPECIAL THANKS", " ", "ROMANOV S***N", "FOMIN NIKITA", " ",
                   ]

    texts = []

    for i, line in enumerate(credit_list):
        s = font.render(line, 1, (10, 10, 10))
        r = s.get_rect(centerx=screen_r.centerx, y=screen_r.bottom + i * 45)
        texts.append((r, s))

    while True:
        for e in pygame.event.get():
            if e.type == QUIT:
                pygame.quit()
                exit()

            elif e.type == KEYDOWN and (e.key == pygame.K_ESCAPE or e.key == pygame.K_SPACE):
                return

        screen.fill((255, 255, 255))

        for r, s in texts:
            r.move_ip(0, -1)
            screen.blit(s, r)

        if not screen_r.collidelistall([r for (r, _) in texts]):
            break

        pygame.display.flip()
        clock.tick(60)
def quitgame():
    pg.quit()
Example #43
0
def ClickResponse(screen, rect):
    pad = pygame.image.load("NUMPAD/numpad.png")
    screen.fill([255, 255, 255])
    CenterText(100, screen, "Zahlensequenz jetzt eingeben")
    impos = pad.get_rect()
    impos.centerx = screen.get_rect().centerx
    centerx = screen.get_rect().centerx
    impos.centery = screen.get_rect().centery
    centery = screen.get_rect().centery
    screen.blit(pad, impos)
    pygame.display.flip()
    exit = 0
    ans = -1
    response = []
    pygame.event.clear()
    while exit == 0:
        if ans > -1:
            CenterText(rect[1] - 100, screen,
                       "Eingabetaste dr" + u"\u00FC" + "cken, um fortzufahren")
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
            if event.type == pygame.KEYDOWN and event.key == 27:
                pygame.quit()
            if event.type == pygame.MOUSEBUTTONDOWN:
                position = event.pos
                if position[0] > centerx - 150 and position[0] < centerx - 50:
                    if position[1] > centery - 200 and position[
                            1] < centery - 100:
                        ans = 1
                        response.append(ans)
                    elif position[1] > centery - 100 and position[1] < centery:
                        ans = 4
                        response.append(ans)
                    elif position[1] > centery and position[1] < centery + 100:
                        ans = 7
                        response.append(ans)
                elif position[0] > centerx - 50 and position[0] < centerx + 50:
                    if position[1] > centery - 200 and position[
                            1] < centery - 100:
                        ans = 2
                        response.append(ans)
                    elif position[1] > centery - 100 and position[1] < centery:
                        ans = 5
                        response.append(ans)
                    elif position[1] > centery and position[1] < centery + 100:
                        ans = 8
                        response.append(ans)
                    elif position[1] > centery + 100 and position[
                            1] < centery + 200:
                        ans = 10
                        response.append(ans)
                elif position[0] > centerx + 50 and position[0] < centerx + 150:
                    if position[1] > centery - 200 and position[
                            1] < centery - 100:
                        ans = 3
                        response.append(ans)
                    elif position[1] > centery - 100 and position[1] < centery:
                        ans = 6
                        response.append(ans)
                    elif position[1] > centery and position[1] < centery + 100:
                        ans = 9
                        response.append(ans)
                if ans > -1:
                    CenterText(100, screen, "Zahlensequenz jetzt eingeben")
                    pad = pygame.image.load("NUMPAD/numpad_" + str(ans) +
                                            ".png")
                    screen.blit(pad, impos)
                    pygame.display.flip()
            if event.type == pygame.MOUSEBUTTONUP:
                CenterText(100, screen, "Zahlensequenz jetzt eingeben")
                pad = pygame.image.load("NUMPAD/numpad.png")
                screen.blit(pad, impos)
                pygame.display.flip()
            if event.type == 2 and event.key == 13:
                if ans > -1:
                    return response
            if event.type == 2 and event.key == 113:
                pygame.quit()
Example #44
0
 def quit(self):
     pygame.quit()
     self.stop()
Example #45
0
def run():
    """Main loop of everything"""
    print(__title__ + ' ' + __version__)
    # Initialize Pygame
    pygame.init()

    # Set up the screen
    screen = pygame.display.set_mode(SCREENSIZE, 0, 16)
    pygame.display.set_caption(__title__ + ' ' + __version__)

    global grid, keyboard
    grid = Grid(10, 20, (SCREENSIZE[0] / 2, SCREENSIZE[1] / 2))
    keyboard = Keyboard(grid)

    # Set up the FPS clock
    clock = pygame.time.Clock()

    MUSIC_END = USEREVENT + 1  #This event is sent when a music track ends

    # Set music end event to our new event
    pygame.mixer.music.set_endevent(MUSIC_END)

    # Load and start playing the music
    pygame.mixer.music.load('sound/tetris.mid')
    pygame.mixer.music.play()

    fallTime = FALLPERSEC

    RUNNING = True

    # While the game is active
    while RUNNING:
        # Event handler
        for event in pygame.event.get():
            if event.type == QUIT:
                RUNNING = False
            elif event.type == MUSIC_END:
                pygame.mixer.music.stop()
                pygame.mixer.music.play()
            else:
                keyboard.readEvent(event)

        time_passed = clock.tick(FPS)
        keyboard.process(time_passed)

        if keyboard.active['down']:
            fallTime = FALLPERSEC
        if fallTime <= 0:
            grid.moveShapeDown()
            fallTime = FALLPERSEC
        fallTime = max(fallTime - (time_passed / 1000), 0)

        screen.unlock()

        screen.fill([255] * 3)
        pygame.draw.rect(
            screen, [200] * 3,
            pygame.Rect(2, 2, SCREENSIZE[0] - 5, SCREENSIZE[1] - 5), 4)

        grid.render(screen)

        screen.lock()

        # Update the display
        pygame.display.update()
    pygame.mixer.music.stop()
    pygame.quit()
Example #46
0
def terminate():
    pygame.quit()
    sys.exit()
Example #47
0
def main():
    # Globals
    global l_count
    global g_count
    global c_line
    global j_x
    global j_y
    global g_busy
    global g_stop

    while True:
        # Check Ctrl+C
        try:
            #detections = model(camera.value)
            #print(detections)
            execute({'new': camera.image_array})

        except KeyboardInterrupt:
            camera.stop()
            #p.stop()
            #GPIO.cleanup()
            pygame.quit()
            sys.exit()

        for event in pygame.event.get():
            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_ESCAPE:
                    #pi.stop()
                    #ser1.close()
                    #print(">> Serial Port " + ser1.port + " closed")
                    #pygame.mixer.music.load('/home/dewald/projects/ziavi/audio/deactivation_complete.wav')
                    #pygame.mixer.music.play()
                    #while pygame.mixer.music.get_busy() == True:
                    #  continue
                    camera.stop()
                    #p.stop()
                    #GPIO.cleanup()
                    pygame.quit()
                    sys.exit()

                if event.key == pygame.K_r:
                    camera.exec_rotate()

                #if event.key == pygame.K_MINUS:
                #    camera.exec_rotate()

            # Possible joystick actions: JOYAXISMOTION JOYBALLMOTION JOYBUTTONDOWN
            # JOYBUTTONUP JOYHATMOTION
            if event.type == pygame.JOYBUTTONDOWN:
                print("Joystick button pressed.")
                buttons = joystick.get_numbuttons()
                for i in range(buttons):
                    button = joystick.get_button(i)
                    print("Button {:>2} value: {}".format(i, button))

                    if i == 0 and button:
                        print("UP - is pressed")

                    if i == 1 and button:
                        print("RIGHT - is pressed")

                    if i == 2 and button:
                        print("DOWN - is pressed")

                    if i == 3 and button:
                        print("LEFT - is pressed")

                    if i == 4 and button:
                        g_stop = True
                        time.sleep(1)
                        print("L.UPPER - is pressed")
                        save_free()

                    if i == 5 and button:
                        print("R.UPPER - is pressed")
                        g_stop = True

                    if i == 6 and button:
                        g_stop = True
                        time.sleep(1)
                        print("L.LOWER - is pressed")
                        save_blocked()

                    if i == 7 and button:
                        print("R.LOWER - is pressed")
                        g_stop = False
                        time.sleep(0.5)

                    if i == 8 and button:
                        print("SELECT - is pressed")
                        g_stop = False
                        print("starting training mode..")
                        time.sleep(10)
                        print("training complete!")

                    if i == 9 and button:
                        print("START - is pressed")

                        time.sleep(0.1)

            if event.type == pygame.JOYBUTTONUP:
                print("Joystick button released.")
Example #48
0
    def run(self):
        current_dir = os.path.dirname(os.path.abspath(__file__))
        image_path = os.path.join(current_dir, "car.png")
        car_image = pygame.image.load(image_path)
        car = Car(0, 0)
        ppu = 32

        while not self.exit:
            dt = self.clock.get_time() / 1000

            # Event queue
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    self.exit = True

            # User input
            pressed = pygame.key.get_pressed()

            if pressed[pygame.K_UP]:
                if car.velocity.x < 0:
                    car.acceleration = car.brake_deceleration
                else:
                    car.acceleration += 1 * dt
            elif pressed[pygame.K_DOWN]:
                if car.velocity.x > 0:
                    car.acceleration = -car.brake_deceleration
                else:
                    car.acceleration -= 1 * dt
            elif pressed[pygame.K_SPACE]:
                if abs(car.velocity.x) > dt * car.brake_deceleration:
                    car.acceleration = -copysign(car.brake_deceleration, car.velocity.x)
                else:
                    car.acceleration = -car.velocity.x / dt
            else:
                if abs(car.velocity.x) > dt * car.free_deceleration:
                    car.acceleration = -copysign(car.free_deceleration, car.velocity.x)
                else:
                    if dt != 0:
                        car.acceleration = -car.velocity.x / dt
            car.acceleration = max(-car.max_acceleration, min(car.acceleration, car.max_acceleration))

            if pressed[pygame.K_RIGHT]:
                car.steering -= 30 * dt
            elif pressed[pygame.K_LEFT]:
                car.steering += 30 * dt
            else:
                car.steering = 0
            car.steering = max(-car.max_steering, min(car.steering, car.max_steering))

            # Logic
            car.update(dt)

            self.textsurface = self.myfont.render('Some Text', False, (0, 0, 0))


            # Drawing
            self.screen.fill((0, 0, 0))
            self.screen.blit(self.bg, (0,0))
            rotated = pygame.transform.rotate(car_image, car.angle)
            rect = rotated.get_rect()
            
            self.screen.blit(rotated, car.position * ppu - (rect.width / 2, rect.height / 2))
            pygame.display.flip()

            self.clock.tick(self.ticks)
        pygame.quit()
 def __del__(self):
     pygame.quit()
Example #50
0
            Mario.skok=True
            Mario.desno=False
            Mario.lijevo=False
            Mario.brojač_hoda=0
            Mario.brojač_skoka=16
            if super_mario:
                jump=pygame.mixer.Sound('Resursi\Zvučni efekti\Mario\Mario Jump.wav')
            else:
                jump=pygame.mixer.Sound('Resursi\Zvučni efekti\Blitzkrieg\Mario Jump.wav')
            jump.play()

    else:
        if Mario.brojač_skoka>=-16:
            neg=1
            if Mario.brojač_skoka<0:
                neg=-1
            if  Mario.y==262:
                Mario.y=262

            else:
                Mario.y-=(Mario.brojač_skoka**2)*0.15*neg
            Mario.brojač_skoka-=1
        else:
            Mario.skok=False
            Mario.bojač_skoka=16
       
    crtanje()    
    pygame.display.update() #osvježavanje prozora

pygame.quit() #kraj programa
Example #51
0
def run_field(
        grain_field: GrainField,
        resolution: int=1,
        simulation_method=CA_METHOD,
        probability: int=100,
        iterations_limit: int=10,
        paused=False,
        update_function=None,
):
    """
    Visualise grain field

    :param grain_field: field to be visualized
    :param resolution: length of square side (in pixels)
    :param simulation_method: method used to simulate growth (can be either ca or mc)
    :param probability: probability used in ca method
    :param paused: whether simulation starts paused or not
    :param iterations_limit: number of iterations after which visualisation will pause
    :param update_function: custom function that can be provided to update grain field
    :return: grain field object after visualisation
    """
    if update_function is None:
        update_function = lambda: grain_field.update(simulation_method, probability)
    pygame.init()

    window_width = grain_field.width * resolution
    window_height = grain_field.height * resolution

    # create screen
    screen = pygame.display.set_mode((window_width, window_height))
    pygame.display.set_caption('Grain field')

    # create clock
    clock = pygame.time.Clock()
    total_time = 0

    # selected cells
    selected_cells = {}
    iterations_num_font = pygame.font.SysFont('monospace', 48 if resolution >= 6 else 24, bold=True)

    visualisation_type = FieldVisualisationType.NUCLEATION
    visualisation_type_toggler = itertools.cycle(FieldVisualisationType.__members__.values())

    # main loop
    while 1337:
        for event in pygame.event.get():
            if event.type is pygame.QUIT:
                pygame.quit()
                return grain_field, selected_cells
                # sys.exit(0)
            elif event.type is pygame.KEYDOWN and event.key is pygame.K_ESCAPE:
                pygame.quit()
                return grain_field, selected_cells
                # sys.exit(0)
            elif event.type is pygame.KEYDOWN:
                if event.key is pygame.K_SPACE:
                    update_function()
                elif event.key is pygame.K_TAB:
                    visualisation_type = next(visualisation_type_toggler)
                elif event.key is pygame.K_e:
                    grain_field.distribute_energy()
                elif event.key is pygame.K_i:
                    export_image(grain_field)
                elif event.key is pygame.K_t:
                    export_text(grain_field)
                elif event.key is pygame.K_l:
                    grain_field = import_text('field.txt')
                elif event.key is pygame.K_p:
                    paused = not paused
                elif event.key is pygame.K_n:
                    grain_field.clear_field(dual_phase=True)
                elif event.key is pygame.K_b:
                    points = []
                    if not any([grain.lock_status is Grain.SELECTED for grain in grain_field.grains]):
                        points = grain_field.grains_boundaries_points
                    else:
                        for state, cells in selected_cells.items():
                            points.extend(grain_field.cells_of_state_boundary_points(state))
                            for cell in cells:
                                cell.lock_status = Grain.ALIVE
                    # points = grain_field.cells_of_state_boundary_points(1)
                    for point in points:
                        grain_field[point].state = Grain.INCLUSION
                    print(grain_field.grain_boundary_percentage)
            elif event.type is pygame.MOUSEBUTTONDOWN:
                # clicking on grains selects them
                gx, gy = mouse2grain_coords(pygame.mouse.get_pos(), resolution)
                grain = grain_field[gx, gy]
                if simulation_method == CA_METHOD:
                    state = grain.prev_state
                elif simulation_method == MC_METHOD:
                    state = grain.state
                else:
                    state = grain.state

                if grain.lock_status is Grain.SELECTED:
                    # unlock it then
                    for cell in selected_cells[state]:
                        cell.lock_status = Grain.ALIVE
                    del selected_cells[state]
                elif state is not Grain.INCLUSION and not grain.is_locked or grain.lock_status is not Grain.RECRYSTALIZED:
                    selected_cells[state] = grain_field.cells_of_state(state)
                    for cell in selected_cells[state]:  # type: Grain
                        cell.lock_status = Grain.SELECTED
                print('selected {} (lock_state: {})'.format(state, grain.lock_status))

        total_time += clock.tick(MAX_FRAMES)

        # m_pos = pygame.mouse.get_pos()
        # display iterations
        label = iterations_num_font.render('{}'.format(grain_field.iteration), 1, (0, 0, 0))

        if grain_field.iteration == iterations_limit:
            paused = True if not grain_field.iteration == 0 else False

        grain_field.display(screen, resolution, visualisation_type)
        screen.blit(label, (window_width - 80, window_height - 80))
        pygame.display.update()

        if not paused:
            update_function()
            # grain_field.update(simulation_method, probability)
            if simulation_method == CA_METHOD and grain_field.full:
                paused = True
            if simulation_method == SXRMC and all([grain.energy_value == 0 for grain in grain_field.grains]):
                paused = True
 def start(self, screen):
     screen = pygame.display.set_mode((self.width+self.panel_width, self.height))
     # 背景图片
     background_img = pygame.image.load(self.other_image_paths.get('background'))
     # 定义精灵组
     player_tanks_group = pygame.sprite.Group()
     enemy_tanks_group = pygame.sprite.Group()
     player_bullets_group = pygame.sprite.Group()
     enemy_bullets_group = pygame.sprite.Group()
     foods_group = pygame.sprite.Group()
     # 定义敌方坦克生成事件
     generate_enemies_event = pygame.constants.USEREVENT
     pygame.time.set_timer(generate_enemies_event, 20000)
     # 我方大本营
     home = Home(position=self.home_position, imagepaths=self.home_image_paths)
     # 我方坦克
     tank_player1 = PlayerTank('player1', position=self.player_tank_positions[0], player_tank_image_paths=self.player_tank_image_paths, border_len=self.border_len, screensize=[self.width, self.height], bullet_image_paths=self.bullet_image_paths, protected_mask_path=self.other_image_paths.get('protect'), boom_image_path=self.other_image_paths.get('boom_static'))
     player_tanks_group.add(tank_player1)
     if self.is_dual_mode:
         tank_player2 = PlayerTank('player2', position=self.player_tank_positions[1], player_tank_image_paths=self.player_tank_image_paths, border_len=self.border_len, screensize=[self.width, self.height], bullet_image_paths=self.bullet_image_paths, protected_mask_path=self.other_image_paths.get('protect'), boom_image_path=self.other_image_paths.get('boom_static'))
         player_tanks_group.add(tank_player2)
     # 敌方坦克
     for position in self.enemy_tank_positions:
         enemy_tanks_group.add(EnemyTank(enemy_tank_image_paths=self.enemy_tank_image_paths, appear_image_path=self.other_image_paths.get('appear'), position=position, border_len=self.border_len, screensize=[self.width, self.height], bullet_image_paths=self.bullet_image_paths, food_image_paths=self.food_image_paths, boom_image_path=self.other_image_paths.get('boom_static')))
     # 游戏开始音乐
     self.sounds['start'].play()
     clock = pygame.time.Clock()
     # 该关卡通过与否的flags
     is_win = False
     is_running = True
     # 游戏主循环
     while is_running:
         screen.fill((0, 0, 0))
         screen.blit(background_img, (0, 0))
         # 用户事件捕捉
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
                 pygame.quit()
                 sys.exit()
             # --敌方坦克生成
             elif event.type == generate_enemies_event:
                 if self.max_enemy_num > len(enemy_tanks_group):
                     for position in self.enemy_tank_positions:
                         if len(enemy_tanks_group) == self.total_enemy_num:
                             break
                         enemy_tank = EnemyTank(enemy_tank_image_paths=self.enemy_tank_image_paths, appear_image_path=self.other_image_paths.get('appear'), position=position, border_len=self.border_len, screensize=[self.width, self.height], bullet_image_paths=self.bullet_image_paths, food_image_paths=self.food_image_paths, boom_image_path=self.other_image_paths.get('boom_static'))
                         if (not pygame.sprite.spritecollide(enemy_tank, enemy_tanks_group, False, None)) and (not pygame.sprite.spritecollide(enemy_tank, player_tanks_group, False, None)):
                             enemy_tanks_group.add(enemy_tank)
         # --用户按键
         key_pressed = pygame.key.get_pressed()
         # 玩家一, WSAD移动, 空格键射击
         if tank_player1.num_lifes >= 0:
             if key_pressed[pygame.K_w]:
                 player_tanks_group.remove(tank_player1)
                 tank_player1.move('up', self.scene_elems, player_tanks_group, enemy_tanks_group, home)
                 player_tanks_group.add(tank_player1)
             elif key_pressed[pygame.K_s]:
                 player_tanks_group.remove(tank_player1)
                 tank_player1.move('down', self.scene_elems, player_tanks_group, enemy_tanks_group, home)
                 player_tanks_group.add(tank_player1)
             elif key_pressed[pygame.K_a]:
                 player_tanks_group.remove(tank_player1)
                 tank_player1.move('left', self.scene_elems, player_tanks_group, enemy_tanks_group, home)
                 player_tanks_group.add(tank_player1)
             elif key_pressed[pygame.K_d]:
                 player_tanks_group.remove(tank_player1)
                 tank_player1.move('right', self.scene_elems, player_tanks_group, enemy_tanks_group, home)
                 player_tanks_group.add(tank_player1)
             elif key_pressed[pygame.K_SPACE]:
                 bullet = tank_player1.shoot()
                 if bullet:
                     self.sounds['fire'].play() if tank_player1.tanklevel < 2 else self.sounds['Gunfire'].play()
                     player_bullets_group.add(bullet)
         # 玩家二, ↑↓←→移动, 小键盘0键射击
         if self.is_dual_mode and (tank_player2.num_lifes >= 0):
             if key_pressed[pygame.K_UP]:
                 player_tanks_group.remove(tank_player2)
                 tank_player2.move('up', self.scene_elems, player_tanks_group, enemy_tanks_group, home)
                 player_tanks_group.add(tank_player2)
             elif key_pressed[pygame.K_DOWN]:
                 player_tanks_group.remove(tank_player2)
                 tank_player2.move('down', self.scene_elems, player_tanks_group, enemy_tanks_group, home)
                 player_tanks_group.add(tank_player2)
             elif key_pressed[pygame.K_LEFT]:
                 player_tanks_group.remove(tank_player2)
                 tank_player2.move('left', self.scene_elems, player_tanks_group, enemy_tanks_group, home)
                 player_tanks_group.add(tank_player2)
             elif key_pressed[pygame.K_RIGHT]:
                 player_tanks_group.remove(tank_player2)
                 tank_player2.move('right', self.scene_elems, player_tanks_group, enemy_tanks_group, home)
                 player_tanks_group.add(tank_player2)
             elif key_pressed[pygame.K_KP0]:
                 bullet = tank_player2.shoot()
                 if bullet:
                     player_bullets_group.add(bullet)
                     self.sounds['fire'].play() if tank_player2.tanklevel < 2 else self.sounds['Gunfire'].play()
         # 碰撞检测
         # --子弹和砖墙
         pygame.sprite.groupcollide(player_bullets_group, self.scene_elems.get('brick_group'), True, True)
         pygame.sprite.groupcollide(enemy_bullets_group, self.scene_elems.get('brick_group'), True, True)
         # --子弹和铁墙
         for bullet in player_bullets_group:
             if pygame.sprite.spritecollide(bullet, self.scene_elems.get('iron_group'), bullet.is_stronger, None):
                 player_bullets_group.remove(bullet)
         pygame.sprite.groupcollide(enemy_bullets_group, self.scene_elems.get('iron_group'), True, False)
         # --子弹撞子弹
         pygame.sprite.groupcollide(player_bullets_group, enemy_bullets_group, True, True)
         # --我方子弹撞敌方坦克
         for tank in enemy_tanks_group:
             if pygame.sprite.spritecollide(tank, player_bullets_group, True, None):
                 if tank.food:
                     foods_group.add(tank.food)
                     tank.food = None
                 if tank.decreaseTankLevel():
                     self.sounds['bang'].play()
                     self.total_enemy_num -= 1
         # --敌方子弹撞我方坦克
         for tank in player_tanks_group:
             if pygame.sprite.spritecollide(tank, enemy_bullets_group, True, None):
                 if tank.is_protected:
                     self.sounds['blast'].play()
                 else:
                     if tank.decreaseTankLevel():
                         self.sounds['bang'].play()
                     if tank.num_lifes < 0:
                         player_tanks_group.remove(tank)
         # --我方子弹撞我方大本营
         if pygame.sprite.spritecollide(home, player_bullets_group, True, None):
             is_win = False
             is_running = False
             home.setDead()
         # --敌方子弹撞我方大本营
         if pygame.sprite.spritecollide(home, enemy_bullets_group, True, None):
             is_win = False
             is_running = False
             home.setDead()
         # --我方坦克在植物里
         if pygame.sprite.groupcollide(player_tanks_group, self.scene_elems.get('tree_group'), False, False):
             self.sounds['hit'].play()
         # --我方坦克吃到食物
         for player_tank in player_tanks_group:
             for food in foods_group:
                 if pygame.sprite.collide_rect(player_tank, food):
                     if food.name == 'boom':
                         self.sounds['add'].play()
                         for _ in enemy_tanks_group:
                             self.sounds['bang'].play()
                         self.total_enemy_num -= len(enemy_tanks_group)
                         enemy_tanks_group = pygame.sprite.Group()
                     elif food.name == 'clock':
                         self.sounds['add'].play()
                         for enemy_tank in enemy_tanks_group:
                             enemy_tank.setStill()
                     elif food.name == 'gun':
                         self.sounds['add'].play()
                         player_tank.improveTankLevel()
                     elif food.name == 'iron':
                         self.sounds['add'].play()
                         self.__pretectHome()
                     elif food.name == 'protect':
                         self.sounds['add'].play()
                         player_tank.setProtected()
                     elif food.name == 'star':
                         self.sounds['add'].play()
                         player_tank.improveTankLevel()
                         player_tank.improveTankLevel()
                     elif food.name == 'tank':
                         self.sounds['add'].play()
                         player_tank.addLife()
                     foods_group.remove(food)
         # 画场景地图
         for key, value in self.scene_elems.items():
             if key in ['ice_group', 'river_group']:
                 value.draw(screen)
         # 更新并画我方子弹
         for bullet in player_bullets_group:
             if bullet.move():
                 player_bullets_group.remove(bullet)
         player_bullets_group.draw(screen)
         # 更新并画敌方子弹
         for bullet in enemy_bullets_group:
             if bullet.move():
                 enemy_bullets_group.remove(bullet)
         enemy_bullets_group.draw(screen)
         # 更新并画我方坦克
         for tank in player_tanks_group:
             tank.update()
             tank.draw(screen)
         # 更新并画敌方坦克
         for tank in enemy_tanks_group:
             enemy_tanks_group.remove(tank)
             data_return = tank.update(self.scene_elems, player_tanks_group, enemy_tanks_group, home)
             enemy_tanks_group.add(tank)
             if data_return.get('bullet'):
                 enemy_bullets_group.add(data_return.get('bullet'))
             if data_return.get('boomed'):
                 enemy_tanks_group.remove(tank)
         enemy_tanks_group.draw(screen)
         # 画场景地图
         for key, value in self.scene_elems.items():
             if key not in ['ice_group', 'river_group']:
                 value.draw(screen)
         # 画大本营
         home.draw(screen)
         # 更新并显示食物
         for food in foods_group:
             if food.update():
                 foods_group.remove(food)
         foods_group.draw(screen)
         self.__showGamePanel(screen, tank_player1, tank_player2) if self.is_dual_mode else self.__showGamePanel(screen, tank_player1)
         # 我方坦克都挂了
         if len(player_tanks_group) == 0:
             is_win = False
             is_running = False
         # 敌方坦克都挂了
         if self.total_enemy_num <= 0:
             is_win = True
             is_running = False
         pygame.display.flip()
         clock.tick(60)
     screen = pygame.display.set_mode((self.width, self.height))
     return is_win
Example #53
0
    def MainFunction(self):
        # Выключаем паузу, смерть игрока и перемещаем игрока на старт
        self.player.MoveToStart((1280 // 2, 265))
        self.isPauseGame = False
        self.player.isDead = False
        self.player.isBlockGravity = True
        # Загружаем спрайты для заднего фона меню
        spritesBackgroundMenuGroup = pygame.sprite.Group()

        # Спрайт заднего фона с размером 1280 на 720
        self.classLoadImage.AddSprite(spritesBackgroundMenuGroup, "Sky.png", (self.width, self.height))
        self.classLoadImage.AddSprite(spritesBackgroundMenuGroup, "Hills_2.png", (self.width, self.height),
                                      way="../data/Levels",
                                      colorkey=-1)
        self.classLoadImage.AddSprite(spritesBackgroundMenuGroup, "Hills_1.png", (self.width, self.height),
                                      way="../data/Levels",
                                      colorkey=-1)
        FPS = 60
        clock = pygame.time.Clock()
        running = True
        levelEnd = False
        while running:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    running = False
                if event.type == pygame.KEYDOWN:
                    idMin, idMax, idSelected = self.ReturnIdButton()
                    if event.key == pygame.K_ESCAPE:
                        self.isPauseGame = not self.isPauseGame
                    if event.key == pygame.K_RETURN and (self.isPauseGame or self.player.isDead or levelEnd):
                        self.soundButtonInput.play()
                        title = self.listAllButtons[idSelected].Input()
                        if title == "ВЫХОД В ВЫБОР УРОВНЯ" or levelEnd:
                            self.LoadSceneLevels(levelEnd)
            keys = pygame.key.get_pressed()
            idMin, idMax, idSelected = self.ReturnIdButton()
            if keys[pygame.K_UP]:
                if idSelected - 1 >= idMin:
                    self.listAllButtons[idSelected].SelectBtn()
                    self.listAllButtons[idSelected - 1].SelectBtn(True)
            elif keys[pygame.K_DOWN]:
                if idSelected + 1 < idMax:
                    self.listAllButtons[idSelected].SelectBtn()
                    self.listAllButtons[idSelected + 1].SelectBtn(True)
            levelEnd = self.player.EndLevel(self.classLoadScene.doorEndLevel)

            if not self.player.isDead and not self.isPauseGame:
                for sprite in self.classLoadScene.spritesTitles:
                    self.camera.apply(sprite)
                for sprite in self.classLoadScene.spritesBots:
                    self.camera.apply(sprite)
                for sprite in self.classLoadScene.spritesThings:
                    self.camera.apply(sprite)
            # Рисование Titles (Начало)
            spritesBackgroundMenuGroup.draw(self.screen)
            for thing in self.classLoadScene.listAllThings:
                thing.Update(self.screen)
                thing.CheckPlayer(self.playerGroup, self.player)
            self.classLoadScene.spritesTitles.draw(self.screen)
            self.classLoadScene.spritesBots.draw(self.screen)
            # Рисование Titles (Конец)

            # Работа ботов (Начало)
            #  print(self.classLoadScene.spritesBots)
            for bot in self.classLoadScene.listAllBots:
                bot.update(self.classLoadScene.spritesBots)
                bot.CheckPlayer(self.playerGroup, self.player)
            # Работа ботов (Конец)

            # Рисование и движение игрока (Начало)
            self.player.update(self.classLoadScene.spritesTitles)
            self.playerGroup.draw(self.screen)
            # Рисование и движение игрока (Конец)
            if self.player.isDead or self.isPauseGame:
                for btn in self.listAllButtons:
                    btn.RenderBtn()
                if not self.player.isDead:
                    self.textPauseMenu.RenderText()
                else:
                    self.textGameOverMenu.RenderText()
            pygame.display.flip()
            clock.tick(FPS)
        pygame.quit()
Example #54
0
def exit_game():
    time_elapsed = datetime.now() - time_start
    print("time elapsed: ", time_elapsed)
    pygame.quit()
    sys.exit()
Example #55
0
def game_loop():
    x = (display_width * 0.45)
    y = (display_height * 0.8)

    x_change = 0

    thing_startx = random.randrange(0, display_width)
    thing_starty = -600
    thing_speed = 3
    thing_width = 100
    thing_height = 100

    thingCount = 1

    dodged = 0

    gameExit = False

    while not gameExit:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()

            if event.type == pygame.KEYDOWN:
                if event.key == pygame.K_LEFT:
                    x_change = -5
                elif event.key == pygame.K_RIGHT:
                    x_change = 5

            if event.type == pygame.KEYUP:
                if event.key == pygame.K_LEFT or event.key == pygame.K_RIGHT:
                    x_change = 0

        x += x_change

        gameDisplay.fill(white)

        #things(thingx, thingy, thingw, thingh, color)
        things(thing_startx, thing_starty, thing_width, thing_height,
               block_color)
        thing_starty += thing_speed

        car(x, y)
        things_dodged(dodged)

        if x > display_width - car_width or x < 0:
            crash()

        if thing_starty > display_height:
            thing_starty = 0 - thing_height
            thing_startx = random.randrange(0, display_width)
            dodged += 1
            thing_speed += 1
            thing_width += (dodged * 1.2)

        if y + 15 < thing_starty + thing_height:
            if x > thing_startx and x < thing_startx + thing_width or x + car_width > thing_startx and x + car_width < thing_startx + thing_width:
                crash()

        pygame.display.update()
        clock.tick(60)  #60fps
Example #56
0
 def teardown(self):
     pygame.quit()
Example #57
0
def main():
	global FPSCLOCK, DISPLAYSURF
	pygame.init()
	FPSCLOCK = pygame.time.Clock()
	DISPLAYSURF = pygame.display.set_mode((WINDOWWIDTH, WINDOWHEIGHT))

	mousex = 0
	mousey = 0
	pygame.display.set_caption('Memory Game')

	mainBoard = getRandomizedBoard()
	revealedBoxes = generateRevealedBoxesData(False)

	firstSelection = None

	DISPLAYSURF.fill(BGCOLOR)
	startGameAnimation(mainBoard)

	while True:
		mouseCliked = False

		DISPLAYSURF.fill(BGCOLOR)
		drawBoard(mainBoard, revealedBoxes)

		for event in pygame.event.get():
			if event.type == QUIT or (event.type == KEYUP and event.key == K_ESCAPE):
				pygame.quit()
				sys.exit()
			elif event.type == MOUSEMOTION:
				mousex, mousey = event.pos
			elif event.type == MOUSEBUTTONUP:
				mousex, mousey = event.pos
				mouseCliked = True

		boxx, boxy = getBoxAtPixel(mousex, mousey)
		if boxx != None and boxy != None:
			if not revealedBoxes[boxx][boxy]:
				drawHighlightBox(boxx, boxy)
			if not revealedBoxes[boxx][boxy] and mouseCliked:
				revealBoxesAnimation(mainBoard, [(boxx, boxy)])
				revealedBoxes[boxx][boxy] = True

				if firstSelection == None:
					firstSelection = (boxx, boxy)
				else:
					icon1shape, icon1color = getShapeAndColor(mainBoard, firstSelection[0], firstSelection[1])
					icon2shape, icon2color = getShapeAndColor(mainBoard, boxx, boxy)

					if icon1shape != icon2shape or icon1color != icon2color:
						pygame.time.wait(1000)
						coverBoxesAnimation(mainBoard, [(firstSelection[0], firstSelection[1]), (boxx, boxy)])
						revealedBoxes[firstSelection[0]][firstSelection[1]] = False
						revealedBoxes[boxx][boxy] = False
					elif hasWon(revealedBoxes):
						gameWonAnimation(mainBoard)
						pygame.time.wait(2000)

						mainBoard = getRandomizedBoard()
						revealedBoxes = generateRevealeBoxesData(False)
						drawBoard(mainBoard, revealedBoxes)
						pygame.display.update()
						pygame.time.wait(1000)

						startGameAnimation(mainBoard)
					firstSelection = None
		pygame.display.update()

		FPSCLOCK.tick(FPS)
Example #58
0
    def get_event(self, event, keys, screen):
        # Carta 1
        if self.u1.getRekt().collidepoint(
                pygame.mouse.get_pos()) and self.revisarJugada(
                    self.u1.makeNaipe(
                    )) and self.checkGame() != True and self.mode_pause:

            self.u1.mouseOverButton(True, 340)
            self.touchCardflag = True

            if event.type == pygame.MOUSEBUTTONDOWN:
                self.play(0, screen, self.cartaHumano)
        else:
            self.u1.mouseOverButton(False, 370)

        # Carta 2
        if self.u2.getRekt().collidepoint(
                pygame.mouse.get_pos()) and self.revisarJugada(
                    self.u2.makeNaipe(
                    )) and self.checkGame() != True and self.mode_pause:
            self.touchCardflag = True
            self.u2.mouseOverButton(True, 340)

            if event.type == pygame.MOUSEBUTTONDOWN:
                self.play(0, screen, self.cartaHumano)
        else:
            self.u2.mouseOverButton(False, 370)

        # Carta 3
        if self.u3.getRekt().collidepoint(
                pygame.mouse.get_pos()) and self.revisarJugada(
                    self.u3.makeNaipe(
                    )) and self.checkGame() != True and self.mode_pause:
            self.touchCardflag = True
            self.u3.mouseOverButton(True, 340)

            if event.type == pygame.MOUSEBUTTONDOWN:
                self.play(0, screen, self.cartaHumano)
        else:
            self.u3.mouseOverButton(False, 370)

        # Volúmen:
        if self.sound.getRekt().collidepoint(pygame.mouse.get_pos()):
            self.sound.isActivePlayer(True)
            if event.type == pygame.MOUSEBUTTONDOWN:
                if self.volume == 1:
                    self.volume = 2
                    pygame.mixer.music.set_volume(0.7)
                elif self.volume == 2:
                    self.volume = 3
                    pygame.mixer.music.set_volume(0.3)
                elif self.volume == 3:
                    self.volume = 0
                    pygame.mixer.music.set_volume(0.0)
                else:
                    self.volume = 1
                    pygame.mixer.music.set_volume(1.0)
        else:
            self.sound.isActivePlayer(False)
        # Pausar musica:
        if self.music.getRekt().collidepoint(pygame.mouse.get_pos()):
            self.music.isActivePlayer(True)
            if event.type == pygame.MOUSEBUTTONDOWN:
                if self.pauseMusic == False:
                    # Esta sonando el bgm.
                    self.pauseMusic = True
                    pygame.mixer.music.pause()
                else:
                    self.pauseMusic = False
                    pygame.mixer.music.unpause()
        else:
            self.music.isActivePlayer(False)

        # Si el humano no tiene cartas validas para jugar:
        if (not self.atacante or not self.defensor
            ) and not self.checkGame() and self.mode_pause:
            #Humano es el defensor, puede tomar cartas en cualquier momento (no solo si no pueda defenderse). Tecla: t.
            if not self.defensor and self.boolDfs:
                self.tomar.isActivePlayer(True)
                if (self.tomar.getRekt().collidepoint(pygame.mouse.get_pos())
                        and event.type == pygame.MOUSEBUTTONDOWN) or (
                            event.type == pygame.KEYDOWN
                            and event.key == pygame.K_t):
                    self.play(0, screen, "pass")
                    self.tomar.isActivePlayer(False)
            #Humano es un atacante, decide por su cuenta si atacar o pasar el turno. Tecla : p.
            elif not self.atacante and self.boolAtq:
                self.pasar.isActivePlayer(True)
                if (self.pasar.getRekt().collidepoint(pygame.mouse.get_pos())
                        and event.type == pygame.MOUSEBUTTONDOWN) or (
                            event.type == pygame.KEYDOWN
                            and event.key == pygame.K_p):
                    self.play(0, screen, "pass")
                    self.pasar.isActivePlayer(False)

        # Para las flechas:
        if (event.type == pygame.KEYDOWN and event.key == pygame.K_UP
            ) or (event.type == pygame.MOUSEBUTTONDOWN
                  and self.arrow_up.getRekt().collidepoint(
                      pygame.mouse.get_pos())) and self.mode_pause:
            self.avanzarListPos(False)
            self.manoVisible = self.jugadores[0].manoAcotada(self.listpos)
            self.refreshUI(screen)

        if (event.type == pygame.KEYDOWN and event.key == pygame.K_DOWN
            ) or (event.type == pygame.MOUSEBUTTONDOWN
                  and self.arrow_down.getRekt().collidepoint(
                      pygame.mouse.get_pos())) and self.mode_pause:
            self.avanzarListPos(True)
            self.manoVisible = self.jugadores[0].manoAcotada(self.listpos)
            self.refreshUI(screen)

        #En juego se para al presionar SPACE o al usar el botón de pause.
        if (event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE) or (
                event.type == pygame.MOUSEBUTTONDOWN
                and self.pause.getRekt().collidepoint(pygame.mouse.get_pos())):
            if self.mode_pause:
                self.mode_pause = False
            else:
                self.mode_pause = True
        #Término de juego.
        if self.gameFinished == True:
            self.st_done = True
            self.next = "FIN"
            pygame.mixer.music.stop()

        if (event.type == pygame.QUIT) or (event.type == pygame.KEYDOWN
                                           and event.key == pygame.K_ESCAPE):
            self.quit = True
            pygame.quit()
            quit()

        self.actualizarMano(0)
Example #59
0
def mainGame():
    """
    Steps:
    First: vars and physics vars 
    second: Blit the player and bg and base
    Third: Event Loop with the exit
    Fourth: PLayer Vel increase and player fall down logic
    Fifth: Flapyer Flap in event loop
    Sixth: Get random Pipe
    Seven : Call Function
    Eighth: Make list and make it move
    Nine: Crash detection 
    Ten : Score Increase 
    11: Score display
    """
    score = 0
    playerx = int(SCREENWIDTH/5)
    playery = int(SCREENWIDTH/2)
    basex = 0
    pipeVelX = -4
    playerVelY = -8
    playerMaxVelY = 10
    playerMinVelY = -8
    playerAccY = 1
    playerFlapVel = -8 # velocity while flapping
    playerFlapped = False 
    newPipe1=getRandomPipe()
    newPipe2=getRandomPipe()
    upperPipes = [
        {'x': SCREENWIDTH+200, 'y':newPipe1[0]['y']},
        {'x': SCREENWIDTH+200+(SCREENWIDTH/2), 'y':newPipe2[0]['y']},
    ]
    # my List of lower pipes
    lowerPipes = [
        {'x': SCREENWIDTH+200, 'y':newPipe1[1]['y']},
        {'x': SCREENWIDTH+200+(SCREENWIDTH/2), 'y':newPipe2[1]['y']},
    ]
    while True:
        for event in pygame.event.get():
            if event.type == QUIT or (event.type == KEYDOWN and event.key == K_ESCAPE):
                pygame.quit()
                sys.exit()
            if event.type == KEYDOWN and (event.key == K_SPACE or event.key == K_UP):
               
                if playery > 0: #Player is in the screen
                    playerVelY = playerFlapVel
                    
                    playerFlapped = True
            if playerFlapped:
                playerFlapped = False  
                


        if playerVelY <playerMaxVelY and not playerFlapped:
        
            playerVelY += playerAccY
            print(playerVelY)

                  
        playerHeight = GAME_SPRITES['player'].get_height()
        playery = playery + min(playerVelY, GROUNDY - playery - playerHeight)

        # move pipes to the left
        for upperPipe , lowerPipe in zip(upperPipes, lowerPipes):
            upperPipe['x'] += pipeVelX
            lowerPipe['x'] += pipeVelX
        

        # Add a new pipe when the first is about to cross the leftmost part of the screen
        if 0<upperPipes[0]['x']<5:
            newPipe=getRandomPipe()
            upperPipes.append(newPipe[0])
            lowerPipes.append(newPipe[1])
        if upperPipes[0]['x'] < -GAME_SPRITES['pipe'][0].get_width():
            upperPipes.pop(0)
            lowerPipes.pop(0)
        crashTest = isCollided(playerx, playery, upperPipes, lowerPipes) # This function will return true if the player is crashed
        if crashTest:
            return  
        playerMidPos = playerx + GAME_SPRITES['player'].get_width()/2
        for pipe in upperPipes:
            pipeMidPos = pipe['x'] + GAME_SPRITES['pipe'][0].get_width()/2
            if pipeMidPos<= playerMidPos < pipeMidPos +4:
                score +=1
        
        # Lets blit our sprites now
        SCREEN.blit(GAME_SPRITES['background'], (0, 0))
        for upperPipe, lowerPipe in zip(upperPipes, lowerPipes):
            SCREEN.blit(GAME_SPRITES['pipe'][0], (upperPipe['x'], upperPipe['y']))
            SCREEN.blit(GAME_SPRITES['pipe'][1], (lowerPipe['x'], lowerPipe['y']))
        myDigits = [int(x) for x in list(str(score))]
        width = 0
        for digit in myDigits:
            width += GAME_SPRITES['numbers'][digit].get_width()
        Xoffset = (SCREENWIDTH - width)/2

        for digit in myDigits:
            SCREEN.blit(GAME_SPRITES['numbers'][digit], (Xoffset, SCREENHEIGHT*0.12))
            Xoffset += GAME_SPRITES['numbers'][digit].get_width()
        SCREEN.blit(GAME_SPRITES['base'], (basex, GROUNDY))
        SCREEN.blit(GAME_SPRITES['player'], (playerx, playery))
        pygame.display.update()
        FPSCLOCK.tick(FPS)

p.mixer.init()#초기화
hit = p.mixer.Sound("www.wav")


while playing:
    t2 = int(t.time()) #흐르는 시간
    timer = 60 - (t2 - t1)
    print (timer)

    
    for event in p.event.get():
        if event.type == p.QUIT:
            playing = False
            p.quit()
            quit()
        if event.type == p.MOUSEBUTTONDOWN:
           for do_rect in do_list:
               if do_rect.collidepoint(event.pos[0],event.pos[1]):
                   do_list.remove(do_rect)
                   do_rect = do.get_rect(left=r.randint(0,700),top=r.randint(0,300))
                   do_list.append(do_rect)
                   score +=1 #score = score + 1
                   hit.play() 
           
    sc.fill(w)
    for do_rect in do_list:
        sc .blit(do,do_rect)

    if timer == 0: