| """ 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() |