Beispiel #1
0
def play ():
    
    grid = []
    util.create_grid (grid)
    add_block (grid)
    add_block (grid)
    won_message = False
    while (True):
        util.print_grid (grid)
        key = input ("Enter a direction:\n")
        if (key in ['x', 'u', 'd', 'l', 'r']):
            saved_grid = util.copy_grid (grid)
            if (key == 'x'):
                return
            elif (key == 'u'):
                push.push_up (grid)
            elif (key == 'd'):
                push.push_down (grid)
            elif (key == 'r'):
                push.push_right (grid)
            elif (key == 'l'):
                push.push_left (grid)
            if util.check_lost (grid):
                print ("Game Over!")
                return
            elif util.check_won (grid) and not won_message:
                print ("Won!")
                won_message = True  
            if not util.grid_equal (saved_grid, grid):
                add_block (grid)
Beispiel #2
0
def play ():
    """generate grid and play game interactively"""
    # create grid
    grid = []
    util.create_grid (grid)
    # add 2 starting random numbers
    add_block (grid)
    add_block (grid)
    won_message = False
    while (True):
        util.print_grid (grid)
        key = input ("Enter a direction:\n")
        if (key in ['x', 'u', 'd', 'l', 'r']):
            # make a copy of the grid
            saved_grid = util.copy_grid (grid)
            if (key == 'x'):
                # quit the game
                return
            # manipulate the grid depending on input
            elif (key == 'u'):
                push.push_up (grid)
            elif (key == 'd'):
                push.push_down (grid)
            elif (key == 'r'):
                push.push_right (grid)
            elif (key == 'l'):
                #print(grid)
                push.push_left (grid)
                #print(grid)
            # check for a grid with no more gaps or legal moves
            if util.check_lost (grid):
                print ("Game Over!")
                return
            # check for a grid with the final number
            elif util.check_won (grid) and not won_message:
                print ("Won!")
                won_message = True
            # finally add a random block if the grid has changed    
            if not util.grid_equal (saved_grid, grid):
                add_block (grid)
Beispiel #3
0
def play():
    """generate grid and play game interactively"""
    # create grid
    grid = []
    util.create_grid(grid)
    # add 2 starting random numbers
    add_block(grid)
    add_block(grid)
    won_message = False
    while (True):
        util.print_grid(grid)
        key = input("Enter a direction:\n")
        if (key in ['x', 'u', 'd', 'l', 'r']):
            # make a copy of the grid
            saved_grid = util.copy_grid(grid)
            if (key == 'x'):
                # quit the game
                return
            # manipulate the grid depending on input
            elif (key == 'u'):
                push.push_up(grid)
            elif (key == 'd'):
                push.push_down(grid)
            elif (key == 'r'):
                push.push_right(grid)
            elif (key == 'l'):
                push.push_left(grid)
            # check for a grid with no more gaps or legal moves
            if util.check_lost(grid):
                print("Game Over!")
                return
            # check for a grid with the final number
            elif util.check_won(grid) and not won_message:
                print("Won!")
                won_message = True
            # finally add a random block if the grid has changed
            if not util.grid_equal(saved_grid, grid):
                add_block(grid)
Beispiel #4
0
def play ():
    # makes the game and plays
    # makes grid
    grid = []
    util.create_grid (grid)
    # adds 2 random numbers to start with
    add_block (grid)
    add_block (grid)
    won_message = False
    while (True):
        util.print_grid (grid)
        key = input ("Enter a direction:\n")
        if (key in ['x', 'u', 'd', 'l', 'r']):
            # copies the grid
            saved_grid = util.copy_grid (grid)
            if (key == 'x'):
                # end the game
                return
            # edit the grid depending on the input
            elif (key == 'u'):
                push.push_up (grid)
            elif (key == 'd'):
                push.push_down (grid)
            elif (key == 'r'):
                push.push_right (grid)
            elif (key == 'l'):
                push.push_left (grid)
            # check for a grid with no more gaps or legal moves
            if util.check_lost (grid):
                print ("Game Over!")
                return
            # check for a grid with the last number
            elif util.check_won (grid) and not won_message:
                print ("Won!")
                won_message = True
            # lastly add a random block if the grid has changed    
            if not util.grid_equal (saved_grid, grid):
                add_block (grid)
Beispiel #5
0
def run_test (test):
   if test == 0:
      grid = []    
      util.create_grid (grid)
      print(grid)
      print (len (grid))
      print (len (grid[0]))
      print (len (grid[1]))
      print (len (grid[2]))
      print (len (grid[3]))
      print (grid[0][0])
      print (grid[1][2])
      print (grid[2][1])
      print (grid[3][3])
   elif test == 1:
      grid = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      util.print_grid (grid)
   elif test == 2:
      grid = [[2,0,2,0],[0,4,0,8],[0,16,0,128],[2,2,2,2]]
      util.print_grid (grid)
   elif test == 3:
      grid = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      print (util.check_lost (grid))
   elif test == 4:
      grid = [[2,0,2,0],[0,4,0,8],[0,16,0,128],[2,2,2,2]]
      print (util.check_lost (grid))
   elif test == 5:
      grid = [[2,2,2,2],[2,2,2,2],[2,2,2,2],[2,2,2,2]]
      print (util.check_lost (grid))
   elif test == 6:
      grid = [[4,16,2,4],[2,4,16,2],[2,4,8,4],[4,8,4,2]]
      print (util.check_lost (grid))
   elif test == 7:
      grid = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      print (util.check_lost (grid))
   elif test == 8:
      grid = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      print (util.check_won (grid))
   elif test == 9:
      grid = [[2,0,2,0],[0,4,0,8],[0,16,0,128],[2,2,2,2]]
      print (util.check_won (grid))
   elif test == 10:
      grid = [[2,2,2,2],[2,2,2,2],[2,2,2,2],[2,2,2,2]]
      print (util.check_won (grid))
   elif test == 11:
      grid = [[4,16,2,4],[2,4,16,2],[2,4,8,4],[4,8,4,2]]
      print (util.check_won (grid))
   elif test == 12:
      grid = [[2,32,2,4],[4,2,16,2],[8,0,8,4],[2,0,4,2]]
      print (util.check_won (grid))
   elif test == 13:
      grid = [[2,2,8,0],[0,8,16,0],[16,32,8,8],[2,8,4,4]]
      print (util.check_won (grid))
   elif test == 14:
      grid = [[64,32,32,2],[8,4,2,0],[4,2,0,0],[2,0,0,0]]
      print (util.check_won (grid))
   elif test == 15:
       grid = [[64,32,32,2],[8,4,2,0],[4,2,0,0],[2,0,0,0]]
       print (util.check_won (grid))
   elif test == 16:
      grid = [[128,4,0,0],[8,4,2,0],[4,2,0,2],[2,0,0,0]]
      print (util.check_won (grid))
   elif test == 17:
      grid = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      test_grid = util.copy_grid (grid)
      print (grid[0][0],test_grid[0][0])
      print (grid[1][2],test_grid[1][2])
      print (grid[3][3],test_grid[3][3])
      grid[0][0] = 64
      grid[1][2] = 64
      grid[3][3] = 64
      print (grid[0][0],test_grid[0][0])
      print (grid[1][2],test_grid[1][2])
      print (grid[3][3],test_grid[3][3])
   elif test == 18:
      grid1 = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      grid2 = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      print (util.grid_equal (grid1, grid2))
   elif test == 19:
      grid1 = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      grid2 = [[4,2,8,2],[2,8,16,4],[16,32,8,4],[4,8,4,2]]
      print (util.grid_equal (grid1, grid2))
   elif test == 20:
      grid1 = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      grid2 = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      print (util.grid_equal (grid1, grid2))
   elif test == 21:
      grid1 = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      grid2 = [[2,4,8,16],[32,64,128,256],[512,1024,2048,4096],[8192,16384,32768,65536]]
      print (util.grid_equal (grid1, grid2))
   elif test == 22:
      grid1 = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      grid2 = [[2,2,2,2],[2,2,2,2],[2,2,2,2],[2,2,2,2]]
      print (util.grid_equal (grid1, grid2))
Beispiel #6
0
def play():
    """generate grid and play game interactively"""
    # create grid
    grid = []
    util.create_grid(grid)
    # add 2 starting random numbers
    add_block(grid)
    add_block(grid)
    # initially set 'won_message' to False. 'won_message' is used to determine if the user has been alerted that they won as to not keep printing the winning  message if they continue playing.
    won_message = False
    # start
    while (True):
        # Clear the terminal so that the game seems more interactive
        os.system('cls' if os.name == 'nt' else 'clear')
        # print the current state of the grid
        util.print_grid(grid)
        # set 'key' to a user input which represents the move they would like to do
        key = input("Enter a direction:\n")
        # check if 'key' is one of the available options
        if (key in ['x', 'u', 'd', 'l', 'r']):
            # make a copy of the grid
            saved_grid = util.copy_grid(grid)
            if (key == 'x'):
                # quit the game
                return
            # manipulate the grid depending on input
            elif (key == 'u'):
                push.push_up(grid)
            elif (key == 'd'):
                push.push_down(grid)
            elif (key == 'r'):
                push.push_right(grid)
            elif (key == 'l'):
                push.push_left(grid)
            # check for a grid with no more gaps or legal moves
            if util.check_lost(grid):
                print("Game Over!")
                return
            # check for a grid with the final number
            elif not won_message and util.check_won(grid):
                print("Won!")
                won_message = True
                # Clear the terminal so that the game seems more interactive
                os.system('cls' if os.name == 'nt' else 'clear')
                # print the current state of the grid
                util.print_grid(grid)
                if input('Would you like to keep playing? (Y)es or (N)o: '
                         ).lower() == 'n':
                    print('Game Over!')
                    return
            # finally add a random block if the grid has changed
            if not util.grid_equal(saved_grid, grid):
                add_block(grid)
            # check for a grid with no more gaps or legal moves
            if util.check_lost(grid):
                # Clear the terminal so that the game seems more interactive
                os.system('cls' if os.name == 'nt' else 'clear')
                # print last state of grid
                util.print_grid(grid)
                print("Game Over!")
                return
Beispiel #7
0
def run_test (test):
   if test == 0:
      grid = []    
      util.create_grid (grid)
      print (len (grid))
      print (len (grid[0]))
      print (len (grid[1]))
      print (len (grid[2]))
      print (len (grid[3]))
      print (grid[0][0])
      print (grid[1][2])
      print (grid[2][1])
      print (grid[3][3])
   elif test == 1:
      grid = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      util.print_grid (grid)
   elif test == 2:
      grid = [[2,0,2,0],[0,4,0,8],[0,16,0,128],[2,2,2,2]]
      util.print_grid (grid)
   elif test == 3:
      grid = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      print (util.check_lost (grid))
   elif test == 4:
      grid = [[2,0,2,0],[0,4,0,8],[0,16,0,128],[2,2,2,2]]
      print (util.check_lost (grid))
   elif test == 5:
      grid = [[2,2,2,2],[2,2,2,2],[2,2,2,2],[2,2,2,2]]
      print (util.check_lost (grid))
   elif test == 6:
      grid = [[4,16,2,4],[2,4,16,2],[2,4,8,4],[4,8,4,2]]
      print (util.check_lost (grid))
   elif test == 7:
      grid = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      print (util.check_lost (grid))
   elif test == 8:
      grid = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      print (util.check_won (grid))
   elif test == 9:
      grid = [[2,0,2,0],[0,4,0,8],[0,16,0,128],[2,2,2,2]]
      print (util.check_won (grid))
   elif test == 10:
      grid = [[2,2,2,2],[2,2,2,2],[2,2,2,2],[2,2,2,2]]
      print (util.check_won (grid))
   elif test == 11:
      grid = [[4,16,2,4],[2,4,16,2],[2,4,8,4],[4,8,4,2]]
      print (util.check_won (grid))
   elif test == 12:
      grid = [[2,32,2,4],[4,2,16,2],[8,0,8,4],[2,0,4,2]]
      print (util.check_won (grid))
   elif test == 13:
      grid = [[2,2,8,0],[0,8,16,0],[16,32,8,8],[2,8,4,4]]
      print (util.check_won (grid))
   elif test == 14:
      grid = [[64,32,32,2],[8,4,2,0],[4,2,0,0],[2,0,0,0]]
      print (util.check_won (grid))
   elif test == 15:
       grid = [[64,32,32,2],[8,4,2,0],[4,2,0,0],[2,0,0,0]]
       print (util.check_won (grid))
   elif test == 16:
      grid = [[128,4,0,0],[8,4,2,0],[4,2,0,2],[2,0,0,0]]
      print (util.check_won (grid))
   elif test == 17:
      grid = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      test_grid = util.copy_grid (grid)
      print (grid[0][0],test_grid[0][0])
      print (grid[1][2],test_grid[1][2])
      print (grid[3][3],test_grid[3][3])
      grid[0][0] = 64
      grid[1][2] = 64
      grid[3][3] = 64
      print (grid[0][0],test_grid[0][0])
      print (grid[1][2],test_grid[1][2])
      print (grid[3][3],test_grid[3][3])
   elif test == 18:
      grid1 = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      grid2 = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      print (util.grid_equal (grid1, grid2))
   elif test == 19:
      grid1 = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      grid2 = [[4,2,8,2],[2,8,16,4],[16,32,8,4],[4,8,4,2]]
      print (util.grid_equal (grid1, grid2))
   elif test == 20:
      grid1 = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      grid2 = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      print (util.grid_equal (grid1, grid2))
   elif test == 21:
      grid1 = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      grid2 = [[2,4,8,16],[32,64,128,256],[512,1024,2048,4096],[8192,16384,32768,65536]]
      print (util.grid_equal (grid1, grid2))
   elif test == 22:
      grid1 = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      grid2 = [[2,2,2,2],[2,2,2,2],[2,2,2,2],[2,2,2,2]]
      print (util.grid_equal (grid1, grid2))
Beispiel #8
0
def play(agent='human', record=True, filename='human_games.dat', delay=1):
    """generate grid and play game interactively"""
    # create grid
    grid = []
    util.create_grid(grid)
    # add 2 starting random numbers
    add_block(grid)
    add_block(grid)
    won_message = False
    score = 0
    trajectory = []
    saved_grid = [[]]
    try:
        while (True):
            util.print_grid(grid)
            if agent == HUMAN:
                key = input("Enter a direction:\n")
                if (key == 'x'):
                    # quit the game
                    break
                try:
                    key = util.action_num_to_letter(int(key))
                except:
                    continue
            elif agent == SVM or agent == NN:
                if util.grid_equal(saved_grid,
                                   grid):  #previous action not allowed
                    #use pior agent since model is deterministic given the same input
                    key = agents.random_agent_with_prior()
                    print("Prior")
                else:
                    print("Model")
                    model_agent = agents.Model()
                    model_agent.load_model(filename="models/" + agent +
                                           ".joblib")
                    key = model_agent.predict([np.array(grid).flatten()])
                    key = util.action_num_to_letter(int(key[0]))
                print(key)
            elif agent == RANDOM:
                key = agents.random_agent()
            elif agent == RANDOM_WITH_PRIOR:
                key = agents.random_agent_with_prior()
            if (key in ['u', 'd', 'l', 'r']):
                # make a copy of the grid
                saved_grid = util.copy_grid(grid)
                # manipulate the grid depending on input
                if (key == 'u'):
                    _, add_score = push.push_up(grid)
                elif (key == 'd'):
                    _, add_score = push.push_down(grid)
                elif (key == 'r'):
                    _, add_score = push.push_right(grid)
                elif (key == 'l'):
                    _, add_score = push.push_left(grid)
                score += add_score
                print("Score: ", score)
                if record and key in 'ludr':
                    data_instance = np.array(saved_grid).flatten()
                    data_instance = np.append(
                        data_instance,
                        [util.action_letter_to_num(key), add_score, score])
                    data_instance = np.append(data_instance,
                                              np.array(grid).flatten())
                    trajectory.append(data_instance)
                # check for a grid with no more gaps or legal moves
                if util.check_lost(grid):
                    print("Game Over!")
                    break
                # check for a grid with the final number
                elif util.check_won(grid) and not won_message:
                    print("Won!")
                    won_message = True
                # finally add a random block if the grid has changed
                if not util.grid_equal(saved_grid, grid):
                    add_block(grid)
            if agent != HUMAN:
                time.sleep(delay)  #in seconds
    finally:
        if record:
            util.save_game(trajectory,
                           filename="games/" + agent.lower() + "/" +
                           agent.lower())
Beispiel #9
0
def run_test (test):
   if test == 0:
      grid = []    
      util.create_grid (grid)
      print (len (grid))
      print (len (grid[0]))
      print (len (grid[1]))
      print (len (grid[2]))
      print (len (grid[3]))
      print (grid[0][0])
      print (grid[1][2])
      print (grid[2][1])
      print (grid[3][3])
   elif test == 1:
      grid = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      util.print_grid (grid)
   elif test == 2:
      grid = [[2  File "/home/rngkum001/python/util.py", line 21
    print("|")
             ^
IndentationError: unindent does not match any outer indentation level
rngkum001@sl-dual-78:~/python$ python3 question2.py >  output.txt
Traceback (most recent call last):
,0,2,0],[0,4,0,8],[0,16,0,128],[2,2,2,2]]
      util.print_grid (grid)
   elif test == 3:
      grid = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      print (util.check_lost (grid))
   elif test == 4:
      grid = [[2,0,2,0],[0,4,0,8],[0,16,0,128],[2,2,2,2]]
      print (util.check_lost (grid))
   elif test == 5:
      grid = [[2,2,2,2],[2,2,2,2],[2,2,2,2],[2,2,2,2]]
      print (util.check_lost (grid))
   elif test == 6:
      grid = [[4,16,2,4],[2,4,16,2],[2,4,8,4],[4,8,4,2]]
      print (util.check_lost (grid))
   elif test == 7:
      grid = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      print (util.check_lost (grid))
   elif test == 8:
      grid = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      print (util.check_won (grid))
   elif test == 9:
      grid = [[2,0,2,0],[0,4,0,8],[0,16,0,128],[2,2,2,2]]
      print (util.check_won (grid))
   elif test == 10:
      grid = [[2,2,2,2],[2,2,2,2],[2,2,2,2],[2,2,2,2]]
      print (util.check_won (grid))
   elif test == 11:
      grid = [[4,16,2,4],[2,4,16,2],[2,4,8,4],[4,8,4,2]]
      print (util.check_won (grid))
   elif test == 12:
      grid = [[2,32,2,4],[4,2,16,2],[8,0,8,4],[2,0,4,2]]
      print (util.check_won (grid))
   elif test == 13:
      grid = [[2,2,8,0],[0,8,16,0],[16,32,8,8],[2,8,4,4]]
      print (util.check_won (grid))
   elif test == 14:
      grid = [[64,32,32,2],[8,4,2,0],[4,2,0,0],[2,0,0,0]]
      print (util.check_won (grid))
   elif test == 15:
      grid = [[64,32,32,2],[8,4,2,0],[4,2,0,0],[2,0,0,0]]
      print (util.check_won (grid))
   elif test == 16:
      grid = [[128,4,0,0],[8,4,2,0],[4,2,0,2],[2,0,0,0]]
      print (util.check_won (grid))
   elif test == 17:
      grid = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      test_grid = util.copy_grid (grid)
      print (grid[0][0],test_grid[0][0])
      print (grid[1][2],test_grid[1][2])
      print (grid[3][3],test_grid[3][3])
      grid[0][0] = 64
      grid[1][2] = 64
      grid[3][3] = 64
      print (grid[0][0],test_grid[0][0])
      print (grid[1][2],test_grid[1][2])
      print (grid[3][3],test_grid[3][3])
   elif test == 18:
      grid1 = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      grid2 = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      print (util.grid_equal (grid1, grid2))
   elif test == 19:
      grid1 = [[4,2,8,2],[2,8,16,8],[16,32,8,4],[4,8,4,2]]
      grid2 = [[4,2,8,2],[2,8,16,4],[16,32,8,4],[4,8,4,2]]
      print (util.grid_equal (grid1, grid2))
   elif test == 20:
      grid1 = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      grid2 = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      print (util.grid_equal (grid1, grid2))
   elif test == 21:
      grid1 = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      grid2 = [[2,4,8,16],[32,64,128,256],[512,1024,2048,4096],[8192,16384,32768,65536]]
      print (util.grid_equal (grid1, grid2))
   elif test == 22:
      grid1 = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
      grid2 = [[2,2,2,2],[2,2,2,2],[2,2,2,2],[2,2,2,2]]
      print (util.grid_equal (grid1, grid2))