import curses import random class ooPuzzle: """Encapsulates a oo puzzle state. No rendering information is stored or interpreted here. All attributes are intended to be accessed through methods. If direct access is necessary, here are their explanations: (the following attributes are constant) DIRECTIONS is a dictionary mapping: each direction as a string to a direction index in range(4) DX_DY is a list mapping: each direction index in range(4) to a differential of form (dx, dy) EDGES_TO_PIECE_ORIENT is a dictionary mapping: each tuple of edge-filled statuses in order of direction to a tuple of (piece id in range(6), orientation direction in range(4)) PIECE_ORIENT_TO_EDGES is an inverse of the previous mapping. (the following attributes are set by __init__) X is an integer for the range of x-positions Y is an integer for the range of y-positions game_id is an integer used by set_pieces_from_game_id It uniquely corresponds to the solution. toroidal is a bool indicating whether the border of the puzzle loops back to the opposite side (the following attributes are variable during normal use) pieces is a dictionary mapping: each position of form (x in range(self.X), y in range(self.Y)) to a piece id in range(6) inverted_pieces is a closely related mapping to pieces, where all edges swap filled state NOT IMPLEMENTED not_inverted_pieces is similar, but only swaps border edges NOT IMPLEMENTED orients is a dictionary mapping: each position of form (x in range(self.X), y in range(self.Y)) to a direction index in range(4) """ def __init__(self, X, Y, game_id=None, toroidal=False): """Create a new ooPuzzle instance. Arguments. X,Y : horizontal and vertical size of the puzzle game_id : passed to ooPuzzle.set_pieces_from_game_id toroidal : bool for looping around the end of the puzzle """ self.X, self.Y = X, Y self.toroidal = toroidal self.pieces = {} self.orients = {} self.set_pieces_from_game_id(game_id) # Changing conceptual directions into indices. DIRECTIONS = {'LEFT' : 0, 'UP' : 1, 'RIGHT': 2, 'DOWN' : 3} # Changing direction indices into (dx, dy) pairs. DX_DY = [(-1, 0), ( 0, -1), ( 1, 0), ( 0, 1)] # Given piece id and orientation direction, # return edge-filled status for each direction. PIECE_ORIENT_TO_EDGES = { (0, 0) : (0, 0, 0, 0), (0, 1) : (0, 0, 0, 0), (0, 2) : (0, 0, 0, 0), (0, 3) : (0, 0, 0, 0), (1, 0) : (1, 0, 0, 0), (1, 1) : (0, 1, 0, 0), (1, 2) : (0, 0, 1, 0), (1, 3) : (0, 0, 0, 1), (2, 0) : (1, 1, 0, 0), (2, 1) : (0, 1, 1, 0), (2, 2) : (0, 0, 1, 1), (2, 3) : (1, 0, 0, 1), (3, 0) : (1, 0, 1, 0), (3, 1) : (0, 1, 0, 1), (3, 2) : (1, 0, 1, 0), (3, 3) : (0, 1, 0, 1), (4, 0) : (0, 1, 1, 1), (4, 1) : (1, 0, 1, 1), (4, 2) : (1, 1, 0, 1), (4, 3) : (1, 1, 1, 0), (5, 0) : (1, 1, 1, 1), (5, 1) : (1, 1, 1, 1), (5, 2) : (1, 1, 1, 1), (5, 3) : (1, 1, 1, 1) } # One choice of inverse of the previous dictionary. EDGES_TO_PIECE_ORIENT = { (0, 0, 0, 0) : (0, 0), (1, 0, 0, 0) : (1, 0), (0, 1, 0, 0) : (1, 1), (0, 0, 1, 0) : (1, 2), (0, 0, 0, 1) : (1, 3), (1, 1, 0, 0) : (2, 0), (0, 1, 1, 0) : (2, 1), (0, 0, 1, 1) : (2, 2), (1, 0, 0, 1) : (2, 3), (1, 0, 1, 0) : (3, 0), (0, 1, 0, 1) : (3, 1), (0, 1, 1, 1) : (4, 0), (1, 0, 1, 1) : (4, 1), (1, 1, 0, 1) : (4, 2), (1, 1, 1, 0) : (4, 3), (1, 1, 1, 1) : (5, 0) } #### # # The following methods are low-level, # and require position inputs to be forced in range. # #### def get_piece(self, x, y): x %= self.X y %= self.Y return self.pieces[x, y] def get_orient(self, x, y): x %= self.X y %= self.Y return self.orients[x, y] def get_piece_orient(self, x, y): x %= self.X y %= self.Y return self.pieces[x, y], self.orients[x, y] def get_adj_pos(self, x0, y0, direction, return_is_internal=False): """Returns the position adjacent to (x0, y0) in direction. direction may be any string or integer in the dictionary self.DIRECTIONS (case insensitive) If return_is_internal, then a third output is returned, a bool for whether both edges are internal. (If false, then the edges are across a border.) """ x0 %= self.X y0 %= self.Y if type(direction) is str: direction = self.DIRECTIONS[direction.upper()] dx, dy = self.DX_DY[direction] x1 = (x0 + dx) % self.X y1 = (y0 + dy) % self.Y if return_is_internal: is_internal = ( x0 + dx == x1 and y0 + dy == y1 ) return x1, y1, is_internal return x1, y1 def set_piece(self, x, y, value): x %= self.X y %= self.Y self.pieces[x, y] = value def set_orient(self, x, y, value): x %= self.X y %= self.Y self.orients[x, y] = value def set_piece_orient(self, x, y, value): x %= self.X y %= self.Y self.pieces[x, y], self.orients[x, y] = value def set_pieces_from_edges(self, horiz_edges, vert_edges): """Convert edge dictionaries into a puzzle state. Adjacent edges in a solution must be either both filled or both unfilled, and so a bit of data is assigned to each pair. vert_edges is the dictionary for vertical pairs key: (x, row) x: the usual x-coordinate of the piece row: the y-coordinate or y+1, depending on whether you want the pair above or below the piece : row == 0 and row == self.Y are border edges so it's good to think of row as 1-indexed horiz_edges is the dictionary for horizontal pairs key: (col, y) col: the x-coord or x+1, same as row but left or right y: the usual y-coord """ for x in range(self.X): for y in range(self.Y): left = horiz_edges[x , y] right = horiz_edges[x+1, y] up = vert_edges[x, y ] down = vert_edges[x, y+1] piece, orient = \ self.EDGES_TO_PIECE_ORIENT[left, up, right, down] self.pieces [x, y] = piece self.orients[x, y] = orient def set_pieces_from_game_id(self, game_id=None): """Convert game_id value into a solution puzzle state. game_id is an integer if toroidal: in range(2**( 2*X*Y )) if not toroidal: in range(2**( (X-1)*Y + X*(Y-1) )) if None, then a random game_id is generated """ # compute: # n_horiz, the number of horizontal edge pairs # n_vert, the number of vertical edge pairs shift = -int(not self.toroidal) n_col = self.X + shift n_row = self.Y + shift n_horiz = n_col * self.Y n_vert = self.X * n_row # generate and record game_id if game_id == None: game_id = random.randrange(0, 2**(n_horiz + n_vert)) self.game_id = game_id # prepare to record edges for self.set_pieces_from_edges vert_edges = {} horiz_edges = {} # set the right and bottom border edges # if toroidal, these will be overwritten in the next step for x in range(self.X): vert_edges[x, self.Y] = 0 for y in range(self.Y): horiz_edges[self.X, y] = 0 # set the edges determined by game_id for i in range(n_vert): row, x = divmod(i, self.X) game_id, bit = divmod(game_id, 2) vert_edges[x, row+1] = bit for i in range(n_horiz): col, y = divmod(i, self.Y) game_id, bit = divmod(game_id, 2) horiz_edges[col+1, y] = bit # make the left and top border edges match the opposite sides for y in range(self.Y): horiz_edges[0, y] = horiz_edges[self.X, y] for x in range(self.X): vert_edges[x, 0] = vert_edges[x, self.Y] # turn edges into pieces self.set_pieces_from_edges(horiz_edges, vert_edges) #### # # The following methods are high-level, # and no longer require position inputs to be forced in range. # # (They call the low-level functions when needed.) # #### def rotate_cw(self, x, y, turns=1): """Rotates the piece at (x, y) by clockwise turns.""" o = self.get_orient(x, y) o = (o + turns) % 4 self.set_orient(x, y, o) def random_orients(self): """Randomly rotate the current pieces.""" for x in range(self.X): for y in range(self.Y): self.set_orient(x, y, random.randrange(4)) def get_edge_pair(self, x0, y0, direction): """Returns the edge pair's filled status in direction and is_internal. direction may be any string or integer in the dictionary self.DIRECTIONS (case insensitive) The first output is the status of the edge of (x0, y0) in direction. The second output is the status of the adjacent edge, that is, of the piece adjacent to (x0, y0) in direction, the status of the edge in the opposite direction. The third output is a bool for whether both edges are internal. (If false, then the edges are across a border.) """ if type(direction) is str: direction = self.DIRECTIONS[direction.upper()] piece, orient = self.get_piece_orient(x0, y0) edge0 = self.PIECE_ORIENT_TO_EDGES[piece, orient][direction] x1, y1, is_internal = \ self.get_adj_pos(x0, y0, direction, return_is_internal=True) piece, orient = self.get_piece_orient(x1, y1) direction = (direction + 2) % 4 edge1 = self.PIECE_ORIENT_TO_EDGES[piece, orient][direction] return edge0, edge1, is_internal def check_edge_pair(self, x, y, direction, if_filled=False): """Check the edge pair's validity around (x, y) in direction. If if_filled, then only check the edge pair if the base edge is filled. """ e0, e1, is_internal = self.get_edge_pair(x, y, direction) if if_filled and not e0: return True if not is_internal and not self.toroidal: return not e0 and not e1 return e0 == e1 def check_piece(self, x, y, if_filled=True): """Check the validity of edge pairs around (x, y). if_filled is passed on to check_edge_pair """ for direction in self.DIRECTIONS: if not self.check_edge_pair(x, y, direction, if_filled): return False return True def is_solved(self): """Check whether the puzzle is in a solved state.""" for x in range(self.X): for y in range(self.Y): if not self.check_edge_pair(x, y, "RIGHT"): return False if not self.check_edge_pair(x, y, "DOWN"): return False return True class ooPlay: """Encapsulates an oo game instance. Renders and interacts with an ooPuzzle instance using curses. """ def __init__(self, screen): """Create a new ooPlay instance. Arguments. scr : curses screen object used for display """ self.screen = screen self.Y, self.X = self.screen.getmaxyx() self.puzzle = ooPuzzle(self.X, self.Y-2) self.puzzle.random_orients() # set up colors curses.start_color() curses.init_color(curses.COLOR_GREEN, 0, 300, 0) curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_GREEN) curses.init_pair(2, curses.COLOR_RED, curses.COLOR_BLACK) curses.init_pair(3, curses.COLOR_RED, curses.COLOR_GREEN) # initialize flags self.help_ind = 0 self.show_errors = False self.inverted = False self.toroidal = False self.extra_hard = False # draw the board state and help area self.screen.clear() self.display() self.write() # start the main loop self.xpos, self.ypos = 0, 0 self.max_xpos = self.puzzle.X - 1 self.max_ypos = self.puzzle.Y - 1 self.keyloop() def new_game(self): """Restarts an already-running ooPlay instance. Flags are preserved, and toroidal is implemented. toroidal is also passed to ooPuzzle at this point, so self.toroidal == self.puzzle.toroidal afterwards. """ self.Y, self.X = self.screen.getmaxyx() if self.toroidal: self.X = (self.X // 2) * 2 self.Y = (self.Y // 2) * 2 X = self.X // 2 Y = (self.Y - 2) // 2 else: X = self.X Y = self.Y - 2 self.puzzle = ooPuzzle(X, Y, toroidal = self.toroidal) if self.extra_hard: while True: for piece in self.puzzle.pieces.values(): if piece in [0, 5]: break else: break self.puzzle.set_pieces_from_game_id() self.puzzle.random_orients() # draw the board state and help area self.screen.clear() self.display() self.write() # return to the main loop self.xpos, self.ypos = 0, 0 self.max_xpos = self.puzzle.X * (1 + self.toroidal) - 1 self.max_ypos = self.puzzle.Y * (1 + self.toroidal) - 1 PIECE_ORIENT_TO_STRING = \ [" ", "╸╵╺╷", "┙┕┍┑", "━│━│", "┝┯┥┷", "┿┿┿┿"] def display_subroutine(self, x, y, recursing=False): """Update one position on the board.""" #TODO: use inverted_pieces and not_inverted_pieces # if self.inverted piece, orient = self.puzzle.get_piece_orient(x, y) string = self.PIECE_ORIENT_TO_STRING[piece][orient] is_error = False if self.show_errors: is_error = not self.puzzle.check_piece(x, y) color = curses.color_pair((x + y) % 2 + 2*is_error) self.screen.addstr(y, x, string, color) if self.puzzle.toroidal and not recursing: X, Y = self.puzzle.X, self.puzzle.Y x1 = (x + X) % (2*X) y1 = (y + Y) % (2*Y) self.display_subroutine(x1, y , recursing=True) self.display_subroutine(x , y1, recursing=True) self.display_subroutine(x1, y1, recursing=True) def display_pos(self, x, y): """Update one position on the board, refresh screen.""" self.display_subroutine(x, y) if self.show_errors: for direction in self.puzzle.DIRECTIONS: x1, y1 = self.puzzle.get_adj_pos(x, y, direction) self.display_subroutine(x1, y1) self.screen.refresh() def display(self): """Update the state of the board, refresh screen.""" for x in range(self.puzzle.X): for y in range(self.puzzle.Y): self.display_subroutine(x, y) self.screen.refresh() pause_length = 80 def write(self, string=None, pause=None): """Write string to the bottom line. if string is narrower than line: centers string within the line if string is wider than line: scrolls through string if a string is not given, then "H" is used if pause is True, there will be a pause for reading if pause is not given but a string is, there will be a pause if neither a pause nor a string is given, there will not be a pause ooPlay.pause_length is the number of milliseconds per character to pause """ if string == None: string = "H" if pause == None: pause = False if pause == None: pause = True width = self.X - 1 color = curses.color_pair(int(pause)) border_line = self.X * "═" self.screen.addstr(self.Y - 2, 0, border_line, color) # writing a string that fits in the width if len(string) <= width: centered_string = string.center(width, " ") self.screen.addstr(self.Y - 1, 0, centered_string, color) self.screen.refresh() if pause: curses.napms(self.pause_length * len(string)) curses.ungetch(0) # clear input return # scrolling through a wider string strings = [string[i:i + width] for i in range(len(string) - width + 1)] self.screen.addstr(self.Y - 1, 0, strings[0], color) self.screen.refresh() curses.napms(self.pause_length * width) for s in strings: self.screen.addstr(self.Y - 1, 0, s, color) self.screen.refresh() curses.napms(self.pause_length) if pause: curses.napms(self.pause_length * width) curses.ungetch(0) # clear input #TODO: ungetch appears to not clear inputs as desired :/ def write_help(self): """Write one of the help messages.""" if self.help_ind == 0: self.write("Help on controls.") self.write("arrow or vi keys: move cursor") self.write("space bar or return: rotates piece") self.write("q: quit game") self.write("n: new game") self.write("r: randomize rotations") self.write("s: toggle show errors") self.write("t: toggle toroidal mode") self.write("i: toggle inverted mode") self.write("x: toggle extra hard mode") self.write("The next help is game explanation.") self.write() if self.help_ind == 1: self.write("Help on game.") self.write("If game is not inverted," + " the object is to have every line connect to another.") self.write("If game is inverted," + " the object is to have no two lines connected.") self.write("If game is not toroidal," + " the borders cannot have lines extending outwards.") self.write("If game is toroidal," + " the borders loop back" + " and may connect to the opposite side.") self.write("If game is extra hard," + " then no completely (un)filled pieces are used.") self.write("The next help is on controls.") self.write() self.help_ind += 1 self.help_ind %= 2 def success(self): """Write and respond to the win screen.""" self.write("You won!") self.write("r n q", pause=False) while True: inp = self.screen.getch() if inp in map(ord, 'QqNnRr'): break return chr(inp) def keyloop(self): """Wait for and parse keypress.""" while True: self.screen.move(self.ypos, self.xpos) inp = self.screen.getch() # parse character input if 0 < inp < 256: inp = chr(inp) if inp in " \n": self.puzzle.rotate_cw(self.xpos, self.ypos) self.display_pos(self.xpos, self.ypos) if self.puzzle.is_solved(): inp = self.success() # if inp is changed by self.success, we catch it here if inp in "Qq": self.write("Quit") return elif inp in "Rr": self.write("Randomize") self.puzzle.random_orients() self.display() self.write() elif inp in "Nn": self.write("New Game") self.new_game() elif inp in "H": self.write_help() elif inp in "Ss": self.write("Do Not "*self.show_errors + "Show Errors") self.show_errors = not self.show_errors self.display() self.write() #TODO: add in show solution, with undo option elif inp in "Ii": self.write("Puzzle is now" + " NOT"*self.inverted + " inverted.") self.inverted = not self.inverted self.display() self.write() elif inp in "Tt": self.write("Next new game will" + " NOT"*self.toroidal + " be toroidal.") self.toroidal = not self.toroidal self.write() elif inp in "Xx": self.write("Next new game will" + " NOT"*self.extra_hard + " be extra hard.") self.extra_hard = not self.extra_hard self.write() # parse arrow/vi key input for motion if inp in [curses.KEY_UP, "k"]: if self.toroidal: self.ypos = (self.ypos - 1) % (self.max_ypos + 1) elif self.ypos > 0: self.ypos -= 1 elif inp in [curses.KEY_DOWN, "j"]: if self.toroidal: self.ypos = (self.ypos + 1) % (self.max_ypos + 1) elif self.ypos < self.max_ypos: self.ypos += 1 elif inp in [curses.KEY_LEFT, "h"]: if self.toroidal: self.xpos = (self.xpos - 1) % (self.max_xpos + 1) elif self.xpos > 0: self.xpos -= 1 elif inp in [curses.KEY_RIGHT, "l"]: if self.toroidal: self.xpos = (self.xpos + 1) % (self.max_xpos + 1) elif self.xpos < self.max_xpos: self.xpos += 1 def main(): curses.wrapper(ooPlay) if __name__ == "__main__": main()