//////////////////////////////////////////////
// CLIENT SIDE CODE
//////////////////////////////////////////////
- (void)application:(UIApplication *)app didRegisterForRemoteNotificationsWithDeviceToken:(NSData *)devToken 
{
    NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
 
    // to make sure your device will be just registered once, we store
    // the state in userDefaults.
 
    if ( ![userDefaults boolForKey:@"DeviceTokenRegistered"] )  //if ( null, nil or "false" )
    {
        [userDefaults setBool:YES forKey:@"DeviceTokenRegistered"]; 
        NSLog(@"Device Token: %@", devToken); // log the device token as ascii
 
        // send it somehow to your server - apple says the best way is to
        // send it as bytes : ( assuming you wrote a "sendProviderDeviceToken" method )
        [self sendProviderDeviceToken: [devToken bytes]];
    }
}
 
- (void) applicationDidFinishLaunching:(UIApplication*)application
{
    /*
    UIRemoteNotificationTypeNone
    UIRemoteNotificationTypeBadge
    UIRemoteNotificationTypeSound
    UIRemoteNotificationTypeAlert 
    */
    [[UIApplication sharedApplication] registerForRemoteNotificationTypes:(UIRemoteNotificationTypeBadge | UIRemoteNotificationTypeSound | UIRemoteNotificationTypeAlert)]; 
}

$ctx = stream_context_create(); 
//////////////////////////////////////////////
// SERVER SIDE CODE
//////////////////////////////////////////////
 
// send our authentification file
stream_context_set_option($ctx, 'ssl', 'local_cert', 'apns-dev.pem'); 
 
// open a connection to the sandbox server
$apnsConnection = stream_socket_client('ssl://gateway.sandbox.push.apple.com:2195', $err, $errstr, 60, STREAM_CLIENT_CONNECT, $ctx); 
 
// creating the notification message (256 Byte max)
 
// your device token here
$deviceToken = 'e6636942 e1d5cf29 924628c3 115004af 1caba414 d4e52098 023fef08 07954d6a'; 
 
// your message goes here
$message = "Your push notification text goes here.";
 
// define a sound file if you want here
$sound = 'mySoundFile.caf'; //name of the sound file inside the XCode project.
 
// Construct the notification payload
$body = array();
$body['aps'] = array('alert' => $message);
$badge = (int)$argv[2]; // a number which will be displayed over the apps icon
if ($badge)
{
  $body['aps']['badge'] = $badge;
}
if ($sound)
{
  $body['aps']['sound'] = $sound;
}
$payload = json_encode($body);
 
// remove blanks and pack it.
$msg = chr(0) . pack("n",32) . pack('H*', str_replace(' ', '', $deviceToken)) . pack("n",strlen($payload)) . $payload;
 
// push the message through APNS
fwrite($apnsConnection, $msg); 
 
//close APNS connection
fclose($apnsConnection);

// assuming we are implementing an update routine 
// for an extended CCSprite class, lets say: CCSpriteExt.m
-(void) onUpdate:(ccTime) delta
{
	for (CCNode * you in children)
	{
		if ( you == self) continue;
 
		if ( [self isCollidingWithObject:you] ) 
		{
			// collision detected !
			[collisionDelegate performSelector:collisionSelector withObject:self withObject:you];
		}
	}
}

// assuming we are implementing an udate routine in a CCScene or CCLayer class
..
for (int idxMe=0; idxMe < [children_ count]; idxMe++ )
{
	CCNode * me = (CCNode *) [children_ objectAtIndex:idxMe];
	for (int idxYou=idxMe+1; idxYou < [children_ count]; idxYou++ )
	{		
		CCNode * you = (CCNode *) [children_ objectAtIndex:idxYou];
 
		if ( [self isCollidingObject:Me WithObject:you] ) 
		{
			// collision detected !
			[collisionDelegate performSelector:collisionSelector withObject:me withObject:you];
		}
	}
}

// assuming we are implementing an udate routine in a CCScene or CCLayer class
..
for (int idxMe=0; idxMe < [children_ count]; idxMe++ )
{
	CCNode * meNode = (CCNode*) [children_ objectAtIndex:idxMe];
 
	if ( ! [meNode isKindOfClass:[CCSpriteExt class]] )
	{
		continue;
	}
 
	CCSpriteExt * me = (CCSpriteExt *) meNode;
 
	for (int idxYou=idxMe+1; idxYou < [children_ count]; idxYou++ )
	{		
		CCNode * youNode = (CCNode*) [children_ objectAtIndex:idxYou];
		if ( ! [youNode isKindOfClass:[CCSpriteExt class]] )
		{
			continue;
		}
 
		CCSpriteExt * you = (CCSpriteExt *) youNode;
 
		if ( (me.collisionID == you.collisionID) && 
		    [self isCollidingObject:Me WithObject:you] )
		{
			// collision detected !
			[collisionDelegate performSelector:collisionSelector withObject:me withObject:you];
		}
	}
}

-(BOOL) isCollidingObject:(CCSpriteExt*)obj1 WithObject:(CCSpriteExt*) obj2
{
	if ( obj1.collisionID == obj1.collisionID )
	{
		if ( obj1.collisionBodyType != obj2.collisionBodyType) 
		{
			// not supported yet.
			return NO;
		}
		switch (obj1.collisionBodyType )
		{
			case BOUNDING_BOX : 
			return [self isCollidingBox:obj1 WithBox:obj2]; 
 
			case BOUNDING_SPHERE :
			return [self isCollidingBox:obj1 WithBox:obj2] && // first boxed test!
			[self isCollidingSphere:obj1 WithSphere:obj2];
 
			case POLYGON : 
			return [self isCollidingBox:obj1 WithBox:obj2] && // first boxed test!
			[self isCollidingPolygon:obj1 WithPolygon:obj2];
 
			case PIXEL : 
			return [self isCollidingBox:obj1 WithBox:obj2] && // first boxed test!
			[self isCollidingPixel:obj1 WithPixel:obj2];
 
			default:
			// not supported type
			break;
		}
	}
	return NO;
}

-(BOOL) isCollidingBox : (CCSpriteExt *) obj1 WithBox: (CCSpriteExt *) obj2 
{	
	float dx = fabs(obj2.position.x - obj1.position.x);
	float dy = fabs(obj2.position.y - obj1.position.y);	
 
	float dx1;
	float dx2;
 
	if (obj2.position.x > obj1.position.x) 
	{
		dx1 = (1-obj1.collisionSprite.anchorPoint.x) * obj1.collisionSprite.contentSize.width * obj1.collisionSprite.scaleX;
		dx2 = obj2.collisionSprite.anchorPoint.x * obj2.collisionSprite.contentSize.width * obj2.collisionSprite.scaleX;
	}
	else 
	{
		dx1 = (obj1.collisionSprite.anchorPoint.x) *  obj1.collisionSprite.contentSize.width * obj1.collisionSprite.scaleX;
		dx2 = (1-obj2.collisionSprite.anchorPoint.x) *obj2.collisionSprite.contentSize.width * obj2.collisionSprite.scaleX;
	}
 
	float dy1;
	float dy2;
 
	if (obj2.position.y < obj1.position.y) 
	{
		dy1 = obj1.collisionSprite.anchorPoint.y * obj1.collisionSprite.contentSize.height * obj1.collisionSprite.scaleY;
		dy2 = (1 - obj2.collisionSprite.anchorPoint.y) * obj2.collisionSprite.contentSize.height * you.collisionSprite.scaleY;
	}
	else 
	{
		dy1 = (1 - obj1.collisionSprite.anchorPoint.y) * obj1.collisionSprite.contentSize.height * obj1.collisionSprite.scaleY;
		dy2 = (obj2.collisionSprite.anchorPoint.y) * obj2.collisionSprite.contentSize.height * obj2.collisionSprite.scaleY;
	}
 
	return !((dx > (dx1+dx2)) || (dy > (dy1+dy2)));
}

-(BOOL) isCollidingBox : (CCSpriteExt *) obj1 WithBox: (CCSpriteExt *) obj2 
{
	return !CGRectIsNull( CGRectIntersection(obj1.boundingBox, obj2.boundingBox) );	
}

-(BOOL) isCollidingSphere:(CCSpriteExt*) obj1 WithSphere:(CCSprite *) obj2
{
	float minDistance = object.radius + self.radius;
	float dx = obj2.position.x - obj1.position.x;
	float dy = obj2.position.y - obj1.position.y;
	if (! (dx > minDistance || dy > minDistance) )
	{
		float actualDistance = sqrt( dx * dx + dy * dy );
		return (actualDistance < = minDistance);
	}
	return NO;
}

//
//  CCCollisionBody.h
//
 
/**
 * collision body types
 * @version 1.0
 */
#define COLLISIONBODYTYPE_NONE		0
#define COLLISIONBODYTYPE_POINT		1
#define COLLISIONBODYTYPE_LINE		2
#define COLLISIONBODYTYPE_SPHERE	3
#define COLLISIONBODYTYPE_RECT		4
#define COLLISIONBODYTYPE_POLY		5
#define COLLISIONBODYTYPE_PIXEL		6
 
@class CCNode; // pre decleration of CCNode, import will be in .m file
/** 
 * A class to define the collision body for a proxy game object.
 * collisionbodys are classified by types. Not all types are yet defined to collide with each other.
 * please use sphere and rect collisionbodys only to ensure proper functionallity
 */
@interface CCCollisionBody : NSObject 
{
	CCNode * proxy; // proxy object 
	uint type; // defines the collision body type (see above)
	CGSize size; // if used by the type : defines the dimensions of the collision body.
	float radius; // if used by the type : defines the radial dimensions of the collision body.
	BOOL disabled; // if true the collions are deactivated otherwise collisions with this body will be checked.
	int collisionGroupID; // collision group ID - only objects of the same group IDs will collide
}
@property (nonatomic, assign) int collisionGroupID;
@property (nonatomic, assign) bool disabled;
@property (nonatomic, retain) CCNode * proxy;
@property (nonatomic, assign) uint type;
@property (nonatomic, assign) CGSize size;
@property (nonatomic, assign) float radius;
 
/**
 * creates a spherical collision body specified by a given radius and a proxy game object.
 */
-(id) initAsSphereWithProxy:(CCNode*) proxyObject Radius: (float) sphereRadius;
 
/**
 * creates a rectangle collision body specified by a given size and a proxy game object.
 */
-(id) initAsRectWithProxy:(CCNode*) proxyObject Size:(CGSize) rectSize;
 
/**
 * returns if a collision body collides with another collision body.
 * v1.0 only supports sphereical and rectangle collisionbodys.
 */
-(bool) collidesWith:(CollisionBody*) object;
 
@end

//
//  CollisionBody.m
//
 
#import "CCCollisionBody.h"
#import "cocos2d.h"
 
#pragma mark -
#pragma mark CCCollisionBody Implementation
@implementation CCCollisionBody
@synthesize radius, size, type, proxy, disabled, collisionGroupID;
 
#pragma mark -
#pragma mark Initialisierung
 
#pragma mark  
#pragma mark COLLISIONBODYTYPE_NONE : no collision
 
-(id) initWithProxy:(CCNode*) proxyObject
{
	self = [super init];
	if (self)
	{
		self.type = COLLISIONBODYTYPE_NONE;
		self.proxy = proxyObject;
	}
	return self;
}
 
#pragma mark  
#pragma mark COLLISIONBODYTYPE_RECT : bounding box
-(id) initAsRectWithProxy:(CCNode*) proxyObject Size:(CGSize) rectSize
{
	if ([self initWithProxy:proxyObject])
	{
		self.size = rectSize;
		self.type = COLLISIONBODYTYPE_RECT;
	}
	return self;
}
 
#pragma mark  
#pragma mark COLLISIONBODYTYPE_SPHERE : bounding sphere
-(id) initAsSphereWithProxy:(CCNode*) proxyObject Radius: (float) sphereRadius;
{
	if ([self initWithProxy:proxyObject])
	{
		self.radius = sphereRadius;
		self.type = COLLISIONBODYTYPE_SPHERE;
	}
	return self;
}
 
#pragma mark -
#pragma mark cleanup
 
-(void) dealloc
{
	self.proxy = nil;
	[super dealloc];
}
 
#pragma mark -
#pragma mark collision tests
 
#pragma mark  
#pragma mark Rect-Rect collision 
-(bool) isRectRectIntersection:(CollisionBody*) object
{
	return !CGRectIsNull( CGRectIntersection(proxy.boundingBox, object.proxy.boundingBox) );	
}
 
#pragma mark  
#pragma mark Sphere-Sphere collision 
-(bool) isSphereSphereIntersection:(CollisionBody*) object
{
	float minDistance = object.radius + self.radius;
	float dx = object.proxy.position.x - self.proxy.position.x;
	float dy = object.proxy.position.y - self.proxy.position.y;
	if (! (dx > minDistance || dy > minDistance) )
	{
		float actualDistance = sqrt( dx * dx + dy * dy );
		return (actualDistance < = minDistance);
	}
	return false;
}
 
 
 
#pragma mark  
#pragma mark main collision detection
-(bool) collidesWith:(CollisionBody*) object
{
	if (!self.disabled && !object.disabled && self.collisionGroupID == object.collisionGroupID)
	{
		if (self.type == COLLISIONBODYTYPE_RECT && object.type == COLLISIONBODYTYPE_RECT)
		{
			return [self isRectRectIntersection:object];
		}
 
		if (self.type == COLLISIONBODYTYPE_SPHERE && object.type == COLLISIONBODYTYPE_SPHERE)
		{
			return [self isSphereSphereIntersection:object];
		}
 
		// NOT SUPPORTED COLLISION TYPE!
	}
 
	return NO;
}
 
@end

CCSpriteFrameCache * cache = [CCSpriteFrameCache sharedSpriteFrameCache];
[cache addSpriteFramesWithFile:@"blob.plist"];
 
CCAnimation * animation = [[CCAnimation alloc] initWithName:@"idle" delay:1/24.0];
for ( int i=1; i < 25; ++i )
{
	// frame name format: blob_idle_01.png .. blob_idle_24.png
	NSString * fname = [NSString stringWithFormat:@"blob_idle_%02i.png", i];
	[animation addFrame:[cache spriteFrameByName: fname]];
}
CCSprite * blob = [CCSprite spriteWithSpriteFrameName:@"blob_idle_01.png"];
// deprecated since 0.9: CCSprite * blob = [cache createSpriteWithFrameName:@"blob_idle_01.png"];
id action = [CCRepeatForever actionWithAction:[CCAnimate actionWithAnimation:animation]];
[blob runAction:action];
 
// position our blob
blob.position = ccp( 160, 240 );
 
// add blob to scene ( self should be a visible CCLayer or CCScene )
[self addChild:blob];

#import "MyScene.h"
@implementation MyScene
-(void) onButton1Pressed:(id) sender
{
	// TODO: something phenomenal 
}
 
-(void) onButton2Pressed:(id) sender
{
	// TODO: something even more phenomenal 
}
 
-(void) setupMenu
{
	CCMenuItemImage * button1 = [CCMenuItemImage itemFromNormalImage:@"b1_up.png" selectedImage:@"b1_down.png" target:self selector:@selector(onButton1Pressed:)];
 
	CCMenuItemImage * button2 = [CCMenuItemImage itemFromNormalImage:@"b2_up.png" selectedImage:@"b2_down.png" disabledImage:"b2_disabled.png" target:self selector:@selector(onButton2Pressed:)];
}

#import "MyScene.h"
@implementation MyScene
-(void) onButton1Pressed:(id) sender
{
	// TODO: something phenomenal 
}
 
-(void) onButton2Pressed:(id) sender
{
	// TODO: something even more phenomenal 
}
 
-(void) setupMenu
{
	CCMenuItemImage * button1 = [CCMenuItemImage itemFromNormalImage:@"b1_up.png" selectedImage:@"b1_down.png" target:self selector:@selector(onButton1Pressed:)];
 
	CCMenuItemImage * button2 = [CCMenuItemImage itemFromNormalImage:@"b2_up.png" selectedImage:@"b2_down.png" disabledImage:"b2_disabled.png" target:self selector:@selector(onButton2Pressed:)];
 
	CCMenu * menu = [CCMenue menueWithItems:button1 , button2, nil]; // you have to terminate the list with nil
 
	menu.position = ccp ( 160, 240 );
	[menu alignItemsHorizontallyWithPadding:10.0f];
	[self addChild: menu];
}

//
//  CCRadioMenu.h
//  Cocos2d Version used: 0.9.0 alpha
//  Created by Hans Hamm on 24.11.09.  
//
 
#import "cocos2d.h"
 
 
@interface CCRadioMenu : CCMenu {
	int selectedItemIndex; // will be the current targeted item 
	int fallBackItemIndex; // will be our fall back item (previously selected one)
}
 
@property int selectedItemIndex;
 
-(CCMenuItem *) itemForTouch: (UITouch *) touch; // will retrieve the current item for the touch
 
@end

//
//  CCRadioMenu.m
// 
//  Cocos2d Version used: 0.9.0 alpha
//  Created by Hans Hamm on 24.11.09.  
//
 
#import "CCRadioMenu.h"
 
@implementation CCRadioMenu
 
@synthesize selectedItemIndex;
 
/**
 * will be called if a touch started.
 */
-(BOOL) ccTouchBegan:(UITouch *)touch withEvent:(UIEvent *)event
{
	if( state != kMenuStateWaiting ) return NO; // do not track events if menu is busy
 
	selectedItem = [self itemForTouch:touch]; // any of our items was selected?
 
	if( selectedItem ) // if one of our items was selected
	{
		[selectedItem selected]; // make it be selected
		state = kMenuStateTrackingTouch; // mark menu as busy
		return YES; // say : "yes, we want more events from this touch"
	}
	return NO; // none of our items was selected, so we dont want to hear from this touch event anymore
}
 
/**
 * will be called if a touch event ended.
 */
-(void) ccTouchEnded:(UITouch *)touch withEvent:(UIEvent *)event
{
	NSAssert(state == kMenuStateTrackingTouch, @"[Menu ccTouchEnded] -- invalid state");
 
	for( CCMenuItem* item in children ) // unselect all items
	{
		[item unselected];	
	}
 
	if (selectedItem) // if we have selected an item:
	{
		[selectedItem selected]; // make it selected
		[selectedItem activate]; // an execute it
		fallBackItemIndex = selectedItemIndex; // the new fall back item is the current target
	}
	else // there is none selected
	{
		self.selectedItemIndex = fallBackItemIndex; // so just fall back to the old one
	}	
 
	state = kMenuStateWaiting; // we are not busy anymore
}
 
/**
 * will be called if a touch event was canceled. Normaly the user dont want
 * to execute the last selected one, so just fall back to the old one here.
 */
-(void) ccTouchCancelled:(UITouch *)touch withEvent:(UIEvent *)event
{
	NSAssert(state == kMenuStateTrackingTouch, @"[Menu ccTouchCancelled] -- invalid state");
 
	for( CCMenuItem* item in children ) // unselect all items
	{
		[item unselected];	
	}
	// on cancel just fall back to the old one :
	self.selectedItemIndex = fallBackItemIndex;
 
	// we are not busy anymore
	state = kMenuStateWaiting;
}
 
/**
 * will be called if a touch event moved.
 */
-(void) ccTouchMoved:(UITouch *)touch withEvent:(UIEvent *)event
{
	NSAssert(state == kMenuStateTrackingTouch, @"[Menu ccTouchMoved] -- invalid state");
 
	// still one of our items selected?
	CCMenuItem * currentItem = [self itemForTouch:touch]; 
 
	// if not, what was the fallback item again?
	CCMenuItem * fallBackItem = (CCMenuItem *) [children objectAtIndex:fallBackItemIndex];
 
	// if the new selected item changed and is not our fallback item
	if (currentItem != selectedItem && currentItem != fallBackItem)
	{				
		[selectedItem unselected]; // unselect the previous one
		selectedItem = currentItem; // this is our new targeted one ( could be nil ! ) 
 
		if (selectedItem) // if there is a new one ( touch could be outside the menu )
		{		
			[selectedItem selected]; // select this new one
		}
		else // there is no new one, so just fall back to the old one
		{
			[[children objectAtIndex:fallBackItemIndex]selected];
		}
 
	}
}
 
/**
 * Returns the first menu item hit by a touch event.
 * Also we could update the selectedItemIndex here.
 */
-(CCMenuItem *) itemForTouch: (UITouch *) touch
{
	CGPoint touchLocation = [touch locationInView: [touch view]]; // touch location
	touchLocation = [[CCDirector sharedDirector] convertToGL: touchLocation]; // in gl coordinates
	int idx = -1; // helper variable to determine the index of the item ( 0 = first item )
 
	for( CCMenuItem* item in children ) 
	{
		idx++; // in first step this would be zero ( 0 )
 
		// convert the touch to the local coordinates of the current item
		// and check if the location is inside the rect of it
 
		CGPoint local = [item convertToNodeSpace:touchLocation]; 		
		CGRect r = [item rect];  
		r.origin = CGPointZero;
 
		if( CGRectContainsPoint( r, local ) ) // if touch is inside it
		{
			selectedItemIndex = idx;  // save the itemIndex and..
			return item;	 // .. return the item
		}
	}
 
	// we found not item hit by that touch:
	return nil;
}
 
/**
 * returns the current selected Item Index.
 */
-(int) selectedItemIndex
{
	return selectedItemIndex;
}
 
/**
 *  sets the current Selected Item Index ( but does not activate it )
 */
- (void)setSelectedItemIndex:(int) value 
{
	for( CCMenuItem* item in children )  // unselect all
	{
		[item unselected];	
	}
 
	selectedItemIndex = value;	// store new index
	selectedItem = [children objectAtIndex:selectedItemIndex]; // get the item for that index	
	fallBackItemIndex = selectedItemIndex; // store as fallBackIndex, too.	
	[selectedItem selected]; // mark as selected.
}
 
@end

menu.selectedItemIndex = 0; // first Item should be initially selected

#import "MyScene.h"
#import "CCRadioMenu.h"
 
@implementation MyScene
-(void) onButton1Pressed:(id) sender
{
	// TODO: something phenomenal 
}
 
-(void) onButton2Pressed:(id) sender
{
	// TODO: something even more phenomenal 
}
 
-(void) setupMenu
{
	CCMenuItemImage * button1 = [CCMenuItemImage itemFromNormalImage:@"b1_up.png" selectedImage:@"b1_down.png" target:self selector:@selector(onButton1Pressed:)];
 
	CCMenuItemImage * button2 = [CCMenuItemImage itemFromNormalImage:@"b2_up.png" selectedImage:@"b2_down.png" disabledImage:"b2_disabled.png" target:self selector:@selector(onButton2Pressed:)];
 
	CCRadioMenu * menu = [CCRadioMenu menueWithItems:button1 , button2, nil]; // you have to terminate the list with nil
 
	menu.selectedItemIndex = 0; // first Item should be initially selected
 
	menu.position = ccp ( 160, 240 );
	[menu alignItemsHorizontallyWithPadding:10.0f];
	[self addChild: menu];
}

#import "CCRadioMenu.h"
 
@implementation CCRadioMenu
 
@synthesize selectedItemIndex;
 
-(BOOL) ccTouchBegan:(UITouch *)touch withEvent:(UIEvent *)event
{
	if( state != kMenuStateWaiting ) return NO;
 
	selectedItem = [self itemForTouch:touch];
 
	if( selectedItem ) 
	{
		[selectedItem selected];
		state = kMenuStateTrackingTouch;
		return YES;
	}
	return NO;
}
 
-(void) ccTouchEnded:(UITouch *)touch withEvent:(UIEvent *)event
{
	NSAssert(state == kMenuStateTrackingTouch, @"[Menu ccTouchEnded] -- invalid state");
 
	for( CCMenuItem* item in children_ ) 
	{
		[item unselected];	
	}
 
	if (selectedItem)
	{
		[selectedItem selected];
		[selectedItem activate];
		fallBackItemIndex = selectedItemIndex;
	}
	else
	{
		self.selectedItemIndex = fallBackItemIndex;
	}	
 
	state = kMenuStateWaiting;
}
 
-(void) ccTouchCancelled:(UITouch *)touch withEvent:(UIEvent *)event
{
	NSAssert(state == kMenuStateTrackingTouch, @"[Menu ccTouchCancelled] -- invalid state");
 
	for( CCMenuItem* item in children_ ) 
	{
		[item unselected];	
	}
 
	self.selectedItemIndex = fallBackItemIndex;
 
	state = kMenuStateWaiting;
}
 
-(void) ccTouchMoved:(UITouch *)touch withEvent:(UIEvent *)event
{
	NSAssert(state == kMenuStateTrackingTouch, @"[Menu ccTouchMoved] -- invalid state");
 
	CCMenuItem * currentItem = [self itemForTouch:touch];
	CCMenuItem * fallBackItem = (CCMenuItem *) [children_ objectAtIndex:fallBackItemIndex];
	if (currentItem != selectedItem && currentItem != fallBackItem) 
	{				
		[selectedItem unselected];
		selectedItem = currentItem;
 
		if (selectedItem)
		{		
			[selectedItem selected];
		}
		else
		{
			[[children_ objectAtIndex:fallBackItemIndex]selected];
		}
 
	}
}
 
-(CCMenuItem *) itemForTouch: (UITouch *) touch
{
	CGPoint touchLocation = [touch locationInView: [touch view]];
	touchLocation = [[CCDirector sharedDirector] convertToGL: touchLocation];
	int idx = -1;
 
	for( CCMenuItem* item in children_ ) 
	{
		idx++;
		CGPoint local = [item convertToNodeSpace:touchLocation];
 
		CGRect r = [item rect];
		r.origin = CGPointZero;
 
		if( CGRectContainsPoint( r, local ) )
		{
			selectedItemIndex = idx;
			return item;
		}
	}
 
	return nil;
}
 
-(int) selectedItemIndex
{
	return selectedItemIndex;
}
 
- (void)setSelectedItemIndex:(int) value 
{
	for( CCMenuItem* item in children_ ) 
	{
		[item unselected];	
	}
 
	selectedItemIndex = value;	
	selectedItem = [children_ objectAtIndex:selectedItemIndex];
 
	fallBackItemIndex = selectedItemIndex;
 
	[selectedItem selected];      
}
 
@end

CCSprite * mySprite = [CCSprite spriteWithFile:@"myFile.png"];
mySprite.position = CGPointMake(160, 240);
mySprite.rotation = 45; // Degrees
[self addChild:mySprite];

CCSprite * tveffect = [CCSprite spriteWithFile:@"televisionStreak.png"]; 
ccBlendFunc additiveBlendFunction = {GL_SRC_ALPHA, GL_ONE};
tveffect.blendFunc = additiveBlendFunction;
 
tveffect.position = ccp(160,0);	
[tveffect setOpacity:0];
 
id fadeAction = [CCSequence actions:
				 [CCFadeTo actionWithDuration:0.5 opacity:255],
				 [CCDelayTime actionWithDuration:1.0],
				 [CCFadeTo actionWithDuration:0.5 opacity:0],
				 nil];
 
id moveAction = [CCSequence actions:
				 [CCMoveTo actionWithDuration:0 position:ccp(160, 0)],
				 [CCMoveTo actionWithDuration:2 position:ccp(160, 480],
				 nil];
 
[tveffect runAction:[CCRepeatForever actionWithAction: [CCSpawn actions:fadeAction,moveAction, nil]]];

//
//  MyFileName.m
//  MyProjectName
//
//  Created by Hans Hamm on 24.11.09.
//  Copyright 2009 __MyCompanyName__. All rights reserved.
//

defaults write com.apple.Xcode PBXCustomTemplateMacroDefinitions '{ "ORGANIZATIONNAME" = "My Company";}'

cd /Applications/Utilities
ln -s /Developer/Platforms/iPhoneOS.platform/DeviceSupport/3.0\ \(7A341\) /Developer/Platforms/iPhoneOS.platform/DeviceSupport/3.0.1

/*
 
    File: MyOpenALSupport.h
Abstract: OpenAL-related support functions
 Version: 1.3
 
Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple
Inc. ("Apple") in consideration of your agreement to the following
terms, and your use, installation, modification or redistribution of
this Apple software constitutes acceptance of these terms.  If you do
not agree with these terms, please do not use, install, modify or
redistribute this Apple software.
 
In consideration of your agreement to abide by the following terms, and
subject to these terms, Apple grants you a personal, non-exclusive
license, under Apple's copyrights in this original Apple software (the
"Apple Software"), to use, reproduce, modify and redistribute the Apple
Software, with or without modifications, in source and/or binary forms;
provided that if you redistribute the Apple Software in its entirety and
without modifications, you must retain this notice and the following
text and disclaimers in all such redistributions of the Apple Software.
Neither the name, trademarks, service marks or logos of Apple Inc. may
be used to endorse or promote products derived from the Apple Software
without specific prior written permission from Apple.  Except as
expressly stated in this notice, no other rights or licenses, express or
implied, are granted by Apple herein, including but not limited to any
patent rights that may be infringed by your derivative works or by other
works in which the Apple Software may be incorporated.
 
The Apple Software is provided by Apple on an "AS IS" basis.  APPLE
MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
 
IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
 
Copyright (C) 2008 Apple Inc. All Rights Reserved.
 
 */
 
#import <OpenAL/al.h>
#import <OpenAL/alc.h>
#import <AudioToolbox/AudioToolbox.h>
#import <AudioToolbox/ExtendedAudioFile.h>
 
typedef ALvoid	AL_APIENTRY	(*alBufferDataStaticProcPtr) (const ALint bid, ALenum format, ALvoid* data, ALsizei size, ALsizei freq);
ALvoid  alBufferDataStaticProc(const ALint bid, ALenum format, ALvoid* data, ALsizei size, ALsizei freq);
 
void* MyGetOpenALAudioData(CFURLRef inFileURL, ALsizei *outDataSize, ALenum *outDataFormat, ALsizei*	outSampleRate);

/*
 
    File: MyOpenALSupport.c
Abstract: OpenAL-related support functions
 Version: 1.3
 
Disclaimer: IMPORTANT:  This Apple software is supplied to you by Apple
Inc. ("Apple") in consideration of your agreement to the following
terms, and your use, installation, modification or redistribution of
this Apple software constitutes acceptance of these terms.  If you do
not agree with these terms, please do not use, install, modify or
redistribute this Apple software.
 
In consideration of your agreement to abide by the following terms, and
subject to these terms, Apple grants you a personal, non-exclusive
license, under Apple's copyrights in this original Apple software (the
"Apple Software"), to use, reproduce, modify and redistribute the Apple
Software, with or without modifications, in source and/or binary forms;
provided that if you redistribute the Apple Software in its entirety and
without modifications, you must retain this notice and the following
text and disclaimers in all such redistributions of the Apple Software.
Neither the name, trademarks, service marks or logos of Apple Inc. may
be used to endorse or promote products derived from the Apple Software
without specific prior written permission from Apple.  Except as
expressly stated in this notice, no other rights or licenses, express or
implied, are granted by Apple herein, including but not limited to any
patent rights that may be infringed by your derivative works or by other
works in which the Apple Software may be incorporated.
 
The Apple Software is provided by Apple on an "AS IS" basis.  APPLE
MAKES NO WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION
THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND
OPERATION ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
 
IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL
OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION,
MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED
AND WHETHER UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE),
STRICT LIABILITY OR OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
 
Copyright (C) 2008 Apple Inc. All Rights Reserved.
 
*/
 
#include "MyOpenALSupport.h"
 
ALvoid  alBufferDataStaticProc(const ALint bid, ALenum format, ALvoid* data, ALsizei size, ALsizei freq)
{
	static	alBufferDataStaticProcPtr	proc = NULL;
 
    if (proc == NULL) {
        proc = (alBufferDataStaticProcPtr) alcGetProcAddress(NULL, (const ALCchar*) "alBufferDataStatic");
    }
 
    if (proc)
        proc(bid, format, data, size, freq);
 
    return;
}
 
void* MyGetOpenALAudioData(CFURLRef inFileURL, ALsizei *outDataSize, ALenum *outDataFormat, ALsizei*	outSampleRate)
{
	OSStatus err = noErr;
	SInt64 theFileLengthInFrames = 0;
	AudioStreamBasicDescription theFileFormat;
	UInt32 thePropertySize = sizeof(theFileFormat);
	ExtAudioFileRef extRef = NULL;
	void* theData = NULL;
	AudioStreamBasicDescription theOutputFormat;
 
	// Open a file with ExtAudioFileOpen()
	err = ExtAudioFileOpenURL(inFileURL, &extRef);
	if(err) { printf("MyGetOpenALAudioData: ExtAudioFileOpenURL FAILED, Error = %ld\n", err); goto Exit; }
 
	// Get the audio data format
	err = ExtAudioFileGetProperty(extRef, kExtAudioFileProperty_FileDataFormat, &thePropertySize, &theFileFormat);
	if(err) { printf("MyGetOpenALAudioData: ExtAudioFileGetProperty(kExtAudioFileProperty_FileDataFormat) FAILED, Error = %ld\n", err); goto Exit; }
	if (theFileFormat.mChannelsPerFrame > 2)  { printf("MyGetOpenALAudioData - Unsupported Format, channel count is greater than stereo\n"); goto Exit;}
 
	// Set the client format to 16 bit signed integer (native-endian) data
	// Maintain the channel count and sample rate of the original source format
	theOutputFormat.mSampleRate = theFileFormat.mSampleRate;
	theOutputFormat.mChannelsPerFrame = theFileFormat.mChannelsPerFrame;
 
	theOutputFormat.mFormatID = kAudioFormatLinearPCM;
	theOutputFormat.mBytesPerPacket = 2 * theOutputFormat.mChannelsPerFrame;
	theOutputFormat.mFramesPerPacket = 1;
	theOutputFormat.mBytesPerFrame = 2 * theOutputFormat.mChannelsPerFrame;
	theOutputFormat.mBitsPerChannel = 16;
	theOutputFormat.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger;
 
	// Set the desired client (output) data format
	err = ExtAudioFileSetProperty(extRef, kExtAudioFileProperty_ClientDataFormat, sizeof(theOutputFormat), &theOutputFormat);
	if(err) { printf("MyGetOpenALAudioData: ExtAudioFileSetProperty(kExtAudioFileProperty_ClientDataFormat) FAILED, Error = %ld\n", err); goto Exit; }
 
	// Get the total frame count
	thePropertySize = sizeof(theFileLengthInFrames);
	err = ExtAudioFileGetProperty(extRef, kExtAudioFileProperty_FileLengthFrames, &thePropertySize, &theFileLengthInFrames);
	if(err) { printf("MyGetOpenALAudioData: ExtAudioFileGetProperty(kExtAudioFileProperty_FileLengthFrames) FAILED, Error = %ld\n", err); goto Exit; }
 
	// Read all the data into memory
	UInt32		dataSize = theFileLengthInFrames * theOutputFormat.mBytesPerFrame;;
	theData = malloc(dataSize);
	if (theData)
	{
		AudioBufferList		theDataBuffer;
		theDataBuffer.mNumberBuffers = 1;
		theDataBuffer.mBuffers[0].mDataByteSize = dataSize;
		theDataBuffer.mBuffers[0].mNumberChannels = theOutputFormat.mChannelsPerFrame;
		theDataBuffer.mBuffers[0].mData = theData;
 
		// Read the data into an AudioBufferList
		err = ExtAudioFileRead(extRef, (UInt32*)&theFileLengthInFrames, &theDataBuffer);
		if(err == noErr)
		{
			// success
			*outDataSize = (ALsizei)dataSize;
			*outDataFormat = (theOutputFormat.mChannelsPerFrame > 1) ? AL_FORMAT_STEREO16 : AL_FORMAT_MONO16;
			*outSampleRate = (ALsizei)theOutputFormat.mSampleRate;
		}
		else
		{
			// failure
			free (theData);
			theData = NULL; // make sure to return NULL
			printf("MyGetOpenALAudioData: ExtAudioFileRead FAILED, Error = %ld\n", err); goto Exit;
		}
	}
 
Exit:
	// Dispose the ExtAudioFileRef, it is no longer needed
	if (extRef) ExtAudioFileDispose(extRef);
	return theData;
}

static MySingeltonClass *sharedSingeltonInstance = nil;
 
+ (MySingeltonClass*)sharedManager
{
    @synchronized(self) {
        if (sharedSingeltonInstance == nil) {
            [[self alloc] init]; // assignment not done here
        }
    }
    return sharedSingeltonInstance;
}
 
+ (id)allocWithZone:(NSZone *)zone
{
    @synchronized(self) {
        if (sharedSingeltonInstance == nil) {
            sharedSingeltonInstance = [super allocWithZone:zone];
            return sharedSingeltonInstance;  // assignment and return on first allocation
        }
    }
    return nil; //on subsequent allocation attempts return nil
}
 
- (id)copyWithZone:(NSZone *)zone
{
    return self;
}
 
- (id)retain
{
    return self;
}
 
- (unsigned)retainCount
{
    return UINT_MAX;  //denotes an object that cannot be released
}
 
- (void)release
{
    //do nothing
}
 
- (id)autorelease
{
    return self;
}

//
//  MyOpenAL.h
//
 
#import <Foundation/Foundation.h>
#import <OpenAL/al.h>
#import <OpenAL/alc.h>
#import <AudioToolbox/AudioToolbox.h>
 
@interface MyOpenAL : NSObject {
 
	ALCcontext* mContext; // stores the context (the 'air')
	ALCdevice* mDevice; // stores the device
	NSMutableArray * bufferStorageArray; // stores the buffer ids from openAL
	NSMutableDictionary * soundDictionary; // stores our soundkeys
}
 
// if you want to access directly the buffers or our sound dictionary
@property (nonatomic, retain) NSMutableArray * bufferStorageArray;
@property (nonatomic, retain) NSMutableDictionary * soundDictionary;
 
- (id) init; // init once
- (bool) initOpenAL; // no need to make it public, but I post it here to show you which methods we need. initOpenAL will be called within init process once.
- (void) playSoundWithKey:(NSString*)soundKey; // play a sound by name
- (void) stopSoundWithKey:(NSString*)soundKey; // stop a sound by name
- (bool) isPlayingSoundWithKey:(NSString *) soundKey; // check if sound is playing by name
- (void) rewindSoundWithKey:(NSString *) soundKey; // rewind a sound by name so its playing again
- (bool) loadSoundWithKey:(NSString *)_soundKey File:(NSString *)_file Ext:(NSString *) _ext Loop:(bool)loops; // load a sound and give it a name
 
+ (MyOpenAL*)sharedMyOpenAL; // access to our instance
 
@end

//
//  MyOpenAL.m
//
 
#import "MyOpenAL.h"
#import "MyOpenALSupport.h"
 
@implementation MyOpenAL
 
@synthesize bufferStorageArray;
@synthesize soundDictionary;
 
static MyOpenAL *sharedMyOpenAL = nil;
 
- (void) shutdownMyOpenAL {
	@synchronized(self) {
        if (sharedMyOpenAL != nil) {
			[self dealloc]; // assignment not done here
        }
    }
}
 
+ (MyOpenAL*)sharedMyOpenAL {
 
    @synchronized(self) {
        if (sharedMyOpenAL == nil) {
            [[self alloc] init]; // assignment not done here
        }
    }
    return sharedMyOpenAL;
}
 
+ (id)allocWithZone:(NSZone *)zone
{
    @synchronized(self) {
        if (sharedMyOpenAL == nil) {
            sharedMyOpenAL = [super allocWithZone:zone];
            return sharedMyOpenAL;  // assignment and return on first allocation
        }
    }
    return nil; //on subsequent allocation attempts return nil
}
 
- (id)copyWithZone:(NSZone *)zone
{
    return self;
}
 
- (id)retain
{
    return self;
}
 
- (unsigned)retainCount
{
 
	return UINT_MAX;  //denotes an object that cannot be released
}
 
- (void)release
{
    //do nothing
}
 
- (id)autorelease
{
    return self;
}
 
// seek in audio file for the property 'size'
// return the size in bytes
-(UInt32)audioFileSize:(AudioFileID)fileDescriptor
{
	MARK;
	UInt64 outDataSize = 0;
	UInt32 thePropSize = sizeof(UInt64);
	OSStatus result = AudioFileGetProperty(fileDescriptor, kAudioFilePropertyAudioDataByteCount, &thePropSize, &outDataSize);
	if(result != 0) NSLog(@"cannot find file size");
	return (UInt32)outDataSize;
}
 
// start up openAL
-(bool) initOpenAL
{
	MARK;
	// Initialization
	mDevice = alcOpenDevice(NULL); // select the "preferred device"
	if (mDevice) {
		// use the device to make a context
		mContext=alcCreateContext(mDevice,NULL);
		// set my context to the currently active one
		alcMakeContextCurrent(mContext);
		return true;
	}
	return false;
}
 
-(id) init {
		MARK;
	if (self = [super init] ) {
		if ([self initOpenAL]) {
			self.bufferStorageArray = [[[NSMutableArray alloc]init]autorelease];
			self.soundDictionary = [[[NSMutableDictionary alloc]init]autorelease];
 
		}
		return self;
	}
	[self release];
	return nil;
}
 
-(void) dealloc {
 
		MARK;
	// delete the sources
	for (NSNumber * sourceNumber in [soundDictionary allValues]) {
		NSUInteger sourceID = [sourceNumber unsignedIntegerValue];
		alDeleteSources(1, &sourceID);
	}
 
	self.soundDictionary=nil;
 
	// delete the buffers
	for (NSNumber * bufferNumber in bufferStorageArray) {
		NSUInteger bufferID = [bufferNumber unsignedIntegerValue];
		alDeleteBuffers(1, &bufferID);
	}
	self.bufferStorageArray=nil;
 
	// destroy the context
	alcDestroyContext(mContext);
	// close the device
	alcCloseDevice(mDevice);
 
	[super dealloc];
}
 
// the main method: grab the sound ID from the library
// and start the source playing
- (void)playSoundWithKey:(NSString*)soundKey
{
		MARK;
	NSNumber * numVal = [soundDictionary objectForKey:soundKey];
	if (numVal == nil) return;
	NSUInteger sourceID = [numVal unsignedIntValue];
	alSourcePlay(sourceID);
}
 
- (void)stopSoundWithKey:(NSString*)soundKey
{
	MARK;
	NSNumber * numVal = [soundDictionary objectForKey:soundKey];
	if (numVal == nil) return;
	NSUInteger sourceID = [numVal unsignedIntValue];
	alSourceStop(sourceID);
}
 
-(void) rewindSoundWithKey:(NSString *) soundKey {
 
	MARK;
	NSNumber * numVal = [soundDictionary objectForKey:soundKey];
	if (numVal == nil) return;
	NSUInteger sourceID = [numVal unsignedIntValue];
	alSourceRewind (sourceID);
}
 
-(bool) isPlayingSoundWithKey:(NSString *) soundKey {
 
	MARK;
	NSNumber * numVal = [soundDictionary objectForKey:soundKey];
	if (numVal == nil) return false;
	NSUInteger sourceID = [numVal unsignedIntValue];
 
	ALenum state;
 
    alGetSourcei(sourceID, AL_SOURCE_STATE, &state);
 
    return (state == AL_PLAYING);
}
 
-(bool) loadSoundWithKey:(NSString *)_soundKey File:(NSString *)_file Ext:(NSString *) _ext Loop:(bool)loops{
 
	START_TIMER;
 
	ALvoid * outData;
	ALenum  error = AL_NO_ERROR;
	ALenum  format;
	ALsizei size;
	ALsizei freq;
 
	NSBundle * bundle = [NSBundle mainBundle];
 
	// get some audio data from a wave file
	CFURLRef fileURL = (CFURLRef)[[NSURL fileURLWithPath:[bundle pathForResource:_file ofType:_ext]] retain];
 
	if (!fileURL)
	{
		END_TIMER(@"file not found.");
		return false;
	}
 
	outData = MyGetOpenALAudioData(fileURL, &size, &format, &freq);
 
	CFRelease(fileURL);
 
	if((error = alGetError()) != AL_NO_ERROR) {
		printf("error loading sound: %x\n", error);
		exit(1);
	}
 
	ALog(@"getting a free buffer from openAL.");
	NSUInteger bufferID;
	// grab a buffer ID from openAL
	alGenBuffers(1, &bufferID);
 
	ALog(@"loading audio data into openAL buffer.");
	// load the awaiting data blob into the openAL buffer.
	alBufferData(bufferID,format,outData,size,freq); 
 
	// save the buffer so we can release it later
	[bufferStorageArray addObject:[NSNumber numberWithUnsignedInteger:bufferID]];
 
	ALog(@"getting a free source from openAL.");
	NSUInteger sourceID;
	// grab a source ID from openAL
	alGenSources(1, &sourceID); 
 
	ALog(@"attatching the buffer to the source and setting up preferences");
	// attach the buffer to the source
	alSourcei(sourceID, AL_BUFFER, bufferID);
	// set some basic source prefs
	alSourcef(sourceID, AL_PITCH, 1.0f);
	alSourcef(sourceID, AL_GAIN, 1.0f);
	if (loops) alSourcei(sourceID, AL_LOOPING, AL_TRUE);
 
	// store this for future use
	[soundDictionary setObject:[NSNumber numberWithUnsignedInt:sourceID] forKey:_soundKey];	
 
	ALog(@"free %i bytes of temporary allocated memory.", size);
	// clean up the buffer
	if (outData)
	{
		free(outData);
		outData = NULL;
	}
 
	END_TIMER(@"Audiofile successfully loaded.");
	return true;
 
}
@end

[[MyOpenAL sharedMyOpenAL] loadSoundWithKey:@"music" File:"backgroundMusic" Ext:"aif" Loop:true];
[[MyOpenAL sharedMyOpenAL] loadSoundWithKey:@"beep" File:"Sound1" Ext:"aif" Loop:false];
 
[[MyOpenAL sharedMyOpenAL] playSoundWithKey:@"music"];
[[MyOpenAL sharedMyOpenAL] playSoundWithKey:@"beep"];

 #import <AudioToolbox/AudioToolbox.h>

NSString* path = [[NSBundle mainBundle] pathForResource:@"soundName" ofType:@"caf"];
NSURL * afUrl = [NSURL fileURLWithPath:path];
UInt32 soundID;
AudioServicesCreateSystemSoundID((CFURLRef)afUrl,&soundID);
AudioServicesPlaySystemSound (soundID);

usr/bin/afconvert -f caff -d LEI16@44100 inputSoundFile.aiff outputSoundFile.caf