def __init__(self):
        """Initialize the game, create game resources."""
        pygame.init()
        self.settings = Settings()

        self.screen = pygame.display.set_mode(
            (self.settings.screen_width, self.settings.screen_height))
        pygame.display.set_caption("Alien Invasion")

        # Create an instance to store game stats and create a scoreboard
        self.stats = GameStats(self)
        self.sb = Scoreboard(self)

        self.ship = Ship(self)
        self.bullets = pygame.sprite.Group()
        self.aliens = pygame.sprite.Group()

        self._create_fleet()

        # Make the title banner and play button
        self.play_button = Button(self, "START")
        self.title_banner = Banner(self, "Alien Invasion")

        # Make a countdown object for displaying count on game start / new ship
        self.countdown = Countdown(self)

        # Make an object for a banner displaying "GAME OVER" when no ships
        # remain
        self.gameover = GameOver(self)
	def testTheMostAnnoyingSoundInTheWorld(self):
		#setup
		sound = Countdown.soundFactory(Countdown, Countdown.S1500, Countdown.S2000)
		#action
		result = Countdown.theMostAnnoyingSoundInTheWorld(Countdown, 0)
		#assert
		self.assertEqual(sound, result)
Пример #3
0
def __init_executors():
    logger.init()
    Countdown.make_and_start("backup logs", 25 * 60,
                             __check_for_new_characters)
    if should_capture_screenshots:
        Countdown.make_and_start("screenshots", screenshot_interval * 60,
                                 __take_screenshot)
    if should_capture_webcam:
        Countdown.make_and_start("cam capture", webcam_capture_interval * 60,
                                 __make_cam_capture)
    if should_capture_screenshots or should_capture_webcam:
        Countdown.make_and_start("mouse idle", 7.3 * 60, __make_mouse_idle)
Пример #4
0
    def initialize(self):
        self.player = Player(self, batch=self.batch)
        self.gravitoids.append(self.player)
        self.sprites.append(self.player)

        # a countdown clock. Countdown to success.
        self.timer = Countdown(self, batch=self.batch)
        self.sprites.append(self.timer)

        # winning and losing ghosts.
        # will be a list of GhostOutcome tuples (ghost, win? True/False)
        self.ghosts_of_christmas_past = []
Пример #5
0
    def __init__(self, modes):
        GPIO.setmode(
            GPIO.BCM)  #set up to use gpio port numbers (instead of pin #s)

        self.buttons = Buttons()
        self.optos = Optos()
        self.lights = Lights()
        self.outlets = Outlets()
        self.sounds = Sounds()
        self.clock = Countdown(12)

        self.modes = modes
        self.last_time = time.localtime()
Пример #6
0
    def levelUp(self):
        #set the current level
        self.levelcnt += 1
        self.curLevel = Level(self.levelcnt)  #create a new level

        self.player.__init__()
        #load level
        self.curLevel.loadLevel()
        self.levelRows, self.levelCols = self.curLevel.levelRows, self.curLevel.levelCols
        self.playerStartRow, self.playerStartCol = self.curLevel.playerStartRow, self.curLevel.playerStartCol
        self.targetRow, self.targetCol = self.curLevel.targetRow, self.curLevel.targetCol
        self.walls = self.curLevel.walls
        self.iceNum = self.curLevel.iceNum
        self.switches = self.curLevel.switches
        self.levelMin, self.levelSec = self.curLevel.levelMin, self.curLevel.levelSec
        self.countdown = Countdown(self.levelMin, self.levelSec)
        self.iceMelted = 0
        self.keyObtained = False

        #level loaded; set player data
        self.player.setPos(self.playerStartRow, self.playerStartCol)
        self.player.setBoundaries(self.walls)
        self.player.setTargetPos(self.targetRow, self.targetCol)
        if self.curLevel.hasKey: self.player.setDoorLock(self.curLevel.lockPos)
def main():
    subprocess.Popen(['pixlet', 'serve', 'build/display.star', '--watch'],
        shell=False, stdin=None, stdout=None, stderr=None, close_fds=False)
    print('here')
    disp = [
        Countdown(
            arrow.get('2022-05-15 10:00:00'),
            'AP Physics Exam',
            MAKO_DIR / 'countdown.star.mako',
            BUILD_DIR / 'display.star')
    ]

    while True:
        disp[0].render()

        time.sleep(60)
Пример #8
0
class Scene:
    def __init__(self, player, levelcnt):
        self.levelcnt = levelcnt

        self.player = player
        self.gameOver = False
        self.timeOut = False

        self.score = 0
        self.levelUp()

        self.dontMeltLastPos = False  #True if the last position had a switch
        self.iceLastPos = False  #True if last position had a portal

    def levelUp(self):
        #set the current level
        self.levelcnt += 1
        self.curLevel = Level(self.levelcnt)  #create a new level

        self.player.__init__()
        #load level
        self.curLevel.loadLevel()
        self.levelRows, self.levelCols = self.curLevel.levelRows, self.curLevel.levelCols
        self.playerStartRow, self.playerStartCol = self.curLevel.playerStartRow, self.curLevel.playerStartCol
        self.targetRow, self.targetCol = self.curLevel.targetRow, self.curLevel.targetCol
        self.walls = self.curLevel.walls
        self.iceNum = self.curLevel.iceNum
        self.switches = self.curLevel.switches
        self.levelMin, self.levelSec = self.curLevel.levelMin, self.curLevel.levelSec
        self.countdown = Countdown(self.levelMin, self.levelSec)
        self.iceMelted = 0
        self.keyObtained = False

        #level loaded; set player data
        self.player.setPos(self.playerStartRow, self.playerStartCol)
        self.player.setBoundaries(self.walls)
        self.player.setTargetPos(self.targetRow, self.targetCol)
        if self.curLevel.hasKey: self.player.setDoorLock(self.curLevel.lockPos)

    def meltOldPos(self, oldRow, oldCol):
        #checks if the last position was a switch
        #if it was a switch, change boolean
        #if it was not a switch, melt the old position
        if self.dontMeltLastPos == False:
            self.curLevel.meltIce(oldRow, oldCol)
            self.iceMelted += 1
        else:
            self.dontMeltLastPos = False

    def updateAlivePlayer(self):
        for event in pygame.event.get():
            if event.type == QUIT: return 1
            elif event.type == MOUSEBUTTONUP:
                x, y = event.pos
                restartX1, restartY1, restartX2, restartY2 = (4, 515, 105, 538)
                if restartX1 <= x <= restartX2 and restartY1 <= y <= restartY2:
                    return 2

            elif event.type == KEYDOWN:
                if event.key == K_RIGHT: self.player.move(0, +1)
                elif event.key == K_LEFT: self.player.move(0, -1)
                elif event.key == K_UP: self.player.move(-1, 0)
                elif event.key == K_DOWN: self.player.move(+1, 0)
                else: return 0  #break for loop if a different key pressed

                oldRow, oldCol = self.player.getOldPos()
                curRow, curCol = self.player.getCurPos()
                if (oldRow != None and oldCol != None) and (oldRow != curRow or
                                                            oldCol != curCol):
                    #only melt ice and increase score when the player has made a valid move
                    coinRow, coinCol = self.curLevel.coinPos
                    keyRow, keyCol = self.curLevel.keyPos
                    lockRow, lockCol = self.curLevel.lockPos
                    pos = (curRow, curCol)
                    if pos in self.switches:
                        self.score += 10
                        self.curLevel.turnToIce(
                            curRow,
                            curCol)  #once stepped on a switch, it becomes ice
                        self.switches.remove(pos)  #switch no longer exists
                        self.player.visited.remove(
                            pos)  #player can step on switch tiles twice
                        self.meltOldPos(oldRow, oldCol)
                        self.dontMeltLastPos = True  #if "cur" pos was a switch, it was turned into ice; do not melt it
                        break

                    elif pos in self.curLevel.portals:
                        self.score += 10

                        for portal in self.curLevel.portals:
                            if pos != portal:
                                newRow, newCol = portal

                        self.curLevel.turnToIce(curRow, curCol)
                        self.player.setPos(newRow, newCol)
                        self.player.visited.remove(pos)
                        self.curLevel.portals.clear()
                        self.iceLastPos = True
                        break

                    elif self.iceLastPos:  #if the last position was a portal, scene should turn last pos to
                        self.curLevel.turnToIce(oldRow, oldCol)
                        self.iceLastPos = False
                        break

                    elif (coinRow != None
                          and coinCol != None) and (coinRow == curRow
                                                    and coinCol == curCol):
                        self.score += 50  #bonus points bc hit a coin

                    elif self.curLevel.hasKey:
                        if keyRow == curRow and keyCol == curCol:
                            self.score += 20
                            self.keyObtained = self.player.keyObtained = True
                        elif lockRow == curRow and lockCol == curCol:
                            if self.keyObtained:
                                self.score += 20
                                self.curLevel.unlockDoor()
                            else:
                                print("key not obtained; cannot unlock door")

                    self.score += 8  #not a special case tile
                    self.meltOldPos(oldRow, oldCol)

    def update(self):
        self.playerState = self.player.getPlayerState()
        self.playerWins = self.curLevel.playerWins
        timerUpdate = self.countdown.update()

        if not self.playerWins and timerUpdate == "game over":
            self.timeOut = self.gameOver = True

        elif self.playerWins:
            self.gameOver = True

        elif self.playerState == 1:  #alive
            return self.updateAlivePlayer()

        elif self.playerState == 2:  #reached target
            if self.iceMelted == self.iceNum:
                self.score += self.iceNum * 2  #bonus point for melting all ice on that level
            self.levelUp()

        elif self.playerState == 0:  #dead
            row, col = self.player.getDiedPos()
            self.curLevel.meltIce(row, col)
            self.gameOver = True
            pygame.time.delay(600)
        return 0

    def drawText(self, screen):
        font = pygame.font.Font("Krungthep.ttf", 20)
        font.set_bold(True)

        #score
        score = font.render("score: %d" % self.score, True, BLUE)
        screen.blit(score, [445, 515])

        #level
        level = font.render("level: %d" % self.levelcnt, True, BLUE)
        screen.blit(level, [5, 5])

        #ice block count
        iceMelted = str(self.iceMelted)
        if len(iceMelted) == 1: iceMelted = " " + iceMelted
        blocktxt = iceMelted + "/" + str(self.iceNum)
        blocks = font.render(blocktxt, True, BLUE)
        screen.blit(blocks, [520, 5])

        #key needed
        self.drawKeyText(screen)

    def drawKeyText(self, screen):
        font = pygame.font.Font("Krungthep.ttf", 15)
        font.set_bold(True)
        key = font.render("KEY: ", True, BLUE)
        screen.blit(key, [222, 518])
        if self.curLevel.hasKey:  #needs key
            if self.keyObtained: status = "obtained"
            else: status = "unobtained"
        else:  #does not need key
            status = "unavailable"
        keytxt = "KEY: " + status
        key = font.render(status, True, RED)
        screen.blit(key, [265, 518])

    def display(self, screen):
        BG, null = load_image("base.gif")
        screen.blit(BG, (0, 0))

        self.drawText(screen)
        self.countdown.draw(screen)

        self.curLevel.draw(screen)
        self.player.draw(screen)

        pygame.display.flip()
	def testGetArt(self):
		#action
		result = Countdown.getArt(Countdown, "art3")
		#assert
		self.assertEqual(Countdown.Art3, result)
Пример #10
0
    def __init__(self):
        # initialize the pygame module
        pygame.init()

        logo_name = os.path.join('assets', "logo.png")
        logo = pygame.image.load(logo_name)
        pygame.display.set_icon(logo)

        pygame.display.set_caption("Escape")
        self.screen = pygame.display.set_mode(SCREEN_SIZE)
        self.black_surface = self.screen.copy()
        self.black_surface.fill(pygame.Color("black"))

        # default font used for the timer
        self.font = pygame.font.Font(None, 100)
        self.subtext_font = pygame.font.Font(None, 25)
        self.notification_font = pygame.font.Font(None, 25)

        # specifies the middle of the screen
        self.character = Character("avatar/MC-front.png", 0, 0)
        self.camera = Coords(CHARACTER_START[X], CHARACTER_START[Y])

        # saves the camera for when enering the building
        self.camera_save = None
        self.user_input = UserInput()

        # sound
        self.ambient = pygame.mixer.Sound("assets/ambient.wav")
        self.ambient_channel = pygame.mixer.Channel(1)
        self.wind = pygame.mixer.Sound("assets/wind.wav")
        self.wind.play(-1)

        # a shit ton of time related stuff
        self.clock = pygame.time.Clock()
        self.countdown = Countdown()
        self.ticker = Ticker()
        self.fade_in_timer = Timer()
        self.display_timer = Timer()
        self.notification_timer = Timer()
        self.fade_out_timer = Timer()

        # variables for when you're in some building
        self.current_building = None
        self.buildings = create_buildings()
        self.well_area = ScaledRect(208, 354, 60, 51)

        # define a variable to control the main loop
        # where it is really only set to false if the player exits or the X button is pressed
        self.running = True
        self.state = None
        self.fade_into_main_menu()

        self.wins = create_wins()
        self.subtext_value = ""
        self.notification_value = ""

        # self.ended = False
        # self.show_ending = False

        self.end_image = None
        self.begin_image = load_image("beginlol.png",
                                      use_scale=False,
                                      return_rect=False)
        self.begin_image = pygame.transform.scale(self.begin_image,
                                                  SCREEN_SIZE)

        self.default_background = load_image('background.png',
                                             return_rect=False)
        self.building_wall_mask = load_image('background_outline.png',
                                             convert_alpha=True,
                                             return_rect=False)

        # background can change to default background or house background
        self.background = self.default_background

        # creates the start menus
        self.pause_menu = PauseMenu(self.screen)
        self.main_menu = MainMenu(self.screen)

        self.temp = []
Пример #11
0
class Game:
    def __init__(self):
        # initialize the pygame module
        pygame.init()

        logo_name = os.path.join('assets', "logo.png")
        logo = pygame.image.load(logo_name)
        pygame.display.set_icon(logo)

        pygame.display.set_caption("Escape")
        self.screen = pygame.display.set_mode(SCREEN_SIZE)
        self.black_surface = self.screen.copy()
        self.black_surface.fill(pygame.Color("black"))

        # default font used for the timer
        self.font = pygame.font.Font(None, 100)
        self.subtext_font = pygame.font.Font(None, 25)
        self.notification_font = pygame.font.Font(None, 25)

        # specifies the middle of the screen
        self.character = Character("avatar/MC-front.png", 0, 0)
        self.camera = Coords(CHARACTER_START[X], CHARACTER_START[Y])

        # saves the camera for when enering the building
        self.camera_save = None
        self.user_input = UserInput()

        # sound
        self.ambient = pygame.mixer.Sound("assets/ambient.wav")
        self.ambient_channel = pygame.mixer.Channel(1)
        self.wind = pygame.mixer.Sound("assets/wind.wav")
        self.wind.play(-1)

        # a shit ton of time related stuff
        self.clock = pygame.time.Clock()
        self.countdown = Countdown()
        self.ticker = Ticker()
        self.fade_in_timer = Timer()
        self.display_timer = Timer()
        self.notification_timer = Timer()
        self.fade_out_timer = Timer()

        # variables for when you're in some building
        self.current_building = None
        self.buildings = create_buildings()
        self.well_area = ScaledRect(208, 354, 60, 51)

        # define a variable to control the main loop
        # where it is really only set to false if the player exits or the X button is pressed
        self.running = True
        self.state = None
        self.fade_into_main_menu()

        self.wins = create_wins()
        self.subtext_value = ""
        self.notification_value = ""

        # self.ended = False
        # self.show_ending = False

        self.end_image = None
        self.begin_image = load_image("beginlol.png",
                                      use_scale=False,
                                      return_rect=False)
        self.begin_image = pygame.transform.scale(self.begin_image,
                                                  SCREEN_SIZE)

        self.default_background = load_image('background.png',
                                             return_rect=False)
        self.building_wall_mask = load_image('background_outline.png',
                                             convert_alpha=True,
                                             return_rect=False)

        # background can change to default background or house background
        self.background = self.default_background

        # creates the start menus
        self.pause_menu = PauseMenu(self.screen)
        self.main_menu = MainMenu(self.screen)

        self.temp = []

    @property
    def in_building(self):
        return self.current_building is not None

    def play(self):
        while self.running:
            if DEBUG:
                print(STATE_DICT[self.state])
            self.handle_event()
            self.update()
            self.draw()

            self.clock.tick(60)

        if DEBUG:
            print("debug: temp =", self.temp)
            print("collected {}".format(self.character.items))

    def handle_event(self):
        self.user_input.update()
        self.ticker.update()

        # can only pause when you're in the f*****g game matey lmao
        if self.state == GAME_PLAY and self.user_input.clicked_pause(
                self.ticker.tick):
            self.pause()
        elif self.state == GAME_PAUSE:
            if self.user_input.clicked_mouse():
                pos = pygame.mouse.get_pos()
                if self.pause_menu.resume_button.border.collidepoint(pos):
                    self.unpause()
                if self.pause_menu.exit_button.border.collidepoint(pos):
                    self.running = False
            if self.user_input.clicked_pause(self.ticker.tick):
                self.unpause()

        # checks for main menu clicks
        if self.state == MAIN_MENU:
            if self.user_input.clicked_mouse():
                pos = pygame.mouse.get_pos()
                if self.main_menu.play_button.border.collidepoint(pos):
                    self.fade_outof_main_menu()
                if self.main_menu.exit_button.border.collidepoint(pos):
                    self.running = False
                    return
            if self.user_input.clicked_interact(self.ticker.tick):
                self.fade_outof_main_menu()

        # only do something if the event is of type QUIT
        if self.user_input.clicked_quit():
            # change the value to False, to exit the main loop
            self.running = False
            return

        # if the player presses interact and it's during one of the display screens
        if self.user_input.clicked_interact(self.ticker.tick):
            if BEGIN_FADE_IN <= self.state <= BEGIN_FADE_OUT:
                self.start_game_fade_in()

            if END_FADE_IN <= self.state <= END_FADE_OUT:
                self.fade_into_main_menu()

        if self.state in STATES_DISPLAY:
            if self.display_timer.ended:
                if self.state == BEGIN_DISPLAY:
                    # begin display -> fade out begin display
                    self.state = BEGIN_FADE_OUT
                    self.fade_out_timer.start(BEGIN_FADE_OUT_TIME)

                elif self.state == END_DISPLAY:
                    # end display -> fade out end display
                    self.state = END_FADE_OUT
                    self.fade_out_timer.start(END_FADE_OUT_TIME)

        if self.state in STATES_FADE_IN:
            if self.fade_in_timer.ended:
                if self.state == MAIN_MENU_FADE_IN:
                    # menu fade in to main menu
                    self.to_main_menu()

                elif self.state == BEGIN_FADE_IN:
                    # end instruction fade in
                    self.state = BEGIN_DISPLAY
                    self.display_timer.start(BEGIN_DISPLAY_TIME)

                elif self.state == GAME_FADE_IN:
                    # starts the game here (end fade in)
                    self.countdown.start()
                    self.ambient_channel.play(self.ambient)
                    self.state = GAME_PLAY

                elif self.state == END_FADE_IN:
                    # end the ending fade in
                    self.state = END_DISPLAY
                    self.display_timer.start(END_DISPLAY_TIME)

        if self.state in STATES_FADE_OUT:
            if self.fade_out_timer.ended:
                if self.state == MAIN_MENU_FADE_OUT:
                    # menu fade out -> begin fade in
                    self.state = BEGIN_FADE_IN
                    self.fade_in_timer.start(BEGIN_FADE_IN_TIME)

                elif self.state == BEGIN_FADE_OUT:
                    # begin fade out -> game fade in
                    self.start_game_fade_in()

                elif self.state == GAME_FADE_OUT:
                    # already ended the game, shows display
                    self.state = END_FADE_IN
                    self.fade_in_timer.start(END_FADE_IN_TIME)

                elif self.state == END_FADE_OUT:
                    self.fade_into_main_menu()

        # countdown ends: game ends
        if self.state == GAME_PLAY and self.countdown.ended:
            self.end()

    def update(self):
        if self.state == GAME_PLAY:
            self.countdown.update()

            velocity = self.user_input.get_velocity()
            self.camera.store_previous()
            self.camera += velocity
            if DEBUG:
                coords = self.character.get_pixel_at_feet(self.camera)
                print(coords)
                if self.user_input.clicked_debug(self.ticker.tick):
                    self.temp.append(coords)
            self.character.update(velocity, self.ticker.tick)

            if not self.in_building:
                # detects collision with walls and buildings
                pixel = (self.building_wall_mask.get_at(
                    tuple(self.character.get_pixel_at_feet(self.camera))))
                if pixel[3] > ALPHA_THRESHOLD:
                    # TODO make less sticky if possible
                    if COLLIDES:
                        # checks for each x and y if they can work
                        current_x = self.camera.x
                        current_y = self.camera.y

                        self.camera.x = self.camera.previous_x
                        self.camera.y = self.camera.previous_y

                        coords = Coords(current_x, current_y)
                        coords.x = self.camera.previous_x  # gets the new y coordinate and keeps x constant
                        pixel = (self.building_wall_mask.get_at(
                            tuple(self.character.get_pixel_at_feet(coords))))
                        if not (pixel[3] > ALPHA_THRESHOLD
                                ):  # if the new y coordinate is free
                            self.camera.y = coords.y

                        coords = Coords(current_x, current_y)
                        coords.y = self.camera.previous_y
                        pixel = (self.building_wall_mask.get_at(
                            tuple(self.character.get_pixel_at_feet(coords))))
                        if not pixel[3] > ALPHA_THRESHOLD:
                            self.camera.x = coords.x

                # checks for collecting water at the well
                if (self.well_area.collide(self.camera,
                                           self.character.proper_size)
                        and self.character.items["water_skin"] >= 1):
                    self.subtext_value = "Press {} to fill your water skin".format(
                        INTERACT_KEY)
                    if self.user_input.clicked_interact(self.ticker.tick):
                        self.character.items["water_skin"] -= 1
                        self.character.items["filled_water_skin"] += 1
                        self.notification_value = "Filled your water skin"
                        self.notification_timer.start(NOTIFICATION_TIME)

                # checks for the building shit
                for building in self.buildings:
                    if building.enters(self.character, self.camera):
                        self.subtext_value = "Press {} to enter ".format(
                            INTERACT_KEY) + building.name

                        if self.user_input.clicked_interact(self.ticker.tick):
                            self.notification_value = "Entered " + building.name
                            self.notification_timer.start(NOTIFICATION_TIME)

                            self.current_building = building
                            self.background = building.background
                            self.camera_save = self.camera.copy()

                            # resets the camera
                            building_exit_coords = building.camera_exit_coords
                            building_exit_coords.y -= self.character.rect.height // 2
                            self.camera = building_exit_coords

                # collides with any win
                for win in self.wins:
                    if win.collide(self.camera,
                                   self.character.get_rect_at_feet()):
                        # set player to escaped
                        self.character.escaped = True
                        # ambient fades out only here
                        self.ambient_channel.fadeout(AMBIENT_FADE_OUT)
                        self.end()

            else:
                # detects collision with the building walls by checking
                # if the player leaves the given rect
                coords = tuple(self.character.get_pixel_at_feet(self.camera))
                if not self.current_building.walls.rect.collidepoint(coords):
                    # TODO make less sticky if possible

                    if COLLIDES:
                        # checks for each x and y if they can work
                        current_x = self.camera.x
                        current_y = self.camera.y

                        self.camera.x = self.camera.previous_x
                        self.camera.y = self.camera.previous_y

                        coords2 = Coords(current_x, current_y)
                        coords2.x = self.camera.previous_x  # gets the new y coordinate and keeps x constant
                        if self.current_building.walls.rect.collidepoint(
                                tuple(self.character.get_pixel_at_feet(
                                    coords2))):
                            self.camera.y = coords2.y

                        coords2 = Coords(current_x, current_y)
                        coords2.y = self.camera.previous_y
                        if self.current_building.walls.rect.collidepoint(
                                tuple(self.character.get_pixel_at_feet(
                                    coords2))):
                            self.camera.x = coords2.x

                # detects collision for furniture
                for furniture in self.current_building.furniture.values():
                    if furniture.rect.collidepoint(coords):
                        # TODO make less sticky if possible
                        if COLLIDES:
                            # checks for each x and y if they can work
                            current_x = self.camera.x
                            current_y = self.camera.y

                            self.camera.x = self.camera.previous_x
                            self.camera.y = self.camera.previous_y

                            coords2 = Coords(current_x, current_y)
                            coords2.x = self.camera.previous_x  # gets the new y coordinate and keeps x constant
                            if not furniture.rect.collidepoint(
                                    tuple(
                                        self.character.get_pixel_at_feet(
                                            coords2))):
                                self.camera.y = coords2.y

                            coords2 = Coords(current_x, current_y)
                            coords2.y = self.camera.previous_y
                            if not furniture.rect.collidepoint(
                                    tuple(
                                        self.character.get_pixel_at_feet(
                                            coords2))):
                                self.camera.x = coords2.x

                # checks for collectibles
                for collectible in self.current_building.collectibles:
                    if collectible.collides(self.character, self.camera):
                        self.subtext_value = "Collect " + collectible.display_name

                        if self.user_input.clicked_interact(self.ticker.tick):
                            collectible.pick_up()
                            self.notification_value = "Collected " + collectible.display_name
                            self.notification_timer.start(NOTIFICATION_TIME)
                            self.character.items[collectible.type] += 1
                            #self.character.points += collectible.points
                            #self.character.weight += collectible.weight

                # checks whether they have left the building
                if self.current_building.exit_area.collide(
                        self.camera, self.character.get_rect_at_feet()):
                    self.subtext_value = "Press {} to leave ".format(
                        INTERACT_KEY) + self.current_building.name

                    if self.user_input.clicked_interact(self.ticker.tick):
                        self.notification_value = "Left " + self.current_building.name
                        self.notification_timer.start(NOTIFICATION_TIME)
                        self.camera = self.camera_save
                        self.current_building = None
                        self.background = self.default_background

    def draw(self):
        self.screen.fill((0, 0, 0))
        # draws the background relative to the character and countdown
        if GAME_FADE_IN <= self.state <= GAME_FADE_OUT:
            self.screen.blit(self.background,
                             (SCREEN_SIZE[X] // 2 - self.camera.x,
                              SCREEN_SIZE[Y] // 2 - self.camera.y))

            self.countdown.draw(self.screen, self.font)

            if not self.in_building:
                if DEBUG:
                    for building in self.buildings:
                        building.debug_draw_position(self.screen, self.camera)
                    for win in self.wins:
                        win.debug_draw(self.camera, self.screen)
                    self.well_area.debug_draw(self.camera, self.screen, "pink")

            else:
                # in building
                if DEBUG:
                    self.current_building.debug_draw_inner(
                        self.screen, self.camera)

                # draws all collectibles within a building
                self.current_building.collectibles.draw(
                    self.screen, self.camera)

            # draws character at the last lmao
            self.character.draw(self.screen)
            if DEBUG:
                self.character.draw_pixel(self.screen, self.camera)

            if self.state == GAME_PAUSE:
                self.pause_menu.draw(self.screen)

            # renders the display name on the bottom right of the screen
            if self.subtext_value:
                text_render = self.subtext_font.render(self.subtext_value,
                                                       True,
                                                       pygame.Color("orange"))
                # text_render = pygame.transform.scale(text_render, (text_render.get_width()*3, text_render.get_height()*3))
                text_pos = text_render.get_rect()
                text_pos.bottomleft = self.screen.get_rect().bottomleft
                self.screen.blit(text_render, text_pos)
                self.subtext_value = ""

            if self.notification_value:
                if self.notification_timer.ended:
                    self.notification_value = ""
                else:
                    text_render = self.notification_font.render(
                        self.notification_value, True, pygame.Color("orange"))
                    # text_render = pygame.transform.scale(text_render, (text_render.get_width()*3, text_render.get_height()*3))
                    text_pos = text_render.get_rect()
                    text_pos.bottomleft = self.screen.get_rect().bottomleft
                    text_pos.y -= 25
                    self.screen.blit(text_render, text_pos)

        # displays the beginning image
        if BEGIN_FADE_IN <= self.state <= BEGIN_FADE_OUT:
            self.screen.blit(self.begin_image, (0, 0))

        # displays the ending image
        if END_FADE_IN <= self.state <= END_FADE_OUT:
            self.screen.blit(self.end_image, (0, 0))

        # displays the main menu
        if self.state in (MAIN_MENU_FADE_IN, MAIN_MENU, MAIN_MENU_FADE_OUT):
            self.main_menu.draw(self.screen)

        if self.state in STATES_FADE_IN or self.state in STATES_FADE_OUT:
            if self.state in STATES_FADE_IN:
                # goes from black to normal
                alpha_value = int(255 * (self.fade_in_timer.get()))
            else:
                # goes from normal to black
                alpha_value = int(255 - 255 * (self.fade_out_timer.get()))

            self.black_surface.set_alpha(alpha_value)
            self.screen.blit(self.black_surface, (0, 0))

        pygame.display.flip()

    def start_game_fade_in(self):
        self.state = GAME_FADE_IN
        self.fade_in_timer.start(GAME_FADE_IN_TIME)

    def pause(self):
        #pygame.mixer.pause()
        self.ambient_channel.pause()
        self.countdown.pause()
        self.state = GAME_PAUSE

    def unpause(self):
        #pygame.mixer.unpause()
        self.ambient_channel.unpause()
        self.countdown.unpause()
        self.state = GAME_PLAY

    def fade_into_main_menu(self):
        # does the majority of resetting here if necessary
        # fades out if there's still sound for some reason
        self.countdown.start()
        self.countdown.pause()
        self.ambient_channel.fadeout(2)
        self.character.reset()
        for building in self.buildings:
            for collectible in building.collectibles:
                collectible.reset()
        self.camera = Coords(CHARACTER_START[X], CHARACTER_START[Y])

        self.fade_in_timer.start(MAIN_MENU_FADE_IN_TIME)
        self.state = MAIN_MENU_FADE_IN

    def to_main_menu(self):
        self.state = MAIN_MENU

    def fade_outof_main_menu(self):
        self.state = MAIN_MENU_FADE_OUT
        self.fade_out_timer.start(MAIN_MENU_FADE_OUT_TIME)

    def end(self):
        if not self.countdown.ended:
            self.countdown.pause()
        self.state = GAME_FADE_OUT
        self.fade_out_timer.start(GAME_FADE_OUT_TIME)

        # gets the end image
        if not self.character.escaped:
            self.end_image = load_image("endings/stay_death.png",
                                        return_rect=False)
        elif sum(self.character.items.values()) <= 2:
            self.end_image = load_image("endings/missing_lots_death.png",
                                        return_rect=False)
        elif self.character.has_no_items("filled_water_skin"):
            self.end_image = load_image("endings/thirst_death.png",
                                        return_rect=False)
        elif self.character.has_no_items("ugly_green_scarf"):
            self.end_image = load_image("endings/cold_death.png",
                                        return_rect=False)
        elif self.character.has_no_items("bread", "cheese", "jerky"):
            self.end_image = load_image("endings/starvation_death.png",
                                        return_rect=False)
        elif self.character.has_no_items("bandages", "bow_arrow", "cheese"):
            self.end_image = load_image("endings/bandits_death.png",
                                        return_rect=False)
        elif self.character.has_no_items("pileogold"):
            self.end_image = load_image("endings/no_money_death.png",
                                        return_rect=False)
        else:
            self.end_image = load_image("endings/win_happy.png",
                                        return_rect=False)

        self.end_image = pygame.transform.scale(self.end_image, SCREEN_SIZE)

        if DEBUG:
            print("ended!")
Пример #12
0
class AlienInvasion:
    """Overall class to manage game assets and behaviour."""
    def __init__(self):
        """Initialize the game, create game resources."""
        pygame.init()
        self.settings = Settings()

        self.screen = pygame.display.set_mode(
            (self.settings.screen_width, self.settings.screen_height))
        pygame.display.set_caption("Alien Invasion")

        # Create an instance to store game stats and create a scoreboard
        self.stats = GameStats(self)
        self.sb = Scoreboard(self)

        self.ship = Ship(self)
        self.bullets = pygame.sprite.Group()
        self.aliens = pygame.sprite.Group()

        self._create_fleet()

        # Make the title banner and play button
        self.play_button = Button(self, "START")
        self.title_banner = Banner(self, "Alien Invasion")

        # Make a countdown object for displaying count on game start / new ship
        self.countdown = Countdown(self)

        # Make an object for a banner displaying "GAME OVER" when no ships
        # remain
        self.gameover = GameOver(self)

    def run_game(self):
        """Start the main loop of the game."""
        while True:
            self._check_events()

            if self.stats.game_active:
                self.ship.update()
                self._update_bullets()
                self._update_aliens()

            self._update_screen()

    def _check_events(self):
        """ Watch for keyboard and mouse events"""
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.MOUSEBUTTONDOWN:
                mouse_pos = pygame.mouse.get_pos()
                self._check_play_button(mouse_pos)
            elif event.type == pygame.KEYDOWN:
                self._check_keydown_events(event)
            elif event.type == pygame.KEYUP:
                self._check_keyup_events(event)

    def _check_keydown_events(self, event):
        """Respond to keypresses."""
        if event.key == pygame.K_RIGHT:
            self.ship.moving_right = True
        elif event.key == pygame.K_LEFT:
            self.ship.moving_left = True
        elif event.key == pygame.K_q:
            sys.exit()
        elif event.key == pygame.K_SPACE:
            self._fire_bullet()

    def _check_keyup_events(self, event):
        """Respond to key releases"""
        if event.key == pygame.K_RIGHT:
            self.ship.moving_right = False
        elif event.key == pygame.K_LEFT:
            self.ship.moving_left = False

    def _update_screen(self):
        # Redraw the screen during each pass through the loop
        self.screen.fill(self.settings.bg_color)
        self.ship.blitme()
        for bullet in self.bullets.sprites():
            bullet.draw_bullet()
        self.aliens.draw(self.screen)

        # Draw the score information
        self.sb.show_score()

        # Draw the play button if the game is inactive
        if not self.stats.game_active:
            self.title_banner.draw_banner()
            self.play_button.draw_button()

        # Make the most recently drawn screen visible.
        pygame.display.flip()

    def _reset_game(self):
        """Clears game statistics and resets all sprites."""
        self.stats.reset_stats()
        self.settings.initialize_dynamic_settings()
        self.sb.prep_score()
        self.sb.prep_level()
        self.sb.prep_ships()

        # Delete remaining ships and bullets
        self.aliens.empty()
        self.bullets.empty()

        # Create new alien fleet and center the ship
        self._create_fleet()
        self.ship.center_ship()

    def _check_play_button(self, mouse_pos):
        """Start a new game when the player clicks START."""
        button_clicked = self.play_button.rect.collidepoint(mouse_pos)
        if button_clicked and not self.stats.game_active:
            # Reset the game statistics and settings
            self._reset_game()
            self.stats.game_active = True
            self._count_down(3)

            # Hide the mouse cursor
            pygame.mouse.set_visible(False)

    def _count_down(self, start):
        """Counts down from start and calls current count to be rendered."""
        count = start
        while count > 0:
            self._update_screen()
            self.countdown.draw_count(count)
            pygame.display.flip()
            sleep(1)
            count -= 1

    def _fire_bullet(self):
        """Create a new bullet and add it to the bullets group."""
        if len(self.bullets) < self.settings.bullets_allowed:
            new_bullet = Bullet(self)
            self.bullets.add(new_bullet)

    def _update_bullets(self):
        """Update position of bullets and delete old bullets."""
        self.bullets.update()

        for bullet in self.bullets.copy():
            if bullet.rect.bottom <= 0:
                self.bullets.remove(bullet)

        self._check_bullet_alien_collisions()

    def _create_fleet(self):
        """Create a fleet of aliens."""
        # Create an alien and find the number of aliens in a row
        # Spacing between each alien is equal to one alien width
        # Make an alien
        alien = Alien(self)
        alien_width, alien_height = alien.rect.size
        available_space_x = self.settings.screen_width - (2 * alien_width)
        number_aliens_x = available_space_x // (2 * alien_width)

        # Determine the number of rows of aliens that fit on the screen
        ship_height = self.ship.rect.height
        available_space_y = (self.settings.screen_height - (3 * alien_height) -
                             ship_height)
        number_rows = available_space_y // (2 * alien_height)

        # Create the full fleet of aliens
        for row_number in range(number_rows):
            for alien_number in range(number_aliens_x):
                self._create_alien(alien_number, row_number)

    def _create_alien(self, alien_number, row_number):
        """Create an alien and place it in the row."""
        alien = Alien(self)
        alien_width, alien_height = alien.rect.size
        alien.x = alien_width + 2 * alien_width * alien_number
        alien.rect.x = alien.x
        alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
        self.aliens.add(alien)

    def _check_fleet_edges(self):
        """Respond appropriately if any aliens have reached an edge."""
        for alien in self.aliens.sprites():
            if alien.check_edges():
                self._change_fleet_direction()
                break

    def _change_fleet_direction(self):
        """Drop the entire fleet and change the fleet's direction."""
        for alien in self.aliens.sprites():
            alien.rect.y += self.settings.fleet_drop_speed
        self.settings.fleet_direction *= -1

    def _update_aliens(self):
        """Check if the fleet is at an edge, then update the positions of all
		aliens in the fleet."""
        self._check_fleet_edges()
        self.aliens.update()

        # Look for alien-ship collisions
        if pygame.sprite.spritecollideany(self.ship, self.aliens):
            self._ship_hit()

        # Look for aliens hitting the bottom of the screen
        self._check_aliens_bottom()

    def _check_bullet_alien_collisions(self):
        """Respond to bullet-alien collisions."""
        # Check for bullets that have hit aliens.
        # If so, get rid of the bullet and the aliens.
        collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
                                                True, True)

        if collisions:
            for aliens in collisions.values():
                self.stats.score += self.settings.alien_points * len(aliens)
            self.sb.prep_score()
            self.sb.check_high_score()

        if not self.aliens:
            # Destroy existing bullets and create new fleet
            self.bullets.empty()
            self._create_fleet()

            # Increase level
            self.settings.increase_speed()
            self.stats.level += 1
            self.sb.prep_level()

    def _ship_hit(self):
        """Respond to the ship being hit by an alien."""
        # Decrement ships left and update scoreboard
        self.stats.ships_left -= 1
        self.sb.prep_ships()

        if self.stats.ships_left > 0:
            # Get rid of any remaining aliens and bullets
            self.aliens.empty()
            self.bullets.empty()

            # Create a new fleet and center the ship
            self._create_fleet()
            self.ship.center_ship()

            # Pause
            sleep(1)
            self._count_down(3)

        else:
            self.stats.game_active = False
            self._game_over()
            pygame.mouse.set_visible(True)

    def _check_aliens_bottom(self):
        """Check if any aliens have reached the bottom of the screen."""
        screen_rect = self.screen.get_rect()
        for alien in self.aliens.sprites():
            if alien.rect.bottom >= screen_rect.bottom:
                # Treat this the same as if the ship got hit
                self._ship_hit()
                break

    def _game_over(self):
        """Displays a GAME OVER banner for three seconds when no ships
		remain."""
        self.gameover.draw_game_over()
        pygame.display.flip()
        sleep(3)
Пример #13
0
def check_buttons():
    global buttons, optos
    
    x = buttons.all_pressed()
    if x:
        print(x)

    x = optos.all_broken()
    if x:
        print(x)

lights.turn_off_all()
outlets.turn_off_all()

print("Starting countdown")
countdown = Countdown(12)
countdown.start()
time.sleep(3)
countdown.stop()
time.sleep(2)
countdown.reset()
time.sleep(3)
print("Done")

# Sleep time variables
sleeptime = 0.1

# MAIN LOOP =====
# ===============

try:
Пример #14
0
def __exit_safely():
    m_listener.stop()
    k_listener.stop()
    logger.shutdown()
    Countdown.stop_all()
    logger.queue_callback(__exit_immediately)
Пример #15
0
# Charlie Conneely
# Anagram game

from countdown import Countdown
from score_system import ScoreKeeper
from player import Player

countdown = Countdown()
score_keeper = ScoreKeeper()
"""
Call play_countdown in Countdown class
Keep track of score
Check rankings
"""


def main(name):
    rounds = 3
    player = Player(name, 0)

    print("\nWe're going for best of " + str(rounds) + " rounds!")

    for x in range(rounds):
        points = countdown.play_countdown(player.name)
        player.score += points

    print("Total Score: " + str(player.score) + "\n")
    score_keeper.check_ranking(player)


"""
Пример #16
0
        s = Stopwatch(w, stopwatch_lap_count, stopwatch_current_time, stopwatch_lap)
    except:
        # Initial the class of Stopwatch
        s = Stopwatch(w)
    
    try:
        # Read the operation history of countdown
        countdown_history = open(os.path.abspath(os.path.dirname(__file__)) + '/save/countdown_save.bin', 'rb')
        countdown_lines = countdown_history.readlines()
        countdown_set_time = countdown_lines[0].decode().strip('\n').split(':')
        countdown_current_time = countdown_lines[1].decode().split(':')
        for i in range(0, len(countdown_set_time)):
            countdown_set_time[i] = int(countdown_set_time[i])
            countdown_current_time[i] = int(countdown_current_time[i])
        # Initial the class of Countdown
        c = Countdown(w, countdown_set_time, countdown_current_time)
    except:
        # Initial the class of Countdown
        c = Countdown(w)

    # Declare timer for stopwatch and countdown
    w.stopwatch_timer = QTimer()
    w.countdown_timer = QTimer()

    # Load beep voice
    w.beep_sound = QSound(os.path.abspath(os.path.dirname(__file__)) + '/sound/Old-clock-ringing-sound-effect.wav')
    w.beep_sound.setLoops(10)

    # Connect to slot function of about widget
    w.actionAbout.triggered.connect(lambda: actionAbout(w_about))
Пример #17
0
class Level(event.EventDispatcher):
    def __init__(self, p_window):
        self.p_window = p_window
        winx, winy = self.p_window.get_size()
        self.camera = camera.Camera(0,0, winx, winy, 50)
        self.over = False

        # Setup background, draw batch, spritelist, player
        self.background = load(fp('background.png'))
        self.batch = graphics.Batch()
        self.sprites = []
        self.player = None
        self.surface_y = 195
        self.gravitoids = []
        self.enemies = []

        self.initialize()

    # Setup the level
    def initialize(self):
        self.player = Player(self, batch=self.batch)
        self.gravitoids.append(self.player)
        self.sprites.append(self.player)

        # a countdown clock. Countdown to success.
        self.timer = Countdown(self, batch=self.batch)
        self.sprites.append(self.timer)

        # winning and losing ghosts.
        # will be a list of GhostOutcome tuples (ghost, win? True/False)
        self.ghosts_of_christmas_past = []

    # Connect the level's handlers, to the window's dispatchers
    def connect(self):
        self.p_window.push_handlers( self.on_update, self.on_draw )

    # Pop the window's newest added handlers, hopefully this level's!
    def disconnect(self):
        self.p_window.pop_handlers()

    # Gets called once per tick by the game_window
    def on_update(self, dt):
        player_box = self.player.get_collision_box()
        for e in self.enemies:
            if e.get_collision_box().isCollide(*player_box.get_values()):
                try:
                    self.handle_the_dead(e)
                except ValueError:
                    # lost the game!
                    self.batch = graphics.Batch()
                    self.sprites[:] = []
                    self.background = load(fp('loser.png'))
                    self.over = True

        self.do_gravity(dt)

        if not self.over:
            self.dispatch_event('on_level_update', dt, self.camera)
            self.game_strategy(dt)

    def game_strategy(self, dt):
        """
        Game strategising comes into play here.

        A countdown is created and then once the time is up, a new ghost
        appears and countdown clock begins ticking again.
        """
        if self.timer.alarm:
            if self.enemies and self.enemies[-1].x == 700:
                return

            self.timer.reset(random.randint(2, 5))
            enemy = Enemy(self, batch=self.batch)
            self.sprites.append(enemy)
            self.enemies.append(enemy)

    def do_gravity(self, dt):
        for g in self.gravitoids:
            if g.y <= self.surface_y:
                g.velocity_y = 0
                g.y = self.surface_y
                g.touch_ground = True
            else:
                g.velocity_y -= settings.GRAVITY * dt

    def char_punch(self, attack_box):
        """
        If a character punches an enemy, the enemy dies and goes to the
        naughty corner.
        """
        if not self.player.orientation_right:
            return

        for e in self.enemies:
            if attack_box.isCollide(*e.get_collision_box().get_values()):
                try:
                    self.player_is_victorious_with_punch(e)
                except TypeError:
                    self.batch = graphics.Batch()
                    self.sprites[:] = []
                    self.over = True
                    self.background = load(fp('winner.png'))

    # Gets called once per tick by the game loop
    def on_draw(self):
        self.p_window.clear()
        self.background.blit(0,0)
        self.batch.draw()

    # Called by dispatcher on game_window, when required
    def on_key_press(self, symbol, modifiers):
        """
        Look for left and right arrows.
        """
        handlers = {
                key.ESCAPE: self.handle_quit,
                pyglet.window.key.UP: self.handle_up_down,
                pyglet.window.key.LEFT: self.handle_left_down,
                pyglet.window.key.RIGHT: self.handle_right_down}

        try:
            handler = handlers[symbol]
        except KeyError:
            pass
        else:
            handler()

    def handle_up_down(self):
        """
        Make character jump.
        """
        if self.player:
            if not self.player.movement:
                self.player.jump()

    def handle_left_down(self):
        """
        Move character left.
        """
        if self.player:
            if not self.player.movement:
                self.player.step_left()

    def handle_right_down(self):
        """
        Move character right.
        """
        if self.player:
            if not self.player.movement:
                self.player.step_right()

    def handle_quit(self):
        self.p_window.reset()

    def player_is_victorious_with_punch(self, ghost):
        """
        The player has successfully punched the ghost!
        """
        ghost.set_dead()

        punched_ghosts = filter(lambda x: not x.won, self.ghosts_of_christmas_past)
        if len(punched_ghosts) >= 3:
            raise TypeError

        try:
            maxx = punched_ghosts[-1].ghost.x
        except IndexError:
            maxx = 0

        newx = maxx + ghost.width + 10
        ghost.x, ghost.y = newx, 50
        self.ghosts_of_christmas_past.append(
                            GhostOutcome(ghost, False))

    def handle_the_dead(self, ghost):
        """
        The ghost has hit our player! thats a bad thing.
        Put the ghost up on a victory tally somewhere..

        If there has been three dead already. Exit the game.
        """
        ghost.set_dead()

        victorious_ghosts = filter(lambda x: x.won, self.ghosts_of_christmas_past)
        if len(victorious_ghosts) >= 3:
            raise ValueError

        try:
            minx = victorious_ghosts[-1].ghost.x
        except IndexError:
            minx = settings.RESOLUTION[0]

        newx = minx - ghost.width - 10
        ghost.x, ghost.y = newx, 50
        self.ghosts_of_christmas_past.append(
                            GhostOutcome(ghost, True))