PyGame : Using the fullscreen with PyGame.

In this tutorial, I will show you how to use the fullscreen feature with pygame python module.
The scrip I used uses two keys: F12 for fullscreen and ESC for quit to windows.
The script starts with the default initialization of the PyGame python module.
The open the window in fullscreen with a resolution of 1024x768.
Using the while True condition you can change it into window mode with a resolution of 640x480 by pressing the F12 key.
In this loop is set the key ESC to quit the application.

import pygame,sys
pygame.init()
#set the fullscreen - my display is 1024 by 576
screen = pygame.display.set_mode((1024, 576),pygame.FULLSCREEN,32) 
pygame.display.set_caption("Example fullscreen")
cursor_x,cursor_y = 0,0
cmddown = False
fullscreen = True
while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            pygame.quit()
            sys.exit()
        if event.type == pygame.KEYDOWN:
            #Toggle Fullscreen (press escape to exit/enter fullscreen)
            if event.key == pygame.K_F12:
                if fullscreen == True:
                    #exits fullscreen
                    screen = pygame.display.set_mode((640, 480)) 
                    pygame.display.set_caption("Example window 640x480")
                    fullscreen = False
                else:
                    screen = pygame.display.set_mode((1024, 576),pygame.FULLSCREEN,32)
                    pygame.display.set_caption("Example fullscreen 1024x768")
                    fullscreen = True
            if event.key == pygame.K_ESCAPE:
                if cmddown == True:
                    pygame.quit()
                    sys.exit()
        elif event.type == pygame.KEYUP:
            cmddown = False
    screen.fill((0,0,0))
    pygame.display.flip()

PyGame : Testing example of pygame module.

The Pygame python module is a good way to start programming games.
This python module comes with examples, see the official webpage.
These should help get you started with Pygame.
The source code for these examples is in the public domain.
Today I will show you how to find and run an example from this python module.
Let's start with these commands:

C:\Python373>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD6
4)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> import pygame.examples.aliens
pygame 1.9.6
Hello from the pygame community. https://www.pygame.org/contribute.html
>>> pygame.examples.aliens.__file__
'C:\\Python373\\lib\\site-packages\\pygame\\examples\\aliens.py'
>>> pygame.examples.aliens.main()

The result of running the aliens game.

PyGame : First interface - part 10.

Today I will create a maze can be used into pygame interface gaming area.
The algorithm starts at a random cell.
Mark the current cell as visited, and get a list of its neighbors.
Now, for each neighbor, starting with a randomly selected neighbor.
If that neighbor hasn't been visited, remove the wall between this cell and that neighbor.
Use this recourse idea with that neighbor as the current cell.
Let's see the source code:

import os
import pygame
from pygame.locals import *
from random import choice
# create a maze cell with rect sized 6 pixels
class maze_cell(pygame.sprite.Sprite):
    w, h = 6, 6

    def __init__(self, x, y, maze):
        pygame.sprite.Sprite.__init__(self)
        self.image = pygame.Surface([self.w, self.h])
        self.image.fill((0, 0, 255))
        self.rect = self.image.get_rect()
        self.rect.x = x * self.w
        self.rect.y = y * self.h

        self.x = x
        self.y = y
        self.maze = maze
        self.nbs = [(x + nx, y + ny) for nx, ny in ((-2, 0), (0, -2), (2, 0), (0, 2))
                    if 0 <= x + nx < maze.w and 0 <= y + ny < maze.h]
    # draw screen with pygame blit 
    def draw(self, screen):
        screen.blit(self.image, self.rect)
# create the maze wall 
class maze_wall(maze_cell):
    def __init__(self, x, y, maze):
        super(maze_wall, self).__init__(x, y, maze)
        self.image.fill((0, 0, 0))
        self.type = 0
# create the maze by generate into grid 
class create_maze:
    def __init__(self, size):
        self.w, self.h = size[0] // maze_cell.w, size[1] // maze_cell.h
        self.grid = [[maze_wall(x, y, self) for y in range(self.h)] for x in range(self.w)]

    def get(self, x, y):
        return self.grid[x][y]

    def place_maze_wall(self, x, y):
        self.grid[x][y] = maze_wall(x, y, self)

    def draw(self, screen):
        for row in self.grid:
            for maze_cell in row:
                maze_cell.draw(screen)

    def generate(self, screen=None, animate=False):
        
        unvisited = [c for r in self.grid for c in r if c.x % 2 and c.y % 2]
        cur = unvisited.pop()
        stack = []

        while unvisited:
            try:
                n = choice([c for c in map(lambda x: self.get(*x), cur.nbs) if c in unvisited])
                stack.append(cur)
                nx, ny = cur.x - (cur.x - n.x) // 2, cur.y - (cur.y - n.y) // 2
                self.grid[nx][ny] = maze_cell(nx, ny, self)
                self.grid[cur.x][cur.y] = maze_cell(cur.x, cur.y, self)
                cur = n
                unvisited.remove(n)

                if animate:
                    self.draw(screen)
                    pygame.display.update()
                    pygame.time.wait(10)
            except IndexError:
                if stack:
                    cur = stack.pop()

def draw_maze(screen):
    maze = create_maze(WINSIZE)
    maze.generate(screen, True)

WINSIZE = (maze_cell.w * 76, maze_cell.h * 76)

def main():
    pygame.init()
    screen = pygame.display.set_mode(WINSIZE)
    pygame.display.set_caption('Generate maze')
    screen.fill((0, 0, 0))
    clock = pygame.time.Clock()

    draw_maze(screen)

    done = 0

    while not done:
        for e in pygame.event.get():
            if e.type == QUIT or (e.type == KEYUP and e.key == K_ESCAPE):
                done = 1
        pygame.display.update()
        clock.tick()

if __name__ == '__main__':
    main()

The result of this source code:

PyGame : First interface - part 9.

Today I start with another tutorial with pygame python module and python version 3.7.3.
For this series of tutorials, I will introduce you a radar interface.
The advantages of using such an interface are evident from technical considerations and not only. This type of interface is very used in games because most users have become accustomed to it.
Let's start installing the pygame python module.

C:\Python373\Scripts>pip install pygame
Requirement already satisfied: pygame in c:\python373\lib\site-packages (1.9.6)

I try to follow some goals, like:

• install pygame with pip tool for python 3.7.3;
• create an interface for drawing;
• use a configuration with values, see: screen_size;
• use events to stop the script;
• use line and circle with math and radians;
• use the pygame.gfxdraw module to draw lines and circles;

This python script is simple to understand:

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

configuration = {
        'screen_size': (500,500),
}
pygame.init()
screen = pygame.display.set_mode(configuration['screen_size'])
FPSCLOCK = pygame.time.Clock()
done = False
screen.fill((0, 0, 0))
azimuth_degrees=0
while not done:
    screen.fill(0)
    # get events
    for e in pygame.event.get():
        if e.type == QUIT or (e.type == KEYDOWN and e.key == K_ESCAPE):
            done = True
            break
    screen.fill((0, 0, 0))
    # radar position on window     
    radar = (250,250)
    # radar lenght 
    radar_len = 276
    for x in range(1, 250, 30):
        # radar circle position on window
        pygame.gfxdraw.circle(screen,radar[0],radar[1],x,(0,0,255))   

    # calculate the x and y radar beam
    x = radar[0] + math.cos(math.radians( azimuth_degrees)) * radar_len
    y = radar[1] + math.sin(math.radians( azimuth_degrees)) * radar_len
    
    # then render the line radar with value (x,y)
    pygame.gfxdraw.line(screen, radar[0],radar[1], int(x),int(y), Color("blue"))
    pygame.display.flip() 

      
    azimuth_degrees+=1
    FPSCLOCK.tick(40)

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: