Initial commit (version 0.2.1)

1 files changed, 768 insertions, 0 deletions

@@ -0,0 +1,768 @@
+/*
+ * cocos2d for iPhone: http://www.cocos2d-iphone.org
+ *
+ * Copyright (c) 2009 On-Core
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ */
+
+
+#import "CCActionTiledGrid.h"
+#import "CCDirector.h"
+#import "ccMacros.h"
+#import "Support/CGPointExtension.h"
+
+typedef struct
+{
+        CGPoint position;
+        CGPoint startPosition;
+        ccGridSize      delta;
+} Tile;
+
+#pragma mark -
+#pragma mark ShakyTiles3D
+
+@implementation CCShakyTiles3D
+
++(id)actionWithRange:(int)range shakeZ:(BOOL)shakeZ grid:(ccGridSize)gridSize duration:(ccTime)d
+{
+        return [[[self alloc] initWithRange:range shakeZ:shakeZ grid:gridSize duration:d] autorelease];
+}
+
+-(id)initWithRange:(int)range shakeZ:(BOOL)sz grid:(ccGridSize)gSize duration:(ccTime)d
+{
+        if ( (self = [super initWithSize:gSize duration:d]) )
+        {
+                randrange = range;
+                shakeZ = sz;
+        }
+        
+        return self;
+}
+
+-(id) copyWithZone: (NSZone*) zone
+{
+        CCGridAction *copy = [[[self class] allocWithZone:zone] initWithRange:randrange shakeZ:shakeZ grid:gridSize_ duration:duration_];
+        return copy;
+}
+
+
+-(void)update:(ccTime)time
+{
+        int i, j;
+        
+        for( i = 0; i < gridSize_.x; i++ )
+        {
+                for( j = 0; j < gridSize_.y; j++ )
+                {
+                        ccQuad3 coords = [self originalTile:ccg(i,j)];
+
+                        // X
+                        coords.bl.x += ( rand() % (randrange*2) ) - randrange;
+                        coords.br.x += ( rand() % (randrange*2) ) - randrange;
+                        coords.tl.x += ( rand() % (randrange*2) ) - randrange;
+                        coords.tr.x += ( rand() % (randrange*2) ) - randrange;
+
+                        // Y
+                        coords.bl.y += ( rand() % (randrange*2) ) - randrange;
+                        coords.br.y += ( rand() % (randrange*2) ) - randrange;
+                        coords.tl.y += ( rand() % (randrange*2) ) - randrange;
+                        coords.tr.y += ( rand() % (randrange*2) ) - randrange;
+
+                        if( shakeZ ) {
+                                coords.bl.z += ( rand() % (randrange*2) ) - randrange;
+                                coords.br.z += ( rand() % (randrange*2) ) - randrange;
+                                coords.tl.z += ( rand() % (randrange*2) ) - randrange;
+                                coords.tr.z += ( rand() % (randrange*2) ) - randrange;
+                        }
+                                                
+                        [self setTile:ccg(i,j) coords:coords];
+                }
+        }
+}
+
+@end
+
+////////////////////////////////////////////////////////////
+
+#pragma mark -
+#pragma mark CCShatteredTiles3D
+
+@implementation CCShatteredTiles3D
+
++(id)actionWithRange:(int)range shatterZ:(BOOL)sz grid:(ccGridSize)gridSize duration:(ccTime)d
+{
+        return [[[self alloc] initWithRange:range shatterZ:sz grid:gridSize duration:d] autorelease];
+}
+
+-(id)initWithRange:(int)range shatterZ:(BOOL)sz grid:(ccGridSize)gSize duration:(ccTime)d
+{
+        if ( (self = [super initWithSize:gSize duration:d]) )
+        {
+                once = NO;
+                randrange = range;
+                shatterZ = sz;
+        }
+        
+        return self;
+}
+
+-(id) copyWithZone: (NSZone*) zone
+{
+        CCGridAction *copy = [[[self class] allocWithZone:zone] initWithRange:randrange shatterZ:shatterZ grid:gridSize_ duration:duration_];
+        return copy;
+}
+
+
+-(void)update:(ccTime)time
+{
+        int i, j;
+        
+        if ( once == NO )
+        {
+                for( i = 0; i < gridSize_.x; i++ )
+                {
+                        for( j = 0; j < gridSize_.y; j++ )
+                        {
+                                ccQuad3 coords = [self originalTile:ccg(i,j)];
+                                
+                                // X
+                                coords.bl.x += ( rand() % (randrange*2) ) - randrange;
+                                coords.br.x += ( rand() % (randrange*2) ) - randrange;
+                                coords.tl.x += ( rand() % (randrange*2) ) - randrange;
+                                coords.tr.x += ( rand() % (randrange*2) ) - randrange;
+                                
+                                // Y
+                                coords.bl.y += ( rand() % (randrange*2) ) - randrange;
+                                coords.br.y += ( rand() % (randrange*2) ) - randrange;
+                                coords.tl.y += ( rand() % (randrange*2) ) - randrange;
+                                coords.tr.y += ( rand() % (randrange*2) ) - randrange;
+
+                                if( shatterZ ) {
+                                        coords.bl.z += ( rand() % (randrange*2) ) - randrange;
+                                        coords.br.z += ( rand() % (randrange*2) ) - randrange;                          
+                                        coords.tl.z += ( rand() % (randrange*2) ) - randrange;
+                                        coords.tr.z += ( rand() % (randrange*2) ) - randrange;
+                                }
+                                
+                                [self setTile:ccg(i,j) coords:coords];
+                        }
+                }
+                
+                once = YES;
+        }
+}
+
+@end
+
+////////////////////////////////////////////////////////////
+
+#pragma mark -
+#pragma mark CCShuffleTiles
+
+@implementation CCShuffleTiles
+
++(id)actionWithSeed:(int)s grid:(ccGridSize)gridSize duration:(ccTime)d
+{
+        return [[[self alloc] initWithSeed:s grid:gridSize duration:d] autorelease];
+}
+
+-(id)initWithSeed:(int)s grid:(ccGridSize)gSize duration:(ccTime)d
+{
+        if ( (self = [super initWithSize:gSize duration:d]) )
+        {
+                seed = s;
+                tilesOrder = nil;
+                tiles = nil;
+        }
+        
+        return self;
+}
+
+-(id) copyWithZone: (NSZone*) zone
+{
+        CCGridAction *copy = [[[self class] allocWithZone:zone] initWithSeed:seed grid:gridSize_ duration:duration_];
+        return copy;
+}
+
+
+-(void)dealloc
+{
+        if ( tilesOrder ) free(tilesOrder);
+        if ( tiles ) free(tiles);
+        [super dealloc];
+}
+
+-(void)shuffle:(int*)array count:(NSUInteger)len
+{
+        NSInteger i;
+        for( i = len - 1; i >= 0; i-- )
+        {
+                NSInteger j = rand() % (i+1);
+                int v = array[i];
+                array[i] = array[j];
+                array[j] = v;
+        }
+}
+
+-(ccGridSize)getDelta:(ccGridSize)pos
+{
+        CGPoint pos2;
+        
+        NSInteger idx = pos.x * gridSize_.y + pos.y;
+        
+        pos2.x = tilesOrder[idx] / (int)gridSize_.y;
+        pos2.y = tilesOrder[idx] % (int)gridSize_.y;
+        
+        return ccg(pos2.x - pos.x, pos2.y - pos.y);
+}
+
+-(void)placeTile:(ccGridSize)pos tile:(Tile)t
+{
+        ccQuad3 coords = [self originalTile:pos];
+        
+        CGPoint step = [[target_ grid] step];
+        coords.bl.x += (int)(t.position.x * step.x);
+        coords.bl.y += (int)(t.position.y * step.y);
+
+        coords.br.x += (int)(t.position.x * step.x);
+        coords.br.y += (int)(t.position.y * step.y);
+
+        coords.tl.x += (int)(t.position.x * step.x);
+        coords.tl.y += (int)(t.position.y * step.y);
+
+        coords.tr.x += (int)(t.position.x * step.x);
+        coords.tr.y += (int)(t.position.y * step.y);
+
+        [self setTile:pos coords:coords];
+}
+
+-(void)startWithTarget:(id)aTarget
+{
+        [super startWithTarget:aTarget];
+        
+        if ( seed != -1 )
+                srand(seed);
+        
+        tilesCount = gridSize_.x * gridSize_.y;
+        tilesOrder = (int*)malloc(tilesCount*sizeof(int));
+        int i, j;
+        
+        for( i = 0; i < tilesCount; i++ )
+                tilesOrder[i] = i;
+        
+        [self shuffle:tilesOrder count:tilesCount];
+        
+        tiles = malloc(tilesCount*sizeof(Tile));
+        Tile *tileArray = (Tile*)tiles;
+        
+        for( i = 0; i < gridSize_.x; i++ )
+        {
+                for( j = 0; j < gridSize_.y; j++ )
+                {
+                        tileArray->position = ccp(i,j);
+                        tileArray->startPosition = ccp(i,j);
+                        tileArray->delta = [self getDelta:ccg(i,j)];
+                        tileArray++;
+                }
+        }
+}
+
+-(void)update:(ccTime)time
+{
+        int i, j;
+        
+        Tile *tileArray = (Tile*)tiles;
+        
+        for( i = 0; i < gridSize_.x; i++ )
+        {
+                for( j = 0; j < gridSize_.y; j++ )
+                {
+                        tileArray->position = ccpMult( ccp(tileArray->delta.x, tileArray->delta.y), time);
+                        [self placeTile:ccg(i,j) tile:*tileArray];
+                        tileArray++;
+                }
+        }
+}
+
+@end
+
+////////////////////////////////////////////////////////////
+
+#pragma mark -
+#pragma mark CCFadeOutTRTiles
+
+@implementation CCFadeOutTRTiles
+
+-(float)testFunc:(ccGridSize)pos time:(ccTime)time
+{
+        CGPoint n = ccpMult( ccp(gridSize_.x,gridSize_.y), time);
+        if ( (n.x+n.y) == 0.0f )
+                return 1.0f;
+        
+        return powf( (pos.x+pos.y) / (n.x+n.y), 6 );
+}
+
+-(void)turnOnTile:(ccGridSize)pos
+{
+        [self setTile:pos coords:[self originalTile:pos]];
+}
+
+-(void)turnOffTile:(ccGridSize)pos
+{
+        ccQuad3 coords; 
+        bzero(&coords, sizeof(ccQuad3));
+        [self setTile:pos coords:coords];
+}
+
+-(void)transformTile:(ccGridSize)pos distance:(float)distance
+{
+        ccQuad3 coords = [self originalTile:pos];
+        CGPoint step = [[target_ grid] step];
+        
+        coords.bl.x += (step.x / 2) * (1.0f - distance);
+        coords.bl.y += (step.y / 2) * (1.0f - distance);
+
+        coords.br.x -= (step.x / 2) * (1.0f - distance);
+        coords.br.y += (step.y / 2) * (1.0f - distance);
+
+        coords.tl.x += (step.x / 2) * (1.0f - distance);
+        coords.tl.y -= (step.y / 2) * (1.0f - distance);
+
+        coords.tr.x -= (step.x / 2) * (1.0f - distance);
+        coords.tr.y -= (step.y / 2) * (1.0f - distance);
+
+        [self setTile:pos coords:coords];
+}
+
+-(void)update:(ccTime)time
+{
+        int i, j;
+        
+        for( i = 0; i < gridSize_.x; i++ )
+        {
+                for( j = 0; j < gridSize_.y; j++ )
+                {
+                        float distance = [self testFunc:ccg(i,j) time:time];
+                        if ( distance == 0 )
+                                [self turnOffTile:ccg(i,j)];
+                        else if ( distance < 1 )
+                                [self transformTile:ccg(i,j) distance:distance];
+                        else
+                                [self turnOnTile:ccg(i,j)];
+                }
+        }
+}
+
+@end
+
+////////////////////////////////////////////////////////////
+
+#pragma mark -
+#pragma mark CCFadeOutBLTiles
+
+@implementation CCFadeOutBLTiles
+
+-(float)testFunc:(ccGridSize)pos time:(ccTime)time
+{
+        CGPoint n = ccpMult(ccp(gridSize_.x, gridSize_.y), (1.0f-time));
+        if ( (pos.x+pos.y) == 0 )
+                return 1.0f;
+        
+        return powf( (n.x+n.y) / (pos.x+pos.y), 6 );
+}
+
+@end
+
+////////////////////////////////////////////////////////////
+
+#pragma mark -
+#pragma mark CCFadeOutUpTiles
+
+@implementation CCFadeOutUpTiles
+
+-(float)testFunc:(ccGridSize)pos time:(ccTime)time
+{
+        CGPoint n = ccpMult(ccp(gridSize_.x, gridSize_.y), time);
+        if ( n.y == 0 )
+                return 1.0f;
+        
+        return powf( pos.y / n.y, 6 );
+}
+
+-(void)transformTile:(ccGridSize)pos distance:(float)distance
+{
+        ccQuad3 coords = [self originalTile:pos];
+        CGPoint step = [[target_ grid] step];
+        
+        coords.bl.y += (step.y / 2) * (1.0f - distance);
+        coords.br.y += (step.y / 2) * (1.0f - distance);
+        coords.tl.y -= (step.y / 2) * (1.0f - distance);
+        coords.tr.y -= (step.y / 2) * (1.0f - distance);
+        
+        [self setTile:pos coords:coords];
+}
+
+@end
+
+////////////////////////////////////////////////////////////
+
+#pragma mark -
+#pragma mark CCFadeOutDownTiles
+
+@implementation CCFadeOutDownTiles
+
+-(float)testFunc:(ccGridSize)pos time:(ccTime)time
+{
+        CGPoint n = ccpMult(ccp(gridSize_.x,gridSize_.y), (1.0f - time));
+        if ( pos.y == 0 )
+                return 1.0f;
+        
+        return powf( n.y / pos.y, 6 );
+}
+
+@end
+
+////////////////////////////////////////////////////////////
+
+#pragma mark -
+#pragma mark TurnOffTiles
+
+@implementation CCTurnOffTiles
+
++(id)actionWithSeed:(int)s grid:(ccGridSize)gridSize duration:(ccTime)d
+{
+        return [[[self alloc] initWithSeed:s grid:gridSize duration:d] autorelease];
+}
+
+-(id)initWithSeed:(int)s grid:(ccGridSize)gSize duration:(ccTime)d
+{
+        if ( (self = [super initWithSize:gSize duration:d]) )
+        {
+                seed = s;
+                tilesOrder = nil;
+        }
+        
+        return self;
+}
+
+-(id) copyWithZone: (NSZone*) zone
+{
+        CCGridAction *copy = [[[self class] allocWithZone:zone] initWithSeed:seed grid:gridSize_ duration:duration_];
+        return copy;
+}
+
+-(void)dealloc
+{
+        if ( tilesOrder ) free(tilesOrder);
+        [super dealloc];
+}
+
+-(void)shuffle:(int*)array count:(NSUInteger)len
+{
+        NSInteger i;
+        for( i = len - 1; i >= 0; i-- )
+        {
+                NSInteger j = rand() % (i+1);
+                int v = array[i];
+                array[i] = array[j];
+                array[j] = v;
+        }
+}
+
+-(void)turnOnTile:(ccGridSize)pos
+{
+        [self setTile:pos coords:[self originalTile:pos]];
+}
+
+-(void)turnOffTile:(ccGridSize)pos
+{
+        ccQuad3 coords;
+        
+        bzero(&coords, sizeof(ccQuad3));
+        [self setTile:pos coords:coords];
+}
+
+-(void)startWithTarget:(id)aTarget
+{
+        int i;
+        
+        [super startWithTarget:aTarget];
+        
+        if ( seed != -1 )
+                srand(seed);
+        
+        tilesCount = gridSize_.x * gridSize_.y;
+        tilesOrder = (int*)malloc(tilesCount*sizeof(int));
+
+        for( i = 0; i < tilesCount; i++ )
+                tilesOrder[i] = i;
+        
+        [self shuffle:tilesOrder count:tilesCount];
+}
+
+-(void)update:(ccTime)time
+{
+        int i, l, t;
+        
+        l = (int)(time * (float)tilesCount);
+        
+        for( i = 0; i < tilesCount; i++ )
+        {
+                t = tilesOrder[i];
+                ccGridSize tilePos = ccg( t / gridSize_.y, t % gridSize_.y );
+                
+                if ( i < l )
+                        [self turnOffTile:tilePos];
+                else
+                        [self turnOnTile:tilePos];
+        }
+}
+
+@end
+
+////////////////////////////////////////////////////////////
+
+#pragma mark -
+#pragma mark CCWavesTiles3D
+
+@implementation CCWavesTiles3D
+
+@synthesize amplitude;
+@synthesize amplitudeRate;
+
++(id)actionWithWaves:(int)wav amplitude:(float)amp grid:(ccGridSize)gridSize duration:(ccTime)d
+{
+        return [[[self alloc] initWithWaves:wav amplitude:amp grid:gridSize duration:d] autorelease];
+}
+
+-(id)initWithWaves:(int)wav amplitude:(float)amp grid:(ccGridSize)gSize duration:(ccTime)d
+{
+        if ( (self = [super initWithSize:gSize duration:d]) )
+        {
+                waves = wav;
+                amplitude = amp;
+                amplitudeRate = 1.0f;
+        }
+        
+        return self;
+}
+
+-(id) copyWithZone: (NSZone*) zone
+{
+        CCGridAction *copy = [[[self class] allocWithZone:zone] initWithWaves:waves amplitude:amplitude grid:gridSize_ duration:duration_];
+        return copy;
+}
+
+
+-(void)update:(ccTime)time
+{
+        int i, j;
+        
+        for( i = 0; i < gridSize_.x; i++ )
+        {
+                for( j = 0; j < gridSize_.y; j++ )
+                {
+                        ccQuad3 coords = [self originalTile:ccg(i,j)];
+                        
+                        coords.bl.z = (sinf(time*(CGFloat)M_PI*waves*2 + (coords.bl.y+coords.bl.x) * .01f) * amplitude * amplitudeRate );
+                        coords.br.z     = coords.bl.z;
+                        coords.tl.z = coords.bl.z;
+                        coords.tr.z = coords.bl.z;
+                        
+                        [self setTile:ccg(i,j) coords:coords];
+                }
+        }
+}
+@end
+
+////////////////////////////////////////////////////////////
+
+#pragma mark -
+#pragma mark CCJumpTiles3D
+
+@implementation CCJumpTiles3D
+
+@synthesize amplitude;
+@synthesize amplitudeRate;
+
++(id)actionWithJumps:(int)j amplitude:(float)amp grid:(ccGridSize)gridSize duration:(ccTime)d
+{
+        return [[[self alloc] initWithJumps:j amplitude:amp grid:gridSize duration:d] autorelease];
+}
+
+-(id)initWithJumps:(int)j amplitude:(float)amp grid:(ccGridSize)gSize duration:(ccTime)d
+{
+        if ( (self = [super initWithSize:gSize duration:d]) )
+        {
+                jumps = j;
+                amplitude = amp;
+                amplitudeRate = 1.0f;
+        }
+        
+        return self;
+}
+
+-(id) copyWithZone: (NSZone*) zone
+{
+        CCGridAction *copy = [[[self class] allocWithZone:zone] initWithJumps:jumps amplitude:amplitude grid:gridSize_ duration:duration_];
+        return copy;
+}
+
+
+-(void)update:(ccTime)time
+{
+        int i, j;
+        
+        float sinz =  (sinf((CGFloat)M_PI*time*jumps*2) * amplitude * amplitudeRate );
+        float sinz2 = (sinf((CGFloat)M_PI*(time*jumps*2 + 1)) * amplitude * amplitudeRate );
+        
+        for( i = 0; i < gridSize_.x; i++ )
+        {
+                for( j = 0; j < gridSize_.y; j++ )
+                {
+                        ccQuad3 coords = [self originalTile:ccg(i,j)];
+                        
+                        if ( ((i+j) % 2) == 0 )
+                        {
+                                coords.bl.z += sinz;
+                                coords.br.z += sinz;
+                                coords.tl.z += sinz;
+                                coords.tr.z += sinz;
+                        }
+                        else
+                        {
+                                coords.bl.z += sinz2;
+                                coords.br.z += sinz2;
+                                coords.tl.z += sinz2;
+                                coords.tr.z += sinz2;
+                        }
+                        
+                        [self setTile:ccg(i,j) coords:coords];
+                }
+        }
+}
+@end
+
+////////////////////////////////////////////////////////////
+
+#pragma mark -
+#pragma mark SplitRows
+
+@implementation CCSplitRows
+
++(id)actionWithRows:(int)r duration:(ccTime)d
+{
+        return [[[self alloc] initWithRows:r duration:d] autorelease];
+}
+
+-(id)initWithRows:(int)r duration:(ccTime)d
+{
+        rows = r;
+        return [super initWithSize:ccg(1,r) duration:d];
+}
+
+-(id) copyWithZone: (NSZone*) zone
+{
+        CCGridAction *copy = [[[self class] allocWithZone:zone] initWithRows:rows duration:duration_];
+        return copy;
+}
+
+-(void)startWithTarget:(id)aTarget
+{
+        [super startWithTarget:aTarget];
+        winSize = [[CCDirector sharedDirector] winSizeInPixels];
+}
+
+-(void)update:(ccTime)time
+{
+        int j;
+        
+        for( j = 0; j < gridSize_.y; j++ )
+        {
+                ccQuad3 coords = [self originalTile:ccg(0,j)];
+                float   direction = 1;
+                
+                if ( (j % 2 ) == 0 )
+                        direction = -1;
+                
+                coords.bl.x += direction * winSize.width * time;
+                coords.br.x += direction * winSize.width * time;
+                coords.tl.x += direction * winSize.width * time;
+                coords.tr.x += direction * winSize.width * time;
+                
+                [self setTile:ccg(0,j) coords:coords];
+        }
+}
+
+@end
+
+////////////////////////////////////////////////////////////
+
+#pragma mark -
+#pragma mark CCSplitCols
+
+@implementation CCSplitCols
+
++(id)actionWithCols:(int)c duration:(ccTime)d
+{
+        return [[[self alloc] initWithCols:c duration:d] autorelease];
+}
+
+-(id)initWithCols:(int)c duration:(ccTime)d
+{
+        cols = c;
+        return [super initWithSize:ccg(c,1) duration:d];
+}
+
+-(id) copyWithZone: (NSZone*) zone
+{
+        CCGridAction *copy = [[[self class] allocWithZone:zone] initWithCols:cols duration:duration_];
+        return copy;
+}
+
+-(void)startWithTarget:(id)aTarget
+{
+        [super startWithTarget:aTarget];
+        winSize = [[CCDirector sharedDirector] winSizeInPixels];
+}
+
+-(void)update:(ccTime)time
+{
+        int i;
+        
+        for( i = 0; i < gridSize_.x; i++ )
+        {
+                ccQuad3 coords = [self originalTile:ccg(i,0)];
+                float   direction = 1;
+                
+                if ( (i % 2 ) == 0 )
+                        direction = -1;
+                
+                coords.bl.y += direction * winSize.height * time;
+                coords.br.y += direction * winSize.height * time;
+                coords.tl.y += direction * winSize.height * time;
+                coords.tr.y += direction * winSize.height * time;
+                
+                [self setTile:ccg(i,0) coords:coords];
+        }
+}
+
+@end