Ejemplo n.º 1
0
    def layer2_init(self):
        w, h = director.get_window_size()

        self.l2 = Layer()
        self.l2.visible = False

        self.stallone = Layer()

        bg = get_sprite('jungle.jpg', w // 2, h // 2)
        bg.scale = 1.3
        bg.do(R_ScaleFromTo(2, 1.3, 0.1))
        self.stallone.add(bg)

        s = get_sprite('stallone.png', w // 2, h // 2 + 100)
        s.scale = 1.35
        s.do(Repeat(Shaky3D(randrange=2, grid=(32, 24), duration=5)))
        s.do(R_ScaleFromTo(2, 1.3, 0.2))
        self.stallone.add(s)

        self.l2.add(self.stallone)

        txt = Line("TOTALNE           ",
                   100, (255, 255, 0, 255),
                   w // 2,
                   h // 2,
                   "November",
                   anchor_x=pyglet.font.Text.CENTER,
                   anchor_y=pyglet.font.Text.CENTER)
        txt.do(Repeat(CallFunc(txt.update_line) + Delay(0.1)))
        txt.transform_anchor = w // 2, h // 2
        txt.position = -600, 0
        txt.rotation = 60
        self.l2.add(txt)

        txt = Line("ZNISZCZENIE       ",
                   100, (255, 255, 0, 255),
                   w // 2,
                   h // 2,
                   "November",
                   anchor_x=pyglet.font.Text.CENTER,
                   anchor_y=pyglet.font.Text.CENTER)
        txt.do(Repeat(CallFunc(txt.update_line) + Delay(0.1)))
        txt.transform_anchor = w // 2, h // 2
        txt.position = 600, 0
        txt.rotation = -60
        self.l2.add(txt)

        wixa = get_sprite('wixapol-full.png', 200, 250)
        wixa.scale = 0.3
        wixa.do(R_Blink(20, 3))
        self.l2.add(wixa)

        wixa = get_sprite('wixapol-full.png', w - 200, 250)
        wixa.scale = 0.3
        wixa.do(R_Blink(20, 3))
        self.l2.add(wixa)

        self.add(self.l2)
Ejemplo n.º 2
0
    def layer1_init(self):
        w, h = director.get_window_size()

        self.group1 = []
        self.l1 = Layer()
        self.l1.visible = False

        self.xds = Layer()

        for i in range(0, 18):
            xd = Line("xD " * 20, 50, (255, 255, 0, 255), w // 2, h // 2,
                      "November", pyglet.font.Text.CENTER,
                      pyglet.font.Text.CENTER)
            xd.do(Repeat(CallFunc(xd.update_line) + Delay(0.05)))
            self.xds.add(xd)

        # self.xds.do(R_Blink(10, 2))
        self.xds.do(Repeat(RotateBy(-20, 0.4)))
        self.xds.do(R_ScaleFromTo(1.2, 0.9, 0.3))
        self.l1.add(self.xds)

        self.picolos = Layer()

        for i in range(0, 370, 10):
            s = cocos.sprite.Sprite(Picolo.animation,
                                    position=(w // 2, h // 2),
                                    scale=0.8)
            s.rotation = i
            s.position = (w // 2, h // 2)
            if i == 0:
                s.scale = 0.1
            s.visible = i == 0
            self.group1.append(s)
            self.picolos.add(s)

        self.l1.add(self.picolos)

        x, y = 0 - 300, h // 2
        self.wixa1 = get_sprite('wixapol-full.png', x, y)
        self.wixa1.scale = 0.3
        self.wixa1.do(R_Blink(20, 3))
        self.l1.add(self.wixa1)

        x, y = w + 300, h // 2
        self.wixa2 = get_sprite('wixapol-full.png', x, y)
        self.wixa2.scale = 0.3
        self.wixa2.do(R_Blink(20, 3))
        self.l1.add(self.wixa2)

        self.l1.visible = False
        self.add(self.l1)
Ejemplo n.º 3
0
    def start(self):
        #variaveis a serem resetadas com u jogo novo
        self.is_game_over = False
        self.is_colliding_left = False
        self.is_colliding_right = False
        self.is_colliding_base = False
        self.currentScore = 0        
        self.game_time = 0

        self.c_manager =  game_controller.game_controller.c_manager# obtem instancia do gerenciador de colisao

        self.keybd_input = Keyboard_Input()# iniciaiza o layer de input do teclado
        self.wall_limits = Wall_Limits()# iniciaiza o layer para as delimitacoes do jogo
        self.pieces_wall = Pieces_Wall()# iniciaiza o layer de bloco de pecas
        self.game_info_layer = Game_Info()# iniciaiza o layer de informacoes do jogo (informacoes no canto direito)
        self.game_over_lyr = Ranking(is_game_over=True)# iniciaiza o layer de game over para mostrar ranking
        self.pause_lyr = Pause()# iniciaiza o layer de pause do game
        # iniciaiza o layer multiplo para alternar entre layer do input,mostrar o game over e pause
        self.multi_layer = MultiplexLayer(Layer(), self.game_over_lyr, self.pause_lyr)

        self.add(self.wall_limits)# adiciona layer
        self.add(self.game_info_layer)# adiciona layer
        self.add(self.pieces_wall)# adiciona a a layer
        self.add(self.keybd_input)# adiciona layer
        self.add(self.multi_layer)# adiciona layer

        self.add_next_piece()# inicializa a primeira peca

        self.start_timer()
Ejemplo n.º 4
0
    def __init__(self):
        Scene.__init__(self)
        self.add(
            Sprite(image=pyglet.resource.image('background.png'),
                   position=(self.anchor_x,
                             self.anchor_y)))  # Background Image

        black_fade = ColorLayer(0, 0, 0, 0)
        black_fade.opacity = 120
        self.add(black_fade)

        menu = Menu("TETRIS")
        menu.position = (0, -60)
        menu.font_title["font_name"] = "Tetrominoes"
        menu.font_title["color"] = (214, 178, 152, 255)
        menu.font_item["font_name"] = "Ravie"
        menu.font_item_selected["font_name"] = "Ravie"

        menu_items = [
            MenuItem('Start Game',
                     game_controller.game_controller.init_new_game),
            MenuItem('Ranking', self.show_ranking),
            MenuItem('Quit', game_controller.game_controller.close_scene)
        ]
        menu.menu_hmargin = 10
        menu.create_menu(menu_items)

        menu.on_quit = self.on_quit

        self.menu_lyr = Layer()
        self.menu_lyr.add(menu)
        self.rank = Ranking()
        self.multi_layer = MultiplexLayer(self.menu_lyr, self.rank)
        self.add(self.multi_layer)
Ejemplo n.º 5
0
    def __init__(self):
        super(WixaPortal, self).__init__()
        w, h = director.get_window_size()

        self.xds = Layer()
        for i in range(0, 180, 10):
            xd = Line("xD " * 20, 50, (255, 255, 0, 255), w // 2, h // 2,
                      "November", pyglet.font.Text.CENTER,
                      pyglet.font.Text.CENTER)
            xd.rotation = i
            xd.do(Repeat(CallFunc(xd.update_line) + Delay(0.05)))
            self.xds.add(xd)

        self.add(self.xds)

        x, y = w // 2, h // 2

        s = get_sprite('krawczyk.png', x, y)
        s.do(Repeat(RotateTo(20, 0.2) + RotateTo(-10, 0.2)))
        self.add(s)

        self.wixa1 = get_sprite('wixapol-full.png', x, y)
        # self.wixa1.do(R_ScaleFromTo(1.5, 0.3, 0.3))
        self.wixa1.do(R_Blink(15, 3))
        self.add(self.wixa1)
Ejemplo n.º 6
0
    def __init__(self):
        super(Battlefiled, self).__init__()

        self.background = Layer()
        self.player = PlayerLayer()

        self.map = cocos.tiles.load('sources/map.tmx')['map']
        self.map.set_view(0, 0, 16 * 32, 16 * 32)

        self.add(self.map)
        self.add(self.background)
        self.add(self.player)

        label = Label('Battlefiled',
                      font_name='Times New Roman',
                      font_size=32,
                      anchor_x='center',
                      anchor_y='center')
        label.position = 512, 20
        self.background.add(label)

        self.posion = Poisoner(self.map)
        self.posion.setPoisonRegion((64, 64), 128)

        self.schedule_interval(self.schedWork, 1)
Ejemplo n.º 7
0
    def __init__(self, person, callback=None, **kwargs):
        super(Personinfo, self).__init__()

        self.add(Back(position=(self.width // 72, self.height // 20),
                     size=(self.width // 24, int(self.height * 0.9)),callback=self._callback, switch=self.switch))
        self.add(Back(position=(self.width * 17 // 18, self.height // 20),
                     size=(self.width // 24, int(self.height * 0.9)),callback=self._callback, switch=self.switch))
        self.callback = callback
        self.kwargs = kwargs
        self.layer1 = Layer()
        self.layer2 = Layer()
        self.add(self.layer1)
        self.add(self.layer2)

        self.person = person
        self.info_display(person)

        self.layer2.visible = False
Ejemplo n.º 8
0
    def on_mouse_press(self, x, y, buttons, modifiers):
        if buttons is 1:
            if y in range(self.position[1], self.position[1] + self.height):
                print(self.i, self.displayitem)
                if self.operation is 'save':
                    self.parent.set_handler(False)
                    if self.map is None:
                        print('saved')
                        self.save()
                    else:
                        self.parent.add(
                            Confirm(confirm=self.save, cancel=self.cancel))
                elif self.operation is 'load' and self.map is not None:
                    map = self.map
                    menulayer = Menulayer()
                    infolayer = Layer()
                    arena2 = arena.Arena(map, menulayer, infolayer)

                    class Transition(FadeTransition):
                        def finish(self):
                            super().finish()
                            for rec in map.reconstruct_log:
                                arena2.reconstruct(rec, ty='load')
                            arena2.focus('1')
                            arena2.map.take_turn(arena2)

                    self.kill()
                    director.replace(
                        Transition(Scene(arena2, menulayer, infolayer),
                                   duration=1))
                    if self.arena is not None:
                        self.arena.kill()

        elif buttons is 4:
            self.parent.kill()
            if self.arena is not None:
                director.window.push_handlers(self.arena)
            else:
                from main import Main
                from .arena import map_init
                layer = Layer()
                director.replace(Scene(layer, Main(map_init(), layer)))
            pass
Ejemplo n.º 9
0
    def __init__(self):
        super(Podium, self).__init__()

        self.podium = Layer()
        self.podium.is_event_handler = True
        self.podium.on_key_press = self.on_key_press

        center = director.window.width / 2

        podium_sprite = Sprite('podium.png')
        podium_sprite.image_anchor_y = 0
        podium_sprite.x = center

        self.podium.add(podium_sprite)

        top_3 = state.cup.total_ranking[:3]

        for index, car in enumerate(top_3):
            label = util.Label(text=car.name,
                               font_size=25,
                               anchor_y='bottom',
                               anchor_x='center')
            label.x = center + (X_DIR[index] * BLOCK_WIDTH)
            label.y = HEIGHTS[index] + 20
            self.podium.add(label, z=3)

        self.add(self.podium, z=2)

        fireworks = Fireworks()
        fireworks.x = center
        fireworks.y = director.window.height / 2 + 100
        self.add(fireworks, z=1)

        if state.profile.car in top_3:
            position = top_3.index(state.profile.car)
            earned = MONEY[position]
            head_text = 'You earned $%d!' % (earned, )

            state.profile.money += earned
            state.profile.save()

            if position == 0:
                head_text = 'Congratulations! ' + head_text
        else:
            head_text = 'Better luck next time!'

        head_label = util.Label(text=head_text,
                                font_size=30,
                                anchor_x='center',
                                anchor_y='bottom')
        head_label.x = center
        head_label.y = director.window.height - 75
        self.add(head_label, z=3)
Ejemplo n.º 10
0
    def __init__(self, track):
        Scene.__init__(self)
        self.text = 'Loading...'
        self.track = track
        self.layer = Layer()
        self.label = Label(self.text + '0%', position=(100, 100))
        self.layer.add(self.label)
        self.add(self.layer)

        self.schedule(self.load_track)

        self.images_loaded = False
        self.overlay_loaded = False
Ejemplo n.º 11
0
 def changeright(self, source):
     self.right.kill()
     if type(source) is str:
         self.right = Sprite(source, position=(self.w * 5 // 6, self.h // 2))
         self.right.scale_x, self.right.scale_y = \
             480 / self.right.width, 640 / self.right.height
     else:
         self.right = Layer()
         pos1, pos2 = (self.w-640, self.h // 2), (self.w-300, self.h // 2)
         spr1, spr2 = Sprite(source[0], position=pos1), Sprite(source[1], position=pos2)
         spr1.scale_x, spr1.scale_y = 480 / spr1.width, 640 / spr1.height
         spr2.scale_x, spr2.scale_y = 480 / spr2.width, 640 / spr2.height
         self.right.add(spr1)
         self.right.add(spr2)
     self.add(self.right)
Ejemplo n.º 12
0
    def __init__(self):
        super(SportySpice2, self).__init__()
        w, h = director.get_window_size()
        l = Layer()
        demon = get_sprite('mememe_evil.jpg', w // 2, h // 2 - 270)
        demon.scale = 0.7
        demon.do(R_Blink(10, 3))
        demon.transform_anchor = 0, h // 2
        l.add(demon)
        # demon.do(R_ScaleFromTo(3, 1, 0.2))
        # self.add(demon)

        sporty = cocos.text.RichLabel("S\nP\nO\nR\nT\nY",
                                      x=w // 2,
                                      y=h // 2,
                                      font_name="November",
                                      multiline=True,
                                      width=50,
                                      color=(255, 255, 0, 255),
                                      font_size=60)

        sporty.transform_anchor = w // 2, h // 2
        sporty.rotation = -25
        sporty.position = -300, 300
        # sporty.do(R_ScaleFromTo(1, 1.3, 0.1))
        # sporty.do(Shaky3D())

        # self.add(sporty)
        l.add(sporty)
        spice = cocos.text.RichLabel("S\nP\nI\nC\nE",
                                     x=w // 2,
                                     y=h // 2,
                                     font_name="November",
                                     multiline=True,
                                     width=50,
                                     color=(255, 255, 0, 255),
                                     font_size=60)
        spice.transform_anchor = w // 2, h // 2
        spice.rotation = 30
        spice.position = 300, 300
        l.add(spice)

        # self.add(spice)
        l.transform_anchor = w // 2, h // 2 + 200

        l.do(R_ScaleFromTo(3, 1, 0.2))
        self.add(l)
Ejemplo n.º 13
0
 def test_add(self):
     positions = {
         "left": (320, 249.0),
         "right": (101, 249.0),
         "top": (254.0, 204),
         "bottom": (254.0, 240)
     }
     for side in positions:
         frame = Frame(background_color=(0, 0, 98, 255), side=side)
         frame.position = 320, 240
         layer = Layer()
         scene = Scene()
         layer.add(frame)
         scene.add(layer)
         label = Label("Hello World")
         label_new = Label("Hello World again")
         frame.add(label)
         frame.add(label_new)
Ejemplo n.º 14
0
 def display(self):
     self.i = 0
     text_list = self.event[self.i]['Text']
     text_source = self.map.global_vars.data.text
     tag = self.event[self.i]['Tag']
     self.event_length = len(self.event)
     self.keep = Afterdialog(text_list,
                             text_source,
                             self.map,
                             self.w,
                             self.h,
                             tag=tag,
                             callback=self._callback,
                             info=self.dialog_info)
     self.scene = Layer()
     director.push(Scene(self.scene))
     self.scene.add(self.keep)
     self.keep.excute()
Ejemplo n.º 15
0
 def display(self):
     self.i = 0
     while not check_condition(self.event[self.i]['Condition'], self.map):
         self.i += 1
     if self.i < len(self.event):
         text_list = self.event[self.i]['Text']
         text_source = self.map.global_vars.data.text
         tag = self.event[self.i]['Tag']
         self.event_length = len(self.event)
         self.keep = Afterdialog(text_list,
                                 text_source,
                                 self.map,
                                 self.w,
                                 self.h,
                                 tag=tag,
                                 callback=self._callback,
                                 info=self.dialog_info)
         self.scene = Layer()
         director.push(Scene(self.scene))
         self.scene.add(self.keep)
         self.keep.excute()
     else:
         self.kill()
         self.callback.__call__(**self.kwargs)
Ejemplo n.º 16
0
        l.append(MenuItem('New_game', self.new_game))
        l.append(MenuItem('Load_game', self._load_game, layer))
        l.append(MenuItem('Quit', self.quit))

        self.create_menu(l, zoom_in(), zoom_out())

    def new_game(self):
        new_game(self.map)

    def _load_game(self, layer):
        sl = Saveload(1280, 720, None, 'load')
        layer.add(sl)
        self.kill()

    def quit(self):
        director.pop()


if __name__ == '__main__':
    pyglet.resource.path = ['./img']
    pyglet.resource.reindex()
    director.init(caption='The Lost Books', width=1280, height=720)
    director.show_FPS = True
    img = pyglet.resource.image('cursor/sword.png', flip_x=True)
    img.width, img.height = 40, 40
    img.anchor_x, img.anchor_y = 20, 20
    cursor = pyglet.window.ImageMouseCursor(img)
    director.window.set_mouse_cursor(cursor)
    layer = Layer()
    director.run(Scene(layer, Main(map_init(), layer=layer)))
Ejemplo n.º 17
0
            self.add(self.mbg)
            self.active = 0

        def on_text(self, text):
            if text == 'r':
                self.bg.color = (255, 0, 0)
            if text == 'g':
                self.bg.color = (0, 255, 0)
            if text == 'b':
                self.bg.color = (0, 0, 255)
            if text in '0123':
                self.active = int(text)

        def on_text_motion(self, motion):
            if motion == pyglet.window.key.MOTION_LEFT:
                if self.active == 0:
                    self.bg.value -= .1
                else:
                    values = list(self.mbg.values)
                    values[self.active - 1] -= .1
                    self.mbg.values = values
            if motion == pyglet.window.key.MOTION_RIGHT:
                if self.active == 0:
                    self.bg.value += .1
                else:
                    values = list(self.mbg.values)
                    values[self.active - 1] += .1
                    self.mbg.values = values

    director.run(Scene(Layer()))
Ejemplo n.º 18
0
    def __init__(self):
        super(CrystalSkulls, self).__init__()
        w, h = director.get_window_size()

        s = get_sprite('bones.png', w // 2, h // 2)
        s.do(R_ScaleFromTo(2, 1, 0.3))
        self.add(s)

        self.l1 = Layer()

        self.l1.add(Skulls())

        s = get_sprite('wixapol.png', w // 2 - 80, h // 2 + 50)
        s.do(R_ScaleFromTo(1.2, 0.2, 0.1))
        self.l1.add(s)

        s = get_sprite('wixapol.png', w // 2 + 80, h // 2 + 50)
        s.do(R_ScaleFromTo(1.2, 0.2, 0.1))
        self.l1.add(s)

        self.l1.transform_anchor = w // 2, h // 2
        OFFSET_X = 400
        OFFSET_Y = 200
        DELAY = 0.15

        self.l1.do(
            Repeat((Place(
                (-OFFSET_X, 0)) + Delay(DELAY) + ScaleTo(1, 0.15) + Place(
                    (0, 0)) + Delay(DELAY) + ScaleTo(2, 0.15) + Place(
                        (OFFSET_X, 0)) + Delay(DELAY) + ScaleTo(1, 0.15) +
                    Place((0, 0)) + Delay(DELAY) + ScaleTo(2, 0.15) + Place(
                        (-OFFSET_X, 0)) + Delay(DELAY) + ScaleTo(1, 0.15) +
                    Place((0, 0)) + Delay(DELAY) + ScaleTo(2, 0.15) + Place(
                        (0, OFFSET_Y)) + Delay(DELAY) + Place(
                            (0, 0)) + Delay(DELAY) + Place(
                                (0, -OFFSET_Y)) + Delay(DELAY) + Place(
                                    (0, 0)) + Delay(DELAY) + Place(
                                        (0, OFFSET_Y)) + Delay(DELAY) + Place(
                                            (0, 0)) + Delay(DELAY))))

        self.l2 = Layer()
        s = get_sprite('skeleton.png', w // 2, h // 2)
        s.scale = 0.7
        s.do(
            Repeat(
                Twirl(center=(w // 2, 200),
                      grid=(16, 12),
                      duration=5,
                      twirls=6,
                      amplitude=0.5)))
        self.l2.add(s)

        for pos in ((w // 2 - 600, h // 2), (w // 2 + 600, h // 2)):
            x, y = pos
            s = get_sprite('wixapol-full.png', x, y)
            s.scale = 0.4

            s.do(
                Repeat(
                    Place((x, y - 250)) + Delay(DELAY * 2) + Place((x, y)) +
                    Delay(DELAY * 2) + Place((x, y + 250)) + Delay(DELAY * 2) +
                    Place((x, y)) + Delay(DELAY * 2)))
            s.do(R_Blink(10, 3))
            self.l2.add(s)

        self.add(self.l1)
        self.add(self.l2)

        self.is_first_layer = True

        self.do(Repeat(CallFunc(self.callback) + Delay(15)))