Getting the Data

OpenStreetMap nodes are filled with useful meta information, one of them being the “smoking” tag which indicates whether smoking is allowed, not allowed or only allowed in a separated area. So first we have to get the data from somewhere. Because downloading the whole planet is a bit much, I downloaded only the Austria file (about 320 MB compressed / 4 GB uncompressed) from http://download.geofabrik.de/osm/europe/.

The raw file contains all available nodes, ways and relations and their meta data. As I am only interested in nodes containing the smoking tag, I somehow needed to filter the file to get a much smaller file containing only the necessary data. This can be done with the command line tool osmosis (install instructions). To make life easier I also used OSMembrane as a GUI on top of osmosis. The configuration I used was read-xml -> node-key filter -> write-xml:

The node-key filter was configured with “Task = node-key” and “keyList = smoking”, which results in all the nodes containing the tag “smoking”.

When you run this pipeline, the result is a 234kb osm file containing standard XML. A sample node from the file looks like this:

As you can see it contains a lot of useful data, e.g. name, address and other contact information of the facility. The most important data for our app are of course the geolocation (lat/lon) and the “smoking” tag.

What now?

The exported file can now be used in an iPhone app by parsing it with the NSXMLParser class, for example. The geolocation can be used to place pins on a MKMapView. Smoking restrictions of the facilities can be visualized using custom map annotations. Using the other meta data it is also possible to show detailed information about a facility (and make phone calls directly within the app). A simple app using this data could look like this:

Please contact me if you need further details or require source code.

Download Grain-Wallpaper.zip

What Game should I make?

It generates new game ideas by randomly choosing from genre, visual style and other parameters. You can also preselect each parameter, e.g. if you just want to make 8bit 2D games.
Feel free to use it, share it or do whatever you like with it!

In this post I will focus on how to develop a multi-touch enabled musical instrument app with low latency playback of audio samples.

Prerequisites

The app should be able to play about 50 different sound samples, at least 5 of them simultaneously. Playing a sound should be instant, so low latency is required.

Android Sound Libraries

Android offers three different sound APIs: MediaPlayer, SoundPool and AudioTrack. MediaPlayer is for playback of longer audio files and video, so this API is not suitable for our needs.

SoundPool’s documentation tells us that it should be used for repeated, simultaneous low-latency playback of multiple short sound samples. That’s exactly what we need! Unfortunately it turned out to be very laggy when playing. So the last resort was Android’s low level audio API AudioTrack.

Using AudioTrack

To play a sound with AudioTrack, the file has to be read into a buffer which is then pushed directly to the audio hardware. Playing multiple sounds simultaneously requires a thread for each sound.

Playing a Sound

To encapsulate audio playback, I created the AudioTrackSoundPlayer class:

The two members are a HashMap to store the threads of the currently playing sounds and a reference to the activity context which is needed later to create AudioTrack objects.

When playing a note a new thread is started and put into the map. Notes are only played if they are not already playing. Stopping a note (if the user releases the button) fetches the thread out of the map and requests it to stop.

To check if a note is already playing we simply have to look for the kay in the map.

Now to the fun part: the PlayThread class.

The class stores the note it plays, a stop flag which is set when the thread should be terminated (and thus stop playing the sound) and the AudioTrack instance used to play the sound.

First the file name is constructed by adding “.wav” to the note. Then the file size is read by opening the file with AssetManager. Next we create a 4096 byte buffer to store the audio data. Adapt the buffer size to your needs. 4096 seemed to work best for me. The AudioTrack object is then created with the appropriate configuration, depending on the sample files you use.

Next audio playback of the AudioTrack object is started. Now we have to continuously feed audio data to the object. In a standard WAVE file the raw audio data starts at offset 0x2C, so we skip the header. The outer while loop is used for looping the sound sample indefinitely. The inner while loop reads the actual audio data and feeds it to the AudioTrack object until the end of the file is reached. If the stop flag is set, the loop stops execution and the thread is terminated. The requestStop method sets the stop flag.

Conclusion

The AudioTrackSoundPlayer class gives us a very simple interface for usage in musical instrument apps. Simultaneous low-latency playback of sound samples using Android’s AudioTrack API can be done quite easily by spawning threads for each sample. I hope this saves you some of the trouble I went through while figuring out Android audio.

To further improve the class, additional configuration settings could be added as well as support for compressed file formats like mp3 or ogg. Currently only PCM data (WAV) can be played.

The complete project including the code used for multi-touch handling can be downloaded here: PianoTest.zip.

Adding a Space Ship

Download the zip file containing the image of a space ship and a bullet to shoot here. Extract the zip and add both files to the Resources group in your Xcode project.

Now add a new class derived from CCNode and name it “Ship”. Open Ship.m. Add an init method:

Open HelloWorldLayer.m. Remove the code which adds the “Hello World” label in the init-method. We don’t need that any more. Now add the following code at the end of init:

Build an run the project. You should now see the space ship on the screen.

Moving the Ship

We will implement ship movement using booleans to control the directions. Open Ship.h and modify it so that it looks like this:

In Ship.m add the @synthesize directives:

The actual movement will be handled in a Cocos2D standard update method:

VELOCITY is the amount of pixels per second the ship should move. The ship’s position is updated depending on which direction is currently active.

Register the ship object to be included in Cocos2D’s update calls by adding

to the init method. To clean up, also add a dealloc with the according unscheduleUpdate:

Open HelloWorldLayer.m and scroll down to the DDHidLib delegate methods. The ship can be controlled either with an analog stick or a d-pad, so we will implement movement behavior in the according delegate methods.

Analog:

d-pad:

Build and run. You should now be able to move the ship around using an analog stick or a d-pad.

Shooting

Open HelloWorldLayer.h and add a member variable:

The BOOL flag will determine if new bullets should be fired or not.
Open HelloWorldLayer.m and in the init method register the object to receive update: calls:

Unregister in dealloc:

Add a new method that shoots a bullet:

A new sprite is instantiated and added to the layer. A CCMoveBy action is used to animate the bullet until it is out of view. Then the removeBullet: method is called:

This method stops all active actions and removes the bullet from the layer.
Add the upadte: method which simply shoots bullets if the shoot flag is YES:

To set the values for the shoot flags we implement two DDHidLib delegate methods which handle button presses:

Build and run. Now you can move your ship AND shoot bullets!

You can download the complete Xcode project here: JoystickTest_Final.zip

After doing some research I found out that a joystick is a HID (Human Interface Device) and there is a crude, low level C API on the Mac to interface HIDs called IOHIDLib. Then I found out about Dave Dribin’s excellent DDHidLib library, an Objective-C wrapper around IOHIDLib. You can download it here: DDHidLib. In the first part of the tutorial I’ll show you how to integrate it in your Cocos2D project (I assume you use Xcode 4).

Building the Framework

1. Download and extract the source code of DDHidLib from the above link.
2. Open the DDHidLib Xcode project.
3. Select the DDHidLib scheme.
4. Edit the scheme so it uses the Release build configuration.
5. Build the framework. If you run into problems here make sure the Base SDK is set to “Latest Mac OS X” in the target’s build settings.
6. Locate the framework in Finder for later use.

Demo Project

Now I’ll take you through the process of integrating DDHidLib into a Cocos2D project.
Create a new project in Xcode using the template called “cocos2d_macosx” and name it “JoystickTest”. Build and run. This should just display a Hello World label. Now to the fun part.

Adding the Framework

1. Drag DDHidLib.framework into the Frameworks group of your demo project and make sure “Copy items” is checked. The framework will now be linked to the target.
2. Go to you project settings, select the JoystickTest target.
3. Select the “Build Phases” tab and add a new “Copy Files” phase.
4. Select destination “Frameworks” and also rename the phase to “Frameworks”.
5. Drag DDHidLib.framework from the project navigator into the build phase.
6. Build and run the project to see if everything works.

Intercepting Joystick Events

1. Open HelloWorldLayer.h and add a member variable:
   @interface HelloWorldLayer : CCLayer
   {
       NSArray *joysticks;
   }
2. Open HelloWorldLayer.m and add these pieces:
   #import <DDHidLib/DDHidLib.h>

   At the end of the init method add

   // allJoysticks returns an array of all connected joysticks
   joysticks = [[DDHidJoystick allJoysticks] retain];
   
   // we want to be the delegate of the joysticks
   [joysticks makeObjectsPerformSelector:@selector(setDelegate:) withObject:self];
   
   // start listening to all joystick events
   [joysticks makeObjectsPerformSelector:@selector(startListening) withObject:nil];
3. Now we can receive delegate methods which are called when the user interacts with the joystick.
   Add the following code at the end of the file. Use these delegate methods to set states or trigger actions in your game logic. The methods are pretty self explanatory.
   #pragma mark - Joystick stuff
   
   - (void)ddhidJoystick:(DDHidJoystick *)joystick buttonDown:(unsigned)buttonNumber
   {
       // this method would be a good place to start shooting bullets
       NSLog(@"button down: %d", buttonNumber);
   }
   
   - (void)ddhidJoystick:(DDHidJoystick *)joystick buttonUp:(unsigned)buttonNumber
   {
       // this method would be a good place to stop shooting bullets
       NSLog(@"button up: %d", buttonNumber);
   }
   
   
   #define THRESHOLD   2<<13   // this threshold defines the dead zone of analog sticks
   
   - (void)ddhidJoystick:(DDHidJoystick *)joystick
                   stick:(unsigned)stick
                xChanged:(int)value
   {
       // this method gets called when an analog stick is moved on the x axis.
      
       if(value < -THRESHOLD)
           NSLog(@"stick left");
       else if(value > THRESHOLD)
           NSLog(@"stick right");
       else
           NSLog(@"x axis neutral zone");
   }
   
   - (void)ddhidJoystick:(DDHidJoystick *)joystick
                   stick:(unsigned)stick
               yChanged:(int)value
   {
       // this method gets called when an analog stick is moved on the y axis.
      
       if(value < -THRESHOLD)
           NSLog(@"stick up");
       else if(value > THRESHOLD)
           NSLog(@"stick down");
       else
           NSLog(@"y axis neutral zone");
   }
   
   - (void)ddhidJoystick:(DDHidJoystick *)joystick
                   stick:(unsigned)stick
               otherAxis:(unsigned)otherAxis
            valueChanged:(int)value
   {
       NSLog(@"otherAxis: %u   value: %d", otherAxis, value);
   }
   
   - (void)ddhidJoystick:(DDHidJoystick *)joystick
                   stick:(unsigned)stick
               povNumber:(unsigned)povNumber
            valueChanged:(int)value
   {
       // This method gets called when d-pad buttons are pressed. The value is direction in degrees * 100
      
       switch (value)
       {
           case -1:
               text = @"d-pad none";
               break;
              
           case 0:
               text = @"d-pad N";
               break;
          
           case 4500:
               text = @"d-pad NE";
               break;
              
           case 9000:
               text = @"d-pad E";
               break;
   
           case 13500:
               text = @"d-pad SE";
               break;
   
           case 18000:
               text = @"d-pad S";
               break;
   
           case 22500:
               text = @"d-pad SW";
               break;
   
           case 27000:
               text = @"d-pad W";
               break;
              
           case 31500:
               text = @"d-pad NW";
               break;
              
           default:
               break;
       }
   }
4. Connect a joystick or pad to your Mac and try it out!

You can download the finished Xcode project here: JoystickTest.zip

• Navigation Bar
• Tab Bar
• Content

The navigation bar has a custom background image and a fixed title with custom font. The tab bar should be directly under the navigation bar and has complete custom styling.

Basic Setup

To start off I created a new Xcode project and added a UITabBarController with three static views. Although I have XIBs for each content view, I added everything else in code. Each view has a UINavigationController so it can easily contain its own navigation stack.

Navigation Bar

An easy technique to get a custom background in a UINavigationBar is to make a cateogory. Add this code (e.g. in YourAppDelegate.m):

To get the fixed title with custom font I added a method that creates a UILabel:

Tab Bar

A little bit of frame hackery was necessary to get the tab bar right beneath the navigation bar:

To have a custom layout for the tab bar, it is necessary to subclass UITabBarController. We don’t need UIKit’s tab bar at all, so we just hide it and create our own custom tabs:

First I added a UIImageView containing a background image:

Next we want to display a tab image to indicate which tab is active:

Finally I added three buttons to trigger tab selection:

Button creation method:

Note that the buttons’ action is _buttonClicked. There we need to set the currently selected tab index in the UITabBarController.

We also want to update the tab image’s position after a tab was selected. This is what _updateTabImage is for:

Now we have a fully functioning tab bar with custom layout. You can download the full Xcode project here: MyCustomTabBar_final.zip.

Gigster in the App Store: Jump

A new feature in Xcode 4 are “Behaviors” which can be configured in the preferences window. Basically you can tell Xcode what to do after certain events.

1. Open any project in Xcode 4.
2. Show the tab bar if it is not visible yet (View > Show Tab Bar)
3. Add a new tab by pressing CMD-T
4. Rename the new tab by double clicking its name. Call it “LOG” and drag it to the left in the tab bar.
5. Configure the tab to only show the information you need. I like to have all the available space for log output. Drag up the debug area all the way to the top. I also hide the utilities section on the right. Within the debug area I only have the console visible.
   
6. Open the preferences window and select “Behaviors”
7. Because we want the log to open when an application is run, select “Run starts”.
8. Click the checkbox “Show Tab” and enter “LOG” in the textbox.
   

That’s it! From now on whenever you run your project, Xcode automatically jumps to the LOG tab if it exists.

Finally, both our new apps are now available in the App Stores.

Gigster

Setlists at your fingertips
Create, play and share setlists for gigs and shows as a band, individual artist, manager or fan.

CREATE.
Enter your songs, along with relevant information such as tempo, key or your instrument’s settings. Create and save setlists of your songs for your tours and gigs.

PLAY.
Gigster’s live view is the perfect tool for your rehearsal sessions and live on stage – let it guide you through your setlist in a beautifully designed interface, providing you with important notes and settings for each song.

SHARE.
Tell the world about your band’s fabulous gig, or your friends about the great show you just attended, by sharing your setlist on Facebook.

iTunes Link

Savior

SAVE EARLY, SAVE OFTEN
Sometimes, even the most well-crafted applications crash. Let Savior auto-save all your opened documents and never lose unsaved changes again. Better to have saved than be sorry.

CONCISE
You can easily configure how Savior behaves. Set the autosave interval, select which applications are being taken into account and whether only the currently active document is being saved.

LEAN AND CLEAR
Savior is easy to use and provides relevant information at a glance. Use Growl notifications to keep informed about your documents’ status.

ACTIVELY DEVELOPED
Savior just works. Still, it is constantly being improved in order to extend compatibility with popular applications and introduce new, great features.

iTunes Link