Advertisement
kernel_memory_dump

Ana

Jul 10th, 2014
282
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 5.77 KB | None | 0 0
  1.  
  2.  
  3.  
  4. class TreeNode(object):
  5.  
  6.  
  7.  
  8.     def __init__(self, data, sign="O"):
  9.         self._data = data
  10.         self.parent = None
  11.         self.children = []
  12.         if self.get_score("X", "O") == 0:
  13.             for x in range(len(self._data)):
  14.                 if self._data[x] == " ":
  15.                     if sign == "X":
  16.                         nextSign = "O"
  17.                     else:
  18.                         nextSign = "X"
  19.                     l = list(self._data)
  20.                     l[x] = nextSign
  21.                     temp = TreeNode(l, nextSign)
  22.                     self.add_child(temp)
  23.  
  24.     def __getitem__(self, key):
  25.         return self._data[key]
  26.  
  27.     def __setitem__(self, key, value):
  28.         self._data[key] = value
  29.  
  30.     def is_root(self):
  31.         return self.parent is None
  32.  
  33.     def is_leaf(self):
  34.         return len(self.children) == 0
  35.  
  36.     def add_child(self, n):
  37.         n.parent = self
  38.         self.children.append(n)
  39.  
  40.     def get_score(self, signComputer, signPlayer):
  41.         threes = [[self._data[0], self._data[1], self._data[2]],
  42.                   [self._data[3], self._data[4], self._data[5]],
  43.                   [self._data[6], self._data[7], self._data[8]],
  44.                   [self._data[0], self._data[3], self._data[6]],
  45.                   [self._data[1], self._data[4], self._data[7]],
  46.                   [self._data[2], self._data[5], self._data[8]],
  47.                   [self._data[0], self._data[4], self._data[8]],
  48.                   [self._data[2], self._data[4], self._data[6]]]
  49.         for x in threes:
  50.             if x.count(signComputer) == 3:
  51.                 return 1
  52.             elif x.count(signPlayer) == 3:
  53.                 return -1
  54.         return 0
  55.  
  56.     def get_children_value(self, signComputer, signPlayer, depth=1):
  57.         if self.get_score(signComputer, signPlayer) != 0:
  58.             return self.get_score(signComputer, signPlayer)
  59.         else:
  60.             suma = None
  61.             suma2 = self.get_score(signComputer, signPlayer)
  62.             if suma == None or suma2 > suma:
  63.                     suma = suma2
  64.             return suma
  65.  
  66.  
  67. class Tree(object):
  68.  
  69.     def drawBoard(self):
  70.         board = self.root._data
  71.         f = open ('log.txt', 'a')
  72.         f.write("#######\n")
  73.         f.write('   |   |')
  74.         f.write(' ' + board[0] + ' | ' + board[1] + ' | ' + board[2])
  75.         f.write('   |   |')
  76.         f.write('-----------\n')
  77.         f.write('   |   |')
  78.         f.write(' ' + board[3] + ' | ' + board[4] + ' | ' + board[5])
  79.         f.write('   |   |')
  80.         f.write('-----------\n')
  81.         f.write('   |   |')
  82.         f.write(' ' + board[6] + ' | ' + board[7] + ' | ' + board[8])
  83.         f.write('   |   |')
  84.         f.write("\n")
  85.         f.close()
  86.  
  87.     """docstring for Tree"""
  88.     def __init__(self, signComputer, signPlayer):
  89.         self.root = TreeNode([" ", " ", " ", " ", " ", " ", " ", " ", " "])
  90.         self.signComputer = signComputer
  91.         self.signPlayer = signPlayer
  92.         self.end = False
  93.         self.win = 0
  94.  
  95.         self.lastMove = []
  96.  
  97.  
  98.     def is_empty(self):
  99.         return self.root is None
  100.  
  101.     def depth(self, n):
  102.         if self.is_root():
  103.             return 0
  104.         else:
  105.             return 1 + self.depth(n.parent)
  106.  
  107.     def height(self, n):
  108.         if self.is_root is None:
  109.             return 0
  110.         else:
  111.             return 1 + max(self.height(c) for c in n.children)
  112.  
  113.     def postorder(self, n):
  114.         if not self.is_empty():
  115.             for c in n.children:
  116.                 self.postorder(c)
  117.             print n._data
  118.  
  119.     def preorder(self, n):
  120.         if not self.is_empty():
  121.             print n._data
  122.             for c in n.children:
  123.                 self.preorder(c)
  124.  
  125.     def checkEnd(self):
  126.         full = True
  127.         if self.root._data.count(" ") > 0:
  128.             full = False
  129.         if full:
  130.             self.end = True
  131.         if self.root.get_score(self.signComputer, self.signPlayer) != 0:
  132.             self.end = True
  133.  
  134.     def movePlayer(self, pozicija):
  135.         self.root[pozicija] = self.signPlayer
  136.         for child in self.root.children:
  137.             if self.root._data == child._data:
  138.                 self.root = child
  139.                 break
  140.         self.checkEnd()
  141.  
  142.     def cancelLastMove(self):
  143.         #while self.lastMove:
  144.         self.root = self.lastMove.pop()
  145.  
  146.     def playNextMove(self):
  147.         self.lastMove.append(self.root)
  148.  
  149.     def moveOpponent (self):
  150.         best = self.root
  151.         maxScore = None
  152.         score = None
  153.         root = self.root
  154.  
  155.         for child in root.children:
  156.             self.checkEnd()
  157.             if self.end:
  158.                 self.root = best
  159.                 return
  160.             else:
  161.                 #self.drawBoard()
  162.                 self.playNextMove()
  163.                 self.root = child
  164.                 #self.drawBoard()
  165.                 self.moveComputer()
  166.                 score = self.root.get_score(self.signPlayer, self.signComputer)
  167.                 self.cancelLastMove()
  168.             if maxScore == None or score < maxScore:
  169.                 maxScore = score
  170.                 best = child
  171.  
  172.         self.root = best
  173.  
  174.  
  175.     def moveComputer(self):
  176.         best = self.root
  177.         maxScore = None
  178.         score = None
  179.         root = self.root
  180.  
  181.         for child in root.children:
  182.  
  183.             self.checkEnd()
  184.             if self.end:
  185.                 self.root = best
  186.                 return
  187.             else:
  188.                 self.playNextMove()
  189.                 #self.drawBoard()
  190.                 self.moveOpponent()
  191.                 score = self.root.get_score(self.signComputer, self.signPlayer)
  192.                 self.cancelLastMove()
  193.             if maxScore == None or score > maxScore:
  194.                 maxScore = score
  195.                 best = child
  196.  
  197.  
  198.         self.root = best
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement