D:\>pip install freegames -i https://pypi.tuna.tsinghua.edu.cn/simple/
Looking in indexes: https://pypi.tuna.tsinghua.edu.cn/simple/
Collecting freegames
  Downloading https://pypi.tuna.tsinghua.edu.cn/packages/62/f5/643ebe95085f1fea2
d8e4597259d8c56a920df1ed10dcfb65d7b80caff4f/freegames-2.4.0-py3-none-any.whl (10
8 kB)
     ------------------------------------ 109.0/109.0 kB 528.1 kB/s eta 0:00:00
Installing collected packages: freegames
Successfully installed freegames-2.4.0

D:\>python -m freegames list
ant
bagels
bounce
cannon
connect
crypto
fidget
flappy
guess
life
madlibs
maze
memory
minesweeper
pacman
paint
pong
simonsays
snake
tictactoe
tiles
tron

"""Maze, move from one side to another.
Excercises
1. Keep score by counting taps.
2. Make the maze harder.
3. Generate the same maze twice.
"""
 
from random import random
from turtle import *
 
from freegames import line
 
 
def draw():
    """Draw maze."""
    color('black')
    width(5)
 
    for x in range(-200, 200, 40):
        for y in range(-200, 200, 40):
            if random() > 0.5:
                line(x, y, x + 40, y + 40)
            else:
                line(x, y + 40, x + 40, y)
 
    update()
 
 
def tap(x, y):
    """Draw line and dot for screen tap."""
    if abs(x) > 198 or abs(y) > 198:
        up()
    else:
        down()
 
    width(2)
    color('red')
    goto(x, y)
    dot(4)
 
 
setup(420, 420, 370, 0)
hideturtle()
tracer(False)
draw()
onscreenclick(tap)
done()

"""Snake, classic arcade game.
Exercises
1. How do you make the snake faster or slower?
2. How can you make the snake go around the edges?
3. How would you move the food?
4. Change the snake to respond to mouse clicks.
"""
 
from random import randrange
from turtle import *
 
from freegames import square, vector
 
food = vector(0, 0)
snake = [vector(10, 0)]
aim = vector(0, -10)
 
 
def change(x, y):
    """Change snake direction."""
    aim.x = x
    aim.y = y
 
 
def inside(head):
    """Return True if head inside boundaries."""
    return -200 < head.x < 190 and -200 < head.y < 190
 
 
def move():
    """Move snake forward one segment."""
    head = snake[-1].copy()
    head.move(aim)
 
    if not inside(head) or head in snake:
        square(head.x, head.y, 9, 'red')
        update()
        return
 
    snake.append(head)
 
    if head == food:
        print('Snake:', len(snake))
        food.x = randrange(-15, 15) * 10
        food.y = randrange(-15, 15) * 10
    else:
        snake.pop(0)
 
    clear()
 
    for body in snake:
        square(body.x, body.y, 9, 'black')
 
    square(food.x, food.y, 9, 'green')
    update()
    ontimer(move, 100)
 
 
setup(420, 420, 370, 0)
hideturtle()
tracer(False)
listen()
onkey(lambda: change(10, 0), 'Right')
onkey(lambda: change(-10, 0), 'Left')
onkey(lambda: change(0, 10), 'Up')
onkey(lambda: change(0, -10), 'Down')
move()
done()

>>> from freegames import square, vector

>>> import freegames
>>> freegames.__all__
['floor', 'line', 'path', 'square', 'vector']

CLASSES
    collections.abc.Sequence(collections.abc.Reversible, collections.abc.Collection)
        freegames.utils.vector
    
    class vector(collections.abc.Sequence)
     |  vector(x, y)
     |  
     |  Two-dimensional vector.
     |  
     |  Vectors can be modified in-place.
     |  
     |  >>> v = vector(0, 1)
     |  >>> v.move(1)
     |  >>> v
     |  vector(1, 2)
     |  >>> v.rotate(90)
     |  >>> v
     |  vector(-2.0, 1.0)
     |  
     |  Method resolution order:
     |      vector
     |      collections.abc.Sequence
     |      collections.abc.Reversible
     |      collections.abc.Collection
     |      collections.abc.Sized
     |      collections.abc.Iterable
     |      collections.abc.Container
     |      builtins.object
     |  
     |  Methods defined here:
     |  
     |  __abs__(self)
     |      v.__abs__() -> abs(v)
     |      
     |      >>> v = vector(3, 4)
     |      >>> abs(v)
     |      5.0
     |  
     |  __add__(self, other)
     |      v.__add__(w) -> v + w
     |      
     |      >>> v = vector(1, 2)
     |      >>> w = vector(3, 4)
     |      >>> v + w
     |      vector(4, 6)
     |      >>> v + 1
     |      vector(2, 3)
     |      >>> 2.0 + v
     |      vector(3.0, 4.0)
     |  
     |  __eq__(self, other)
     |      v.__eq__(w) -> v == w
     |      
     |      >>> v = vector(1, 2)
     |      >>> w = vector(1, 2)
     |      >>> v == w
     |      True
     |  
     |  __getitem__(self, index)
     |      v.__getitem__(v, i) -> v[i]
     |      
     |      >>> v = vector(3, 4)
     |      >>> v[0]
     |      3
     |      >>> v[1]
     |      4
     |      >>> v[2]
     |      Traceback (most recent call last):
     |          ...
     |      IndexError
     |  
     |  __hash__(self)
     |      v.__hash__() -> hash(v)
     |      
     |      >>> v = vector(1, 2)
     |      >>> h = hash(v)
     |      >>> v.x = 2
     |      Traceback (most recent call last):
     |          ...
     |      ValueError: cannot set x after hashing
     |  
     |  __iadd__(self, other)
     |      v.__iadd__(w) -> v += w
     |      
     |      >>> v = vector(1, 2)
     |      >>> w = vector(3, 4)
     |      >>> v += w
     |      >>> v
     |      vector(4, 6)
     |      >>> v += 1
     |      >>> v
     |      vector(5, 7)
     |  
     |  __imul__(self, other)
     |      v.__imul__(w) -> v *= w
     |      
     |      >>> v = vector(1, 2)
     |      >>> w = vector(3, 4)
     |      >>> v *= w
     |      >>> v
     |      vector(3, 8)
     |      >>> v *= 2
     |      >>> v
     |      vector(6, 16)
     |  
     |  __init__(self, x, y)
     |      Initialize vector with coordinates: x, y.
     |      
     |      >>> v = vector(1, 2)
     |      >>> v.x
     |      1
     |      >>> v.y
     |      2
     |  
     |  __isub__(self, other)
     |      v.__isub__(w) -> v -= w
     |      
     |      >>> v = vector(1, 2)
     |      >>> w = vector(3, 4)
     |      >>> v -= w
     |      >>> v
     |      vector(-2, -2)
     |      >>> v -= 1
     |      >>> v
     |      vector(-3, -3)
     |  
     |  __itruediv__(self, other)
     |      v.__itruediv__(w) -> v /= w
     |      
     |      >>> v = vector(2, 4)
     |      >>> w = vector(4, 8)
     |      >>> v /= w
     |      >>> v
     |      vector(0.5, 0.5)
     |      >>> v /= 2
     |      >>> v
     |      vector(0.25, 0.25)
     |  
     |  __len__(self)
     |      v.__len__() -> len(v)
     |      
     |      >>> v = vector(1, 2)
     |      >>> len(v)
     |      2
     |  
     |  __mul__(self, other)
     |      v.__mul__(w) -> v * w
     |      
     |      >>> v = vector(1, 2)
     |      >>> w = vector(3, 4)
     |      >>> v * w
     |      vector(3, 8)
     |      >>> v * 2
     |      vector(2, 4)
     |      >>> 3.0 * v
     |      vector(3.0, 6.0)
     |  
     |  __ne__(self, other)
     |      v.__ne__(w) -> v != w
     |      
     |      >>> v = vector(1, 2)
     |      >>> w = vector(3, 4)
     |      >>> v != w
     |      True
     |  
     |  __neg__(self)
     |      v.__neg__() -> -v
     |      
     |      >>> v = vector(1, 2)
     |      >>> -v
     |      vector(-1, -2)
     |  
     |  __radd__ = __add__(self, other)
     |  
     |  __repr__(self)
     |      v.__repr__() -> repr(v)
     |      
     |      >>> v = vector(1, 2)
     |      >>> repr(v)
     |      'vector(1, 2)'
     |  
     |  __rmul__ = __mul__(self, other)
     |  
     |  __sub__(self, other)
     |      v.__sub__(w) -> v - w
     |      
     |      >>> v = vector(1, 2)
     |      >>> w = vector(3, 4)
     |      >>> v - w
     |      vector(-2, -2)
     |      >>> v - 1
     |      vector(0, 1)
     |  
     |  __truediv__(self, other)
     |      v.__truediv__(w) -> v / w
     |      
     |      >>> v = vector(1, 2)
     |      >>> w = vector(3, 4)
     |      >>> w / v
     |      vector(3.0, 2.0)
     |      >>> v / 2
     |      vector(0.5, 1.0)
     |  
     |  copy(self)
     |      Return copy of vector.
     |      
     |      >>> v = vector(1, 2)
     |      >>> w = v.copy()
     |      >>> v is w
     |      False
     |  
     |  move(self, other)
     |      Move vector by other (in-place).
     |      
     |      >>> v = vector(1, 2)
     |      >>> w = vector(3, 4)
     |      >>> v.move(w)
     |      >>> v
     |      vector(4, 6)
     |      >>> v.move(3)
     |      >>> v
     |      vector(7, 9)
     |  
     |  rotate(self, angle)
     |      Rotate vector counter-clockwise by angle (in-place).
     |      
     |      >>> v = vector(1, 2)
     |      >>> v.rotate(90)
     |      >>> v == vector(-2, 1)
     |      True
     |  
     |  scale(self, other)
     |      Scale vector by other (in-place).
     |      
     |      >>> v = vector(1, 2)
     |      >>> w = vector(3, 4)
     |      >>> v.scale(w)
     |      >>> v
     |      vector(3, 8)
     |      >>> v.scale(0.5)
     |      >>> v
     |      vector(1.5, 4.0)
     |  
     |  ----------------------------------------------------------------------
     |  Data descriptors defined here:
     |  
     |  x
     |      X-axis component of vector.
     |      
     |      >>> v = vector(1, 2)
     |      >>> v.x
     |      1
     |      >>> v.x = 3
     |      >>> v.x
     |      3
     |  
     |  y
     |      Y-axis component of vector.
     |      
     |      >>> v = vector(1, 2)
     |      >>> v.y
     |      2
     |      >>> v.y = 5
     |      >>> v.y
     |      5
     |  
     |  ----------------------------------------------------------------------
     |  Data and other attributes defined here:
     |  
     |  PRECISION = 6
     |  
     |  __abstractmethods__ = frozenset()
     |  
     |  ----------------------------------------------------------------------
     |  Methods inherited from collections.abc.Sequence:
     |  
     |  __contains__(self, value)
     |  
     |  __iter__(self)
     |  
     |  __reversed__(self)
     |  
     |  count(self, value)
     |      S.count(value) -> integer -- return number of occurrences of value
     |  
     |  index(self, value, start=0, stop=None)
     |      S.index(value, [start, [stop]]) -> integer -- return first index of value.
     |      Raises ValueError if the value is not present.
     |      
     |      Supporting start and stop arguments is optional, but
     |      recommended.
     |  
     |  ----------------------------------------------------------------------
     |  Class methods inherited from collections.abc.Reversible:
     |  
     |  __subclasshook__(C) from abc.ABCMeta
     |      Abstract classes can override this to customize issubclass().
     |      
     |      This is invoked early on by abc.ABCMeta.__subclasscheck__().
     |      It should return True, False or NotImplemented.  If it returns
     |      NotImplemented, the normal algorithm is used.  Otherwise, it
     |      overrides the normal algorithm (and the outcome is cached).
 
FUNCTIONS
    floor(value, size, offset=200)
        Floor of `value` given `size` and `offset`.
        
        The floor function is best understood with a diagram of the number line::
        
             -200  -100    0    100   200
            <--|--x--|-----|--y--|--z--|-->
        
        The number line shown has offset 200 denoted by the left-hand tick mark at
        -200 and size 100 denoted by the tick marks at -100, 0, 100, and 200. The
        floor of a value is the left-hand tick mark of the range where it lies. So
        for the points show above: ``floor(x)`` is -200, ``floor(y)`` is 0, and
        ``floor(z)`` is 100.
        
        >>> floor(10, 100)
        0.0
        >>> floor(120, 100)
        100.0
        >>> floor(-10, 100)
        -100.0
        >>> floor(-150, 100)
        -200.0
        >>> floor(50, 167)
        -33.0
    
    line(a, b, x, y)
        Draw line from `(a, b)` to `(x, y)`.
    
    path(filename)
        Return full path to `filename` in freegames module.
    
    square(x, y, size, name)
        Draw square at `(x, y)` with side length `size` and fill color `name`.
        
        The square is oriented so the bottom left corner is at (x, y).