Commit 14118e1b authored by Alan Aguiar's avatar Alan Aguiar
Browse files

basic sugar activity

parent 37dd3548
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sugargame
import sugargame.canvas
from sugar.activity import activity
import main
class Activity(activity.Activity):
def __init__(self, handle):
activity.Activity.__init__(self, handle)
self.max_participants = 1
self.actividad = main.Flappy()
self._pygamecanvas = sugargame.canvas.PygameCanvas(self)
self.set_canvas(self._pygamecanvas)
self._pygamecanvas.grab_focus()
self._pygamecanvas.run_pygame(self.actividad.main)
[Activity]
name = Flappy
activity_version = 1
bundle_id = org.ceibaljam.flappy
icon = flappy
exec = sugar-activity activity.Activity
license = GPLv3
summary = The popular Flappy bird game
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!-- Created with Inkscape (http://www.inkscape.org/) -->
<svg
xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:cc="http://creativecommons.org/ns#"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:svg="http://www.w3.org/2000/svg"
xmlns="http://www.w3.org/2000/svg"
xmlns:xlink="http://www.w3.org/1999/xlink"
xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
id="svg2"
version="1.1"
inkscape:version="0.48.4 r9939"
width="55"
height="55"
sodipodi:docname="bird_h_alfa.png">
<metadata
id="metadata8">
<rdf:RDF>
<cc:Work
rdf:about="">
<dc:format>image/svg+xml</dc:format>
<dc:type
rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
<dc:title></dc:title>
</cc:Work>
</rdf:RDF>
</metadata>
<defs
id="defs6" />
<sodipodi:namedview
pagecolor="#ffffff"
bordercolor="#666666"
borderopacity="1"
objecttolerance="10"
gridtolerance="10"
guidetolerance="10"
inkscape:pageopacity="0"
inkscape:pageshadow="2"
inkscape:window-width="1366"
inkscape:window-height="744"
id="namedview4"
showgrid="false"
inkscape:zoom="4.8813559"
inkscape:cx="25.914931"
inkscape:cy="21"
inkscape:window-x="0"
inkscape:window-y="24"
inkscape:window-maximized="1"
inkscape:current-layer="svg2" />
<image
width="55"
height="39.152542"
xlink:href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADsAAAAqCAYAAAANryONAAAABHNCSVQICAgIfAhkiAAAA/BJREFU
aIHtmV1sk1UYx39t33azn3Q6tB0GEGOk0c0bF0mqF0wXTbjSYUiAYGKMU6deOSAjGk0mCSZmTiNG
vaCJMThxRp0MEmMkKwkXfhBQuJDN4WSjbu0K/Rijb/t6UTn9SN/tXd9KIu/+V+c5z+n/PM97/uej
55j4D7DjldeVWvK529t495GgSS+PVItgypEcOV5TPtdDwZrwmGvC8j9B1dJ4fmBIVarmLz7VxHE5
liSVuAKARbLgW+Or2E5++FEUu13Y7z+5qaq4q5Zx5O1+Vd++gRc0cXx9YITw4VMArLjFw54DPRXb
9XT0EL0YW3qQZTCUjA2VrGYZdw19r1z964Kwb/strNo2m/q1Yn0saiVy0SrseoeTlgdbAHB5Xap8
61sDJGYTwr75qe1ivbCtauK9TRs1zWHNyc6fGyV28HNh71xgXs6NdlesPx12ceTbBmFvfqmDjpfb
Fu17W/fWErsz+JwoN2zZvOjvr8FQMjZUsqoy7gwdUqb3fyjstVOn2VUkXTWpLgUzY3FGwxP5QOos
rL7fX7Fd+dbzQXi/KId6QzzxQLsCYPX7ODgYUp2/hhpZQyVbIuPtXbuV9I8/AeA40k/X3kiR9zxz
o0evZ2w1h6FGdjnZGxWqW8/4H/W8tnu17g46X5zE588AsCGYYEOwcOwbHhrkrV3fAeD2enh2Z2Fr
Wxe8XZR7D/XqjgMMNrKGSta05fEd4h9EW/td3B24VTdpX/eAKBfLuByXL1lIpfLfO522MXw4IHx1
DpumvmKRGOlEGgCTJCGtbCxw3LmO0L5XxYlKykxOCafbvh7/mkauF9yeLG5PFoDZ2RzTU3/r4lNk
meJ8pAZvid9QMi5ZjbPp35HjMwCYJA8WZ7MmEjk+UlXn42N1TE3m5apcMbPRnq2KRw3x5AxP7+0X
07Q02eQvZKIpAMz1d2hONhP9pqxG25Z19oydE8fdADRYFHobK8/tanEyfoGfvxoStqFkbKhkTcWa
9iVO4JkfyzssHizOezWRyJdKL998scIpqfm+JA5HDoBzMSenIh7hWzFpwzmTn0k5IJ7V/ZxTgvhK
H2MtrcIuYS/+i6cH7zx2smL9D+ONfHm2SdgdLpm2fz9ENAt7prXtrVpx0z0BPvm4T+RoKBmXrMaS
14PVn39vUeavIkejwme3ynjr9a2WTptMk2tO2LLFzEQm/72TOVgl5XTxZxQTkQWmgqqn/MKttSnG
1uY/dQVTjsEzTRw7nz+x1WLrmciYeDNauIQ3tIwNlazmtf6Zvo+U4uePYqitvktBNG3jjWOBxRsu
gOV74yIsJ3ujoibns2tvLXpg8XoZGP6stufFMhhqZA2V7D8nMDNGX1B/JgAAAABJRU5ErkJggg==
"
id="image10"
x="0"
y="8.8474579" />
</svg>
......@@ -20,6 +20,7 @@
# Contact information:
# Alan Aguiar alanjas@hotmail.com
import gtk
import pygame
import sys
import pygame.sprite as sprite
......@@ -116,6 +117,8 @@ class Flappy():
self.state = INIT
self.running = True
while self.running:
while gtk.events_pending():
gtk.main_iteration()
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.running = False
......
#! /usr/bin/env python
# -*- coding: utf-8 -*-
from sugar.activity import bundlebuilder
if __name__ == "__main__":
bundlebuilder.start()
\ No newline at end of file
__version__ = '1.1'
import os
import gtk
import gobject
import pygame
import event
CANVAS = None
class PygameCanvas(gtk.EventBox):
"""
mainwindow is the activity intself.
"""
def __init__(self, mainwindow, pointer_hint = True):
gtk.EventBox.__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_flags(gtk.CAN_FOCUS)
self._socket = gtk.Socket()
self.add(self._socket)
self._initialized = False
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):
# PygameCanvas.run_pygame can only be called once
if self._initialized:
return
# Preinitialize Pygame with the X window ID.
os.environ['SDL_WINDOWID'] = str(self._socket.get_id())
if pygame.display.get_surface() is not None:
pygame.display.quit()
pygame.init()
# Restore the default cursor.
self._socket.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()
self._initialized = True
return False
def get_pygame_widget(self):
return self._socket
import gtk
import gobject
import pygame
import pygame.event
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(
gtk.gdk.KEY_PRESS_MASK | \
gtk.gdk.KEY_RELEASE_MASK | \
gtk.gdk.VISIBILITY_NOTIFY_MASK
)
self._inner_evb.set_events(
gtk.gdk.POINTER_MOTION_MASK | \
gtk.gdk.POINTER_MOTION_HINT_MASK | \
gtk.gdk.BUTTON_MOTION_MASK | \
gtk.gdk.BUTTON_PRESS_MASK | \
gtk.gdk.BUTTON_RELEASE_MASK
)
self._mainwindow.set_flags(gtk.CAN_FOCUS)
self._inner_evb.set_flags(gtk.CAN_FOCUS)
# Callback functions to link the event systems
self._mainwindow.connect('unrealize', self._quit_cb)
self._mainwindow.connect('visibility_notify_event', self._visibility_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('expose-event', self._expose_cb)
self._inner_evb.connect('configure-event', self._resize_cb)
self._inner_evb.connect('screen-changed', self._screen_changed_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 update_display(self):
pygame.event.post(pygame.event.Event(pygame.VIDEOEXPOSE))
def _expose_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 _screen_changed_cb(self, widget, screen):
if pygame.display.get_init():
self.update_display()
def _quit_cb(self, data=None):
self.__stopped = True
pygame.event.post(pygame.event.Event(pygame.QUIT))
def _visibility_cb(self, widget, event):
if pygame.display.get_init():
self.update_display()
return False
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 = gtk.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(gtk.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:
x, y, state = event.window.get_pointer()
else:
x = event.x
y = event.y
state = event.state
rel = (x - self.__mouse_pos[0], y - self.__mouse_pos[1])
self.__mouse_pos = (x, y)
self.__button_state = [
state & gtk.gdk.BUTTON1_MASK and 1 or 0,
state & gtk.gdk.BUTTON2_MASK and 1 or 0,
state & gtk.gdk.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
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment