PyGame : First interface - part 8.

The PyGame - first interface is a series of python tutorials using PyGame python module and other python modules that help us create a good interface.
If you look at the Wikipedia website then the first phrase is clear:
  In computing, an interface is a shared boundary across which two or more separate components of a computer system exchange information.
Today I will start with ThorPy python module.
This python module comes with the version 1.5.9.
You can read more about this python and test examples at the official webpage.
You can install this python module with the pip tool:

c:\Python364\Scripts>pip install thorpy
Collecting thorpy
  Downloading https://files.pythonhosted.org/packages/09/aa/...
.../thorpy-1.6.tar.gz (373kB)
    100% |████████████████████████████████| 378kB 374kB/s
<5 .10="" python_version=""><2 .0.0=""><2 .0.0="">...
Installing collected packages: thorpy
Successfully installed thorpy-1.6

This is the result of submenus from official website.

PyGame : Test with an animated image.

This is a simple tutorial about how to create a bouncing ball effect with pygame python module.
The source code is very simple and you need a transparent image named earth.png .
The variables I used is size, speed, ball, ballrect.
I used ballrect with  get_rect().
The result get pygame Rect object.
This  has several virtual attributes which can be used to move and align the Rect:

• x,y
• top, left, bottom, right
• topleft, bottomleft, topright, bottomright
• midtop, midleft, midbottom, midright
• center, centerx, centery
• size, width, height
• w,h

All of these attributes can be assigned to ballrect variable.

import sys
import pygame
pygame.init()
 
size = width, height = 640, 420
speed = [1, 1]
black = 0, 0, 0
 
screen = pygame.display.set_mode(size)
 
ball = pygame.image.load("earth.png")
ballrect = ball.get_rect()
 
while 1:
    for event in pygame.event.get():
        if event.type == pygame.QUIT: sys.exit()
 
    ballrect = ballrect.move(speed)
    if ballrect.left < 0 or ballrect.right > width:
        speed[0] = -speed[0]
    if ballrect.top < 0 or ballrect.bottom > height:
        speed[1] = -speed[1]
 
    screen.fill(black)
    screen.blit(ball, ballrect)
    pygame.display.flip()

pygame.display.update()

The result of this source code :

PyGame : The pymunk python module.

First about pymunk python module:
Pymunk is an easy-to-use pythonic 2d physics library that can be used whenever you need 2d rigid body physics from Python. Perfect when you need 2d physics in your game, demo or other application!
I install it with pip and python 2.7 and I test it with one example from the official website.
The source code is this:

import sys, random
import os

description = """
---- Newton's Cradle ----
A screensaver version of Newton's Cradle with an interactive mode
/s - Run in fullscreen screensaver mode
/p #### - Display a preview of the screensaver using a window handler
/i - Interactive mode
"""

if len(sys.argv) < 2:
    print(description)
    sys.exit()

is_interactive = False
display_flags = 0
if sys.argv[1] == "/p":  # preview mode
    os.environ['SDL_VIDEODRIVER'] = 'windib'
    os.environ['SDL_WINDOWID'] = sys.argv[2]
    display_size = (100, 100)
    is_interactive = False

### We must set OS env before the pygame imports..
import pygame
from pygame.locals import *
from pygame.color import *

if sys.argv[1] == "/s":  # fullscreen screensaver mode
    display_size = (0, 0)
    is_interactive = False
    display_flags = display_flags | FULLSCREEN  # FULLSCREEN) # | DOUBLEBUF | HWSURFACE     )
elif sys.argv[1] == "/i":  # interactive
    display_size = (600, 600)
    is_interactive = True

import pymunk as pm
from pymunk import Vec2d


def drawcircle(image, colour, origin, radius, width=0):
    if width == 0:
        pygame.draw.circle(image, colour, origin, int(radius))
    else:
        if radius > 65534 / 5:
            radius = 65534 / 5
        circle = pygame.Surface([radius * 2 + width, radius * 2 + width]).convert_alpha()
        circle.fill([0, 0, 0, 0])
        pygame.draw.circle(circle, colour, [circle.get_width() / 2, circle.get_height() / 2], radius + (width / 2))
        if int(radius - (width / 2)) > 0:
            pygame.draw.circle(circle, [0, 0, 0, 0], [circle.get_width() / 2, circle.get_height() / 2],
                               abs(int(radius - (width / 2))))
        image.blit(circle, [origin[0] - (circle.get_width() / 2), origin[1] - (circle.get_height() / 2)])

def reset_bodies(space):
    for body in space.bodies:
        body.position = Vec2d(body.start_position)
        body.force = 0, 0
        body.torque = 0
        body.velocity = 0, 0
        body.angular_velocity = 0
    color = random.choice(list(THECOLORS.values()))
    for shape in space.shapes:
        shape.color = color

def main():
    pygame.init()
    screen = pygame.display.set_mode(display_size, display_flags)
    width, height = screen.get_size()

    def to_pygame(p):
        """Small hack to convert pymunk to pygame coordinates"""
        return int(p.x), int(-p.y + height)

    def from_pygame(p):
        return to_pygame(p)

    clock = pygame.time.Clock()
    running = True
    font = pygame.font.Font(None, 16)

    ### Physics stuff
    space = pm.Space()
    space.gravity = (0.0, -1900.0)
    space.damping = 0.999  # to prevent it from blowing up.
    mouse_body = pm.Body(body_type=pm.Body.KINEMATIC)

    bodies = []
    for x in range(-100, 150, 50):
        x += width / 2
        offset_y = height / 2
        mass = 10
        radius = 25
        moment = pm.moment_for_circle(mass, 0, radius, (0, 0))
        body = pm.Body(mass, moment)
        body.position = (x, -125 + offset_y)
        body.start_position = Vec2d(body.position)
        shape = pm.Circle(body, radius)
        shape.elasticity = 0.9999999
        space.add(body, shape)
        bodies.append(body)
        pj = pm.PinJoint(space.static_body, body, (x, 125 + offset_y), (0, 0))
        space.add(pj)

    reset_bodies(space)
    selected = None

    if not is_interactive:
        pygame.time.set_timer(USEREVENT + 1, 70000)  # apply force
        pygame.time.set_timer(USEREVENT + 2, 120000)  # reset
        pygame.event.post(pygame.event.Event(USEREVENT + 1))
        pygame.mouse.set_visible(False)

    while running:
        for event in pygame.event.get():
            if event.type == QUIT:
                running = False
            elif event.type == KEYDOWN and event.key == K_p:
                pygame.image.save(screen, "newtons_cradle.png")

            if event.type == pygame.USEREVENT + 1:
                r = random.randint(1, 4)
                for body in bodies[0:r]:
                    body.apply_impulse_at_local_point((-6000, 0))
            if event.type == pygame.USEREVENT + 2:
                reset_bodies(space)

            elif event.type == KEYDOWN and event.key == K_r and is_interactive:
                reset_bodies(space)
            elif event.type == KEYDOWN and event.key == K_f and is_interactive:
                r = random.randint(1, 4)
                for body in bodies[0:r]:
                    body.apply_impulse_at_local_point((-6000, 0))

            elif event.type == MOUSEBUTTONDOWN and is_interactive:
                if selected != None:
                    space.remove(selected)
                p = from_pygame(Vec2d(event.pos))
                hit = space.point_query_nearest(p, 0, pm.ShapeFilter())
                if hit != None:
                    shape = hit.shape
                    rest_length = mouse_body.position.get_distance(shape.body.position)
                    ds = pm.DampedSpring(mouse_body, shape.body, (0, 0), (0, 0), rest_length, 1000, 10)
                    space.add(ds)
                    selected = ds

            elif event.type == MOUSEBUTTONUP and is_interactive:
                if selected != None:
                    space.remove(selected)
                    selected = None

            elif event.type == KEYDOWN:
                running = False
            elif event.type == MOUSEBUTTONDOWN:
                running = False

        mpos = pygame.mouse.get_pos()
        p = from_pygame(Vec2d(mpos))
        mouse_body.position = p

        ### Clear screen
        screen.fill(THECOLORS["black"])

        ### Draw stuff
        for c in space.constraints:
            pv1 = c.a.position + c.anchor_a
            pv2 = c.b.position + c.anchor_b
            p1 = to_pygame(pv1)
            p2 = to_pygame(pv2)
            pygame.draw.aalines(screen, THECOLORS["lightgray"], False, [p1, p2])

        for ball in space.shapes:
            p = to_pygame(ball.body.position)
            drawcircle(screen, ball.color, p, int(ball.radius), 0)
            # pygame.draw.circle(screen, ball.color, p, int(ball.radius), 0)

        ### Update physics
        fps = 50
        iterations = 25
        dt = 1.0 / float(fps) / float(iterations)
        for x in range(iterations):  # 10 iterations to get a more stable simulation
            space.step(dt)

        ### Flip screen
        if is_interactive:
            screen.blit(font.render("fps: " + str(clock.get_fps()), 1, THECOLORS["white"]), (0, 0))
            screen.blit(font.render("Press left mouse button and drag to interact", 1, THECOLORS["darkgrey"]),
                        (5, height - 35))
            screen.blit(font.render("Press R to reset, any other key to quit", 1, THECOLORS["darkgrey"]),
                        (5, height - 20))

        pygame.display.flip()
        clock.tick(fps)

if __name__ == '__main__':
    sys.exit(main()

I test with this command:

C:\Python27>python.exe newtons_cradle.py /i

The result work well, see the next image: 

PyGame : The experimental gfxdraw.

This is a tutorial about gfxdraw how to use.
Note: this is an EXPERIMENTAL feature for PyGame ( meaning this API may change, or disappear in later pygame releases).
First about this gfxdraw we can use this:

• pygame module for drawing shapes
• pygame.gfxdraw.pixel — place a pixel
• pygame.gfxdraw.hline — draw a horizontal line
• pygame.gfxdraw.vline — draw a vertical line
• pygame.gfxdraw.rectangle — draw a rectangle
• pygame.gfxdraw.box — draw a box
• pygame.gfxdraw.line — draw a line
• pygame.gfxdraw.circle — draw a circle
• pygame.gfxdraw.arc — draw an arc
• pygame.gfxdraw.aacircle — draw an anti-aliased circle
• pygame.gfxdraw.filled_circle — draw a filled circle
• pygame.gfxdraw.ellipse — draw an ellipse
• pygame.gfxdraw.aaellipse — draw an anti-aliased ellipse
• pygame.gfxdraw.filled_ellipse — draw a filled ellipse
• pygame.gfxdraw.pie — draw a pie
• pygame.gfxdraw.trigon — draw a triangle
• pygame.gfxdraw.aatrigon — draw an anti-aliased triangle
• pygame.gfxdraw.filled_trigon — draw a filled trigon
• pygame.gfxdraw.polygon — draw a polygon
• pygame.gfxdraw.aapolygon — draw an anti-aliased polygon
• pygame.gfxdraw.filled_polygon — draw a filled polygon
• pygame.gfxdraw.textured_polygon — draw a textured polygon
• pygame.gfxdraw.bezier — draw a Bézier curve

Nou about the example I will use into this tutorial. Is a very simple class with an anti-aliased ellipse.
This class used pygame.gfxdraw.aaellipse , see the doc:
pygame.gfxdraw.aaellipse()
    draw an anti-aliased ellipse
      aaellipse(surface, x, y, rx, ry, color) -> None
      Draws anti aliased edges of an ellipse onto a surface.

#!/usr/bin/python

import random
import math

import pygame
from pygame.locals import *
from pygame import *
from pygame import gfxdraw

#create a math function
def linear_interp(a, b, x):
 return a*(1-x) + b*x

#a class python to show on display
class Screen():
 def __init__(self):
  pygame.init()

  self.display_flags = DOUBLEBUF
  rect = self.width, self.height = 640, 480

  if pygame.display.mode_ok(rect, self.display_flags):
   self.screen = pygame.display.set_mode(rect, self.display_flags)

 def shell_print(self,text):
  print text

 def aaellipse(self,surface, x, y, rx, ry, color):
  pygame.gfxdraw.ellipse(surface, x, y, rx, ry, color)

show = Screen()

run = 1
clock = pygame.time.Clock()

show.shell_print("test")
show.aaellipse(show.screen, x=300, y=200, rx=100, ry=60, color=(8, 8, 160))

while run:
 events = pygame.event.get()

 for event in events:
  if event.type == QUIT:
   run = 0

 pygame.display.flip()

 clock.tick(60)

To understand the class methods I used two: shell_print and aaellipse.
The shell_print is used just to print a input text to python shell.
The aaellipse take all inputs for the default pygame.gfxdraw.ellipse.
The result is a simple blue ellipse at 300 and 200 points and sized with 100 and 60.
Another aspect to note is use of the surface into show.aaellipse : show.screen.
This means that the drawing screen is used and not another defined surface.
Of course we can change Screen class to help us - decorators, other defining surfaces, initializations...