def __init__(self):
        super().__init__(WIDTH, HEIGHT, NAME)

        arcade.set_background_color(arcade.color.WHITE)

        self.SERVER = socket.gethostbyname(socket.gethostname())
        self.PORT = 5050
        self.ADDR = (self.SERVER, self.PORT)
        self.FORMAT = 'utf-8'

        try:
            self.client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.client.setblocking(1)
            self.client.connect(self.ADDR)
        except:
            pass

        self.board_draw = Board()
        self.board = {
            '7': ' ',
            '8': ' ',
            '9': ' ',
            '4': ' ',
            '5': ' ',
            '6': ' ',
            '1': ' ',
            '2': ' ',
            '3': ' '
        }

        self.button_list = []
        self.popup_list = []
        self.cursor = Cursor()

        self.client_ID = None

        self.my_turn = False
        self.game_over = False

        #SERVER REQUEST BOOLS
        self.board_request = False
        self.ID_request = False

        self.player_2 = False
        self.request_reset = False
        self.reset_state = False
        self.clear_state = False

        self.winner = None

        self.popup = Popup(WIDTH / 2, HEIGHT / 2 - HEIGHT / 4, 1)
        self.game_over_popup = Popup(WIDTH / 2, HEIGHT / 2 - HEIGHT / 4, 2)
        self.restart_popup = Popup(WIDTH / 2, HEIGHT / 2 - HEIGHT / 2.5, 3)
        self.popup_list.append(self.restart_popup)

        for x in range(1, 10):
            button = Button(x)
            self.button_list.append(button)
Exemple #2
0
def enter():
    hide_cursor()
    global start_select, cursor, background, big_start, small_start
    start_select = False
    cursor = Cursor()
    background = Background()
    big_start = Big_start()
    small_start = Small_start()
    game_world.add_object(cursor, 0)
Exemple #3
0
 def __init__(self):
     self.board = Board(ROWS, COLUMNS)
     self.gui = GUI(ROWS, COLUMNS, SIZE, self.board)
     self.rules = Rules()
     self.cursor = Cursor()
     self.player1 = Player(1)
     self.player2 = AIPlayer(2, self.rules, self.board)
     self.currentPlayer = self.assign_player()
     self.gameOver = False
     self.menuFlag = False
Exemple #4
0
def enter():
    global cursor, background, sad, happy, selected_character
    cursor = Cursor()
    background = Background()
    sad = Choose_sadness300()
    happy = Choose_happiness300()
    selected_character = 'none'

    game_world.add_object(background, 0)
    game_world.add_object(happy, 1)
    game_world.add_object(sad, 1)
    game_world.add_object(cursor, 2)
Exemple #5
0
 def __init__(self):
     
     self.pantalla=pygame.display.set_mode((600,704))
     self.fondo1=fondo("galaxy.jpg")
     self.footPage=pygame.image.load("macro.png").convert_alpha()
     self.Cursor=Cursor()
     self.boton1=Boton("boton3.png","boton4.png")
     self.boton2=Boton("boton5.png","boton6.png",300,350)
     self.boton3=Boton("boton7.png","boton8.png",300,450)
     self.logo=pygame.sprite.Sprite()
     self.logo=pygame.image.load("LogoGame2.png").convert_alpha()
     self.Dibujar_Menu()
Exemple #6
0
    def __init__(self, parent=None, video="./SampleVideo.mp4"):
        super().__init__(parent)
        self.setLayout(QVBoxLayout())
        self.layout().setSpacing(0)
        self.layout().setContentsMargins(0, 0, 0, 0)
        self.setStyleSheet("border: #f00 solid 5px")

        # Load Video
        self._video_path = video
        self.video = cv2.VideoCapture(video)
        atexit.register(self.video.release)
        self.__fps = self.video.get(cv2.CAP_PROP_FPS)
        self.__resolution = self.video.get(
            cv2.CAP_PROP_FRAME_WIDTH), self.video.get(
                cv2.CAP_PROP_FRAME_HEIGHT)
        self.__number_of_frames = self.video.get(cv2.CAP_PROP_FRAME_COUNT)
        print("Playing {} at {} fps and {}x{}".format(self._video_path,
                                                      self.fps,
                                                      self.resolution[0],
                                                      self.resolution[1]))

        # Video Reader
        self.__image_update_thread = VideoThread(self, video=self.video)
        self.__image_update_thread.changePixmap.connect(self.__setImage)
        self.__image_update_thread.start()
        self.__sizeChanged.connect(self.__image_update_thread.updateSize)

        # Pass through signals
        self.__image_update_thread.newFrame.connect(self.newFrame.emit,
                                                    type=Qt.DirectConnection)
        self.__image_update_thread.positionChanged.connect(
            self.positionChanged.emit)
        self.__image_update_thread.stateChanged.connect(self.stateChanged.emit)

        # Click Events
        # self.mouse_down = pyqtSignal(Video, tuple)
        # self.mouse_move = pyqtSignal(Video, tuple)
        # self.mouse_up = pyqtSignal(Video, tuple)

        self.setFixedWidth(self.resolution[0] / 2)

        # Blurring
        self._blur_strands = []
        self._blur_object = None

        # Set Cursor
        self.setCursor(Cursor())
        # self.setCursor(QCursor(Qt.CrossCursor))
        # cursor_size = self.cursor().pixmap().size()
        # self.cursor().pixmap().load("../assets/erase.png")
        # print("Cursor size",cursor_size.width(), cursor_size.height())
        self.installEventFilter(self)
Exemple #7
0
 def __init__(self, mainSurface, width, height):
     self.roomWidth = width
     self.roomHeight = height
     self.screenWidth = width
     self.screenHeight = height
     self.assetLoader = AssetLoader(self)
     self.mainSurface = mainSurface
     self.background = Background()
     self.level = 1
     self.cursor = Cursor(self)
     self.loadMenu()
     self.events = []
     self.fullscreen = False
     self.alreadyClicked = False
     pygame.mixer.music.play(-1)
Exemple #8
0
def make_objs():
    Building.create_buildings()

    i = 0
    # 계단끼리 연결
    while i < 3:
        stair_list[i + 3].other_stair = stair_list[i + 6]
        stair_list[i + 6].other_stair = stair_list[i + 3]
        stair_list[i + 3 + 12].other_stair = stair_list[i + 6 + 12]
        stair_list[i + 6 + 12].other_stair = stair_list[i + 3 + 12]
        i += 1

    # Make Obj
    for j in range(2):
        for i in range(6):
            make_random_floor_obj(j, i)

    random_actor_generator()
    Player2()

    # ui ----------------------------

    Cursor()

    ui_mouse = Ui(1)
    ui_mouse.load_img('img/ui_mouse.png')
    ui_mouse.set_pos(0, 90)
    ui_mouse.set_off((-1, 0))

    ui_keyboard = Ui(1)
    ui_keyboard.load_img('img/ui_keyboard.png')
    ui_keyboard.set_pos(-00, 90)
    ui_keyboard.set_off((1, 0))

    global ui_hp1, ui_hp2
    ui_hp1 = PlayerUI(1)
    ui_hp1.set_pos(-369, 64)
    ui_hp1.size[0], ui_hp1.size[1] = 0, 35
    ui_hp1.init(240, 63, 63, -1.0, ui_keyboard.pos)

    ui_hp2 = PlayerUI(1)
    ui_hp2.set_pos(369, 64)
    ui_hp2.size[0], ui_hp2.size[1] = 0, 35
    ui_hp2.init(91, 215, 232, 1.0, ui_mouse.pos)

    ui_center = Ui(1)
    ui_center.load_img('img/ui_center.png')
    ui_center.set_pos(0, 75)
Exemple #9
0
    def __init__(self):

        self.pantalla = pygame.display.set_mode((600, 704))
        self.fondo1 = fondo("Fondo.jpg")
        self.logo = pygame.sprite.Sprite()
        self.footPage = pygame.image.load("macro.png").convert_alpha()
        self.Cursor = Cursor()
        self.boton1 = Boton("boton3.png", "boton4.png")
        self.boton2 = Boton("boton5.png", "boton6.png", 300, 350)
        self.boton3 = Boton("boton7.png", "boton8.png", 300, 450)
        self.boton4 = Boton("boton1.png", "boton2.png", 500, 600)
        self.logo = pygame.sprite.Sprite()
        self.logo = pygame.image.load("LogoGame2.png").convert_alpha()
        self.visibilidad = True
        #self.lista_menu = pygame.sprite.Group()
        self.Dibujar_Menu()
Exemple #10
0
def enter():
    global background, smallReplay, smallExit, bigReplay, bigExit, chooseExit, chooseReplay, cursor, crying, score
    background = Background()
    smallReplay = SmallReplay()
    smallExit = SmallExit()
    bigReplay = BigReplay()
    bigExit = BigExit()
    chooseExit = False
    chooseReplay = False
    cursor = Cursor()
    crying = Crying()
    score = Score()
    score.score = main_state.number.score
    game_world.clear()
    game_world.add_object(crying, 0)
    game_world.add_object(score, 0)
    game_world.add_object(cursor, 1)
Exemple #11
0
    def __init__(self):
        self.climate = "temperate"
        self.current_weather = "clear"
        self.grid = [['0' for x in range(0, 45)] for y in range(0, 30)]
        self.over_grid = [['0' for x in range(0, 45)] for y in range(0, 30)]
        self.cursor_grid = [['0' for x in range(0, 45)] for y in range(0, 30)]
        self.cursor = Cursor(352, 240)
        self.control_panel = pygame.Surface((180, 480))
        self.view_x = 0
        self.view_y = 0

        climate_number = randint(0, 2)
        if (climate_number == 0):
            self.climate = "temperate"
        elif (climate_number == 1):
            self.climate = "hot"
        else:
            self.climate = "cold"

        self.control_panel.fill((0, 100, 0))
Exemple #12
0
    def __init__(self, n):
        self.blockFactory = BlockFactory()
        self.grid = []
        #add second, empty grid
        for i in range(n):
            self.grid.append([])
            for j in range(n):
                self.grid[i].append(None)
        #create grid filled with blocks
        for i in range(n):
            self.grid.append([])
            for j in range(n):
                cellPos = (j * (cellWidth + padding),
                           (n + i) * (cellHeight + padding))
                self.grid[n + i].append(self.blockFactory.build(cellPos))
        self.n = n
        self.center = (n * (cellWidth + padding) / 2, n *
                       (cellHeight + padding) + n * (cellHeight + padding) / 2)

        #cursor set to (0,0) on the grid
        self.cursor = Cursor(n, n, [n - 1, 0])
Exemple #13
0
 def __init__(self):
     self.sceneManager = SceneManager(self)
     pygame.init()
     self.size = self.width, self.height = 480, 320
     self.backgroundColor = 0, 0, 0
     self.screen = pygame.display.set_mode(self.size)
     self.clock = pygame.time.Clock()
     self.sceneManager.setScene('Menu')
     self.cursor = Cursor(self)
     while 1:
         deltaTime = 1 / float(self.clock.tick(60))
         events = pygame.event.get()
         for event in events:
             if event.type == pygame.QUIT:
                 sys.exit()
             if event.type == pygame.KEYDOWN:
                 if event.key == pygame.K_ESCAPE:
                     sys.exit()
         self.update(deltaTime, events)
         self.screen.fill(self.backgroundColor)
         self.draw(self.screen)
         pygame.display.flip()
Exemple #14
0
 def __init__(self):
     self.characters = []
     self.cursor = Cursor(self)
     self.filename = ''
Exemple #15
0
run = 1

fd_gr = pg.sprite.Group()
crtb_gr = pg.sprite.Group()
crts_gr = pg.sprite.Group()
deadb_gr = pg.sprite.Group()
deads_gr = pg.sprite.Group()
curs_gr = pg.sprite.Group()
btn_gr = pg.sprite.Group()

vis_gr = []
crt_mas = [Creature(WCR, HCR, SENS) for i in range(count_crt)]
fd_mas = [Food() for i in range(COUNT_FD)]
curs_mas = [
    Cursor(10, 160 + 80 * i, [COUNT_FD / 2000, SPEED, SP_GEN_FD][i])
    for i in range(3)
]

for i in range(count_crt):
    crtb_gr.add(crt_mas[i].body)
    crts_gr.add(crt_mas[i].sens_circ)

for i in range(COUNT_FD):
    fd_gr.add(fd_mas[i])

for i in range(3):
    curs_gr.add(curs_mas[i])

for i in range(len(btn_mas)):
    btn_gr.add(btn_mas[i])
Exemple #16
0
    def __init__(self, w, h):
        #pygame shit
        pygame.init()
        window = pygame.display.set_mode((w, h))
        clock = pygame.time.Clock()
        font = pygame.font.SysFont('Courier', 20)

        #variables +other cool stuff
        im.__init__()
        paused = False
        p1 = Player((-1, 1, 0))
        terrain = TerrainGenerator()
        render = Render()
        cursor = Cursor((4, 2, 0))

        #debug menu
        debug = Menu()
        b1 = Button(pygame.Rect(100, 100, 120, 50), terrain.test, "test", font)
        b3 = Button(pygame.Rect(100, 160, 120, 50), terrain.clear, "clear",
                    font)
        debug.add_buttons(b1, b3)

        #game loop
        while True:
            dt = clock.tick() / 200
            if dt == 0: dt = 0.01

            #input shenanigans
            im.manage_input()
            for e in im.keydown():
                if e.key == pygame.K_ESCAPE:
                    paused = not paused
                    pygame.event.set_grab(not paused)
                    #pygame.mouse.set_visible(paused)
                    print("Paused:", paused)
                elif e.key == pygame.K_RETURN:
                    terrain.test()

            #temporary gibberish
            if not paused:
                pygame.mouse.set_pos(256, 256)
                pygame.event.clear(pygame.MOUSEMOTION)
                p1.update(dt)

                render.cubes(terrain.cube_list, p1)
                render.octree(terrain.map, p1)
                render.draw()

                cursor.update()
                render.cursor(cursor, p1)
            else:
                debug.update()

            window.blit(Render.world_surface, (0, 0))
            if paused:
                window.blit(debug.menu_surface, (0, 0))

            #print out fps
            fps = font.render(str(int(clock.get_fps())), True, (0, 255, 0))
            window.blit(fps, (20, 20))

            pygame.display.flip()
Exemple #17
0
    def loop(self):
        """
        The main loop

        	@param self -- the JogoDoPiano
	    
        """
        sc = Screen()
        screen = sc.getScreen()

        statusBar = Label(10, 805, [(0, 0), (1, 1), (0, 1)])
        statusBarRight = Label(1100, 805, [(0, 0), (1, 1), (0, 1)])
        #statusBar = Label(10, 10, [(0,0), (1,1), (0,1)])

        lampCursor = Cursor("lamp", 0, 0, [(0, 0), (1, 1), (0, 1)])
        earCursor = Cursor("ear", 0, 0, [(0, 0), (1, 1), (0, 1)])
        lamp = Lamp("lamp", 825, 709, [(836, 721), (868, 721), (836, 779),
                                       (868, 779)], lampCursor)
        #lamp = Lamp("lamp", 825, 709, [(0, 0), (0, 20), (20, 20), (20, 0)], lampCursor)
        game = Game()

        buttons = [
            Key("1", -36, 507, [(28, 508), (0, 566), (0, 639), (31, 649),
                                (49, 602), (30, 595), (58, 514)], game),
            Key("2", 31, 510, [(60, 512), (30, 595), (58, 603), (89, 518)],
                game),
            Key("3", 19, 516, [(89, 518), (59, 603), (49, 602), (34, 649),
                               (88, 664), (100, 615), (84, 610), (104, 520)],
                game),
            Key("4", 85, 517, [(106, 520), (84, 610), (113, 615), (133, 524)],
                game),
            Key("5", 75, 524, [(134, 524), (113, 615), (100, 614), (87, 663),
                               (137, 672), (158, 527)], game),
            Key("6", 131, 527, [(160, 527), (138, 671), (196, 677), (200, 624),
                                (184, 621), (196, 532)], game),
            Key("7", 187, 529, [(194, 532), (184, 621), (213, 623),
                                (221, 536)], game),
            Key("8", 190, 535, [(221, 536), (215, 623), (201, 624), (196, 680),
                                (254, 677), (253, 628), (232, 626),
                                (237, 538)], game),
            Key("9", 234, 534, [(236, 536), (232, 625), (263, 626),
                                (262, 539)], game),
            Key("10", 243, 538,
                [(262, 539), (263, 626), (252, 627), (254, 676), (303, 675),
                 (296, 627), (284, 626), (279, 538)], game),
            Key("11", 282, 532, [(279, 538), (285, 625), (312, 625),
                                 (301, 538)], game),
            Key("12", 295, 540, [(302, 540), (312, 625), (297, 627),
                                 (301, 676), (344, 670), (317, 539)], game),
            Key("13", 320, 537, [(317, 539), (344, 671), (389, 662),
                                 (378, 625), (367, 624), (342, 538)], game),
            Key("14", 342, 532, [(342, 538), (367, 623), (387, 621),
                                 (358, 535)], game),
            Key("15", 358, 535,
                [(358, 535), (387, 620), (378, 625), (389, 661), (432, 651),
                 (418, 618), (407, 619), (376, 534)], game),
            Key("16", 377, 526, [(376, 534), (406, 618), (424, 614),
                                 (394, 530)], game),
            Key("17", 393, 529, [(394, 531), (424, 613), (418, 618),
                                 (431, 653), (473, 639), (411, 529)], game),
            Key("18", 413, 524, [(413, 530), (474, 639), (511, 628),
                                 (496, 603), (484, 605), (434, 525)], game),
            Key("19", 436, 516, [(435, 526), (483, 604), (503, 599),
                                 (456, 521)], game),
            Key("20", 455, 520,
                [(455, 522), (503, 599), (496, 603), (511, 629), (548, 615),
                 (532, 592), (522, 593), (474, 520)], game),
            Key("21", 475, 508, [(473, 520), (522, 592), (542, 585),
                                 (493, 514)], game),
            Key("22", 494, 512,
                [(493, 514), (541, 585), (532, 591), (548, 616), (585, 600),
                 (568, 579), (559, 580), (507, 512)], game),
            Key("23", 510, 502, [(508, 512), (559, 580), (577, 574),
                                 (526, 507)], game),
            Key("24", 526, 506, [(527, 508), (577, 574), (569, 582),
                                 (585, 602), (621, 586), (538, 504)], game),
            Key("25", 539, 496, [(538, 504), (622, 588), (661, 571),
                                 (639, 550), (626, 553), (572, 496)], game),
            Key("26", 572, 485, [(572, 496), (627, 553), (644, 546),
                                 (595, 494)], game),
            Key("27", 595, 492,
                [(596, 493), (645, 546), (639, 551), (662, 572), (698, 562),
                 (672, 538), (664, 539), (610, 491)], game),
            Key("28", 611, 481, [(610, 492), (664, 539), (679, 534),
                                 (632, 488)], game),
            Key("29", 632, 488, [(633, 489), (679, 534), (672, 539),
                                 (698, 562), (729, 553), (646, 488)], game),
            Key("30", 647, 485, [(645, 488), (731, 556), (763, 550),
                                 (739, 531), (728, 531), (671, 485)], game),
            Key("31", 672, 478, [(670, 485), (728, 530), (742, 527),
                                 (690, 484)], game),
            Key("32", 690, 483,
                [(693, 484), (742, 528), (739, 532), (763, 551), (796, 545),
                 (778, 530), (769, 529), (714, 482)], game),
            Key("33", 715, 474, [(714, 483), (770, 529), (784, 525),
                                 (734, 481)], game),
            Key("34", 735, 481,
                [(736, 481), (784, 524), (777, 529), (797, 547), (829, 543),
                 (810, 527), (802, 525), (748, 481)], game),
            Key("35", 746, 472, [(749, 481), (802, 525), (817, 521),
                                 (771, 480)], game),
            Key("36", 771, 482, [(773, 481), (818, 522), (810, 527),
                                 (830, 543), (869, 541), (793, 481)], game),
            Key("37", 794, 481, [(793, 481), (869, 540), (902, 539),
                                 (879, 520), (866, 518), (821, 480)], game),
            Key("38", 823, 472, [(820, 480), (866, 519), (881, 516),
                                 (843, 480)], game),
            Key("39", 843, 480,
                [(843, 480), (881, 518), (878, 520), (902, 539), (936, 537),
                 (909, 515), (899, 516), (852, 480)], game),
            Stick("2", _("Aleluia - Handel - 4 notes"), 892,
                  241, [(1022, 330), (1017, 325), (1011, 327), (1005, 319),
                        (1008, 315), (1010, 301), (1008, 296), (1004, 289),
                        (993, 284), (984, 277), (983, 257), (988, 248),
                        (998, 247), (1007, 247), (1013, 249), (1018, 257),
                        (1020, 269), (1016, 277), (1010, 282), (1007, 285),
                        (1009, 295), (1016, 295), (1021, 326)], game),
            Stick("1", _("Silent Night - Christmas Song - 4 notes"), 885,
                  271, [(1006, 343), (1001, 338), (1006, 330), (1000, 322),
                        (994, 325), (984, 324), (976, 319), (970, 308),
                        (973, 296), (982, 288), (992, 285), (1003, 290),
                        (1008, 299), (1009, 309), (1004, 321), (1010, 327),
                        (1017, 325), (1038, 351)], game),
            Stick("3", _("Save me - Hanson - 4 notes"), 917, 222,
                  [(1039, 351), (1027, 338), (1024, 278), (1031, 276),
                   (1030, 265), (1026, 262), (1019, 256), (1015, 246),
                   (1016, 233), (1026, 229), (1036, 226), (1046, 231),
                   (1049, 238), (1049, 252), (1044, 262), (1036, 266),
                   (1037, 276), (1046, 276), (1049, 352), (1037, 352)], game),
            Stick("4", _("Every breath you take - Sting - 5 notes"), 944, 213,
                  [(1050, 233), (1054, 223), (1063, 218), (1071, 218),
                   (1084, 223), (1087, 235), (1083, 247), (1079, 253),
                   (1070, 250), (1061, 249), (1055, 249), (1053, 248)], game),
            Stick("5", _("Aquarela - Toquinho - 6 notes"), 950, 247,
                  [(1061, 353), (1055, 302), (1063, 299), (1062, 289),
                   (1055, 283), (1048, 276), (1047, 263), (1053, 254),
                   (1059, 250), (1070, 250), (1082, 257), (1086, 271),
                   (1081, 278), (1074, 282), (1070, 289), (1070, 299),
                   (1078, 301), (1081, 351)], game),
            Stick("6", _("Wedding March - Felix Mendelssohn - 7 notes"), 969,
                  202, [(1091, 233), (1091, 239), (1094, 248), (1100, 257),
                        (1108, 257), (1116, 257), (1125, 252), (1128, 242),
                        (1129, 234), (1128, 226), (1122, 222), (1111, 219),
                        (1102, 221), (1096, 226)], game),
            Stick("7", _("Amor Maior - Jota Quest - 8 notes"), 977, 251,
                  [(1081, 352), (1079, 324), (1086, 304), (1093, 308),
                   (1097, 296), (1094, 291), (1090, 283), (1089, 275),
                   (1091, 267), (1096, 263), (1104, 261), (1109, 260),
                   (1114, 262), (1119, 266), (1126, 272), (1126, 279),
                   (1124, 290), (1119, 295), (1108, 298), (1102, 299),
                   (1101, 303), (1098, 311), (1105, 313), (1091, 351)], game),
            Stick("8", _("Greenleaves - Anonymous - 9 notes"), 1014, 211,
                  [(1108, 346), (1118, 296), (1124, 292), (1125, 286),
                   (1127, 279), (1127, 274), (1124, 266), (1129, 267),
                   (1133, 257), (1127, 252), (1128, 251), (1129, 242),
                   (1130, 238), (1130, 230), (1128, 222), (1133, 219),
                   (1136, 217), (1144, 217), (1149, 220), (1155, 226),
                   (1158, 234), (1158, 245), (1152, 252), (1143, 258),
                   (1136, 263), (1135, 267), (1133, 271), (1136, 286),
                   (1134, 278), (1138, 291), (1140, 293), (1140, 301),
                   (1132, 301), (1129, 301), (1126, 316), (1120, 328),
                   (1114, 339), (1111, 344)], game),
            Stick("9", _("Velha Infancia - Tribalistas - 5 notes"), 985, 219,
                  [(1113, 344), (1130, 303), (1139, 303), (1143, 294),
                   (1139, 288), (1136, 282), (1135, 273), (1138, 266),
                   (1140, 262), (1146, 259), (1157, 259), (1167, 260),
                   (1170, 269), (1173, 278), (1171, 286), (1165, 293),
                   (1157, 295), (1149, 297), (1148, 298), (1146, 307),
                   (1151, 309), (1139, 339), (1113, 345)], game),
            Stick("10", _("Jingle Bells - Christmas Song - 11 notes"), 883,
                  496, [(1009, 604), (1002, 560), (1009, 558), (1009, 547),
                        (1004, 545), (996, 543), (991, 533), (990, 526),
                        (995, 513), (997, 510), (1007, 507), (1016, 507),
                        (1021, 511), (1025, 518), (1027, 528), (1024, 536),
                        (1019, 545), (1014, 546), (1014, 557), (1023, 557),
                        (1028, 609)], game),
            Stick("11", _("Habanera - Georges Bizet - 8 notes"), 927, 479,
                  [(1039, 612), (1034, 536), (1040, 533), (1040, 521),
                   (1034, 519), (1029, 515), (1024, 509), (1024, 499),
                   (1026, 490), (1030, 487), (1039, 485), (1048, 484),
                   (1059, 490), (1062, 498), (1062, 509), (1056, 515),
                   (1047, 521), (1046, 523), (1047, 534), (1054, 534),
                   (1059, 612)], game),
            Stick("12", _("Yellow Submarine - Beatles - 10 notes"), 954, 497,
                  [(1060, 609), (1059, 589), (1062, 571), (1066, 552),
                   (1071, 551), (1074, 541), (1068, 537), (1062, 526),
                   (1064, 513), (1071, 504), (1085, 503), (1087, 504),
                   (1096, 512), (1099, 520), (1096, 532), (1089, 539),
                   (1080, 543), (1078, 553), (1086, 556), (1074, 614)], game),
            Stick("13",
                  _("Jesu, Joy of Man's Desiring - J. S. Bach - 12 notes"),
                  995, 495,
                  [(1087, 612), (1105, 549), (1113, 550), (1114, 538),
                   (1110, 533), (1104, 522), (1105, 515), (1112, 506),
                   (1118, 504), (1126, 501), (1134, 503), (1139, 509),
                   (1143, 519), (1139, 533), (1129, 541), (1122, 543),
                   (1117, 553), (1126, 554), (1108, 608)], game),
            Stick("14", _("Symphony No. 9 - Beethoven - 15 notes"), 1027, 515,
                  [(1113, 605), (1133, 566), (1138, 569), (1145, 560),
                   (1142, 551), (1139, 544), (1139, 536), (1145, 529),
                   (1152, 525), (1160, 526), (1169, 529), (1176, 539),
                   (1174, 553), (1169, 560), (1158, 565), (1151, 564),
                   (1146, 572), (1151, 578), (1138, 600)], game), lampCursor,
            earCursor, lamp, statusBar, statusBarRight
        ]

        helps = [
            Help("re", 370, 500, [(0, 0), (1, 1), (0, 1)]),
            Help("re_sust", 380, 458, [(0, 0), (1, 1), (0, 1)]),
            Help("mi", 415, 490, [(0, 0), (1, 1), (0, 1)]),
            Help("fa", 450, 478, [(0, 0), (1, 1), (0, 1)]),
            Help("fa_sust", 455, 435, [(0, 0), (1, 1), (0, 1)]),
            Help("sol", 490, 470, [(0, 0), (1, 1), (0, 1)]),
            Help("sol_sust", 490, 425, [(0, 0), (1, 1), (0, 1)]),
            Help("la", 525, 460, [(0, 0), (1, 1), (0, 1)]),
            Help("la_sust", 530, 417, [(0, 0), (1, 1), (0, 1)]),
            Help("si", 565, 445, [(0, 0), (1, 1), (0, 1)]),
            Help("do", 595, 430, [(0, 0), (1, 1), (0, 1)]),
            Help("do_sust", 600, 395, [(0, 0), (1, 1), (0, 1)]),
            Help("re", 640, 420, [(0, 0), (1, 1), (0, 1)]),
            Help("re_sust", 630, 380, [(0, 0), (1, 1), (0, 1)]),
            Help("mi", 675, 405, [(0, 0), (1, 1), (0, 1)]),
            Help("fa", 708, 402, [(0, 0), (1, 1), (0, 1)]),
            Help("fa_sust", 695, 370, [(0, 0), (1, 1), (0, 1)]),
            Help("sol", 742, 398, [(0, 0), (1, 1), (0, 1)])
        ]

        game.setButtons(buttons, helps)

        stones = [
            Stone("stone", 115, 187, [(116, 188), (159, 188), (159, 234),
                                      (116, 234)], game),
            Stone("stone", 163, 187, [(164, 188), (207, 188), (207, 234),
                                      (164, 234)], game),
            Stone("stone", 211, 187, [(212, 188), (255, 188), (255, 234),
                                      (212, 234)], game),
            Stone("stone", 259, 187, [(260, 188), (303, 188), (303, 234),
                                      (260, 234)], game),
            Stone("stone", 307, 187, [(308, 188), (351, 188), (351, 234),
                                      (308, 234)], game),
            Stone("stone", 355, 187, [(356, 188), (399, 188), (399, 234),
                                      (356, 234)], game),
            Stone("stone", 403, 187, [(404, 188), (447, 188), (447, 234),
                                      (404, 234)], game),
            Stone("stone", 451, 187, [(452, 188), (495, 188), (495, 234),
                                      (452, 234)], game),
            Stone("stone", 498, 187, [(500, 188), (543, 188), (543, 234),
                                      (500, 234)], game),
            Stone("stone", 546, 187, [(548, 188), (591, 188), (591, 234),
                                      (548, 234)], game),
            Stone("stone", 594, 187, [(596, 188), (639, 188), (639, 234),
                                      (596, 234)], game),
            Stone("stone", 642, 187, [(644, 188), (687, 188), (687, 234),
                                      (644, 234)], game),
            Stone("stone", 690, 187, [(692, 188), (735, 188), (735, 234),
                                      (692, 234)], game),
            Stone("stone", 738, 187, [(740, 188), (783, 188), (783, 234),
                                      (740, 234)], game),
            Stone("stone", 786, 187, [(788, 188), (831, 188), (831, 234),
                                      (788, 234)], game)
        ]

        animation = [
            Ball("bar", 80, 287, [(0, 0), (1, 1), (0, 1)], game),
            Ball("redBall", 10, 247, [(8, 247), (100, 247), (100, 338),
                                      (8, 338)], game),
            Ball("greenBall", 10, 247, [(8, 247), (100, 247), (100, 338),
                                        (8, 338)], game),
            Ball("blueBall", 10, 247, [(8, 247), (100, 247), (100, 338),
                                       (8, 338)], game),
            Ball("yellowBall", 10, 247, [(8, 247), (100, 247), (100, 338),
                                         (8, 338)], game),
            Ball("rightBall", 850, 267, [(0, 0), (1, 1), (0, 1)], game)
        ]

        game.addChallenge(
            Challenge("noitefeliz", [20, 22, 20, 17], buttons[40], stones,
                      [5, 7, 5, 2], animation[1], animation[0], animation[5],
                      "easy", game))
        game.addChallenge(
            Challenge("aleluia", [27, 22, 24, 22], buttons[39], stones,
                      [12, 7, 9, 7], animation[3], animation[0], animation[5],
                      "easy", game))
        game.addChallenge(
            Challenge("saveme", [16, 17, 24, 17], buttons[41], stones,
                      [1, 2, 9, 2], animation[2], animation[0], animation[5],
                      "easy", game))
        game.addChallenge(
            Challenge("everybreath", [26, 27, 26, 24, 22], buttons[42], stones,
                      [11, 12, 11, 9, 7], animation[3], animation[0],
                      animation[5], "easy", game))
        game.addChallenge(
            Challenge("aquarela", [15, 15, 20, 20, 19, 17], buttons[43],
                      stones, [0, 0, 5, 5, 4, 2], animation[4], animation[0],
                      animation[5], "easy", game))
        game.addChallenge(
            Challenge("marchanupcial", [25, 24, 19, 22, 20, 18, 15],
                      buttons[44], stones, [10, 9, 4, 7, 5, 3, 0],
                      animation[1], animation[0], animation[5], "easy", game))
        game.addChallenge(
            Challenge("amormaior", [22, 23, 22, 25, 27, 22, 20, 18],
                      buttons[45], stones, [7, 8, 7, 10, 12, 7, 5, 3],
                      animation[2], animation[0], animation[5], "easy", game))
        game.addChallenge(
            Challenge("greenleaves", [17, 20, 22, 24, 25, 24, 22, 19, 15],
                      buttons[46], stones, [], animation[4], animation[0],
                      animation[5], "easy", game))
        game.addChallenge(
            Challenge("velhainfancia", [19, 22, 19, 22, 29], buttons[47],
                      stones, [4, 7, 4, 7, 14], animation[1], animation[0],
                      animation[5], "easy", game))
        game.addChallenge(
            Challenge("jinglebells",
                      [24, 24, 24, 24, 24, 24, 24, 27, 20, 22, 24],
                      buttons[48], stones, [9, 9, 9, 9, 9, 9, 9, 12, 5, 7, 9],
                      animation[1], animation[0], animation[5], "difficult",
                      game))
        game.addChallenge(
            Challenge("habanera", [27, 26, 25, 25, 25, 24, 23, 22],
                      buttons[49], stones, [12, 11, 10, 10, 10, 9, 8, 7],
                      animation[2], animation[0], animation[5], "difficult",
                      game))
        game.addChallenge(
            Challenge("yellow", [27, 27, 27, 27, 29, 24, 22, 22, 22, 22],
                      buttons[50], stones, [12, 12, 12, 12, 14, 9, 7, 7, 7, 7],
                      animation[3], animation[0], animation[5], "difficult",
                      game))
        game.addChallenge(
            Challenge("jesusalegria",
                      [20, 22, 24, 27, 25, 25, 29, 27, 27, 32, 31, 32],
                      buttons[51], stones,
                      [5, 7, 9, 12, 10, 10, 14, 12, 12, 17, 16, 17],
                      animation[0], animation[4], animation[5], "difficult",
                      game))
        game.addChallenge(
            Challenge(
                "nonasinfonia",
                [19, 19, 20, 22, 22, 20, 19, 17, 15, 15, 17, 19, 19, 17, 17],
                buttons[52], stones,
                [4, 4, 5, 7, 7, 5, 4, 2, 0, 0, 2, 4, 4, 2, 2], animation[3],
                animation[0], animation[5], "difficult", game))

        keyboard = pygame.image.load("image/keyboard.png")

        bigBar = pygame.image.load("image/bigBar.png")
        bigBar.set_alpha(None)  # disable alpha.
        bigBar.convert()
        bigBar.set_colorkey((255, 0, 255))  # magenta

        frame = pygame.image.load("image/frame.png")
        frame.set_alpha(None)  # disable alpha.
        frame.convert()
        frame.set_colorkey((255, 0, 255))  # magenta

        bucket1 = pygame.image.load("image/bucket1.png")
        bucket1.set_alpha(None)  # disable alpha.
        bucket1.convert()
        bucket1.set_colorkey((255, 0, 255))  # magenta

        bucket2 = pygame.image.load("image/bucket2.png")
        bucket2.set_alpha(None)  # disable alpha.
        bucket2.convert()
        bucket2.set_colorkey((255, 0, 255))  # magenta

        clock = pygame.time.Clock()
        FPS = 20

        while self.run:
            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    sys.exit()
                else:
                    for button in buttons:
                        button.parseEvent(event)
                    for stone in stones:
                        stone.parseEvent(event)
                    for help in helps:
                        help.parseEvent(event)
                    for thing in animation:
                        thing.parseEvent(event)
                    if event.type == MOUSEMOTION:
                        posicao = (event.pos[0], event.pos[1])
                        #pygame.display.set_caption(str(posicao[0])+" x "+str(posicao[1]))

            screen.blit(keyboard, (0, -1))

            for button in buttons:
                button.draw(screen)

            for stone in stones:
                stone.draw(screen)

                for thing in animation:
                    thing.draw(screen)

            screen.blit(frame, (-39, 470))
            screen.blit(bigBar, (114, 274))

            for help in helps:
                help.draw(screen)

            screen.blit(bucket1, (988, 338))
            screen.blit(bucket2, (987, 597))

            lampCursor.draw(screen)
            earCursor.draw(screen)

            #update the surface in the screen
            pygame.display.flip()

            #control number of frames per second
            clock.tick(FPS)
Exemple #18
0
 def __init__(self):
     self.__cursor = Cursor()
     self.__limite = 10
     self.__elementos = 0
 def create_cursor(self, coord):
     from Cursor import Cursor
     self.cursor = Cursor('Cursor', coord, fake=True)
Exemple #20
0
    def main_game_loop(self):

        # Define the entity groups
        character_entities = pygame.sprite.Group()  # All character entities (including Player.py)
        built_entities = pygame.sprite.Group()  # Anything the player has built

        # Build the level
        level = Level()
        level.generate(self.tile_cache)

        # Create the player
        player_sprites = "data/images/player/"
        camera = Camera(main_camera, level.width * self.tile_size, level.height * self.tile_size,
                        self.window_width, self.window_height)
        self.player = Player(32, 32, player_sprites, self.tile_size, self.tile_size, 2, camera)
        character_entities.add(self.player)

        # Create cursor entity for better collisions
        cursor = Cursor()

        game_running = True

        up, down, left, right = 0, 0, 0, 0

        while game_running:

            # Reset game variables
            mouse_clicked = False

            for event in pygame.event.get():
                if event.type == pygame.QUIT:
                    quit_game()

                # Key down events
                if event.type == pygame.KEYDOWN:

                    if event.key in (pygame.K_UP, pygame.K_w):
                        up = 1
                    if event.key in (pygame.K_DOWN, pygame.K_s):
                        down = 1
                    if event.key in (pygame.K_LEFT, pygame.K_a):
                        left = 1
                    if event.key in (pygame.K_RIGHT, pygame.K_d):
                        right = 1

                # Key up events
                if event.type == pygame.KEYUP:

                    if event.key in (pygame.K_UP, pygame.K_w):
                        up = 0
                    if event.key in (pygame.K_DOWN, pygame.K_s):
                        down = 0
                    if event.key in (pygame.K_LEFT, pygame.K_a):
                        left = 0
                    if event.key in (pygame.K_RIGHT, pygame.K_d):
                        right = 0

            cursor.update()

            for tile in level.terrain:
                self.screen.blit(tile.image, self.player.camera.apply(tile))

            for tile in level.obstacles:
                self.screen.blit(tile.image, self.player.camera.apply(tile))

            for character in character_entities:
                self.screen.blit(character.image, self.player.camera.apply(character))

            self.player.update(up, down, left, right, level.obstacles)

            pygame.display.flip()

        self.main_menu_loop()