Follow Me Base

author: flavio <fdanesse@gmail.com> 2012-12-20 18:13:21 (GMT)
committer: flavio <fdanesse@gmail.com> 2012-12-20 18:13:21 (GMT)
commit: da77c8f245b5f186445352992cb6280503585985 (patch)
tree: 9cdbb3ca0e9cb6aa6455b62a36b968d9b2ce5b00
72 files changed, 1407 insertions, 0 deletions
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..4842d8c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+*.py[co]
+*.bak
diff --git a/FollowMe.py b/FollowMe.py
new file mode 100755
index 0000000..bc1c02f
--- /dev/null
+++ b/FollowMe.py
@@ -0,0 +1,218 @@
+#!/usr/bin/python
+# FollowMe.py
+"""
+    Copyright (C) 2010  Peter Hewitt
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+"""
+import g,utils,pygame,simon,buttons,sys,slider,load_save,rc_skip_last
+try:
+    import gtk
+except:
+    pass
+
+class FollowMe:
+    
+    def __init__(self):
+        self.journal=True # set to False if we come in via main()
+        self.canvas=None # set to the pygame canvas if we come in via activity.py
+
+    def display(self):
+        g.screen.fill((0,255,0))
+        if self.aim.running or self.aim.glow_active:
+            pass
+        else:
+            x=g.imgs[g.green].x; y=g.imgs[g.green].y
+            w=g.imgs[g.green].w; h=g.imgs[g.green].h
+            pygame.draw.rect(g.screen,utils.WHITE,(x,y,w,h),g.sy(.2))
+        for img in g.imgs: # img from ImgClick (centred)
+            img.draw(g.screen)
+        if g.wrong:
+            img=g.imgs[g.wrong_ind]
+            utils.centre_blit(g.screen,g.wrong_img,(img.cx,img.cy))
+            img=g.imgs[g.right_ind]
+            utils.centre_blit(g.screen,g.glowy[g.right_ind],(img.cx,img.cy))
+        buttons.draw()
+        self.slider.draw()
+        self.ladder()
+        self.aim.glow()
+        self.player.glow(True)
+
+    def do_click(self):
+        self.glow_off()
+        if self.click(): return
+        bu=buttons.check()
+        if bu<>'':self.do_button(bu); return
+        if self.slider.mouse(): self.set_delay()
+
+    def do_button(self,bu):
+        if bu=='green': # start
+            self.aim.new1(); g.player_n=0; g.wrong=False; g.score=0
+            buttons.off("green"); buttons.on("back")
+        elif bu=='back': self.aim.start() # show again
+
+    def do_key(self,key):
+        if key in g.TICK:
+            self.change_level(); self.set_delay(); return
+        if key==pygame.K_v: g.version_display=not g.version_display; return
+        if self.aim.running or self.aim.glow_active: return
+        if key in g.CROSS: self.do_click(); return
+        if key in g.SQUARE:
+            if buttons.active('green'): self.do_button('green'); return
+            if buttons.active('back'): self.do_button('back'); return
+        if key in g.RIGHT:
+            g.green=self.rc.inc_c(g.green); g.imgs[g.green].mouse_set()
+        if key in g.LEFT:
+            g.green=self.rc.dec_c(g.green); g.imgs[g.green].mouse_set()
+        if key in g.UP:
+            g.green=self.rc.dec_r(g.green); g.imgs[g.green].mouse_set()
+        if key in g.DOWN:
+            g.green=self.rc.inc_r(g.green); g.imgs[g.green].mouse_set()
+
+    def mouse_set(self):
+        ind=0
+        for imgc in g.imgs:
+            if imgc.mouse_on(): g.green=ind; return
+            ind+=1
+
+    def change_level(self):
+        g.level+=1
+        if g.level>self.slider.steps: g.level=1
+
+    def ladder(self):
+        if g.score>g.best: g.best=g.score
+        if g.best>11:
+            cx=g.sx(30.55); cy=g.sy(13.25)
+            utils.centre_blit(g.screen,g.star,(cx,cy))
+            utils.display_number(g.best,(cx,cy),g.font2)
+        if g.score>0:
+            n=g.score-1
+            if n>11: n=11
+            g.screen.blit(g.ladder,(g.sx(26.95),g.sy(13.7)))
+            x=g.man_x0+n*g.man_dx; y=g.man_y0+n*g.man_dy
+            g.screen.blit(g.man,(x,y))
+            cx=x+g.man_sc_dx; cy=y+g.man_sc_dy
+            if g.score<g.best or g.best<12:
+                utils.centre_blit(g.screen,g.star,(cx,cy))
+                utils.display_number(g.score,(cx,cy),g.font2)
+        
+    def which(self):
+        ind=0
+        for img in g.imgs:
+            if img.mouse_on(): return ind
+            ind+=1
+        return -1 # none clicked
+
+    def click(self):
+        if self.aim.running: return False
+        if g.wrong: return False
+        ind=self.which()
+        if ind==-1: return False
+        if len(self.aim.list1)==0: return False
+        self.player.glow_start(ind)
+        buttons.off("back")
+        if ind==self.aim.list1[g.player_n]:
+            g.player_n+=1
+            if g.player_n>g.score: g.score=g.player_n
+            if g.player_n==len(self.aim.list1): # all correct - add another
+                self.aim.inc(); g.player_n=0
+        else:
+            g.wrong=True; g.wrong_ind=ind
+            g.right_ind=self.aim.list1[g.player_n]
+            buttons.on("green")
+        return True # click processed
+        
+    def glow_off(self):
+        self.aim.glow_off(); self.player.glow_off()
+
+    def set_delay(self):
+        self.aim.glow_time=(4-g.level)*500-300
+        self.aim.delay=(4-g.level)*330
+
+    def flush_queue(self):
+        flushing=True
+        while flushing:
+            flushing=False
+            if self.journal:
+                while gtk.events_pending(): gtk.main_iteration()
+            for event in pygame.event.get(): flushing=True
+
+    def run(self):
+        g.init()
+        if not self.journal: utils.load()
+        load_save.retrieve()
+        self.aim=simon.Simon(1200) # arg is glow time
+        self.set_delay()
+        self.player=simon.Simon(200)
+        bx=g.sx(22.42); by=g.sy(20.8)
+        buttons.Button("green",(bx,by),True)
+        buttons.Button("back",(bx,by),True); buttons.off("back")
+        self.slider=slider.Slider(g.sx(9),g.sy(20.8),3,utils.BLUE)
+        self.rc=rc_skip_last.RC(3,5)
+        if self.canvas<>None: self.canvas.grab_focus()
+        ctrl=False
+        pygame.key.set_repeat(600,120); key_ms=pygame.time.get_ticks()
+        going=True
+        while going:
+            if self.journal:
+                # Pump GTK messages.
+                while gtk.events_pending(): gtk.main_iteration()
+
+            # Pump PyGame messages.
+            for event in pygame.event.get():
+                if event.type==pygame.QUIT:
+                    if not self.journal: utils.save()
+                    going=False
+                elif event.type == pygame.MOUSEMOTION:
+                    g.pos=event.pos
+                    g.redraw=True
+                    if self.canvas<>None: self.canvas.grab_focus()
+                    self.mouse_set()
+                elif event.type == pygame.MOUSEBUTTONDOWN:
+                    g.redraw=True
+                    if event.button==1: self.do_click(); self.flush_queue()
+                elif event.type == pygame.KEYDOWN:
+                    # throttle keyboard repeat
+                    if pygame.time.get_ticks()-key_ms>110:
+                        key_ms=pygame.time.get_ticks()
+                        if ctrl:
+                            if event.key==pygame.K_q:
+                                if not self.journal: utils.save()
+                                going=False; break
+                            else:
+                                ctrl=False
+                        if event.key in (pygame.K_LCTRL,pygame.K_RCTRL):
+                            ctrl=True; break
+                        self.do_key(event.key); g.redraw=True
+                        self.flush_queue()
+                elif event.type == pygame.KEYUP:
+                    ctrl=False
+            if not going: break
+            if g.player_n==0 and not buttons.active('green'):
+                buttons.on("back")
+            self.player.do()
+            self.aim.do()
+            if g.redraw:
+                self.display()
+                if g.version_display: utils.version_display()
+                if self.aim.running or self.aim.glow_active:
+                    pass
+                else:
+                    g.screen.blit(g.pointer,g.pos)
+                pygame.display.flip()
+                g.redraw=False
+            g.clock.tick(40)
+
+if __name__=="__main__":
+    pygame.init()
+    pygame.display.set_mode((1024,768),pygame.FULLSCREEN)
+    game=FollowMe()
+    game.journal=False
+    game.run()
+    pygame.display.quit()
+    pygame.quit()
+    sys.exit(0)
diff --git a/MANIFEST b/MANIFEST
new file mode 100644
index 0000000..8c1774d
--- /dev/null
+++ b/MANIFEST
@@ -0,0 +1,70 @@
+slider.py
+setup.py
+g.py
+buttons.py
+imgClick.py
+load_save.py
+simon.py
+utils.py
+FollowMe.py
+rc_skip_last.py
+activity.py
+sugargame/__init__.py
+sugargame/canvas.py
+sugargame/event.py
+activity/activity.info
+activity/activity.svg
+data/pointer.png
+data/7.png
+data/fast.png
+data/3.png
+data/man.png
+data/star.png
+data/green_down.png
+data/ladder.png
+data/back_up.png
+data/13.png
+data/slow.png
+data/10.png
+data/12.png
+data/8.png
+data/xo.png
+data/9.png
+data/14.png
+data/back_down.png
+data/4.png
+data/6.png
+data/11.png
+data/5.png
+data/2.png
+data/1.png
+data/wrong.png
+data/green_up.png
+data/glow/7.png
+data/glow/3.png
+data/glow/13.png
+data/glow/10.png
+data/glow/12.png
+data/glow/8.png
+data/glow/9.png
+data/glow/14.png
+data/glow/4.png
+data/glow/6.png
+data/glow/11.png
+data/glow/5.png
+data/glow/2.png
+data/glow/1.png
+data/glowy/7.png
+data/glowy/3.png
+data/glowy/13.png
+data/glowy/10.png
+data/glowy/12.png
+data/glowy/8.png
+data/glowy/9.png
+data/glowy/14.png
+data/glowy/4.png
+data/glowy/6.png
+data/glowy/11.png
+data/glowy/5.png
+data/glowy/2.png
+data/glowy/1.png
diff --git a/activity.py b/activity.py
new file mode 100755
index 0000000..fdaa0f9
--- /dev/null
+++ b/activity.py
@@ -0,0 +1,53 @@
+# activity.py
+# my standard link between sugar and my activity
+
+from gettext import gettext as _
+
+import gtk
+import pygame
+from sugar.activity import activity
+from sugar.graphics.toolbutton import ToolButton
+import gobject
+import sugargame.canvas
+import load_save
+import FollowMe
+
+class PeterActivity(activity.Activity):
+    def __init__(self, handle):
+        super(PeterActivity, self).__init__(handle)
+
+        # Build the activity toolbar.
+        toolbox = activity.ActivityToolbox(self)
+        activity_toolbar = toolbox.get_activity_toolbar()
+        activity_toolbar.keep.props.visible = False
+        activity_toolbar.share.props.visible = False
+
+        toolbox.show()
+        self.set_toolbox(toolbox)
+
+        # Create the game instance.
+        self.game = FollowMe.FollowMe()
+
+        # 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.game.canvas=self._pygamecanvas
+
+        # Start the game running.
+        self._pygamecanvas.run_pygame(self.game.run)
+
+    def read_file(self, file_path):
+        try:
+            f = open(file_path, 'r')
+        except:
+            return #****
+        load_save.load(f)
+        f.close()
+
+    def write_file(self, file_path):
+        f = open(file_path, 'w')
+        load_save.save(f)
+        f.close()
diff --git a/activity/activity.info b/activity/activity.info
new file mode 100644
index 0000000..2fda8c4
--- /dev/null
+++ b/activity/activity.info
@@ -0,0 +1,8 @@
+[Activity]
+name = Follow Me
+activity_version = 22
+host_version = 1
+bundle_id = org.laptop.community.FollowMe
+icon = activity
+show_launcher = yes
+exec = sugar-activity activity.PeterActivity
diff --git a/activity/activity.svg b/activity/activity.svg
new file mode 100644
index 0000000..2555585
--- /dev/null
+++ b/activity/activity.svg
@@ -0,0 +1,105 @@
+<?xml version="1.0" ?><!DOCTYPE svg  PUBLIC '-//W3C//DTD SVG 1.1//EN'  'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd' [
+	<!ENTITY stroke_color "#00ff03">
+	<!ENTITY fill_color "#ff0000">
+]><!--Generator: Xara Xtreme (www.xara.com), SVG filter version: 1.0.0.13--><svg fill-rule="evenodd" height="39.595pt" overflow="visible" stroke-linejoin="bevel" stroke-width="0.501" version="1.1" viewBox="0 0 41.247 39.595" width="41.247pt" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+ <defs>
+  <marker id="DefaultArrow2" markerHeight="1" markerUnits="strokeWidth" markerWidth="1" orient="auto" overflow="visible" viewBox="0 0 1 1">
+   <!-- REF_ARROW_STRAIGHT (-2) -->
+   <g transform="scale(0.0092592592)">
+    <!-- 1/108 -->
+    <path d="M -9 54 L -9 -54 L 117 0 z"/>
+   </g>
+  </marker>
+  <marker id="DefaultArrow3" markerHeight="1" markerUnits="strokeWidth" markerWidth="1" orient="auto" overflow="visible" viewBox="0 0 1 1">
+   <!-- REF_ARROW_ANGLED -->
+   <g transform="scale(0.0092592592)">
+    <path d="M -27 54 L -9 0 L -27 -54 L 135 0 z"/>
+   </g>
+  </marker>
+  <marker id="DefaultArrow4" markerHeight="1" markerUnits="strokeWidth" markerWidth="1" orient="auto" overflow="visible" viewBox="0 0 1 1">
+   <!-- REF_ARROW_ROUNDED -->
+   <g transform="scale(0.0092592592)">
+    <path d="M -9,0 L -9,-45 C -9,-51.708 2.808,-56.580 9,-54 L 117,-9 C 120.916,-7.369 126.000,-4.242 126,0 C 126,4.242 120.916,7.369 117,9 L 9,54 C 2.808,56.580 -9,51.708 -9,45 z"/>
+   </g>
+  </marker>
+  <marker id="DefaultArrow5" markerHeight="1" markerUnits="strokeWidth" markerWidth="1" orient="auto" overflow="visible" viewBox="0 0 1 1">
+   <!-- REF_ARROW_SPOT -->
+   <g transform="scale(0.0092592592)">
+    <path d="M -54, 0 C -54,29.807 -29.807,54 0,54 C 29.807,54 54,29.807 54,0 C 54,-29.807 29.807,-54 0,-54 C -29.807,-54 -54,-29.807 -54,0 z"/>
+   </g>
+  </marker>
+  <marker id="DefaultArrow6" markerHeight="1" markerUnits="strokeWidth" markerWidth="1" orient="auto" overflow="visible" viewBox="0 0 1 1">
+   <!-- REF_ARROW_DIAMOND -->
+   <g transform="scale(0.0092592592)">
+    <path d="M -63,0 L 0,63 L 63,0 L 0,-63 z"/>
+   </g>
+  </marker>
+  <marker id="DefaultArrow7" markerHeight="1" markerUnits="strokeWidth" markerWidth="1" orient="auto" overflow="visible" viewBox="0 0 1 1">
+   <!-- REF_ARROW_FEATHER -->
+   <g transform="scale(0.0092592592)">
+    <path d="M 18,-54 L 108,-54 L 63,0 L 108,54 L 18, 54 L -36,0 z"/>
+   </g>
+  </marker>
+  <marker id="DefaultArrow8" markerHeight="1" markerUnits="strokeWidth" markerWidth="1" orient="auto" overflow="visible" viewBox="0 0 1 1">
+   <!-- REF_ARROW_FEATHER2 -->
+   <g transform="scale(0.0092592592)">
+    <path d="M -36,0 L 18,-54 L 54,-54 L 18,-18 L 27,-18 L 63,-54 L 99,-54 L 63,-18 L 72,-18 L 108,-54 L 144,-54 L 90,0 L 144,54 L 108,54 L 72,18 L 63,18 L 99,54 L 63,54 L 27,18 L 18,18 L 54,54 L 18,54 z"/>
+   </g>
+  </marker>
+  <marker id="DefaultArrow9" markerHeight="1" markerUnits="strokeWidth" markerWidth="1" orient="auto" overflow="visible" viewBox="0 0 1 1">
+   <!-- REF_ARROW_HOLLOWDIAMOND -->
+   <g transform="scale(0.0092592592)">
+    <path d="M 0,45 L -45,0 L 0, -45 L 45, 0 z M 0, 63 L-63, 0 L 0, -63 L 63, 0 z"/>
+   </g>
+  </marker>
+  <filter id="StainedFilter">
+   <feBlend in="SourceGraphic" in2="BackgroundImage" mode="multiply" result="blend"/>
+   <feComposite in="blend" in2="SourceAlpha" operator="in" result="comp"/>
+  </filter>
+  <filter id="BleachFilter">
+   <feBlend in="SourceGraphic" in2="BackgroundImage" mode="screen" result="blend"/>
+   <feComposite in="blend" in2="SourceAlpha" operator="in" result="comp"/>
+  </filter>
+  <filter id="InvertTransparencyBitmapFilter">
+   <feComponentTransfer>
+    <feFuncR amplitude="1.055" exponent=".416666666" offset="-0.055" type="gamma"/>
+    <feFuncG amplitude="1.055" exponent=".416666666" offset="-0.055" type="gamma"/>
+    <feFuncB amplitude="1.055" exponent=".416666666" offset="-0.055" type="gamma"/>
+   </feComponentTransfer>
+   <feComponentTransfer>
+    <feFuncR intercept="1" slope="-1" type="linear"/>
+    <feFuncG intercept="1" slope="-1" type="linear"/>
+    <feFuncB intercept="1" slope="-1" type="linear"/>
+    <feFuncA intercept="0" slope="1" type="linear"/>
+   </feComponentTransfer>
+   <feComponentTransfer>
+    <feFuncR amplitude="1" exponent="2.4" offset="0" type="gamma"/>
+    <feFuncG amplitude="1" exponent="2.4" offset="0" type="gamma"/>
+    <feFuncB amplitude="1" exponent="2.4" offset="0" type="gamma"/>
+   </feComponentTransfer>
+  </filter>
+  <image height="0.001" id="Bitmap" width="0.001" xlink:href="data:image/png;base64,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">
+   <title>ladder.png</title>
+  </image>
+  <pattern height="1000" id="BitmapFill" patternTransform="translate(-115.281 186.176) scale(1 -1)" patternUnits="userSpaceOnUse" width="1000">
+   <rect fill="white" height="1000" stroke="none" width="1000"/>
+   <use transform="scale(258750 500249)" xlink:href="#Bitmap"/>
+  </pattern>
+ </defs>
+ <g fill="none" font-family="Times New Roman" font-size="16" id="Document" stroke="black" transform="scale(1 -1)">
+  <g id="Spread" transform="translate(0 -39.595)">
+   <g display="none" id="Layer 1">
+    <path d="M -115.281,186.176 L 143.469,186.176 L 143.469,-314.073 L -115.281,-314.073 L -115.281,186.176 Z" fill="url(#BitmapFill)" marker-end="none" marker-start="none" stroke="none" stroke-linejoin="miter"/>
+   </g>
+   <g id="star2"/>
+   <g id="ladder"/>
+   <g id="man">
+    <path d="M 20.701,38.954 L 15.897,24.281 L 0.599,24.307 L 12.928,15.221 L 8.116,0.553 L 20.541,9.609 L 32.866,0.517 L 28.215,15.199 L 40.644,24.25 L 25.346,24.268 L 20.701,38.954 Z" fill="&fill_color;" marker-end="none" marker-start="none" stroke-linejoin="miter" stroke-miterlimit="79.8403193612775" stroke-width="0.393"/>
+    <path d="M 20.19,21.742 C 19.745,20.499 19.446,19.319 19.693,18.397 C 21.586,17.548 23.616,16.769 25.02,15.674 C 25.321,15.351 25.485,14.896 25.515,14.31 C 25.082,12.353 24.586,10.532 24.029,8.861 C 23.595,8.382 23.185,8.189 22.791,8.242 C 22.121,8.233 21.653,8.546 21.427,9.233 C 21.419,9.394 21.436,9.6 21.55,9.976 L 22.791,13.94 L 19.074,13.94 C 18.994,9.473 19.069,5.232 19.446,1.428 C 19.327,0.759 18.97,0.3 18.083,0.315 C 17.373,0.405 16.924,0.658 16.72,1.058 C 16.609,1.376 16.524,1.706 16.473,2.048 L 15.729,10.471 C 14.844,13.842 13.957,17.221 14.119,23.477 C 11.067,24.606 8.249,26.012 6.069,28.183 C 5.856,28.66 5.776,29.148 6.193,29.671 C 6.584,29.999 6.959,30.159 7.308,30.042 L 8.176,29.792 C 9.807,28.58 11.5,27.672 13.251,27.07 L 16.473,27.194 C 15.527,27.812 14.912,28.768 14.738,30.166 C 14.941,31.203 15.498,31.964 16.473,32.395 C 17.407,32.544 18.179,32.4 18.826,32.024 C 19.75,31.47 20.165,30.543 19.818,29.05 C 19.546,28.417 19.139,27.954 18.581,27.69 C 18.183,27.368 18.231,27.139 18.455,26.946 L 18.826,26.822 C 19.912,26.376 20.752,25.689 21.302,24.717 C 22.068,23.737 22.899,23.057 23.78,22.61 L 27.373,22.365 C 27.58,22.283 27.759,22.138 27.744,21.496 C 27.71,21.226 27.531,20.976 27.125,20.75 C 25.795,20.533 24.538,20.39 23.409,20.38 C 22.437,20.667 21.452,21.084 20.436,21.742 L 20.19,21.742 Z" fill="&stroke_color;" marker-end="none" marker-start="none" stroke-miterlimit="79.8403193612775" stroke-width="0.458"/>
+   </g>
+   <g display="none" id="star">
+    <path d="M -39.651,-1.415 L -44.362,-26.409 L -69.36,-29.637 L -47.276,-41.843 L -52,-66.833 L -33.64,-49.384 L -11.562,-61.601 L -22.299,-38.611 L -3.93,-21.17 L -28.926,-24.411 L -39.651,-1.415 Z" fill="#fffc00" marker-end="none" marker-start="none" stroke-linejoin="miter" stroke-miterlimit="79.8403193612775" stroke-width="0.442"/>
+   </g>
+  </g>
+ </g>
+</svg>
+\ No newline at end of file
diff --git a/buttons.py b/buttons.py
new file mode 100755
index 0000000..9542796
--- /dev/null
+++ b/buttons.py
@@ -0,0 +1,106 @@
+# buttons.py
+import g,utils,pygame
+
+class Button:
+    _instances=[]
+    
+    def __init__(self,name,(x1,y1),centre=True): # eg ('plus',(30,40))
+        self._instances.append(self)
+        up=utils.load_image(name+"_up.png",True)
+        down=utils.load_image(name+"_down.png",True)
+        w=up.get_width();h=up.get_height();x=x1;y=y1
+        if centre:
+            self.cx=x; self.cy=y
+            x=x-w/2; y=y-h/2
+        else:
+            self.cx=x+w/2; self.cy=y+h/2
+        self.rect=pygame.Rect(x,y,w,h)
+        self.name=name; self.x=x; self.y=y; self.active=True
+        self.up=up; self.down=down; self.stay_down=False
+
+    def mouse_on(self):
+        mx,my=g.pos
+        return self.rect.collidepoint(mx,my)
+
+    def draw_up(self):
+        g.screen.blit(self.up,(self.x,self.y))
+
+    def draw_down(self):
+        g.screen.blit(self.down,(self.x,self.y))
+
+    def on(self):
+        self.active=True
+
+    def off(self):
+        self.active=False
+
+def draw():
+    for b in Button._instances:
+        if b.active:
+            if b.stay_down:
+                b.draw_down()
+            else:
+                b.draw_up()
+
+def check():
+    clear()
+    for b in Button._instances:
+        if b.active:
+            if b.mouse_on():
+                if b.name in ('xyz1','xyz2'):
+                    b.stay_down=True
+                else:
+                    b.draw_down()
+                    g.screen.blit(g.pointer,g.pos)
+                    pygame.display.flip()
+                    pygame.time.wait(300)
+                return b.name #****
+    return '' # no button pressed
+
+def clear():
+    for b in Button._instances: b.stay_down=False
+    
+def active(name):
+    for b in Button._instances:
+        if b.name==name: return b.active #****
+    return False # not found
+
+def stay_down(name):
+    for b in Button._instances:
+        if b.name==name: b.stay_down=True; return #****
+    return
+
+def mouse_on(name):
+    mx,my=g.pos
+    for b in Button._instances:
+        if b.name==name:
+            return b.rect.collidepoint(mx,my)
+    return False
+
+def set_mouse(name):
+    p2=g.pointer.get_height()/2
+    for b in Button._instances:
+        if b.name==name:
+            x=b.cx; y=b.cy+p2
+            pygame.mouse.set_pos(x,y); g.pos=(x,y)
+
+# eg1 buttons.on('plus')
+# eg2 buttons.on(['plus','times'])
+def on(name):
+    if type(name)==type('a'):
+        list1=[]; list1.append(name)
+    else:
+        list1=name
+    for b in Button._instances:
+        if b.name in list1: b.active=True
+
+# eg1 buttons.off('plus')
+# eg2 buttons.off(['plus','times'])
+def off(name):
+    if type(name)==type('a'):
+        list1=[]; list1.append(name)
+    else:
+        list1=name
+    for b in Button._instances:
+        if b.name in list1: b.active=False
+
diff --git a/data/1.png b/data/1.png
new file mode 100755
index 0000000..d809c57
--- /dev/null
+++ b/data/1.png
diff --git a/data/10.png b/data/10.png
new file mode 100755
index 0000000..874aec2
--- /dev/null
+++ b/data/10.png
diff --git a/data/11.png b/data/11.png
new file mode 100755
index 0000000..624a619
--- /dev/null
+++ b/data/11.png
diff --git a/data/12.png b/data/12.png
new file mode 100755
index 0000000..374b4ab
--- /dev/null
+++ b/data/12.png
diff --git a/data/13.png b/data/13.png
new file mode 100755
index 0000000..a1e3903
--- /dev/null
+++ b/data/13.png
diff --git a/data/14.png b/data/14.png
new file mode 100755
index 0000000..1ef3e38
--- /dev/null
+++ b/data/14.png
diff --git a/data/2.png b/data/2.png
new file mode 100755
index 0000000..ba74d1c
--- /dev/null
+++ b/data/2.png
diff --git a/data/3.png b/data/3.png
new file mode 100755
index 0000000..3827fed
--- /dev/null
+++ b/data/3.png
diff --git a/data/4.png b/data/4.png
new file mode 100755
index 0000000..6e29e2f
--- /dev/null
+++ b/data/4.png
diff --git a/data/5.png b/data/5.png
new file mode 100755
index 0000000..bd4c28d
--- /dev/null
+++ b/data/5.png
diff --git a/data/6.png b/data/6.png
new file mode 100755
index 0000000..15067b1
--- /dev/null
+++ b/data/6.png
diff --git a/data/7.png b/data/7.png
new file mode 100755
index 0000000..21548bf
--- /dev/null
+++ b/data/7.png
diff --git a/data/8.png b/data/8.png
new file mode 100755
index 0000000..8205f76
--- /dev/null
+++ b/data/8.png
diff --git a/data/9.png b/data/9.png
new file mode 100755
index 0000000..7cc120b
--- /dev/null
+++ b/data/9.png
diff --git a/data/back_down.png b/data/back_down.png
new file mode 100755
index 0000000..1da7008
--- /dev/null
+++ b/data/back_down.png
diff --git a/data/back_up.png b/data/back_up.png
new file mode 100755
index 0000000..2023b80
--- /dev/null
+++ b/data/back_up.png
diff --git a/data/fast.png b/data/fast.png
new file mode 100755
index 0000000..f638c00
--- /dev/null
+++ b/data/fast.png
diff --git a/data/glow/1.png b/data/glow/1.png
new file mode 100755
index 0000000..517b396
--- /dev/null
+++ b/data/glow/1.png
diff --git a/data/glow/10.png b/data/glow/10.png
new file mode 100755
index 0000000..07cf282
--- /dev/null
+++ b/data/glow/10.png
diff --git a/data/glow/11.png b/data/glow/11.png
new file mode 100755
index 0000000..75aa9ed
--- /dev/null
+++ b/data/glow/11.png
diff --git a/data/glow/12.png b/data/glow/12.png
new file mode 100755
index 0000000..e1c84b2
--- /dev/null
+++ b/data/glow/12.png
diff --git a/data/glow/13.png b/data/glow/13.png
new file mode 100755
index 0000000..991db74
--- /dev/null
+++ b/data/glow/13.png
diff --git a/data/glow/14.png b/data/glow/14.png
new file mode 100755
index 0000000..fa382e9
--- /dev/null
+++ b/data/glow/14.png
diff --git a/data/glow/2.png b/data/glow/2.png
new file mode 100755
index 0000000..d0244c6
--- /dev/null
+++ b/data/glow/2.png
diff --git a/data/glow/3.png b/data/glow/3.png
new file mode 100755
index 0000000..56bee60
--- /dev/null
+++ b/data/glow/3.png
diff --git a/data/glow/4.png b/data/glow/4.png
new file mode 100755
index 0000000..5eec50a
--- /dev/null
+++ b/data/glow/4.png
diff --git a/data/glow/5.png b/data/glow/5.png
new file mode 100755
index 0000000..f05510c
--- /dev/null
+++ b/data/glow/5.png
diff --git a/data/glow/6.png b/data/glow/6.png
new file mode 100755
index 0000000..4e83d68
--- /dev/null
+++ b/data/glow/6.png
diff --git a/data/glow/7.png b/data/glow/7.png
new file mode 100755
index 0000000..7241602
--- /dev/null
+++ b/data/glow/7.png
diff --git a/data/glow/8.png b/data/glow/8.png
new file mode 100755
index 0000000..888dd7a
--- /dev/null
+++ b/data/glow/8.png
diff --git a/data/glow/9.png b/data/glow/9.png
new file mode 100755
index 0000000..ade2c0a
--- /dev/null
+++ b/data/glow/9.png
diff --git a/data/glowy/1.png b/data/glowy/1.png
new file mode 100755
index 0000000..9bdb579
--- /dev/null
+++ b/data/glowy/1.png
diff --git a/data/glowy/10.png b/data/glowy/10.png
new file mode 100755
index 0000000..6ff6261
--- /dev/null
+++ b/data/glowy/10.png
diff --git a/data/glowy/11.png b/data/glowy/11.png
new file mode 100755
index 0000000..e04a6d2
--- /dev/null
+++ b/data/glowy/11.png
diff --git a/data/glowy/12.png b/data/glowy/12.png
new file mode 100755
index 0000000..fa8948e
--- /dev/null
+++ b/data/glowy/12.png
diff --git a/data/glowy/13.png b/data/glowy/13.png
new file mode 100755
index 0000000..cedc13c
--- /dev/null
+++ b/data/glowy/13.png
diff --git a/data/glowy/14.png b/data/glowy/14.png
new file mode 100755
index 0000000..e1b3108
--- /dev/null
+++ b/data/glowy/14.png
diff --git a/data/glowy/2.png b/data/glowy/2.png
new file mode 100755
index 0000000..fbd013c
--- /dev/null
+++ b/data/glowy/2.png
diff --git a/data/glowy/3.png b/data/glowy/3.png
new file mode 100755
index 0000000..a01c739
--- /dev/null
+++ b/data/glowy/3.png
diff --git a/data/glowy/4.png b/data/glowy/4.png
new file mode 100755
index 0000000..15a29e0
--- /dev/null
+++ b/data/glowy/4.png
diff --git a/data/glowy/5.png b/data/glowy/5.png
new file mode 100755
index 0000000..f52cd4c
--- /dev/null
+++ b/data/glowy/5.png
diff --git a/data/glowy/6.png b/data/glowy/6.png
new file mode 100755
index 0000000..317f1e9
--- /dev/null
+++ b/data/glowy/6.png
diff --git a/data/glowy/7.png b/data/glowy/7.png
new file mode 100755
index 0000000..aca8192
--- /dev/null
+++ b/data/glowy/7.png
diff --git a/data/glowy/8.png b/data/glowy/8.png
new file mode 100755
index 0000000..c68b0d7
--- /dev/null
+++ b/data/glowy/8.png
diff --git a/data/glowy/9.png b/data/glowy/9.png
new file mode 100755
index 0000000..4316d54
--- /dev/null
+++ b/data/glowy/9.png
diff --git a/data/green_down.png b/data/green_down.png
new file mode 100755
index 0000000..645684c
--- /dev/null
+++ b/data/green_down.png
diff --git a/data/green_up.png b/data/green_up.png
new file mode 100755
index 0000000..2dc5b20
--- /dev/null
+++ b/data/green_up.png
diff --git a/data/ladder.png b/data/ladder.png
new file mode 100755
index 0000000..67bd7b6
--- /dev/null
+++ b/data/ladder.png
diff --git a/data/man.png b/data/man.png
new file mode 100755
index 0000000..2a519ac
--- /dev/null
+++ b/data/man.png
diff --git a/data/pointer.png b/data/pointer.png
new file mode 100755
index 0000000..7fceb06
--- /dev/null
+++ b/data/pointer.png
diff --git a/data/slow.png b/data/slow.png
new file mode 100755
index 0000000..e6d3a2a
--- /dev/null
+++ b/data/slow.png
diff --git a/data/star.png b/data/star.png
new file mode 100755
index 0000000..506bb48
--- /dev/null
+++ b/data/star.png
diff --git a/data/wrong.png b/data/wrong.png
new file mode 100755
index 0000000..10701d3
--- /dev/null
+++ b/data/wrong.png
diff --git a/data/xo.png b/data/xo.png
new file mode 100755
index 0000000..c272e68
--- /dev/null
+++ b/data/xo.png
diff --git a/g.py b/g.py
new file mode 100755
index 0000000..4233b0b
--- /dev/null
+++ b/g.py
@@ -0,0 +1,127 @@
+# g.py - globals
+import pygame,utils,random,imgClick
+
+app='Follow Me'; ver='1.0'
+ver='1.1'
+# new bgd
+# ladder
+ver='1.2'
+# scaled font @ imgf
+# man on ladder
+# green bgd -> new buttons
+ver='1.3'
+# star separate & left @ top
+ver='1.4' #<<<< Release 3
+# added magician pic
+ver='1.5'
+# magician -> object
+# speed slider
+# change green button colour
+ver='1.5'
+# rationalised g.py
+# no Esc on XO
+# simon.py - delay also controlled by slider
+# save level
+ver='2.0'
+# sugar coated
+# got this to work ok BUT cursor flickers
+ver='2.1'
+# added journal switch
+# swapped me & grapes
+# added version display for right click
+ver='2.2'
+# cf Boxes
+ver='2.3'
+# app title
+ver='2.4'
+# yellow glow for player & longer
+# increased glow size
+# random seed
+ver='3.0'
+# redraw implemented
+ver='4.0'
+# new sugar cursor etc
+ver='21'
+# bigger white glow
+# no pointer or rectangle while leading
+ver='22'
+# flush_queue() doesn't use gtk on non-XO
+
+UP=(264,273)
+DOWN=(258,274)
+LEFT=(260,276)
+RIGHT=(262,275)
+CROSS=(259,120)
+CIRCLE=(265,111)
+SQUARE=(263,32)
+TICK=(257,13)
+
+def init(): # called by main()
+    random.seed()
+    global redraw
+    global screen,w,h,font1,font2,clock,click_snd
+    global factor,offset,imgf,message,version_display
+    global pos,pointer
+    redraw=True
+    version_display=False
+    screen = pygame.display.get_surface()
+    pygame.display.set_caption(app)
+    screen.fill((70,0,70))
+    pygame.display.flip()
+    w,h=screen.get_size()
+    if float(w)/float(h)>1.5: #widescreen
+        offset=(w-4*h/3)/2 # we assume 4:3 - centre on widescreen
+    else:
+        h=int(.75*w) # allow for toolbar - works to 4:3
+        offset=0
+    clock=pygame.time.Clock()
+    factor=float(h)/24 # measurement scaling factor (32x24 = design units)
+    offset=(w-4*h/3)/2 # we assume 4:3 - centre on widescreen
+    imgf=float(h)/900 # image scaling factor - all images built for 1200x900
+    if pygame.font:
+        t=int(54*imgf); font1=pygame.font.Font(None,t)
+        t=int(48*imgf); font2=pygame.font.Font(None,t)
+    message=''
+    pos=pygame.mouse.get_pos()
+    pointer=utils.load_image('pointer.png',True)
+    pygame.mouse.set_visible(False)
+    
+    # this activity only
+    global imgs,glow,glowy,wrong_img,man,ladder,star,score
+    global man_x0,man_y0,man_dx,man_dy,man_sc_dx,man_sc_dy
+    global wrong,player_n,best,level
+    global max_w,max_h,green
+    wrong_img=utils.load_image('wrong.png',True); wrong_ind=0; right_ind=0
+    man=utils.load_image('man.png',True)
+    man_x0=sx(25.5); man_y0=sy(18.31)
+    man_dx=(sx(27.87)-man_x0)/11.0; man_dy=(sy(12.15)-man_y0)/11.0
+    man_sc_dx=sx(25.38)-man_x0; man_sc_dy=sy(18.61)-man_y0
+    ladder=utils.load_image('ladder.png',True)
+    star=utils.load_image('star.png',True)
+    cy=sy(3.2); dx=sy(6.4); dy=sy(6.2); i=1
+    score=0; best=0; level=1
+    imgs=[]; glow=[]; glowy=[]; max_w=0; max_h=0
+    for r in range(1,4):
+        cx=sx(3.2)
+        for c in range(1,6):
+            img=utils.load_image(str(i)+'.png',True)
+            imgC=imgClick.ImgClick(img,(cx,cy),True)
+            if imgC.w>max_w: max_w=imgC.w
+            if imgC.h>max_h: max_h=imgC.h
+            imgs.append(imgC)
+            glow.append(utils.load_image(str(i)+'.png',True,'glow'))
+            glowy.append(utils.load_image(str(i)+'.png',True,'glowy'))
+            cx+=dx; i+=1
+            if i==15: break
+        cy+=dy
+    player_n=0 # player click counter
+    wrong=False
+    green=0
+    imgs[green].mouse_set()
+
+def sx(f): # scale x function
+    return int(f*factor+offset+.5)
+
+def sy(f): # scale y function
+    return int(f*factor+.5)
+
diff --git a/imgClick.py b/imgClick.py
new file mode 100755
index 0000000..707ab86
--- /dev/null
+++ b/imgClick.py
@@ -0,0 +1,27 @@
+#imgClick.py
+# eg click_img=ImgClickClass(img,(x,y)) (x,y)=top left
+#   if click_img.mouse_on():
+#   click_img.draw(gscreen)
+
+import g,pygame
+
+class ImgClick: # for clickable images
+    def __init__(self,img,(x1,y1),centre=False):
+        w=img.get_width();h=img.get_height();x=x1;y=y1
+        if centre: x=x-w/2; y=y-h/2; self.cx=x1; self.cy=y1
+        else: self.cx=x+w/2; self.cy=y+h/2
+        self.rect=pygame.Rect(x,y,w,h)
+        self.x=x; self.y=y; self.img=img
+        self.w=w; self.h=h
+
+
+    def mouse_on(self):
+        return self.rect.collidepoint(g.pos)
+
+    def draw(self,screen):
+        screen.blit(self.img,(self.x,self.y))
+
+    def mouse_set(self):
+        pygame.mouse.set_pos((self.cx,self.cy))
+        g.pos=(self.cx,self.cy)
+        
diff --git a/load_save.py b/load_save.py
new file mode 100755
index 0000000..33d1265
--- /dev/null
+++ b/load_save.py
@@ -0,0 +1,26 @@
+#load_save.py
+import g
+
+loaded=[] # list of strings
+
+def load(f):
+    global loaded
+    try:
+        for line in f.readlines():
+            loaded.append(line)
+    except:
+        pass
+
+def save(f):
+    f.write(str(g.best)+'\n')
+    f.write(str(g.level)+'\n')
+
+# note need for rstrip() on strings
+def retrieve():
+    global loaded
+    if len(loaded)>1:
+        g.best=int(loaded[0])
+        g.level=int(loaded[1])
+
+
+    
diff --git a/rc_skip_last.py b/rc_skip_last.py
new file mode 100755
index 0000000..6557039
--- /dev/null
+++ b/rc_skip_last.py
@@ -0,0 +1,46 @@
+# rc.py
+
+class RC():
+    def __init__(self,nr,nc):
+        self.nr=nr; self.nc=nc
+
+    def inc_r(self,ind):
+        r,c=self.row_col(ind)
+        r+=1
+        if r==self.nr: r=0
+        if r==(self.nr-1) and c==(self.nc-1): r=0
+        return self.indx(r,c)
+
+    def dec_r(self,ind):
+        r,c=self.row_col(ind)
+        r-=1
+        if r<0: r=self.nr-1
+        if r==(self.nr-1) and c==(self.nc-1): r=self.nr-2
+        return self.indx(r,c)
+
+    def inc_c(self,ind):
+        r,c=self.row_col(ind)
+        c+=1
+        if c==self.nc: c=0
+        if r==(self.nr-1) and c==(self.nc-1): c=0
+        return self.indx(r,c)
+
+    def dec_c(self,ind):
+        r,c=self.row_col(ind)
+        c-=1
+        if c<0: c=self.nc-1
+        if r==(self.nr-1) and c==(self.nc-1): c=self.nc-2
+        return self.indx(r,c)
+
+    def row_col(self,ind):
+        i=0
+        for r in range(self.nr):
+            for c in range(self.nc):
+                if i==ind: return r,c
+                i+=1
+
+    def indx(self,r,c):
+        return r*self.nc+c
+
+
+
diff --git a/setup.py b/setup.py
new file mode 100755
index 0000000..77fda74
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,4 @@
+#!/usr/bin/env python
+from sugar.activity import bundlebuilder
+if __name__ == "__main__":
+    bundlebuilder.start()
diff --git a/simon.py b/simon.py
new file mode 100755
index 0000000..4633ab4
--- /dev/null
+++ b/simon.py
@@ -0,0 +1,65 @@
+# simon.py
+import g,pygame,random,utils
+
+class Simon: # most methods only used by aim instance
+
+    def __init__(self,glow_time):
+        self.glow_time=glow_time; self.list1=[]
+        self.running=False; self.ind=0; self.started=False
+        self.glow_active=False
+        self.delay=1000 # between item displays - only used by aim instance
+    
+    def new1(self):
+        self.list1=[]; self.inc(); self.started=False
+
+    def do(self):
+        if self.glow_active:
+            d=pygame.time.get_ticks()-self.glow_ms
+            if d<0 or d>=self.glow_time:
+                self.glow_active=False; g.redraw=True
+        if self.running and not self.glow_active:
+            d=pygame.time.get_ticks()-self.ms
+            if d<0 or d>=self.delay: # time to display
+                g.redraw=True
+                self.glow_start(self.list1[self.ind]); self.ind+=1
+                self.ms=pygame.time.get_ticks()+self.glow_time
+                if self.ind==len(self.list1): self.running=False
+
+    def inc(self):
+        while True: # don't allow double at the start
+            r=random.randint(0,len(g.imgs)-1)
+            if self.list1==[]: break
+            if len(self.list1)>1: break
+            if r<>self.list1[0]: break
+        #if len(self.list1)>1: r=self.list1[0]+1 ###
+        self.list1.append(r)
+        self.play(); self.started=True
+        
+    def play(self): # delayed start
+        self.running=True; self.ind=0
+        self.ms=pygame.time.get_ticks()
+        
+    def start(self): # immediate start
+        self.running=True; self.ind=0
+        self.ms=pygame.time.get_ticks()-self.delay
+        
+    def glow(self,y=False):
+        if self.glow_active:
+            ind=self.glow_ind
+            cx=g.imgs[ind].cx; cy=g.imgs[ind].cy
+            img=g.glow[ind]
+            if y: img=g.glowy[ind]
+            utils.centre_blit(g.screen,img,(cx,cy))
+
+    def glow_start(self,ind):
+        self.glow_ms=pygame.time.get_ticks()
+        self.glow_active=True
+        self.glow_ind=ind
+
+    def glow_off(self):
+        self.glow_active=False
+
+
+
+    
+
diff --git a/slider.py b/slider.py
new file mode 100755
index 0000000..8968e6f
--- /dev/null
+++ b/slider.py
@@ -0,0 +1,55 @@
+# slider.py
+import utils,pygame,g,copy
+
+# sets g.level 1..steps
+class Slider:
+    def __init__(self,cx,cy,steps,colour=utils.BLACK):
+        self.easy=utils.load_image('slow.png',True)
+        self.hard=utils.load_image('fast.png',True)
+        self.xo=utils.load_image('xo.png',True)
+        iw=self.hard.get_width(); ih=self.hard.get_height()
+        w=g.sy(16); w2=w/2; h2=ih/2
+        self.x1=cx-w2; self.y=cy-h2; self.x2=cx+w2-iw
+        x=cx-w2+iw*1.2; w=w-2*iw*1.2; h=g.sy(.12);y=cy+g.sy(.34)
+        self.rect=pygame.Rect(x,y,w,h)
+        mh=g.sy(1);self.mark=pygame.Rect(x,y-mh/2+h/2,h,mh)
+        self.steps=steps; self.dx=w/(steps-1);self.colour=colour
+        self.cx=cx; self.cy=cy
+        marks=[]; x=self.rect.left; click_rects=[]; dx=self.dx
+        for i in range(self.steps):
+            rect=copy.copy(self.mark); rect.left=x-5; rect.width=10; marks.append(rect)
+            click_rect=pygame.Rect(x-dx/2,self.mark.top,dx,self.mark.h)
+            click_rects.append(click_rect)
+            x+=dx
+        self.marks=marks; self.click_rects=click_rects
+
+    def draw(self):
+        g.screen.blit(self.easy,(self.x1,self.y));
+        g.screen.blit(self.hard,(self.x2,self.y))
+        pygame.draw.rect(g.screen,self.colour,self.rect) # horizontal line
+        x=self.rect.left # now draw marks
+        for i in range(self.steps):
+            self.mark.left=x; pygame.draw.rect(g.screen,self.colour,self.mark)
+            if i==(g.level-1):
+                dx=self.xo.get_width()/2; dy=self.xo.get_height()/2
+                g.screen.blit(self.xo,(x-dx+self.mark.w/2,self.cy-dy))
+            x+=self.dx
+
+    def mouse(self):
+        mx,my=g.pos
+        rect=self.easy.get_rect(topleft=(self.x1,self.y))
+        if rect.collidepoint(mx,my):
+            if g.level>1: g.level-=1; return True#****
+        rect=self.hard.get_rect(topleft=(self.x2,self.y))
+        if rect.collidepoint(mx,my):
+            if g.level<self.steps: g.level+=1; return True#****
+        n=1
+        for rect in self.click_rects:
+            if rect.collidepoint(mx,my):
+                if g.level==n:
+                    return False#****
+                else:
+                    g.level=n; return True#****
+            n+=1
+        return False
+    
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..9cbef63
--- /dev/null
+++ b/sugargame/canvas.py
@@ -0,0 +1,62 @@
+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.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.window.set_cursor(None) = no "phantom" cursor
+
+        # 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..4cc3be8
--- /dev/null
+++ b/sugargame/event.py
@@ -0,0 +1,243 @@
+import gtk
+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(
+            gtk.gdk.KEY_PRESS_MASK | \
+            gtk.gdk.KEY_RELEASE_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._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)
+        
+        # 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 _expose_cb(self, event, widget):
+        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 = 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
diff --git a/utils.py b/utils.py
new file mode 100755
index 0000000..969d66d
--- /dev/null
+++ b/utils.py
@@ -0,0 +1,189 @@
+# utils.py
+import g,pygame,sys,os,random,copy,load_save
+
+#constants
+RED,BLUE,GREEN,BLACK,WHITE=(255,0,0),(0,0,255),(0,255,0),(0,0,0),(255,255,255)
+CYAN,ORANGE,CREAM,YELLOW=(0,255,255),(255,165,0),(255,255,192),(255,255,0)
+
+def exit():
+    save()
+    pygame.display.quit()
+    pygame.quit()
+    sys.exit()
+
+def save():
+    dir=''
+    dir=os.environ.get('SUGAR_ACTIVITY_ROOT')
+    if dir==None: dir=''
+    fname=os.path.join(dir,'data','follow.dat')
+    f=open(fname, 'w')
+    load_save.save(f)
+    f.close
+    
+def load():
+    dir=''
+    dir=os.environ.get('SUGAR_ACTIVITY_ROOT')
+    if dir==None: dir=''
+    fname=os.path.join(dir,'data','follow.dat')
+    try:
+        f=open(fname, 'r')
+    except:
+        return None #****
+    try:
+        load_save.load(f)
+    except:
+        pass
+    f.close
+    
+def version_display():
+    g.message=g.app+' '+g.ver
+    g.message+='  '+str(g.screen.get_width())+' x '+str(g.screen.get_height())
+    message(g.screen,g.font1,g.message)
+    
+# loads an image (eg pic.png) from the data subdirectory
+# converts it for optimum display
+# resizes it using the image scaling factor, g.imgf
+#   so it is the right size for the current screen resolution
+#   all images are designed for 1200x900
+def load_image(file1,alpha=False,subdir=''): # eg subdir='glow'
+    data='data'
+    if subdir!='': data=os.path.join('data',subdir)
+    fname=os.path.join(data,file1)
+    try:
+        img=pygame.image.load(fname)
+    except:
+        print "Peter says: Can't find "+fname; exit()
+    if alpha:
+        img=img.convert_alpha()
+    else:
+        img=img.convert()
+    if abs(g.imgf-1.0)>.1: # only scale if factor <> 1
+        w=img.get_width(); h=img.get_height()
+        try:
+            img=pygame.transform.smoothscale(img,(int(g.imgf*w),int(g.imgf*h)))
+        except:
+            img=pygame.transform.scale(img,(int(g.imgf*w),int(g.imgf*h)))
+    return img
+               
+# eg new_list=copy_list(old_list)
+def copy_list(l):
+    new_list=[];new_list.extend(l)
+    return new_list
+
+def shuffle(lst):        
+    l1=lst; lt=[]
+    for i in range(len(lst)):
+        ln=len(l1); r=random.randint(0,ln-1);
+        lt.append(lst[r]); l1.remove(lst[r])
+    return lt
+
+def centre_blit(screen,img,(cx,cy),angle=0): # rotation is clockwise
+    img1=img
+    if angle!=0: img1=pygame.transform.rotate(img,-angle)
+    rect=img1.get_rect()
+    screen.blit(img1,(cx-rect.width/2,cy-rect.height/2))
+
+def text_blit(screen,s,font,(cx,cy),(r,g,b)):
+    text=font.render(s,True,(0,0,0))
+    rect=text.get_rect(); rect.centerx=cx+2; rect.centery=cy+2
+    screen.blit(text,rect)
+    text=font.render(s,True,(r,g,b))
+    rect=text.get_rect(); rect.centerx=cx; rect.centery=cy
+    screen.blit(text,rect)
+    return rect
+
+def text_blit1(screen,s,font,(x,y),(r,g,b)):
+    text=font.render(s,True,(r,g,b))
+    rect=text.get_rect(); rect.x=x; rect.y=y
+    screen.blit(text,rect)
+
+# m is the message
+# d is the # of pixels in the border around the text
+# (cx,cy) = co-ords centre - (0,0) means use screen centre
+def message(screen,font,m,(cx,cy)=(0,0),d=20):
+    if m!='':
+        if pygame.font:
+            text=font.render(m,True,(255,255,255))
+            shadow=font.render(m,True,(0,0,0))
+            rect=text.get_rect()
+            if cx==0: cx=screen.get_width()/2
+            if cy==0: cy=screen.get_height()/2
+            rect.centerx=cx;rect.centery=cy
+            bgd=pygame.Surface((rect.width+2*d,rect.height+2*d))
+            bgd.fill((0,255,255))
+            bgd.set_alpha(128)
+            screen.blit(bgd,(rect.left-d,rect.top-d))
+            screen.blit(shadow,(rect.x+2,rect.y+2,rect.width,rect.height))
+            screen.blit(text,rect)
+
+def mouse_on_img(img,(x,y)): # x,y=top left
+    w=img.get_width()
+    h=img.get_height()
+    mx,my=g.pos
+    if mx<x: return False
+    if mx>(x+w): return False
+    if my<y: return False
+    if my>(y+h): return False
+    try: # in case out of range
+        col=img.get_at((int(mx-x),int(my-y)))
+    except:
+        return False
+    if col[3]<10: return False
+    return True
+
+def mouse_on_img1(img,(cx,cy)):
+    xy=centre_to_top_left(img,(cx,cy))
+    return mouse_on_img(img,xy)
+            
+def mouse_on_img_rect(img,(cx,cy)):
+    w2=img.get_width()/2; h2=img.get_height()/2
+    x1=cx-w2; y1=cy-h2; x2=cx+w2; y2=cy+h2
+    return mouse_in(x1,y1,x2,y2)
+            
+def mouse_in(x1,y1,x2,y2):
+    mx,my=g.pos
+    if x1>mx: return False
+    if x2<mx: return False
+    if y1>my: return False
+    if y2<my: return False
+    return True
+
+def mouse_in_rect(rect): # x,y,w,h
+    return mouse_in(rect[0],rect[1],rect[0]+rect[2],rect[1]+rect[3])
+
+def display_score():
+    if pygame.font:
+        text=g.font2.render(str(g.score),True,ORANGE,BLUE)
+        w=text.get_width(); h=text.get_height()
+        x=g.sx(5.7); y=g.sy(18.8); d=g.sy(.3)
+        pygame.draw.rect(g.screen,BLUE,(x-d-g.sy(.05),y-d,w+2*d,h+2*d))
+        g.screen.blit(text,(x,y))
+        centre_blit(g.screen,g.sparkle,(x-d+g.sy(.05),y+h/2-g.sy(.2)))
+
+def display_number(n,(cx,cy),font,colour=BLACK,bgd=None,outline_font=None):
+    if pygame.font:
+        if bgd==None:
+            text=font.render(str(n),True,colour)
+        else:
+            text=font.render(str(n),True,colour,bgd)
+        if outline_font<>None:
+            outline=outline_font.render(str(n),True,BLACK)
+            centre_blit(g.screen,outline,(cx,cy))
+        centre_blit(g.screen,text,(cx,cy))
+
+def display_number1(n,(x,cy),font,colour=BLACK):
+    if pygame.font:
+        text=font.render(str(n),True,colour)
+        y=cy-text.get_height()/2
+        g.screen.blit(text,(x,y))
+
+def top_left_to_centre(img,(x,y)):
+    cx=x+img.get_width()/2; cy=y+img.get_height()/2
+    return (cx,cy)
+
+def centre_to_top_left(img,(cx,cy)):
+    x=cx-img.get_width()/2; y=cy-img.get_height()/2
+    return (x,y)
+
+       
+
author	flavio <fdanesse@gmail.com>	2012-12-20 18:13:21 (GMT)
committer	flavio <fdanesse@gmail.com>	2012-12-20 18:13:21 (GMT)
commit	da77c8f245b5f186445352992cb6280503585985 (patch)
tree	9cdbb3ca0e9cb6aa6455b62a36b968d9b2ce5b00