fork(1) download
copy 
  1. # life.py
  2. # Glenn A. Richard
  3. # Mechanical MOOC MIT OCW 6.189
  4. # Project 2 Conway's Game of Life
  5. # Currently set to create a Gosper Glider Gun
  6. # Use Python 2.7
  7. # July 24, 2013
  8. # Modified July 30, 2013
  9. ## Code template written by Sarina Canelake & Kelly Casteel, August 2010
  10. ## Revised January 2011
  11. from graphics import *
  12. import random
  13.  
  14. ############################################################
  15. # GLOBAL VARIABLES
  16. ############################################################
  17.  
  18. BLOCK_SIZE = 16
  19. BLOCK_OUTLINE_WIDTH = 2
  20. BOARD_WIDTH = 50
  21. BOARD_HEIGHT = 50
  22. COLOR = "red" # I added this.
  23. DELAY = 200
  24.  
  25. neighbor_test_blocklist = [(0,0), (1,1)]
  26. blinker_blocklist = [(2, 2), (2, 3), (2, 4)]
  27. toad_blocklist = [(4,4), (3,5), (3,6), (5,7), (6,5), (6,6)]
  28. beacon_blocklist = [(2,3), (2,4), (3,3), (3,4), (4,5), (4,6), (5,5), (5,6)]
  29. glider_blocklist = [(1,2), (2,3), (3,1), (3,2), (3,3)]
  30. pulsar_blocklist = [(2,4), (2,5), (2,6), (4,2), (4,7), (5,2), (5,7),
  31.                     (6,2), (6,7), (7,4), (7,5), (7,6)]
  32. gosper_glider_gun_blocklist = [(1,5), (1,6), (2,5), (2,6), (11,5), (11,6), (11,7), (12,4), (12,8), (13,3), (13,9), (14,3), (14,9), (15,6), (16,4), (16,8), (17,5), (17,6), (17,7), (18,6), (21,3), (21,4), (21,5), (22,3), (22,4), (22,5), (23,2), (23,6), (25,1), (25,2), (25,6), (25,7), (35,3), (35,4), (36,3), (36,4)]
  33. # for diehard, make board at least 25x25, might need to change block size
  34. diehard_blocklist = [(5,7), (6,7), (6,8), (10,8), (11,8), (12,8), (11,6)]
  35. # list of blocklists
  36. blocklist_list = [glider_blocklist, gosper_glider_gun_blocklist]
  37.  
  38. # blocklist_list = [toad_blocklist, beacon_blocklist, glider_blocklist, pulsar_blocklist, diehard_blocklist, gosper_glider_gun_blocklist]
  39. ############################################################
  40. # TEST CODE (don't worry about understanding this section)
  41. ############################################################
  42.  
  43. def test_neighbors(board):
  44.     '''
  45.     Code to test the board.get_block_neighbor function
  46.     '''
  47.     for block in board.block_list.values():
  48.         neighbors = board.get_block_neighbors(block)
  49.         ncoords = [neighbor.get_coords() for neighbor in neighbors]
  50.         if block.get_coords() == (0,0):
  51.             zeroneighs = [(0,1), (1,1), (1,0)]
  52.             for n in ncoords:
  53.                 if n not in zeroneighs:
  54.                     print "Testing block at (0,0)"
  55.                     print "Got", ncoords
  56.                     print "Expected", zeroneighs
  57.                     return False
  58.  
  59.             for neighbor in neighbors:
  60.                 if neighbor.get_coords() == (1, 1):
  61.                     if neighbor.is_live() == False:
  62.                         print "Testing block at (0, 0)..."
  63.                         print "My neighbor at (1, 1) should be live; it is not."
  64.                         print "Did you return my actual neighbors, or create new copies of them?"
  65.                         print "FAIL: get_block_neighbors() should NOT return new Blocks!"
  66.                         return False
  67.  
  68.         elif block.get_coords() == (1,1):
  69.             oneneighs = [(0,0), (0,1), (0,2), (1,0), (1,2), (2,0), (2,1),(2,2)]
  70.             for n in ncoords:
  71.                 if n not in oneneighs:
  72.                     print "Testing block at (1,1)"
  73.                     print "Got", ncoords
  74.                     print "Expected", oneneighs
  75.                     return False
  76.             for n in oneneighs:
  77.                 if n not in ncoords:
  78.                     print "Testing block at (1,1)"
  79.                     print "Got", ncoords
  80.                     print "Expected", oneneighs
  81.                     return False
  82.     print "Passed neighbor test"
  83.     return True
  84.  
  85.  
  86. ############################################################
  87. # BLOCK CLASS (Read through and understand this part!)
  88. ############################################################
  89.  
  90. class Block(Rectangle):
  91.     ''' Block class:
  92.         Implement a block for a tetris piece
  93.         Attributes: x - type: int
  94.                     y - type: int
  95.         specify the position on the board
  96.         in terms of the square grid
  97.     '''
  98.  
  99.     def __init__(self, pos, color):
  100.         '''
  101.         pos: a Point object specifing the (x, y) square of the Block (NOT in pixels!)
  102.         color: a string specifing the color of the block (eg 'blue' or 'purple')
  103.         '''
  104.         self.x = pos.x
  105.         self.y = pos.y
  106.  
  107.         p1 = Point(pos.x*BLOCK_SIZE,
  108.                    pos.y*BLOCK_SIZE)
  109.         p2 = Point(p1.x + BLOCK_SIZE, p1.y + BLOCK_SIZE)
  110.  
  111.         Rectangle.__init__(self, p1, p2)
  112.         self.setWidth(BLOCK_OUTLINE_WIDTH)
  113.         self.setFill(color)
  114.         self.status = 'dead'
  115.         self.new_status = 'None'
  116.  
  117.     def get_coords(self):
  118.         return (self.x, self.y)
  119.  
  120.     def set_live(self, canvas):
  121.         '''
  122.         Sets the block status to 'live' and draws it on the grid.
  123.         Be sure to do this on the canvas!
  124.         '''
  125.         if self.status=='dead':
  126.           self.status = 'live'
  127.           self.draw(canvas)
  128.  
  129.     def set_dead(self):
  130.         '''
  131.         Sets the block status to 'dead' and undraws it from the grid.
  132.         '''
  133.         if self.status=='live':
  134.           self.status = 'dead'
  135.           self.undraw()
  136.  
  137.     def is_live(self):
  138.         '''
  139.         Returns True if the block is currently 'live'. Returns False otherwise.
  140.         '''
  141.         if self.status == 'live':
  142.             return True
  143.         return False
  144.  
  145.     def reset_status(self, canvas):
  146.         '''
  147.         Sets the new_status to be the current status
  148.         '''
  149.         if self.new_status=='dead':
  150.             self.set_dead()
  151.         elif self.new_status=='live':
  152.             self.set_live(canvas)
  153.  
  154.  
  155. ###########################################################
  156. # BOARD CLASS (Read through and understand this part!)
  157. # Print out and turn in this section.
  158. # Name:
  159. # Recitation:
  160. ###########################################################
  161.  
  162. class Board(object):
  163.     ''' Board class: it represents the Game of Life board
  164.  
  165.         Attributes: width - type:int - width of the board in squares
  166.                     height - type:int - height of the board in squares
  167.                     canvas - type:CanvasFrame - where the blocks will be drawn
  168.                     block_list - type:Dictionary - stores the blocks for a given position
  169.     '''
  170.  
  171.     def __init__(self, win, width, height):
  172.         self.width = width
  173.         self.height = height
  174.         self.win = win
  175.         # self.delay is the number of ms between each simulation. Change to be
  176.         # shorter or longer if you wish!
  177.         self.delay = DELAY
  178.  
  179.         # create a canvas to draw the blocks on
  180.         self.canvas = CanvasFrame(win, self.width * BLOCK_SIZE,
  181.                                        self.height * BLOCK_SIZE)
  182.         self.canvas.setBackground('white')
  183.  
  184.         # initialize grid lines
  185.         for x in range(1,self.width):
  186.             self.draw_gridline(Point(x, 0), Point(x, self.height))
  187.  
  188.         for y in range(1,self.height):
  189.             self.draw_gridline(Point(0, y), Point(self.width, y))
  190.  
  191.         # For each square on the board, we need to initialize
  192.         # a block and store that block in a data structure. A
  193.         # dictionary (self.block_list) that has key:value pairs of
  194.         # (x,y):Block will be useful here.
  195.         self.block_list = {}
  196.  
  197.         ####### YOUR CODE HERE ######
  198. ##        BLOCK_SIZE = 40
  199. ##        BLOCK_OUTLINE_WIDTH = 2
  200. ##        BOARD_WIDTH = 12
  201. ##        BOARD_HEIGHT = 12
  202. ##        # raise Exception("__init__ not implemented")
  203.         for x in range(BOARD_WIDTH):
  204.             for y in range(BOARD_HEIGHT):
  205.                 self.block_list[x, y] = Block(Point(x, y), COLOR)
  206.  
  207.  
  208.     def draw_gridline(self, startp, endp):
  209.         ''' Parameters: startp - a Point of where to start the gridline
  210.                         endp - a Point of where to end the gridline
  211.             Draws two straight 1 pixel lines next to each other, to create
  212.             a nice looking grid on the canvas.
  213.         '''
  214.         line = Line(Point(startp.x*BLOCK_SIZE, startp.y*BLOCK_SIZE), \
  215.                     Point(endp.x*BLOCK_SIZE, endp.y*BLOCK_SIZE))
  216.         line.draw(self.canvas)
  217.  
  218.         line = Line(Point(startp.x*BLOCK_SIZE-1, startp.y*BLOCK_SIZE-1), \
  219.                     Point(endp.x*BLOCK_SIZE-1, endp.y*BLOCK_SIZE-1))
  220.         line.draw(self.canvas)
  221.  
  222.  
  223.     def random_seed(self, percentage):
  224.         ''' Parameters: percentage - a number between 0 and 1 representing the
  225.                                      percentage of the board to be filled with
  226.                                      blocks
  227.             This method activates the specified percentage of blocks randomly.
  228.         '''
  229.         for block in self.block_list.values():
  230.             if random.random() < percentage:
  231.                 block.set_live(self.canvas)
  232.  
  233.     def seed(self, block_coords, offset_x_y = (0, 0)):
  234.         '''
  235.         Seeds the board with a certain configuration.
  236.         Takes in a list of (x, y) tuples representing block coordinates,
  237.         and activates the blocks corresponding to those coordinates.
  238.         '''
  239.  
  240.         #### YOUR CODE HERE #####
  241.         # raise Exception("seed not implemented")
  242.         for coord in block_coords:
  243.             coord = (coord[0] + offset_x_y[0], coord[1] + offset_x_y[1])
  244.             self.block_list[coord].set_live(self.canvas)
  245.  
  246.  
  247.     def get_block_neighbors(self, block):
  248.         '''
  249.         Given a Block object, returns a list of neighboring blocks.
  250.         Should not return itself in the list.
  251.         '''
  252.         #### YOUR CODE HERE #####
  253.         #### Think about edge conditions!
  254.         # raise Exception("get_block_neighbors not implemented")
  255.         x = block.x
  256.         y = block.y
  257.         neighborCoordList = []
  258.         for col in range(x - 1, x + 2):
  259.             for row in range(y - 1, y + 2):
  260.                 if 0 <= col < BOARD_WIDTH and 0 <= row < BOARD_HEIGHT:
  261.                     neighborCoordList.append((col, row))
  262.         neighborCoordList.remove((x, y))
  263.         neighborList = []
  264.         for coords in neighborCoordList:
  265.             neighborList.append(self.block_list[coords])
  266.         return neighborList
  267.  
  268.     def simulate(self):
  269.         '''
  270.         Executes one turn of Conways Game of Life using the rules
  271.         listed in the handout. Best approached in a two-step strategy:
  272.  
  273.         1. Calculate the new_status of each block by looking at the
  274.            status of its neighbors.
  275.  
  276.         2. Set blocks to 'live' if their new_status is 'live' and their
  277.            status is 'dead'. Similarly, set blocks to 'dead' if their
  278.            new_status is 'dead' and their status is 'live'. Then, remember
  279.            to call reset_status(self.canvas) on each block.
  280.         '''
  281.  
  282.         #### YOUR CODE HERE #####
  283.         for col in range(BOARD_WIDTH):
  284.             for row in range(BOARD_HEIGHT):
  285.                 block = self.block_list[col, row]
  286.                 n = self.count_live_neighbors(block)
  287.                 if block.is_live():
  288.                     if 2 <= n <= 3:
  289.                         block.new_status = "live"
  290.                     else:
  291.                         block.new_status = "dead"
  292.                 else:
  293.                     if n == 3:
  294.                         block.new_status = "live"
  295.                     else:
  296.                         block.new_status = "dead"
  297.  
  298.         for col in range(BOARD_WIDTH):
  299.             for row in range(BOARD_HEIGHT):
  300.                 block = self.block_list[col, row]
  301.                 block.reset_status(self.canvas)
  302.         # raise Exception("simulate not implemented")
  303.     # My helper methods below
  304.     def count_live_neighbors(self, block):
  305.         count = 0
  306.         neighbors = self.get_block_neighbors(block)
  307.         for n in neighbors:
  308.             if n.is_live():
  309.                 count += 1
  310.         return count
  311.     # My helper methods above
  312.  
  313.  
  314.  
  315.     def animate(self):
  316.         '''
  317.         Animates the Game of Life, calling "simulate"
  318.         once every second
  319.         '''
  320.         self.simulate()
  321.         self.win.after(self.delay, self.animate)
  322.  
  323.  
  324.  
  325. ################################################################
  326. # RUNNING THE SIMULATION
  327. ################################################################
  328.  
  329. if __name__ == '__main__':    
  330.     # Initalize board
  331.     win = Window("Conway's Game of Life")
  332.     board = Board(win, BOARD_WIDTH, BOARD_HEIGHT)
  333.  
  334.     ## PART 1: Make sure that the board __init__ method works    
  335.     # board.random_seed(.15)
  336.  
  337.     ## PART 2: Make sure board.seed works. Comment random_seed above and uncomment
  338.     ##  one of the seed methods below
  339.     # board.seed(toad_blocklist)
  340.  
  341.     ## PART 3: Test that neighbors work by commenting the above and uncommenting
  342.     ## the following two lines:
  343.     # board.seed(neighbor_test_blocklist)
  344.     # test_neighbors(board)
  345.  
  346.  
  347.     ## PART 4: Test that simulate() works by uncommenting the next two lines:
  348.  
  349.     # board.seed(blocklist_list[random.randint(0, len(blocklist_list) - 1)])
  350.     board.seed(gosper_glider_gun_blocklist)
  351.  
  352.     # win.after(2000, board.simulate)
  353.  
  354.     ## PART 5: Try animating! Comment out win.after(2000, board.simulate) above, and
  355.     ## uncomment win.after below.
  356.     win.after(2000, board.animate)
  357.  
  358.     ## Yay, you're done! Try seeding with different blocklists (a few are provided at the top of this file!)
  359.  
  360.     win.mainloop()
  361.  
  362.  
Not running #stdin #stdout 0s 0KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/gwgC33
Mechanical MOOC - MIT OCW 6.189 - Project 2 - Conway's Game of Life

The graphics.py file from here is needed for executing this code: http://o...content-available-to-author-only...t.edu/courses/electrical-engineering-and-computer-science/6-189-a-gentle-introduction-to-programming-using-python-january-iap-2011/assignments/graphics.py

For the project specifications, see: http://o...content-available-to-author-only...t.edu/courses/electrical-engineering-and-computer-science/6-189-a-gentle-introduction-to-programming-using-python-january-iap-2011/assignments/MIT6_189IAP11_project2.pdf
language:
Python (cpython 2.7.16)
created:
10 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!