FM / turtle

/usr/lib64/python2.7/Demo/turtle

Name	Size	Mode	Actions
about_turtle.txt	3525	0644	edit dl rm
about_turtledemo.txt	302	0644	edit dl rm
demohelp.txt	3034	0644	edit dl rm
tdemo_bytedesign.py	4218	0755	edit dl rm
tdemo_bytedesign.pyc	5313	0644	edit dl rm
tdemo_bytedesign.pyo	5313	0644	edit dl rm
tdemo_chaos.py	951	0644	edit dl rm
tdemo_chaos.pyc	2296	0644	edit dl rm
tdemo_chaos.pyo	2296	0644	edit dl rm
tdemo_clock.py	3219	0755	edit dl rm
tdemo_clock.pyc	4535	0644	edit dl rm
tdemo_clock.pyo	4535	0644	edit dl rm
tdemo_colormixer.py	1338	0644	edit dl rm
tdemo_colormixer.pyc	2365	0644	edit dl rm
tdemo_colormixer.pyo	2365	0644	edit dl rm
tdemo_fractalcurves.py	3409	0755	edit dl rm
tdemo_fractalcurves.pyc	3524	0644	edit dl rm
tdemo_fractalcurves.pyo	3524	0644	edit dl rm
tdemo_I_dontlike_tiltdemo.py	1073	0755	edit dl rm
tdemo_I_dontlike_tiltdemo.pyc	1660	0644	edit dl rm
tdemo_I_dontlike_tiltdemo.pyo	1660	0644	edit dl rm
tdemo_lindenmayer_indian.py	2432	0755	edit dl rm
tdemo_lindenmayer_indian.pyc	3602	0644	edit dl rm
tdemo_lindenmayer_indian.pyo	3602	0644	edit dl rm
tdemo_minimal_hanoi.py	2049	0755	edit dl rm
tdemo_minimal_hanoi.pyc	3623	0644	edit dl rm
tdemo_minimal_hanoi.pyo	3623	0644	edit dl rm
tdemo_nim.py	6514	0644	edit dl rm
tdemo_nim.pyc	9384	0644	edit dl rm
tdemo_nim.pyo	9384	0644	edit dl rm
tdemo_paint.py	1289	0755	edit dl rm
tdemo_paint.pyc	1901	0644	edit dl rm
tdemo_paint.pyo	1901	0644	edit dl rm
tdemo_peace.py	1065	0755	edit dl rm
tdemo_peace.pyc	1388	0644	edit dl rm
tdemo_peace.pyo	1388	0644	edit dl rm
tdemo_penrose.py	3535	0755	edit dl rm
tdemo_penrose.pyc	6005	0644	edit dl rm
tdemo_penrose.pyo	6005	0644	edit dl rm
tdemo_planet_and_moon.py	2823	0755	edit dl rm
tdemo_planet_and_moon.pyc	4535	0644	edit dl rm
tdemo_planet_and_moon.pyo	4535	0644	edit dl rm
tdemo_tree.py	1410	0755	edit dl rm
tdemo_tree.pyc	2123	0644	edit dl rm
tdemo_tree.pyo	2123	0644	edit dl rm
tdemo_two_canvases.py	1120	0644	edit dl rm
tdemo_two_canvases.pyc	1635	0644	edit dl rm
tdemo_two_canvases.pyo	1635	0644	edit dl rm
tdemo_wikipedia.py	1347	0644	edit dl rm
tdemo_wikipedia.pyc	1955	0644	edit dl rm
tdemo_wikipedia.pyo	1955	0644	edit dl rm
tdemo_yinyang.py	807	0755	edit dl rm
tdemo_yinyang.pyc	1320	0644	edit dl rm
tdemo_yinyang.pyo	1320	0644	edit dl rm
turtle.cfg	160	0644	edit dl rm
turtleDemo.py	10091	0755	edit dl rm
turtleDemo.pyc	10948	0644	edit dl rm
turtleDemo.pyo	10948	0644	edit dl rm

Edit: /usr/lib64/python2.7/Demo/turtle/tdemo_nim.py (6514B)

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

cmd: