Assignment 5. INF109 Dataprogrammering for naturvitskap

Transcription

1 Assignment 5 INF109 Dataprogrammering for naturvitskap This is the fifth of seven assignments. You can get a total of 15 points for this task. Friday, 8. April, Submit the report as a single.py file. Submit the report on the course website at MiSide. The tasks should be submitted individually, i.e. it should be your own work. However some cooperation and discussion is allowed. 1 Game of Life In this task, you will implement the well-known game called Game of Life. The game is a board game that has a few very simple rules, and we shall implement these rules and simulate the game graphically. (a) Bikube (b) Blokk (c) Båt (d) Brød Figure 1: examples 1.1 The game Usually, the Game of Life is played on an infinite plane but, for simplicity, we implement a version that plays on a board of finite size. As with games like pacman, we play on the topology of a torus or a so-called unfolded donut, i.e. if you leave from one side of the board then you return from the other side. Neighbourhood. The board we play on is divided into squares as shown in the examples above. Each square is called a cell and a cell is either dead or alive. In the pictures above the black cells are alive and the white cells are dead. We define the neighbourhood of the cell with coordinates (x, y), being the eight different positions as shown below. Top 1: (x 1, y + 1) Top 2: (x, y + 1) Top 3: (x + 1, y + 1) Middle 1: (x 1, y) Middle 2: (x + 1, y) Bottom 1: (x 1, y 1) Bottom 2: (x, y 1) Bottom 3: (x + 1, y 1) 1

2 Iteration. The game comprises iterations or rounds. Between each round, we update the status of a cell, being the number of live neighbouring cells it has. If a cell has too many living neighbours, we say that it dies because of over-population, and if too few living neighbours, we say that it dies due to under-population and if a cell that is currently dead has exactly three live neighbouring cells, it is brought back to life, i.e. revived for reproduction. 1.2 Rules For each cell on the board, we now explain the rules that determine whether the cell is living or dead in the next iteration: Rule 1. A live cell with fewer than two live neighbours dies. Rule 2. A live cell with two or three live neighbours survives to the next round. Rule 3. A living cell with more than three live neighbours dies. Rule 4. A dead cell with exactly three live neighbours comes to life. These rules were developed by the British mathematician John Horton Conway in 1970 after an idea by John von Neumann. Conway later proved that the Game of Life is Turing-complete, meaning that this game can simulate any computation a (classical) computer can do. 2 Algorithms and data structures In Python a matrix is a list of lists in the same way that, in mathematics, a matrix is a vector of vectors. However, in Python we often put all kinds of weird objects into a vector whilst, in mathematics, it is usual that the vectors contain just numbers. We can represent a list of lists of Boolean values, as follows: >>> board = [[ False, False, False ], [ False, False, False ], [ False, False, False ]] This python code describes a Game of Life board by a 3 3 matrix with False entries. For simplicity, we always assume that the boards are square, in which case, if we say that the size of the board is n, then we are referring to an n n grid of cells. We shall always have a variable called board, that records the status of the cells (i.e. whether the cells are dead or alive), but in addition, we have an equally large matrix called rectangles, which contains graphical Rectangle-objects that we use to update the color to display whether the cells are dead or not. def size (): """ Returns the size of the board. """ return 3 2

3 2.1 Counting live neighbours The entire rule set for the Game of Life is based on how many neighbouring living cells a given cell has. Therefore, it is very natural to make the following function, which has the task to count precisely this. Remember that a cell always has eight neighbours, and each of them can be alive or dead. This also means that when a cell is along an edge or corner, some of the neighbouring cells are on the opposite side of the board - we shall use modular arithmetic to take care of this situation. def living_neighbors (x,y, board ): """ Counts the number of living neighbors of the cell in the given coordinate (x, y). If either coordinate is on the edge, we wrap : i. e. we re living on a torus. Finally, we return the number of neighbors. """ neighbors = 0 # put stuff here # Be on the lookout for values greater than size () # and smaller than 0. return neighbors Here is a hint. We are given a matrix board and a coordinate (x, y). As described above, the neighbours have coordinates (x 1, y 1), (x, y 1),... and it is not difficult to count them. The problem occurs when we encounter a value v = 0 or v = size() 1. But this can be easily solved by using modular arithmetic: (x + 1) % size() is always less than size(), and provides the values we are looking for: If we have the value size() 1, then (size() 1 + 1) % size() = 0, and we get the coordinate of the cell on the other side of the board. 2.2 Iteration The main action of the game is the function iterate(board), which takes in a board (an n n matrix of Boolean values) and returns a new board for the next iteration. def iterate ( board ): """ Does one iteration, returns the next generation of cells. Returns the tuple ( living, board ), where living is the number of alive cells and board is a matrix of boolean values corresponding to the liveness of each cell. """ new_board = [] for i in range ( size ()): row = [] for j in range ( size ()): row. append ( False ) new_board. append ( row ) # put your code here return ( living, new_board ) 3

4 2.3 Graphics The first program calls a function initiate(), which returns a pair, (board, rectangles), which are both matrices of size size() size(). The matrix board contains a random configuration of True and False. A random boolean value can most easily be obtained as follows: from random import choice def random_bit (): """ Returns a random value of True or False. """ return choice ([ True, False ]) Then the rectangles are populated with Rectangle objects. In position x, y we create an object Rectangle(Point(x,y),Point(x+1,y+1)). Remember to set the coordinate system of the window, with setcoords, to (0,0,size(),size()). Now that you have board and rectangles, it is a simple task to set the colour of each rectangle as desired: def update_color (x,y, board, rectangles ): """ Sets colour in rectangles [x, y] to correct value according to the status of its corresponding cell in board. """ if ( board [x][y]): rectangles [x][y]. setfill (" red4 ") else : rectangles [x][y]. setfill (" gray3 ") 3 Speed If everything works as it should, you should then implement the following speed-up. Let the function iterate do one additional thing. It should now return (living, board, changes), where the new variable is a list of coordinates that have changed. This will be used to update the colour of only those cells that have changed status. 4

5 4 Task 1 Task 1 is to have a working implementation of the Game of Life. When the program starts, a window of size n n is created, where you decide the value of n. In the initial phase you create a random distribution of living cells. Then you have a while(true) loop that realises the iterations, until you manually enter something to interrupt the program. If you want the updates to be slower, use sleep(r) to allow the program to sleep for r seconds where r is some floating point number. But remember that you must first import sleep from the environment time, using the line from time import sleep. 5 Task 2 Now you shall enhance your application so as to have the following functionality: a text field (Entry) and a start button, a clear button, a randomize button, a load and a save button, a quit button. In the text field, the user of the program enters the desired number iterations to be performed, and when the start button is pressed, the program runs for the desired number of iterations. Both before and after the start button has been pressed, the user should be able to access cells to switch them between living and dead. If the clear button is pressed, all cells of the board become dead and if randomize is pressed, the cells are assigned, randomly, and independently, to dead or alive states. The buttons load and save should be used to save and load patterns (you can assume that the pattern can be accomodated by the size of your current board). Button quit will close the program. Hint. If you set the coordinate system to be (0,-3,size(),size()), you can represent the buttons using y-coordinates. Remember to create a function is inside(rectangle, point) that returns True if and only if Point is inside the rectangle, and use this to determine if the user pressed a button or not. 5

6 6 Submission Save your program in a.py file called oblig5-abc123.py, where abc123 should be replaced with your username and your assignment on the student portal Mi Side. Innleveringsmappe Vurderingsmappe Innlevering5. 7 Marking/assessment For this task, you can get a maximum of 15 points. The distribution of points is as follows. The program works as expected 12 (ca ) The program is well documented, clear, and with comments 2 Naming 1 15 The program works as expected. Here you will lose marks if your program prints the wrong data or in the wrong format (differs from the example), crashes in any manner, or if function names are not as stated. The program is well documented, clear, and with comments. You will lose marks if your program is not commented sufficiently, but also if there are too many comments. You can also lose marks if the program is unclear, meaning that it is difficult for another person to familiarize themselves with the program s functionality. Naming It is required that the names of variables and functions are sensibly chosen and that the naming used is consistent: either mixedcase or with underscore. 1 The tasks will be marked within one week of submission and the score and any comments will be posted in the assessment portfolio under comments. Questions or complaints on the marking can be directed to one of the group leaders. 1 mixedcase refers to variables such as innlestdata, and underscore refers to variables entered like innlest data. Choose one of these two and stick to that. Never start with a capital letter, e.g. InnlestData or similar, as these are reserved for class names, which are partially outside of the curriculum for this course. 6