Python Stage.save Beispiele

Beispiel #1

Datei: stage8.py Projekt: nganhkhoa/ai-ass1-demo

def stage8():
    arr = [[] for i in range(9)]  # type: List[List[Tile]]

    arr[0] = [None for i in range(9)]
    arr[0] += [Tile(), Tile(), Tile()]

    arr[1] = [None for i in range(9)]
    arr[1] += [Tile(), Tile(), Tile()]

    arr[2] = [None for i in range(9)]
    arr[2] += [Tile(), Tile(), Tile()]

    arr[3] = [Tile() for i in range(6)]
    arr[3] += [None, None, None]
    arr[3] += [Tile() for i in range(6)]

    arr[4] = [Tile() for i in range(4)]
    arr[4] += [Tile(T.split, [1, 10, 7, 10]), Tile(), None, None, None]
    arr[4] += [Tile(), Tile(), Tile(), Tile(), Tile(T.goal), Tile()]

    arr[5] = [Tile() for i in range(6)]
    arr[5] += [None, None, None]
    arr[5] += [Tile() for i in range(6)]

    arr[6] = [None for i in range(9)]
    arr[6] += [Tile(), Tile(), Tile()]

    arr[7] = [None for i in range(9)]
    arr[7] += [Tile(), Tile(), Tile()]

    arr[8] = [None for i in range(9)]
    arr[8] += [Tile(), Tile(), Tile()]

    s = Stage('8', arr, 4, 1)
    s.save('8')

Beispiel #2

Datei: stage2.py Projekt: nganhkhoa/ai-ass1-demo

def stage2():
    arr = [[] for i in range(6)]  # type: List[List[Tile]]
    bridge_left = [Tile(T.bridge, False), Tile(T.bridge, False)]
    bridge_right = [Tile(T.bridge, False), Tile(T.bridge, False)]

    arr[0] = [None, None, None, None, None, None,
              Tile(), Tile(), Tile(), Tile(),
              None, None, Tile(), Tile(), Tile()]

    arr[1] = [Tile(), Tile(), Tile(), Tile(), None, None, Tile(), Tile(),
              Tile(T.hard_special_button, bridge_right, []), Tile(),
              None, None, Tile(), Tile(T.goal), Tile()]

    arr[2] = [Tile(), Tile(), Tile(T.soft_button, bridge_left), Tile(),
              None, None, Tile(), Tile(), Tile(), Tile(),
              None, None, Tile(), Tile(), Tile()]

    arr[3] = [Tile(), Tile(), Tile(), Tile(),
              None, None, Tile(), Tile(), Tile(), Tile(),
              None, None, Tile(), Tile(), Tile()]

    arr[4] = [Tile(), Tile(), Tile(), Tile(),
              bridge_left[0], bridge_left[1], Tile(), Tile(), Tile(), Tile(),
              bridge_right[0], bridge_right[1], Tile(), Tile(), Tile()]

    arr[5] = [Tile(), Tile(), Tile(), Tile(), None, None,
              Tile(), Tile(), Tile(), Tile(),
              None, None, None, None, None, None]

    s = Stage('2', arr, 4, 1)
    s.save('2')

Beispiel #3

def stage14():
    HB1 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    HB2 = [Tile(T.bridge, False), Tile(T.bridge, False)]

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [None for i in range(8)]
    arr[0] += [Tile(), Tile(), Tile()]

    arr[1] = [
        None, None, None,
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(),
        Tile(),
        Tile()
    ]

    arr[2] = [Tile(), HB1[0], HB1[1]]
    arr[2] += [Tile() for i in range(11)]

    arr[3] = [Tile(), HB2[0], HB2[1], Tile(), Tile(), Tile()]
    arr[3] += [None for i in range(6)]
    arr[3] += [Tile(T.hard_button, HB1), Tile()]

    arr[4] = [Tile()]
    arr[4] += [None for i in range(11)]
    arr[4] += [Tile(), Tile()]

    arr[5] = [Tile()]
    arr[5] += [None for i in range(11)]
    arr[5] += [Tile(), Tile()]

    arr[6] = [Tile()]
    arr[6] += [None for i in range(7)]
    arr[6] += [Tile() for i in range(6)]

    arr[7] = [Tile() for i in range(5)]
    arr[7] += [None, None, None, Tile(), Tile(), Tile()]

    arr[8] = [
        None,
        Tile(),
        Tile(),
        Tile(T.goal),
        Tile(), None, None, None,
        Tile(),
        Tile(),
        Tile()
    ]

    arr[9] = [None, None, Tile(), Tile(), Tile(), None, None, None]
    arr[9] += [Tile() for i in range(5)]
    arr[9].append(Tile(T.hard_button, HB2))

    s = Stage('14', arr, 2, 4)
    s.save('14')

Beispiel #4

Datei: stage27.py Projekt: nganhkhoa/ai-ass1-demo

def stage27():
    SB1 = Tile(T.bridge, True)
    SB2 = Tile(T.bridge, True)

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [Tile(), Tile(), Tile(), None, None, None, None]
    arr[0] += [Tile() for i in range(8)]

    arr[1] = [Tile() for i in range(11)]
    arr[1] += [None, None, Tile(), Tile()]

    arr[2] = [
        Tile(),
        Tile(),
        Tile(), None, None, None, None,
        Tile(),
        Tile(), None, None, None, None,
        Tile(),
        Tile()
    ]

    arr[3] = [None for i in range(12)]
    arr[3] += [Tile(), Tile(T.hard_special_button, [], [SB1, SB2]), Tile()]

    arr[4] = [None for i in range(12)]
    arr[4] += [Tile(), Tile()]

    arr[5] = [
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(T.soft_ground),
        Tile(T.soft_ground),
        Tile(T.soft_ground),
        Tile(T.soft_ground),
        Tile(), None, None,
        Tile(T.soft_special_button, [], [SB1]),
        Tile(T.soft_special_button, [], [SB2])
    ]

    arr[6] = [Tile(), Tile(T.goal), Tile()]
    arr[6] += [Tile(T.soft_ground) for i in range(7)]
    arr[6] += [None, None, Tile(), Tile(), Tile()]

    arr[7] = [Tile(), Tile(), Tile()]
    arr[7] += [Tile(T.soft_ground) for i in range(9)]
    arr[7] += [Tile(), Tile(), Tile()]

    arr[8] = [None for i in range(5)]
    arr[8] += [Tile(T.soft_ground) for i in range(7)]
    arr[8] += [Tile(), Tile(), Tile()]

    arr[9] = [None for i in range(6)]
    arr[9] += [SB1, Tile(), Tile(), SB2]

    s = Stage('27', arr, 1, 1)
    s.save('27')

Beispiel #5

Datei: stage18.py Projekt: nganhkhoa/ai-ass1-demo

def stage18():
    HB = [Tile(T.bridge, False)]
    SB2 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    SB3 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    SB4 = [Tile(T.bridge, False), Tile(T.bridge, False)]

    arr = [[] for i in range(9)]  # type: List[List[Tile]]

    arr[0] = [None for i in range(7)]
    arr[0].append(Tile(T.soft_special_button, SB2, []))

    arr[1] = [
        Tile(),
        Tile(),
        Tile(T.soft_special_button, [], [SB3[0], SB3[1], SB4[0], SB4[1]]),
        Tile(), None, None, None,
        Tile()
    ]

    arr[2] = [Tile(), Tile(), Tile(), Tile(), Tile(), None, None, Tile()]

    arr[3] = [Tile(), Tile(T.soft_special_button, [], SB2)]
    arr[3] += [Tile() for i in range(6)]
    arr[3] += [SB2[0], SB2[1], Tile(), Tile(), SB3[0], SB3[1], Tile()]

    arr[4] = [Tile() for i in range(5)]
    arr[4] += [HB[0], None, None, Tile(), None, None, None, Tile()]

    arr[5] = [
        Tile(),
        Tile(),
        Tile(T.soft_special_button, [], [SB3[0], SB3[1], SB4[0], SB4[1]]),
        Tile(), None, None, None, None,
        Tile(), None, None, None,
        Tile()
    ]

    arr[6] = [Tile()]
    arr[6] += [None for i in range(7)]
    arr[6] += [
        Tile(T.soft_special_button, [SB3[0], SB3[1], SB4[0], SB4[1]], []),
        None, None,
        Tile(),
        Tile(),
        Tile()
    ]

    arr[7] = [Tile()]
    arr[7] += [None for i in range(9)]
    arr[7] += [Tile(), Tile(), Tile(T.goal), Tile()]

    arr[8] = [Tile(), SB4[0], SB4[1], Tile(T.hard_button, HB)]
    arr[8] += [None for i in range(6)]
    arr[8] += [Tile(), Tile(), Tile(), Tile()]

    s = Stage('18', arr, 3, 2)
    s.save('18')

Beispiel #6

Datei: stage22.py Projekt: nganhkhoa/ai-ass1-demo

def stage22():
    B1 = [Tile(T.bridge, False), Tile(T.bridge, False)]

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [None for i in range(5)]
    arr[0] += [Tile(), Tile(), None, None, None, None, Tile(), Tile(), Tile()]

    arr[1] = [None, None, None]
    arr[1] += [Tile() for i in range(6)]
    arr[1] += [None, None, Tile(), Tile(T.goal), Tile()]

    arr[2] = [Tile() for i in range(6)]
    arr[2] += [Tile(T.soft_special_button, [], B1)]
    arr[2] += [Tile() for i in range(7)]

    arr[3] = [
        Tile(),
        Tile(),
        Tile(),
        Tile(),
        Tile(T.soft_special_button, [], B1), None, None,
        Tile(),
        Tile(),
        Tile(),
        Tile(),
        Tile(), B1[1]
    ]

    arr[4] = [Tile(), Tile(), Tile()]
    arr[4] += [None for i in range(6)]
    arr[4] += [Tile(), Tile(), Tile()]

    arr[5] = [None, Tile()]
    arr[5] += [None for i in range(7)]
    arr[5] += [None, Tile()]

    arr[6] = [None, Tile()]
    arr[6] += [None for i in range(7)]
    arr[6] += [None, Tile()]

    arr[7] = [None, Tile(), B1[0]]
    arr[7] += [None for i in range(6)]
    arr[7] += [Tile(), Tile()]

    arr[8] = [None, Tile(), Tile()]
    arr[8] += [None for i in range(6)]
    arr[8] += [Tile(), Tile()]

    arr[9] = [None, None, Tile(T.hard_button, [B1[1]])]
    arr[9] += [None for i in range(6)]
    arr[9] += [Tile(T.hard_button, [B1[0]])]

    s = Stage('22', arr, 3, 1)
    s.save('22')

Beispiel #7

Datei: stage30.py Projekt: nganhkhoa/ai-ass1-demo

def stage30():
    B1 = [Tile(T.bridge, True), Tile(T.bridge, True)]
    B2 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    SB1 = Tile(T.bridge, False)

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [None, None, None]
    arr[0] += [Tile() for i in range(5)]
    arr[0] += [Tile(T.soft_ground), Tile(T.soft_ground), Tile(), Tile(), Tile(), Tile()]

    arr[1] = [None, None, None, Tile(), Tile(T.goal), Tile(), Tile()]
    arr[1] += [None for i in range(5)]
    arr[1] += [Tile(T.soft_ground), Tile()]

    arr[2] = [None, None, None, Tile(), Tile(), Tile()]
    arr[2] += [None for i in range(6)]
    arr[2] += [Tile(T.soft_ground), Tile(), Tile(T.hard_special_button, B2, B1)]

    arr[3] = [None for i in range(7)]
    arr[3] += [Tile(T.soft_ground), Tile(), Tile(), B1[0], B1[1], Tile(), Tile(), Tile()]

    arr[4] = [None, None, Tile()]
    arr[4] += [None for i in range(4)]
    arr[4] += [Tile(T.soft_ground), Tile(T.soft_ground)]
    arr[4] += [None for i in range(5)]
    arr[4] += [Tile()]

    arr[5] = [None, Tile(T.hard_special_button, B1, []), Tile(), Tile(T.soft_ground), 
                None, None, None, Tile(T.soft_ground), Tile(T.soft_ground)]
    arr[5] += [None for i in range(5)]
    arr[5] += [Tile()]

    arr[6] = [Tile(T.soft_ground) for i in range(4)]
    arr[6] += [None, None, None, Tile(), Tile()]
    arr[6] += [B2[0], None, None, B2[1]]
    arr[6] += [Tile(), Tile()]

    arr[7] = [Tile(T.soft_ground), Tile(T.soft_ground), Tile(T.soft_ground), 
                Tile(), Tile(T.soft_ground), Tile(), Tile(T.soft_ground), Tile(T.soft_ground), 
                Tile(), Tile(T.soft_ground), None, None, Tile(T.hard_button, [SB1]), Tile(), SB1]

    arr[8] = [Tile()]
    arr[8] += [Tile(T.soft_ground) for i in range(11)]
    arr[8] += [Tile()]

    arr[9] = [None, Tile(T.soft_ground), Tile(), 
                Tile(T.soft_ground), Tile(T.soft_ground), Tile(T.soft_ground), 
                None, None, Tile(T.soft_ground), Tile(T.soft_ground), 
                Tile(T.soft_ground), Tile(T.soft_ground), Tile()]

    s = Stage('30', arr, 4, 2)
    s.save('30')

Beispiel #8

Datei: stage16.py Projekt: nganhkhoa/ai-ass1-demo

def stage16():
    B1 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    B2 = [Tile(T.bridge, False), Tile(T.bridge, False)]

    arr = [[] for i in range(8)]  # type: List[List[Tile]]

    arr[0] = [None, Tile(T.split, [1, 7, 1, 5])]
    arr[0] += [None for i in range(8)]
    arr[0] += [Tile(), Tile(), Tile()]

    arr[1] = [
        Tile(T.split, [1, 2, 0, 1]),
        Tile(),
        Tile(T.split, [1, 0, 1, 2]), B1[0], B1[1],
        Tile(T.hard_special_button, B1, []),
        Tile(T.hard_special_button, B2, []),
        Tile(), B2[0], B2[1],
        Tile(),
        Tile(T.goal),
        Tile()
    ]

    arr[2] = [None, Tile(T.split, [2, 1, 1, 0])]
    arr[2] += [None for i in range(8)]
    arr[2] += [Tile(), Tile(), Tile()]

    arr[5] = [
        None, None,
        Tile(),
        Tile(),
        Tile(), None, None, None,
        Tile(),
        Tile(),
        Tile()
    ]

    arr[6] = [None, None]
    arr[6] += [Tile() for i in range(7)]
    arr[6] += [Tile(T.split, [0, 1, 1, 0]), Tile()]

    arr[7] = [
        None, None,
        Tile(),
        Tile(),
        Tile(), None, None, None,
        Tile(),
        Tile(),
        Tile()
    ]

    s = Stage('16', arr, 6, 3)
    s.save('16')

Beispiel #9

def stage19():
    SB1 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    SB2 = [Tile(T.bridge, True), Tile(T.bridge, True)]

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [None]
    arr[0] += [Tile() for i in range(9)]
    arr[0] += [Tile(T.soft_button, SB1), Tile(), Tile(), Tile(), Tile()]

    arr[1] = [None for i in range(5)]
    arr[1] += [Tile(), Tile()]
    arr[1] += [None for i in range(6)]
    arr[1] += [Tile(), Tile()]

    arr[2] = [None for i in range(5)]
    arr[2] += [Tile(), Tile()]
    arr[2] += [None for i in range(6)]
    arr[2] += [Tile(), Tile()]

    arr[3] = [None for i in range(13)]
    arr[3] += [Tile(), Tile()]

    arr[4] = [None for i in range(13)]
    arr[4] += [Tile(), Tile()]

    arr[5] = [
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(),
        Tile(), SB1[0], SB1[1],
        Tile(),
        Tile(T.soft_special_button, [], SB2),
        Tile(),
        Tile(),
        Tile(),
        Tile()
    ]

    arr[6] = [Tile(), Tile(T.goal), Tile(), None, None, Tile(), Tile()]

    arr[7] = [Tile(), Tile(), Tile(), None, None, Tile(), Tile()]

    arr[8] = [None, Tile(), Tile(), None, None, Tile(), Tile()]

    arr[9] = [None, Tile(), SB2[0], SB2[1]]
    arr[9] += [Tile() for i in range(6)]
    arr[9] += [Tile(T.soft_special_button, SB2, []), Tile(), Tile(), Tile()]

    s = Stage('19', arr, 0, 1)
    s.save('19')

Beispiel #10

def stage23():
    B1 = [Tile(T.bridge, True), Tile(T.bridge, True)]
    B2 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    SB = Tile(T.bridge, True)
    SB1 = Tile(T.bridge, False)
    SB2 = Tile(T.bridge, False)
    SB3 = Tile(T.bridge, False)

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [None, Tile(), Tile(), Tile()]
    arr[0] += [None for i in range(8)]
    arr[0] += [Tile(), Tile(), Tile()]

    arr[1] = [None, Tile(), Tile(T.hard_special_button, [SB3], []), Tile()]
    arr[1] += [None for i in range(8)]
    arr[1] += [Tile(), Tile(T.soft_hell_button, [SB1], B2, []), Tile()] #!!!!!!!!!!!!open B2, toggle SB1

    arr[2] = [None, Tile(), Tile(), Tile(), 
                None, None, None, Tile(), Tile(), Tile(), 
                B1[0], B1[1], Tile(), Tile(), Tile()]

    arr[3] = [SB2, Tile(), Tile(), Tile(), SB3, 
                None, None, Tile(), Tile(T.goal), Tile(), 
                None, None, Tile(), Tile(), Tile(T.soft_special_button, [], [B1[0], B1[1], SB])]

    arr[4] = [Tile(), None, None, None, 
                Tile(), None, None, Tile(), Tile(), Tile(), 
                None, None, None, None, Tile()]

    arr[5] = [Tile(T.soft_special_button, [SB2], B2), None, None, None, 
                Tile(), None, None, Tile(T.soft_ground), Tile(T.soft_ground), Tile(T.soft_ground), 
                None, None, None, None, Tile()]

    arr[6] = [Tile(), B2[0], B2[1], Tile(), Tile(), Tile()]
    arr[6] += [Tile(T.soft_ground) for i in range(5)]
    arr[6] += [Tile(), Tile(), Tile(), SB]

    arr[7] = [None, None, None, Tile(), Tile(), Tile()]
    arr[7] += [Tile(T.soft_ground) for i in range(5)]
    arr[7] += [Tile(), Tile(T.split, [7,12,2,2]), Tile()]

    arr[8] = [None, None, None, Tile(), Tile(), Tile()]
    arr[8] += [Tile(T.soft_ground) for i in range(5)]
    arr[8] += [Tile(), Tile(), Tile()]

    arr[9] = [None, None, None]
    arr[9] += [Tile() for i in range(5)]
    arr[9] += [SB1]

    s = Stage('23', arr, 7, 4)
    s.save('23')

Beispiel #11

def stage12():
    H1 = [Tile(T.bridge, False)]
    H2 = [Tile(T.bridge, False)]

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [None for i in range(12)]
    arr[0].append(Tile(T.hard_button, H2))

    arr[1] = [None for i in range(5)]
    arr[1] += [Tile(), Tile(), Tile(), None, None, Tile(), Tile(), Tile()]

    arr[2] = [None for i in range(5)]
    arr[2] += [
        Tile(),
        Tile(T.hard_button, H1),
        Tile(),
        Tile(),
        Tile(),
        Tile(),
        Tile(), H1[0]
    ]

    arr[3] = [None, None, None]
    arr[3] += [Tile() for i in range(5)]
    arr[3] += [None, None, Tile(), Tile()]

    arr[4] = [None, None, None, Tile(), Tile(T.goal), Tile(), H2[0]]
    arr[4] += [None for i in range(3)]
    arr[4] += [Tile(), Tile()]

    arr[5] = [None] + [Tile() for i in range(5)]
    arr[5] += [None, None, None]
    arr[5] += [Tile() for i in range(4)]

    arr[6] = [Tile() for i in range(4)]
    arr[6] += [None for i in range(5)]
    arr[6] += [Tile() for i in range(4)]

    arr[7] = [Tile() for i in range(4)]
    arr[7] += [None, None]
    arr[7] += [Tile() for i in range(5)]

    arr[8] = [None for i in range(5)]
    arr[8] += [Tile(), Tile(), Tile()]

    arr[9] = [None for i in range(5)]
    arr[9] += [Tile(), Tile(), Tile()]

    s = Stage('12', arr, 6, 2)
    s.save('12')

Beispiel #12

def stage10():
    HB = [Tile(T.bridge, False), 
            Tile(T.bridge, False), 
            Tile(T.bridge, False), 
            Tile(T.bridge, False)]

    SB = [Tile(T.bridge, False), Tile(T.bridge, False)]

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [Tile(), Tile(), Tile()]
    arr[0] += [None for i in range(5)]
    arr[0] += [Tile() for i in range(6)]

    arr[1] = [Tile(), Tile(T.goal), Tile()]
    arr[1] += [SB[0], SB[1], Tile(), HB[0], HB[1]]
    arr[1] += [Tile(), Tile(), Tile(), Tile(), Tile(T.split, [1,9,1,12]), Tile()]

    arr[2] = [Tile(), Tile(), Tile()]
    arr[2] += [None for i in range(5)]
    arr[2] += [Tile() for i in range(4)]
    arr[2].append(HB[2])

    arr[3] = [None for i in range(9)]
    arr[3] += [Tile(), Tile(), Tile(), HB[3]]

    arr[4] = [None for i in range(11)]
    arr[4] += [Tile(), Tile()]

    arr[5] = [None for i in range(12)]
    arr[5].append(Tile())

    arr[6] = [None for i in range(12)]
    arr[6].append(Tile())

    arr[7] = [None for i in range(11)]
    arr[7] += [Tile(), Tile()]

    arr[8] = [None for i in range(4)]
    arr[8] += [Tile() for i in range(5)]
    arr[8] += [None, None, Tile(), Tile()]

    arr[9] = [None for i in range(4)]
    arr[9] += [Tile(), Tile(T.soft_button, SB), None, None]
    arr[9] += [Tile(), Tile(), Tile(), Tile(T.hard_button, HB), Tile()]

    s = Stage('10', arr, 1, 9)
    s.save('10')

Beispiel #13

def stage5():
    B1 = [Tile(T.bridge, True), Tile(T.bridge, True)]
    B2 = [Tile(T.bridge, True), Tile(T.bridge, True)]
    B3 = [Tile(T.bridge, True), Tile(T.bridge, True)]
    arr = [[] for i in range(10)]

    arr[0] = [None for i in range(11)]
    arr[0] += [Tile() for i in range(4)]

    arr[1] = [None, Tile(), Tile(), Tile(), Tile(), B1[0], B1[1],
              Tile(), Tile(T.soft_button, B1)]
    arr[1] += [Tile() for i in range(6)]

    arr[2] = [None] + [Tile() for i in range(4)]
    arr[2] += [None for i in range(7)]
    arr[2] += [Tile() for i in range(3)]

    arr[3] = [None, Tile(), Tile(),
              Tile(T.soft_special_button, B3, []), Tile()]

    arr[4] = [None] + [Tile() for i in range(4)]

    arr[5] = [None, None, None, Tile(), Tile(), Tile(),
              Tile(T.soft_special_button, [], B3), Tile(), B2[0], B2[1],
              Tile(), Tile(), Tile()]

    arr[6] = [None for i in range(10)]
    arr[6] += [Tile() for i in range(4)]
    arr[6].append(Tile(T.soft_special_button, B3, []))

    arr[7] = [Tile() for i in range(3)]
    arr[7] += [None for i in range(7)]
    arr[7] += [Tile() for i in range(5)]

    arr[8] = [Tile(), Tile(T.goal)] + [Tile() for i in range(3)]
    arr[8] += [B3[0], B3[1]]
    arr[8] += [Tile() for i in range(6)]

    arr[9] = [Tile() for i in range(4)]

    s = Stage('5', arr, 1, 13)
    s.save('5')

Beispiel #14

def stage6():
    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [None for i in range(5)]
    arr[0] += [Tile() for i in range(6)]

    arr[1] = [None for i in range(5)]
    arr[1] += [Tile(), None, None, Tile(), Tile(), Tile()]

    arr[2] = [None for i in range(5)]
    arr[2] += [Tile(), None, None]
    arr[2] += [Tile() for i in range(5)]

    arr[3] = [Tile() for i in range(6)]
    arr[3] += [None for i in range(5)]
    arr[3] += [Tile() for i in range(4)]

    arr[4] = [None for i in range(4)]
    arr[4] += [Tile(), Tile(), Tile()]
    arr[4] += [None for i in range(4)]
    arr[4] += [Tile(), Tile(), Tile(T.goal), Tile()]

    arr[5] = [None for i in range(4)]
    arr[5] += [Tile(), Tile(), Tile()]
    arr[5] += [None for i in range(5)]
    arr[5] += [Tile(), Tile(), Tile()]

    arr[6] = [None for i in range(6)]
    arr[6].append(Tile())
    arr[6] += [None, None, Tile(), Tile()]

    arr[7] = [None for i in range(6)]
    arr[7] += [Tile() for i in range(5)]

    arr[8] = [None for i in range(6)]
    arr[8] += [Tile() for i in range(5)]

    arr[9] = [None for i in range(7)]
    arr[9] += [Tile(), Tile(), Tile()]

    s = Stage('6', arr, 3, 0)
    s.save('6')

Beispiel #15

Datei: stage7.py Projekt: nganhkhoa/ai-ass1-demo

def stage7():
    B = [Tile(T.bridge, False)]

    arr = [[] for i in range(8)]  # type: List[List[Tile]]

    arr[0] = [None for i in range(8)]
    arr[0] += [Tile() for i in range(4)]

    arr[1] = [None for i in range(8)]
    arr[1] += [Tile() for i in range(4)]

    arr[2] = [Tile(), Tile(), Tile()]
    arr[2] += [None for i in range(5)]
    arr[2] += [Tile(), None, None]
    arr[2] += [Tile() for i in range(4)]

    arr[3] = [Tile() for i in range(9)]
    arr[3] += [None, None, None, Tile(), Tile(T.goal), Tile()]

    arr[4] = [Tile(), Tile(), Tile()]
    arr[4] += [None for i in range(4)]
    arr[4] += [
        Tile(),
        Tile(),
        Tile(T.hard_button, B), None, None,
        Tile(),
        Tile(),
        Tile()
    ]

    arr[5] = [Tile(), Tile(), Tile()]
    arr[5] += [None for i in range(4)]
    arr[5] += [Tile(), Tile(), Tile(), None, None, Tile(), Tile(), Tile()]

    arr[6] = [None, Tile(), Tile(), B[0], None, None, None, Tile()]

    arr[7] = [None, None]
    arr[7] += [Tile() for i in range(6)]

    s = Stage('7', arr, 3, 1)
    s.save('7')

Beispiel #16

Datei: stage1.py Projekt: nganhkhoa/ai-ass1-demo

def stage1():
    arr = [[] for i in range(6)]  # type: List[List[Tile]]

    arr[0] = [Tile(), Tile(), Tile()]

    arr[1] = [Tile(), Tile(), Tile(), Tile(), Tile(), Tile()]

    arr[2] = [Tile(), Tile(), Tile(), Tile(),
              Tile(), Tile(), Tile(), Tile(), Tile()]

    arr[3] = [None, Tile(), Tile(), Tile(), Tile(),
              Tile(), Tile(), Tile(), Tile(), Tile()]

    arr[4] = [None, None, None, None, None,
              Tile(), Tile(), Tile(T.goal), Tile(), Tile()]

    arr[5] = [None, None, None, None, None,
              None, Tile(), Tile(), Tile()]

    s = Stage('1', arr, 1, 1)
    s.save('1')

Beispiel #17

def stage9():
    arr = [[] for i in range(5)]  # type: List[List[Tile]]

    arr[0] = [Tile() for i in range(4)]
    arr[0] += [None, None, None, Tile(), None, None, None]
    arr[0] += [Tile() for i in range(4)]

    arr[1] = [Tile(), Tile(), Tile(), Tile()]
    arr[1] += [None, None, None, Tile(), None, None, None]
    arr[1] += [Tile(), Tile(), Tile(T.split, [1,2,1,12]), Tile()]

    arr[2] = [Tile() for i in range(15)]

    arr[3] = [None for i in range(6)]
    arr[3] += [Tile(), Tile(T.goal), Tile()]
    
    arr[4] = [None for i in range(6)]
    arr[4] += [Tile(), Tile(), Tile()]

    s = Stage('9', arr, 1, 1)
    s.save('9')

Beispiel #18

def stage4():
    arr = [[] for i in range(9)]

    arr[0] = [None, None, None] + [Tile(T.soft_ground) for i in range(7)]

    arr[1] = [None, None, None] + [Tile(T.soft_ground) for i in range(7)]

    arr[2] = [Tile() for i in range(4)] + [None for i in range(5)]
    arr[2] += [Tile() for i in range(3)]

    arr[3] = [Tile(), Tile(), Tile()] + [None for i in range(7)]
    arr[3] += [Tile(), Tile()]

    arr[4] = [Tile(), Tile(), Tile()] + [None for i in range(7)]
    arr[4] += [Tile(), Tile()]

    arr[5] = [Tile(), Tile(), Tile(), None, None]
    arr[5] += [Tile() for i in range(4)]
    arr[5] += [Tile(T.soft_ground) for i in range(5)]

    arr[6] = [Tile(), Tile(), Tile(), None, None]
    arr[6] += [Tile() for i in range(4)]
    arr[6] += [Tile(T.soft_ground) for i in range(5)]

    arr[7] = [None for i in range(5)]
    arr[7] += [
        Tile(),
        Tile(T.goal),
        Tile(), None, None,
        Tile(T.soft_ground),
        Tile(T.soft_ground),
        Tile(),
        Tile(T.soft_ground)
    ]

    arr[8] = [None for i in range(5)] + [Tile(), Tile(), Tile(), None, None]
    arr[8] += [Tile(T.soft_ground) for i in range(4)]

    s = Stage('4', arr, 5, 1)
    s.save('4')

Beispiel #19

Datei: stage26.py Projekt: nganhkhoa/ai-ass1-demo

def stage26():
    B1 = [Tile(T.bridge, True), Tile(T.bridge, True)]
    B2 = [Tile(T.bridge, False), Tile(T.bridge, False)]

    arr = [[] for i in range(9)]  # type: List[List[Tile]]

    arr[0] = [None for i in range(5)]
    arr[0] += [Tile() for i in range(4)]
    arr[0] += [None for i in range(4)]
    arr[0] += [Tile(T.split, [3,12,5,10])]

    arr[1] = [None for i in range(5)]
    arr[1] += [Tile(), Tile(), Tile(T.soft_special_button, [], B1), 
                Tile(), Tile(), Tile(), None, None, Tile()]

    arr[2] = [None for i in range(4)]
    arr[2] += [Tile() for i in range(7)]
    arr[2] += [None, None, Tile()]
    
    arr[3] = [Tile(), Tile(), B1[0], B1[1], Tile(), Tile(), Tile(), Tile(), 
                None, None, Tile(), Tile(), Tile(), Tile()]

    arr[4] = [Tile(), Tile(), Tile(), B2[0], None, None, Tile(), None, None, None, Tile(), Tile()]

    arr[5] = [Tile(), Tile(), Tile(), None, None, None, Tile(), None, None, None, Tile()]
    
    arr[6] = [None, Tile()]
    arr[6] += [None for i in range(4)]
    arr[6] += [Tile(), Tile(), Tile()]

    arr[7] = [None, Tile(T.hard_special_button, B2, [])]
    arr[7] += [None for i in range(4)]
    arr[7] += [Tile(), Tile(T.goal), Tile(), B2[1]]

    arr[8] = [None for i in range(6)]
    arr[8] += [Tile(), Tile(), Tile()]

    s = Stage('26', arr, 5, 10)
    s.save('26')

Beispiel #20

Datei: stage3.py Projekt: nganhkhoa/ai-ass1-demo

def stage3():
    arr = [[] for i in range(6)]

    arr[0] = [None for i in range(6)]
    arr[0] += [Tile() for i in range(7)]

    arr[1] = [Tile() for i in range(4)] + [None, None]
    arr[1] += [Tile() for i in range(3)] + [None, None, Tile(), Tile()]

    arr[2] = [Tile() for i in range(9)] + [None, None]
    arr[2] += [Tile() for i in range(4)]

    arr[3] = [Tile() for i in range(4)] + [None for i in range(7)]
    arr[3] += [Tile(), Tile(), Tile(T.goal), Tile()]

    arr[4] = [Tile() for i in range(4)] + [None for i in range(7)]
    arr[4] += [Tile(), Tile(), Tile(), Tile()]

    arr[5] = [None for i in range(12)] + [Tile(), Tile(), Tile()]

    s = Stage('3', arr, 3, 1)
    s.save('3')

Beispiel #21

def stage25():
    B1 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    B2 = [Tile(T.bridge, True), Tile(T.bridge, True)]
    B3 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    SB1 = Tile(T.bridge, False)

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [None, None, Tile(), Tile()]

    arr[1] = [None, None, Tile(), Tile(), Tile()]

    arr[2] = [None, None, Tile(), Tile(), Tile(T.soft_button, [B1[0], B1[1], B3[0], B3[1]])]
    arr[2] += [None for i in range(5)]
    arr[2] += [Tile(), Tile(), Tile(), B3[0]]

    arr[3] = [None, None, None, Tile(), Tile(), Tile(), Tile(), 
                SB1, None, None, Tile(), Tile(T.goal), Tile(), B3[1]]

    arr[4] = [None for i in range(6)]
    arr[4] += [Tile(), Tile(), B1[0], B1[1], Tile(), Tile(), Tile()]

    arr[5] = [None, Tile(), Tile(), None, None, None, Tile(), Tile()]

    arr[6] = [Tile(), Tile(), Tile(T.hard_special_button, B1, []), Tile(), B2[0], B2[1], Tile(), Tile()]

    arr[7] = [Tile(), Tile(), Tile(), None, None, None, Tile(), Tile()]
    arr[7] += [None, None, None, Tile(), Tile(), Tile()]

    arr[8] = [Tile(), Tile(), Tile(), None, None, None, Tile(), Tile(),
                 Tile(T.soft_special_button, [SB1], B2)]
    arr[8] += [Tile() for i in range(5)]

    arr[9] = [None for i in range(11)]
    arr[9] += [Tile(), Tile(), Tile()]

    s = Stage('25', arr, 7, 1)
    s.save('25')

Beispiel #22

Datei: stage11.py Projekt: nganhkhoa/ai-ass1-demo

def stage11():
    B = [Tile(T.bridge, True), Tile(T.bridge, True)]

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [None, Tile(), Tile(), Tile(), B[0]]

    arr[1] = [None, Tile(), Tile(T.goal), Tile(), B[1]]

    arr[2] = [None, Tile(), Tile(), Tile()]

    arr[3] = [None, Tile(), None, None, None]
    arr[3] += [Tile() for i in range(6)]

    arr[4] = [None, Tile(), None, None, None]
    arr[4] += [Tile(), Tile(), None, None, Tile(), Tile()]

    arr[5] = [Tile() for i in range(7)]
    arr[5] += [None, None, Tile(), Tile(), Tile()]

    arr[6] = [None for i in range(5)]
    arr[6] += [Tile(), Tile(T.soft_special_button, [], B)]
    arr[6] += [None for i in range(4)]
    arr[6] += [Tile()]

    arr[7] = [None for i in range(5)]
    arr[7] += [Tile() for i in range(4)]
    arr[7] += [None, None, Tile()]

    arr[8] = [None for i in range(5)]
    arr[8] += [Tile() for i in range(7)]

    arr[9] = [None for i in range(8)]
    arr[9] += [Tile(), Tile(), Tile()]

    s = Stage('11', arr, 5, 0)
    s.save('11')

Beispiel #23

Datei: stage17.py Projekt: nganhkhoa/ai-ass1-demo

def stage17():
    SB = [Tile(T.bridge, False)]
    HB1 = [Tile(T.bridge, False)]
    HB2 = [Tile(T.bridge, False)]
    HB3 = [Tile(T.bridge, False)]

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [Tile(), Tile(), Tile()]

    arr[1] = [Tile() for i in range(9)]
    arr[1] += [HB2[0], None, None, Tile(), Tile(), Tile()]

    arr[2] = [Tile(), Tile(), Tile()]
    arr[2] += [
        None, None, None, None, HB1[0],
        Tile(),
        Tile(),
        Tile(),
        Tile(),
        Tile(),
        Tile(T.goal),
        Tile()
    ]

    arr[3] = [Tile(), Tile(), Tile()]
    arr[3] += [None for i in range(9)]
    arr[3] += [
        Tile(T.hard_special_button, [], HB3),
        Tile(T.hard_special_button, HB3, []),
        Tile()
    ]

    arr[4] = [Tile(), Tile(), Tile()]

    arr[5] = [Tile(), Tile(), Tile()]

    arr[6] = [
        Tile(),
        Tile(),
        Tile(), None, None, None, HB3[0],
        Tile(),
        Tile(),
        Tile(),
        Tile(),
        Tile(),
        Tile(T.hard_special_button, HB1, [])
    ]

    arr[7] = [Tile() for i in range(8)]
    arr[7] += [SB[0], None, None, Tile(), Tile()]

    arr[8] = [Tile(), Tile(T.soft_special_button, SB, []), Tile()]
    arr[8] += [None for i in range(8)]
    arr[8] += [Tile(), Tile()]

    arr[9] = [Tile(), Tile(), Tile()]
    arr[9] += [None for i in range(8)]
    arr[9] += [Tile(), Tile(T.hard_special_button, HB2, SB)]

    s = Stage('17', arr, 1, 1)
    s.save('17')

Beispiel #24

def stage33():
    B1 = [Tile(T.bridge, False)]
    B2 = [Tile(T.bridge, True), Tile(T.bridge, True)]

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [None for i in range(5)]
    arr[0] += [
        Tile(),
        Tile(),
        Tile(T.soft_special_button, [], B2),
        Tile(),
        Tile(),
        Tile()
    ]

    arr[1] = [None for i in range(5)]
    arr[1] += [Tile() for i in range(6)]
    arr[1] += [B1[0]]

    arr[2] = [
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(T.soft_special_button, [], B2),
        Tile(),
        Tile(),
        Tile(T.soft_special_button, [], B2)
    ]
    arr[2] += [Tile() for i in range(5)]

    arr[3] = [
        Tile(),
        Tile(),
        Tile(),
        Tile(),
        Tile(),
        Tile(),
        Tile(),
        Tile(),
        Tile(),
        Tile(T.soft_special_button, [], B2),
        Tile(T.soft_special_button, [], B2),
        Tile(),
        Tile(),
        Tile(T.soft_special_button, [], B2)
    ]

    arr[4] = [None for i in range(5)]
    arr[4] += [
        Tile(),
        Tile(),
        Tile(T.soft_special_button, [], B2),
        Tile(),
        Tile(),
        Tile(T.soft_special_button, [], B2),
        Tile(),
        Tile(),
        Tile()
    ]

    arr[5] = [None for i in range(5)]
    arr[5] += [Tile() for i in range(6)]
    arr[5] += [Tile(T.soft_special_button, [], B2), Tile(), Tile()]

    arr[6] = [Tile(), Tile(), Tile(), None, None]
    arr[6] += [Tile() for i in range(6)]
    arr[6] += [Tile(T.soft_special_button, [], B2), Tile(), Tile(), Tile()]

    arr[7] = [
        Tile(),
        Tile(T.goal),
        Tile(), B2[0], B2[1],
        Tile(),
        Tile(T.soft_special_button, [], B2),
        Tile(), None, None,
        Tile(),
        Tile(),
        Tile(),
        Tile(T.soft_special_button, [], B2),
        Tile(T.hard_special_button, B1, [])
    ]

    arr[8] = [
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(),
        Tile(),
        Tile(), None, None, None,
        Tile(),
        Tile(),
        Tile(),
        Tile()
    ]

    arr[9] = [Tile(), Tile(), Tile()]
    arr[9] += [None for i in range(9)]
    arr[9] += [Tile(), Tile(), Tile()]

    s = Stage('33', arr, 3, 1)
    s.save('33')

Beispiel #25

Datei: stage13.py Projekt: nganhkhoa/ai-ass1-demo

def stage13():
    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [Tile(), Tile(), Tile(), Tile(T.soft_ground)]
    arr[0] += [Tile() for i in range(4)]
    arr[0] += [Tile(T.soft_ground)]
    arr[0] += [Tile() for i in range(4)]

    arr[1] = [Tile(), Tile()]
    arr[1] += [None for i in range(8)]
    arr[1] += [Tile(), Tile(), Tile()]

    arr[2] = [Tile(), Tile()]
    arr[2] += [None for i in range(9)]
    arr[2] += [Tile(), Tile(), Tile()]

    arr[3] = [Tile(), Tile(), Tile()]
    arr[3] += [None, None, None]
    arr[3] += [Tile(), Tile(), Tile(), None, None]
    arr[3] += [Tile(), Tile(), Tile()]

    arr[4] = [
        Tile(),
        Tile(),
        Tile(),
        Tile(T.soft_ground),
        Tile(T.soft_ground),
        Tile(T.soft_ground),
        Tile(),
        Tile(T.goal),
        Tile(), None, None,
        Tile(),
        Tile(),
        Tile()
    ]

    arr[5] = [
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(T.soft_ground),
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile()
    ]

    arr[6] = [None, None, Tile(), None, None]
    arr[6] += [Tile(T.soft_ground) for i in range(5)]
    arr[6] += [Tile(), Tile()]

    arr[7] = [
        None, None,
        Tile(),
        Tile(),
        Tile(),
        Tile(T.soft_ground),
        Tile(T.soft_ground),
        Tile(),
        Tile(T.soft_ground),
        Tile(T.soft_ground),
        Tile(T.soft_ground)
    ]

    arr[8] = [None, None, None, Tile(), Tile()]
    arr[8] += [Tile(T.soft_ground) for i in range(6)]

    arr[9] = [
        None, None, None,
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(),
        Tile()
    ]

    s = Stage('13', arr, 3, 12)
    s.save('13')

Beispiel #26

Datei: stage31.py Projekt: nganhkhoa/ai-ass1-demo

def stage31():
    B1 = [Tile(T.bridge, True), Tile(T.bridge, True)]
    B2 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    B3 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    B4 = [Tile(T.bridge, True), Tile(T.bridge, True)]
    B5 = [Tile(T.bridge, False), Tile(T.bridge, False), Tile(T.bridge, False)]

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [None for i in range(11)]
    arr[0] += [Tile(), Tile(), Tile(), B5[0]]

    arr[1] = [
        None,
        Tile(),
        Tile(),
        Tile(), None, None, None, None,
        Tile(T.hard_button, B2), None, None,
        Tile(),
        Tile(T.goal),
        Tile(), B5[1]
    ]

    arr[2] = [
        None,
        Tile(),
        Tile(),
        Tile(), B1[0], B1[1],
        Tile(),
        Tile(),
        Tile(), B2[0], B2[1],
        Tile(),
        Tile(),
        Tile(), B5[2]
    ]

    arr[3] = [
        None,
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(),
        Tile(),
        Tile(), None, None, None,
        Tile()
    ]

    arr[4] = [
        None,
        Tile(T.soft_ground),
        Tile(T.soft_ground),
        Tile(T.soft_ground), None, None,
        Tile(T.soft_special_button, [],
             [B1[0], B1[1], B2[0], B2[1], B3[0], B3[1], B4[0], B4[1]]),
        Tile(),
        Tile(), None, None, None,
        Tile(T.soft_ground)
    ]

    arr[5] = [
        None, None,
        Tile(T.soft_ground), None, None, None,
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(T.soft_ground),
        Tile(T.soft_ground),
        Tile(T.soft_ground)
    ]

    arr[6] = [
        None, None,
        Tile(), None, None, None,
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(),
        Tile(),
        Tile()
    ]

    arr[7] = [
        Tile(),
        Tile(),
        Tile(),
        Tile(), B3[0], B3[1],
        Tile(),
        Tile(T.soft_special_button, [],
             [B1[0], B1[1], B2[0], B2[1], B3[0], B3[1], B4[0], B4[1]]),
        Tile(), B4[0], B4[1],
        Tile(),
        Tile(),
        Tile()
    ]

    arr[8] = [
        Tile(),
        Tile(),
        Tile(T.hard_special_button, B5, B1),
        Tile(), None, None,
        Tile(T.hard_button, B3), None, None, None, None,
        Tile(),
        Tile(),
        Tile()
    ]

    arr[9] = [Tile(), Tile(), Tile(), Tile()]

    s = Stage('31', arr, 7, 12)
    s.save('31')

Beispiel #27

Datei: stage21.py Projekt: nganhkhoa/ai-ass1-demo

def stage21():
    HB = Tile(T.bridge, False)
    HB1 = Tile(T.bridge, False)

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [None for i in range(8)]
    arr[0] += [Tile(), Tile()]

    arr[1] = [None for i in range(7)]
    arr[1] += [Tile(), Tile(), Tile()]

    arr[2] = [Tile(), Tile(), None, None]
    arr[2] += [Tile() for i in range(6)]

    arr[3] = [Tile() for i in range(6)]
    arr[3] += [None, None, Tile()]

    arr[4] = [
        Tile(),
        Tile(),
        Tile(),
        Tile(), None, None, None, None,
        Tile(), None, None, None,
        Tile(),
        Tile(),
        Tile()
    ]

    arr[5] = [None, Tile(), Tile()]
    arr[5] += [None for i in range(5)]
    arr[5] += [
        Tile(T.hard_button, [HB]),
        Tile(),
        Tile(),
        Tile(),
        Tile(),
        Tile(T.goal),
        Tile()
    ]

    arr[6] = [None, None, Tile()]
    arr[6] += [None for i in range(5)]
    arr[6] += [
        Tile(T.hard_button, [HB1]),
        Tile(), None, None,
        Tile(),
        Tile(),
        Tile()
    ]

    arr[7] = [
        None, None,
        Tile(),
        Tile(),
        Tile(), HB1, None, None,
        Tile(),
        Tile()
    ]

    arr[8] = [
        None, None, None,
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(),
        Tile()
    ]

    arr[9] = [None, None, None, HB]
    arr[9] += [Tile() for i in range(6)]

    s = Stage('21', arr, 3, 1)
    s.save('21')

Beispiel #28

Datei: stage15.py Projekt: nganhkhoa/ai-ass1-demo

def stage15():
    B0 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    B1 = [Tile(T.bridge, True), Tile(T.bridge, True)]
    B2 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    B3 = [Tile(T.bridge, True), Tile(T.bridge, True)]

    arr = [[] for i in range(10)]  # type: List[List[Tile]]

    arr[0] = [None for i in range(7)]
    arr[0] += [Tile(), Tile(), Tile(), None, None, Tile(), Tile(), Tile()]

    arr[1] = [
        None, None, None, None,
        Tile(), B1[0], B1[1],
        Tile(),
        Tile(),
        Tile(), B2[0], B2[1],
        Tile(T.hard_button, [B0[0], B0[1], B1[0], B1[1]]),
        Tile(),
        Tile()
    ]

    arr[2] = [
        Tile(),
        Tile(), B0[0], B0[1],
        Tile(), None, None,
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(),
        Tile(),
        Tile()
    ]

    arr[3] = [Tile() for i in range(5)]
    arr[3] += [
        None, None, None,
        Tile(T.soft_button, [B1[0], B1[1], B2[0], B2[1]])
    ]

    arr[4] = [Tile(), Tile()]

    arr[5] = [None, Tile()]
    arr[5] += [None for i in range(5)]
    arr[5].append(Tile(T.split, [1, 14, 8, 1]))

    arr[6] = [None, Tile()]
    arr[6] += [None for i in range(5)]
    arr[6].append(Tile())

    arr[7] = [
        Tile(),
        Tile(),
        Tile(), None, None, None,
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(T.soft_special_button, [], B3),
        Tile(),
        Tile()
    ]

    arr[8] = [Tile() for i in range(9)]
    arr[8] += [B3[0], B3[1], Tile(), Tile(T.goal), Tile()]

    arr[9] = [
        Tile(),
        Tile(),
        Tile(), None, None, None,
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(T.soft_special_button, [], B3),
        Tile(),
        Tile()
    ]

    s = Stage('15', arr, 8, 1)
    s.save('15')

Beispiel #29

Datei: stage24.py Projekt: nganhkhoa/ai-ass1-demo

def stage24():
    B1 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    B2 = [Tile(T.bridge, False), Tile(T.bridge, False)]
    SB1 = Tile(T.bridge, False)
    SB2 = Tile(T.bridge, False)

    arr = [[] for i in range(8)]  # type: List[List[Tile]]

    arr[0] = [None for i in range(10)]
    arr[0] += [Tile(), Tile(), Tile(), Tile()]

    arr[1] = [None, None, None, SB1]
    arr[1] += [Tile() for i in range(7)]
    arr[1] += [
        Tile(T.hard_special_button, B1, []),
        Tile(),
        Tile(T.split, [6, 5, 6, 7])
    ]

    arr[2] = [
        None,
        Tile(), B1[0], B1[1],
        Tile(),
        Tile(T.hard_special_button, [SB2], []),
        Tile(), None, None, None,
        Tile(),
        Tile(),
        Tile(),
        Tile()
    ]

    arr[3] = [
        Tile(T.hard_special_button, [SB1], []),
        Tile(), None, None,
        Tile(),
        Tile()
    ]
    arr[3] += [None for i in range(6)]
    arr[3] += [Tile()]

    arr[4] = [Tile(), Tile(), None, None, Tile()]
    arr[4] += [None for i in range(7)]
    arr[4] += [Tile()]

    arr[5] = [Tile() for i in range(5)]
    arr[5] += [None for i in range(5)]
    arr[5] += [Tile(), Tile(), Tile()]

    arr[6] = [
        Tile(),
        Tile(),
        Tile(), None, None,
        Tile(),
        Tile(),
        Tile(), B2[0], B2[1],
        Tile(),
        Tile(T.goal),
        Tile()
    ]

    arr[7] = [None for i in range(5)]
    arr[7] += [
        Tile(T.hard_special_button, B2, []),
        Tile(), SB2, None, None,
        Tile(),
        Tile(),
        Tile()
    ]

    s = Stage('24', arr, 2, 1)
    s.save('24')

Beispiel #30

def stage_():
    arr = [[] for i in range(0)]  # type: List[List[Tile]]

    s = Stage('_', arr, 1, 1)
    s.save('_')