""" turtle-example-suite:

 tdemo_nim.py

Play nim against the computer. The player
who takes the last stick is the winner.

Implements the model-view-controller
design pattern.
"""


import turtle
import random
import time

SCREENWIDTH = 640
SCREENHEIGHT = 480

MINSTICKS = 7
MAXSTICKS = 31

HUNIT = SCREENHEIGHT // 12
WUNIT = SCREENWIDTH // ((MAXSTICKS // 5) * 11 + (MAXSTICKS % 5) * 2)

SCOLOR = (63, 63, 31)
HCOLOR = (255, 204, 204)
COLOR = (204, 204, 255)

def randomrow():
 return random.randint(MINSTICKS, MAXSTICKS)

def computerzug(state):
 xored = state[0] ^ state[1] ^ state[2]
 if xored == 0:
 return randommove(state)
 for z in range(3):
 s = state[z] ^ xored
 if s <= state[z]:
 move = (z, s)
 return move

def randommove(state):
 m = max(state)
 while True:
 z = random.randint(0,2)
 if state[z] > (m > 1):
 break
 rand = random.randint(m > 1, state[z]-1)
 return z, rand


class NimModel(object):
 def __init__(self, game):
 self.game = game

 def setup(self):
 if self.game.state not in [Nim.CREATED, Nim.OVER]:
 return
 self.sticks = [randomrow(), randomrow(), randomrow()]
 self.player = 0
 self.winner = None
 self.game.view.setup()
 self.game.state = Nim.RUNNING

 def move(self, row, col):
 maxspalte = self.sticks[row]
 self.sticks[row] = col
 self.game.view.notify_move(row, col, maxspalte, self.player)
 if self.game_over():
 self.game.state = Nim.OVER
 self.winner = self.player
 self.game.view.notify_over()
 elif self.player == 0:
 self.player = 1
 row, col = computerzug(self.sticks)
 self.move(row, col)
 self.player = 0

 def game_over(self):
 return self.sticks == [0, 0, 0]

 def notify_move(self, row, col):
 if self.sticks[row] <= col:
 return
 self.move(row, col)


class Stick(turtle.Turtle):
 def __init__(self, row, col, game):
 turtle.Turtle.__init__(self, visible=False)
 self.row = row
 self.col = col
 self.game = game
 x, y = self.coords(row, col)
 self.shape("square")
 self.shapesize(HUNIT/10.0, WUNIT/20.0)
 self.speed(0)
 self.pu()
 self.goto(x,y)
 self.color("white")
 self.showturtle()

 def coords(self, row, col):
 packet, remainder = divmod(col, 5)
 x = (3 + 11 * packet + 2 * remainder) * WUNIT
 y = (2 + 3 * row) * HUNIT
 return x - SCREENWIDTH // 2 + WUNIT // 2, SCREENHEIGHT // 2 - y - HUNIT // 2

 def makemove(self, x, y):
 if self.game.state != Nim.RUNNING:
 return
 self.game.controller.notify_move(self.row, self.col)


class NimView(object):
 def __init__(self, game):
 self.game = game
 self.screen = game.screen
 self.model = game.model
 self.screen.colormode(255)
 self.screen.tracer(False)
 self.screen.bgcolor((240, 240, 255))
 self.writer = turtle.Turtle(visible=False)
 self.writer.pu()
 self.writer.speed(0)
 self.sticks = {}
 for row in range(3):
 for col in range(MAXSTICKS):
 self.sticks[(row, col)] = Stick(row, col, game)
 self.display("... a moment please ...")
 self.screen.tracer(True)

 def display(self, msg1, msg2=None):
 self.screen.tracer(False)
 self.writer.clear()
 if msg2 is not None:
 self.writer.goto(0, - SCREENHEIGHT // 2 + 48)
 self.writer.pencolor("red")
 self.writer.write(msg2, align="center", font=("Courier",18,"bold"))
 self.writer.goto(0, - SCREENHEIGHT // 2 + 20)
 self.writer.pencolor("black")
 self.writer.write(msg1, align="center", font=("Courier",14,"bold"))
 self.screen.tracer(True)

 def setup(self):
 self.screen.tracer(False)
 for row in range(3):
 for col in range(self.model.sticks[row]):
 self.sticks[(row, col)].color(SCOLOR)
 for row in range(3):
 for col in range(self.model.sticks[row], MAXSTICKS):
 self.sticks[(row, col)].color("white")
 self.display("Your turn! Click leftmost stick to remove.")
 self.screen.tracer(True)

 def notify_move(self, row, col, maxspalte, player):
 if player == 0:
 farbe = HCOLOR
 for s in range(col, maxspalte):
 self.sticks[(row, s)].color(farbe)
 else:
 self.display(" ... thinking ... ")
 time.sleep(0.5)
 self.display(" ... thinking ... aaah ...")
 farbe = COLOR
 for s in range(maxspalte-1, col-1, -1):
 time.sleep(0.2)
 self.sticks[(row, s)].color(farbe)
 self.display("Your turn! Click leftmost stick to remove.")

 def notify_over(self):
 if self.game.model.winner == 0:
 msg2 = "Congrats. You're the winner!!!"
 else:
 msg2 = "Sorry, the computer is the winner."
 self.display("To play again press space bar. To leave press ESC.", msg2)

 def clear(self):
 if self.game.state == Nim.OVER:
 self.screen.clear()


class NimController(object):

 def __init__(self, game):
 self.game = game
 self.sticks = game.view.sticks
 self.BUSY = False
 for stick in self.sticks.values():
 stick.onclick(stick.makemove)
 self.game.screen.onkey(self.game.model.setup, "space")
 self.game.screen.onkey(self.game.view.clear, "Escape")
 self.game.view.display("Press space bar to start game")
 self.game.screen.listen()

 def notify_move(self, row, col):
 if self.BUSY:
 return
 self.BUSY = True
 self.game.model.notify_move(row, col)
 self.BUSY = False


class Nim(object):
 CREATED = 0
 RUNNING = 1
 OVER = 2
 def __init__(self, screen):
 self.state = Nim.CREATED
 self.screen = screen
 self.model = NimModel(self)
 self.view = NimView(self)
 self.controller = NimController(self)


def main():
 mainscreen = turtle.Screen()
 mainscreen.mode("standard")
 mainscreen.setup(SCREENWIDTH, SCREENHEIGHT)
 nim = Nim(mainscreen)
 return "EVENTLOOP"

if __name__ == "__main__":
 main()
 turtle.mainloop()