Ejemplo n.º 1
0
def test_level(fn):
    level = Level()
    level.read(fn)

    solutions = level.solve()
    assert len(solutions) > 0
    assert level.par == len(solutions[0])
Ejemplo n.º 2
0
 def setUp(self):
     self.level = Level()
     self.room_a = Room(width=2, height=3)
     self.room_a.x, self.room_a.y = 0, 0
     self.room_b = Room(width=2, height=1)
     self.room_b.x, self.room_b.y = 2, 3
     for room in (self.room_a, self.room_b):
         self.level.add(room)
Ejemplo n.º 3
0
Archivo: game.py Proyecto: gwen23/P3
 def __init__(self):
     pg.init()
     self.maze = Maze()
     pg.display.set_mode((WIDTH, HEIGHT))
     pg.image.load(FL).convert()
     pg.image.load(WA).convert()
     pg.image.load(E).convert_alpha()
     pg.image.load(T).convert_alpha()
     pg.image.load(S).convert_alpha()
     pg.image.load(BG).convert_alpha()
     pg.image.load(PL).convert_alpha()
     pg.display.set_caption('The Maze')
     self.clock = pg.time.Clock()
     self.is_running = True
     self.SCREEN = pg.display.set_mode((WIDTH, HEIGHT))
     self.fond = pg.image.load("./images/floor-tiles-20x20.png").convert()
     self.level = Level()
     self.run()
Ejemplo n.º 4
0
    def setup (self):
        keyboard = mixin (KeyboardTask, AutoSender) (
            DEFAULT_KEYMAP)

        base.setBackgroundColor (Vec4 (.4, .6, .9, 1))
        
        self.events.connect (keyboard)
        self.events.event ('panda-escape').connect (self.kill)

        physics = Physics ()

        boy = Boy (physics = physics,
                   render = render)
        boy.set_position ((0, 70, 20))

        level = Level (physics = physics,
                       render = render)
        level.set_position ((0, 0, -100))

        self.tasks.add (keyboard)
        self.tasks.add (boy)
        self.tasks.add (level)
        self.tasks.add (physics)

        boy.connect (SlowEntityFollower (base.camera))
        keyboard.connect (
            mixin (DelegatePlayerEntity, AutoReceiver) (delegate = boy))
        
        plightnode = PointLight("point light")
        plightnode.setAttenuation (Vec3(1,0.0000005,0.0000001))
        plight = render.attachNewNode (plightnode)
        plight.setPos (100, -100, 1000)

        alightnode = AmbientLight("ambient light")
        alightnode.setColor (Vec4(0.4,0.4,0.4,1))
        alight = render.attachNewNode (alightnode)

        #render.setLight (alight)
        render.setLight (plight)
Ejemplo n.º 5
0
def start_game():
    appium = webdriver.Remote(config.APPIUM_HOST, config.DESIRED_CAPABILITIES)
    unity = AltrunUnityDriver(appium, config.PLATFORM)
    main_menu = MainMenu(unity)
    main_menu.play_button.tap()
    return {
        "Appium": appium,
        "Unity": unity,
        "Game": Game(unity),
        "MainMenu": main_menu,
        "Level": Level(unity),
        "Player": Player(unity),
        "LevelCompleteMenu": LevelComplete(unity),
    }
Ejemplo n.º 6
0
class Play(GameState):
    """The GameState while actually playing a level."""
    highlight = Renderable("resources/images/highlight.png", TILE_CENTER)
    win = Renderable("resources/images/cleared_screen.png",
                     Point(605 / 2, 455 / 2),
                     ignore_cam=True)
    restart = Renderable("resources/images/restart_button.png",
                         Point(100, 0),
                         ignore_cam=True)
    levels = Renderable("resources/images/levels_button.png",
                        Point(0, 0),
                        ignore_cam=True)

    def __init__(self, filepath):
        super(Play, self).__init__()
        self.filepath = filepath
        tileset = Tileset('resources/tileset/default.tset')
        self.level = Level(tileset, filepath)

    def logic(self, mouse):
        if mouse.clicked:
            scr = SCREEN.center * 2
            # restart button
            if (scr.x - SCREEN.camera.x - mouse.pos.x <= 100
                    and SCREEN.camera.y + mouse.pos.y <= 65):
                self.next = Play(self.filepath)
            # levels button
            elif (SCREEN.camera.x + mouse.pos.x <= 100
                  and SCREEN.camera.y + mouse.pos.y <= 65):
                self.next = LevelPicker()
            else:
                # pass the win dialogs
                if self.level.win():
                    if (SCREEN.center - SCREEN.camera - mouse.pos).x > 0:
                        self.next = Title()
                    else:
                        self.next = LevelPicker()
                # pass the click to the level
                tile = screen_to_iso(mouse.pos)
                self.level.tile_clicked(tile)
        self.level.knight.logic()

    def render(self, mouse):
        self.level.render()
        self.highlight.render(iso_to_screen(screen_to_iso(mouse.pos)))
        self.restart.render(Point((SCREEN.center * 2).x, 0))
        self.levels.render(Point(0, 0))
        if self.level.win():
            self.win.render(SCREEN.center)
Ejemplo n.º 7
0
class Play(GameState):
    """The GameState while actually playing a level."""
    highlight = Renderable("resources/images/highlight.png", TILE_CENTER)
    win = Renderable("resources/images/cleared_screen.png",
                     Point(605/2, 455/2), ignore_cam=True)
    restart = Renderable("resources/images/restart_button.png",
                         Point(100, 0), ignore_cam=True)
    levels = Renderable("resources/images/levels_button.png",
                        Point(0, 0), ignore_cam=True)

    def __init__(self, filepath):
        super(Play, self).__init__()
        self.filepath = filepath
        tileset = Tileset('resources/tileset/default.tset')
        self.level = Level(tileset, filepath)

    def logic(self, mouse):
        if mouse.clicked:
            scr = SCREEN.center * 2
            # restart button
            if (scr.x - SCREEN.camera.x - mouse.pos.x <= 100 and
                        SCREEN.camera.y + mouse.pos.y <= 65):
                self.next = Play(self.filepath)
            # levels button
            elif (SCREEN.camera.x + mouse.pos.x <= 100 and
                  SCREEN.camera.y + mouse.pos.y <= 65):
                self.next = LevelPicker()
            else:
                # pass the win dialogs
                if self.level.win():
                    if (SCREEN.center - SCREEN.camera - mouse.pos).x > 0:
                        self.next = Title()
                    else:
                        self.next = LevelPicker()
                # pass the click to the level
                tile = screen_to_iso(mouse.pos)
                self.level.tile_clicked(tile)
        self.level.knight.logic()

    def render(self, mouse):
        self.level.render()
        self.highlight.render(iso_to_screen(screen_to_iso(mouse.pos)))
        self.restart.render(Point((SCREEN.center * 2).x, 0))
        self.levels.render(Point(0, 0))
        if self.level.win():
            self.win.render(SCREEN.center)
Ejemplo n.º 8
0
class LevelGetRoomTest(TestCase):

    def setUp(self):
        self.level = Level()
        self.room_a = Room(width=2, height=3)
        self.room_a.x, self.room_a.y = 0, 0
        self.room_b = Room(width=2, height=1)
        self.room_b.x, self.room_b.y = 2, 3
        for room in (self.room_a, self.room_b):
            self.level.add(room)

    def test_get_nothing(self):
        self.assertEqual(self.level.get(x=128, y=128), set())

    def test_get_one_room(self):
        self.assertEqual(self.level.get(x=0, y=0), set([self.room_a]))

    def test_get_multiple_rooms(self):
        self.assertEqual(self.level.get(width=2),
                         set([self.room_a, self.room_b]))

    def test_get_with_nonexistent_kwargs(self):
        self.assertEqual(self.level.get(nonexistent_kwarg=True), set())
Ejemplo n.º 9
0
class LevelGenerateTest(TestCase):

    def setUp(self):
        self.level = Level()

    def test_generate_one_room(self):
        self.level.generate(num=1)
        self.assertEqual(len(self.level.rooms), 1)

    def test_generate_two_rooms(self):
        self.level.generate(num=2)
        self.assertEqual(len(self.level.rooms), 2)
        room_a, room_b = self.level.rooms
        a_x, a_y = room_a.x, room_a.y
        a_w, a_h = room_a.width, room_a.height
        b_x, b_y = room_b.x, room_b.y
        b_w, b_h = room_b.width, room_b.height
        self.assertTrue(
            (max(a_x, b_x) - min(a_x, b_x) <= max(a_w, b_w) + 1) or
            (max(a_y, b_y) - min(a_y, b_y) <= max(a_h, b_h) + 1))

    def test_generate_eight_rooms(self):
        self.level.generate(num=8)
        self.assertEqual(len(self.level.rooms), 8)
Ejemplo n.º 10
0
def level(unity):
    return Level(unity)
Ejemplo n.º 11
0
Archivo: game.py Proyecto: gwen23/P3
class Game:
    def __init__(self):
        pg.init()
        self.maze = Maze()
        pg.display.set_mode((WIDTH, HEIGHT))
        pg.image.load(FL).convert()
        pg.image.load(WA).convert()
        pg.image.load(E).convert_alpha()
        pg.image.load(T).convert_alpha()
        pg.image.load(S).convert_alpha()
        pg.image.load(BG).convert_alpha()
        pg.image.load(PL).convert_alpha()
        pg.display.set_caption('The Maze')
        self.clock = pg.time.Clock()
        self.is_running = True
        self.SCREEN = pg.display.set_mode((WIDTH, HEIGHT))
        self.fond = pg.image.load("./images/floor-tiles-20x20.png").convert()
        self.level = Level()
        self.run()

    def run(self):
        self.SCREEN.blit(self.fond, (0, 0))
        self.level.display(self.maze.tiles)
        self.count_display()
        self.main_loop()

    def count_display(self):
        # create a black surface and display it
        s = pg.Surface((300, 100))
        s.fill((0, 0, 0))
        self.SCREEN.blit(s, (20, 300))
        # write object count
        white = (255, 255, 255)
        phrase = "nombre d'objets ramassés : " + str(self.maze.numb_objects)
        font = pg.font.SysFont("arial", 24)
        text = font.render(phrase, True, white)
        self.SCREEN.blit(text, (20, 310))

    def main_loop(self):
        x = 0
        y = 20
        is_running = True
        while is_running:
            clock.tick(5)
            for event in pg.event.get():
                if event.type == Kd and event.key == pg.K_RIGHT:
                    if self.maze.move_macgyver("right"):
                        SCREEN.blit(pg.image.load(FL).convert(), (x, y))
                        x += 1 * SIZE_SPRITE
                        SCREEN.blit(pg.image.load(PL).convert_alpha(), (x, y))
                elif event.type == Kd and event.key == pg.K_LEFT:
                    if self.maze.move_macgyver("left"):
                        SCREEN.blit(pg.image.load(FL).convert(), (x, y))
                        x -= 1 * SIZE_SPRITE
                        SCREEN.blit(pg.image.load(PL).convert_alpha(), (x, y))
                elif event.type == Kd and event.key == pg.K_UP:
                    if self.maze.move_macgyver("up"):
                        SCREEN.blit(pg.image.load(FL).convert(), (x, y))
                        y -= 1 * SIZE_SPRITE
                        SCREEN.blit(pg.image.load(PL).convert_alpha(), (x, y))
                elif event.type == Kd and event.key == pg.K_DOWN:
                    if self.maze.move_macgyver("down"):
                        SCREEN.blit(pg.image.load(FL).convert(), (x, y))
                        y += 1 * SIZE_SPRITE
                        SCREEN.blit(pg.image.load(PL).convert_alpha(), (x, y))
                if event.type == pg.QUIT:
                    is_running = False
                self.count_display()
            pg.display.update()
        pg.quit()
Ejemplo n.º 12
0
Archivo: game.py Proyecto: gwen23/P3
import pygame as pg
from pygame.locals import KEYDOWN as Kd

from game.settings import E, T, S, FL, WA, BG, PL, WIDTH, HEIGHT, SIZE_SPRITE
from game.level import Level
from game.the_maze import Maze

clock = pg.time.Clock()
pg.display.set_caption('The Maze')
level = Level()
SCREEN = pg.display.set_mode((WIDTH, HEIGHT))


class Game:
    def __init__(self):
        pg.init()
        self.maze = Maze()
        pg.display.set_mode((WIDTH, HEIGHT))
        pg.image.load(FL).convert()
        pg.image.load(WA).convert()
        pg.image.load(E).convert_alpha()
        pg.image.load(T).convert_alpha()
        pg.image.load(S).convert_alpha()
        pg.image.load(BG).convert_alpha()
        pg.image.load(PL).convert_alpha()
        pg.display.set_caption('The Maze')
        self.clock = pg.time.Clock()
        self.is_running = True
        self.SCREEN = pg.display.set_mode((WIDTH, HEIGHT))
        self.fond = pg.image.load("./images/floor-tiles-20x20.png").convert()
        self.level = Level()
Ejemplo n.º 13
0
 def __init__(self, filepath):
     super(Play, self).__init__()
     self.filepath = filepath
     tileset = Tileset('resources/tileset/default.tset')
     self.level = Level(tileset, filepath)
Ejemplo n.º 14
0
    def __game(self):
        print("entering __game")

        levels = Level(self.graphics, "home")

        bobby = Bobby(self.graphics)

        finalrender = pygame.Surface(
            (levels.get_map_size()[0], levels.get_map_size()[1]))

        in_dial = False
        pnj_name = "null"
        dial_count = 1

        state_to_return = "EXIT"
        goon = True
        while goon:
            #print(self.clock.get_fps())
            deltatime = self.clock.tick(30) / 100.0

            #events
            for event in pygame.event.get():
                if event.type == QUIT:
                    goon = False

                if in_dial:
                    if event.type == pygame.KEYUP:
                        if event.key == pygame.K_ESCAPE:
                            in_dial = False
                            pnj_name = "null"
                            dial_count = 1

                        if event.key == pygame.K_RETURN:
                            dial_count += 1
                            if dial_count > len(
                                    levels.chars[pnj_name]["dials"]):
                                in_dial = False
                                pnj_name = "null"
                                dial_count = 1
                else:
                    levels.event(event)

                    bobby.event(event)

            # updates
            bob_value = bobby.update(deltatime, levels.get_map_size(), levels)

            if bobby.get_state_to_return() == "MENU":
                state_to_return = "MENU"
                goon = False

            levels.update(bob_value, bobby)

            if levels.currentmap == "credits":
                goon = False
                state_to_return = "CREDITS"
                break

            if finalrender.get_width() != levels.get_map_size(
            )[0] or finalrender.get_height() != levels.get_map_size()[1]:
                finalrender = pygame.Surface(
                    (levels.get_map_size()[0], levels.get_map_size()[1]))

            # draws
            finalrender.blit(levels.draw(), (0, 0))

            b_x, b_y = bobby.get_pos()
            finalrender.blit(bobby.draw(), (b_x, b_y))

            self.screen.blit(
                pygame.transform.scale(finalrender,
                                       (c.WINDOW_WIDTH, c.WINDOW_HEIGHT)),
                (0, 0))

            if bob_value.split(' ')[0] == "pnj" and not in_dial:  # or in_dial
                in_dial = True
                pnj_name = bob_value.split(' ')[1]

            elif in_dial:
                bobby_talk = False

                my_font = pygame.font.Font("res/ubuntumono-r.ttf", 22)
                my_string = levels.chars[pnj_name]["dials"][str(dial_count)]
                if my_string[0] == "*":
                    bobby_talk = True
                    my_string = "<Bobby>  " + my_string[1:]
                else:
                    my_string = "<" + pnj_name[0].upper(
                    ) + pnj_name[1:] + ">  " + my_string

                my_rect = pygame.Rect(
                    (0, 0, c.WINDOW_WIDTH, c.WINDOW_HEIGHT / 4))
                rendered_text = Dialog().render_textrect(
                    my_string, my_font, my_rect, (216, 216, 216),
                    (0, 0, 20, 225), 0)
                self.screen.blit(
                    rendered_text,
                    (0, c.WINDOW_HEIGHT - rendered_text.get_height()))

                # TODO: Change head if ":" or "*"
                if bobby_talk:
                    head = pygame.transform.scale(
                        self.graphics["bobby_head.png"],
                        (175, rendered_text.get_height() + 50))
                else:
                    head = pygame.transform.scale(
                        self.graphics[pnj_name + "_head.png"],
                        (175, rendered_text.get_height() + 50))

                self.screen.blit(
                    head, (0, c.WINDOW_HEIGHT - rendered_text.get_height()))

                continue_font = my_font
                continue_font.set_italic(True)
                dial_left = "(" + str(dial_count) + "/" + str(
                    len(levels.chars[pnj_name]["dials"])) + ")"
                continue_font_rendered = continue_font.render(
                    "Press Enter to continue... " + dial_left, 1,
                    (150, 150, 150))
                self.screen.blit(
                    continue_font_rendered,
                    (c.WINDOW_WIDTH - continue_font_rendered.get_width(),
                     c.WINDOW_HEIGHT - continue_font_rendered.get_height()))

            pygame.display.flip()

        print("exiting __game")

        return state_to_return
Ejemplo n.º 15
0
class LevelAddRoomTest(TestCase):

    def setUp(self):
        self.level = Level()

    def test_empty_level(self):
        self.assertEqual(self.level.rooms, set())

    def test_level_with_one_room(self):
        room = Room(width=1, height=1)
        room.x, room.y = 0, 0
        self.level.add(room)
        self.assertEqual(self.level.rooms, set([room]))

    def test_add_room_without_coordinates(self):
        room = Room(width=1, height=1)
        with self.assertRaises(Level.RoomCoordinatesRequired):
            self.level.add(room)

    def test_add_an_overlapping_room_with_matching_coordinates(self):
        room = Room(width=1, height=1)
        room.x, room.y = 0, 0
        self.level.add(room)
        overlap_room = Room(width=1, height=1)
        overlap_room.x, overlap_room.y = 0, 0
        with self.assertRaises(Level.RoomOverlap):
            self.level.add(overlap_room)

    def test_add_an_overlapping_room_with_positive_shift(self):
        room = Room(width=3, height=3)
        room.x, room.y = 0, 0
        self.level.add(room)
        overlap_room = Room(width=2, height=2)
        overlap_room.x, overlap_room.y = 2, 2
        with self.assertRaises(Level.RoomOverlap):
            self.level.add(overlap_room)

    def test_add_an_overlapping_room_with_negative_shift(self):
        room = Room(width=3, height=3)
        room.x, room.y = 3, 3
        self.level.add(room)
        overlap_room = Room(width=2, height=2)
        overlap_room.x, overlap_room.y = 2, 2
        with self.assertRaises(Level.RoomOverlap):
            self.level.add(overlap_room)

    def test_level_with_two_non_adjacent_rooms(self):
        for x, y in [(0, 0), (3, 3)]:
            room = Room(width=1, height=1)
            room.x, room.y = x, y
            self.level.add(room)
        self.assertEqual(len(self.level.rooms), 2)

    def test_two_diagonaly_adjacent_rooms(self):
        """
        Rooms are not considered to be adjacent if they touch diagonaly.
        """
        for x, y in [(0, 0), (1, 1)]:
            room = Room(width=1, height=1)
            room.x, room.y = x, y
            self.level.add(room)
            turf = iter(room.get(x=0, y=0)).next()
            self.assertEqual(turf.exits, {})
        self.assertEqual(len(self.level.rooms), 2)

    def test_level_with_two_fully_adjacent_rooms(self):
        """Exits are added to adjacent turfs."""
        a, b = Room(width=1, height=1), Room(width=1, height=1)
        a.x, a.y, b.x, b.y = 0, 0, 1, 0
        self.level.add(a)
        self.level.add(b)
        turf_a = iter(a.get(x=0, y=0)).next()
        turf_b = iter(b.get(x=0, y=0)).next()
        self.assertEqual(len(self.level.rooms), 2)
        self.assertEqual(len(turf_a.exits), 1)
        self.assertEqual(len(turf_b.exits), 1)
        self.assertEqual(turf_a.exits[(1, 0)], turf_b)
        self.assertEqual(turf_b.exits[(-1, 0)], turf_a)

    def test_level_with_two_partially_adjacent_rooms(self):
        """Non-adjacent turfs do not become exits."""
        a, b = Room(width=3, height=3), Room(width=3, height=3)
        a.x, a.y, b.x, b.y = 3, 1, 0, 0
        self.level.add(a)
        self.level.add(b)
        exits = set([((0, 0), (2, 1)), ((0, 1), (2, 2))])
        for ((a_x, a_y), (b_x, b_y)) in exits:
            turf_a = iter(a.get(x=a_x, y=a_y)).next()
            turf_b = iter(b.get(x=b_x, y=b_y)).next()
            self.assertEqual(len(turf_a.exits), 1)
            self.assertEqual(len(turf_b.exits), 1)
            self.assertEqual(turf_a.exits[(-1, 0)], turf_b)
            self.assertEqual(turf_b.exits[(1, 0)], turf_a)
        no_exits = {
            a: set([(0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]),
            b: set([(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0)])}
        for room, coordinates in no_exits.items():
            for (x, y) in coordinates:
                turf = iter(room.get(x=x, y=y)).next()
                self.assertEqual(len(turf.exits), 0)

    def test_level_with_three_adjacent_rooms(self):
        a, b, c = Room(width=1, height=1), Room(1, 1), Room(1, 1)
        a.x, a.y, b.x, b.y, c.x, c.y = 0, 0, 1, 0, 0, 1
        for room in (a, b, c):
            self.level.add(room)
        turf_a = iter(a.get(x=0, y=0)).next()
        turf_b = iter(b.get(x=0, y=0)).next()
        turf_c = iter(c.get(x=0, y=0)).next()
        self.assertEqual(len(turf_a.exits), 2)
        for turf in (turf_b, turf_c):
            self.assertEqual(len(turf.exits), 1)
        self.assertEqual(turf_a.exits, {(1, 0): turf_b, (0, 1): turf_c})
        self.assertEqual(turf_b.exits[(-1, 0)], turf_a)
        self.assertEqual(turf_c.exits[(0, -1)], turf_a)
Ejemplo n.º 16
0
 Level(
     pygame.image.load("./assets/bgs/hometown.png"),
     "./assets/sounds/music/pallet_town.mp3",
     [
         Entity([0, 0], [430, 75]),  # level walls
         Entity([0, 0], [220, 720]),
         Entity([0, 560], [1080, 720]),
         Entity([1080 - 224, 0], [224, 720]),
         Entity([1080 - 434, 0], [434, 75]),
         Entity([315, 90], [140, 80]),  # topleft house
         Entity([315, 90], [35, 110]),
         Entity([400, 90], [55, 110]),
         Entity([620, 90], [140, 80]),  # topright house
         Entity([620, 90], [35, 110]),
         Entity([705, 90], [55, 110]),
         Entity([620, 310], [140, 80]),  # bottomright house
         Entity([620, 310], [35, 110]),
         Entity([705, 310], [55, 110]),
         Entity([300, 310], [180, 80]),  # oakslab
         Entity([300, 310], [65, 110]),
         Entity([415, 310], [65, 110]),
     ],
     [
         ExitZone([430, 0], [220, 5], (0, 670),
                  "route1",
                  True,
                  doMusicChange=True),  # hometown to route 1
         # ExitZone([360, 180], [35, 5], (527,570) , "oakslab", False), # hometown to topleft house
         ExitZone([375, 400], [35, 5], (527, 570),
                  "oakslab",
                  False,
                  doMusicChange=True),  # hometown to oakslab
     ],
     PokeZone()),
Ejemplo n.º 17
0
 def __init__(self, filepath):
     super(Play, self).__init__()
     self.filepath = filepath
     tileset = Tileset('resources/tileset/default.tset')
     self.level = Level(tileset, filepath)
Ejemplo n.º 18
0
 def setUp(self):
     self.level = Level()