Esempio n. 1
0
def check_only_move(initial_data, expected, direction):

    arr = e2048._build_from_2048(np.array(initial_data))
    board1 = e2048.Board.fromarray(arr)
    board2 = e2048.Board.fromarray(e2048._build_from_2048(np.array(initial_data)))

    moved = e2048._only_move(arr, direction)

    assert board1 == board2, "A new array is built"

    expected_board = e2048.Board.fromarray(expected)
    resulting_board = e2048.Board.fromarray(moved)

    assert expected_board == resulting_board
Esempio n. 2
0
def test_only_move():

    initial_data = [
        [ 0, 0, 0, 0 ],
        [ 2, 2, 4, 8 ],
        [ 0, 0, 2, 2 ],
        [ 2, 2, 2, 2 ]
    ]

    expected_down = e2048._build_from_2048(np.array([
        [ 0, 0, 0, 0 ],
        [ 0, 0, 0, 0 ],
        [ 0, 0, 4, 8 ],
        [ 4, 4, 4, 4 ]
    ]))

    yield check_only_move, initial_data, expected_down, Directions.down

    expected_up = e2048._build_from_2048(np.array([
        [ 4, 4, 4, 8 ],
        [ 0, 0, 4, 4 ],
        [ 0, 0, 0, 0 ],
        [ 0, 0, 0, 0 ]
    ]))

    yield check_only_move, initial_data, expected_up, Directions.up

    expected_right = e2048._build_from_2048(np.array([
        [ 0, 0, 0, 0 ],
        [ 0, 4, 4, 8 ],
        [ 0, 0, 0, 4 ],
        [ 0, 0, 4, 4 ]
    ]))

    yield check_only_move, initial_data, expected_right, Directions.right

    expected_left = e2048._build_from_2048(np.array([
        [ 0, 0, 0, 0 ],
        [ 4, 4, 8, 0 ],
        [ 4, 0, 0, 0 ],
        [ 4, 4, 0, 0 ]
    ]))

    yield check_only_move, initial_data, expected_left, Directions.left
Esempio n. 3
0
def test_potential_states():
    
    # This can be moved up, down, left and right.
    # In each case, there will be one 0 (and therefore, 
    # 2 potential new states)
    initial_data = e2048._build_from_2048(np.array([
        [  2,  4,  8, 16 ],
        [ 16,  8,  4,  2 ],
        [ 32, 64,  8,  2 ],
        [ 64, 32,  2,  2 ]
    ]))

    expected_up_2 = e2048._build_from_2048(np.array([
        [  2,  4,  8, 16 ],
        [ 16,  8,  4,  4 ],
        [ 32, 64,  8,  2 ],
        [ 64, 32,  2,  2 ]
    ]))

    expected_up_4 = e2048._build_from_2048(np.array([
        [  2,  4,  8, 16 ],
        [ 16,  8,  4,  4 ],
        [ 32, 64,  8,  2 ],
        [ 64, 32,  2,  4 ]
    ]))

    expected_down_2 = e2048._build_from_2048(np.array([
        [  2,  4,  8,  2 ],
        [ 16,  8,  4, 16 ],
        [ 32, 64,  8,  2 ],
        [ 64, 32,  2,  4 ]
    ]))

    expected_down_4 = e2048._build_from_2048(np.array([
        [  2,  4,  8,  4 ],
        [ 16,  8,  4, 16 ],
        [ 32, 64,  8,  2 ],
        [ 64, 32,  2,  4 ]
    ]))

    expected_right_2 = e2048._build_from_2048(np.array([
        [  2,  4,  8, 16 ],
        [ 16,  8,  4,  2 ],
        [ 32, 64,  8,  2 ],
        [  2, 64, 32,  4 ]
    ]))

    expected_right_4 = e2048._build_from_2048(np.array([
        [  2,  4,  8, 16 ],
        [ 16,  8,  4,  2 ],
        [ 32, 64,  8,  2 ],
        [  4, 64, 32,  4 ]
    ]))

    expected_left_2 = e2048._build_from_2048(np.array([
        [  2,  4,  8, 16 ],
        [ 16,  8,  4,  2 ],
        [ 32, 64,  8,  2 ],
        [ 64, 32,  4,  2 ]
    ]))

    expected_left_4 = e2048._build_from_2048(np.array([
        [  2,  4,  8, 16 ],
        [ 16,  8,  4,  2 ],
        [ 32, 64,  8,  2 ],
        [ 64, 32,  4,  4 ]
    ]))

    expected_potential_states = {
        Directions.left : {
            e2048.build_value(expected_left_2) : 0.9,
            e2048.build_value(expected_left_4) : 0.1,
        },
        Directions.right : {
            e2048.build_value(expected_right_2) : 0.9,
            e2048.build_value(expected_right_4) : 0.1,
        },
        Directions.up : {
            e2048.build_value(expected_up_2) : 0.9,
            e2048.build_value(expected_up_4) : 0.1,
        },
        Directions.down : {
            e2048.build_value(expected_down_2) : 0.9,
            e2048.build_value(expected_down_4) : 0.1,
        },
    }

    resulting_potential_states = e2048.potential_states(initial_data)
    
    assert pprint.pformat(resulting_potential_states) == pprint.pformat(expected_potential_states)

    # This can be moved up, down, left and right.
    # In each case, there will be one 0 (and therefore, 
    # 2 potential new states)
    initial_data = e2048._build_from_2048(np.array([
        [  2,  4,  8, 16 ],
        [ 16,  8,  4,  2 ],
        [ 32, 64,  8, 16 ],
        [ 64, 32,  2,  2 ]
    ]))

    expected_left_2 = e2048._build_from_2048(np.array([
        [  2,  4,  8, 16 ],
        [ 16,  8,  4,  2 ],
        [ 32, 64,  8, 16 ],
        [ 64, 32,  4,  2 ]
    ]))

    expected_left_4 = e2048._build_from_2048(np.array([
        [  2,  4,  8, 16 ],
        [ 16,  8,  4,  2 ],
        [ 32, 64,  8, 16 ],
        [ 64, 32,  4,  4 ]
    ]))

    expected_right_2 = e2048._build_from_2048(np.array([
        [  2,  4,  8, 16 ],
        [ 16,  8,  4,  2 ],
        [ 32, 64,  8, 16 ],
        [  2, 64, 32,  4 ]
    ]))

    expected_right_4 = e2048._build_from_2048(np.array([
        [  2,  4,  8, 16 ],
        [ 16,  8,  4,  2 ],
        [ 32, 64,  8, 16 ],
        [  4, 64, 32 , 4 ]
    ]))

    expected_potential_states = {
        Directions.left : {
            e2048.build_value(expected_left_2) : 0.9,
            e2048.build_value(expected_left_4) : 0.1,
        },
        Directions.right : {
            e2048.build_value(expected_right_2) : 0.9,
            e2048.build_value(expected_right_4) : 0.1,
        },
    }

    resulting_potential_states = e2048.potential_states(initial_data)
    
    assert str(pprint.pformat(resulting_potential_states)) == str(pprint.pformat(expected_potential_states))