コード例 #1
0
class Game:
    filename = 'basketball.png'

    def __init__(self):
        self.screen = Screen()
        self.surface = self.screen.make_screen()  # screen itself
        self.platform = Platform(self.screen)
        self.game_over = False
        self.objects = []
        self.ball = Image(self.filename)
        self.game_over_text = Text("Game over!")

        self.buttons = {
            'd_is_pressed':
            False,  # Переменные для постоянного движения платформы при длительном нажатии
            'a_is_pressed': False
        }

    def make_multiple_objects(self, amount):
        for i in range(amount):
            self.objects.append(Image(self.filename))

    def move_platform(self):
        if self.buttons['d_is_pressed']:
            self.platform.move_right(self.screen)
        elif self.buttons['a_is_pressed']:
            self.platform.move_left()

    def process_collisions(self):
        if self.platform.collides_with(self.ball):
            self.ball.collision()

    def run_multiple(self):
        for ball in self.objects:
            ball.move(self.screen)
            ball.render_image(self.surface)

    def game_is_over(self):
        self.surface.blit(self.game_over_text.render_text(), (50, 100))

    def run(self):
        self.surface.fill(self.screen.bg_color)
        self.move_platform()
        self.platform.draw(self.surface)
        # self.run_multiple()
        self.ball.move(self.screen)
        self.ball.render_image(self.surface)
        self.process_collisions()
        if self.ball.touches_bottom(self.screen):
            self.game_is_over()
コード例 #2
0
        player.combo()
        player.collide_platform(floor, 0)
        platform_controller.collide_set(player)

        platform_controller.score = player.score
        camera.update(player.score)
        platform_controller.generate_new_platforms(camera)

        if player.fallen_off_screen(camera):
            game_state = 'Game Over'

            # game_display.fill(black)
            # image = pygame.transform.scale(image, (800,desired_height))
        game_display.blit(background, (0, 0))

        floor.draw(game_display, camera)
        platform_controller.draw(game_display, camera)
        player.draw(game_display, camera)

        message_display(game_display, str(player.score), 25, 30, 36, white)

    #------------------------GAME OVER--------------------------
    elif game_state == 'Game Over':

        game_display.blit(over, (-113, -83))
        if pygame.font:
            message_display(game_display, "GAME OVER", 0, 200, 70, white, True)
            message_display(game_display, "Score: %d" % player.score, 0, 300,
                            50, white, True)
            message_display(game_display, "Press SPACE to play again!", 0, 400,
                            50, white, True)
コード例 #3
0
ファイル: Simulator.py プロジェクト: SpeeritX/drone-simulator
class Simulator:
    OFFSET = 10
    DEBUGSCREENSIZE = (350, 200)
    MASS = 1
    MOMENT = 500

    def __init__(self, ai_type, fullscreen):

        self.ai_type = ai_type
        # Screen
        self.running = True
        self.screen = Screen(fullscreen)

        self.width, self.height = pygame.display.Info(
        ).current_w, pygame.display.Info().current_h
        self.startPoistion = (self.width / 2, self.height / 2)
        # FpsController
        self.fpsController = FpsController()
        self.fpsCounter = 0
        self.setFps(60)
        # Physics
        self.physics = Physics()
        # Drone
        self.drone = self.createDrone()
        self.camera = Camera(self.drone.body.position)
        # Platform
        self.platform = Platform()
        # Add element to space
        self.physics.addToSpace(self.platform.getShapes())
        self.physics.addToSpace(self.drone.getShapes())

        # Create Debug Screen
        DebugScreen.getInstance().setSize(self.DEBUGSCREENSIZE)
        DebugScreen.getInstance().setPosition(
            (self.width - self.DEBUGSCREENSIZE[0] - 10, 10))

    def createDrone(self) -> Drone:

        if self.ai_type == AIType.fuzzyLogic:
            return Drone(self.MASS, self.MOMENT, self.physics.getGravity(),
                         self.startPoistion, FuzzyLogicAI())
        elif self.ai_type == AIType.neuronNetwork:
            return Drone(self.MASS, self.MOMENT, self.physics.getGravity(),
                         self.startPoistion, NeuralNetworkAI())
        elif self.ai_type == AIType.simpleAI:
            return Drone(self.MASS, self.MOMENT, self.physics.getGravity(),
                         self.startPoistion, SimpleAI())
        elif self.ai_type == AIType.manualAI:
            return Drone(self.MASS, self.MOMENT, self.physics.getGravity(),
                         self.startPoistion, ManualAI())
        raise RuntimeError("Invalid ai type")

    def setFps(self, numberOfFps):
        # Example of changes fps, default 60
        self.fpsController.setFps(numberOfFps)

    def checkEvents(self):

        for event in pygame.event.get():

            if event.type == QUIT or event.type == KEYDOWN and (
                    event.key in [K_ESCAPE, K_q]):
                self.running = False

            elif event.type == KEYDOWN and event.key == K_r:

                # Remove all Drone elements from the screen
                self.physics.removeObject(self.drone.getShapes())
                # Create new Drone and add to space
                self.drone = self.createDrone()
                self.physics.addToSpace(self.drone.getShapes())

        keys = pygame.key.get_pressed()

        # Engines take values ​​of <0, 1>
        # For physics testing they were introduced permanently

        leftPower = 0.0
        rightPower = 0.0

        if keys[K_UP]:
            leftPower += 0.2
            rightPower += 0.2

        self.drone.leftEngine.setForce(leftPower)
        self.drone.rightEngine.setForce(rightPower)

    def startSimulation(self):

        # Each iteration of this loop will last (at least) 1/(number of FPS | default 60) of a second.
        while self.running:
            self.checkEvents()

            self.drone.update()
            self.camera.update(self.drone.body.position)
            self.draw()
            self.physics.updatePhysics()
            self.fpsController.waitForReady()
            self.fpsController.nextFrame()

    def draw(self):
        self.screen.clear()

        DebugScreen.getInstance().addInfo(
            "x", "{:.2f}".format(self.drone.body.position.x))
        DebugScreen.getInstance().addInfo(
            "y", "{:.2f}".format(self.drone.body.position.y))

        # Set screen offset based on camera position
        self.screen.setOffset(self.camera.getPosition())

        # self.screen.drawPhysics(self.physics.space)
        self.platform.draw(self.screen)
        self.drone.draw(self.screen)

        DebugScreen.getInstance().draw(self.screen)

        self.screen.show()
コード例 #4
0
ファイル: Game.py プロジェクト: leoragilbert/icy_tower_clone
		player.collide_platform(floor,0)
		platform_controller.collide_set(player)

	
		platform_controller.score = player.score
		camera.update(player.score)
		platform_controller.generate_new_platforms(camera)

		if player.fallen_off_screen(camera):
			game_state = 'Game Over'

			# game_display.fill(black)
			# image = pygame.transform.scale(image, (800,desired_height))
		game_display.blit(background,(0,0))

		floor.draw(game_display, camera)
		platform_controller.draw(game_display, camera)
		player.draw(game_display, camera)
		
		message_display(game_display, str(player.score), 25, 30, 36, white)

	#------------------------GAME OVER--------------------------
	elif game_state == 'Game Over':

		game_display.blit(background,(0,0))
		if pygame.font:
		    message_display(game_display, "GAME OVER", 0, 200, 70, white, True)
		    message_display(game_display, "Score: %d" % player.score, 0, 300, 50, white, True)
		    message_display(game_display, "Press SPACE to play again!", 0, 400, 50, white, True)
		    message_display(game_display, "Press ESC to return to menu!", 0, 500, 40, white, True)
コード例 #5
0
ファイル: Tower.py プロジェクト: ostrowskaaa/jump_the_tower
                pygame.quit()
        if event.type == KEYDOWN:
            if event.key == K_SPACE:
                reinit()


game = True
#game loop
while game:
    event()

    player.update(platform_controller)
    player.collide_platform(floor, 0)
    platform_controller.update()
    platform_controller.collide_set(player)
    platform_controller.score = player.score
    camera.update(player.score)
    platform_controller.generate_new_platforms(camera)

    window.fill(background)
    floor.draw(window, camera)
    platform_controller.draw(window, camera)
    player.draw(window, camera)
    message_display(window, str(player.score), 25, 30, 36, white)

    if player.fallen_off_screen(camera) == True:
        game_over()

    pygame.display.update()
    clock.tick(fps)