Changes

Jump to navigation Jump to search
no edit summary
Line 1: Line 1:  
== Sugargame ==
 
== Sugargame ==
   −
Sugargame is a Python package which allows [http://www.pygame.org/ Pygame] programs to run well under Sugar.  
+
Sugargame is a Python package which allows [http://www.pygame.org/ Pygame]  
It is fork of the olcpgames framework, which is no longer maintained.
+
programs to run well under Sugar.
 
+
It is a fork of olcpgames, which is no longer maintained.
Sugargame embeds the Pygame window into a GTK window, and translates GTK
  −
events to Pygame events.
      
What it does:
 
What it does:
Line 13: Line 11:  
* Provides hooks for saving to and restoring from the Journal
 
* Provides hooks for saving to and restoring from the Journal
   −
=== Differences between Sugargame and olpcgames ===
+
Get it from:
 +
 
 +
http://github.com/sugarlabs/sugargame
   −
The olpcgames framework provides a wrapper around Pygame which attempts to allow a Pygame program to run mostly unmodified under SugarTo this end, the Pygame program is run in a separate thread with its own Pygame message loop while the main thread runs the GTK message loopAlso, olpcgames wraps Sugar APIs such as the journal and mesh into a Pygame-like API.
+
And place it within your activity sourceIt is not part of SugarRemember to check back for updates when you are continuing development of your activity.
   −
Sugargame takes a simpler approach; it simply offers a way to embed Pygame into a GTK widgetThe Sugar APIs are used to interact with Sugar, the Pygame APIs are used for the game.
+
You can find it in some activities alreadyIt is so small that the duplication is unimportant.
   −
Sugargame advantages:
+
== Using Sugargame ==
   −
* Simpler code
+
See also [[Development Team/Sugargame/Examples]].
* More elegant interface between Pygame and GTK
  −
* Runs as a single thread: no thread related segfaults
  −
* Possible to use Sugar widgets with Pygame
     −
Sugargame limitations:
+
==== Wrapping a Pygame program ====
   −
* No support for Pango or SVG sprites (yet)
+
To use Sugargame to Sugarize a Pygame program, set up an activity directory and copy the Sugargame package into it. For an example, see the directory named test, inside the Sugargame repository.  It is in fact a Sugargame activity.
   −
== Using Sugargame ==
  −
  −
To use Sugargame in an activity, copy the sugargame folder into the activity's
  −
source directory.
  −
   
The activity directory should look something like this:
 
The activity directory should look something like this:
 
   
 
   
Line 42: Line 34:  
   mygame.py            - Pygame code
 
   mygame.py            - Pygame code
 
   setup.py            - Install script
 
   setup.py            - Install script
 
+
 
To make the Activity class, start with test/TestActivity.py.   
+
To make the Activity class, start with test/TestActivity.py from the Sugargame distribution.
 +
 
 +
The activity must create a single PygameCanvas widget:
 +
self._canvas = sugargame.canvas.PygameCanvas(self)
 +
self.set_canvas(self._canvas)
 +
 
 +
The activity may assign keyboard focus to the PygameCanvas widget, so that keyboard events generate pygame events:
 +
self._canvas.grab_focus()
 +
 
 +
The activity must call the run_pygame method of the PygameCanvas widget, passing the main loop function of the Pygame program.
 +
# Start the game running.
 +
  self._canvas.run_pygame(self.game.run)
 +
 
 +
In your Pygame main loop, you must pump the GTK event loop:
 +
 
 +
  while gtk.events_pending():
 +
      gtk.main_iteration()
 +
 
 +
==== Adding Pygame to a PyGTK activity ====
 +
 
 +
To add Pygame to an existing Sugar activity, create a PygameCanvas widget and call
 +
run_pygame on it. 
 +
 
 +
widget = sugargame.canvas.PygameCanvas(self)
 +
vbox.pack_start(widget)
 +
 +
widget.run_pygame(self.game.run)
 +
 
 +
Due to limitations of Pygame and SDL, there can only be one PygameCanvas in the
 +
entire activity.
 +
 
 +
The argument to run_pygame is a function structured like a Pygame program.  In the
 +
main loop, remember to dispatch GTK messages using gtk.main_iteration().
 +
 
 +
def main_loop():
 +
        clock = pygame.time.Clock()
 +
        screen = pygame.display.get_surface()
 +
 +
        while self.running:
 +
            # Pump GTK messages.
 +
            while gtk.events_pending():
 +
                gtk.main_iteration()
 +
 +
            # Pump PyGame messages.
 +
            for event in pygame.event.get():
 +
                if event.type == pygame.QUIT:
 +
                    return
 +
                elif event.type == pygame.VIDEORESIZE:
 +
                    pygame.display.set_mode(event.size, pygame.RESIZABLE)
 +
 +
            # Check the mouse position
 +
            x, y = pygame.mouse.get_pos()
 +
 
 +
            # Clear Display
 +
            screen.fill((255,255,255)) #255 for white
 +
 +
            # Draw stuff here
 +
            .................
 +
 +
            # Flip Display
 +
            pygame.display.flip() 
 +
           
 +
            # Try to stay at 30 FPS
 +
            self.clock.tick(30)
    
== Support ==
 
== Support ==
Line 50: Line 105:     
: sugar-devel@lists.sugarlabs.org
 
: sugar-devel@lists.sugarlabs.org
  −
== Author ==
      
Sugargame is developed by Wade Brainerd <wadetb@gmail.com>.   
 
Sugargame is developed by Wade Brainerd <wadetb@gmail.com>.   
    
It is loosely based on the source code to the olpcgames framework, developed by  
 
It is loosely based on the source code to the olpcgames framework, developed by  
the One Laptop Per Child project.
+
the One Laptop per Child project.
 +
 
 +
== Changelog ==
 +
 
 +
===v1.1===
 +
* Fix bugs in event handling.  (Pablo Moleri)
 +
* Remove reference to gtk.Socket.get_window() method, which is missing in older versions of PyGTK.
 +
 
 +
===v1.0===
 +
* Initial version of Sugargame
 +
 
 +
== Differences between Sugargame and olpcgames ==
 +
 
 +
The olpcgames framework provides a wrapper around Pygame which attempts to
 +
allow a Pygame program to run mostly unmodified under Sugar.  To this end,
 +
the Pygame program is run in a separate thread with its own Pygame message
 +
loop while the main thread runs the GTK message loop.  Also, olpcgames wraps
 +
Sugar APIs such as the journal and mesh into a Pygame-like API.
 +
 
 +
Sugargame takes a simpler approach; it provides a way to embed Pygame into a
 +
GTK widget.  The Sugar APIs are used to interact with Sugar, the Pygame APIs
 +
are used for the game. 
 +
 
 +
Sugargame advantages:
 +
 
 +
* Simpler code
 +
* More elegant interface between Pygame and GTK
 +
* Runs as a single thread: no thread related segfaults
 +
* Possible to use Sugar widgets with Pygame
 +
 
 +
Sugargame limitations:
 +
 
 +
* No support for Pango or SVG sprites (yet)

Navigation menu