Using Android Accelerometer with Pygame

My son recently started to use the accelerometer functions in his Android phone to develop games with Python. He's building a variation of Swarm, a 2D tile map game that he wrote in middle school.

The accelerometer is easy to get working with pgs4a.

To pull the x,y,z axis, use this:

You will get a floating point number for each of the three axises.

Here's a simple way to set four directions, up, down, left, right:

In the example above, I'm holding the phone sideways, in landscape mode.  The left-right movement is controlled by the 2nd value in the list and the up-down movement is controlled by the 1st item in the list.

It would easy to set up 8 direction movement or even a greater range of movement.  Unlike Swarm, which used only 8 directions for bullets, we're using sin and cos to give the bullets a greater range of movement.

In order to test the application on my desktop, I've also created a virtual controller to simulate the accelerometer.

Here's the application running on my desktop with the virtual controller.

After you install the application on your Android phone, it is a bit more difficult to debug and test the accelerometer.   You can print out the value of the accelerometer and then tune your game so that the player moves with the sensitivity that works for your game. If you print out the accel_reading, you will see a three number tuple, with the numbers all in floating point.

I/python  (21058): Initialize Python for Android
I/python  (21058): ['/data/data/org.pychildren.accel/files/lib/python2.7/site-packages', '/data/data/org.pychildren.accel/files/lib/site-python']
I/python  (21058): Opening APK '/data/app/org.pychildren.accel-1.apk'
I/python  (21058): (-3.8019924163818359, -0.31603461503982544, 8.7819318771362305)
I/python  (21058): (-3.8019924163818359, -0.31603461503982544, 8.7819318771362305)
I/python  (21058): (-3.8019924163818359, -0.31603461503982544, 8.7819318771362305)

If you don't know how to see the output from your app when it is running on your phone, read my   post explaining how you can see the output of your print statements with adb.

Here's a demo of the character running on an old Samsung phone without the flock.   The controller in the lower right is for 360 degree bullet firing.

Pygame on Android - What to Do When Your Android App Dies Soon After Startup

You can use adb to get console error messages and print statement output from your pygame app on Android phones.  One of the most frustrating thing for beginners to pygame on Android is when the app runs fine on their desktop, but dies soon after startup on their Android phone.  Usually, you click on the app, the splash screen comes up, then the Android app silently dies.  Unless you're using adb, corrently you could be stuck.

With the usb cable connected between your phone and desktop, run 

adb logcat |grep python

Here's the output I got today.

I/python  (  580): 
Opening APK '/data/app/org.pychildren.surfsc-2.apk'I/python  (  580): 
Traceback (most recent call last):I/python  (  580):   
File "main.py", line 323, in <module>I/python  (  580):     
main()I/python  (  580):   
File "main.py", line 296, in mainI/python  (  580):     
pprint.pprint(weather.w_dict)I/python  (  580): 
NameError: global name 'pprint' is not definedI/python  (  580): 
Python for android ended.I/ActivityManager( 7163): Process org.pychildren.surfsc:python (pid 580) has died.

It is clear that there's a problem with the pprint.pprint statement that I was using to display the Python dictionary of weather data.  It even gives me the line number in my source code.  I simply commented out the line and the app started working again on my Android phone.

I've added basic weather information to my version.  My son's version has a cleaner interface and better colors.

Overview of Teaching Python to Graph Output from Cloud API - Spitcast Surf

I've been working with my son to build a mobile app that displays graphs of tide charts and tables of surf forecasts for the Santa Cruz region.  The app runs on his Android Motorola Moto-G phone and my Samsung Galaxy Note 2.  He grabs the data using the Spitcast API and displays the output using Pygame.

Surf Santa Cruz is available on GitHub.

The tide has a huge influence on the quality of surf in Eastside Santa Cruz.  The optimal tide conditions at my favorite spot is a tide that is rising from 2 feet to 3.5 feet.  The swell height and direction also plays a big role.  In the future, we'll use the API from OpenWeatherMap to pull the sunrise, sunset, and wind.

The steps are:

1. Pull data from Spitcast using urllib2
2. Read JSON data from API into program and then convert to a list of Python dictionaries using the json library

The lesson gets off to an exciting start. The student will realize the potential of accessing cloud-based APIs. Assuming the student has a basic understanding of Python data structures lists and dictionaries, they'll also understand how easy it is to parse the data. The simple idea to convert the tide values of feet into pixels is just to multiply feet by a constant number. In this case, I multiply the height of the wave in feet by 50 to get a pixel value. For example, a wave height of 5 feet will correspond to a screen height of 250 pixels. To generate the y coordinate for the Pygame screen, I subtract the pixel height from 550. Remember that a y value of 0 is the top of the screen. I set my screen height on the phone to 500 pixels. A wave height of 1 foot will equal screen height of 50 pixels. Subtracting this from 550 will yield a y position of 500.

1. Build start and end points for a series of 23 vertical lines spaced evenly apart to create the x axis grid. 
2.  Create a point list that will be used by pygame.draw.lines in a future section.

At this point, the student will have a list of points that they can then draw with pygame.draw.lines for the tide graph or pygame.draw.line x, y axis grids.
Here's the basic algorithms with a bit more bells and whistles.

In the main while loop, I have this code.
This is the android-presplash.jpg screen of the application.


In the future, we'll merge the features from my son's Weather App project into Santa Cruz Surf.

Below is a shot of the app developer benefiting from the application.

Windows 8.1 and Pygame Subset for Android (pgs4a)

I recently got asked a question about Windows installation on the PyChildren forum.

Here's the question:

When I touch the icon, the screen turns black, and then it goes back to my apps page in my phone. I then run the logcat to find the problem, but all it gives me is this:

V/python ( 676): Extracting private assets.
I/python ( 676): extracting private.mp3 to /data/data/com.bennybear.fungame/files

The user was not using an mp3 sound file.  When the person extracted the Windows compressed package for pgs4a, the file got added into a sub-directory of the build.    Since I was helping my son to install pgs4a on his Windows 8.1 computer, I was able to replicate the problem.   I think that the process of unzipping or extracting the pgs4a file partially failed.  When I compared the pgs4a files on two different Windows 8.1 computers, I noticed they were different.

I then went to the pgs4a site and downloaded a tar.bz2 archive.  I used tar jxvf on cygwin to extract the files.

A working directory is shown below.

Note that inside of the pgs4a-0.9.6 directory, there is not another sub-directory called pgs4a-0.9.6.  In the failed builds, I noticed that there was a temporary pgs4a-0.9.6 file created in the same directory and all the files from that directory were not properly copied into the main directory.

Once I had the files properly extracted, I noticed that the python android.py installsdk script was giving me error messages.  The script was failing to install android-api-15 and android-api-8.  I used the android.bat program in the android-sdk\tools directory to update the android SDK APIs.  

If you get an error message indicating that ant cannot find the build.xml file, this usually indicates that you don't have the proper Google APIs installed from the Android SDK (not the pgs4a android.py installsdk script).  In almost all cases, I've had to install the Google APIs with the android sdk.  On windows, the android sdk manager is called android.bat

There is another pgs4a tool called android.py.  These tools are completely unrelated.

Once I had those installed, the build went fine.  In order to connect the Windows 8.1 laptop to my son's Motorola Moto G Android phone, I had to go to the Motorola site and install the driver.  With driver from Motorola, adb was able to detect the phone and install went smoothly.

I also installed it on my Samsung Galaxy phone from his Windows 8.1 laptop.

This seems like a pain in the rear, but I encourage you to keep going.  Pygame is fun because it makes it easy to bring the creative ideas from your brain into reality very quickly.   By putting these ideas, your works of art, on a phone, you can show your friends and help them to understand a bit more about how you think as a person.

My long term goal for my children is for technology to serve as a tool for creative expression, not a barrier.  It should be fun and frivolous.  Games are great learning tools.  The work and lessons here should not be viewed through the lens of making money or job-training.  These experiments with children are about developing creative thinking and techniques to express ideas.  Sure, it's a pain to get pgs4a to install sometimes.  I agree.  But, I still think it's the best way to get kids and adults up to speed to be able to take their ideas and prototype them on a mobile phone.  

Have fun!

If you have questions or would like to join the discussion, go to the PyChildren Forum.

Installing Pygame Subset for Android on Windows 8.1

I documented an epic tale of installing pgs4a on Windows 8.1.

Although it took more time than I anticipated, I successfully installed a Pygame application from Windows 8.1 to my Samsung Galaxy Note 2.

 I previously wrote about Shems Eddine tutorial on pgs4a installation and always assumed that the process was easy on Windows.  Wow, now I realize that there are a few hurdles.  Although several people had asked me about pgs4a installation and configuration, I could never replicate these problems on Linux.

I was able to install a rudimentary version of Asteroids that my son and I are working on.  A big part of the lesson is using sine and cosine to rotate the ship in all 360 degrees.

I've also been encouraging him to move to PyCharm.

The screenshot below shows how to start android.bat from within the pgs4a\android-sdk\tools\ directory.

View of the Android-SDK package manager showing the API 17 packages installed.

• Early install of pgs4a on Linux

Python Android App Debugging Tip: adb and python print statements

With the phone connected to the USB cable and in debug mode, open a new terminal window and type:

  $ adb logcat |grep python

Update 10/11/2014. Windows users, see below. An alternative to using grep:

$ adb  logcat python *:s

You can now view standard python output from applications running on your android phone with python print statements. Output of logcat

I/python  ( 2392): play sounds
I/python  ( 2392): play sounds
I/python  ( 2392): play sounds

The most common problems with Python Subset for Android Apps dying on the Android phone at startup:

1. you didn't import the sound mixer module properly
2. your fonts are not in the main program directory
3. your sound files are not in the main program directory
4. your graphic files or map files are not in the main program directory
5. you are using a python module that is not in your main program directory

Note that there's a common theme here of a desktop program working because the assets exist somewhere on your desktop machine, but those assets don't get transferred to your phone.  Look at your sound, graphic, and font files to make sure they are in your main directory.

In the problems above, the adb logcat command will usually show you what asset the program fails to load.

You'll save time in the debugging process if you open up two terminals at once.  In one terminal, run the adb output.  In the other terminal, build and install your program onto your phone.  With the USB cable connected, run your application on your phone.

Check to make sure you are initializing the android library.

Make sure you are importing the mixer module as shown below. In previous versions of pgs4a, I had problems with audio files that weren't in *.wav format. I only use wav files now.

Another common problem is that your application is not named main.py.

Make sure you have called the application main.py and that you are building the application with the name of the directory that contains your application.

if you are using the sgc gui toolkit with android, you need to make sure that the fonts are loaded prior to setting up the sgc screen. I've had several occasions when I got the order wrong the my application worked on the desktop and crashed on the phone. This code below is only relevant if you use sgc, which is definitely not needed to make games on android. However, if you do use sgc to make your buttons and sliders, it can be a bit tricky to use on android.

Update: 10/11/2014 As my son is starting to do some development on Windows 8.1, I realized that he didn't have grep installed and didn't really need to go through the hassle of installing grep with cygwin. I looked at the filter options for adb logcat. The key is to set everything to silent except for strings containing python. Here's some docs built into adb that are somewhat difficult to understand. The only one that you need to use is the -s or *:s

Usage: logcat [options] [filterspecs]
options include:
  -s              Set default filter to silent.
                  Like specifying filterspec '*:s'
  -f    Log to file. Default to stdout
  -r []   Rotate log every kbytes. (16 if unspecified). Requires -f
  -n       Sets max number of rotated logs to , default 4
  -v      Sets the log print format, where  is one of:

                  brief process tag thread raw time threadtime long

  -c              clear (flush) the entire log and exit
  -d              dump the log and then exit (don't block)
  -t       print only the most recent  lines (implies -d)
  -g              get the size of the log's ring buffer and exit
  -b      Request alternate ring buffer, 'main', 'system', 'radio'
                  or 'events'. Multiple -b parameters are allowed and the
                  results are interleaved. The default is -b main -b system.
  -B              output the log in binary
filterspecs are a series of
  [:priority]

where  is a log component tag (or * for all) and priority is:
  V    Verbose
  D    Debug
  I    Info
  W    Warn
  E    Error
  F    Fatal
  S    Silent (supress all output)

'*' means '*:d' and  by itself means :v

If not specified on the commandline, filterspec is set from ANDROID_LOG_TAGS.
If no filterspec is found, filter defaults to '*:I'

If not specified with -v, format is set from ANDROID_PRINTF_LOG
or defaults to "brief"

Using the Android Keyboard with Pygame

I modified the GUI example I posted on GitHub yesterday to include an example of using the Android software keyboard  for text input.

I had to build my own text box input since I couldn't get it to work with SGC.   There's still a few glitches with the keyboard and I don't suggest you use the code in a production application, but it should be suitable for my son's next class.

I'm sure there's an easier way to handle the text from the keyboard and I would love to see another person's code.  However, since the whole purpose of my project is to teach my son programming, it should be useful to teach him to build a text input box with the Android keyboard. 

This only works with individual keys right now and it won't work with Swype.

On the pgs4a forum, there was some question as to whether or not the soft keyboard actually worked.  I thought I would create a quick example to show that it does work.

Best Python GUI for Pygame, pgs4a, Android Phones

Simple Game Code and Pygame

Three weeks ago, I wrote about testing PGU with Pygame.  After evaluating it yesterday, I gave up trying to get PGU to work on Android and moved to Sam Bull's Simple Game Code (SGC).  It may be possible, to get PGU to work, but I wasn't able to find anyone using it on Android when I searched through the pgs4a forums.

Sam Bull's code is nice and easy to use and I was able to get several nice menu widgets running on my test LG Optimus S Android phone within an hour.  There's extensive documentation the widgets drop right into a standard pygame code structure.

Radio buttons, switch, slider, and drop down

It's easy to connect the buttons to code to run things in your games.  For example, in the example above, the "Start" button will change the game level, which will run a different set of code.  The "Quit" button will exit the game.  The drop down menu and radio button work fine.

Easy to use text on Pygame surfaces

Running on LG Optimus S Android phone

I'll be doing additional experiments in the future.  In the meantime, I put my experiments for today up on GitHub.

If you end up using SGC on Android, I would be interested in hearing about it and seeing some code examples.

Everyone asks what the "best" library to use is.  It's going to be a matter of taste.  SGC on Android is the best for me and I thought I would share my opinion.   If you have a different opinion, I would like to learn about other GUI toolkits for Python/Android.

Update February 17, 2014
The blog Possibly Wrong has a description of getting PGU working with pgs4a.

I am having problems getting the software keyboard working with SGC InputBox.  I can't get the text to display properly inside of the text input box.  At this point, I'm still planning on using SGC unless I learn something more about PGU to make it worth digging into.

Phyiscal Maps and PGU GUI for Pygame

Classes are going slowly at the start of the year.  My son has been working on a program to manipulate a map of Palo Alto, based on the city's bicycle routes.  In the first class, he got the map to display, navigate, bounds checking, and jump to a specific location.  In the second class he started to build the menu for the touchscreen.

Since he's building basic widgets such as buttons on a regular basis, I looked at what type of pre-built widgets are out there.  The lead GUI toolkit for Pygame appears to be PGU.  I downloaded it, but did not develop any applications with it yet.

We blew through half the class last night trying to figure out how to get the background transparency working on a sprite sheet.  We finally got it working with Surface.subsurface(rect).  I should have realized this earlier since I wrote this blog post last month about slicing algorithms using subsurface.

PGS4A Installation Tutorial

Just saw this tutorial by Shems Eddine on getting PGS4A running.  Installing pgs4a is a common question.

Since I haven't had problems with the installation and I am running pgs4a primarily on Linux, I haven't been able to help with this problems.  Please see Shem Eddine's Journal for some great tips.  The tutorial is focused on Windows, which is great for all you Windows programmers out there.

If you're still stuck, there's the pgs4a forum.

Pygame on Android App Crashes on Start: FIXED

A good tileset in the wrong place at the wrong time

After catching Jack smelt in Capitola and seeing an amazing display of seals, dolphins, and school of tens of thousands of fish, my son worked on his 2D tile map game, Maze.  The Android app consistently crashed on start.  It would display the initial splash screen and then die, leaving no error message.

This has happened in the past with other games.  We usually solve the problem with adb, the Android debugger.  Today, the fix was easy.  However, since I know that it can be daunting to wade through the adb logcat, I'll provide a few tips specific to Python / Pygame Subset for Android debugging.

My son's game uses Python and pgs4a.  He also uses Tiled to export JSON map files. 

First, find adb on your system.  It's not something that python developers normally use from the command line.  adb is in the platform-tools sub-directory of the android-sdk main SDK directory.

  pgs4a/android-sdk/platform-tools$
 From the Linux command line, you can either just run adb logcat or you can run it through grep and look for references to python.

  platform-tools$ ./adb logcat *:D |grep python

 A larger snippet of the log file is shown below. I/ActivityManager( 1465): Start proc com.kaiyotesof.maze:python for activity com.kaiyotesof.maze/org.renpy.android.PythonActivity: pid=5088 uid=10062 gids={1015, 3003} I/python ( 5088): Private directory is /data/data/com.kaiyotesof.maze/files I/python ( 5088): Argument is /data/data/com.kaiyotesof.maze/files I/python ( 5088): Handing off to main. I/python ( 5088): /data/data/com.kaiyotesof.maze/files/main.py:1: RuntimeWarning: import cdrom: No module named cdrom I/python ( 5088): (ImportError: No module named cdrom) I/python ( 5088): 1600 I/python ( 5088): 1600 I/python ( 5088): Traceback (most recent call last): I/python ( 5088): File "start.pyx", line 52, in start (jni/../jni/application/src//start.c:1313) I/python ( 5088): File "KaiGames/Maze/main.py", line 55, in <module> I/python ( 5088): error: Couldn't open ../../../pgs4a/KaiGames/Maze/tilesets/grass_water_terrain.png I/ActivityManager( 1465): Process com.kaiyotesof.maze:python (pid 5088) has died.


 In this case, the error was an incorrect reference to the tileset graphic.
   I/python ( 5088): error: Couldn't open ../../../pgs4a/KaiGames/Maze/tilesets/grass_water_terrain.png I/ActivityManager( 1465): Process com.kaiyotesof.maze:python (pid 5088) has died.

The error is caused by a relative reference to a non-existent file.  Although the program works on the desktop, it doesn't work on the phone.  The fix is to place the tileset files in the same directory or sub-directory of your main.py program and create a new map and tileset with tiled.  If you've already created an extensive map, you can also edit the json file with a text editor to have it reference the correct location.

In this example, the file is called grass_water_terrain.png.

In a previous game, my son had a similar problem with the app crashing when it tried to load a font file that was in the wrong location.  Fonts and graphics are the two most common problems.  If you have all your fonts and graphic files in the same directory and your program still doesn't work on Android, but works on your desktop, you may be trying to import a library another directory.  Everything needs to be in the directory where main.py is or in a sub-directory.

If the application works on your desktop and it builds and then loads onto your phone fine, but crashes on start, think through what files the application is trying to load on the Android phone.  Then, work backwards and think through the differences between the phone directory structure and your desktop.  Also, think about the obvious things.  Check that you imported the android library and you've initialized it android.init().

If the problem is not immediately obvious, fire up adb and look for references to python.

Checklist:

• import android library
• initialize android library
• main game file is called, main.py
• graphic files are in the main or sub-directory
• font files are in the main or sub-directory
• custom libraries that you wrote are in the main or sub-directory

Update: March 3, 2014
One of the viewers of my pychildren YouTube channel had a problem with sound.  The important section is to map pygame.mixer and android.mixer to mixer.

try:    
    import pygame.mixer as mixer
except ImportError:    
    import android.mixer as mixer

The other problem with sound is that there may be problems with different types of sound formats.  I suggest you use .wav files.  Since sound is handled differently on Android and the desktop, a few problems occur.

Pygame Subset for Android Sprite Optimization with RenderUpdates

In order to get 2D map games written in python working faster on low-end Android phones, I experimented with optimizations. I purposely selected a complex background image in order to stress the application.

The first set of huge gains came from using the Surface.convert_alpha() method to optimize the images. This was easy and resulted in significant performance gains.

The trickier part was to update only the sections of the screen that had changed since the last cycle.

I decided to use sprites for this since many of the optimization examples I've seen use sprites.  Instead of using pygame.sprite.Group, I used pygame.sprite.RenderUpdates.  This is basically the same as the sprite group, but it as the enhanced ability to track the changed areas of the screen.

The images in the group are drawn to the screen with the standard sprite.Group.draw(SCREEN) method.  The cool little addition is the RenderUpdates.clear(SCREEN, background) method which clears the sprite by blitting a piece of the background over it.  Nice.

The final section is to update the display with a list of the rectangles, pygame.display.update(rectlist).

That's the main things to change.  I experimented with not ticking the pygame.time.Clock under android.   I'm not sure if it makes a difference, but the application appeared to me to run slower on android when I used the clock tick.

This is the first time that I've used this bit of code to pause the android device when the user hits things like the home button on the phone.

if android: if android.check_pause(): android.wait_for_resume()
I was pretty happy that my alpha transparency worked with the sprite group.
def __init__(self): pygame.sprite.Sprite.__init__(self) self.image = pygame.Surface((60, 60)) self.image.fill(GREEN) self.image.set_alpha(70)

I also experimented with different ways to optimize the events. However, I couldn't find anything useful.

Here's the full code.
__author__ = 'craig' import pygame, sys import random class Player(pygame.sprite.Sprite): def __init__(self): pygame.sprite.Sprite.__init__(self) self.image = pygame.image.load("ninja.png").convert_alpha() self.rect = pygame.Rect(226, 100, 32, 32) self.direction = "stop" self.mouse_press = False def update(self): if self.mouse_press: if self.direction == "right" and self.rect.centerx < 480: self.rect.centerx += 8 elif self.direction == "left" and self.rect.centerx > 0: self.rect.centerx -= 8 elif self.direction == "up" and self.rect.centery > 0: self.rect.centery -= 8 elif self.direction == "down" and self.rect.centery < 320: self.rect.centery += 8 class Control(pygame.sprite.Sprite): def __init__(self): pygame.sprite.Sprite.__init__(self) self.image = pygame.Surface((60, 60)) self.image.fill(GREEN) self.image.set_alpha(70) class Girl(pygame.sprite.Sprite): def __init__(self, x): pygame.sprite.Sprite.__init__(self) self.image = pygame.image.load("girl.png").convert_alpha() self.rect = pygame.Rect(x, 5, 32, 32) self.direction = "down" self.speed = random.randrange(1, 3) def update(self): if self.direction == "down": if self.rect.centery < 320: self.rect.centery += self.speed else: self.direction = "up" self.speed = random.randrange(1,3) elif self.direction == "up": if self.rect.centery > 0: self.rect.centery -= self.speed else: self.direction = "down" self.speed = random.randrange(1,3) try: import android except ImportError: android = None pygame.init() if android: android.init() android.map_key(android.KEYCODE_BACK, pygame.K_ESCAPE) SCREEN = pygame.display.set_mode((480, 320)) BLACK = (0, 0, 0) RED = (255, 0, 0) GREEN = (0, 255, 0) DARKGREEN = (0x0b, 0x61, 0x0b) clock = pygame.time.Clock() mouse_pos = (0,0) mouse_press = False control_left_rect = pygame.Rect(300, 170, 60, 60) control_right_rect = pygame.Rect(400, 170, 60, 60) control_up_rect = pygame.Rect(350, 100, 60, 60) control_down_rect = pygame.Rect(350, 240, 60, 60) control_list = [control_left_rect, control_right_rect, control_up_rect, control_down_rect] control_group = pygame.sprite.RenderUpdates() for control_rect in control_list: control = Control() control.rect = control_rect control_group.add(control) player = Player() player_group = pygame.sprite.RenderUpdates() player_group.add(player) girl_group = pygame.sprite.RenderUpdates() for x in range (80, 480, 80): girl = Girl(x) girl_group.add(girl) direction = "stop" background = pygame.image.load("background.png").convert_alpha() SCREEN.blit(background, (0,0)) pygame.display.update() pygame.event.set_allowed([pygame.KEYDOWN, pygame.MOUSEBUTTONDOWN, pygame.MOUSEBUTTONUP, pygame.QUIT, pygame.ACTIVEEVENT]) while True: if android: if android.check_pause(): android.wait_for_resume() for event in pygame.event.get(): #event = pygame.event.poll() if (event.type == pygame.QUIT) or (event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE): pygame.quit() sys.exit() elif event.type == pygame.MOUSEBUTTONDOWN: mouse_press = True elif event.type == pygame.MOUSEBUTTONUP: mouse_press = False mouse_pos = pygame.mouse.get_pos() control_group.clear(SCREEN, background) control_rect_list = control_group.draw(SCREEN) # SCREEN.blit(background, (0,0)) if mouse_press and control_left_rect.collidepoint(mouse_pos): pygame.draw.rect(SCREEN, DARKGREEN, control_left_rect) direction = "left" if mouse_press and control_right_rect.collidepoint(mouse_pos): pygame.draw.rect(SCREEN, DARKGREEN, control_right_rect) direction = "right" if mouse_press and control_up_rect.collidepoint(mouse_pos): pygame.draw.rect(SCREEN, DARKGREEN, control_up_rect) direction = "up" if mouse_press and control_down_rect.collidepoint(mouse_pos): pygame.draw.rect(SCREEN, DARKGREEN, control_down_rect) direction = "down" player.mouse_press = mouse_press player.direction = direction player_group.update() player_group.clear(SCREEN, background) rectlist = player_group.draw(SCREEN) girl_group.update() girl_group.clear(SCREEN, background) girl_rectlist = girl_group.draw(SCREEN) rectlist.extend(control_rect_list) rectlist.extend(girl_rectlist) pygame.event.pump() if not android: clock.tick(40) pygame.display.update(rectlist)

Paint Program with Pygame

My fourteen year old son did a nice job with his paint program. This took two or three lessons. He's making rapid progress now. He's quite busy with school and sports and doesn't have enough time to work on his programming. Despite the limited time he spends on programming, his cognitive skills are improving rapidly and he's able to build usable programs in a short amount of time. He was also able to incorporate feedback from his 8 year old sister. She designed the color palette and put a feature request for the stamps. I think she might have preferred flowers to the stamps.
This program uses Pygame and pgs4a.
Stay tuned for his next application, a JSON 2D map loader and maze game. import pygame, sys from pygame.locals import * try: import android except ImportError: android = None windowSurface = pygame.display.set_mode((480, 320)) ## Colors list GREEN = (0, 255, 0) GRAY = (197, 197, 197) BLACK = (0, 0, 0) RED = (255, 0, 0) BLUE = (0, 0, 255) DARK_GRAY = (107, 104, 99) PINK = (249, 57, 255) LIGHT_BLUE = (54, 207, 241) YELLOW = (255, 241, 73) ORANGE = (252, 155, 64) PURPLE = (167, 0, 238) DARK_GREEN = (58, 158, 73) WHITE = (255, 255, 255) BROWN = (85, 46, 46) PRETTY_BLUE = (0, 238, 195) ## fish = pygame.image.load("img/fish.jpg") shark = pygame.image.load("img/shark.jpg") eraser = pygame.image.load("img/eraser.png") fish_button_1 = pygame.transform.scale(fish, (40, 40)) fish_button_2 = pygame.transform.scale(shark, (40, 40)) fish_rect = pygame.Rect(5, 120, 40, 40) shark_rect = pygame.Rect(47, 120, 40, 40) stamp = "Fish" stamp_state = False pygame.init() ## font setup menu_font = pygame.font.Font("font/FreeSans.ttf", 17) menu_text = menu_font.render("Kai Paint", True, BLACK) clear_text = menu_font.render(" Clear", True, BLACK) brush_text = menu_font.render("Brushes", True, BLACK) save_text = menu_font.render(" SAVE", True, BLACK) draw = False brush_size = 5 brush_color = GREEN menu_rect = pygame.Rect(0, 0, 100, 320) screen_rect = pygame.Rect(100, 0, 380, 320) green_rect = pygame.Rect(5, 55, 20, 20) red_rect = pygame.Rect(27, 55, 20, 20) blue_rect = pygame.Rect(49, 55, 20, 20) pink_rect = pygame.Rect(71, 55, 20, 20) light_blue_rect = pygame.Rect(5, 77, 20, 20) yellow_rect = pygame.Rect(27, 77, 20, 20) orange_rect = pygame.Rect(49, 77, 20, 20) purple_rect = pygame.Rect(71, 77, 20, 20) dark_green_rect = pygame.Rect(5, 99, 20, 20) brown_rect = pygame.Rect(27, 99, 20, 20) white_rect = pygame.Rect(49, 99, 20, 20) pretty_blue_rect = pygame.Rect(71, 99, 20, 20) clear_rect = pygame.Rect(10, 290, 70, 25) eraser_rect = pygame.Rect(27, 210, 40, 40) thin_brush = pygame.Rect(5, 185, 20, 20) medium_brush = pygame.Rect(27, 185, 20, 20) thick_brush = pygame.Rect(49, 185, 20, 20) supa_brush = pygame.Rect(71, 185, 20, 20) save_rect = pygame.Rect(5, 260, 90, 25) save_flag = False file_number = 1 if android: android.init() android.map_key(android.KEYCODE_BACK, pygame.K_ESCAPE) while True: for event in pygame.event.get(): if event.type == QUIT: pygame.quit() sys.exit() if event.type == KEYDOWN: if event.key == K_ESCAPE: pygame.quit() sys.exit() if event.type == MOUSEBUTTONDOWN: draw = True if event.type == MOUSEBUTTONUP: draw = False # Drawing dot when mousebuttondown mouse_pos = pygame.mouse.get_pos() if draw == True and mouse_pos[0] > 100 and stamp_state == False: pygame.draw.circle(windowSurface, brush_color, mouse_pos, brush_size) save_flag = False ## Drawing stamp when mousebuttondown mouse_pos = pygame.mouse.get_pos() if draw == True and mouse_pos[0] > 100 and stamp == "Fish" and stamp_state == True: windowSurface.blit(fish_button_1, mouse_pos) draw = False save_flag = False mouse_pos = pygame.mouse.get_pos() if draw == True and mouse_pos[0] > 100 and stamp == "Shark" and stamp_state == True: windowSurface.blit(fish_button_2, mouse_pos) draw = False save_flag = False # collision detection for COLOR if draw == True: if green_rect.collidepoint(mouse_pos): brush_color = GREEN stamp_state = False if red_rect.collidepoint(mouse_pos): brush_color = RED stamp_state = False if blue_rect.collidepoint(mouse_pos): brush_color = BLUE stamp_state = False if pink_rect.collidepoint(mouse_pos): brush_color = PINK stamp_state = False if light_blue_rect.collidepoint(mouse_pos): brush_color = LIGHT_BLUE stamp_state = False if yellow_rect.collidepoint(mouse_pos): brush_color = YELLOW stamp_state = False if orange_rect.collidepoint(mouse_pos): brush_color = ORANGE stamp_state = False if purple_rect.collidepoint(mouse_pos): brush_color = PURPLE stamp_state = False if dark_green_rect.collidepoint(mouse_pos): brush_color = DARK_GREEN stamp_state = False if white_rect.collidepoint(mouse_pos): brush_color = WHITE stamp_state = False if brown_rect.collidepoint(mouse_pos): brush_color = BROWN stamp_state = False if pretty_blue_rect.collidepoint(mouse_pos): brush_color = PRETTY_BLUE stamp_state = False ## collision detection for eraser if draw == True: if eraser_rect.collidepoint(mouse_pos): brush_color = BLACK stamp_state = False ## collision detection for CLEAR if draw == True: if clear_rect.collidepoint(mouse_pos): pygame.draw.rect(windowSurface, BLACK, screen_rect) pygame.draw.rect(windowSurface, GRAY, menu_rect) windowSurface.blit(menu_text, (10, 20)) pygame.draw.line(windowSurface, BLACK, (0, 40), (100, 40)) pygame.draw.line(windowSurface, BLACK, (0, 45), (100, 45)) pygame.draw.rect(windowSurface, DARK_GRAY, clear_rect) windowSurface.blit(clear_text, (10, 290)) ## windowSurface.blit(brush_text, (10, 160)) pygame.draw.line(windowSurface, BLACK, (0, 180), (100, 180)) ## Blit the save rect pygame.draw.rect(windowSurface, DARK_GRAY, save_rect) windowSurface.blit(save_text, (13, 262)) ## Collision detection for SAVE if draw == True and save_flag == False: if save_rect.collidepoint(mouse_pos): print("File has been saved :P") save_surface = pygame.Surface((380, 320)) save_surface.blit(windowSurface, (0, 0), (100, 0, 380, 320)) try: with open("saved_files/PaintImage_" + str(file_number) + ".png"): print("file already exists") file_number = file_number + 1 save_flag = True except IOError: save_flag = True pygame.image.save(save_surface, "saved_files/PaintImage_" + str(file_number) + ".png") ## collision detectin for BRUSH SIZE if draw == True: if thin_brush.collidepoint(mouse_pos): brush_size = 1 if medium_brush.collidepoint(mouse_pos): brush_size = 3 if thick_brush.collidepoint(mouse_pos): brush_size = 5 if supa_brush.collidepoint(mouse_pos): brush_size = 10 ## collision detection for STAMP if draw == True: if fish_rect.collidepoint(mouse_pos): stamp = "Fish" stamp_state = True if shark_rect.collidepoint(mouse_pos): stamp = "Shark" stamp_state = True # rect for brush_color pygame.draw.rect(windowSurface, GREEN, green_rect) if brush_color == GREEN: border = 3 else: border = 1 pygame.draw.rect(windowSurface, BLACK, green_rect, border) pygame.draw.rect(windowSurface, RED, red_rect) if brush_color == RED: border = 3 else: border = 1 pygame.draw.rect(windowSurface, BLACK, red_rect, border) pygame.draw.rect(windowSurface, BLUE, blue_rect) if brush_color == BLUE: border = 3 else: border = 1 pygame.draw.rect(windowSurface, BLACK, blue_rect, border) pygame.draw.rect(windowSurface, PINK, pink_rect) if brush_color == PINK: border = 3 else: border = 1 pygame.draw.rect(windowSurface, BLACK, pink_rect, border) pygame.draw.rect(windowSurface, LIGHT_BLUE, light_blue_rect) if brush_color == LIGHT_BLUE: border = 3 else: border = 1 pygame.draw.rect(windowSurface, BLACK, light_blue_rect, border) pygame.draw.rect(windowSurface, YELLOW, yellow_rect) if brush_color == YELLOW: border = 3 else: border = 1 pygame.draw.rect(windowSurface, BLACK, yellow_rect, border) pygame.draw.rect(windowSurface, ORANGE, orange_rect) if brush_color == ORANGE: border = 3 else: border = 1 pygame.draw.rect(windowSurface, BLACK, orange_rect, border) pygame.draw.rect(windowSurface, ORANGE, orange_rect) if brush_color == ORANGE: border = 3 else: border = 1 pygame.draw.rect(windowSurface, BLACK, orange_rect, border) pygame.draw.rect(windowSurface, DARK_GREEN, dark_green_rect) if brush_color == DARK_GREEN: border = 3 else: border = 1 pygame.draw.rect(windowSurface, BLACK, dark_green_rect, border) pygame.draw.rect(windowSurface, PURPLE, purple_rect) if brush_color == PURPLE: border = 3 else: border = 1 pygame.draw.rect(windowSurface, BLACK, purple_rect, border) pygame.draw.rect(windowSurface, WHITE, white_rect) if brush_color == WHITE: border = 3 else: border = 1 pygame.draw.rect(windowSurface, BLACK, white_rect, border) pygame.draw.rect(windowSurface, BROWN, brown_rect) if brush_color == BROWN: border = 3 else: border = 1 pygame.draw.rect(windowSurface, BLACK, brown_rect, border) pygame.draw.rect(windowSurface, PRETTY_BLUE, pretty_blue_rect) if brush_color == PRETTY_BLUE: border = 3 else: border = 1 pygame.draw.rect(windowSurface, BLACK, pretty_blue_rect, border) #### RECT FOR ERASER windowSurface.blit(eraser, eraser_rect) if brush_color == BLACK: border = 3 else: border = 1 pygame.draw.rect(windowSurface, BLACK, eraser_rect, border) # Rect for brush size if brush_size == 1: brush_border = 3 else: brush_border = 1 pygame.draw.rect(windowSurface, BLACK, thin_brush, brush_border) pygame.draw.circle(windowSurface, BLACK, thin_brush.center, 1) pygame.draw.rect(windowSurface, BLACK, thin_brush, brush_border) if brush_size == 3: brush_border = 3 else: brush_border = 1 pygame.draw.rect(windowSurface, BLACK, medium_brush, brush_border) pygame.draw.circle(windowSurface, BLACK, medium_brush.center, 3) pygame.draw.rect(windowSurface, BLACK, medium_brush, brush_border) if brush_size == 5: brush_border = 3 else: brush_border = 1 pygame.draw.rect(windowSurface, BLACK, thick_brush, 1) pygame.draw.circle(windowSurface, BLACK, thick_brush.center, 5) pygame.draw.rect(windowSurface, BLACK, thick_brush, brush_border) if brush_size == 10: brush_border = 3 else: brush_border = 1 pygame.draw.rect(windowSurface, BLACK, supa_brush, brush_border) pygame.draw.circle(windowSurface, BLACK, supa_brush.center, 10) pygame.draw.rect(windowSurface, BLACK, supa_brush, brush_border) ## Blitting the stamp if stamp == "Fish": stamp_border = 3 else: stamp_border = 1 windowSurface.blit(fish_button_1, (5, 120)) pygame.draw.rect(windowSurface, BLACK, fish_rect, stamp_border) if stamp == "Shark": stamp_border = 3 else: stamp_border = 1 windowSurface.blit(fish_button_2, (47, 120)) pygame.draw.rect(windowSurface, BLACK, shark_rect, stamp_border) pygame.display.update()

Installing Pygame Subset for Android

I noticed that a new version of pgs4a came out.  I upgraded from 0.9.4 to 0.9.6 this morning.  The process went smoothly on my Ubuntu 12.04 LTS system.  I was up and running in 10 minutes and my programs ran with no problems.

Since the installation on Linux normally goes fine, I suspect that many of the problems people have with pgs4a is not due to the installation, but due to usage.

Here are three common problems I've heard about:

1) You're not specifying the directory of your application.  Many people will configure and build the name of the python file.  This is wrong.  You need to specify the name of the directory.

craig@ubuntu-desktop:~/Documents/python/android_development/pgs4a$ ./android.py build ../../pgs4a/dad/runner/ release

The location specified after build is the name of the directory, not the file.

2) You didn't name your main python file main.py.   You may have called the file something like runner.py or angryfish.py.  This is wrong.  The file needs to be called main.py.

3) You didn't initialize the android library in  your python code.

try: import android except ImportError: android = None pygame.init() if android: android.init() android.map_key(android.KEYCODE_BACK, pygame.K_ESCAPE)
Then, there are cases where everything should be working, but it's not. Assuming that you installed the android sdk with the command. $ ./android.py installsdk

 then your adb tool will be in android-sdk/platform-tools.

The most useful command will be ./adb help followed by ./adb logcat.   With your phone connected to your computer with a USB cable, running ./adb logcat will give you the logs from your phone.  By reading through the logs, you should be able to get some clues as to why your program is failing.

Lesson 6 - Putting it all together - Python tile game on Android

Middle school student teaches a lesson on getting a character to walk around a map.  The map was created with Tiled.  It is a single image saved in png format.  The character can now move in all four directions.

Lesson 5 - Going Mobile - Python on Android

Part one covers Python code modification.  Part two covers Android phone settings and configuration of Pygame Subset for Android.

Part 1

Technical points of part 1:

• import android library and handle exceptions
• map keyboard ESC key to Android back key (hard button) on phone
• quit game if phone back key is pressed

Part 2

Technical points of part 2:

• Set Android phone to debug mode
• Configure game build with pgs4a
• Build, package, install
• Test game

2D Android Tile Game "Swarm" is Finished

Disneyland, the winter flu, soccer, surfing, school and work, these are all normal family activities.  Learning to program in python often seems to fall down on the priority list, especially for my teenage son, who is often boiling over with energy.  He'd rather be out running, hiking, fishing, or playing a team sport.

My son blocked out some time today for python programming and he decided to complete development of Swarm after finishing the eighth level.  Each level now has a different map.  He also changed the game fonts to more stylistic fonts he downloaded from the Internet. The video above shows all eight levels of his game running on a SamSung Galaxy Note II.

The levels are created with python code only.  He decided not to use a map editor since the map size is small and manageable.

There is a story behind the game.  The blue boy goes through different areas of the world looking for a girl that is imprisoned in a haunted castle.  If the boy gets through eight levels, he saves the girl.  A hero screen appears with the boy and girl enjoying a sunrise.

The next game he's working on is a 2d side-scroller game.

The distribution file and source code for Swarm are here.

Pygame Performance on Android Phones

The performance of python games is fine on old, cheap Android phones.  My son has written several games for his cheap LG Optimus S phone with 170MB of memory.  Although the games are slower than on a desktop, there are no problems with the speed of simple games on the phone.

Getting Android adb working with Pipo Smart S1

The Pipo Smart S1 is a 7" Android 4.1 tablet that costs under $100.  It works great and is quite fast.   It's comparable to the Nexus 7" at half the price.  I changed the firmware to rev3 with instructions from TopNotchTablets.  This download also got rid of the apps that had Chinese language, giving a more comfortable user experience.

The CPU is a Rockwell RK3066 1.6GHz chip.

Rooting the tablet and upgrading the firmware was fast and painless.

Getting the tablet to work with the Android Debug Bridge (adb) was trickier.

Pygame Subset for Android (PGS4A) relies on adb that is included in the platform-tools sub-directory of the Android SDK.

android-sdk/platform-tools$ ls aapt aidl dexdump fastboot llvm-rs-cc renderscript adb api dx lib NOTICE.txt source.properties


When I first connected the Pipo Smart S1 tablet to my Ubuntu box with a micro USB cable, the build worked, but the install failed.

After figuring out how to use adb, I started to use adb devices to see the connected devices.  It wasn't detecting the tablet.


I found out that adb needs a USB Vendor ID to work properly.  Pipo wasn't listed as a vendor.   I found that the Vendor ID for the RK3066 chip is 0x2207.

Using the Android Developer documentation on Hardware Devices, I created the file /etc/udev/rules.d/51-android.rules and inserted this:


SUBSYSTEM=="usb", ATTR{idVendor}=="0x2207", MODE="0666", GROUP="plugdev"

It still wasn't working for me.  I had USB debugging enabled on my tablet.

I then added the vendor ID code to ~/.android/adb_usb.ini

:~/.android$ cat adb_usb.ini 

# ANDROID 3RD PARTY USB VENDOR ID LIST -- DO NOT EDIT.

# USE 'android update adb' TO GENERATE.

# 1 USB VENDOR ID PER LINE.

0x2207

It's still not happening.  I check out lsusb and see some hope that the device is detected.  

$ lsusb Bus 001 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub Bus 002 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub Bus 003 Device 001: ID 1d6b:0002 Linux Foundation 2.0 root hub Bus 004 Device 001: ID 1d6b:0003 Linux Foundation 3.0 root hub Bus 001 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub Bus 002 Device 002: ID 8087:0024 Intel Corp. Integrated Rate Matching Hub Bus 001 Device 003: ID 0409:005a NEC Corp. HighSpeed Hub Bus 001 Device 004: ID 06a3:8021 Saitek PLC Eclipse II Keyboard Bus 001 Device 005: ID 046d:c016 Logitech, Inc. Optical Wheel Mouse Bus 001 Device 006: ID 046d:c218 Logitech, Inc. Logitech RumblePad 2 USB Bus 001 Device 020: ID 2207:0010

I turn off wifi from the tablet.

I run adb devices again.


$ ./adb devices
List of devices attached 
???????????? no permissions

There's a bit more life.  I run it again as sudo.

$ sudo ./adb devices

[sudo] password for craig: 

List of devices attached 

???????????? no permissions

No go.

I kill the server. Then start it as root.

$ sudo ./adb devices

* daemon not running. starting it now on port 5037 *

* daemon started successfully *

List of devices attached 

ZX7U17M3NX device

It found the device!

I build the Python app:

$ ./android.py build dad/dad_image release install

install:

     [echo] Installing /home/c/Documents/python/pgs4a-0.9.4/bin/dad_image-1-release.apk onto default emulator or device...

     [exec] 5391 KB/s (2741472 bytes in 0.496s)

     [exec] pkg: /data/local/tmp/dad_image-1-release.apk

     [exec] Success

BUILD SUCCESSFUL

Total time: 8 seconds

It looks like the build succeeded.  

Here's a screenshot of the game running on the Pipo Smart S1, transferred using a USB cable with adb.

After I got this working, I worked with my son, my only computer programming student,  to get a similar game working on his LG Optimus S phone.  The main learning points today:

• using .append to fill a list of objects.   The list target_group contains all the enemies and all the bombs.
• Set up triggers based on elapsed time use list slicing to control the number of targets on the screen.

###statement to determine the levels current_target = target_group if clock.elapsed(1) < 35: current_target = current_target[:5] if clock.elapsed(1) < 27: current_target = current_target[:4] if clock.elapsed(1) < 19: current_target = current_target[:3] if clock.elapsed(1) < 11: current_target = current_target[:2] if clock.elapsed(1) < 5: current_target = current_target[:1] windowSurface.fill(game.color.BLACK) for targ in current_target:

---

After I wrote the blog post, I also found this  on slatedroid.com.  It covers many of the same steps.  I'm not sure if shutting off WiFi is needed.  The person below also seems to have adb working without having to run the adb server as root.  I may fiddle around with more things in the future.  The main thing is that I can connect my tablet to adb in debug mode and install the apk files easily.

Posted 21 November 2012 - 08:31 PM

Just a few tips to those are trying to connect to a RK3066 via ADB on linux.

• Download & Install SDK
• Edit udev rules (see step #3), the RK3066 Vendor ID is 2207
• Restart udev (udevadm control --reload-rules)
• Edit $HOME/.android/adb_usb.ini, add 0x2207 at the end of the file
• Restart adb server (adb kill-server && adb start-server)
• Plug & List your device (adb devices)

At step #2, you should get something like this

SUBSYSTEM=="usb", ATTR{idVendor}=="2207", MODE="0666", GROUP="plugdev"

At step #4, you should get something like this

# ANDROID 3RD PARTY USB VENDOR ID LIST -- DO NOT EDIT.
# USE 'android update adb' TO GENERATE.
# 1 USB VENDOR ID PER LINE.
0x2207