NodeBeat is a generative music app for the iPhone and iPad in the style of apps like Bloom. In it, gently drifting nodes interact with pulsing triggers producing minimal soundscapes. It offers several options to tailor the parameters of the music generation. The overall experience is very soothing and meditative; background gradients  swirl through prismatic color changes.

Below is a mini-interview with the authors of the app, Seth Sandler and Justin Windle:

Justin:
I was reading a lot about sync at the time and was interested in experimenting with systems which could be free to form their own patterns, with the possibilities of spontaneous and unexpected ‘syncs’ emerging. Setting up rules to describe quite loosely coupled processes and then observing whether some kind of order emerges from them is something that I find fascinating. Aesthetically, I wanted the system I programmed to feel organic and so chose to work around the analogy of neurons and synapses firing – something talked about a lot in sync theory. These concepts concern themselves a lot with rhythm, repetition and cycles and so using audio seemed like a natural step, which is what gave rise to the idea of a sequencer of sorts. I had recently been introduced the Tonfall AS3 library, written by André Michelle and was keen to experiment with audio synthesis in Flash so I build the initial experiment on top of this as the library had a pretty small learning curve. The user interactions and the ability to tweak parameters at runtime, in order to produce different types of patterns; was something I added to give a layer of feedback to the experiment and push it more in the direction of an instrument that to an extent can be played rather than just observed.

Seth:
I’ve always been inspired by the simplicity of iOS applications like Bloom and how something simple can appeal to many and create a variety of musical interactions. When I saw Justin’s sequencer, I thought that it was a great example of something that was simple, yet created an interesting, visual and fun experience. Since, I typically focus on musical applications that aren’t targeted at musicians, I thought NodeBeat was a great fit.

Seth:
In terms of NodeBeat, the iOS implementation, the main goal is really just to provide a fun musical experience. While we had a variety of additional ideas to implement, we really wanted to keep the feature set simple and easy to understand on the first release. The hope is that anyone, musical or not, is able to experiment and create melodies and rhythms without having to learn anything or understand how notes, octaves, or rhythmic subdivisions work.

NodeBeat is developed using openFrameworks and utilizes PureData for audio synthesis. You can download the free desktop version + source code at NodeBeat.com.

Platform: iPhone/iPad
Version: 1.0
Cost: $0.99
Developer: AffinityBlue
(iPhone)
(Pad)

Created by Naoki Nishimura, Helvetica Face is a Livetype format font. This new Helvetica family font changes the “typeface” based on the posting of a new “face”. The site allows you to record your face within the font, adjusting the threshold resulting in a new glyph you can download.

While normal fonts which are governed by software rules on how to show the internal form (=data), Helvetica Face doesn’t have this internal information on the form. What is does have is external data given in the shape of a image of your face, and how to show that form is the only rule. For that reason, through the given data, the form continues to change without bounds.

Livetype is a new font format which takes a variety of data and can change the form of it in real time.

livetype.in/face/

From the makers of Computer Arts magazine, Visualator lets you create simple abstract imagery with your fingertips. Play with colour, shape and form to produce vibrant collages on the move.

The app has launched with two tools - Gradulate and Triangulate and the app is built entirely using Flash CS5.

Triangulate
Triangulate is a simple graphic image-creator that enables you to make geometric designs. You can control background colour, the colour of triangles created as well as patterns that fill either.

Gradulate
Gradulate is a live pen-based drawing system that uses simple physics to drive the pen’s motion, and adds a random element to the creation process. You can control colour, opacity, size of the brush as well as spring which generates springiness of your pen, and how much it bounces and spirals around the screen.

Visualator was created by Matt Booth and Stewart Hamilton-Arrandale. To find out more about it and how to make it for yourself, see the 32-page guide inComputer Arts Projects issue 144.

Platform: iPhone/iPad (Universal)
Version: 1.0
Cost: Free
Developer: Future plc

AV Clash is a Web-based project by Video Jack (André Carrilho and Nuno Correia, with Gokce Taskan) evolved AVOL – AudioVisual OnLine (2007), which allows the creation of audiovisual compositions, consisting of combinations of sound and audio-reactive animation loops. AV (AudioVisual) Clash is composed of 4 audiovisual “objects”, which enable playback and manipulation of four different loops of sound and audio-reactive visuals. Objects can be dragged and thrown, creating interactions (clashes) between them. The sounds in AV Clash are retrieved from Freesound.org, an online sound database. Users can change which 4 sound and animation loops are contained in each of the objects.

Have a play at avclash.com

(Thanks Nuno)

I have been following his work for some time now (10 years) but recently, at Flashbelt,  I had a pleasure of meeting Jared Tarbell and was deeply touched by his inquisitive nature. If you have seen Jared speak, or even better have met him, you’ll know exactly what I am talking about. His talk, beautifully executed, took us on a journey from the images of sun, recursion experiments to geodesic spheres and beautifully crafted laser-cut boxes. Some of this work was from a while ago, by no means new, nevertheless composed and contextualised into a perfect harmony. He talked about inspiration driven from nature, observing plants and different organisms inhabiting our planet, the way these patterns evolve, scale, the logic behind them and visual aesthetic they posses. His desire to “replicate” or “evolve” these, poeticising their nature,  results in an endless collection of experiments driven by his algorithms left me breathless. Some of these were created using Flash, others with Processing but regardless of tools used it is their prescribed evolution and aesthetic derived therein they all devise an ecology of beautifully developed and executed work.

He modestly writes:
I write computer programs to create graphic images.  With an algorithmic goal in mind, I manipulate the work by finely crafting the semantics of each program. Specific results are pursued, although occasionally surprising discoveries are made. I believe all code is dead unless executing within the computer. For this reason I distribute the source code of my programs in modifiable form. Modifications and extensions of these algorithms are encouraged.

Born in 1973 in the high altitude desert city of Albuquerque, New Mexico, Jared Tarbell was first introduced to personal computers in 1987. Working mostly with flash and generative art, in July 2005, Jared co-founded Etsy, an online marketplace to buy and sell handmade goods. Etsy has grown significantly since then and now has approximately 60 employees and sales of $10 to 13 million per month (wiki). Jared continues to work there today, building tools and visualizations for shoppers. Jared holds a Bachelor of Science degree in Computer Science from New Mexico State University and sits on the Board of the Austin Museum of Digital Art. When not engaged in programming, Jared nearly always tries to find himself outside, exploring the mysterious wilderness areas of New Mexico together with his wife Laurie where they moved to few years ago. He is not accepting any work at this time nor is any of his work available for purchase. I have been told getting hold of these can be somewhat tricky but his code is openly available for download (+). Jared does regularly give talks and my understanding is that Flash on the Beach in Brighton, UK is next. If you live in the UK, this is definitely worth a visit and rest assured I will be making my way down to say hello.

http://www.complexification.net
http://levitated.net
Jared’s Flickr

Jared’s publications:
New Masters of Flash 2004, APress ISBN forthcoming
Flash 3D Cheats Most Wanted, APress ISBN 1590592212 
The Hidden Power of Flash Components, Sybex ISBN 0782142109
Fresh Flash: New Design Ideas, Friends of ED ISBN 1903450993 
Flash Math Creativity, Friends of ED ISBN 1903450500

Here is one of Jared’s geodesic sphere’s assembled by Ralph Hauwert.

SoBe ReSkin in an installation created for SXSW Interactive this year, utilising Flash to provide the public with an opportunity to “Virtually reskin yourself, then fool your friends”.

Few words from Dofl Y.H. Yun, Lead Developer on the project:
This project has couple of special meaning to me. Fist of all, I moved to NYC to do interactive installation jobs and this is the first project here. FB proposed clients installation projects since I joined and finally Pepsi accepted our proposal. Secondly, I learned how our work with simple idea makes people happy and then they make me happy again while staying in Austin for 5 days of SXSW Interactive. You might understand what I mean after looking at photos I took.

Here is a list of what Dofl did to add tattoos realism.

- Matching the quality of tattoo to user photo. Because the kiosk used a built-in low quality camera and the condition of space wasn’t perfect to take best quality photos so the quality of tattoo was reduced to match quality of them dynamically.
- Multiply Blend mode. It is basically used to overlap a tattoo to skin.
- Tattoo Opacity.
- Contour to skin. This part would be the most great part. The displacement map filter which is a Flash built in feature is mainly used to add skinning tattoo realism. The kiosk application reads pixel values, especially red channel this time, from user photos in runtime and performs a displacement effect on tattoos. By controlling amount of distortion, a tattoo can be not only overlapped as flat as a pancake but also mapped to skin based on user photos .
- Redness Opacity and Thickness.
- Transforming. This allows user to move, rotate, skew and scale a tattoo.

Try the DEMO here.

AGENCY: Firstborn / CLIENT: SoBe / Date: March 2010 / Lead Developer: Dofl Y.H. Yun
Executive Producer : Crytinue Cho / Creative Director  : Dave Snyder

Dofl Y.H. Yun is a Senior Developer at Firstborn Multimedia, code artist and technical writer. More about Dofl can be found on his website.

In this tutorial, I’ll explain how to develop a very simple Defender-style game using the open-source Flixel 2 game library for Flash. Flixel was written by Adam Saltsman and extracted from a couple of his own Flash games, including Gravity Hook, Fathom and Canabalt. There is also an iPhone version lurking around the corner, which will make Flixel even more useful.

Flixel is an AS3-only framework which means that we don’t need Adobe Flash CS4 at all. No movieclips, no timeline, no library and no high price tag. Instead, we will do everything with pure code and bitmap spritesheets.

Game demo:

Setting up the project

Before we start, you need to setup your working environment so you can compile AS3-only projects into SWF files using the free Flex SDK. For this tutorial I have used Flex SDK 4.0. If you work on a Mac I recommend using TextMate for editing the source code. Have a look at this tutorial for how to set it up for AS3 projects. If you work on Windows FlashDevelop is a popular choice and completely free. The Flixel wiki has a good tutorial on how to setup FlashDevelop for Flixel.

Next, download version 2.32 of the Flixel library from GitHub. Since new versions of Flixel are frequently released version 2.32 might not be latest one, but we can be sure the tutorial will work with this version of Flixel.

Now let’s set up the basic project directory structure. Create a project folder that contains the TextMate or FlashDevelop project file, a folder for all graphic and sound assets, a folder for all source files with the Main.as file at the root and a bin folder for the compiled SWF. Move the org folder from the Flixel library into the src folder. Create the subfolders de/pixelate/flixelprimer for the actual source files of the game.

You can find the complete source code for this tutorial on GitHub including the graphic and sound assets we will use for the tutorial.

Main.as will be the entry point for our game. Whenever it runs, it will execute the code in this class first. Make sure that you point the compiler to the Main.as file. (See links to the tutorials above on how to do this in TextMate or FlashDevelop.) When using Flixel we make the Main class a subclass of FlxGame, which is the heart of every Flixel game. The Main class imports the ActionScript files we need, sets up the screen size to 640×480 and starts the game with the PlayState.

[sourcecode language="as3"]package {
import org.flixel.*;
import de.pixelate.flixelprimer.*;

[SWF(width="640", height="480", backgroundColor="#ABCC7D")]
[Frame(factoryClass="Preloader")]

public class Main extends FlxGame
{
public function Main():void
{
super(640, 480, PlayState, 1);
}
}
}[/sourcecode]

The main class also points to the Preloader class, which will show a nice 8-bit style preloader bar when loading the game in the browser. The class looks like this:

[sourcecode language="as3"]package
{
import org.flixel.FlxPreloader;

public class Preloader extends FlxPreloader
{
public function Preloader():void
{
className = "Main";
super();
}
}
}[/sourcecode]

A Flixel game usually consists of different states which subclass FlxState. A common usage would be to have a state for the menu screen, one for the actual game and one for the highscore screen. In our case we will only use one state to keep things simple. Let’s add the scaffold for the play state. The create function will be called once PlayState is created by the main class. The update function is the main loop of the game which will be called every frame.

[sourcecode language="as3"]package de.pixelate.flixelprimer
{
import org.flixel.*;

public class PlayState extends FlxState
{
override public function create():void
{
super.create();
}

override public function update():void
{
super.update();
}
}
}[/sourcecode]

Adding the player sprite and controls

Now that we have a good scaffold for the game, let’s add a space ship for the player. Create a new class in src/de/pixelate/flixelprimer called Ship.as:

[sourcecode language="as3"]package de.pixelate.flixelprimer
{
import org.flixel.*;

public class Ship extends FlxSprite
{
[Embed(source="../../../../assets/png/Ship.png")]
private var ImgShip:Class;

public function Ship():void
{
super(50, 50, ImgShip);
}

override public function update():void
{
velocity.x = 0;
velocity.y = 0;

if(FlxG.keys.LEFT)
{
velocity.x = -250;
}
else if(FlxG.keys.RIGHT)
{
velocity.x = 250;
}

if(FlxG.keys.UP)
{
velocity.y = -250;
}
else if(FlxG.keys.DOWN)
{
velocity.y = 250;
}

super.update();
}
}
}[/sourcecode]

FlxSprite is the main game object class in Flixel and handles basic physics and animation. The Ship class extends FlxSprite, draws the sprite at position x 50 and y 50 and sets the bitmap graphic for the ship which resides in the assets folder. The player controls are handled in the update function which is called by Flixel every frame. First the velocity is set back to zero. Then we check if the player is pressing the arrow keys and change the velocity accordingly. The super.update() call takes care of changing the position of the ship based on the current velocity.

Now we have to add the ship to the game stage. Add the following code to the create function in PlayState.as and declare _ship as a private variable above the function. We also set the background color of the game state to a nice monochrome green.

[sourcecode language="as3"]private var _ship: Ship;

override public function create():void
{
bgColor = 0xFFABCC7D;

_ship = new Ship();
add(_ship);

super.create();
}[/sourcecode]

Now compile the project and start the SWF in the Flash Player. Move the ship around with the arrow keys. The player input works well but the ship can move outside the screen. Let’s fix that. Add the following code into the update function in Ship.as where we make sure that the position of the ship is always within the screen dimensions. We also add a padding of 16 pixels to the if-condition to make it look nicer. Make sure to insert the code after the super.update() call.

[sourcecode language="as3"]if(x > FlxG.width-width-16)
{
x = FlxG.width-width-16;
}
else if(x < 16)
{
x = 16;
}

if(y > FlxG.height-height-16)
{
y = FlxG.height-height-16;
}
else if(y < 16)
{
y = 16;
}[/sourcecode]

Adding enemies

Next, let’s add some enemies. Create the file Alien.as inside src/de/pixelate/flixelprimer. The Alien class takes x and y as arguments in the constructor so we can easily position the sprite when creating it. We set the horizontal velocity to -200 which makes the alien move from right to left at a constant speed. In the update function we use a cosine function to move the alien up and down in a wave motion.

[sourcecode language="as3"]package de.pixelate.flixelprimer
{
import org.flixel.*;

public class Alien extends FlxSprite
{
[Embed(source="../../../../assets/png/Alien.png")]
private var ImgAlien:Class;

public function Alien(x: Number, y: Number):void
{
super(x, y, ImgAlien);
velocity.x = -200;
}

override public function update():void
{
velocity.y = Math.cos(x / 50) * 50;
super.update();
}
}
}[/sourcecode]

To spawn the aliens, we need to add some more code to the PlayState. First we add a FlxGroup for the alien sprites, a logical container which helps us to organize the collision detection between the player ship and aliens. Second we add a spawn timer which controls the interval when a new alien is spawned. The interval starts at 2.5 seconds and slowly becomes faster until it reaches it’s maximum of spawning a new alien every tenth second. Finally we add a function for spawning an alien at a random position at the right border of the screen.

[sourcecode language="as3"]package de.pixelate.flixelprimer
{
import org.flixel.*;

public class PlayState extends FlxState
{
private var _ship: Ship;
private var _aliens: FlxGroup;
private var _spawnTimer: Number;
private var _spawnInterval: Number = 2.5;

override public function create():void
{
bgColor = 0x0ABCC7D;

_ship = new Ship();
add(_ship);

_aliens = new FlxGroup();
add(_aliens);

resetSpawnTimer();

super.create();
}

override public function update():void
{
_spawnTimer -= FlxG.elapsed;

if(_spawnTimer < 0)
{
spawnAlien();
resetSpawnTimer();
}

super.update();
}

private function spawnAlien():void
{
var x: Number = FlxG.width;
var y: Number = Math.random() * (FlxG.height – 100) + 50;
_aliens.add(new Alien(x, y));
}

private function resetSpawnTimer():void
{
_spawnTimer = _spawnInterval;
_spawnInterval *= 0.95;
if(_spawnInterval < 0.1)
{
_spawnInterval = 0.1;
}
}
}
}[/sourcecode]

Adding bullets

Now let’s add bullets so the player can shoot to fight the aliens. Create a new class in src/de/pixelate/flixelprimer called Bullet.as. Nothing fancy here, except that we don’t use a bitmap graphic, but draw the bullet directly in the createGraphic() call.

[sourcecode language="as3"]package de.pixelate.flixelprimer
{
import org.flixel.*;

public class Bullet extends FlxSprite
{
public function Bullet(x: Number, y: Number):void
{
super(x, y);
createGraphic(16, 4, 0xFF597137);
velocity.x = 1000;
}
}
}[/sourcecode]

As with the aliens we add a FlxGroup for the bullets and a spawn function as well. In the update function we check if the player just pressed the space key and fire a bullet if that is the case.

[sourcecode language="as3"]package de.pixelate.flixelprimer
{
import org.flixel.*;

public class PlayState extends FlxState
{
private var _ship: Ship;
private var _aliens: FlxGroup;
private var _bullets: FlxGroup;
private var _spawnTimer: Number;
private var _spawnInterval: Number = 2.5;

override public function create():void
{
bgColor = 0x0ABCC7D;

_ship = new Ship();
add(_ship);

_aliens = new FlxGroup();
add(_aliens);

_bullets = new FlxGroup();
add(_bullets);

resetSpawnTimer();

super.create();
}

override public function update():void
{
if(FlxG.keys.justPressed("SPACE") && _ship.dead == false)
{
spawnBullet(_ship.getBulletSpawnPosition());
}

_spawnTimer -= FlxG.elapsed;

if(_spawnTimer < 0)
{
spawnAlien();
resetSpawnTimer();
}

super.update();
}

private function spawnBullet(p: FlxPoint):void
{
var bullet: Bullet = new Bullet(p.x, p.y);
_bullets.add(bullet);
}

// …
}
}[/sourcecode]

Note that we also added a new function to Ship.as to get the correct spawn position for the bullet from the player’s ship:

[sourcecode language="as3"]public function getBulletSpawnPosition():FlxPoint
{
var p: FlxPoint = new FlxPoint(x + 36, y + 12);
return p;
}[/sourcecode]

Adding collision detection

The only thing missing to make our game playable is collision detection. We handle the collision in the beginning of the update function of PlayState. The first call checks if any sprite in the aliens group overlaps with any bullet sprite and calls the overlapAlienBullet callback if so. The second call checks for collisions between the aliens and the ship sprite.

[sourcecode language="as3"]FlxU.overlap(_aliens, _bullets, overlapAlienBullet);
FlxU.overlap(_aliens, _ship, overlapAlienShip);[/sourcecode]

In the callback functions we define what happens in case of a collision. When an alien sprite gets hit by a bullet, we destroy both the alien and the bullet sprite, increase the score counter and display the updated score on the screen. When the ship gets hit by an alien we also let the screen rumble a bit using the quake function and display a game over message.

[sourcecode language="as3"]private function overlapAlienBullet(alien: Alien, bullet: Bullet):void
{
alien.kill();
bullet.kill();
FlxG.score += 1;
_scoreText.text = FlxG.score.toString();
}

private function overlapAlienShip(alien: Alien, ship: Ship):void
{
ship.kill();
alien.kill();
FlxG.quake.start(0.02);

_gameOverText = new FlxText(0, FlxG.height / 2, FlxG.width,
"GAME OVER\nPRESS ENTER TO PLAY AGAIN");
_gameOverText.setFormat(null, 16, 0xFF597137, "center");
add(_gameOverText);
}[/sourcecode]

We also need to initialize the text fields. Add a private variable declaration for the text fields in PlayState:

[sourcecode language="as3"]private var _scoreText: FlxText;
private var _gameOverText: FlxText;[/sourcecode]

To allow the player to restart the game on game over we add the following code to the update function in the PlayState:

[sourcecode language="as3"]if(FlxG.keys.ENTER && _ship.dead)
{
FlxG.state = new PlayState();
}[/sourcecode]

Create the score text field in the create function in PlayState and set the FlxG.score variable to zero.

[sourcecode language="as3"]FlxG.score = 0;
_scoreText = new FlxText(10, 8, 200, "0");
_scoreText.setFormat(null, 32, 0xFF597137, "left");
add(_scoreText);[/sourcecode]

Adding sounds

The game is fully playable now. Let’s add some sounds to give the player a better feedback of the action. Define all references to the sound files in the header of PlayState.

[sourcecode language="as3"]public class PlayState extends FlxState
{
[Embed(source="../../../../assets/mp3/ExplosionShip.mp3")]
private var SoundExplosionShip:Class;
[Embed(source="../../../../assets/mp3/ExplosionAlien.mp3")]
private var SoundExplosionAlien:Class;
[Embed(source="../../../../assets/mp3/Bullet.mp3")]
private var SoundBullet:Class;

// …
}[/sourcecode]

We call the FlxG.play function to play the sounds in the according situations.

[sourcecode language="as3"]// In spawnBullet()
FlxG.play(SoundBullet);

// In overlapAlienBullet()
FlxG.play(SoundExplosionAlien);

// In overlapAlienShip()
FlxG.play(SoundExplosionShip);[/sourcecode]

Adding explosions

Finally we add some particle explosions when the ship or an alien is destroyed using the FlxEmitter class. We want to use the same explosion for the ship and the aliens so we move the explosion code into a reusable function.

[sourcecode language="as3"]private function createEmitter():FlxEmitter
{
var emitter:FlxEmitter = new FlxEmitter();
emitter.delay = 1;
emitter.gravity = 0;
emitter.maxRotation = 0;
emitter.setXSpeed(-500, 500);
emitter.setYSpeed(-500, 500);
var particles: int = 10;
for(var i: int = 0; i < particles; i++)
{
var particle:FlxSprite = new FlxSprite();
particle.createGraphic(2, 2, 0xFF597137);
particle.exists = false;
emitter.add(particle);
}
emitter.start();
add(emitter);
return emitter;
}[/sourcecode]

In the collision callback functions we create the emitter for the explosion and place it at the position of the ship or alien using emitter.at().

[sourcecode language="as3"]// In overlapAlienBullet()
var emitter:FlxEmitter = createEmitter();
emitter.at(alien);

// In overlapAlienShip()
var emitter:FlxEmitter = createEmitter();
emitter.at(ship);[/sourcecode]

Now you have a simple game in Flixel that should help you getting started building your own ideas. If you have any questions, leave a comment or have a look at the Flixel forums and the wiki.

Digging in the Crates is an interactive installation by Roland Loesslein which attempts to explore Sampling as a production technology of modern music. Dynamic music data is navigated using modified turntables with information graphics helping understand the complex relationships that exist between the sample and composition.

Besides the history of sampling or technical backgrounds of the digitization of analog audio signals, visitors can also obtain information on the dissociation of sample-based productions and other musicological phenomena such as remixes, mashups or covers. As a highlight of the exhibition the visitor can slip into the role of a producer and goes on a fascinating search for suitable samples, which will be found on soul, funk and jazz records of the 70s and 80s.

Digging in the Crates aims to describe the sampling culture in all its aspects, characteristics, and influences. Not only the understanding of the creative process as a craft but also the effort and creative processes associated with sampling should be communicated authentically.

Visitors can choose from 50 old records of the 70s and 80s. All of these records contain one or more samples, which can be analyzed by placing the records on the turntable. A projection onto the record itself shows included samples as shaded areas. The old records can either be played or analyzed. To choose between these two modes, the on / off switch of the turntable is pressed. A modified turntable acts as an tangible interface to navigate and analyze each single sample on the placed record.

“Digging in the Crates” is a diploma thesis in the Department of Design at the University of Applied Sciences in Augsburg by developer and designer Roland Loesslein.

More of his work can be viewed online at http//www.weaintplastic.com

Digging in the Crates was created using Flash Actionscript3/Adobe Air.

Created by onyro, toneglue is a musical mapping web application to visually display relationships, by similarity of music artists. Navigate endless networks of relating artists by first searching for a single artists and expanding relationships. The data is pulled from Amazon and LastFM so some artists will include additional information such as about and releases.

Visit toneglue for more information.

(via Web.AppStorm)

Sometimes we come across little jewels in the AppStore and such is the work of BeInteractive!. Yoshihiro Shindo is behind this little collective and the collection of apps in the AppStore are little experiments but nonetheless very inspiring bundles of code. Three of these deserve a special mention:

Infinity Sheep plays with the idea of counting sheep as you are tying to go into sleep. You are presented with a hand drawn version of sheep which you can swipe across the screen to be greeted with exactly the same one. As you swipe the number goes up and you can hide by pulling up a blindfold at the bottom of the screen. You can count sheep automatically and very fast by tilting your iPhone to the right angle. Find more details here.
Price: $0.99

Net&Ball is a physics game where you knock back a ball by a net between fingers. If you put two fingers on the screen, a net will be woven between the fingers. Knocking the ball counts toward your score, so challenge the high score. As you score goes up so the bouncing ball goes higher beyond the edges of the screen making it more difficult to predict where it will fall.
Price: $0.99

KATAMARU? OR NOT (my favorite) is Katamari (Keita Takahashi) inspired tap to shoot a block into a ever spinning rock. Stick the block to get score and it is game over if the blocks go over the circular border. Created with Adobe Flash CS5!
Price: Free

See movies below of all three apps. If you have come across interesting developers in the AppStore, do give us a shout.