井字过三关

jinziqi.py

#coding:utf8
import unittest
import itertools

DEBUG = False

class Jinziqi_core():
    def __init__(self):
        self.player_A = []
        self.player_B = []
        self._chessboard = {1:(0,0), 2:(0,1), 3:(0,2), 4:(1,0), 5:(1,1), 6:(1,2), 7:(2,0), 8:(2,1), 9:(2,2)}
        self.chesses = []
    def exit_jinziqi(self, info):
        who = info
        print "%s is win" % who
        print 'congratulation %s please run the program again' % who
        exit(0)
    def jinziqi_start(self):
        print 'game start, use 1-9 to play'
        flag = 0                # who to play now
        for i in range(1,10):
            while True:
                if i%2 != 0:
                    who = 'player A'
                    flag = 0
                else:
                    who = 'player B'
                    flag = 1
                output_str = 'Now %s, select(%s): ' % (who, self.chesses_total())
                n = input(output_str)
                if self.add_chess(n):
                    if flag == 0:
                        self.player_A.append(n)
                        if self.is_win(self.player_A):
                            self.exit_jinziqi(who)
                        else:
                            break
                    else:
                        self.player_B.append(n)
                        if self.is_win(self.player_B):
                            self.exit_jinziqi(who)
                        else:
                            break
                else:
                    print 'choose the bad chess,do it again'
        print '平手了,重启程序再玩一次'

    def is_win(self, p):
        combinations = self.player_chesses_combinations(p)
        #cb = [self.chessboard(c) for c in combinations] # 有坐标的棋子集合
        for chesses in combinations:
            a = self.chessboard(chesses[0])
            b = self.chessboard(chesses[1])
            c = self.chessboard(chesses[2])
            if self.isline(a, b, c):
                return True
        return False

    def player_chesses_combinations(self, player, c = 3 ):
        return tuple(itertools.combinations(player, c))
    def chesses_total(self):
        a = set(range(1,10))
        b = set(self.chesses)
        return list(a - b)
    def add_chess(self, ch):
        if ch < 1 or ch > 9 :
            return False
        if ch not in (self.chesses):
            self.chesses.append(ch)
            return True
        else:
            return False
    def chessboard(self, t):
        return self._chessboard[t]
    def isline(self, a, b, c):
        if self._isline_x(a,b,c):
            return True
        if self._isline_y(a,b,c):
            return True
        if self._isline_xy_1(a,b,c):
            return True
        if self._isline_xy_2(a,b,c):
            return True
        return False
    def _isline_x(self, a, b, c):
        if a[0] == b[0] :
            if b[0] == c[0]:
                return True
            else:
                return False
        else:
            return False
    def _isline_y(self, a, b, c):
        if a[1] == b[1] :
            if b[1] == c[1]:
                return True
            else:
                return False
        else:
            return False
    def _isline_xy_1(self, a, b, c):
        #y=x
        c = [a,b,c]
        result = True
        for x,y in c:
            if x==y:
                result = True
            else:
                result = False
                break
        return result
    def _isline_xy_2(self, a, b, c):
        #y = 2-x
        c = [a,b,c]
        result = True
        for x,y in c:
            if y == (2-x):
                result = True
            else:
                result = False
                break
        return result

class JinziqiTest(unittest.TestCase):
    def test_player(self):
        '''测试玩家
        '''
        wuziqi_program = Jinziqi_core()
        self.assertEquals([],wuziqi_program.player_A)
        self.assertEquals([],wuziqi_program.player_B)
    def test_coord_range(self):
        '''测试棋子对应的坐标
        '''
        wuziqi_program = Jinziqi_core()
        self.assertTrue((0,0) == wuziqi_program.chessboard(1))
        self.assertTrue((0,1) == wuziqi_program.chessboard(2))
        self.assertTrue((0,2) == wuziqi_program.chessboard(3))
        self.assertTrue((1,0) == wuziqi_program.chessboard(4))
        self.assertTrue((1,1) == wuziqi_program.chessboard(5))
        self.assertTrue((1,2) == wuziqi_program.chessboard(6))
        self.assertTrue((2,0) == wuziqi_program.chessboard(7))
        self.assertTrue((2,1) == wuziqi_program.chessboard(8))
        self.assertTrue((2,2) == wuziqi_program.chessboard(9))
    def test_line_x(self):
        '''测试坐标是否符合一条横直线
        '''
        wuziqi_program = Jinziqi_core()
        a = wuziqi_program.chessboard(1)
        b = wuziqi_program.chessboard(2)
        c = wuziqi_program.chessboard(3)
        self.assertTrue(wuziqi_program.isline(a, b, c))
        a = wuziqi_program.chessboard(1)
        b = wuziqi_program.chessboard(8)
        c = wuziqi_program.chessboard(3)
        self.assertFalse(wuziqi_program.isline(a, b, c))
    def test_line_y(self):
        '''测试坐标是否符合一条纵直线
        '''
        wuziqi_program = Jinziqi_core()
        a = wuziqi_program.chessboard(1)
        b = wuziqi_program.chessboard(4)
        c = wuziqi_program.chessboard(7)
        self.assertTrue(wuziqi_program.isline(a, b, c))
    def test_line_xy(self):
        '''测试方程y=x和y=2-x两条直线
        '''
        wuziqi_program = Jinziqi_core()
        a = wuziqi_program.chessboard(1)
        b = wuziqi_program.chessboard(5)
        c = wuziqi_program.chessboard(9)
        self.assertTrue(wuziqi_program.isline(a, b, c))
        a = wuziqi_program.chessboard(7)
        b = wuziqi_program.chessboard(5)
        c = wuziqi_program.chessboard(3)
        self.assertTrue(wuziqi_program.isline(a, b, c))
    def test_chess_exists(self):
        '''
        '''
        wuziqi_program = Jinziqi_core()
        self.assertTrue(wuziqi_program.add_chess(1))
        self.assertTrue(wuziqi_program.add_chess(2))
        self.assertFalse(wuziqi_program.add_chess(1))
    def test_chess_range(self):
        '''测试棋盘中可用的位置
        '''
        wuziqi_program = Jinziqi_core()
        self.assertFalse(wuziqi_program.add_chess(10))
        self.assertFalse(wuziqi_program.add_chess(0))
        self.assertFalse(wuziqi_program.add_chess(-1))
    def test_chess_total(self):
        '''测试棋盘中剩余的空格
        '''
        wuziqi_program = Jinziqi_core()
        wuziqi_program.add_chess(9)
        wuziqi_program.add_chess(8)
        self.assertTrue([1,2,3,4,5,6,7] == wuziqi_program.chesses_total())
    def test_chesses_combinations(self):
        '''测试棋子的组合
        '''
        wuziqi_program = Jinziqi_core()
        a = wuziqi_program.player_chesses_combinations([1,2,3,4,5])
        b = tuple(itertools.combinations([1,2,3,4,5], 3))
        self.assertTrue(b == a)
    def test_win(self):
        '''测试检测获胜的判断
        '''
        wuziqi_program = Jinziqi_core()
        self.assertTrue(wuziqi_program.is_win([1,2,3,7,8]))
        self.assertTrue(wuziqi_program.is_win([7,8,9,5]))
        self.assertFalse(wuziqi_program.is_win([1,2,7,8]))

if __name__ == '__main__':
    if DEBUG:
        unittest.main()
    else:
        wuziqi_program = Jinziqi_core()
        wuziqi_program.jinziqi_start()