From 0ceb7378c2624a8a8390a03d9c6376c5930e77d8 Mon Sep 17 00:00:00 2001 From: David Wilson Date: Mon, 9 Sep 2013 17:28:34 -0400 Subject: [PATCH] awesome pygame wrapper for XO activities --- example/README.txt | 137 ++++++++++++ example/test/TestActivity.py | 92 ++++++++ example/test/TestGame.py | 91 ++++++++ example/test/activity/activity-generic.svg | 23 ++ example/test/activity/activity.info | 6 + example/test/activity/mimetypes.xml | 8 + example/test/setup.py | 4 + sugargame/__init__.py | 1 + sugargame/canvas.py | 62 ++++++ sugargame/event.py | 244 +++++++++++++++++++++ 10 files changed, 668 insertions(+) create mode 100644 example/README.txt create mode 100644 example/test/TestActivity.py create mode 100755 example/test/TestGame.py create mode 100644 example/test/activity/activity-generic.svg create mode 100755 example/test/activity/activity.info create mode 100644 example/test/activity/mimetypes.xml create mode 100755 example/test/setup.py create mode 100644 sugargame/__init__.py create mode 100644 sugargame/canvas.py create mode 100644 sugargame/event.py diff --git a/example/README.txt b/example/README.txt new file mode 100644 index 0000000..c0ac366 --- /dev/null +++ b/example/README.txt @@ -0,0 +1,137 @@ +== Sugargame == + +Sugargame is a Python package which allows [http://www.pygame.org/ Pygame] +programs to run well under Sugar. +It is fork of the olcpgames framework, which is no longer maintained. + +http://git.sugarlabs.org/projects/sugargame + +What it does: + +* Wraps a Sugar activity around an existing Pygame program with few changes +* Allows Sugar toolbars and other widgets to be added to the activity UI +* Provides hooks for saving to and restoring from the Journal + +==== 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) + +== Using Sugargame == + +See also [[Development Team/Sugargame/Examples]]. + +==== Wrapping a Pygame program ==== + +To use Sugargame to Sugarize a Pygame program, set up an activity directory and +copy the Sugargame package to it. + +The activity directory should look something like this: + + activity/ - Activity directory: activity.info, SVG icon, etc. + sugargame/ - Sugargame package + MyActivity.py - Activity class + mygame.py - Pygame code + setup.py - Install script + +To make the Activity class, start with test/TestActivity.py from the Sugargame +distribution. + +The activity should create a single PygameCanvas widget and call run_pygame on it. +Pass the main loop function of the Pygame program. + + self._canvas = sugargame.canvas.PygameCanvas(self) + self.set_canvas(self._canvas) + + # Start the game running. + self._canvas.run_pygame(self.game.run) + +In your Pygame main loop, pump the GTK message 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 == + +For help with Sugargame, please email the Sugar Labs development list: + +: sugar-devel@lists.sugarlabs.org + +Sugargame is developed by Wade Brainerd . + +It is loosely based on the source code to the olpcgames framework, developed by +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 diff --git a/example/test/TestActivity.py b/example/test/TestActivity.py new file mode 100644 index 0000000..cb67c3c --- /dev/null +++ b/example/test/TestActivity.py @@ -0,0 +1,92 @@ +from gettext import gettext as _ + +import sys +from gi.repository import Gtk +import pygame + +import sugar3.activity.activity +from sugar3.graphics.toolbarbox import ToolbarBox +from sugar3.activity.widgets import ActivityToolbarButton +from sugar3.graphics.toolbutton import ToolButton +from sugar3.activity.widgets import StopButton + + +sys.path.append('..') # Import sugargame package from top directory. +import sugargame.canvas + +import TestGame + + +class TestActivity(sugar3.activity.activity.Activity): + def __init__(self, handle): + super(TestActivity, self).__init__(handle) + + self.paused = False + + # Create the game instance. + self.game = TestGame.TestGame() + + # Build the activity toolbar. + self.build_toolbar() + + # Build the Pygame canvas. + self._pygamecanvas = sugargame.canvas.PygameCanvas(self) + + # Note that set_canvas implicitly calls read_file when + # resuming from the Journal. + self.set_canvas(self._pygamecanvas) + self._pygamecanvas.grab_focus() + + # Start the game running (self.game.run is called when the + # activity constructor returns). + self._pygamecanvas.run_pygame(self.game.run) + + def build_toolbar(self): + toolbar_box = ToolbarBox() + self.set_toolbar_box(toolbar_box) + toolbar_box.show() + + activity_button = ActivityToolbarButton(self) + toolbar_box.toolbar.insert(activity_button, -1) + activity_button.show() + + # Pause/Play button: + + stop_play = ToolButton('media-playback-stop') + stop_play.set_tooltip(_("Stop")) + stop_play.set_accelerator(_('space')) + stop_play.connect('clicked', self._stop_play_cb) + stop_play.show() + + toolbar_box.toolbar.insert(stop_play, -1) + + # Blank space (separator) and Stop button at the end: + + separator = Gtk.SeparatorToolItem() + separator.props.draw = False + separator.set_expand(True) + toolbar_box.toolbar.insert(separator, -1) + separator.show() + + stop_button = StopButton(self) + toolbar_box.toolbar.insert(stop_button, -1) + stop_button.show() + + def _stop_play_cb(self, button): + # Pause or unpause the game. + self.paused = not self.paused + self.game.set_paused(self.paused) + + # Update the button to show the next action. + if self.paused: + button.set_icon('media-playback-start') + button.set_tooltip(_("Start")) + else: + button.set_icon('media-playback-stop') + button.set_tooltip(_("Stop")) + + def read_file(self, file_path): + self.game.read_file(file_path) + + def write_file(self, file_path): + self.game.write_file(file_path) diff --git a/example/test/TestGame.py b/example/test/TestGame.py new file mode 100755 index 0000000..848e220 --- /dev/null +++ b/example/test/TestGame.py @@ -0,0 +1,91 @@ +#!/usr/bin/python +import pygame +from gi.repository import Gtk + + +class TestGame: + def __init__(self): + # Set up a clock for managing the frame rate. + self.clock = pygame.time.Clock() + + self.x = -100 + self.y = 100 + + self.vx = 10 + self.vy = 0 + + self.paused = False + self.direction = 1 + + def set_paused(self, paused): + self.paused = paused + + # Called to save the state of the game to the Journal. + def write_file(self, file_path): + pass + + # Called to load the state of the game from the Journal. + def read_file(self, file_path): + pass + + # The main game loop. + def run(self): + self.running = True + + 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) + elif event.type == pygame.KEYDOWN: + if event.key == pygame.K_LEFT: + self.direction = -1 + elif event.key == pygame.K_RIGHT: + self.direction = 1 + + # Move the ball + if not self.paused: + self.x += self.vx * self.direction + if self.direction == 1 and self.x > screen.get_width() + 100: + self.x = -100 + elif self.direction == -1 and self.x < -100: + self.x = screen.get_width() + 100 + + self.y += self.vy + if self.y > screen.get_height() - 100: + self.y = screen.get_height() - 100 + self.vy = -self.vy + + self.vy += 5 + + # Clear Display + screen.fill((255, 255, 255)) # 255 for white + + # Draw the ball + pygame.draw.circle(screen, (255, 0, 0), (self.x, self.y), 100) + + # Flip Display + pygame.display.flip() + + # Try to stay at 30 FPS + self.clock.tick(30) + + +# This function is called when the game is run directly from the command line: +# ./TestGame.py +def main(): + pygame.init() + pygame.display.set_mode((0, 0), pygame.RESIZABLE) + game = TestGame() + game.run() + +if __name__ == '__main__': + main() diff --git a/example/test/activity/activity-generic.svg b/example/test/activity/activity-generic.svg new file mode 100644 index 0000000..3a642f8 --- /dev/null +++ b/example/test/activity/activity-generic.svg @@ -0,0 +1,23 @@ + + +]> + + + + image/svg+xml + + + + + + + + + + + + + ? + + \ No newline at end of file diff --git a/example/test/activity/activity.info b/example/test/activity/activity.info new file mode 100755 index 0000000..907f533 --- /dev/null +++ b/example/test/activity/activity.info @@ -0,0 +1,6 @@ +[Activity] +name = SugargameTest +bundle_id = org.sugarlabs.SugargameTest +exec = sugar-activity TestActivity.TestActivity +icon = activity-generic +activity_version = 1 diff --git a/example/test/activity/mimetypes.xml b/example/test/activity/mimetypes.xml new file mode 100644 index 0000000..8fe1709 --- /dev/null +++ b/example/test/activity/mimetypes.xml @@ -0,0 +1,8 @@ + + + + Physics Activity + + + + diff --git a/example/test/setup.py b/example/test/setup.py new file mode 100755 index 0000000..d290fe6 --- /dev/null +++ b/example/test/setup.py @@ -0,0 +1,4 @@ +#!/usr/bin/env python +from sugar3.activity import bundlebuilder +bundlebuilder.start() + diff --git a/sugargame/__init__.py b/sugargame/__init__.py new file mode 100644 index 0000000..439eb0c --- /dev/null +++ b/sugargame/__init__.py @@ -0,0 +1 @@ +__version__ = '1.1' diff --git a/sugargame/canvas.py b/sugargame/canvas.py new file mode 100644 index 0000000..1ce0250 --- /dev/null +++ b/sugargame/canvas.py @@ -0,0 +1,62 @@ +import os +from gi.repository import Gtk +from gi.repository import GObject +import pygame +import event + +CANVAS = None + +class PygameCanvas(Gtk.EventBox): + + """ + mainwindow is the activity intself. + """ + def __init__(self, mainwindow, pointer_hint = True): + GObject.GObject.__init__(self) + + global CANVAS + assert CANVAS == None, "Only one PygameCanvas can be created, ever." + CANVAS = self + + # Initialize Events translator before widget gets "realized". + self.translator = event.Translator(mainwindow, self) + + self._mainwindow = mainwindow + + self.set_can_focus(True) + + self._socket = Gtk.Socket() + self.add(self._socket) + self.show_all() + + def run_pygame(self, main_fn): + # Run the main loop after a short delay. The reason for the delay is that the + # Sugar activity is not properly created until after its constructor returns. + # If the Pygame main loop is called from the activity constructor, the + # constructor never returns and the activity freezes. + GObject.idle_add(self._run_pygame_cb, main_fn) + + def _run_pygame_cb(self, main_fn): + assert pygame.display.get_surface() is None, "PygameCanvas.run_pygame can only be called once." + + # Preinitialize Pygame with the X window ID. + assert pygame.display.get_init() == False, "Pygame must not be initialized before calling PygameCanvas.run_pygame." + os.environ['SDL_WINDOWID'] = str(self._socket.get_id()) + pygame.init() + + # Restore the default cursor. + self._socket.props.window.set_cursor(None) + + # Initialize the Pygame window. + r = self.get_allocation() + pygame.display.set_mode((r.width, r.height), pygame.RESIZABLE) + + # Hook certain Pygame functions with GTK equivalents. + self.translator.hook_pygame() + + # Run the Pygame main loop. + main_fn() + return False + + def get_pygame_widget(self): + return self._socket diff --git a/sugargame/event.py b/sugargame/event.py new file mode 100644 index 0000000..431a600 --- /dev/null +++ b/sugargame/event.py @@ -0,0 +1,244 @@ +from gi.repository import Gtk +from gi.repository import Gdk +from gi.repository import GObject +import pygame +import pygame.event +import logging + +class _MockEvent(object): + def __init__(self, keyval): + self.keyval = keyval + +class Translator(object): + key_trans = { + 'Alt_L': pygame.K_LALT, + 'Alt_R': pygame.K_RALT, + 'Control_L': pygame.K_LCTRL, + 'Control_R': pygame.K_RCTRL, + 'Shift_L': pygame.K_LSHIFT, + 'Shift_R': pygame.K_RSHIFT, + 'Super_L': pygame.K_LSUPER, + 'Super_R': pygame.K_RSUPER, + 'KP_Page_Up' : pygame.K_KP9, + 'KP_Page_Down' : pygame.K_KP3, + 'KP_End' : pygame.K_KP1, + 'KP_Home' : pygame.K_KP7, + 'KP_Up' : pygame.K_KP8, + 'KP_Down' : pygame.K_KP2, + 'KP_Left' : pygame.K_KP4, + 'KP_Right' : pygame.K_KP6, + + } + + mod_map = { + pygame.K_LALT: pygame.KMOD_LALT, + pygame.K_RALT: pygame.KMOD_RALT, + pygame.K_LCTRL: pygame.KMOD_LCTRL, + pygame.K_RCTRL: pygame.KMOD_RCTRL, + pygame.K_LSHIFT: pygame.KMOD_LSHIFT, + pygame.K_RSHIFT: pygame.KMOD_RSHIFT, + } + + def __init__(self, mainwindow, inner_evb): + """Initialise the Translator with the windows to which to listen""" + self._mainwindow = mainwindow + self._inner_evb = inner_evb + + # Enable events + # (add instead of set here because the main window is already realized) + self._mainwindow.add_events( + Gdk.EventMask.KEY_PRESS_MASK | \ + Gdk.EventMask.KEY_RELEASE_MASK \ + ) + + self._inner_evb.set_events( + Gdk.EventMask.POINTER_MOTION_MASK | \ + Gdk.EventMask.POINTER_MOTION_HINT_MASK | \ + Gdk.EventMask.BUTTON_MOTION_MASK | \ + Gdk.EventMask.BUTTON_PRESS_MASK | \ + Gdk.EventMask.BUTTON_RELEASE_MASK + ) + + self._mainwindow.set_can_focus(True) + self._inner_evb.set_can_focus(True) + + # Callback functions to link the event systems + self._mainwindow.connect('unrealize', self._quit_cb) + self._inner_evb.connect('key_press_event', self._keydown_cb) + self._inner_evb.connect('key_release_event', self._keyup_cb) + self._inner_evb.connect('button_press_event', self._mousedown_cb) + self._inner_evb.connect('button_release_event', self._mouseup_cb) + self._inner_evb.connect('motion-notify-event', self._mousemove_cb) + self._inner_evb.connect('draw', self._draw_cb) + self._inner_evb.connect('configure-event', self._resize_cb) + + # Internal data + self.__stopped = False + self.__keystate = [0] * 323 + self.__button_state = [0,0,0] + self.__mouse_pos = (0,0) + self.__repeat = (None, None) + self.__held = set() + self.__held_time_left = {} + self.__held_last_time = {} + self.__tick_id = None + + def hook_pygame(self): + pygame.key.get_pressed = self._get_pressed + pygame.key.set_repeat = self._set_repeat + pygame.mouse.get_pressed = self._get_mouse_pressed + pygame.mouse.get_pos = self._get_mouse_pos + + def _draw_cb(self, widget, event): + if pygame.display.get_init(): + pygame.event.post(pygame.event.Event(pygame.VIDEOEXPOSE)) + return True + + def _resize_cb(self, widget, event): + evt = pygame.event.Event(pygame.VIDEORESIZE, + size=(event.width,event.height), width=event.width, height=event.height) + pygame.event.post(evt) + return False # continue processing + + def _quit_cb(self, data=None): + self.__stopped = True + pygame.event.post(pygame.event.Event(pygame.QUIT)) + + def _keydown_cb(self, widget, event): + key = event.keyval + if key in self.__held: + return True + else: + if self.__repeat[0] is not None: + self.__held_last_time[key] = pygame.time.get_ticks() + self.__held_time_left[key] = self.__repeat[0] + self.__held.add(key) + + return self._keyevent(widget, event, pygame.KEYDOWN) + + def _keyup_cb(self, widget, event): + key = event.keyval + if self.__repeat[0] is not None: + if key in self.__held: + # This is possibly false if set_repeat() is called with a key held + del self.__held_time_left[key] + del self.__held_last_time[key] + self.__held.discard(key) + + return self._keyevent(widget, event, pygame.KEYUP) + + def _keymods(self): + mod = 0 + for key_val, mod_val in self.mod_map.iteritems(): + mod |= self.__keystate[key_val] and mod_val + return mod + + def _keyevent(self, widget, event, type): + key = Gdk.keyval_name(event.keyval) + if key is None: + # No idea what this key is. + return False + + keycode = None + if key in self.key_trans: + keycode = self.key_trans[key] + elif hasattr(pygame, 'K_'+key.upper()): + keycode = getattr(pygame, 'K_'+key.upper()) + elif hasattr(pygame, 'K_'+key.lower()): + keycode = getattr(pygame, 'K_'+key.lower()) + elif key == 'XF86Start': + # view source request, specially handled... + self._mainwindow.view_source() + else: + print 'Key %s unrecognized' % key + + if keycode is not None: + if type == pygame.KEYDOWN: + mod = self._keymods() + self.__keystate[keycode] = type == pygame.KEYDOWN + if type == pygame.KEYUP: + mod = self._keymods() + ukey = unichr(Gdk.keyval_to_unicode(event.keyval)) + if ukey == '\000': + ukey = '' + evt = pygame.event.Event(type, key=keycode, unicode=ukey, mod=mod) + self._post(evt) + + return True + + def _get_pressed(self): + return self.__keystate + + def _get_mouse_pressed(self): + return self.__button_state + + def _mousedown_cb(self, widget, event): + self.__button_state[event.button-1] = 1 + return self._mouseevent(widget, event, pygame.MOUSEBUTTONDOWN) + + def _mouseup_cb(self, widget, event): + self.__button_state[event.button-1] = 0 + return self._mouseevent(widget, event, pygame.MOUSEBUTTONUP) + + def _mouseevent(self, widget, event, type): + evt = pygame.event.Event(type, button=event.button, pos=(event.x, event.y)) + self._post(evt) + return True + + def _mousemove_cb(self, widget, event): + # From http://www.learningpython.com/2006/07/25/writing-a-custom-widget-using-pygtk/ + # if this is a hint, then let's get all the necessary + # information, if not it's all we need. + if event.is_hint: + win, x, y, state = event.window.get_device_position(event.device) + else: + x = event.x + y = event.y + state = event.get_state() + + rel = (x - self.__mouse_pos[0], y - self.__mouse_pos[1]) + self.__mouse_pos = (x, y) + + self.__button_state = [ + state & Gdk.ModifierType.BUTTON1_MASK and 1 or 0, + state & Gdk.ModifierType.BUTTON2_MASK and 1 or 0, + state & Gdk.ModifierType.BUTTON3_MASK and 1 or 0, + ] + + evt = pygame.event.Event(pygame.MOUSEMOTION, + pos=self.__mouse_pos, rel=rel, buttons=self.__button_state) + self._post(evt) + return True + + def _tick_cb(self): + cur_time = pygame.time.get_ticks() + for key in self.__held: + delta = cur_time - self.__held_last_time[key] + self.__held_last_time[key] = cur_time + + self.__held_time_left[key] -= delta + if self.__held_time_left[key] <= 0: + self.__held_time_left[key] = self.__repeat[1] + self._keyevent(None, _MockEvent(key), pygame.KEYDOWN) + + return True + + def _set_repeat(self, delay=None, interval=None): + if delay is not None and self.__repeat[0] is None: + self.__tick_id = GObject.timeout_add(10, self._tick_cb) + elif delay is None and self.__repeat[0] is not None: + GObject.source_remove(self.__tick_id) + self.__repeat = (delay, interval) + + def _get_mouse_pos(self): + return self.__mouse_pos + + def _post(self, evt): + try: + pygame.event.post(evt) + except pygame.error, e: + if str(e) == 'Event queue full': + print "Event queue full!" + pass + else: + raise e