import os

import logging

import json

logging.basicConfig(format='%(asctime)s %(levelname)s: %(message)s', level=logging.DEBUG)

	cfgFile=json.load(f)

class misc:

	file=cfgFile["misc"]

	version=(0,0,0)

	defaultImage=file.get("defaultImage", 0)

class gui:

	file=cfgFile["gui"]

	showBigPoints=file.get("showBigPoints", False)

	showGrid=file.get("showGrid", True)

class Core:

	def __init__(self):

		self.grid=None

		self.go=Go()

		self.detector=ImageAnalyzer()

		self.states=StateBag()

		self._ownMessages=MsgQueue(self._handleEvent)

		self._guiMessages=MsgQueue()

		self._imgIndex=cfg.misc.defaultImage

		self._frame=PIL.Image.open(imgPath)

		self._guiProc=multiprocessing.Process(name="gui", target=gui, args=(self._guiMessages,self._ownMessages))

		self._guiProc.start()

		self.relativeFrame(0)

	def setCorners(self,corners):

		self.detector.setGridCorners(corners)

		self.analyze()

	def setTresholds(self,tresB=None,tresW=None):

		if tresB is not None: self.detector.tresB=tresB

		if tresW is not None: self.detector.tresW=tresW

		self.analyze()

	def relativeFrame(self,step):

		self._imgIndex=(self._imgIndex+step)%len(self._imgs)

		self._frame=PIL.Image.open(imgPath)

		self._guiMessages.send("setCurrentFrame",(self._frame.copy(),))

		self.analyze()

	def analyze(self):

		if self.detector.analyze(self._frame):

			if isLegalPosition(self.detector.board):

				self.states.pushState(self.detector.board)

				self._guiMessages.send("setGameState",(self.detector.board,))

				self.go.transitionMove(self.detector.board)

			else:

				log.info("illegal position detected")

	def listen(self):

		listenerThread=threading.Thread(target=lambda: self._ownMessages.listen())

		listenerThread.start()

	def joinGui(self):

		self._guiProc.join()

		self._ownMessages.send("!kill")

	def _handleEvent(self,e):

class Point:

	def __init__(self,c,r):

		self.r=r

		self.c=c

	def __iter__(self):

		yield self.c

		yield self.r

	def __str__(self):

import logging as log

from gamerecord import GameRecord

class Go:

	## Initializes self.board to a list[r][c]=EMPTY.

	def __init__(self,boardSize=19):

		self.boardSize=boardSize

		self.board=[[EMPTY]*boardSize for x in range(boardSize)]

		self._temp=[[EMPTY]*boardSize for x in range(boardSize)]

		self.toMove=BLACK

		self._record=GameRecord()

	## Executes a move.

	#

	#  Doesn't check for kos. Suicide not allowed.

	#

	#  @param color BLACK or WHITE

	#  @return True on success, False on failure (illegal move)

	def move(self,color,row,col):

		if self.board[row][col]!=EMPTY: return False

		self.board[row][col]=color

		# capture neighbors

		for r,c in ((-1,0),(1,0),(0,-1),(0,1)):

			self._clearTemp()

			if not self._floodFill(-color,row+r,col+c): self._remove()

		# check for suicide

		self._clearTemp()

		if not self._floodFill(color,row,col):

import multiprocessing

import logging as log

class MsgQueue:

	def __init__(self,handler=None):

		self._queue=multiprocessing.Queue()

		self._event=multiprocessing.Event()

		self._handleEvent=handler

	def send(self,actionName,args=tuple(),kwargs=None):

		if kwargs is None: kwargs=dict()

		self._queue.put((actionName,args,kwargs))

		self._event.set()

	def listen(self,handleEvent=None):