Board.py

import copy

class Board:
    """
    Provides the 4x4x4 board for the game, holds all moves,
    can be used for lookahead
    """

    # constructor
    def __init__(self):
        """ Creates original Board """
        self.b = [[[0 for i in range(4)] for j in range(4)] for k in range(4)]

        self.currentLines = {}
        for playerNum in [1, 2]:
            for numPoints in [1, 2, 3, 4]:
                self.currentLines[(playerNum, numPoints)] = set()

        self.currentLines[0] = set()
        for i in range(76):
            self.currentLines[0].add(i)

        self.moveList = []

        self.pointsList = {}
        for playerNum in [0, 1, 2]:
            self.pointsList[playerNum] = set()
        for i in range(4):
            for j in range(4):
                for k in range(4):
                    self.pointsList[0].add((i, j, k))

    # make, check and clear moves
    def copyAll(self, b):
        """ copies the given board object into self.b """

        self.currentLines = copy.deepcopy(b.currentLines)
        self.moveList = copy.deepcopy(b.moveList)
        self.pointsList = copy.deepcopy(b.pointsList)

        for x in range(4):
            for y in range(4):
                for z in range(4):
                    self.b[x][y][z] = b.b[x][y][z]

    def openPoints(self):
        """
        Return a list of all open points on the board
        """
        return self.pointsList[0]

    def myPoints(self, n):
        """
        Return a list of all points player n has on the board
        """
        return self.pointsList[n]

    def otherNumber(self, n):
        """
        Returns the other player's number
        """

        newN = 0
        if n == 1:
            newN = 2
        elif n == 2:
            newN = 1
        return newN

    def numMoves(self, n):
        """ Finds how many moves have been made by each player """

        o = self.otherNumber(n)
        return [len(self.pointsList[n]), len(self.pointsList[o])]

    def move(self, n, p):
        """ moves player n at point p, returns false if blocked """

        current = self.pointToValue(p)
        if (current == 0):
            self.b[p[0]][p[1]][p[2]] = n
            self.moveList.append((p, n))
            self.updateLines(n, p)
            self.pointsList[0].remove(p)
            self.pointsList[n].add(p)
            return True
        else:
            return False

    def clearPoint(self, p):
            """ clears a move, returns the previous value there
            WARNING: THIS FUNCTION CURRENTLY DOES NOT UDPATE LINES
            """

            previous = self.b[p[0]][p[1]][p[2]]
            self.b[p[0]][p[1]][p[2]] = 0

            if previous != 0:
                self.moveList.remove((p, previous))
                self.pointsList[0].add(p)
                self.pointsList[previous].remove(p)
                self.updateLines(previous, p)
            return previous

    def updateLines(self, n, p):
        """ updates the important lines after each move"""
        o = self.otherNumber(n)

        for line in self.linesForPoint(p):
            values = self.lineToValues(line)
            playerMoves = values.count(n)
            otherMoves = values.count(o)
            # print line, playerMoves, otherMoves

            # if we just removed a point (it's currently 0)
            if self.pointToValue(p) == 0:
                if otherMoves == 0 and playerMoves == 0:
                    self.currentLines[0].add(line)
                    self.currentLines[(n, 1)].remove(line)
                elif otherMoves == 0:
                    self.currentLines[(n, playerMoves+1)].remove(line)
                    self.currentLines[(n, playerMoves)].add(line)
                elif playerMoves == 0:
                    self.currentLines[(o, otherMoves)].add(line)
            # Otherwise we just added a point, and update accordingly
            else:
                if playerMoves == 1 and otherMoves == 0:
                    self.currentLines[0].remove(line)
                    self.currentLines[(n, 1)].add(line)
                elif playerMoves == 1:
                    self.currentLines[(o, otherMoves)].remove(line)
                elif otherMoves == 0:
                    self.currentLines[(n, playerMoves-1)].remove(line)
                    self.currentLines[(n, playerMoves)].add(line)

    # Find lines
    def findLines(self, n, num):
        """ old find lines but faster """
        return self.currentLines[(n, num)]

    # Point/Line conversions
    def lineToPoints(self, line):
        """
        Given a line number, this will return the set of four
        points that make up that line, listed by x, y, and z
        """
        if (0 <= line and line < 16):
            return self.rowsToPoints(line)
        elif (16 <= line and line < 32):
            return self.colsToPoints(line)
        elif (32 <= line and line < 48):
            return self.vrtsToPoints(line)
        elif (48 <= line and line < 76):
            return self.diasToPoints(line)
        else:
            return []

    def rowsToPoints(self, line):
        """
        Given a line number between 0 and 15, this will return the
        set of four points that make up that line, listed by x, y, and z
        """
        l = line
        z = l % 4
        y = (l-z)/4
        return [(i, y, z) for i in range(4)]

    def colsToPoints(self, line):
        """
        Given a line number between 16 and 31, this will return the
        set of four points that make up that line, listed by x, y, and z
        """
        l = line - 16
        x = l % 4
        z = (l-x)/4
        return [(x, i, z) for i in range(4)]

    def vrtsToPoints(self, line):
        """
        Given a line number between 32 and 47, this will return the
        set of four points that make up that line, listed by x, y, and z
        """
        l = line - 32
        y = l % 4
        x = (l-y)/4
        return [(x, y, i) for i in range(4)]

    def diasToPoints(self, line):
        """
        Given a line number between 48 and 75, this will return the
        set of four points that make up that line, listed by x, y, and z
        """
        if (48 <= line and line < 52):
            l = line - 48
            x = l % 4
            return [(x, i, i) for i in range(4)]
        if (52 <= line and line < 56):
            l = line - 52
            x = l % 4
            return [(x, i, 3-i) for i in range(4)]
        if (56 <= line and line < 60):
            l = line - 56
            y = l % 4
            return [(i, y, i) for i in range(4)]
        if (60 <= line and line < 64):
            l = line - 60
            y = l % 4
            return [(i, y, 3-i) for i in range(4)]
        if (64 <= line and line < 68):
            l = line - 64
            z = l % 4
            return [(i, i, z) for i in range(4)]
        if (68 <= line and line < 72):
            l = line - 68
            z = l % 4
            return [(i, 3-i, z) for i in range(4)]
        if (line == 72):
            return [(i, i, i) for i in range(4)]
        if (line == 73):
            return [(i, i, 3-i) for i in range(4)]
        if (line == 74):
            return [(i, 3-i, i) for i in range(4)]
        if (line == 75):
            return [(3-i, i, i) for i in range(4)]

    def pointsToLine(self, p1, p2):
        """
        Given two points, this will return their line number
        if they're in a line, and -1 if they are not
        """

        line = -1

        # make sure points are valid
        for p in p1, p2:
            for v in p:
                if (v < 0 or v > 3):
                    return line

        # see if they have the same x
        if (p1[0] == p2[0]):
            # see if they have the same y
            if (p1[1] == p2[1]):
                # must be vertical
                if (p1[2] != p2[2]):
                    line = 32 + 4*p1[0] + p1[1]
            # see if they have the same z
            elif (p1[2] == p2[2]):
                # must be in y dir
                line = 16 + 4*p1[2] + p1[0]
            # if both y and z change it must be diagonal
            # see if it's coming from 0,0 or 0,3
            elif (p1[1] == p1[2]):
                # should be coming from 0,0; check
                if (p2[1] == p2[2]):
                    line = 48 + p1[0]
            elif (p1[1] == 3 - p1[2]):
                # should be coming from 0,0; check
                if (p2[1] == 3-p2[2]):
                    line = 52 + p1[0]
        # see if they have the same y
        elif (p1[1] == p2[1]):
            # see if they have the same z
            if (p1[2] == p2[2]):
                # must be in x dir
                line = 4*p1[1] + p1[2]
            # if both x and z change it must be diagonal
            # see if it's coming from 0,0 or 0,3
            elif (p1[0] == p1[2]):
                # should be coming from 0,0; check
                if (p2[0] == p2[2]):
                    line = 56 + p1[1]
            elif (p1[0] == 3 - p1[2]):
                # should be coming from 0,0; check
                if (p2[0] == 3-p2[2]):
                    line = 60 + p1[1]
        # see if they have the same z
        elif (p1[2] == p2[2]):
            # if both x and y change it must be diagonal
            # see if it's coming from 0,0 or 0,3
            if (p1[0] == p1[1]):
                # should be coming from 0,0; check
                if (p2[0] == p2[1]):
                    line = 64 + p1[2]
            elif (p1[0] == 3 - p1[1]):
                # should be coming from 0,0; check
                if (p2[0] == 3-p2[1]):
                    line = 68 + p1[2]
        # if all change, must be on a main diagonal
        # diagnoal 1
        elif (p1[0] == p1[1] and p1[0] == p1[2]):
            # check p2
            if (p2[0] == p2[1] and p2[0] == p2[2]):
                line = 72
        # diagonal 2
        elif (p1[0] == p1[1] and p1[0] == 3 - p1[2]):
            # check p2
            if (p2[0] == p2[1] and p2[0] == 3 - p2[2]):
                line = 73
        # diagonal 3
        elif (p1[0] == 3 - p1[1] and p1[0] == p1[2]):
            # check p2
            if (p2[0] == 3 - p2[1] and p2[0] == p2[2]):
                line = 74
        # diagonal 4
        elif (p1[0] == 3 - p1[1] and p1[0] == 3 - p1[2]):
            # check p2
            if (p2[0] == 3 - p2[1] and p2[0] == 3 - p2[2]):
                line = 75

        return line

    # Searching specific lines
    def lineToValues(self, line):
        """
        Given a line number, this will return the value of all
        four points in a list
        """
        values = []
        points = self.lineToPoints(line)
        for p in points:
            current = self.b[p[0]][p[1]][p[2]]
            values += [current]
        return values

    # finding force moves
    def findForces(self, n):
        """
        Returns pairs of forcing moves
        """
        pairs = []

        lines = self.findLines(n, 2)

        for l in lines:
            currentPair = []
            points = self.lineToPoints(l)
            for p in points:
                if self.pointToValue(p) == 0:
                    currentPair += [p]
            pairs += [currentPair]
        return pairs

    def linesForPoint(self, p):
        """
        Returns a list of all the line numbers passing through point p
        """
        i = p[0]
        j = p[1]
        k = p[2]

        lines = []
        lines += [4*j + k]
        lines += [16 + 4*k + i]
        lines += [32 + 4*i + j]

        if j == k:
            lines += [48 + i]
        if j == 3 - k:
            lines += [52 + i]
        if i == k:
            lines += [56 + j]
        if i == 3 - k:
            lines += [60 + j]
        if j == i:
            lines += [64 + k]
        if j == 3 - i:
            lines += [68 + k]
        if i == j and i == k:
            lines += [72]
        if i == j and i == 3 - k:
            lines += [73]
        if i == k and i == 3 - j:
            lines += [74]
        if j == k and i == 3 - j:
            lines += [75]

        return lines

    def openLinesForPoint(self, n, p, num):
        """
        Returns a list of all the line numbers of lines passing through
        point p, with no non n moves and num moves by player n
        """

        otherN = self.otherNumber(n)
        lines = self.linesForPoint(p)
        openLines = []
        for l in lines:
            blocked = False
            values = self.lineToValues(l)
            p1 = 0
            for v in values:
                if (v == otherN):
                    blocked = True
                    break
                elif (v == n):
                    p1 += 1
            if (p1 == num and not blocked):
                openLines += [l]
        return openLines

    def pointToValue(self, p):
        """ convert a single point to a value """
        return self.b[p[0]][p[1]][p[2]]

    def hash(self):
        """ this is bad and gross. probably fix later"""
        return sum(
            [2**i * (self.b[i % 4][(i/4) % 4][i/16]-1) for i in range(64)])