예제 #1
0
def stopGame():
    global camera
    Config.stopThreadsSetter(True)
    cam.join()
    pygame.quit()
    print("EXITED")
    raise SystemExit
예제 #2
0
    def drawScore(self):
        character = self._game.character
        pygame.font.init()
        textFont = pygame.font.SysFont("arial", 100)
        text = textFont.render(f"Score: {character.score}", True, (255, 0, 0),
                               (0, 0, 0))
        textRect = text.get_rect()
        textRect.center = (1920 // 2, 1080 // 2)

        exitFont = pygame.font.SysFont("arial", 64)
        exitText = exitFont.render("New Game", True, (255, 0, 0), (0, 0, 0))
        exitTextRect = exitText.get_rect()
        exitPos = (1920 // 2, 1080 - 50)
        exitTextRect.center = exitPos

        self.window.blit(text, textRect)
        self.window.blit(exitText, exitTextRect)

        exitPressed = False
        while not exitPressed:
            pygame.display.flip()
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    exitPressed = True
                if event.type == MOUSEBUTTONDOWN:
                    mPos = pygame.mouse.get_pos()
                    if (exitPos[0] - 150 <= mPos[0] <= exitPos[0] + 150) and (
                            exitPos[1] - 30 <= mPos[1] <= exitPos[1] + 30):
                        exitPressed = True
                if event.type == KEYDOWN or event.type == KEYUP:
                    if event.key == K_ESCAPE:
                        exitPressed = True
                        Config.stopThreadsSetter(True)
예제 #3
0
    def draw(self):
        """
        Function: Draws the grid, help button and the run button.
        """

        # detta måste garantera att
        game = self._game
        self.clock = pygame.time.Clock()
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                game.run = False
                Config.stopThreads_setter(True)

        self.window.fill(self.black)

        # Draw the grid
        currentMap = game.map
        for x in range(0, game.map_size[0]):
            for y in range(0, game.map_size[1]):
                if currentMap[y][x] == 1:
                    currentEntityImage = self._wallImage
                elif currentMap[y][x] == 0:
                    currentEntityImage = self._pathImage
                elif currentMap[y][x] == "f":
                    currentEntityImage = self._finishImage
                elif currentMap[y][x] == "c":
                    currentEntityImage = pygame.image.load(
                        f"graphics/character{game.character.direction.lower()}.jpg"
                    )
                elif currentMap[y][x] == "p":
                    currentEntityImage = self._foodImage

                self.window.blit(
                    currentEntityImage,
                    [(self.margin + self.width) * x + self.margin,
                     (self.margin + self.width) * y + self.margin])

        #Hjälp knappen
        _helpPos = (1300, 200)
        font = pygame.font.Font('freesansbold.ttf', 80)
        self._helpText = font.render(
            'HELP',
            True,
            self.red,
        )
        self._helpReact = self._helpText.get_rect()
        self._helpReact = _helpPos
        self.window.blit(self._helpText, self._helpReact)

        #Run knappen
        runPos = (1300, 600)
        self._runText = font.render("RUN", True, self.green)
        self._runReact = self._runText.get_rect()
        self._runReact = runPos
        self.window.blit(self._runText, self._runReact)

        self.clock.tick(self.FPS)
        pygame.display.flip()
예제 #4
0
def stop_game():
    """
    Function: stops and joins main and camera thread and exits the program.
    """
    global camera
    Config.stopThreads_setter(True)
    cam.join()
    pygame.quit()
    print("EXITED")
    raise SystemExit
예제 #5
0
    def camera_thread(stop):
        """
        Function; args stop (Bool), the main function of camera; runs until stop is True.
        """
        cam = cv2.VideoCapture(1)
        if not cam.isOpened():
            # (Failed): Trying to find external camera (for laptop).
            cam = cv2.VideoCapture(0)
            if not cam.isOpened():
                # (Failed): Trying to find external camera (for stat. computer) or laptop's built in camera.
                Config.stopThreads_setter(True)

        cam.set(cv2.CAP_PROP_FRAME_WIDTH, 1920)
        cam.set(cv2.CAP_PROP_FRAME_HEIGHT, 1080)
        Camera.halt = False
        Camera.picReady = False

        while cam.isOpened():
            if (Camera.halt is True) and (Camera.picReady is True):
                time.sleep(0.1)
                continue

            Camera.picReady = False
            successPic, image = cam.read()
            if successPic:
                successWrite = cv2.imwrite("bildSRC.jpg", image)
                if successWrite:
                    Camera.picReady = True
            else:
                Camera.picReady = False

            if stop() is True:
                break

        removedPic = np.zeros((700, 700, 3))
        cam.release()
        successWrite1, successWrite2 = False, False
        while (successWrite1, successWrite2) == (False, False):
            if not successWrite1:
                successWrite1 = cv2.imwrite("bildSRC.jpg", removedPic)
            if not successWrite2:
                successWrite2 = cv2.imwrite("bild.jpg", removedPic)
예제 #6
0
        game.start()
        if game.game.run is False:
            game.window.draw()
            main()


def stopGame():
    global camera
    Config.stopThreadsSetter(True)
    cam.join()
    pygame.quit()
    print("EXITED")
    raise SystemExit


if __name__ == "__main__":
    game = None
    pygame.mixer.pre_init(44100, -16, 2,
                          2048)  # setup mixer to avoid sound lag
    pygame.init()
    pygame.mixer.init()
    pygame.mixer.music.load("music/game.ogg")
    pygame.mixer.music.play(loops=-1)

    Config.stopThreadsSetter(False)
    cam = threading.Thread(target=Camera.cameraThread,
                           args=(lambda: Config.stopThreads, ))
    cam.start()

    main()
예제 #7
0
    def drawHelp(self):

        help_window = HelpWindow()

        #text size
        self.font = pygame.font.Font('freesansbold.ttf', 25)
        self.text_font = pygame.font.Font('freesansbold.ttf', 17)
        self.lang_font = pygame.font.Font('freesansbold.ttf', 17)
        #Title
        self.text = self.font.render(
            'Instruktioner-Instructions',
            True,
            self.black,
        )
        self.text_rect = self.text.get_rect()
        self.text_rect.center = (230, 45)

        #Exit rektangeln
        self.exit_text = self.font.render(
            'Exit',
            True,
            self.red,
        )
        self.exit_react = self.exit_text.get_rect()
        self.exit_react.center = (250, 610)

        #Välj språk, Sve eller Eng
        self.pick_lang_text = self.lang_font.render(
            'Sve/Eng',
            True,
            self.white,
        )
        self.pick_lang_rect = self.pick_lang_text.get_rect()
        self.pick_lang_rect = (405, 38)

        #Start block
        self.start_text = self.text_font.render(
            'Start block: ',
            True,
            self.black,
        )
        self.start_rect = self.start_text.get_rect()
        self.start_rect = (29, 61)

        #Stop block
        self.stop_text = self.text_font.render(
            'Stop block: ',
            True,
            self.black,
        )
        self.stop_rect = self.stop_text.get_rect()
        self.stop_rect = (29, 106)

        #Turn right block
        self.right_text = self.text_font.render('Turn right block: ', True,
                                                self.black)
        self.right_rect = self.right_text.get_rect()
        self.right_rect = (29, 151)

        #Turn left block
        self.left_text = self.text_font.render('Turn left block: ', True,
                                               self.black)
        self.left_rect = self.left_text.get_rect()
        self.left_rect = (29, 195)

        #Go forward block
        self.forward_text = self.text_font.render('Go forward block: ', True,
                                                  self.black)
        self.forward_rect = self.forward_text.get_rect()
        self.forward_rect = (29, 241)

        #While block
        self.while_text = self.text_font.render('While block: ', True,
                                                self.black)
        self.while_rect = self.while_text.get_rect()
        self.while_rect = (29, 286)

        #If-block
        self.if_text = self.text_font.render('If block: ', True, self.black)
        self.if_rect = self.if_text.get_rect()
        self.if_rect = (29, 331)

        #Else block
        self.else_text = self.text_font.render('Else block: ', True,
                                               self.black)
        self.else_rect = self.else_text.get_rect()
        self.else_rect = (29, 376)

        #Path ahead block
        self.ahead_text = self.text_font.render('Path ahead block: ', True,
                                                self.black)
        self.ahead_rect = self.ahead_text.get_rect()
        self.ahead_rect = (29, 421)

        #Path right block
        self.path_right_text = self.text_font.render('Path right block: ',
                                                     True, self.black)
        self.path_right_rect = self.path_right_text.get_rect()
        self.path_right_rect = (29, 466)

        #Path left block
        self.path_left_text = self.text_font.render('Path left block: ', True,
                                                    self.black)
        self.path_left_rect = self.path_left_text.get_rect()
        self.path_left_rect = (29, 511)

        #Not finished block
        self.not_fin_text = self.text_font.render('Not finished block: ', True,
                                                  self.black)
        self.not_fin_rect = self.not_fin_text.get_rect()
        self.not_fin_rect = (29, 556)

        self.windw2.blit(self.bg, (0, 0))
        self.windw2.blit(self.text, self.text_rect)
        self.windw2.blit(self.bg, (0, 0))
        self.windw2.blit(self.text, self.text_rect)
        self.windw2.blit(self.exit_text, self.exit_react)
        self.windw2.blit(self.pick_lang_text, self.pick_lang_rect)
        self.windw2.blit(self.start_text, self.start_rect)
        self.windw2.blit(self.stop_text, self.stop_rect)
        self.windw2.blit(self.right_text, self.right_rect)
        self.windw2.blit(self.left_text, self.left_rect)
        self.windw2.blit(self.forward_text, self.forward_rect)
        self.windw2.blit(self.while_text, self.while_rect)
        self.windw2.blit(self.if_text, self.if_rect)
        self.windw2.blit(self.else_text, self.else_rect)
        self.windw2.blit(self.ahead_text, self.ahead_rect)
        self.windw2.blit(self.path_right_text, self.path_right_rect)
        self.windw2.blit(self.path_left_text, self.path_left_rect)
        self.windw2.blit(self.not_fin_text, self.not_fin_rect)

        help_window.sve()
        pygame.display.flip()

        lang = "sve"
        hasChanged = False
        run = True
        while run:
            if hasChanged:
                self.windw2.blit(self.bg, (0, 0))
                self.windw2.blit(self.text, self.text_rect)
                self.windw2.blit(self.bg, (0, 0))
                self.windw2.blit(self.text, self.text_rect)
                self.windw2.blit(self.exit_text, self.exit_react)
                self.windw2.blit(self.pick_lang_text, self.pick_lang_rect)
                self.windw2.blit(self.start_text, self.start_rect)
                self.windw2.blit(self.stop_text, self.stop_rect)
                self.windw2.blit(self.right_text, self.right_rect)
                self.windw2.blit(self.left_text, self.left_rect)
                self.windw2.blit(self.forward_text, self.forward_rect)
                self.windw2.blit(self.while_text, self.while_rect)
                self.windw2.blit(self.if_text, self.if_rect)
                self.windw2.blit(self.else_text, self.else_rect)
                self.windw2.blit(self.ahead_text, self.ahead_rect)
                self.windw2.blit(self.path_right_text, self.path_right_rect)
                self.windw2.blit(self.path_left_text, self.path_left_rect)
                self.windw2.blit(self.not_fin_text, self.not_fin_rect)
                if lang == "sve":
                    help_window.sve()
                elif lang == "eng":
                    help_window.eng()
                pygame.display.flip()
                hasChanged = False

            for event in pygame.event.get():
                if event.type == pygame.MOUSEBUTTONDOWN:
                    self.mx, self.my = pygame.mouse.get_pos()
                    #Exit knappen
                    if self.mx >= 225 and self.mx <= 275 and self.my >= 600 and self.my <= 620:
                        run = False
                        break
                    #Sve knappen
                    if self.mx >= 405 and self.mx <= 430 and self.my >= 38 and self.my <= 51:
                        lang = "sve"
                        hasChanged = True
                    #Eng knappen
                    if self.mx >= 440 and self.mx <= 469 and self.my >= 40 and self.my <= 55:
                        lang = "eng"
                        hasChanged = True
                if event.type == pygame.QUIT:
                    run = False
                    break

                if event.type == KEYDOWN or event.type == KEYUP:
                    if event.key == K_ESCAPE:
                        exitPressed = True
                        Config.stopThreadsSetter(True)
                        run = False
                        break
예제 #8
0
    def draw(self):
        # detta måste garantera att
        game = self._game
        self.clock = pygame.time.Clock()
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                game.run = False
                Config.stopThreadsSetter(True)

        self.window.fill(self.black)

        # Draw the grid
        currentMap = game.map
        for x in range(0, game.mapSize[0]):
            for y in range(0, game.mapSize[1]):
                # if currentMap[y][x] == 1:
                #     self.cell_color = self.white
                # elif currentMap[y][x] == 0 or currentMap[y][x] == "f":
                #     self.cell_color = self.black
                # elif currentMap[y][x] == "c":
                #     self.cell_color = self.red
                # elif currentMap[y][x] == "p":
                #     self.cell_color = self.green

                # pygame.draw.rect(self.window, self.cell_color,
                #                 [(self.margin + self.width) * x + self.margin,
                #                 (self.margin + self.height) * y + self.margin,
                #                 self.width,
                #                 self.height])

                if currentMap[y][x] == 1:
                    currentEntityImage = self._wallImage
                elif currentMap[y][x] == 0:
                    currentEntityImage = self._pathImage
                elif currentMap[y][x] == "f":
                    currentEntityImage = self._finishImage
                elif currentMap[y][x] == "c":
                    currentEntityImage = pygame.image.load(
                        f"graphics/character{game.character.direction.lower()}.jpg"
                    )
                elif currentMap[y][x] == "p":
                    currentEntityImage = self._foodImage

                self.window.blit(
                    currentEntityImage,
                    [(self.margin + self.width) * x + self.margin,
                     (self.margin + self.width) * y + self.margin])

        #Hjälp knappen
        helpPos = (1300, 200)
        font = pygame.font.Font('freesansbold.ttf', 80)
        self.help_text = font.render(
            'HELP',
            True,
            self.red,
        )
        self.help_react = self.help_text.get_rect()
        self.help_react = helpPos
        self.window.blit(self.help_text, self.help_react)

        #Run knappen
        runPos = (1300, 600)
        self.run_text = font.render("RUN", True, self.green)
        self.run_react = self.run_text.get_rect()
        self.run_react = runPos
        self.window.blit(self.run_text, self.run_react)

        self.clock.tick(self.FPS)
        pygame.display.flip()
예제 #9
0
    def draw_help(self):
        """
        Function: Draws the actuall text on the window and draws the button that changes the language and the exit button.
        """
        help_window = HelpWindow()

        #text size
        self.font = pygame.font.Font('freesansbold.ttf', 25)
        self._textFont = pygame.font.Font('freesansbold.ttf', 17)
        self._langFont = pygame.font.Font('freesansbold.ttf', 17)
        #Title
        self.text = self.font.render(
            'Instruktioner-Instructions',
            True,
            self.black,
        )
        self._textRect = self.text.get_rect()
        self._textRect.center = (230, 45)

        #Exit rektangeln
        self._exitText = self.font.render(
            'Exit',
            True,
            self.red,
        )
        self._exitReact = self._exitText.get_rect()
        self._exitReact.center = (250, 610)

        #Välj språk, Sve eller Eng
        self._pickLangText = self._langFont.render(
            'Sve/Eng',
            True,
            self.white,
        )
        self._pickLangRect = self._pickLangText.get_rect()
        self._pickLangRect = (405, 38)

        #Start block
        self._startText = self._textFont.render(
            'Start block: ',
            True,
            self.black,
        )
        self._startRect = self._startText.get_rect()
        self._startRect = (29, 61)

        #Stop block
        self._stopText = self._textFont.render(
            'Stop block: ',
            True,
            self.black,
        )
        self._stopRect = self._stopText.get_rect()
        self._stopRect = (29, 106)

        #Turn right block
        self._rightText = self._textFont.render('Turn right block: ', True,
                                                self.black)
        self._rightRect = self._rightText.get_rect()
        self._rightRect = (29, 151)

        #Turn left block
        self._leftText = self._textFont.render('Turn left block: ', True,
                                               self.black)
        self._leftRect = self._leftText.get_rect()
        self._leftRect = (29, 195)

        #Go forward block
        self._forwardText = self._textFont.render('Go forward block: ', True,
                                                  self.black)
        self._forwardRect = self._forwardText.get_rect()
        self._forwardRect = (29, 241)

        #While block
        self._whileText = self._textFont.render('While block: ', True,
                                                self.black)
        self._whileRect = self._whileText.get_rect()
        self._whileRect = (29, 286)

        #If-block
        self._ifText = self._textFont.render('If block: ', True, self.black)
        self._ifRect = self._ifText.get_rect()
        self._ifRect = (29, 331)

        #Else block
        self._elseText = self._textFont.render('Else block: ', True,
                                               self.black)
        self._elseRect = self._elseText.get_rect()
        self._elseRect = (29, 376)

        #Path ahead block
        self._aheadText = self._textFont.render('Path ahead block: ', True,
                                                self.black)
        self._aheadRect = self._aheadText.get_rect()
        self._aheadRect = (29, 421)

        #Path right block
        self._pathRightText = self._textFont.render('Path right block: ', True,
                                                    self.black)
        self._pathRightRect = self._pathRightText.get_rect()
        self._pathRightRect = (29, 466)

        #Path left block
        self._pathLeftText = self._textFont.render('Path left block: ', True,
                                                   self.black)
        self._pathLeftRect = self._pathLeftText.get_rect()
        self._pathLeftRect = (29, 511)

        #Not finished block
        self._notFinText = self._textFont.render('Not finished block: ', True,
                                                 self.black)
        self._notFinRect = self._notFinText.get_rect()
        self._notFinRect = (29, 556)

        self._windw.blit(self.bg, (0, 0))
        self._windw.blit(self.text, self._textRect)
        self._windw.blit(self.bg, (0, 0))
        self._windw.blit(self.text, self._textRect)
        self._windw.blit(self._exitText, self._exitReact)
        self._windw.blit(self._pickLangText, self._pickLangRect)
        self._windw.blit(self._startText, self._startRect)
        self._windw.blit(self._stopText, self._stopRect)
        self._windw.blit(self._rightText, self._rightRect)
        self._windw.blit(self._leftText, self._leftRect)
        self._windw.blit(self._forwardText, self._forwardRect)
        self._windw.blit(self._whileText, self._whileRect)
        self._windw.blit(self._ifText, self._ifRect)
        self._windw.blit(self._elseText, self._elseRect)
        self._windw.blit(self._aheadText, self._aheadRect)
        self._windw.blit(self._pathRightText, self._pathRightRect)
        self._windw.blit(self._pathLeftText, self._pathLeftRect)
        self._windw.blit(self._notFinText, self._notFinRect)

        help_window.sve()
        pygame.display.flip()

        lang = "sve"
        hasChanged = False
        run = True
        while run:
            if hasChanged:
                self._windw.blit(self.bg, (0, 0))
                self._windw.blit(self.text, self._textRect)
                self._windw.blit(self.bg, (0, 0))
                self._windw.blit(self.text, self._textRect)
                self._windw.blit(self._exitText, self._exitReact)
                self._windw.blit(self._pickLangText, self._pickLangRect)
                self._windw.blit(self._startText, self._startRect)
                self._windw.blit(self._stopText, self._stopRect)
                self._windw.blit(self._rightText, self._rightRect)
                self._windw.blit(self._leftText, self._leftRect)
                self._windw.blit(self._forwardText, self._forwardRect)
                self._windw.blit(self._whileText, self._whileRect)
                self._windw.blit(self._ifText, self._ifRect)
                self._windw.blit(self._elseText, self._elseRect)
                self._windw.blit(self._aheadText, self._aheadRect)
                self._windw.blit(self._pathRightText, self._pathRightRect)
                self._windw.blit(self._pathLeftText, self._pathLeftRect)
                self._windw.blit(self._notFinText, self._notFinRect)
                if lang == "sve":
                    help_window.sve()
                elif lang == "eng":
                    help_window.eng()
                pygame.display.flip()
                hasChanged = False

            for event in pygame.event.get():
                if event.type == pygame.MOUSEBUTTONDOWN:
                    self._mx, self._my = pygame.mouse.get_pos()
                    #Exit knappen
                    if self._mx >= 225 and self._mx <= 275 and self._my >= 600 and self._my <= 620:
                        run = False
                        break
                    #Sve knappen
                    if self._mx >= 405 and self._mx <= 430 and self._my >= 38 and self._my <= 51:
                        lang = "sve"
                        hasChanged = True
                    #Eng knappen
                    if self._mx >= 440 and self._mx <= 469 and self._my >= 40 and self._my <= 55:
                        lang = "eng"
                        hasChanged = True
                if event.type == pygame.QUIT:
                    run = False
                    break

                if event.type == KEYDOWN or event.type == KEYUP:
                    if event.key == K_ESCAPE:
                        exitPressed = True
                        Config.stopThreads_setter(True)
                        run = False
                        break
예제 #10
0
    def draw_error_pic(self, message, pos=(0, 0)):
        """
        Function: args; message, pos (default=(0,0)) Draws arrow and message to given position
        """

        self.window.fill((255, 255, 255))
        self.window.blit(self.picture, (0, 0))

        pygame.font.init()

        textFont = pygame.font.SysFont("arial", 32)
        text = textFont.render(message, True, (0, 0, 0), (255, 255, 255))
        textRect = text.get_rect()

        exitFont = pygame.font.SysFont("arial", 64)
        exitText = exitFont.render("EXIT", True, (255, 0, 0), (255, 255, 255))
        exitTextRect = exitText.get_rect()
        exitPos = (1920 // 2, 1080 - 50)
        exitTextRect.center = exitPos

        if pos == (0, 0):
            textRect.center = (self.pictureWidth // 2, self.pictureHeight // 2)
        elif pos[1] >= 1920 // 2:
            arrowPoint = (pos[0], pos[1] + 30)
            arrow = (arrowPoint, (arrowPoint[0] - 60, arrowPoint[1] + 30),
                     (arrowPoint[0] - 30, arrowPoint[1] + 30),
                     (arrowPoint[0] - 30, arrowPoint[1] + 90),
                     (arrowPoint[0] + 30, arrowPoint[1] + 90),
                     (arrowPoint[0] + 30, arrowPoint[1] + 30),
                     (arrowPoint[0] + 60, arrowPoint[1] + 30))
            pygame.draw.polygon(self.window, (255, 0, 0), arrow)
            textRect.center = (pos[0], pos[1] + 30 + 90 + 10)
        else:
            arrowPoint = (pos[0], pos[1] - 30)
            arrow = (arrowPoint, (arrowPoint[0] - 60, arrowPoint[1] - 30),
                     (arrowPoint[0] - 30, arrowPoint[1] - 30),
                     (arrowPoint[0] - 30, arrowPoint[1] - 90),
                     (arrowPoint[0] + 30, arrowPoint[1] - 90),
                     (arrowPoint[0] + 30, arrowPoint[1] - 30),
                     (arrowPoint[0] + 60, arrowPoint[1] - 30))
            pygame.draw.polygon(self.window, (255, 0, 0), arrow)
            textRect.center = (pos[0], pos[1] - 30 - 90 - 10)

        self.window.blit(text, textRect)
        self.window.blit(exitText, exitTextRect)
        run = True
        pygame.display.flip()

        while run:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    run = False
                    break
                if event.type == MOUSEBUTTONDOWN or event.type == MOUSEBUTTONDOWN:
                    mPos = pygame.mouse.get_pos()
                    if (exitTextRect.topleft[0] <= mPos[0] <=
                            exitTextRect.bottomright[0]) and (
                                exitTextRect.topleft[1] <= mPos[1] <=
                                exitTextRect.bottomright[1]):
                        run = False
                        break
                if event.type == KEYDOWN or event.type == KEYUP:
                    if event.key == K_ESCAPE:
                        Config.stopThreads_setter(True)
                        run = False
                        break