### use python 3 to build a 2048 game task 1 your first task will be to implement the fu 4952112

Use Python 3 to build a 2048 Game:

**Task 1** Your first task will be to implement the function

**createGrid()** that takes two parameters row and coland returns the grid for the game. You will be using a list oflists to represent the grid. The list should contain row number oflists, each with a length col. All the elements of this datastructure should be 0.

**Task 2** Once you are finished with Task 1, you can begin this task. Besure to erase the test code from the previous task. Now, you willimplement the

**setCell()**and

**getCell()** functions to set and access values inthe grid. We can imagine the elements of the grid to be associatedwith a cell number. That is each element of the grid is a cell.So, in a (4 x 4) grid, the cells are numbered 0 through15. As a result, instead of accessing an element using, say,

**grid._grid[1][2]**, we access that element with

**grid.getCell(6)**. Implement

**setCell()** such that it takes two arguments, celland val, and assigns the value of val to cell number cell in thegrid. Implement

**getCell()** such that it takes anargument, cell, and returns the value in the grid at cell numbercell.

**Task 3** Implement the

**collapsible()** function. Thisfunction should return True if the grid can be collapsed in any ofthe four directions. It should return False otherwise. Uncommentthe line near the bottom that calls the function

**testCollapsible()** and run the file with Python. Ifyour implementation is correct it should print that all the testshave passed. Hint: One way to know if the grid is collapsible is if there isan empty tile in the grid.

**Task 4** In Task 4 you must complete the

**collapseRow()**function. This function is given a list of numbers as an argumentand it should return a LEFT-collapsed list, and a True if the listwas collapsed or False if it was not. The code for your functionmust collapse the list conforming to the rules of 2048. That is, ifit is passed the list [2, 0, 2, 4], after collapsing to the leftthe function should return the list [4, 4, 0, 0]. In order to testyour implementation, you can use the

**tests.py** filethat is given to you. Uncomment the line near the bottom that callsthe function

**testCollapseRow()** and run the filewith Python. If your implementation is correct it should print thatall the tests have passed.

**Task 5** In this task, you will use the

**collapseRow()**function to implement

**collapseLeft()**,

**collapseRight()**,

**collapseDown()**and

**collapseUp()**. For

**collapseLeft()**, you merely need to collapse everyrow of the grid using

**collapseRow()**.

**collapseRight()** is implemented similarly except,in this case, you would reverse each row before collapsing them.Use this idea, to implement

**collapseDown()** and

**collapseUp()**. All four functions should returnTrue if the grid was collapsed and False otherwise.

**Task 6** Implement the function

**updateEmptiesSet()**. Thisfunction is used after every collapse action in the game. Thefunction should update the

**emptiesSet** list tocontain the new set of empty cells after a collapse. Tests for thisfunction can be found in the

**tests.py** file.

**SKELETON CODE** import random as rnd

import os

import sys class Grid():

def __init__(self, row=4, col=4, initial=2):

self.row = row # number of rows in grid

self.col = col # number of columns in grid

self.initial = initial # number of initial cells filled

self.score = 0 self._grid = self.createGrid(row, col) # creates the gridspecified above self.emptiesSet = list(range(row * col)) # list of emptycells for _ in range(self.initial): # assignation to two randomcells

self.assignRandCell(init=True) def createGrid(self, row, col): “””

Create the grid here using the arguments row and col

as the number of rows and columns of the grid to be made. The function should return the grid to be used in__init__()

“”” pass def setCell(self, cell, val): “””

This function should take two arguments cell and val andassign

the cell of the grid numbered ‘cell’ the value in val. This function does not need to return anything. You should use this function to change values of the grid.

“”” pass def getCell(self, cell): “”””

This function should return the value in cell number ‘cell’

of the grid. You should use this function to access values of the grid

“”” pass def assignRandCell(self, init=False): “””

This function assigns a random empty cell of the grid

a value of 2 or 4. In __init__() it only assigns cells the value of 2. The distribution is set so that 75% of the time the random cellis

assigned a value of 2 and 25% of the time a random cell isassigned

a value of 4

“”” if len(self.emptiesSet):

cell = rnd.sample(self.emptiesSet, 1)[0]

if init:

self.setCell(cell, 2)

else:

cdf = rnd.random()

if cdf > 0.75:

self.setCell(cell, 4)

else:

self.setCell(cell, 2)

self.emptiesSet.remove(cell) def drawGrid(self): “””

This function draws the grid representing the state of thegame

grid

“”” for i in range(self.row):

line = ‘t|’

for j in range(self.col):

if not self.getCell((i * self.row) + j):

line += ‘ ‘.center(5) + ‘|’

else:

line += str(self.getCell((i * self.row) + j)).center(5) + ‘|’

print(line)

print() def updateEmptiesSet(self): “””

This function should update the list of empty cells of thegrid.

“”” pass def collapsible(self): “””

This function should test if the grid of the game iscollapsible

in any direction (left, right, up or down.) It should return True if the grid is collapsible.

It should return False otherwise.

“”” pass def collapseRow(self, lst): “””

This function takes a list lst and collapses it to the LEFT. This function should return two values:

1. the collapsed list and

2. True if the list is collapsed and False otherwise.

“”” pass def collapseLeft(self): “””

This function should use collapseRow() to collapse all therows

in the grid to the LEFT. This function should return True if any row of the grid iscollapsed

and False otherwise.

“”” pass def collapseRight(self): “””

This function should use collapseRow() to collapse all therows

in the grid to the RIGHT. This function should return True if any row of the grid iscollapsed

and False otherwise.

“”” pass def collapseUp(self): “””

This function should use collapseRow() to collapse all thecolumns

in the grid to UPWARD. This function should return True if any column of the gridis

collapsed and False otherwise.

“”” pass def collapseDown(self): “””

This function should use collapseRow() to collapse all thecolumns

in the grid to DOWNWARD. This function should return True if any column of the gridis

collapsed and False otherwise.

“”” pass class Game():

def __init__(self, row=4, col=4, initial=2): “””

Creates a game grid and begins the game

“”” self.game = Grid(row, col, initial)

self.play() def printPrompt(self): “””

Prints the instructions and the game grid with a move prompt

“”” if sys.platform == ‘win32’:

os.system(“cls”)

else:

os.system(“clear”) print(‘Press “w”, “a”, “s”, or “d” to move Up, Left, Down orRight respectively.’)

print(‘Enter “p” to quit.n’)

self.game.drawGrid()

print(‘nScore: ‘ + str(self.game.score)) def play(self): moves = {‘w’ : ‘Up’,

‘a’ : ‘Left’,

‘s’ : ‘Down’,

‘d’ : ‘Right’} stop = False

collapsible = True while not stop and collapsible:

self.printPrompt()

key = input(‘nEnter a move: ‘) while not key in list(moves.keys()) + [‘p’]:

self.printPrompt()

key = input(‘nEnter a move: ‘) if key == ‘p’:

stop = True

else:

move = getattr(self.game, ‘collapse’ + moves[key])

collapsed = move() if collapsed:

self.game.updateEmptiesSet()

self.game.assignRandCell() collapsible = self.game.collapsible() if not collapsible:

if sys.platform == ‘win32’:

os.system(“cls”)

else:

os.system(“clear”)

print()

self.game.drawGrid()

print(‘nScore: ‘ + str(self.game.score))

print(‘No more legal moves.’) def main():

game = Game() #main() Attached