Ejemplo n.º 1
0
        """
        Create a new tile in a randomly selected empty
        square.  The tile should be 2 90% of the time and
        4 10% of the time.
        """
        values = [2, 2, 2, 2, 2, 2, 2, 2, 2, 4]
        rand_row = random.randint(0, self.get_grid_height() - 1)
        rand_col = random.randint(0, self.get_grid_width() - 1)
        while self._grid[rand_row][rand_col] != 0:
            rand_row = random.randint(0, self.get_grid_height() - 1)
            rand_col = random.randint(0, self.get_grid_width() - 1)

        self._grid[rand_row][rand_col] = random.choice(values)

    def set_tile(self, row, col, value):
        """
        Set the tile at position row, col to have the given value.
        """
        self._grid[row][col] = value

    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """
        return self._grid[row][col]


M_G9_ = TwentyFortyEight(2, 3)
poc_2048_gui.run_gui(M_G9_)
print str(M_G9_)
Ejemplo n.º 2
0
        """
        Create a new tile in a randomly selected empty
        square.  The tile should be 2 90% of the time and
        4 10% of the time.
        """
        rand_tile_choice = randint(1, 10)
        if rand_tile_choice == 1:
            tile = 4
        else:
            tile = 2
        rand_row_index = randint(0, self._grid_height-1)
        rand_col_index = randint(0, self._grid_width-1)
        if self._board[rand_row_index][rand_col_index] == 0:
            self._board[rand_row_index][rand_col_index] = tile
        else:
            self.new_tile()

    def set_tile(self, row, col, value):
        """
        Set the tile at position row, col to have the given value.
        """
        self._board[row][col] = value

    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """
        return self._board[row][col]

poc_2048_gui.run_gui(TwentyFortyEight(6, 6))
Ejemplo n.º 3
0
        self.set_tile(x_pos, y_pos, tile_value)        
        
    def set_tile(self, row, col, value):
        """
        Set the tile at position row, col to have the given value.
        """        
        self.grid[row][col] = value

    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """        
        return self.grid[row][col]
 
    
poc_2048_gui.run_gui(TwentyFortyEight(3, 3))
##user34_cMJVLVBRqj_5.run_test(merge) # merge test
#my_board = TwentyFortyEight(4,5)
#my_board.grid = []
#my_board.grid.insert(0, [8, 16, 8, 16, 8])
#my_board.grid.insert(1, [16, 8, 16, 8, 16])
#my_board.grid.insert(2, [8, 16, 8, 16, 8])
#my_board.grid.insert(3, [16, 8, 16, 8, 16])
##my_board.grid.insert(0, [2,2,2,2])
##my_board.grid.insert(1, [2,0,2,2])
##my_board.grid.insert(2, [2,4,4,2])
##my_board.grid.insert(0, [0,0,2,2])
#print my_board
#my_board.move(LEFT)
#print my_board
Ejemplo n.º 4
0
        Create a new tile in a randomly selected empty
        square.  The tile should be 2 90% of the time and
        4 10% of the time.
        """
        zero_cells = []
        for row in range(self.height):
            for col in range(self.width):
                if self.grid[row][col] == 0:
                    zero_cells.append((row, col))
        random_cell = random.choice(zero_cells)
        row, col = random_cell
        if int(random.random() * 10) == 0:
            self.grid[row][col] = 4
        else:
            self.grid[row][col] = 2

    def set_tile(self, row, col, value):
        """
        Set the tile at position row, col to have the given value.
        """
        self.grid[row][col] = value

    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """
        return self.grid[row][col]

a_grid = TwentyFortyEight(4, 4)
poc_2048_gui.run_gui(a_grid)
print(a_grid)
Ejemplo n.º 5
0
    text = "Moves: %i" % GAME_ENGINE.get_moves()
    canvas.draw_text( text, ( 151, 32 ), 24, "black" )
    canvas.draw_text( text, ( 150, 31 ), 24, "lime" )
    text = "Max tile: %i" % GAME_ENGINE.get_max_tile()
    canvas.draw_text( text, ( 301, 32 ), 24, "black" )
    canvas.draw_text( text, ( 300, 31 ), 24, "white" )
    if GAME_ENGINE.is_game_over():
        text = "<<<Game Over>>>"
        canvas.draw_text( text, ( 52, 202 ), 48, "black" )
        canvas.draw_text( text, ( 50, 200 ), 48, "#ee5" )        
    
# overwrite painter function
poc_2048_gui.GUI.draw = draw


######################################################
## start game gui
######################################################
poc_2048_gui.run_gui( GAME_ENGINE )




#Math notes:
# n = WIDTH * HEIGHT
# - max possible tile = 2^(n+1)


# GUI
#http://www.codeskulptor.org/#poc_2048_gui.py
        col = random.randrange(0, self.get_grid_width())
        # if there's no zero anywhere on the grid AND
        # no adjacent equal tiles:
        #then game over...
        if self.get_tile(row, col) == 0:
            if random.random() <= 0.9:
                self._tile = 2
                self.set_tile(row, col, self._tile)
            else:
                self._tile = 4
                self.set_tile(row, col, self._tile)
        else:
            self.new_tile()  #This might not be the best method?
            #Maybe set a MAX recursion depth limit of (Height x Width)?

    def set_tile(self, row, col, value):
        """
        Set the tile at position row, col to have the given value.
        """
        self._grid[row][col] = value

    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """
        return self._grid[row][col]


RICE = TwentyFortyEight(4, 4)
poc_2048_gui.run_gui(RICE)
Ejemplo n.º 7
0
        """
        # Select the value of the tile
        new_tile_in_play = random.choice([2,2,2,2,2,2,2,2,4])
        
        # Search all the empty tiles available
        zero_pos_list = []
        for row in range(self.get_grid_height()):
            for col in range(self.get_grid_width()):
                if self.tiles[row][col] == 0:
                    zero_pos_list.append((row, col))
        
        # Select a random tile from the tuples list
        selected_zero_pos = random.choice(zero_pos_list)
        
        # Set the random value
        self.set_tile(selected_zero_pos[0], selected_zero_pos[1], new_tile_in_play)
        
    def set_tile(self, row, col, value):
        """
        Set the tile at position row, col to have the given value.
        """        
        self.tiles[row][col] = value

    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """        
        return self.tiles[row][col]

poc_2048_gui.run_gui(TwentyFortyEight(5, 6))
Ejemplo n.º 8
0
            c_somthing = random.randint(0, self.grid_width - 1)
            r_somthing = random.randint(0, self.grid_height - 1)
            check_repeat.append((r_somthing, c_somthing))
            if len(check_repeat) >= self.grid_width * self.grid_height:
                stop = 1
                break

        if stop == 0:
            self.cells[r_somthing][c_somthing] = random.choice([2] * 9 +
                                                               [4] * 1)
        elif stop == 1:
            return

    def set_tile(self, row, col, value):
        """
        Set the tile at position row, col to have the given value.
        """
        # replace with your code
        self.cells[row][col] = value

    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """
        # replace with your code
        self.value = self.cells[row][col]
        return self.value


poc_2048_gui.run_gui(TwentyFortyEight(3, 3))
Ejemplo n.º 9
0
        number = random.choice(numbers)

        column = random.randrange(0, self._grid_width)
        row = random.randrange(0, self._grid_height)
        if 0 in [
                num for elem in TwentyFortyEight.EXAMPLE_GRID for num in elem
        ]:
            if (TwentyFortyEight.EXAMPLE_GRID[row][column] == 0):
                TwentyFortyEight.EXAMPLE_GRID[row][column] = number
            else:
                self.new_tile()
        else:
            pass

    def set_tile(self, row, col, value):
        """
        Set the tile at position row, col to have the given value.
        """
        # replace with your code
        TwentyFortyEight.EXAMPLE_GRID[row][col] = value

    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """
        # replace with your code
        return TwentyFortyEight.EXAMPLE_GRID[row][col]


poc_2048_gui.run_gui(TwentyFortyEight(5, 5))
Ejemplo n.º 10
0
        if self.initial_board[new_tile_row][new_tile_column] == 0:
            self.initial_board[new_tile_row][new_tile_column] = new_tile

        else:
            self.new_tile()

    def set_tile(self, row, col, value):
        """
        Set the tile at position row, col to have the given value.
        """
        self.initial_board[row][col] = value

    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """
        return self.initial_board[row][col]


board = TwentyFortyEight(4, 4)
poc_2048_gui.run_gui(board)

print board

print board.indicies_dict

initial_tiles = board.indicies_dict[3]
print len(initial_tiles)
print board.indicies_dict[1][1][0]
Ejemplo n.º 11
0
            rand_row = randint(0, self._height-1)
            rand_col = randint(0, self._width-1)
            if self._grid[rand_row][rand_col] != 0:
                continue
            else:
                check = True
            print rand_col, rand_row, rand_seed
            if rand_seed < 10:
                self._grid[rand_row][rand_col] = 2
            else:
                self._grid[rand_row][rand_col] = 4
        #print self

    def set_tile(self, row, col, value):
        """
        Set the tile at position row, col to have the given value.
        """
        # replace with your code
        self._grid[row][col] = value

    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """
        # replace with your code
        return self._grid[row][col]


poc_2048_gui.run_gui(TwentyFortyEight(2, 2))

Ejemplo n.º 12
0
    obj.set_tile(0, 1, 4)
    obj.set_tile(0, 2, 8)
    obj.set_tile(0, 3, 16)
    obj.set_tile(1, 0, 16)
    obj.set_tile(1, 1, 8)
    obj.set_tile(1, 2, 4)
    obj.set_tile(1, 3, 2)
    obj.set_tile(2, 0, 0)
    obj.set_tile(2, 1, 0)
    obj.set_tile(2, 2, 8)
    obj.set_tile(2, 3, 16)
    obj.set_tile(3, 0, 0)
    obj.set_tile(3, 1, 0)
    obj.set_tile(3, 2, 4)
    obj.set_tile(3, 3, 2)
    obj.move(UP)
    alist = [[2, 4, 8, 16], [16, 8, 4, 2], [0, 0, 8, 16], [0, 0, 4, 2]]
    if cmp_list(obj._grid, alist):
        print "Passed "
    else:
        print obj
        print "Expected: \n" + str([row for row in alist]).replace("],", "]\n")
        sys.exit(1)


run_first_test(5, 4, 20)
run_second_test()

TFE = TwentyFortyEight(4, 4)
poc_2048_gui.run_gui(TFE)
                random.randrange(0, self.height),
                random.randrange(0, self.width)
            ]
            if self.grid[rand_square[0]][rand_square[1]] == 0:
                break
        #set that square to either 2 or 4
        seed = random.randint(1, 10)
        if seed == 1:
            tile_value = 4
        else:
            tile_value = 2
        self.grid[rand_square[0]][rand_square[1]] = tile_value

    def set_tile(self, row, col, value):
        """
        Set the tile at position row, col to have the given value.
        """
        # replace with your code
        self.grid[row][col] = value

    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """
        return self.grid[row][col]


game = TwentyFortyEight(4, 5)
poc_2048_gui.run_gui(game)
print game
Ejemplo n.º 14
0
def main():
    new_game = TwentyFortyEight(4,4)
    poc_2048_gui.run_gui(new_game)
                if self._grid[row][col] == 0:
                    zeros.append((row, col))
        return zeros

    def merge_all(self, direction):
        """
        Call merge for all gird
        """
        if direction == UP or direction == DOWN:
            step = self.get_grid_height()
        else:
            step = self.get_grid_width()
        #print('step' ,step)
        for val in self._initial_val[direction]:
            temp_lst = []
            #print('val : ',val)
            row, col = OFFSETS[direction]
            for num in range(step):
                #print(val[0]+x,val[1]+x)
                temp_lst.append(
                    self.get_tile(val[0] + (num * row), val[1] + (num * col)))
            #print("BF : ",temp_lst)
            temp_lst = merge(temp_lst)
            #print("AF : ",temp_lst)
            for num in range(step):
                self.set_tile(val[0] + (row * num), val[1] + (col * num),
                              temp_lst[num])


poc_2048_gui.run_gui(TwentyFortyEight(ROWS, COLS))
Ejemplo n.º 16
0
            if self._grid1_[row][col] == 0:
                self._grid1_[row][col] = new_value
                tile_found = True
            trials += 1
            
            if trials > timeout:
                tile_found = True
                print "GAME OVER!"
                

    def set_tile(self, row, col, value):
        """
        Set the tile at position row, col to have the given value.
        """
        # replace with your code
        self._grid1_[row][col] = value

    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """
        # replace with your code
        return self._grid1_[row][col]
    __repr__ = __str__

    
    


poc_2048_gui.run_gui(TwentyFortyEight(10, 10))
Ejemplo n.º 17
0
    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """

        return self._grid[row][col]

#RICE = TwentyFortyEight(4, 4)
#poc_2048_gui.run_gui(RICE)



TEST1 = TwentyFortyEight(4, 6)
print TEST1
poc_2048_gui.run_gui(TEST1)

##print TEST1
##print str(TEST1)
##print TEST1.reset()
##print TEST1.__str__()
##print
#Test_Suite_2048.run_suite(TEST1)
##print TEST1
##print str(TEST1)
##print TEST1.reset()
##print TEST1.__str__()
##print


Ejemplo n.º 18
0
        twoOrFour = []
        index = 0
        for index in range(0, 100):
            if (index < 90):
                twoOrFour.insert(index, 2)
            else:
                twoOrFour.insert(index, 4)

        randomTwoOrFour = random.randint(0, 99)
        valueOfNewTiles = twoOrFour[randomTwoOrFour]

        rowOfNewTile = coordinatesOfZero[selectedZeroIndex][0]
        columnOfNewTile = coordinatesOfZero[selectedZeroIndex][1]
        self.set_tile(rowOfNewTile, columnOfNewTile, valueOfNewTiles)

    def set_tile(self, row, col, value):
        self.EXAMPLE_GRID[row][col] = value

    def get_tile(self, row, col):
        return self.EXAMPLE_GRID[row][col]

    def set_tile(self, row, col, value):
        self.EXAMPLE_GRID[row][col] = value

    def get_tile(self, row, col):
        return self.EXAMPLE_GRID[row][col]


main = TwentyFortyEight(4, 6)
poc_2048_gui.run_gui(main)
    def new_tile(self):
        # Create a new tile in a randomly selected empty 
        # square.  The tile should be 2 90% of the time and
        # 4 10% of the time.
        available_positions = []
        for row in range(self.grid_height):
            for col in range(self.grid_width):
                if self.cells[row][col] == 0:
                    available_positions.append([row, col])
 
        if not available_positions:
            print "There are no available positions."
        else:
            random_tile = random.choice(available_positions)
 
			weighted_choices = [(2, 9), (4, 1)]
			population = [val for val, cnt in weighted_choices for i in range(cnt)]
			tile = random.choice(population)

            self.set_tile(random_tile[0],random_tile[1], tile)
        
    def set_tile(self, row, col, value):
        # Set the tile at position row, col to have the given value.
        self.cells[row][col] = value
            
    def get_tile(self, row, col):
        # Return the value of the tile at position row, col.
        return self.cells[row][col]
    
poc_2048_gui.run_gui(TwentyFortyEight(4, 4))
Ejemplo n.º 20
0
        4 10% of the time.
        """
        
        random_row = random.randrange(self.height)
        random_col = random.randrange(self.width)
        while self.get_tile(random_row,random_col)!= 0:
            random_row = random.randrange(self.height)
            random_col = random.randrange(self.width)

        if random.random() >= 0.1:
            self.set_tile(random_row, random_col, 2)
        else:
            self.set_tile(random_row, random_col, 4)
        
    def set_tile(self, row, col, value):
        """
        Set the tile at position row, col to have the given value.
        """
        self.grid[row][col] = value

    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """        
        return self.grid[row][col]

## SimpleGUICS2Pygame only works if self._frame.start() is moved to bottom of __init__ in poc_2048_gui.py
poc_2048_gui.run_gui(TwentyFortyEight(9, 10))

#import testsuite
#testsuite.run_test(TwentyFortyEight, merge)
        Function that iterates through the cells in a grid
        in a linear direction

        Both start_cell is a tuple(row, col) denoting the
        starting cell

        direction is a tuple that contains difference between
        consecutive cells in the traversal
        """

        return [
            self._grid[start_cell[0] +
                       step * direction[0]][start_cell[1] +
                                            step * direction[1]]
            for step in range(num_steps)
        ]

    def change_grid(self, start_cell, direction, new_list):
        """
        Function like traverse_grid, but modifies the original
        grid as it iterates
        """

        for step in range(len(new_list)):
            row = start_cell[0] + step * direction[0]
            col = start_cell[1] + step * direction[1]
            self._grid[row][col] = new_list[step]


poc_2048_gui.run_gui(TwentyFortyEight(4, 4))
Ejemplo n.º 22
0
        4 10% of the time.
        """
        # Find an empty cell ("0")
        cell_value = -1
        while cell_value != 0:
            rrow = random.randrange(0, self._height)
            rcol = random.randrange(0, self._width)
            cell_value = self._grid[rrow][rcol]
        
        # Assign a value to it
        if random.randrange(0, 10) > 0:
            self.set_tile(rrow, rcol, 2)
        else:
            self.set_tile(rrow, rcol, 4)
        
    def set_tile(self, row, col, value):
        """
        Set the tile at position row, col to have the given value.
        """
        self._grid[row][col] = value

    def get_tile(self, row, col):
        """
        Return the value of the tile at position row, col.
        """        
        return self._grid[row][col]

    
poc_2048_gui.run_gui(TwentyFortyEight(6, 7))