| #!/usr/bin/env python3 |
| |
| """ |
| A curses-based version of Conway's Game of Life. |
| |
| An empty board will be displayed, and the following commands are available: |
| E : Erase the board |
| R : Fill the board randomly |
| S : Step for a single generation |
| C : Update continuously until a key is struck |
| Q : Quit |
| Cursor keys : Move the cursor around the board |
| Space or Enter : Toggle the contents of the cursor's position |
| |
| Contributed by Andrew Kuchling, Mouse support and color by Dafydd Crosby. |
| """ |
| |
| import curses |
| import random |
| |
| |
| class LifeBoard: |
| """Encapsulates a Life board |
| |
| Attributes: |
| X,Y : horizontal and vertical size of the board |
| state : dictionary mapping (x,y) to 0 or 1 |
| |
| Methods: |
| display(update_board) -- If update_board is true, compute the |
| next generation. Then display the state |
| of the board and refresh the screen. |
| erase() -- clear the entire board |
| make_random() -- fill the board randomly |
| set(y,x) -- set the given cell to Live; doesn't refresh the screen |
| toggle(y,x) -- change the given cell from live to dead, or vice |
| versa, and refresh the screen display |
| |
| """ |
| def __init__(self, scr, char=ord('*')): |
| """Create a new LifeBoard instance. |
| |
| scr -- curses screen object to use for display |
| char -- character used to render live cells (default: '*') |
| """ |
| self.state = {} |
| self.scr = scr |
| Y, X = self.scr.getmaxyx() |
| self.X, self.Y = X - 2, Y - 2 - 1 |
| self.char = char |
| self.scr.clear() |
| |
| # Draw a border around the board |
| border_line = '+' + (self.X * '-') + '+' |
| self.scr.addstr(0, 0, border_line) |
| self.scr.addstr(self.Y + 1, 0, border_line) |
| for y in range(0, self.Y): |
| self.scr.addstr(1 + y, 0, '|') |
| self.scr.addstr(1 + y, self.X + 1, '|') |
| self.scr.refresh() |
| |
| def set(self, y, x): |
| """Set a cell to the live state""" |
| if x < 0 or self.X <= x or y < 0 or self.Y <= y: |
| raise ValueError("Coordinates out of range %i,%i" % (y, x)) |
| self.state[x, y] = 1 |
| |
| def toggle(self, y, x): |
| """Toggle a cell's state between live and dead""" |
| if x < 0 or self.X <= x or y < 0 or self.Y <= y: |
| raise ValueError("Coordinates out of range %i,%i" % (y, x)) |
| if (x, y) in self.state: |
| del self.state[x, y] |
| self.scr.addch(y + 1, x + 1, ' ') |
| else: |
| self.state[x, y] = 1 |
| if curses.has_colors(): |
| # Let's pick a random color! |
| self.scr.attrset(curses.color_pair(random.randrange(1, 7))) |
| self.scr.addch(y + 1, x + 1, self.char) |
| self.scr.attrset(0) |
| self.scr.refresh() |
| |
| def erase(self): |
| """Clear the entire board and update the board display""" |
| self.state = {} |
| self.display(update_board=False) |
| |
| def display(self, update_board=True): |
| """Display the whole board, optionally computing one generation""" |
| M, N = self.X, self.Y |
| if not update_board: |
| for i in range(0, M): |
| for j in range(0, N): |
| if (i, j) in self.state: |
| self.scr.addch(j + 1, i + 1, self.char) |
| else: |
| self.scr.addch(j + 1, i + 1, ' ') |
| self.scr.refresh() |
| return |
| |
| d = {} |
| self.boring = 1 |
| for i in range(0, M): |
| L = range(max(0, i - 1), min(M, i + 2)) |
| for j in range(0, N): |
| s = 0 |
| live = (i, j) in self.state |
| for k in range(max(0, j - 1), min(N, j + 2)): |
| for l in L: |
| if (l, k) in self.state: |
| s += 1 |
| s -= live |
| if s == 3: |
| # Birth |
| d[i, j] = 1 |
| if curses.has_colors(): |
| # Let's pick a random color! |
| self.scr.attrset(curses.color_pair( |
| random.randrange(1, 7))) |
| self.scr.addch(j + 1, i + 1, self.char) |
| self.scr.attrset(0) |
| if not live: |
| self.boring = 0 |
| elif s == 2 and live: |
| # Survival |
| d[i, j] = 1 |
| elif live: |
| # Death |
| self.scr.addch(j + 1, i + 1, ' ') |
| self.boring = 0 |
| self.state = d |
| self.scr.refresh() |
| |
| def make_random(self): |
| "Fill the board with a random pattern" |
| self.state = {} |
| for i in range(0, self.X): |
| for j in range(0, self.Y): |
| if random.random() > 0.5: |
| self.set(j, i) |
| |
| |
| def erase_menu(stdscr, menu_y): |
| "Clear the space where the menu resides" |
| stdscr.move(menu_y, 0) |
| stdscr.clrtoeol() |
| stdscr.move(menu_y + 1, 0) |
| stdscr.clrtoeol() |
| |
| |
| def display_menu(stdscr, menu_y): |
| "Display the menu of possible keystroke commands" |
| erase_menu(stdscr, menu_y) |
| |
| # If color, then light the menu up :-) |
| if curses.has_colors(): |
| stdscr.attrset(curses.color_pair(1)) |
| stdscr.addstr(menu_y, 4, |
| 'Use the cursor keys to move, and space or Enter to toggle a cell.') |
| stdscr.addstr(menu_y + 1, 4, |
| 'E)rase the board, R)andom fill, S)tep once or C)ontinuously, Q)uit') |
| stdscr.attrset(0) |
| |
| |
| def keyloop(stdscr): |
| # Clear the screen and display the menu of keys |
| stdscr.clear() |
| stdscr_y, stdscr_x = stdscr.getmaxyx() |
| menu_y = (stdscr_y - 3) - 1 |
| display_menu(stdscr, menu_y) |
| |
| # If color, then initialize the color pairs |
| if curses.has_colors(): |
| curses.init_pair(1, curses.COLOR_BLUE, 0) |
| curses.init_pair(2, curses.COLOR_CYAN, 0) |
| curses.init_pair(3, curses.COLOR_GREEN, 0) |
| curses.init_pair(4, curses.COLOR_MAGENTA, 0) |
| curses.init_pair(5, curses.COLOR_RED, 0) |
| curses.init_pair(6, curses.COLOR_YELLOW, 0) |
| curses.init_pair(7, curses.COLOR_WHITE, 0) |
| |
| # Set up the mask to listen for mouse events |
| curses.mousemask(curses.BUTTON1_CLICKED) |
| |
| # Allocate a subwindow for the Life board and create the board object |
| subwin = stdscr.subwin(stdscr_y - 3, stdscr_x, 0, 0) |
| board = LifeBoard(subwin, char=ord('*')) |
| board.display(update_board=False) |
| |
| # xpos, ypos are the cursor's position |
| xpos, ypos = board.X // 2, board.Y // 2 |
| |
| # Main loop: |
| while True: |
| stdscr.move(1 + ypos, 1 + xpos) # Move the cursor |
| c = stdscr.getch() # Get a keystroke |
| if 0 < c < 256: |
| c = chr(c) |
| if c in ' \n': |
| board.toggle(ypos, xpos) |
| elif c in 'Cc': |
| erase_menu(stdscr, menu_y) |
| stdscr.addstr(menu_y, 6, ' Hit any key to stop continuously ' |
| 'updating the screen.') |
| stdscr.refresh() |
| # Activate nodelay mode; getch() will return -1 |
| # if no keystroke is available, instead of waiting. |
| stdscr.nodelay(1) |
| while True: |
| c = stdscr.getch() |
| if c != -1: |
| break |
| stdscr.addstr(0, 0, '/') |
| stdscr.refresh() |
| board.display() |
| stdscr.addstr(0, 0, '+') |
| stdscr.refresh() |
| |
| stdscr.nodelay(0) # Disable nodelay mode |
| display_menu(stdscr, menu_y) |
| |
| elif c in 'Ee': |
| board.erase() |
| elif c in 'Qq': |
| break |
| elif c in 'Rr': |
| board.make_random() |
| board.display(update_board=False) |
| elif c in 'Ss': |
| board.display() |
| else: |
| # Ignore incorrect keys |
| pass |
| elif c == curses.KEY_UP and ypos > 0: |
| ypos -= 1 |
| elif c == curses.KEY_DOWN and ypos + 1 < board.Y: |
| ypos += 1 |
| elif c == curses.KEY_LEFT and xpos > 0: |
| xpos -= 1 |
| elif c == curses.KEY_RIGHT and xpos + 1 < board.X: |
| xpos += 1 |
| elif c == curses.KEY_MOUSE: |
| mouse_id, mouse_x, mouse_y, mouse_z, button_state = curses.getmouse() |
| if (mouse_x > 0 and mouse_x < board.X + 1 and |
| mouse_y > 0 and mouse_y < board.Y + 1): |
| xpos = mouse_x - 1 |
| ypos = mouse_y - 1 |
| board.toggle(ypos, xpos) |
| else: |
| # They've clicked outside the board |
| curses.flash() |
| else: |
| # Ignore incorrect keys |
| pass |
| |
| |
| def main(stdscr): |
| keyloop(stdscr) # Enter the main loop |
| |
| if __name__ == '__main__': |
| curses.wrapper(main) |
