added betrayal.py

A test implementation for a table top game I'm working on developing
with JT Booth and John Phillpot.

Author: MichaelSheely

betrayal.py

@@ -0,0 +1,288 @@
+import graphics
+import time
+
+VoffSet = 80
+HoffSet = 40
+cellSize = 40
+
+class Maze:
+
+    def __init__(self, rows, columns):
+        self.rows = rows
+        self.columns = columns
+        self.cells = [] #2D array of cell objects
+        self.Vwalls = [] #2D array of all possible vertical walls
+        self.Hwalls = [] #2D array of all possible horizontal walls
+        self.win = graphics.GraphWin("Maze",2*HoffSet+cellSize*columns,2*VoffSet+cellSize*rows)
+        self.win.setBackground("black")
+        self.initialize()
+
+    def __repr__(self):
+        return str(self.cells)
+
+    def initialize(self):
+        for r in range(self.rows):
+            self.cells += [[]]
+            for c in range(self.columns):
+                self.cells[r] += [Cell(r,c)]
+                self.cells[r][c].cellGraphic.draw(self.win)
+        for r in range(self.rows):
+            self.Vwalls += [[]]
+            for c in range(self.columns+1):
+                if c == 0:
+                    self.Vwalls[r] += [Wall(r,c,'W',True,'v')]
+                elif c == self.columns:
+                    self.Vwalls[r] += [Wall(r,c,'E',True,'v')]
+                else:
+                    self.Vwalls[r] += [Wall(r,c,False,True,'v')]
+                self.Vwalls[r][c].wallGraphic.draw(self.win)
+        for r in range(self.rows+1):
+            self.Hwalls += [[]]
+            for c in range(self.columns):
+                if r == 0:
+                    self.Hwalls[r] += [Wall(r,c,'N',True,'h')]
+                elif r == self.rows:
+                    self.Hwalls[r] += [Wall(r,c,'S',True,'h')]
+                else:
+                    self.Hwalls[r] += [Wall(r,c,False,True,'h')]
+                self.Hwalls[r][c].wallGraphic.draw(self.win)
+
+    def insertObj(self, row, column, obj):
+        """draws the given object in the maze any objects must
+        have a createFigure() member function that provides a
+        drawable .figure data member and take .maze data member
+        that stores the maze in which the object exists"""
+        obj.row = row
+        obj.column = column
+        obj.maze = self #this sets the object to know what maze it is in
+        anchorPt = self.cells[row][column].cellGraphic.getCenter()
+        obj.createFigure(anchorPt)
+        obj.figure.draw(self.win)
+
+    def getWall(self, cell, direction):
+        """returns the wall in the given direction from
+        the given cell"""
+        return self.getWall(cell.row, cell.column, direction)
+
+    def getWall(self, row, column, direction):
+        """returns the wall in the given direction from
+        the given cell"""
+        if direction == 'N':
+            return self.Hwalls[row][column]
+        elif direction == 'W':
+            return self.Vwalls[row][column]
+        elif direction == 'E':
+            return self.Vwalls[row][column+1]
+        elif direction == 'S':
+            return self.Hwalls[row+1][column]
+        
+    def setWall(self, row, column, orientation, solid):
+        if orientation == 'v':
+            self.Vwalls[row][column].setWall(solid)
+        else:
+            self.Hwalls[row][column].setWall(solid)
+    
+    def close(self):
+        self.win.close()
+  
+class Cell:
+
+    def __init__(self, row, column):
+        self.row = row
+        self.column = column
+        self.obj = None
+        p1 = graphics.Point(HoffSet+cellSize*column,VoffSet+cellSize*row)
+        p2 = graphics.Point(HoffSet+cellSize*(column+1),VoffSet+cellSize*(row+1))
+        self.cellGraphic = graphics.Rectangle(p1, p2)
+        self.cellGraphic.setOutline("black")
+
+    def __repr__(self):
+        return str((self.row, self.column))
+
+    def setColor(self, color):
+        self.cellGraphic.setFill(color)
+        
+
+class Wall:
+
+    def __init__(self, row, column, edge, solid, orientation):
+        self.row = row
+        self.column = column
+        self.solid = solid
+        self.edge = edge
+        self.orientation = orientation
+        if orientation == 'v':
+            p1 = graphics.Point(HoffSet+column*cellSize,VoffSet+row*cellSize)
+            p2 = graphics.Point(HoffSet+column*cellSize,VoffSet+(row+1)*cellSize)
+        else:
+            p1 = graphics.Point(HoffSet+column*cellSize,VoffSet+row*cellSize)
+            p2 = graphics.Point(HoffSet+(column+1)*cellSize,VoffSet+row*cellSize)
+        self.wallGraphic = graphics.Line(p1, p2)
+        self.refreshWall()
+
+
+    def __repr__(self):
+        if self.edge != False:
+            return str(self.edge)+" edge of the maze"
+        if self.orientation == 'v':
+            s = "Vertical wall between "
+            s += str((self.row, self.column))
+            s += " and "
+            s += str((self.row+1, self.column))
+        else:
+            s = "Horizontal wall between "
+            s += str((self.row, self.column))
+            s += " and "
+            s += str((self.row, self.column+1))
+        return s
+
+    def setWall(self, solid):
+        self.solid = solid
+        self.refreshWall()
+
+    def refreshWall(self):
+        if self.solid and self.edge == False:
+            self.wallGraphic.setOutline("white")
+        elif self.solid:
+            self.wallGraphic.setOutline("red")
+        else:
+            self.wallGraphic.setOutline("black")
+
+class Player:
+
+    def __init__(self, number):
+        self.number = number
+        self.row = None
+        self.maze = None
+        self.column = None
+        self.figure = None
+        self.heading = None
+        self.standing = True
+        self.alive = True
+
+    def __repr__(self):
+        return "Player " + str(self.number)
+
+    def createFigure(self, anchor):
+        if self.heading == None:
+            self.figure = graphics.Circle(anchor,cellSize/2.5)
+            self.figure.setOutline("yellow")
+        else:
+            if self.heading == 'N':
+                p1x = anchor.getX() 
+                p1y = anchor.getY() - cellSize/3.0 
+                p2x = anchor.getX() - cellSize/5.0
+                p2y = anchor.getY() + cellSize/3.0
+                p3x = anchor.getX() + cellSize/5.0
+                p3y = anchor.getY() + cellSize/3.0
+            elif self.heading == 'S':
+                p1x = anchor.getX() 
+                p1y = anchor.getY() + cellSize/3.0 
+                p2x = anchor.getX() - cellSize/5.0
+                p2y = anchor.getY() - cellSize/3.0
+                p3x = anchor.getX() + cellSize/5.0
+                p3y = anchor.getY() - cellSize/3.0
+            elif self.heading == 'E':
+                p1x = anchor.getX() + cellSize/3.0 
+                p1y = anchor.getY()
+                p2x = anchor.getX() - cellSize/3.0
+                p2y = anchor.getY() - cellSize/5.0
+                p3x = anchor.getX() - cellSize/3.0
+                p3y = anchor.getY() + cellSize/5.0
+            elif self.heading == 'W':
+                p1x = anchor.getX() - cellSize/3.0 
+                p1y = anchor.getY()
+                p2x = anchor.getX() + cellSize/3.0
+                p2y = anchor.getY() - cellSize/5.0
+                p3x = anchor.getX() + cellSize/3.0
+                p3y = anchor.getY() + cellSize/5.0
+            p1 = graphics.Point(p1x, p1y)
+            p2 = graphics.Point(p2x, p2y)
+            p3 = graphics.Point(p3x, p3y)
+            self.figure = graphics.Polygon(p1, p2, p3)
+            self.figure.setOutline("yellow")
+
+    def move(self, direction, newHeading):
+        """this function attempts to move the player
+        in the desired direction, and gives them a new
+        heading, it also assumes they are already inserted
+        into the maze"""
+        self.figure.undraw()
+        self.heading = newHeading
+        r = self.row
+        c = self.column
+        if direction == 'N' and not self.maze.Hwalls[r][c].solid:
+            nextPt = self.getAnchor(r-1, c)
+            self.row -= 1
+        elif direction == 'S' and not self.maze.Hwalls[r+1][c].solid:
+            nextPt = self.getAnchor(r+1, c)
+            self.row += 1
+        elif direction == 'W' and not self.maze.Vwalls[r][c].solid:
+            nextPt = self.getAnchor(r, c-1)
+            self.column -= 1
+        elif direction == 'E' and not self.maze.Vwalls[r][c+1].solid:
+            nextPt = self.getAnchor(r, c+1)
+            self.column += 1
+        else:
+            nextPt = self.getAnchor(r, c)
+        self.createFigure(nextPt)
+        self.figure.draw(self.maze.win)
+
+    def shoot(self, direction):
+        """shoots in a direction, marking the death squares
+        red as the shot moves"""
+        r = self.row
+        c = self.column
+        wallCount = 0
+        while True: #not at the end!
+            if direction == 'N':
+                if self.maze.getWall(r,c,'N').solid: wallCount += 1
+                if wallCount > 1: break
+                r -= 1
+                self.maze.cells[r][c].cellGraphic.setFill('red')
+            elif direction == 'W':
+                if self.maze.getWall(r,c,'W').solid: wallCount += 1
+                if wallCount > 1: break
+                c -= 1
+                self.maze.cells[r][c].cellGraphic.setFill('red')
+            elif direction == 'E':
+                if self.maze.getWall(r,c,'E').solid: wallCount += 1
+                if wallCount > 1: break
+                c += 1
+                self.maze.cells[r][c].cellGraphic.setFill('red')
+            elif direction == 'S':
+                if self.maze.getWall(r,c,'S').solid: wallCount += 1
+                if wallCount > 1: break
+                r += 1
+                self.maze.cells[r][c].cellGraphic.setFill('red')
+            time.sleep(0.5)
+            
+
+    def getAnchor(self, row, column):
+        return self.maze.cells[row][column].cellGraphic.getCenter()
+                           
+
+n = "N"
+e = "E"
+w = "W"
+s = "S"
+N = n
+E = e
+W = w
+S = s 
+
+m = Maze(7,8)
+p = Player(1)
+m.insertObj(2,3,p)
+m.setWall(2,3,'v',False)
+m.setWall(2,5,'v',False)
+m.setWall(3,4,'h',False)
+m.setWall(2,1,'v',False)
+m.setWall(1,0,'h',False)
+m.setWall(2,1,'v',False)
+m.setWall(2,3,'v',False)
+m.setWall(2,2,'v',False)
+m.setWall(3,4,'v',False)
+m.setWall(2,0,'h',False)
+m.setWall(3,3,'h',False)
+