Game development HOWTO: Difference between revisions

From OLPC
Jump to navigation Jump to search
(Beginning of rework to cover approach to getting started quickly)
(better categories)
 
(44 intermediate revisions by 16 users not shown)
Line 1: Line 1:
{{Developers}}
This document describes how to use the [[Pygame]] library for Python to create a new Game activity for the OLPC ([[Sugar]]) platform. Its intention is to allow a Python programmer who wants to learn (or already knows) Pygame to integrate their Pygame application into a Sugar-hosted activity using the OLPCGames [[Pygame wrapper]].
<< [[Tutorials]]


This document describes how to use the [[Pygame]] library for Python for [[game development]] -- to create a new game [[activity]] for OLPC's [[Sugar]] platform. Its intention is to allow a Python programmer who wants to learn (or already knows) Pygame to integrate their Pygame application into a Sugar-hosted activity using the OLPCGames [[Pygame wrapper]].
This HOWTO is current as of December 2007.

If you are looking to create a slightly more limited Activity, you may want to check out [[Pippy]]'s Pygame capabilities.

This HOWTO is current as of December 2007. More recent notes are available at [[Porting pygame games to the XO]] (from March 2008).


= Requirements =
= Requirements =
Line 11: Line 16:
* [[Pygame]] -- this is a Python wrapper around the Simple Direct-media Layer (SDL) library. It is used for lots of games coded in Python and can run on most machines (including Windows, Mac and Linux). If you are running on an OLPC-XO, Pygame should already be available. If not, use your system's package manager to install the Pygame distribution.
* [[Pygame]] -- this is a Python wrapper around the Simple Direct-media Layer (SDL) library. It is used for lots of games coded in Python and can run on most machines (including Windows, Mac and Linux). If you are running on an OLPC-XO, Pygame should already be available. If not, use your system's package manager to install the Pygame distribution.
** The [http://dev.laptop.org/~coderanger/ slides from Noah's lecture] at the start of the game jam are online at (both PDF and PowerPoint form).
** The [http://dev.laptop.org/~coderanger/ slides from Noah's lecture] at the start of the game jam are online at (both PDF and PowerPoint form).
** [[Mac setup instructions]]
** [[Pygame/Mac setup instructions]]
* [[Pygame wrapper|OLPCGames]] -- the OLPC Sugar specific library which provides the glue code that lets your Pygame game run inside a Sugar activity. It also gives you access to the various "special" features in the Sugar environment, such as the mesh network and the camera. If you are on an OLPC-XO, you can download the [http://dev.laptop.org/git?p=projects/games-misc;a=tree;f=olpcgames-src/dist;hb=HEAD current OLPCGames distribution] and unpack it.
* [[Pygame wrapper|OLPCGames]] -- the OLPC Sugar specific library which provides the glue code that lets your Pygame game run inside a Sugar activity. It also gives you access to the various "special" features in the Sugar environment, such as the mesh network and the camera. If you are on an OLPC-XO, you can download the [http://dev.laptop.org/~mcfletch/OLPCGames/ current OLPCGames distribution] and unpack it.
** Note: The OLPCGames Pygame wrapper requires at least build 432 to work for version 1.0 and at least an Update.2 build (649) for version 1.1. See the reference manual at [[Pygame wrapper]]. See also [[Game development]].
** ''Note'': The OLPCGames Pygame wrapper requires at least build 432 to work for version 1.0 and at least an Update.2 build (649) for version 1.1 and above. See the reference manual at [[Pygame wrapper]]. See also [[Game development]].


== Environment ==
== Environment ==


You will need a working Sugar [[Development Environment|Developers]] environment. If you are working directly on an OLPC-XO, you will need to know how to use a standard text editor, such as vi or nano, which are available within the "Terminal" activity in your activity toolbar.
You will need a working Sugar [[Developers/Setup|Developer's]] environment. If you are working directly on an OLPC-XO, you will need to know how to use a standard text editor, such as vi or nano, which are available within the [[Terminal Activity]] in your activity toolbar.
* You'll need to set aside a few hours to [http://www.eng.hawaii.edu/Tutor/vi.html learn vi] before you start this HOWTO if you don't already know it and want to use it well)
* You'll need to set aside a few hours to [http://www.eng.hawaii.edu/Tutor/vi.html learn vi] before you start this HOWTO if you don't already know it and want to use it well)
* Nano is often considered easier to learn immediately because the major commands are all spelled out at the bottom of the screen (where you need to remember the vim commands yourself)
* Nano is often considered easier to learn immediately because the major commands are all spelled out at the bottom of the screen (where you need to remember the vim commands yourself)
Line 25: Line 30:
= Skeleton Setup =
= Skeleton Setup =


To start, you will likely want to download the [http://dev.laptop.org/git?p=projects/games-misc;a=tree;f=olpcgames-src/dist;hb=HEAD OLPCGames 1.2 source package]. This package includes a skeleton package that lets you generate a new OLPCGames-based Pygame Activity with a single command.
To start, you will likely want to download the [http://dev.laptop.org/~mcfletch/OLPCGames/ OLPCGames source package]. This package includes a skeleton script that lets you generate a new OLPCGames-based Pygame Activity with a single command.


== Getting the Skeleton Script ==
== Getting the Skeleton Script ==
Line 31: Line 36:
To install the package, you will need to download the .zip or .tar.gz to your machine and extract it with either of:
To install the package, you will need to download the .zip or .tar.gz to your machine and extract it with either of:


unzip OLPCGames-1.2.zip
unzip OLPCGames-1.4.zip


or
or


tar -zxf OLPCGames-1.2.tar.gz
tar -zxf OLPCGames-1.4.tar.gz


which will create a directory named OLPCGames-1.2. Change to the OLPCGames-1.2/skeleton directory and run the command:
which will create a directory named OLPCGames-1.4. Change to the skeleton directory:

cd OLPCGames-1.4/skeleton

Make sure that your python file has the required permissions to be used.

chmod a+x buildskel.py

And run the command:


./buildskel.py activityname "My Activity Name"
./buildskel.py activityname "My Activity Name"


to create a new activity instance.
to create a new generic activity instance.


== Installing and Testing ==
== Installing and Testing ==
Line 49: Line 62:
python setup.py dev
python setup.py dev


when you restart Sugar you should have a new activity in your Activity bar named "My Activity Name". Clicking on this activity should result in dark blue screen with a toolbar at the top of the window.
when you restart Sugar you should have a new activity in your Activity bar named "My Activity Name". Clicking on this activity should result in dark blue screen with a toolbar at the top of the window. Type Esc to exit.


== Testing Outside Sugar ==
== Testing Outside Sugar ==


The run.py script in the skeleton project is where you skeleton activity currently points for its "mainloop", particularly the "main" function within it. When you are just starting you you'll likely want to work within run.py to create new code and experiment. run.py is actually set up to be used as a python script via:
The run.py script in the skeleton project is where you skeleton activity currently points for its "mainloop", particularly the "main" function within it. When you are just starting you'll likely want to work within run.py to create new code and experiment. run.py is actually set up to be used as a python script via:


python run.py
python run.py
Line 59: Line 72:
which will run on a non-Sugar environment (i.e. a normal Linux, Windows or Mac desktop with Pygame installed). You may, however, have to configure your system to have the current working directory in the Python path (this is the default on Sugar systems, including emulators and sugar-jhbuild shells).
which will run on a non-Sugar environment (i.e. a normal Linux, Windows or Mac desktop with Pygame installed). You may, however, have to configure your system to have the current working directory in the Python path (this is the default on Sugar systems, including emulators and sugar-jhbuild shells).


== Customizing the Skeleton ==
=Development Environment=


Your Sugar-specific activity values are stored in two main locations; the '''activity.py''' file and the activity directory. The pydoc for the [http://www.vrplumber.com/sugar-docs/olpcgames.activity.html#PyGameActivity PyGameActivity class] describes the various attributes/settings available for your Activity object. These include changing the file-name and method-name for your mainloop function, and changing the title of your activity.
You don't need an XO laptop for simple Pygame development. When creating your Pygame game, use this new boilerplate:


The activity directory is used by Sugar to find things such as your svg icon, translated names and the like. See [[Activity Bundles]] for details.
import sys
import pygame
from pygame.locals import *
def main():
# Create a window 400x225 with 16 bpp
window = pygame.display.set_mode((400, 225), 16)
# Block MouseMotion event - Remove that line if you want to capture it
pygame.event.set_blocked(MOUSEMOTION)
# Get going
pygame.init()
while True:
for event in [ pygame.event.wait() ] + pygame.event.get( ):
print event
if event.type == KEYUP:
# Quit on 'q'
if event.key == 113: sys.exit(0)
if __name__=="__main__":
main()


= Getting Started with Pygame =
The 'main' method will be called by the activity wrapper later on, so it must be called 'main'. Using pygame.event.wait() instead of pygame.event.get() reduces the cpu-load from 99% to 0.7 - 4%.


At this point, your OLPC Sugar activity is running as a host for a simple Pygame event loop. You should now, largely, be able to use standard Pygame code to produce graphics, play sounds, and process input.
=Wrapping and Testing=


== Pygame Examples and Tutorials ==
If you want to test using laptop software, but you don't have a real XO, you could set up an [[Emulating the XO|emulated environment]].


Example Activities:
To make your game run as an Activity, you will need the 'olpcgames' wrapper, otherwise known simply as "the wrapper". Eventually, the wrapper will be included as part of the standard laptop software distribution, but for now you must include it in your Activity.
* [http://dev.laptop.org/git?p=projects/games-misc;a=blob;f=FileTest.activity/run.py;hb=HEAD Journal/File Test] -- example of using the [[Journal]] to save/restore state for an activity
* [http://dev.laptop.org/git?p=projects/games-misc;a=blob;f=cameratest.activity/run.py;hb=HEAD Camera Test] -- example of using the <code>olpcgames.camera</code> module [http://dev.laptop.org/~mcfletch/testactivities/cameratest-1.xo XO]
* [http://dev.laptop.org/git?p=projects/games-misc;a=blob;f=soundtest.activity/run.py;hb=HEAD Sound Test] -- example showing simple multi-channel sound usage [http://dev.laptop.org/~mcfletch/testactivities/soundtest-1.xo XO]


* [http://dev.laptop.org/git?p=projects/games-misc;a=blob;f=svgspritetest.activity/run.py;hb=HEAD SVG Sprite Test] -- example showing use of the <code>olpcgames.svgsprite</code> module [http://dev.laptop.org/~mcfletch/testactivities/svgspritetest-1.xo XO]
git clone git://dev.laptop.org/projects/games-misc


* [http://dev.laptop.org/git?p=projects/games-misc;a=blob;f=videotest.activity/run.py;hb=HEAD Video Test] -- example showing use of the [[GStreamer]]-based <code>olpcgames.video</code> module [http://dev.laptop.org/~mcfletch/testactivities/videotest-2.xo XO]
This will download several games-related projects. There are a few game Activities checked in, as well as the wrapper.


First construct an activity development bundle as in [[Sugar Activity Tutorial]].


''Tutorials'':
The wrapper requires the following boilerplate as the main class of your activity as specified in activity.info. Generally this is called 'activity.py' and your Pygame app retains its original name:
* [http://www.pygame.org/wiki/tutorials Pygame Tutorials] -- a wiki-based collection of tutorials for learning Pygame programming
* [http://rene.f0o.com/mywiki/PythonGameProgramming 5-part Tutorial] -- a fairly extensive tutorial on Pygame usage
* [http://www.pygame.org/docs Pygame Documentation] -- the official collection of Pygame documentation, you will need this to get any Pygame programming done
* [[Game templates]] -- serves as a starting point for creating Pygame games
*[[OLPCGames#Activities|OLPCGames-based Activities]] can often be read to find sample code.


== Reference Links ==
<pre>
import olpcgames


* [[Pygame wrapper]] [http://www.vrplumber.com/sugar-docs/olpcgames.html pydoc] -- the OLPCGames wrapper's reference manual and pydoc, you'll want to familiarize yourself with this to understand what's different on the OLPC platform from regular Pygame
# Class name must match 'class' property in activity/activity.info:
* If you are new to game and GUI programming, you may wish to use a [http://www.pygame.org/wiki/gui Pygame GUI engine] to simplify creating buttons, text entry boxes and the like.
class ExampleActivity(olpcgames.PyGameActivity):
"""An example of using a Pygame game as a Sugar activity."""
game_name = 'examplemodule:main' # game_name must match name of your Pygame module
game_title = 'Example'
game_size = (1200,825)
</pre>


= Support =
The <code>game_name</code> parameter has the format "module:method". The module will be imported and the method called to start your Pygame application. Method is optional and defaults to <code>main</code>. (FIXME: Use Gettext to localize the game_title parameter.)


If you have questions, suggestions or problems, please feel free to post to the [http://lists.laptop.org/listinfo/games OLPC Game Development mailing list]. This is a relatively low-traffic list with lots of Pygame users on it. Alternately, IRC channels are available on freenode as #pygame, #sugar and #olpc-content if you want more conversational support. Lastly, [[User:Mcfletch]] is the current maintainer of the wrapper. Contact him if you get stuck, but be aware he tends to be spread a bit thin, the mailing list is generally a better avenue.
The game_size is what sets the display mode in Pygame.


= Reducing CPU Load =
The last step: you need to copy or link the 'olpcgames' directory from the Git repository you checked out into the root of your Activity. (Eventually, 'olpcgames' will be part of the main laptop build, so you will no longer need to do this.)


The code in run.py does some trickery to make the event loop reasonably efficient, by limiting the number of frames rendered per second using a "pygame.time.Clock()" instance. It also uses a complex iteration mechanism:
=Hardware=


events = pausescreen.get_events()
The [[Pygame]] page has some information on hardware.
for event in events:


which allows your activity to go completely quiet if there are no pending events for a given time, but still processes all pending events in a timely manner.
==Camera==


You can see the code that implements this in the olpcgames.pausescreen module. None of that machinery is OLPC or Sugar specific, incidentally, it's just good practice to reduce your processing load when running on an OLPC machine.
OLPCGames provides you with a simple wrapper class that will use GStreamer to snap an image with the built-in camera on the XO. The camera module works by creating a GStreamer pipeline that starts with the camera and terminates in a png or jpeg file. Alternately the module can allow you to take a "picture" of the test source, for those testing on non-XO hardware.


* Note: the event iteration mechanism reduces the cpu-load from 99% to 0.7 - 4% in our tests versus a simple pygame.event.get() loop.
You will need to import the module:
* Read more about [[Monitoring System Load]]


== Eliminating Mouse-move Events ==
from olpcgames import camera


If your activity does not use MOUSEMOTION events it is possible to reduce the overall number of events processed (you can combine this with using a <code>pygame.event.wait()</code> event loop as well. Keep in mind that with this optimization you cannot do mouse-over highlighting or the like.
when you want to take a picture with the camera, call snap_async, like so:


An example code structure might look like this:
camera.snap_async( 'picture 32', source='test' )
import sys
import pygame
from pygame.locals import *
def main():
window = pygame.display.set_mode((400, 225))
pygame.event.set_blocked(MOUSEMOTION)
pygame.init()
while True:
for event in [ pygame.event.wait() ] + pygame.event.get( ):
print event
if event.type == KEYUP:
# Quit on 'q'
if event.key == 113: sys.exit(0)
if __name__=="__main__":
main()


== Extending PyGame with C++ ==
the gstreamer pipeline will be created and will iterate until complete. When the picture is available it will be read as a pygame image and returned via a camera.CAMERA_LOAD or camera.CAMERA_LOAD_FAIL event in your Pygame mainloop. These events have the following members:


See [[Extending PyGame with C++]] for instructions on how to mix Python and C++ code for better performance.
* filename -- filename into which the file was saved
* success -- boolean indicating whether we succeeded/failed
* token -- the object passed in as the first argument to snap_async
* image -- the loaded image as a Pygame surface (image), or None on failure
* err -- if an error occurred, the Exception instance

There is a [http://dev.laptop.org/git?p=projects/games-misc;a=tree;f=cameratest.activity;hb=HEAD cameratest activity in GIT] which demonstrates basic use of the snap_async function.

Note that the camera module exposes an older synchronous API for backwards compatibility. You likely should *not* use that api, as it can hang your entire activity waiting for the GStreamer stream to complete (which can take an arbitrary amount of time).

==Sharing and the Mesh==

Your activity can automatically be shared (through the user clicking "Share" on the Sugar toolbar). You should be using build >=530 (or so) for mesh related stuff. When the user does this, your activity will appear in the Neighborhood screen and others can join it.

In order to meaningfully communicate, you must

<pre>
import olpcgames.mesh as mesh
</pre>

Now, you can make use of events you receive that are mesh related. See [[Pygame_wrapper#Mesh]] for details.

Here is a simple example -- in your event loop, just add listening for certain mesh events:

<pre>
for evt in [ pygame.event.wait() ] + pygame.event.get( ):
if evt.type == pygame.KEYDOWN:
# ...

elif evt.type == mesh.PARTICIPANT_ADD:
# Somebody joined. Add them to our list of people, and send them a message:
self.participants.append(evt.handle)
mesh.send_to(evt.handle, str(self.game_state))

elif evt.type == mesh.MESSAGE_UNI:
# Received a message! Display it (and/or decode it):
print "Got a message from %s: %s" % (evt.handle, evt.content)
# Figure out the nick of whoever sent it:
print "It was from buddy %s" % (mesh.get_buddy(evt.handle).props.nick)
</pre>

See Also:

* [http://blog.vrplumber.com/2016 Discussion] of how Productive uses the mesh module and raw Telepathy


=Troubleshooting=
=Troubleshooting=


Ensure you are using at least an Update.2 (first manufacturing release) Sugar environment. Also ensure you are using a checkout of the wrapper from the Git repository.
Ensure you are using at least an Update.2 (first manufacturing release) Sugar environment. Also ensure you are using a recent version of OLPCGames.


Check your log files. On modern Sugar, use the Log Viewer activity to view the log for your activity. Open this activity and find your activity in the list of activity instances on the left. The numeric suffixes increase as you run your activity multiple times.
Check your log files. On modern Sugar, use the Log Viewer activity to view the log for your activity. Open this activity and find your activity in the list of activity instances on the left. The numeric suffixes increase as you run your activity multiple times.


[[Category:Python]]
[[User:Mcfletch]] is the current maintainer of the wrapper. Contact him if you get stuck.

[[Category:Software]]
[[Category:HowTo]]
[[Category:HowTo]]
[[Category:Games]]
[[Category:Developing games]]
[[Category:Developers]]

Latest revision as of 10:39, 20 November 2008

<< Tutorials

This document describes how to use the Pygame library for Python for game development -- to create a new game activity for OLPC's Sugar platform. Its intention is to allow a Python programmer who wants to learn (or already knows) Pygame to integrate their Pygame application into a Sugar-hosted activity using the OLPCGames Pygame wrapper.

If you are looking to create a slightly more limited Activity, you may want to check out Pippy's Pygame capabilities.

This HOWTO is current as of December 2007. More recent notes are available at Porting pygame games to the XO (from March 2008).

Requirements

This HOWTO assumes that you know the basics of computer programming, how to navigate a file-system, and how to edit files on your machine. It also assumes that you will largely learn Pygame programming through the large number of available Pygame references and tutorials. We focus here on how to integrate your Pygame games into the Sugar environment.

Components

  • Pygame -- this is a Python wrapper around the Simple Direct-media Layer (SDL) library. It is used for lots of games coded in Python and can run on most machines (including Windows, Mac and Linux). If you are running on an OLPC-XO, Pygame should already be available. If not, use your system's package manager to install the Pygame distribution.
  • OLPCGames -- the OLPC Sugar specific library which provides the glue code that lets your Pygame game run inside a Sugar activity. It also gives you access to the various "special" features in the Sugar environment, such as the mesh network and the camera. If you are on an OLPC-XO, you can download the current OLPCGames distribution and unpack it.
    • Note: The OLPCGames Pygame wrapper requires at least build 432 to work for version 1.0 and at least an Update.2 build (649) for version 1.1 and above. See the reference manual at Pygame wrapper. See also Game development.

Environment

You will need a working Sugar Developer's environment. If you are working directly on an OLPC-XO, you will need to know how to use a standard text editor, such as vi or nano, which are available within the Terminal Activity in your activity toolbar.

  • You'll need to set aside a few hours to learn vi before you start this HOWTO if you don't already know it and want to use it well)
  • Nano is often considered easier to learn immediately because the major commands are all spelled out at the bottom of the screen (where you need to remember the vim commands yourself)

If you are working in an emulated environment, or a sugar-jhbuild environment, you can use whatever text editor you prefer to create the files we will be working on. There are many text editors with some Python support, and full IDEs are also available.

Skeleton Setup

To start, you will likely want to download the OLPCGames source package. This package includes a skeleton script that lets you generate a new OLPCGames-based Pygame Activity with a single command.

Getting the Skeleton Script

To install the package, you will need to download the .zip or .tar.gz to your machine and extract it with either of:

unzip OLPCGames-1.4.zip

or

tar -zxf OLPCGames-1.4.tar.gz

which will create a directory named OLPCGames-1.4. Change to the skeleton directory:

cd OLPCGames-1.4/skeleton 

Make sure that your python file has the required permissions to be used.

chmod a+x buildskel.py

And run the command:

./buildskel.py activityname "My Activity Name"

to create a new generic activity instance.

Installing and Testing

To test that you have your environment properly configured, we'll restart sugar and attempt to run the newly created (empty) activity. Change to the new activity directory (activityname.activity) and run:

python setup.py dev

when you restart Sugar you should have a new activity in your Activity bar named "My Activity Name". Clicking on this activity should result in dark blue screen with a toolbar at the top of the window. Type Esc to exit.

Testing Outside Sugar

The run.py script in the skeleton project is where you skeleton activity currently points for its "mainloop", particularly the "main" function within it. When you are just starting you'll likely want to work within run.py to create new code and experiment. run.py is actually set up to be used as a python script via:

python run.py

which will run on a non-Sugar environment (i.e. a normal Linux, Windows or Mac desktop with Pygame installed). You may, however, have to configure your system to have the current working directory in the Python path (this is the default on Sugar systems, including emulators and sugar-jhbuild shells).

Customizing the Skeleton

Your Sugar-specific activity values are stored in two main locations; the activity.py file and the activity directory. The pydoc for the PyGameActivity class describes the various attributes/settings available for your Activity object. These include changing the file-name and method-name for your mainloop function, and changing the title of your activity.

The activity directory is used by Sugar to find things such as your svg icon, translated names and the like. See Activity Bundles for details.

Getting Started with Pygame

At this point, your OLPC Sugar activity is running as a host for a simple Pygame event loop. You should now, largely, be able to use standard Pygame code to produce graphics, play sounds, and process input.

Pygame Examples and Tutorials

Example Activities:


Tutorials:

Reference Links

  • Pygame wrapper pydoc -- the OLPCGames wrapper's reference manual and pydoc, you'll want to familiarize yourself with this to understand what's different on the OLPC platform from regular Pygame
  • If you are new to game and GUI programming, you may wish to use a Pygame GUI engine to simplify creating buttons, text entry boxes and the like.

Support

If you have questions, suggestions or problems, please feel free to post to the OLPC Game Development mailing list. This is a relatively low-traffic list with lots of Pygame users on it. Alternately, IRC channels are available on freenode as #pygame, #sugar and #olpc-content if you want more conversational support. Lastly, User:Mcfletch is the current maintainer of the wrapper. Contact him if you get stuck, but be aware he tends to be spread a bit thin, the mailing list is generally a better avenue.

Reducing CPU Load

The code in run.py does some trickery to make the event loop reasonably efficient, by limiting the number of frames rendered per second using a "pygame.time.Clock()" instance. It also uses a complex iteration mechanism:

 events = pausescreen.get_events()
 for event in events:

which allows your activity to go completely quiet if there are no pending events for a given time, but still processes all pending events in a timely manner.

You can see the code that implements this in the olpcgames.pausescreen module. None of that machinery is OLPC or Sugar specific, incidentally, it's just good practice to reduce your processing load when running on an OLPC machine.

  • Note: the event iteration mechanism reduces the cpu-load from 99% to 0.7 - 4% in our tests versus a simple pygame.event.get() loop.
  • Read more about Monitoring System Load

Eliminating Mouse-move Events

If your activity does not use MOUSEMOTION events it is possible to reduce the overall number of events processed (you can combine this with using a pygame.event.wait() event loop as well. Keep in mind that with this optimization you cannot do mouse-over highlighting or the like.

An example code structure might look like this:

import sys
import pygame
from pygame.locals import *

def main():
	window = pygame.display.set_mode((400, 225))
	pygame.event.set_blocked(MOUSEMOTION)
	pygame.init()

	while True:
		for event in [ pygame.event.wait() ] + pygame.event.get( ):
			print event
			if event.type == KEYUP:
				# Quit on 'q'
				if event.key == 113: sys.exit(0)

if __name__=="__main__":
    main()

Extending PyGame with C++

See Extending PyGame with C++ for instructions on how to mix Python and C++ code for better performance.

Troubleshooting

Ensure you are using at least an Update.2 (first manufacturing release) Sugar environment. Also ensure you are using a recent version of OLPCGames.

Check your log files. On modern Sugar, use the Log Viewer activity to view the log for your activity. Open this activity and find your activity in the list of activity instances on the left. The numeric suffixes increase as you run your activity multiple times.