PyGame : First interface - part 3.

Today I will show you just a few tips about pygame window.
If we want to put the window in the center of the screen we can use this:

import os
os.environ['SDL_VIDEO_CENTERED'] = '1'

Most of the pygame windows are made by :

def main():
  background_colour = (25,25,255)
  screen = pygame.display.set_mode((320,240))
  screen.fill(background_colour)

This will create this window:

Now if you don't need a title window, like the next image...

... then you need to use this source code :

  screen = pygame.display.set_mode((320,240),NOFRAME)

PyGame : The pygame module come without font module.

Today I try to see some old python source code.
I got this error and seam many python users have the same error.

NotImplementedError: font module not available
(ImportError: No module named font)

It's the last release of pygame.
When I try to config the pygame I got this

pygame-1.9.1release]$ python2.7 config.py
Using UNIX configuration...


Backup existing "Setup" file [Y/n]:

Hunting dependencies...
sh: smpeg-config: command not found
WARNING: "smpeg-config" failed!
SDL     : found 1.2.13
FONT    : not found
IMAGE   : found
MIXER   : not found
SMPEG   : not found
PNG     : found
JPEG    : found
SCRAP   : found
PORTMIDI: not found
PORTTIME: not found


Warning, some of the pygame dependencies were not found. Pygame can still
compile and install, but games that depend on those missing dependencies
will not run. Would you like to continue the configuration? [Y/n]:

Not only the FONT is not here. I will try to fix this issue.

PyGame : 5 simple rules help you to programming in pygame.

Some rules when you want to use pygame:
1. Use hardware rendering :

>>> import pygame 
>>> show=pygame.display.set_mode((400,400), pygame.HWSURFACE | pygame.DOUBLEBUF)

2. Use function convert and load BMP file.

>>> im=pygame.image.load("9.bmp").convert()

... also you got the error:

>>> im2=pygame.image.load("9.png")
Traceback (most recent call last):
  File "", line 1, in 
pygame.error: File is not a Windows BMP file

3. Don't use reserved words in your variables, like display, time ...
4. Be advice about low performance. For example, a simple 2D game no needs to use threads. Also the bad configuration of game, wrong sprites, group classes used or using unoptimized images heavily and you will have a low performance.
5. Use the profiler to test how much time your game spend on event handling, computing, and drawing. Don't guess what is wrong?

PyGame : Test class show text "Hello World" .

I wrote in my journal:
Today I received an email in which I asked about python and how to display a text message. I hate this approach, especially on the internet there are hundreds of materials on this subject.
This made ​​me remember my blog and I write a new tutorial on pygame.
I use the old class from last pygame tutorials, see here.
The source code it's pretty simple.
The news is function show_text().
To do this I use pygame functions, see pygame documentation.
Let's see the final source code.

import pygame
from pygame.locals import *

screen_mode = (640, 480)
color_black = 0, 0, 0

class Game:
 def __init__(self):
  pygame.init()
  self.screen = pygame.display.set_mode(screen_mode)
  pygame.display.set_caption("Pygame text window")

  self.quit = False
  
 def update(self):
  print "update function"
  self.show_text()
  return
 
 def draw(self):
  self.screen.fill(color_black)
  self.show_text()
  pygame.display.flip()

 def show_text(self):
  font = pygame.font.Font(None, 36)
  text = font.render("Hello World!", 1, (100, 100, 100))
  textpos = text.get_rect()
  textpos.centerx = self.screen.get_rect().centerx
  self.screen.blit(text, textpos)

 def mainLoop(self):

  while not self.quit:
   for event in pygame.event.get():
    if event.type == pygame.QUIT:
     self.quit = True
    elif  event.type  == pygame.MOUSEBUTTONDOWN:
     print pygame.mouse.get_pressed()
     
     self.update()
   self.draw()
 
if __name__ == '__main__':
 game = Game()
 game.mainLoop()

The result is this:

PyGame : Test mouse class.

Today I will show how to test mouse with pygame.
This is very simple, just you try to use MOUSEBUTTONDOWN.
Also, the click mouse only registers once so you can use it with another event.
If you don't want to use an event handler, you can check for input with:

pygame.mouse.get_pos() 
pygame.mouse.get_pressed()

I created a class called Game, which contains four functions.
A function that needs to pay attention is mainLoop.
This function deals with events in the following order.
While there is no event QUIT then read events.
If there is event QUIT or MOUSEBUTTONDOWN then is running this:
Event QUIT the program is quit.
Event MOUSEBUTTONDOWN print mouse events next use update function with print "update function".
Press mouse buttons: left,right,mouse wheel ,spinning mouse wheel.

(1, 0, 0)
update function
(0, 0, 1)
update function
(0, 1, 0)
update function
(0, 0, 0)
update function

The code is shown below.

import pygame
from pygame.locals import *

screen_mode = (640, 480)
color_black = 0, 0, 0

class Game:
 def __init__(self):
  pygame.init()
  self.screen = pygame.display.set_mode(screen_mode)
  pygame.display.set_caption("Pygame first window")
  self.quit = False
  
 def update(self):
  print "update function"
  return
  
 def draw(self):
  self.screen.fill(color_black)
  pygame.display.flip()
  
 def mainLoop(self):
  while not self.quit:
   for event in pygame.event.get():
    if event.type == pygame.QUIT:
     self.quit = True
    elif  event.type  == pygame.MOUSEBUTTONDOWN:
     print pygame.mouse.get_pressed()
     self.update()
   self.draw()
 
if __name__ == '__main__':
 game = Game()
 game.mainLoop()

PyGame : The script tool with colors.

This is a simple script to allow us to see all colors used by pygame.

import pygame
from pygame.locals import *
from pygame.color import THECOLORS
from time import sleep

def main():
    WINSIZE = 640,480
    pygame.init()
    screen = pygame.display.set_mode(WINSIZE,0,8)
    pygame.display.set_caption('Colors in pygame!')

    for i,j in THECOLORS.iteritems():
        print i
 screen.fill(THECOLORS[i])
 font = pygame.font.Font(None, 36)
 text = font.render(i, 1,(0,0,0),(100,100,100))
 sleep(1.1)
 textpos = text.get_rect()
 textpos.centerx = screen .get_rect().centerx
 screen.blit(text, textpos)
 pygame.display.update()

if __name__=="__main__":
    main()

The script is very simple, just try it.

PyGame : The pygame.display routines

Start pygame display:

C:\>python
Python 2.7 (r27:82525, Jul  4 2010, 09:01:59) [MSC v.1500 32 bit (Intel)] on win
32
Type "help", "copyright", "credits" or "license" for more information.
>>> import pygame
>>> pygame.display.init()

pygame.display.Info() creates an object with some data about hardware:

>>> pygame.display.Info()

Here is the interpretation of the output.

hw: True if the display is hardware accelerated
wm: True if windowed display modes can be used
video_mem: The megabytes of video memory on the display. This is 0 if unknown
bitsize: Number of bits used to store each pixel
bytesize: Number of bytes used to store each pixel
masks: Four values used to pack RGBA values into pixels
shifts: Four values used to pack RGBA values into pixels
losses: Four values used to pack RGBA values into pixels
blit_hw: True if hardware Surface blitting is accelerated
blit_hw_CC: True if hardware Surface colorkey blitting is accelerated
blit_hw_A: True if hardware Surface pixel alpha blitting is accelerated
blit_sw: True if software Surface blitting is accelerated
blit_sw_CC: True if software Surface colorkey blitting is accelerated
blit_sw_A: True if software Surface pixel alpha blitting is acclerated
current_h, current_h: Width and height of the current video mode, or of the
desktop mode if called before the display.set_mode is called.

This will return the name of the currently running video driver.

>>> pygame.display.get_driver()
'directx'

Without arguments, list_modes returns a list of possible dimensions

>>> pygame.display.list_modes()
[(1024, 600), (800, 600), (640, 480), (640, 400), (600, 1024), (600, 800), (512,
 384), (480, 640), (400, 640), (400, 300), (384, 512), (320, 240), (320, 200)]

How to query a specific display mode.

>>> full=pygame.FULLSCREEN | pygame.HWSURFACE | pygame.DOUBLEBUF
>>> pygame.display.mode_ok( [ 800,600 ], full, 32)
32

You can create such a script to help you.

>>> for i in pygame.display.list_modes():
...     a=pygame.display.mode_ok(i,full,16)
...     print "FULLSCREEN | HWSURFACE | DOUBLEBUF for "+str(i)+" x "+str(a)
...
FULLSCREEN | HWSURFACE | DOUBLEBUF for (1024, 600) x 16
FULLSCREEN | HWSURFACE | DOUBLEBUF for (800, 600) x 16
FULLSCREEN | HWSURFACE | DOUBLEBUF for (640, 480) x 16
FULLSCREEN | HWSURFACE | DOUBLEBUF for (640, 400) x 16
FULLSCREEN | HWSURFACE | DOUBLEBUF for (600, 1024) x 16
FULLSCREEN | HWSURFACE | DOUBLEBUF for (600, 800) x 16
FULLSCREEN | HWSURFACE | DOUBLEBUF for (512, 384) x 16
FULLSCREEN | HWSURFACE | DOUBLEBUF for (480, 640) x 16
FULLSCREEN | HWSURFACE | DOUBLEBUF for (400, 640) x 16
FULLSCREEN | HWSURFACE | DOUBLEBUF for (400, 300) x 16
FULLSCREEN | HWSURFACE | DOUBLEBUF for (384, 512) x 16
FULLSCREEN | HWSURFACE | DOUBLEBUF for (320, 240) x 16
FULLSCREEN | HWSURFACE | DOUBLEBUF for (320, 200) x 16

See more here.

PyGame : Using with Android.

What is Android?
Wikipedia says:
Android is an open-source software stack for mobile devices that includes an operating system, middleware, and key applications.[5][6] Google Inc. purchased the initial developer of the software, Android Inc.

Python on Android?

The Pygame Subset for Android is a port of a subset of Pygame functionality to the Android platform.
This pygame subset for Android, allows us the creation of Android-specific games.
In the chapter "samples" comes only with just one classic sliding numbers puzzle.
The good thing is, it can run on a PC.
I installed Fedora pygame with "yum install pygame" as root.
And I run the application example of "samples".
Here is the result:

It works great on Fedora.

PyGame : First interface - part 2

One thing necessary to create an interface and a game is using a "sprite system".
To illustrate this, I'll show you a sequence of source code:

import pygame
def must_quit():
    event = pygame.event.poll()
    return event.type == pygame.QUIT
screen = pygame.display.set_mode((640, 480))
SpriteImage = pygame.image.load('image.jpg')
while not must_quit():
    screen.blit(SpriteImage, (0, 0))
    pygame.display.flip()

It sounds simple but is not.
Why? Because when you work with multiple images when source code is more complicated.
For this we need a system and use the "classes".
Let's see:

class SpriteImage:
    def __init__(self, image_filename):
        self.image = pygame.image.load(image_filename)
    def paint(self):
        screen.blit(self.image, (0, 0))
screen = pygame.display.set_mode((640, 480))
sprite = SpriteImage('image.jpg')

This is a more simple way to use it.
Try learning more about pygame.
Good luck.

PyGame : Info about driver and zbuffer.

Sometimes is very easy to see some info about pygame.
Just use this code:

>>> import pygame 
>>> from pygame import * 
>>> pygame.init()
(6, 0)
>>> pygame.display.gl_set_attribute(GL_DEPTH_SIZE, 16)
>>> pygame.display.set_mode((640,480), OPENGL|DOUBLEBUF )

>>> print "ZBUFFER is:" ,pygame.display.gl_get_attribute(GL_DEPTH_SIZE)
ZBUFFER is: 24
>>> print "Driver is:", pygame.display.get_driver()
Driver is: x11

NOTE: The OpenGL flags are;

  GL_ALPHA_SIZE, GL_DEPTH_SIZE, GL_STENCIL_SIZE, GL_ACCUM_RED_SIZE,
  GL_ACCUM_GREEN_SIZE,  GL_ACCUM_BLUE_SIZE, GL_ACCUM_ALPHA_SIZE,
  GL_MULTISAMPLEBUFFERS, GL_MULTISAMPLESAMPLES, GL_STEREO

You can see more here.

PyGame : Binary bitmate with pygame.

Is a very simple example.
I use this code :

import pygame
from pygame.locals import *
import random
import Numeric
from math import *
import random
WIDTH = 640     #width of screen
HEIGHT = 480    #height of screen
def main():
    pygame.display.init()
    
    screen = pygame.display.set_mode((WIDTH,HEIGHT),DOUBLEBUF,32)
    pixels = pygame.surfarray.pixels3d(screen)
    
    width = len(pixels)-1
    height = len(pixels[0])-1
    
    for y in xrange(height):
        for x in xrange(width):
   a=random.choice([0,1])
   if a==1 : b=(255,255,255)
   else : b=(0,0,0)
   pixels[x,y] = (b)
    pygame.display.update()
    done = False
    while not done:
        for e in pygame.event.get():
            if e.type == KEYDOWN:
                done = True
if __name__ == "__main__":
    main()

The most important is this line : 
pixels = pygame.surfarray.pixels3d(screen)
I use the random function to select "0" or "1" and set the colors.
Next, I fill the screen by update the screen with new values of pixels : pygame.display.update()
See below the result :

PyGame : First interface - part 1

This is the first game based on pygame that I tried to use interface.
As shown in the picture below, we have three areas:

• One at the top where there will be characters
• One at the bottom where there will be buttons
• A mini map on bottom left

I do not want to display the source code yet since it is rough.
I will present in future in a more understandable formula.
Good luck.

PyGame : OpenGL - part 2.

Today I will show you how we find stuff about graphics hardware.
We will use two modules: pyopengl and pygame.
Modules can import other modules.
Each module is only imported once per interpreter session.

>>> import pygame 
>>> import OpenGL 

The imports are taken in the local symbol table, so we need to do this:

>>> from pygame import *
>>> from OpenGL import *
>>> from OpenGL.GL import * 
>>> from OpenGL.GLUT import * 

The next thing you must do is call the function glutInit.

>>> glutInit()
['foo']

Use pygame init function to initialize the window:

>>> pygame.init()
(6, 0)
>>> pygame.display.set_mode((10,10),OPENGL|DOUBLEBUF)

Note:If we not create the window the next commands will not work.
About the beautiful glGetString function, we know.
This return a string describing the current GL connection.
You can use dir() and help() functions to see more.
But we see bellow, some example:

>>> dir(glGetString)
['__call__', '__class__', '__ctypes_from_outparam__', '__delattr__',
 '__dict__','__doc__', '__format__', '__getattribute__', '__hash__',
 '__init__', '__module__',
 '__name__', '__new__', '__nonzero__', '__reduce__', '__reduce_ex__', 
'__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', 
'__subclasshook__',
 '__weakref__', '_b_base_', '_b_needsfree_', '_flags_', '_objects', 
'_restype_', 'argtypes', 'errcheck', 'restype']
>>> dir(glGetString())
['__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', 
'__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', 
'__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

Now, the parameters of this function are :

glGetString(GL_VERSION)
glGetString(GL_VENDOR)
glGetString(GL_RENDERER)
glGetStringi(GL_EXTENSIONS, i) 

Bellow, we see how we use these parameters:

>>> glGetString(GL_VERSION) 
'2.1.2 NVIDIA 173.14.22'
>>> glGetString(GL_VENDOR) 
'NVIDIA Corporation'
>>> glGetString(GL_RENDERER) 
'GeForce FX 5200/AGP/SSE/3DNOW!'

Because the GL_EXTENSIONS is a space-separated list of supported extensions to GL, we can use these commands:

>>> print glGetString(GL_EXTENSIONS)

Or you can format this result, see below

>>> print glGetString(GL_EXTENSIONS).split()
['GL_ARB_depth_texture', 'GL_ARB_fragment_program', ...

This is all.