From 9cd57b731ab1c666d4a1cb725538fdc137763d12 Mon Sep 17 00:00:00 2001 From: Starla Insigna Date: Sat, 30 Jul 2011 11:19:14 -0400 Subject: Initial commit (version 0.2.1) --- libs/cocos2d/CCActionTiledGrid.m | 768 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 768 insertions(+) create mode 100755 libs/cocos2d/CCActionTiledGrid.m (limited to 'libs/cocos2d/CCActionTiledGrid.m') diff --git a/libs/cocos2d/CCActionTiledGrid.m b/libs/cocos2d/CCActionTiledGrid.m new file mode 100755 index 0000000..75965ec --- /dev/null +++ b/libs/cocos2d/CCActionTiledGrid.m @@ -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 -- cgit 1.4.1