🦎 Animals that move by themselves · สัตว์ที่ขยับเองได้ · 自己会动的动物

1 A dot on a leash · จุดที่ผูกสายจูง · 拴着绳子的点

💻 RUN IT

python leash.py

📄 NEW FILE · leash.py

"""leash.py - a dot on a leash.

    python leash.py

Move the mouse over the window. The white dot goes where the mouse goes.
The orange dot must stay LEASH pixels away from it, so it gets pulled along.
"""
import math
import tkinter as tk

WIDE = 800           # the window, in pixels
HIGH = 600
LEASH = 120          # how far the orange dot stays from the white dot
WATER = "#12263a"    # the colour behind everything


def pull(anchor, point, gap):
    """Give back the place that is gap pixels from anchor, on the way to point."""
    far = math.dist(anchor, point)      # how far apart the two are now
    if far == 0:
        # The same place: there is no direction, and gap / 0 would crash.
        return point
    scale = gap / far                   # 0.5 means "come half as far"
    x = anchor[0] + (point[0] - anchor[0]) * scale
    y = anchor[1] + (point[1] - anchor[1]) * scale
    return [x, y]


class Leash:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("leash")
        self.canvas = tk.Canvas(self.root, width=WIDE, height=HIGH, bg=WATER)
        self.canvas.pack()
        # Every time the mouse moves over the canvas, tkinter calls mouse_moved.
        self.canvas.bind("<Motion>", self.mouse_moved)
        self.anchor = [WIDE / 2, HIGH / 2]
        self.dot = [WIDE / 2 + LEASH, HIGH / 2]

    def mouse_moved(self, event):
        self.anchor = [event.x, event.y]

    def circle(self, centre, radius, fill, rim):
        x, y = centre
        # An oval is given by the box around it: left, top, right, bottom.
        box = [x - radius, y - radius, x + radius, y + radius]
        self.canvas.create_oval(box, fill=fill, outline=rim, width=2)

    def draw(self):
        self.canvas.delete("all")                         # wipe the last picture
        self.circle(self.anchor, LEASH, "", "#3d5a80")    # "" is no fill: a ring
        self.canvas.create_line(self.anchor, self.dot, fill="#3d5a80", width=2)
        self.circle(self.anchor, 7, "white", "white")
        self.circle(self.dot, 12, "#ee6c4d", "white")

    def frame(self):
        self.dot = pull(self.anchor, self.dot, LEASH)
        self.draw()
        # Ask tkinter to call frame again in 16 ms, so the picture keeps changing.
        self.root.after(16, self.frame)

    def run(self):
        self.frame()
        self.root.mainloop()


def main():
    leash = Leash()
    leash.run()


if __name__ == "__main__":
    main()

2 Many dots: a chain · หลายจุด: โซ่ · 很多点：一条链

📄 NEW FILE · chain.py

"""chain.py - many dots, each one on a leash to the dot in front.

    python chain.py

Move the mouse over the window. The first point goes to the mouse.
Every other point is pulled by the one in front of it. You get a worm.
"""
import math
import tkinter as tk

WIDE = 800           # the window, in pixels
HIGH = 600
COUNT = 24           # how many points are in the chain
GAP = 16             # pixels from one point to the next
WATER = "#12263a"    # the colour behind everything


def pull(anchor, point, gap):
    """Give back the place that is gap pixels from anchor, on the way to point."""
    far = math.dist(anchor, point)      # how far apart the two are now
    if far == 0:
        # The same place: there is no direction, and gap / 0 would crash.
        return point
    scale = gap / far                   # 0.5 means "come half as far"
    x = anchor[0] + (point[0] - anchor[0]) * scale
    y = anchor[1] + (point[1] - anchor[1]) * scale
    return [x, y]


class Chain:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("chain")
        self.canvas = tk.Canvas(self.root, width=WIDE, height=HIGH, bg=WATER)
        self.canvas.pack()
        self.canvas.bind("<Motion>", self.mouse_moved)
        self.mouse = [WIDE / 2, HIGH / 2]
        # Start as a straight line. Point 0 is the head, in the middle of the window.
        self.points = []
        for i in range(COUNT):
            self.points.append([WIDE / 2 - i * GAP, HIGH / 2])

    def mouse_moved(self, event):
        self.mouse = [event.x, event.y]

    def move(self):
        self.points[0] = self.mouse
        # Start at 1: the head has nothing in front of it to pull it.
        for i in range(1, COUNT):
            self.points[i] = pull(self.points[i - 1], self.points[i], GAP)

    def circle(self, centre, radius, fill, rim):
        x, y = centre
        # An oval is given by the box around it: left, top, right, bottom.
        box = [x - radius, y - radius, x + radius, y + radius]
        self.canvas.create_oval(box, fill=fill, outline=rim, width=2)

    def draw(self):
        self.canvas.delete("all")                         # wipe the last picture
        # One thick line through every point. Round ends and corners make it a worm.
        self.canvas.create_line(self.points, fill="#ee6c4d", width=18,
                                capstyle="round", joinstyle="round")
        for point in self.points:
            self.circle(point, 3, "white", "white")

    def frame(self):
        self.move()
        self.draw()
        # Ask tkinter to call frame again in 16 ms, so the picture keeps changing.
        self.root.after(16, self.frame)

    def run(self):
        self.frame()
        self.root.mainloop()


def main():
    chain = Chain()
    chain.run()


if __name__ == "__main__":
    main()

3 Give it a body · ใส่ลำตัวให้มัน · 给它一个身体

📄 NEW FILE · body.py

"""body.py - give the chain a body: a width at every point, a skin, two eyes.

    python body.py

Move the mouse over the window. The chain is now the spine of a snake.
Turn it sharply and the skin crosses over itself. The next file fixes that.
"""
import math
import tkinter as tk

WIDE = 800                # the window, in pixels
HIGH = 600
GAP = 14                  # pixels from one point of the spine to the next
QUARTER = math.pi / 2     # a quarter turn. Python measures angles in radians.
WATER = "#12263a"         # the colour behind everything

# How far the skin is from the spine at each point, from the head to the tail.
# There is one number for each point, so this list also says how long the snake is.
WIDTHS = [18, 20, 17, 16, 16, 16, 16, 16, 16, 16, 16, 15, 15, 15,
          14, 14, 13, 13, 12, 12, 11, 10, 9, 8, 7, 6, 5, 4]


def pull(anchor, point, gap):
    """Give back the place that is gap pixels from anchor, on the way to point."""
    far = math.dist(anchor, point)      # how far apart the two are now
    if far == 0:
        # The same place: there is no direction, and gap / 0 would crash.
        return point
    scale = gap / far                   # 0.5 means "come half as far"
    x = anchor[0] + (point[0] - anchor[0]) * scale
    y = anchor[1] + (point[1] - anchor[1]) * scale
    return [x, y]


def angle_to(start, end):
    """The direction you face when you stand at start and look at end."""
    return math.atan2(end[1] - start[1], end[0] - start[0])


def walk(start, angle, far):
    """Stand at start, face angle, walk far pixels. Give back where you are."""
    return [start[0] + math.cos(angle) * far, start[1] + math.sin(angle) * far]


class Body:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("body")
        self.canvas = tk.Canvas(self.root, width=WIDE, height=HIGH, bg=WATER)
        self.canvas.pack()
        self.canvas.bind("<Motion>", self.mouse_moved)
        self.mouse = [WIDE / 2, HIGH / 2]
        # Start as a straight line. Point 0 is the head, in the middle of the window.
        self.points = []
        self.angles = []      # which way the body faces at each point
        for i in range(len(WIDTHS)):
            self.points.append([WIDE / 2 - i * GAP, HIGH / 2])
            self.angles.append(0)       # 0 is "facing right"

    def mouse_moved(self, event):
        self.mouse = [event.x, event.y]

    def move(self):
        self.points[0] = self.mouse
        for i in range(1, len(WIDTHS)):
            self.points[i] = pull(self.points[i - 1], self.points[i], GAP)
            # Each point faces the point in front of it.
            self.angles[i] = angle_to(self.points[i], self.points[i - 1])
        # The head has no point in front, so it faces the same way as its neck.
        self.angles[0] = self.angles[1]

    def outline(self):
        """The points of the skin, in order: down one side and back up the other."""
        left = []
        right = []
        for i in range(len(WIDTHS)):
            # A quarter turn from "forward" is "sideways". Walk out to the skin.
            left.append(walk(self.points[i], self.angles[i] - QUARTER, WIDTHS[i]))
            right.append(walk(self.points[i], self.angles[i] + QUARTER, WIDTHS[i]))
        right.reverse()       # the right side runs from the tail back to the head
        nose = walk(self.points[0], self.angles[0], WIDTHS[0])
        return [nose] + left + right

    def circle(self, centre, radius, fill, rim):
        x, y = centre
        # An oval is given by the box around it: left, top, right, bottom.
        box = [x - radius, y - radius, x + radius, y + radius]
        self.canvas.create_oval(box, fill=fill, outline=rim, width=2)

    def draw(self):
        self.canvas.delete("all")                         # wipe the last picture
        # smooth=True rounds every corner, so the dots become one curved skin.
        self.canvas.create_polygon(self.outline(), fill="#ee6c4d",
                                   outline="white", width=3, smooth=True)
        # The eyes. 1.2 is most of a quarter turn (1.57), so one sits on each side.
        head = self.points[0]
        facing = self.angles[0]
        self.circle(walk(head, facing - 1.2, 9), 3, "white", "white")
        self.circle(walk(head, facing + 1.2, 9), 3, "white", "white")

    def frame(self):
        self.move()
        self.draw()
        # Ask tkinter to call frame again in 16 ms, so the picture keeps changing.
        self.root.after(16, self.frame)

    def run(self):
        self.frame()
        self.root.mainloop()


def main():
    body = Body()
    body.run()


if __name__ == "__main__":
    main()

4 A spine that cannot fold, and a head that steers · สันหลังที่พับไม่ได้ และหัวที่เลี้ยวเอง · 折不起来的脊柱，会转弯的头

📄 NEW FILE · snake.py

"""snake.py - a snake that swims to the mouse and cannot fold in half.

    python snake.py

Move the mouse over the window. The snake turns toward it and swims there.
Every joint of the spine has a limit: it can bend only BEND from the one in front.
"""
import math
import tkinter as tk

WIDE = 800                # the window, in pixels
HIGH = 600
GAP = 14                  # pixels from one point of the spine to the next
SPEED = 4                 # pixels the head moves in one frame
TURN = 0.15               # the most the head can turn in one frame
NEAR = 30                 # the head stops when it is this close to the mouse
BEND = math.pi / 8        # the most one joint can bend: 22.5 degrees
QUARTER = math.pi / 2     # a quarter turn. Python measures angles in radians.
WATER = "#12263a"         # the colour behind everything

# How far the skin is from the spine at each point, from the head to the tail.
# There is one number for each point, so this list also says how long the snake is.
WIDTHS = [18, 20, 17, 16, 16, 16, 16, 16, 16, 16, 16, 15, 15, 15,
          14, 14, 13, 13, 12, 12, 11, 10, 9, 8, 7, 6, 5, 4]


def angle_to(start, end):
    """The direction you face when you stand at start and look at end."""
    return math.atan2(end[1] - start[1], end[0] - start[0])


def walk(start, angle, far):
    """Stand at start, face angle, walk far pixels. Give back where you are."""
    return [start[0] + math.cos(angle) * far, start[1] + math.sin(angle) * far]


def limit(angle, middle, most):
    """Give back angle, or the nearest angle that is within most of middle."""
    # How far angle is from middle, going the short way round the circle.
    # The answer is from -pi to pi: minus is one way round, plus is the other.
    away = (angle - middle + math.pi) % (2 * math.pi) - math.pi
    if away > most:
        return middle + most
    if away < -most:
        return middle - most
    return angle


class Snake:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("snake")
        self.canvas = tk.Canvas(self.root, width=WIDE, height=HIGH, bg=WATER)
        self.canvas.pack()
        self.canvas.bind("<Motion>", self.mouse_moved)
        self.mouse = [WIDE / 2, HIGH / 2]
        # Start as a straight line. Point 0 is the head, in the middle of the window.
        self.points = []
        self.angles = []      # which way the body faces at each point
        for i in range(len(WIDTHS)):
            self.points.append([WIDE / 2 - i * GAP, HIGH / 2])
            self.angles.append(0)       # 0 is "facing right"

    def mouse_moved(self, event):
        self.mouse = [event.x, event.y]

    def move(self):
        head = self.points[0]
        if math.dist(head, self.mouse) < NEAR:
            return            # it has arrived, so it waits for the mouse to move
        # The head wants to face the mouse, but it can turn only TURN in one frame.
        wanted = angle_to(head, self.mouse)
        self.angles[0] = limit(wanted, self.angles[0], TURN)
        self.points[0] = walk(head, self.angles[0], SPEED)
        for i in range(1, len(WIDTHS)):
            # Each point wants to face the point in front of it, within BEND.
            wanted = angle_to(self.points[i], self.points[i - 1])
            self.angles[i] = limit(wanted, self.angles[i - 1], BEND)
            # Then it stands GAP behind that point. Minus GAP is a walk backwards.
            self.points[i] = walk(self.points[i - 1], self.angles[i], -GAP)

    def outline(self):
        """The points of the skin, in order: down one side and back up the other."""
        left = []
        right = []
        for i in range(len(WIDTHS)):
            # A quarter turn from "forward" is "sideways". Walk out to the skin.
            left.append(walk(self.points[i], self.angles[i] - QUARTER, WIDTHS[i]))
            right.append(walk(self.points[i], self.angles[i] + QUARTER, WIDTHS[i]))
        right.reverse()       # the right side runs from the tail back to the head
        nose = walk(self.points[0], self.angles[0], WIDTHS[0])
        return [nose] + left + right

    def circle(self, centre, radius, fill, rim):
        x, y = centre
        # An oval is given by the box around it: left, top, right, bottom.
        box = [x - radius, y - radius, x + radius, y + radius]
        self.canvas.create_oval(box, fill=fill, outline=rim, width=2)

    def draw(self):
        self.canvas.delete("all")                         # wipe the last picture
        # smooth=True rounds every corner, so the dots become one curved skin.
        self.canvas.create_polygon(self.outline(), fill="#ee6c4d",
                                   outline="white", width=3, smooth=True)
        # The eyes. 1.2 is most of a quarter turn (1.57), so one sits on each side.
        head = self.points[0]
        facing = self.angles[0]
        self.circle(walk(head, facing - 1.2, 9), 3, "white", "white")
        self.circle(walk(head, facing + 1.2, 9), 3, "white", "white")

    def frame(self):
        self.move()
        self.draw()
        # Ask tkinter to call frame again in 16 ms, so the picture keeps changing.
        self.root.after(16, self.frame)

    def run(self):
        self.frame()
        self.root.mainloop()


def main():
    snake = Snake()
    snake.run()


if __name__ == "__main__":
    main()

5 A fish, and one class for both · ปลา และคลาสเดียวสำหรับทั้งคู่ · 一条鱼，两种动物共用一个类

📄 NEW FILE · fish.py

"""fish.py - one class, two animals. The word you hand in picks which one.

    python fish.py

Move the mouse over the window. A fish swims to it.
In main(), change "fish" to "snake" and run it again.
"""
import math
import tkinter as tk

WIDE = 800                # the window, in pixels
HIGH = 600
SPEED = 4                 # pixels the head moves in one frame
TURN = 0.15               # the most the head can turn in one frame
NEAR = 30                 # the head stops when it is this close to the mouse
BEND = math.pi / 8        # the most one joint can bend: 22.5 degrees
QUARTER = math.pi / 2     # a quarter turn. Python measures angles in radians.
WATER = "#12263a"         # the colour behind everything
FIN = "#81c3d7"           # the colour of the fins

# How far the skin is from the spine at each point, from the head to the tail.
# There is one number for each point, so each list also says how long the animal is.
SNAKE = [18, 20, 17, 16, 16, 16, 16, 16, 16, 16, 16, 15, 15, 15,
         14, 14, 13, 13, 12, 12, 11, 10, 9, 8, 7, 6, 5, 4]
FISH = [20, 25, 27, 27, 25, 21, 17, 12, 9, 6]


def angle_to(start, end):
    """The direction you face when you stand at start and look at end."""
    return math.atan2(end[1] - start[1], end[0] - start[0])


def walk(start, angle, far):
    """Stand at start, face angle, walk far pixels. Give back where you are."""
    return [start[0] + math.cos(angle) * far, start[1] + math.sin(angle) * far]


def limit(angle, middle, most):
    """Give back angle, or the nearest angle that is within most of middle."""
    # How far angle is from middle, going the short way round the circle.
    # The answer is from -pi to pi: minus is one way round, plus is the other.
    away = (angle - middle + math.pi) % (2 * math.pi) - math.pi
    if away > most:
        return middle + most
    if away < -most:
        return middle - most
    return angle


def oval(centre, angle, long, wide):
    """Twelve points round the edge of an oval. Its long side points along angle."""
    edge = []
    for k in range(12):
        around = k * math.pi / 6        # twelve of these make one full turn
        # Go along the oval's long side, then out to the edge.
        along = walk(centre, angle, math.cos(around) * long)
        edge.append(walk(along, angle + QUARTER, math.sin(around) * wide))
    return edge


class Animal:
    def __init__(self, kind):
        self.kind = kind                # draw() reads this later
        if kind == "snake":
            self.widths = SNAKE
            self.gap = 14               # pixels from one point of the spine to the next
            self.colour = "#ee6c4d"
        if kind == "fish":
            self.widths = FISH
            self.gap = 20
            self.colour = "#3a7ca5"
        self.root = tk.Tk()
        self.root.title(kind)
        self.canvas = tk.Canvas(self.root, width=WIDE, height=HIGH, bg=WATER)
        self.canvas.pack()
        self.canvas.bind("<Motion>", self.mouse_moved)
        self.mouse = [WIDE / 2, HIGH / 2]
        # Start as a straight line. Point 0 is the head, in the middle of the window.
        self.points = []
        self.angles = []      # which way the body faces at each point
        for i in range(len(self.widths)):
            self.points.append([WIDE / 2 - i * self.gap, HIGH / 2])
            self.angles.append(0)       # 0 is "facing right"

    def mouse_moved(self, event):
        self.mouse = [event.x, event.y]

    def move(self):
        head = self.points[0]
        if math.dist(head, self.mouse) < NEAR:
            return            # it has arrived, so it waits for the mouse to move
        # The head wants to face the mouse, but it can turn only TURN in one frame.
        wanted = angle_to(head, self.mouse)
        self.angles[0] = limit(wanted, self.angles[0], TURN)
        self.points[0] = walk(head, self.angles[0], SPEED)
        for i in range(1, len(self.widths)):
            # Each point wants to face the point in front of it, within BEND.
            wanted = angle_to(self.points[i], self.points[i - 1])
            self.angles[i] = limit(wanted, self.angles[i - 1], BEND)
            # Then it stands one gap behind that point. Minus is a walk backwards.
            self.points[i] = walk(self.points[i - 1], self.angles[i], -self.gap)

    def outline(self):
        """The points of the skin, in order: down one side and back up the other."""
        left = []
        right = []
        for i in range(len(self.widths)):
            # A quarter turn from "forward" is "sideways". Walk out to the skin.
            wide = self.widths[i]
            left.append(walk(self.points[i], self.angles[i] - QUARTER, wide))
            right.append(walk(self.points[i], self.angles[i] + QUARTER, wide))
        right.reverse()       # the right side runs from the tail back to the head
        nose = walk(self.points[0], self.angles[0], self.widths[0])
        return [nose] + left + right

    def shape(self, edge, colour):
        # smooth=True rounds every corner, so the points become one curved shape.
        self.canvas.create_polygon(edge, fill=colour, outline="white",
                                   width=3, smooth=True)

    def circle(self, centre, radius, fill, rim):
        x, y = centre
        # An oval is given by the box around it: left, top, right, bottom.
        box = [x - radius, y - radius, x + radius, y + radius]
        self.canvas.create_oval(box, fill=fill, outline=rim, width=2)

    def fin(self, spot, side, long, wide):
        """One fin on the skin beside point spot. side is -1 for left, 1 for right."""
        sideways = self.angles[spot] + side * QUARTER
        centre = walk(self.points[spot], sideways, self.widths[spot])
        # The fin leans out and back. It copies the angle of the point in front
        # of it, so it starts to turn a moment before the body under it does.
        lean = self.angles[spot - 1] + side * math.pi / 4
        self.shape(oval(centre, lean, long, wide), FIN)

    def draw(self):
        self.canvas.delete("all")                         # wipe the last picture
        if self.kind == "fish":
            # The fins go on first, so the body covers the place where they join.
            self.fin(3, -1, 26, 10)
            self.fin(3, 1, 26, 10)
            self.fin(7, -1, 15, 5)
            self.fin(7, 1, 15, 5)
            # The tail is one more oval. It sits behind the last point of the spine.
            tail = len(self.widths) - 1
            centre = walk(self.points[tail], self.angles[tail], -16)
            self.shape(oval(centre, self.angles[tail], 20, 5), FIN)
        self.shape(self.outline(), self.colour)
        if self.kind == "fish":
            # The fin on its back goes on after the body, so it sits on top.
            self.shape(oval(self.points[4], self.angles[4], 22, 4), FIN)
        # The eyes. 1.2 is most of a quarter turn (1.57), so one sits on each side.
        head = self.points[0]
        facing = self.angles[0]
        far = self.widths[0] / 2
        self.circle(walk(head, facing - 1.2, far), 3, "white", "white")
        self.circle(walk(head, facing + 1.2, far), 3, "white", "white")

    def frame(self):
        self.move()
        self.draw()
        # Ask tkinter to call frame again in 16 ms, so the picture keeps changing.
        self.root.after(16, self.frame)

    def run(self):
        self.frame()
        self.root.mainloop()


def main():
    animal = Animal("fish")
    animal.run()


if __name__ == "__main__":
    main()

6 An arm that reaches · แขนที่เอื้อมไปหา · 会伸过去的手臂

📄 NEW FILE · arm.py

"""arm.py - an arm that reaches for the mouse. Its shoulder never moves.

    python arm.py

Move the mouse over the window. The hand goes to the mouse if the arm is long
enough. If the mouse is too far, the arm points at it and stretches out straight.
"""
import math
import tkinter as tk

WIDE = 800           # the window, in pixels
HIGH = 600
BONE = 90            # how long each bone of the arm is
JOINTS = 4           # a shoulder, two elbows and a hand: three bones
WATER = "#12263a"    # the colour behind everything


def pull(anchor, point, gap):
    """Give back the place that is gap pixels from anchor, on the way to point."""
    far = math.dist(anchor, point)      # how far apart the two are now
    if far == 0:
        # The same place: there is no direction, and gap / 0 would crash.
        return point
    scale = gap / far                   # 0.5 means "come half as far"
    x = anchor[0] + (point[0] - anchor[0]) * scale
    y = anchor[1] + (point[1] - anchor[1]) * scale
    return [x, y]


def reach(joints, start, end, bone):
    """Bend the chain of joints so it starts at start and reaches toward end."""
    last = len(joints) - 1
    # Forward: put the last joint on the target, then pull the others after it.
    joints[last] = end
    for i in reversed(range(last)):             # count down: last - 1, ..., 1, 0
        joints[i] = pull(joints[i + 1], joints[i], bone)
    # That dragged the first joint off its place. Put it back.
    # Backward: pull the others after it again, this time from the other end.
    joints[0] = start
    for i in range(1, last + 1):
        joints[i] = pull(joints[i - 1], joints[i], bone)


class Arm:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("arm")
        self.canvas = tk.Canvas(self.root, width=WIDE, height=HIGH, bg=WATER)
        self.canvas.pack()
        self.canvas.bind("<Motion>", self.mouse_moved)
        self.mouse = [WIDE / 2 + 200, HIGH / 2]
        self.shoulder = [WIDE / 2, HIGH / 2]
        # Start as a straight line, going up from the shoulder.
        self.joints = []
        for i in range(JOINTS):
            self.joints.append([WIDE / 2, HIGH / 2 - i * BONE])

    def mouse_moved(self, event):
        self.mouse = [event.x, event.y]

    def circle(self, centre, radius, fill, rim):
        x, y = centre
        # An oval is given by the box around it: left, top, right, bottom.
        box = [x - radius, y - radius, x + radius, y + radius]
        self.canvas.create_oval(box, fill=fill, outline=rim, width=2)

    def draw(self):
        self.canvas.delete("all")                         # wipe the last picture
        self.canvas.create_line(self.joints, fill="#52796f", width=16,
                                capstyle="round", joinstyle="round")
        for joint in self.joints:
            self.circle(joint, 5, "white", "white")
        self.circle(self.shoulder, 11, "", "white")       # a ring round the shoulder
        self.circle(self.mouse, 5, "#ee6c4d", "#ee6c4d")

    def frame(self):
        # One reach each frame is enough. The next frame starts from this
        # answer and makes it better, so after a few frames it is right.
        reach(self.joints, self.shoulder, self.mouse, BONE)
        self.draw()
        # Ask tkinter to call frame again in 16 ms, so the picture keeps changing.
        self.root.after(16, self.frame)

    def run(self):
        self.frame()
        self.root.mainloop()


def main():
    arm = Arm()
    arm.run()


if __name__ == "__main__":
    main()

7 Four legs that walk · สี่ขาที่เดินได้ · 会走路的四条腿

📄 NEW FILE · lizard.py

"""lizard.py - one class, three animals. The lizard has four legs that walk.

    python lizard.py

Move the mouse over the window. A lizard walks to it.
In main(), change "lizard" to "fish" or "snake" and run it again.
"""
import math
import tkinter as tk

WIDE = 800                # the window, in pixels
HIGH = 600
SPEED = 4                 # pixels the head moves in one frame
TURN = 0.15               # the most the head can turn in one frame
NEAR = 30                 # the head stops when it is this close to the mouse
BEND = math.pi / 8        # the most one joint can bend: 22.5 degrees
STIFF = math.pi / 16      # a lizard's back is stiffer: 11.25 degrees, so it cannot curl up
QUARTER = math.pi / 2     # a quarter turn. Python measures angles in radians.
BONE = 24                 # how long each of the two bones in a leg is
REACH = 36                # how far from the hip a new step lands
STEP = 60                 # a foot takes a step when it is this far behind
WATER = "#12263a"         # the colour behind everything
FIN = "#81c3d7"           # the colour of the fins

# How far the skin is from the spine at each point, from the head to the tail.
# There is one number for each point, so each list also says how long the animal is.
SNAKE = [18, 20, 17, 16, 16, 16, 16, 16, 16, 16, 16, 15, 15, 15,
         14, 14, 13, 13, 12, 12, 11, 10, 9, 8, 7, 6, 5, 4]
FISH = [20, 25, 27, 27, 25, 21, 17, 12, 9, 6]
LIZARD = [17, 19, 13, 20, 22, 23, 21, 16, 9, 6, 5, 4, 3, 3]


def angle_to(start, end):
    """The direction you face when you stand at start and look at end."""
    return math.atan2(end[1] - start[1], end[0] - start[0])


def walk(start, angle, far):
    """Stand at start, face angle, walk far pixels. Give back where you are."""
    return [start[0] + math.cos(angle) * far, start[1] + math.sin(angle) * far]


def limit(angle, middle, most):
    """Give back angle, or the nearest angle that is within most of middle."""
    # How far angle is from middle, going the short way round the circle.
    # The answer is from -pi to pi: minus is one way round, plus is the other.
    away = (angle - middle + math.pi) % (2 * math.pi) - math.pi
    if away > most:
        return middle + most
    if away < -most:
        return middle - most
    return angle


def oval(centre, angle, long, wide):
    """Twelve points round the edge of an oval. Its long side points along angle."""
    edge = []
    for k in range(12):
        around = k * math.pi / 6        # twelve of these make one full turn
        # Go along the oval's long side, then out to the edge.
        along = walk(centre, angle, math.cos(around) * long)
        edge.append(walk(along, angle + QUARTER, math.sin(around) * wide))
    return edge


def pull(anchor, point, gap):
    """Give back the place that is gap pixels from anchor, on the way to point."""
    far = math.dist(anchor, point)      # how far apart the two are now
    if far == 0:
        # The same place: there is no direction, and gap / 0 would crash.
        return point
    scale = gap / far                   # 0.5 means "come half as far"
    x = anchor[0] + (point[0] - anchor[0]) * scale
    y = anchor[1] + (point[1] - anchor[1]) * scale
    return [x, y]


def reach(joints, start, end, bone):
    """Bend the chain of joints so it starts at start and reaches toward end."""
    last = len(joints) - 1
    # Forward: put the last joint on the target, then pull the others after it.
    joints[last] = end
    for i in reversed(range(last)):             # count down: last - 1, ..., 1, 0
        joints[i] = pull(joints[i + 1], joints[i], bone)
    # That dragged the first joint off its place. Put it back.
    # Backward: pull the others after it again, this time from the other end.
    joints[0] = start
    for i in range(1, last + 1):
        joints[i] = pull(joints[i - 1], joints[i], bone)


class Animal:
    def __init__(self, kind):
        self.kind = kind                # draw() reads this later
        if kind == "snake":
            self.widths = SNAKE
            self.gap = 14               # pixels from one point of the spine to the next
            self.colour = "#ee6c4d"
            self.bend = BEND            # the most one joint of the spine can bend
        if kind == "fish":
            self.widths = FISH
            self.gap = 20
            self.colour = "#3a7ca5"
            self.bend = BEND
        if kind == "lizard":
            self.widths = LIZARD
            self.gap = 20
            self.colour = "#52796f"
            self.bend = STIFF
        self.root = tk.Tk()
        self.root.title(kind)
        self.canvas = tk.Canvas(self.root, width=WIDE, height=HIGH, bg=WATER)
        self.canvas.pack()
        self.canvas.bind("<Motion>", self.mouse_moved)
        self.mouse = [WIDE / 2, HIGH / 2]
        # Start as a straight line. Point 0 is the head, in the middle of the window.
        self.points = []
        self.angles = []      # which way the body faces at each point
        for i in range(len(self.widths)):
            self.points.append([WIDE / 2 - i * self.gap, HIGH / 2])
            self.angles.append(0)       # 0 is "facing right"
        if kind == "lizard":
            # Only the lizard has legs. Each leg is: which point of the spine it
            # joins, which side (-1 left, 1 right), and how far back its foot starts.
            self.legs = []
            self.add_leg(3, -1, 0)
            self.add_leg(3, 1, STEP / 2)    # half a step behind, so the legs take turns
            self.add_leg(7, -1, STEP / 2)
            self.add_leg(7, 1, 0)

    def add_leg(self, spot, side, behind):
        leg = {"spot": spot, "side": side}
        hip, ahead = self.leg_places(leg)
        # The place on the ground where the foot stands. It stays there until a step.
        leg["ground"] = walk(ahead, self.angles[spot], -behind)
        # Hip, knee, foot. The knee starts on the hip, and reach() moves it.
        leg["joints"] = [hip, hip, leg["ground"]]
        self.legs.append(leg)

    def leg_places(self, leg):
        """Where this leg's hip is now, and where its next step will land."""
        spot = leg["spot"]
        facing = self.angles[spot]
        sideways = facing + leg["side"] * QUARTER
        hip = walk(self.points[spot], sideways, self.widths[spot] - 6)
        # The next step lands out to the side and in front: half a quarter turn.
        ahead = walk(hip, facing + leg["side"] * QUARTER / 2, REACH)
        return hip, ahead

    def mouse_moved(self, event):
        self.mouse = [event.x, event.y]

    def move(self):
        head = self.points[0]
        if math.dist(head, self.mouse) < NEAR:
            return            # it has arrived, so it waits for the mouse to move
        # The head wants to face the mouse, but it can turn only TURN in one frame.
        wanted = angle_to(head, self.mouse)
        self.angles[0] = limit(wanted, self.angles[0], TURN)
        self.points[0] = walk(head, self.angles[0], SPEED)
        for i in range(1, len(self.widths)):
            # Each point wants to face the point in front of it, within self.bend.
            wanted = angle_to(self.points[i], self.points[i - 1])
            self.angles[i] = limit(wanted, self.angles[i - 1], self.bend)
            # Then it stands one gap behind that point. Minus is a walk backwards.
            self.points[i] = walk(self.points[i - 1], self.angles[i], -self.gap)

    def move_legs(self):
        for leg in self.legs:
            hip, ahead = self.leg_places(leg)
            # The body walks on and the foot stays. When the foot is too far
            # behind, it gets a new place on the ground: that is one step.
            if math.dist(leg["ground"], ahead) > STEP:
                leg["ground"] = ahead
            # The foot does not jump. Each frame it goes 4 tenths of the way there.
            ground = leg["ground"]
            foot = leg["joints"][2]
            x = foot[0] + (ground[0] - foot[0]) * 0.4
            y = foot[1] + (ground[1] - foot[1]) * 0.4
            reach(leg["joints"], hip, [x, y], BONE)

    def outline(self):
        """The points of the skin, in order: down one side and back up the other."""
        left = []
        right = []
        for i in range(len(self.widths)):
            # A quarter turn from "forward" is "sideways". Walk out to the skin.
            wide = self.widths[i]
            left.append(walk(self.points[i], self.angles[i] - QUARTER, wide))
            right.append(walk(self.points[i], self.angles[i] + QUARTER, wide))
        right.reverse()       # the right side runs from the tail back to the head
        nose = walk(self.points[0], self.angles[0], self.widths[0])
        return [nose] + left + right

    def shape(self, edge, colour):
        # smooth=True rounds every corner, so the points become one curved shape.
        self.canvas.create_polygon(edge, fill=colour, outline="white",
                                   width=3, smooth=True)

    def circle(self, centre, radius, fill, rim):
        x, y = centre
        # An oval is given by the box around it: left, top, right, bottom.
        box = [x - radius, y - radius, x + radius, y + radius]
        self.canvas.create_oval(box, fill=fill, outline=rim, width=2)

    def fin(self, spot, side, long, wide):
        """One fin on the skin beside point spot. side is -1 for left, 1 for right."""
        sideways = self.angles[spot] + side * QUARTER
        centre = walk(self.points[spot], sideways, self.widths[spot])
        # The fin leans out and back. It copies the angle of the point in front
        # of it, so it starts to turn a moment before the body under it does.
        lean = self.angles[spot - 1] + side * math.pi / 4
        self.shape(oval(centre, lean, long, wide), FIN)

    def draw(self):
        self.canvas.delete("all")                         # wipe the last picture
        if self.kind == "fish":
            # The fins go on first, so the body covers the place where they join.
            self.fin(3, -1, 26, 10)
            self.fin(3, 1, 26, 10)
            self.fin(7, -1, 15, 5)
            self.fin(7, 1, 15, 5)
            # The tail is one more oval. It sits behind the last point of the spine.
            tail = len(self.widths) - 1
            centre = walk(self.points[tail], self.angles[tail], -16)
            self.shape(oval(centre, self.angles[tail], 20, 5), FIN)
        if self.kind == "lizard":
            # The legs go on first too. Each is a thick white line with a
            # thinner green line on top, so it looks like it has a white edge.
            for leg in self.legs:
                self.canvas.create_line(leg["joints"], fill="white", width=14,
                                        capstyle="round", joinstyle="round")
                self.canvas.create_line(leg["joints"], fill=self.colour, width=8,
                                        capstyle="round", joinstyle="round")
        self.shape(self.outline(), self.colour)
        if self.kind == "fish":
            # The fin on its back goes on after the body, so it sits on top.
            self.shape(oval(self.points[4], self.angles[4], 22, 4), FIN)
        # The eyes. 1.2 is most of a quarter turn (1.57), so one sits on each side.
        head = self.points[0]
        facing = self.angles[0]
        far = self.widths[0] / 2
        self.circle(walk(head, facing - 1.2, far), 3, "white", "white")
        self.circle(walk(head, facing + 1.2, far), 3, "white", "white")

    def frame(self):
        self.move()
        if self.kind == "lizard":
            self.move_legs()
        self.draw()
        # Ask tkinter to call frame again in 16 ms, so the picture keeps changing.
        self.root.after(16, self.frame)

    def run(self):
        self.frame()
        self.root.mainloop()


def main():
    animal = Animal("lizard")
    animal.run()


if __name__ == "__main__":
    main()

8 Ask a model one question · ถามโมเดลหนึ่งคำถาม · 问模型一个问题

💻 RUN IT

python ask.py

📄 NEW FILE · ask.py

"""ask.py - ask an AI model one question, and print its answer.

    python ask.py

The model reads a few sentences and picks one move. It runs on a small
computer in Chiang Mai, so this file needs the internet.
"""
import json
import urllib.request

MODEL = "https://spark-wav2lip-1.taila00da8.ts.net/gecko/v1/systemone"

# Who the animal is, and its rules. The model reads these every time.
WHO = ("You are a gecko in a rice field. You hunt a dragonfly. "
       "You can only catch a dragonfly that rests.")
RULES = ("If the dragonfly is flying, stay still. "
         "If it rests and is too far to jump at, creep closer. "
         "If it rests and is close enough, jump.")

# The moves the gecko can choose from, and what each one is for.
MOVES = {
    "wait": "Stay still. Do this when the dragonfly is flying.",
    "creep": "Creep closer. Do this when a resting dragonfly is too far to jump at.",
    "jump": "Jump at it. Do this when a resting dragonfly is close enough.",
}

# Three things the gecko might see.
SEES = [
    "The dragonfly is flying. It is too far to jump at.",
    "The dragonfly rests. It is too far to jump at.",
    "The dragonfly rests. It is close enough to jump at.",
]


def ask(sees):
    """Send the rules, what the gecko sees, and the moves. Give back the answer."""
    question = {"type": "choice",
                "instructions": "What should you do right now?",
                "criteria": MOVES}
    message = {"state": WHO + " Rules: " + RULES + "\n\nSituation: " + sees,
               "questions": {"move": question}}
    # The internet carries bytes. dumps() writes the dictionary as text,
    # and encode() turns that text into bytes.
    request = urllib.request.Request(MODEL, json.dumps(message).encode(),
                                     {"Content-Type": "application/json"})
    with urllib.request.urlopen(request, timeout=10) as reply:
        answer = json.load(reply)       # the other way: bytes back to a dictionary
    return answer["answers"]["move"]


def main():
    for sees in SEES:
        try:
            answer = ask(sees)
        except OSError as problem:
            # There is no internet, or the model's computer is off.
            print("No answer:", problem)
            return
        print(sees)
        print("   ", answer["choice"], answer["probabilities"])


if __name__ == "__main__":
    main()

🖨 WHAT IT PRINTED

The dragonfly is flying. It is too far to jump at.
    wait {'wait': 0.9129, 'creep': 0.086, 'jump': 0.0011}
The dragonfly rests. It is too far to jump at.
    creep {'wait': 0.0005, 'creep': 0.9981, 'jump': 0.0014}
The dragonfly rests. It is close enough to jump at.
    jump {'wait': 0.0005, 'creep': 0.0019, 'jump': 0.9976}

9 A gecko that hunts your mouse · ตุ๊กแกที่ล่าเมาส์ของคุณ · 追捕你鼠标的壁虎

📄 NEW FILE · hunt.py

"""hunt.py - a gecko that hunts your mouse. An AI model picks its moves.

    python hunt.py

Your mouse is a dragonfly. Hold the mouse still and the dragonfly rests.
Then the gecko creeps up and jumps. Move away in time.
The model runs on a small computer in Chiang Mai, so this file needs the internet.
In main(), change "model" to "mouse". The gecko walks to the mouse, as in step 7.
"""
import json
import math
import threading
import tkinter as tk
import urllib.request

WIDE = 800                # the window, in pixels
HIGH = 600
SPEED = 4                 # pixels the head moves in one frame when it walks
CREEP = 1.5               # pixels in one frame when it creeps
DASH = 12                 # pixels in one frame when it jumps
TURN = 0.15               # the most the head can turn in one frame
NEAR = 30                 # the head stops when it is this close to the mouse
STIFF = math.pi / 16      # the most one joint of a gecko's back can bend: 11.25 degrees
QUARTER = math.pi / 2     # a quarter turn. Python measures angles in radians.
BONE = 24                 # how long each of the two bones in a leg is
REACH = 36                # how far from the hip a new step lands
STEP = 60                 # a foot takes a step when it is this far behind
JUMP = 130                # how far a jump reaches, in pixels
CATCH = 25                # a jump catches the dragonfly if the head lands this close
REST = 20                 # the dragonfly rests after the mouse is still for 20 frames
THINK = 50                # the gecko asks the model once in every 50 frames
WATER = "#12263a"         # the colour behind everything
WING = "#81c3d7"          # the colour of the dragonfly's wings

# How far the skin is from the spine at each point, from the head to the tail.
LIZARD = [17, 19, 13, 20, 22, 23, 21, 16, 9, 6, 5, 4, 3, 3]

MODEL = "https://spark-wav2lip-1.taila00da8.ts.net/gecko/v1/systemone"

# Who the animal is, and its rules. The model reads these every time.
WHO = ("You are a gecko in a rice field. You hunt a dragonfly. "
       "You can only catch a dragonfly that rests.")
RULES = ("If the dragonfly is flying, stay still. "
         "If it rests and is too far to jump at, creep closer. "
         "If it rests and is close enough, jump.")

# The moves the gecko can choose from, and what each one is for.
MOVES = {
    "wait": "Stay still. Do this when the dragonfly is flying.",
    "creep": "Creep closer. Do this when a resting dragonfly is too far to jump at.",
    "jump": "Jump at it. Do this when a resting dragonfly is close enough.",
}


def angle_to(start, end):
    """The direction you face when you stand at start and look at end."""
    return math.atan2(end[1] - start[1], end[0] - start[0])


def walk(start, angle, far):
    """Stand at start, face angle, walk far pixels. Give back where you are."""
    return [start[0] + math.cos(angle) * far, start[1] + math.sin(angle) * far]


def limit(angle, middle, most):
    """Give back angle, or the nearest angle that is within most of middle."""
    # How far angle is from middle, going the short way round the circle.
    # The answer is from -pi to pi: minus is one way round, plus is the other.
    away = (angle - middle + math.pi) % (2 * math.pi) - math.pi
    if away > most:
        return middle + most
    if away < -most:
        return middle - most
    return angle


def oval(centre, angle, long, wide):
    """Twelve points round the edge of an oval. Its long side points along angle."""
    edge = []
    for k in range(12):
        around = k * math.pi / 6        # twelve of these make one full turn
        # Go along the oval's long side, then out to the edge.
        along = walk(centre, angle, math.cos(around) * long)
        edge.append(walk(along, angle + QUARTER, math.sin(around) * wide))
    return edge


def pull(anchor, point, gap):
    """Give back the place that is gap pixels from anchor, on the way to point."""
    far = math.dist(anchor, point)      # how far apart the two are now
    if far == 0:
        # The same place: there is no direction, and gap / 0 would crash.
        return point
    scale = gap / far                   # 0.5 means "come half as far"
    x = anchor[0] + (point[0] - anchor[0]) * scale
    y = anchor[1] + (point[1] - anchor[1]) * scale
    return [x, y]


def reach(joints, start, end, bone):
    """Bend the chain of joints so it starts at start and reaches toward end."""
    last = len(joints) - 1
    # Forward: put the last joint on the target, then pull the others after it.
    joints[last] = end
    for i in reversed(range(last)):             # count down: last - 1, ..., 1, 0
        joints[i] = pull(joints[i + 1], joints[i], bone)
    # That dragged the first joint off its place. Put it back.
    # Backward: pull the others after it again, this time from the other end.
    joints[0] = start
    for i in range(1, last + 1):
        joints[i] = pull(joints[i - 1], joints[i], bone)


def ask(sees):
    """Send the rules, what the gecko sees, and the moves. Give back the answer."""
    question = {"type": "choice",
                "instructions": "What should you do right now?",
                "criteria": MOVES}
    message = {"state": WHO + " Rules: " + RULES + "\n\nSituation: " + sees,
               "questions": {"move": question}}
    # The internet carries bytes. dumps() writes the dictionary as text,
    # and encode() turns that text into bytes.
    request = urllib.request.Request(MODEL, json.dumps(message).encode(),
                                     {"Content-Type": "application/json"})
    with urllib.request.urlopen(request, timeout=10) as reply:
        answer = json.load(reply)       # the other way: bytes back to a dictionary
    return answer["answers"]["move"]


class Animal:
    def __init__(self, kind):
        self.kind = kind                # "model" hunts. "mouse" walks to the mouse.
        self.widths = LIZARD
        self.gap = 20                   # pixels from one point of the spine to the next
        self.colour = "#52796f"
        self.root = tk.Tk()
        self.root.title(kind)
        self.canvas = tk.Canvas(self.root, width=WIDE, height=HIGH, bg=WATER)
        self.canvas.pack()
        self.canvas.bind("<Motion>", self.mouse_moved)
        self.mouse = [WIDE - 150, HIGH / 2]
        # Start as a straight line on the left. Point 0 is the head.
        self.points = []
        self.angles = []      # which way the body faces at each point
        for i in range(len(self.widths)):
            self.points.append([300 - i * self.gap, HIGH / 2])
            self.angles.append(0)       # 0 is "facing right"
        # Each leg is: which point of the spine it joins, which side
        # (-1 left, 1 right), and how far back its foot starts.
        self.legs = []
        self.add_leg(3, -1, 0)
        self.add_leg(3, 1, STEP / 2)    # half a step behind, so the legs take turns
        self.add_leg(7, -1, STEP / 2)
        self.add_leg(7, 1, 0)
        if kind == "model":
            # Only the hunter needs these. A "mouse" gecko has none of them.
            self.doing = "wait"         # the move the model picked last
            self.asking = False         # True while a question is on its way
            self.frames = 0             # how many frames there have been
            self.still = 0              # frames since the mouse last moved
            self.target = None          # where a jump is going. None: no jump now.
            self.gone = False           # True after a catch, until the mouse moves
            self.caught = 0

    def add_leg(self, spot, side, behind):
        leg = {"spot": spot, "side": side}
        hip, ahead = self.leg_places(leg)
        # The place on the ground where the foot stands. It stays there until a step.
        leg["ground"] = walk(ahead, self.angles[spot], -behind)
        # Hip, knee, foot. The knee starts on the hip, and reach() moves it.
        leg["joints"] = [hip, hip, leg["ground"]]
        self.legs.append(leg)

    def leg_places(self, leg):
        """Where this leg's hip is now, and where its next step will land."""
        spot = leg["spot"]
        facing = self.angles[spot]
        sideways = facing + leg["side"] * QUARTER
        hip = walk(self.points[spot], sideways, self.widths[spot] - 6)
        # The next step lands out to the side and in front: half a quarter turn.
        ahead = walk(hip, facing + leg["side"] * QUARTER / 2, REACH)
        return hip, ahead

    def mouse_moved(self, event):
        self.mouse = [event.x, event.y]
        if self.kind == "model":
            self.still = 0              # the mouse moved, so the dragonfly is flying
            self.gone = False           # after a catch, a new dragonfly comes

    def go(self, place, speed, turn):
        """Move the head toward place. Then the body follows, as in step 4."""
        head = self.points[0]
        wanted = angle_to(head, place)
        self.angles[0] = limit(wanted, self.angles[0], turn)
        self.points[0] = walk(head, self.angles[0], speed)
        for i in range(1, len(self.widths)):
            # Each point wants to face the point in front of it, within STIFF.
            wanted = angle_to(self.points[i], self.points[i - 1])
            self.angles[i] = limit(wanted, self.angles[i - 1], STIFF)
            # Then it stands one gap behind that point. Minus is a walk backwards.
            self.points[i] = walk(self.points[i - 1], self.angles[i], -self.gap)

    def move(self):
        """The head from step 7: walk to the mouse, and stop when it is near."""
        if math.dist(self.points[0], self.mouse) >= NEAR:
            self.go(self.mouse, SPEED, TURN)

    def sees(self):
        """What the gecko sees, in words. The model reads words, not numbers."""
        words = "The dragonfly is flying."
        if self.still >= REST:
            words = "The dragonfly rests."
        if math.dist(self.points[0], self.mouse) <= JUMP:
            return words + " It is close enough to jump at."
        return words + " It is too far to jump at."

    def think(self, sees):
        """Wait for the model's answer, then keep the move it picked."""
        # This runs in a second thread. The window goes on drawing in the first.
        try:
            self.doing = ask(sees)["choice"]
        except OSError:
            self.doing = "no answer"    # no internet, or the model's computer is off
        self.asking = False

    def ask_model(self):
        """Start a second thread that asks the model. Do not wait for it here."""
        self.asking = True
        thread = threading.Thread(target=self.think, args=[self.sees()], daemon=True)
        thread.start()

    def start_jump(self):
        # Jump to where the dragonfly is now. If it flies away, the jump misses.
        head = self.points[0]
        self.target = list(self.mouse)
        if math.dist(head, self.mouse) > JUMP:
            # A jump is JUMP pixels long at most. pull() finds that place.
            self.target = pull(head, self.mouse, JUMP)

    def jump(self):
        """One frame of a jump. When it lands, is the dragonfly still there?"""
        self.go(self.target, DASH, math.pi)     # math.pi: it may turn any way at once
        if math.dist(self.points[0], self.target) > DASH:
            return            # it is still in the air
        if math.dist(self.points[0], self.mouse) < CATCH:
            self.caught = self.caught + 1
            self.gone = True
        self.target = None
        self.doing = "wait"

    def hunt(self):
        """The new head: finish a jump, or ask the model and do the move it picked."""
        self.frames = self.frames + 1
        self.still = self.still + 1
        if self.target:
            self.jump()
            return
        if self.gone:
            return            # it caught the dragonfly, and waits for a new one
        if self.frames % THINK == 0 and not self.asking:
            self.ask_model()
        far = math.dist(self.points[0], self.mouse)
        if self.doing == "creep" and far > JUMP - 10:
            self.go(self.mouse, CREEP, TURN)
        if self.doing == "jump":
            self.start_jump()

    def move_legs(self):
        for leg in self.legs:
            hip, ahead = self.leg_places(leg)
            # The body walks on and the foot stays. When the foot is too far
            # behind, it gets a new place on the ground: that is one step.
            if math.dist(leg["ground"], ahead) > STEP:
                leg["ground"] = ahead
            # The foot does not jump. Each frame it goes 4 tenths of the way there.
            ground = leg["ground"]
            foot = leg["joints"][2]
            x = foot[0] + (ground[0] - foot[0]) * 0.4
            y = foot[1] + (ground[1] - foot[1]) * 0.4
            reach(leg["joints"], hip, [x, y], BONE)

    def outline(self):
        """The points of the skin, in order: down one side and back up the other."""
        left = []
        right = []
        for i in range(len(self.widths)):
            # A quarter turn from "forward" is "sideways". Walk out to the skin.
            wide = self.widths[i]
            left.append(walk(self.points[i], self.angles[i] - QUARTER, wide))
            right.append(walk(self.points[i], self.angles[i] + QUARTER, wide))
        right.reverse()       # the right side runs from the tail back to the head
        nose = walk(self.points[0], self.angles[0], self.widths[0])
        return [nose] + left + right

    def shape(self, edge, colour):
        # smooth=True rounds every corner, so the points become one curved shape.
        self.canvas.create_polygon(edge, fill=colour, outline="white",
                                   width=3, smooth=True)

    def circle(self, centre, radius, fill, rim):
        x, y = centre
        # An oval is given by the box around it: left, top, right, bottom.
        box = [x - radius, y - radius, x + radius, y + radius]
        self.canvas.create_oval(box, fill=fill, outline=rim, width=2)

    def draw_hunt(self):
        if not self.gone:
            # The dragonfly. Two long ovals are its four wings. One is its body.
            self.shape(oval(self.mouse, 0.5, 28, 6), WING)
            self.shape(oval(self.mouse, -0.5, 28, 6), WING)
            self.shape(oval(self.mouse, QUARTER, 20, 3), "#ee6c4d")
        words = "the model says: " + self.doing + "      caught: " + str(self.caught)
        self.canvas.create_text(WIDE / 2, 24, text=words, fill="white",
                                font=("Arial", 14))

    def draw(self):
        self.canvas.delete("all")                         # wipe the last picture
        # The legs go on first. Each is a thick white line with a thinner
        # green line on top, so it looks like it has a white edge.
        for leg in self.legs:
            self.canvas.create_line(leg["joints"], fill="white", width=14,
                                    capstyle="round", joinstyle="round")
            self.canvas.create_line(leg["joints"], fill=self.colour, width=8,
                                    capstyle="round", joinstyle="round")
        self.shape(self.outline(), self.colour)
        # The eyes. 1.2 is most of a quarter turn (1.57), so one sits on each side.
        head = self.points[0]
        facing = self.angles[0]
        far = self.widths[0] / 2
        self.circle(walk(head, facing - 1.2, far), 3, "white", "white")
        self.circle(walk(head, facing + 1.2, far), 3, "white", "white")
        if self.kind == "model":
            self.draw_hunt()

    def frame(self):
        if self.kind == "model":
            self.hunt()
        else:
            self.move()
        self.move_legs()
        self.draw()
        # Ask tkinter to call frame again in 16 ms, so the picture keeps changing.
        self.root.after(16, self.frame)

    def run(self):
        self.frame()
        self.root.mainloop()


def main():
    animal = Animal("model")
    animal.run()


if __name__ == "__main__":
    main()

10 One question, on your own computer · คำถามหนึ่งข้อ บนคอมพิวเตอร์ของคุณเอง · 一个问题，在你自己的电脑上

💻 RUN IT

pip install decider-ai
python decide.py

📄 NEW FILE · decide.py

"""decide.py - load the AI model, ask it one question, and print the answer.

    pip install decider-ai
    python decide.py

The model runs on this computer. The first run downloads it: 3.8 GB.
"""
from decider.infer import Decider

model = Decider("Mapika/decider-2b")

question = {
    "type": "choice",
    "instructions": "What should you do right now?",
    "criteria": {
        "creep": "Creep closer. Do this when the dragonfly is too far to jump at.",
        "jump": "Jump at it. Do this when the dragonfly is close enough.",
    },
}

answer = model.system_one(
    "You are a gecko. You hunt a dragonfly that rests. "
    "Rules: If it is too far to jump at, creep closer. If it is close enough, jump."
    "\n\nSituation: It is close enough to jump at.",
    {"move": question},
)
print(answer)

🖨 WHAT IT PRINTED

{'model': 'decider-2b-v11', 'answers': {'move': {'type': 'choice', 'choice': 'jump', 'confidence': 0.9964, 'x_p_max': 0.9982, 'certainty': 0.9811, 'probabilities': {'creep': 0.0018, 'jump': 0.9982}}}, 'usage': {'input_tokens': 109, 'output_tokens': 0}}

11 The smallest agent · เอเจนต์ที่เล็กที่สุด · 最小的智能体

💻 RUN IT

pip install decider-ai
python agent.py

📄 NEW FILE · agent.py

"""agent.py - the smallest agent, with the AI model inside it.

    pip install decider-ai
    python agent.py

A gecko creeps up on a resting dragonfly. There is no window: the world is
one number. This file asks no server. It loads the model decider-2b and runs
it on this computer. The first run downloads the model: 3.8 GB.
"""
from decider.infer import Decider

JUMP = 2                  # how far a jump reaches, in steps

# Who the animal is, and its rules. The model reads these every time.
WHO = "You are a gecko. You hunt a dragonfly that rests."
RULES = "If it is too far to jump at, creep closer. If it is close enough, jump."

# The moves the gecko can choose from, and what each one is for.
MOVES = {
    "creep": "Creep closer. Do this when the dragonfly is too far to jump at.",
    "jump": "Jump at it. Do this when the dragonfly is close enough.",
}


def ask(model, sees):
    """Give the model the rules, what the gecko sees, and the moves. Give back the move."""
    question = {"type": "choice",
                "instructions": "What should you do right now?",
                "criteria": MOVES}
    state = WHO + " Rules: " + RULES + "\n\nSituation: " + sees
    answer = model.system_one(state, {"move": question})
    return answer["answers"]["move"]["choice"]


def main():
    model = Decider("Mapika/decider-2b")      # load the model: slow, so do it once
    far = 5                   # the whole world: steps from the gecko to the dragonfly
    for turn in range(10):
        # 1. See. The model reads words, so the number becomes a sentence.
        sees = "It is too far to jump at."
        if far <= JUMP:
            sees = "It is close enough to jump at."
        # 2. Ask. The model picks one move.
        move = ask(model, sees)
        print(far, "steps away.", sees, "->", move)
        # 3. Act. The program changes the world. The model never does.
        if move == "jump":
            if far <= JUMP:
                print("The gecko catches the dragonfly.")
            else:
                print("The jump is too short. The dragonfly flies away.")
            return
        far = far - 1         # the move was creep: one step closer
    print("The gecko never jumped.")


if __name__ == "__main__":
    main()

🖨 WHAT IT PRINTED

5 steps away. It is too far to jump at. -> creep
4 steps away. It is too far to jump at. -> creep
3 steps away. It is too far to jump at. -> creep
2 steps away. It is close enough to jump at. -> jump
The gecko catches the dragonfly.