cocos2d 学习 第五章

当你用CCDirector replaceScene方法替换场景时, 每个节点都会调用CCNode所带的三个方法。

这三个方法是:onEnter, onEnterTransitionDidFinish和onExit。 

取决于是否使用了CCTransitionScene, onEnter和onExit会在场景转换过程中的某个时间点被调用。对于这三个方法, 你必须调用它们的super方法以避免触摸输入问题和内存泄漏的问题。 

-(void) onEnter
{

　　// 节点调用init方法以后将会调用此方法
　　// 如果使用了CCTransitionScene,将会在过渡效果开始以后调用此方法

　　[super onEnter];

}

-(void) onEnterTransitionDidFinish
{

　　　　// 调用onEnter以后将会调用此方法
　　　　// 如果使用了CCTransitionScene,将会在过渡效果结束以后调用此方法

　　　　[super onEnterTransitionDidFinish];

}
-(void) onExit
｛

　　　　// 节点调用dealloc方法之前将会调用此方法
　　　　// 如果使用了CCTransitionScene,将会在过渡效果结束以后调用此方法

　　　　[super onExit]; 

｝

如果你不在onEnter方法里调用它的super方法的话,你的新场景可能不会对触摸或者加速计的输入有任何反应。

如果你不在onExit方法里调用它的super方法,当前场景可能不会从内存里释放。 

你可以在场景转换之前或者之后,通过使用上述方法在节点中完成一些特定的 操作。因为在程序进入onEnter方法的时候,场景中的所有节点都已经设置完成 了;同时,在onExit方法中,所有节点都还存在于内存中。 

1. scene: OtherScene
2. init: 
3. onEnter: 
4. // ......
5. onExit: 
6. onEnterTransitionDidFinish: 

7. dealloc: 

replaceScene -> Other Scene.

===========================================

scene: OtherScene

init: <OtherScene = 0x1835e10 | Tag = -1>

onExit: <FirstScene = 0x436170 | Tag = -1>  // 因为切换到OhterScene时，FirstScene还在内存中，过程是先初始化OhterScene，之后从内存中清空FirstScene

dealloc: <FirstScene = 0x436170 | Tag = -1>

onEnter: <OtherScene = 0x1835e10 | Tag = -1>

onEnterTransitionDidFinish: <OtherScene = 0x1835e10 | Tag = -1>

 

#import <Foundation/Foundation.h>

#import "cocos2d.h"

typedefenum

{

    TargetSceneINVALID = 0,

    TargetSceneFirstScene,

    TargetSceneOtherScene,

    TargetSceneMAX,

}

TargetScenes;

 

@interface LoadingScene : CCScene

{

    TargetScenes targetScene_;

}

+(id)sceneWithTargetScene:(TargetScenes)targetScene;

-(id)initWithTargetScene:(TargetScenes)targetScene;

@end

 

 

#import "LoadingScene.h"

#import "FirstScene.h"

#import "OtherScene.h"

 

@implementation LoadingScene

+(id)sceneWithTargetScene:(TargetScenes)targetScene

{

    return [[[self alloc] initWithTargetScene:targetScene] autorelease];

}

 

-(id)initWithTargetScene:(TargetScenes)targetScene

{

    if((self = [super init]))

    {

        targetScene_ = targetScene;

        CCLabelTTF *label = [CCLabelTTFlabelWithString:@"Loading..."

                                               fontName:@"Marker Felt"

                                               fontSize:64];

        CGSize size = [[CCDirectorsharedDirector] winSize];

        label.position = CGPointMake(size.width*0.5, size.height*0.5);

        [self addChild:label];

        [selfscheduleUpdate];

    }

    returnself;

}

 

-(void)update:(ccTime)delta

{

    [selfunscheduleAllSelectors];

    switch (targetScene_) {

        caseTargetSceneFirstScene:

            [[CCDirectorsharedDirector] replaceScene:[FirstScenescene]];

            break;

        caseTargetSceneOtherScene:

            [[CCDirectorsharedDirector] replaceScene:[OtherScenescene]];

            break;

        default:

            NSAssert2(nil, @"%@:unsupported TargetScene %i", NSStringFromSelector(_cmd), targetScene_);

            break;

    }

}

@end

 

因为 LoadingScene 继承自 CCScene,并且要求传递一个新的参数给它,所以仅 仅调用[CCScene node]是不够的。SceneWithTargetScene 方法首先会完成对 self 的内存分配,然后调用 initWithTargetScene 方法,最后返回一个新的自 动释放对象。 

这里的 init 方法把目标场景储存在一个成员变量里面,接着生成一个 “Loading...”标签,最后运行 scheduleUpdate 这个预约方法。 

为什么我们不在init方法里直接使用replaceScene方法呢?这里有两条规则需要遵守。规则一:永远不要在一个节点的init方法中调用CCDirector的replaceScene方法。

规则二:请遵守规则一。不遵守规则的后果是程序崩溃。Director无法容忍一个节点在初始化的同时进行场景替换。 

在过渡效果中使用LoadingScene可以优化内存的使用:因为你使用了一个简单 的过渡场景用于替换当前场景,然后用最终的目标场景替换这个过渡场景。在 这个替换的过程中,cocos2d将会有足够的时间来释放之前场景所占用的内存。 我们得到的实际效果是:不再会有两个复杂场景同时占用着内存的情况了,因 此在场景转换过程中也就减少了出现内存使用高峰的机会。 

#import <Foundation/Foundation.h>
#import "cocos2d.h"
#import "GameLayer.h"
#import "UserInterfaceLayer.h"

typedef enum                // 定义二个层的Tag值
{
    LayerTagGameLayer,      // 用于标示［游戏层］
    LayerTagUILayer,        // 用于标示［用户设置层］
} MultiLayerSceneTags;

typedef enum                            // 定义动作Tag
{
    ActionTagGameLayerMovesBack,
    ActionTagGameLayerRotates,
} MultiLayerSceneActionTags;

@interface MultiLayerScene : CCLayer
{
    bool isToucheForUserInterface;      // 判断用户点击的是否为设置界面
}
@property (readonly) GameLayer *gameLayer;
@property (readonly) UserInterfaceLayer *uiLayer;

+(MultiLayerScene *)sharedLayer;
+(CGPoint)locationFromTouch:(UITouch *)touch;
+(CGPoint)locationFromTouches:(UITouch *)touches;
+(id)scene;

@end

#import "MultiLayerScene.h"

@implementation MultiLayerScene

static MultiLayerScene* multiLayerSceneInstance;    // 定义静态的本场景变量

+(MultiLayerScene *)sharedLayer     // 返回静态场景变量
{
    NSAssert(multiLayerSceneInstance != nil, @"MultiLayerScene not available!");
    return multiLayerSceneInstance;
}

#pragma mark 返回游戏层
- (GameLayer *)gameLayer
{
    CCNode *layer = [self getChildByTag:LayerTagGameLayer];
    NSAssert([layer isKindOfClass:[GameLayer class]], @"%@: not a GameLayer!",NSStringFromSelector(_cmd));
    return (GameLayer *)layer;
}

#pragma mark 返回用户设置层
- (UserInterfaceLayer*)uiLayer
{
    CCNode* layer = [[MultiLayerScene sharedLayer] getChildByTag:LayerTagUILayer];
    NSAssert([layer isKindOfClass:[UserInterfaceLayer class]], @"%@: not a UserInterfaceLayer!", NSStringFromSelector(_cmd));
    return (UserInterfaceLayer *)layer;
}

#pragma mark 得到用户点击的坐标并转换为OpenGL坐标
+(CGPoint)locationFromTouch:(UITouch *)touch
{
    // locationInView:函数返回一个CGPoint类型的值，表示触摸在view这个视图上的位置，这里返回的位置是针对view的坐标系的。
    // 调用时传入的view参数为空的话，返回的时触摸点在整个窗口的位置。
    CGPoint touchLocation = [touch locationInView:[touch view]];
    
    // convertToGL：将ios坐标系转换为OpenGL坐标系，返回类型 CGPoint
    return [[CCDirector sharedDirector] convertToGL:touchLocation];
}

#pragma mark 如果用户是多点触摸，那么返回其中任意一个触摸点的OpenGL坐标
+(CGPoint) locationFromTouches:(NSSet *)touches
{
    return [self locationFromTouch:[touches anyObject]];
}

#pragma mark - 静态构造方法Scene
+(id) scene
{
    CCScene* scene = [CCScene node];
    MultiLayerScene* layer = [MultiLayerScene node];
    [scene addChild:layer];
    return scene;
}

#pragma mark 初始化方法init
-(id) init
{
    if ((self = [super init]))
    {
        NSAssert(multiLayerSceneInstance == nil, @"another MultiLayerScene is already in use!");
        multiLayerSceneInstance = self;
        
        GameLayer* gameLayer = [GameLayer node];
        [self addChild:gameLayer z:1 tag:LayerTagGameLayer];        // 将游戏层加入场景中，Z轴位置为 1，
        // z：是指添加的ZOrder值，ZOrder是指该成员的层级（也可以说深度），z值大的成员在z值小的成员的上面；
        
        UserInterfaceLayer* uiLayer = [UserInterfaceLayer node];    // 将用户设置层加入场景中，Z轴位置为 2
        [self addChild:uiLayer z:2 tag:LayerTagUILayer];
    }
    return self;
}

-(void) dealloc
{
    CCLOG(@"%@: %@", NSStringFromSelector(_cmd), self);
    multiLayerSceneInstance = nil;
    [super dealloc];
}

@end

#import <Foundation/Foundation.h>
#import "cocos2d.h"

#pragma mark 游戏内容层
@interface GameLayer : CCLayer
{
    CGPoint gameLayerPosition;
    CGPoint lastTouchLocation;
}

@end

#import "GameLayer.h"
#import "cocos2d.h"
#import "MultiLayerScene.h"

@interface GameLayer (PrivateMethod)
-(void)addRandomThings;
@end

@implementation GameLayer
-(id)init
{
    if((self = [super init]))
    {
        gameLayerPosition = self.position;                                                      // 返回层的默认坐标(0,0)
        CGSize screenSize = [[CCDirector sharedDirector] winSize];
        CCSprite *background = [CCSprite spriteWithFile:@"grass.png"];                          // 载入“小草”精灵
        background.position = CGPointMake(screenSize.width * 0.5, screenSize.height * 0.5);     // 设置小草精灵的位置
        [self addChild:background];                                                             // 将小草加入游戏层中
        
        CCLabelTTF *label = [CCLabelTTF labelWithString:@"GameLayer"
                                             fontName:@"Marker Felt"
                                               fontSize:44];
        label.color = ccBLACK;
        label.position = CGPointMake(screenSize.width*0.5, screenSize.height * 0.5);
        //label.anchorPoint = CGPointMake(0.5f, 0.5f);
        [self addChild:label];                                                                  // 将文字标签加入游戏层
        
        [self addRandomThings];                                                             
        self.isTouchEnabled = YES;                                                              // 支持触屏
    }
    return self;
}

#pragma mark 在游戏层添加一些随机物品
-(void)addRandomThings
{
    CGSize screenSize = [[CCDirector sharedDirector] winSize];
    
    for (int i = 0; i<4; i++)                       // 添加4团随机的火元素
    {
        CCSprite *firething = [CCSprite spriteWithFile:@"firething.png"];
        firething.position = CGPointMake(CCRANDOM_0_1()*screenSize.width, CCRANDOM_0_1()*screenSize.height);
        [self addChild:firething];                  // 将火元素添加到游戏层中
        [self runRandomMoveSequence:firething];     // 随机移动此火元素
    }
    
    for (int i = 0; i<10; i++)                      // 添加10个随机的蜘蛛
    {
        CCSprite *spider = [CCSprite spriteWithFile:@"spider.png"];
        spider.position = CGPointMake(CCRANDOM_0_1()*screenSize.width, CCRANDOM_0_1()*screenSize.height);
        [self addChild:spider];
        [self runRandomMoveSequence:spider];        // 随机移动此火元素
    }
}
-(void) runRandomMoveSequence:(CCNode*)node
{
    float duration = CCRANDOM_0_1() * 5 + 1;
    
    CCMoveBy *move1 = [CCMoveBy actionWithDuration:duration position:CGPointMake(-180, 0)];     // 在现在位置水平左移180个单位
    CCMoveBy* move2 = [CCMoveBy actionWithDuration:duration position:CGPointMake(0, -180)];
    CCMoveBy* move3 = [CCMoveBy actionWithDuration:duration position:CGPointMake(180, 0)];
    CCMoveBy* move4 = [CCMoveBy actionWithDuration:duration position:CGPointMake(0, 180)];
    CCSequence *sequence = [CCSequence actions:move1,move2,move3,move4, nil];                   // 定义一个动作执行序列
    CCRepeatForever *repeat = [CCRepeatForever actionWithAction:sequence];                      // 该类的作用就是无限期执行某个动作或动作序列，直到被停止
    [node runAction:repeat];
}

#pragma mark 在CCLayer中经常要注册Touch Dispatcher来让Layer处理Touch事件。 Dispatcher:调度员
-(void)registerWithTouchDispatcher
{
    // 设置此层可以接受手触发事件，且priority(优先级)为0，越小优先级越高，越先接受用户触摸事件，swallow(是否可以吞没事件)为YES
    [[[CCDirector sharedDirector] touchDispatcher] addTargetedDelegate:self
                                                              priority:0
                                                       swallowsTouches:YES];
}

#pragma mark 接受用户触摸事件
-(BOOL)ccTouchBegan:(UITouch *)touch withEvent:(UIEvent *)event
{
    CCLOG(@"GameLayer: ccTouchBegan");
    lastTouchLocation = [MultiLayerScene locationFromTouch:touch];  // 得到用户触摸开始点OpenGL坐标
    [self stopActionByTag:ActionTagGameLayerMovesBack];             // 停止此时可能存在加速动作
    return YES;                                                     // 如果是NO，那么就结束触摸事件传递，ccTouchMoved、ccTouchEnded将不执行
    
}

#pragma mark 接受用户滑动事件
-(void)ccTouchMoved:(UITouch *)touch withEvent:(UIEvent *)event
{
    CCLOG(@"GameLayer: ccTouchMoved");
    CGPoint currentTouchLocaion = [MultiLayerScene locationFromTouch:touch];    // 在移动的过程中得到一系列新的目标点位
    CGPoint moveTo = ccpSub(lastTouchLocation, currentTouchLocaion);            // 得到二个点相减后的位置
    moveTo = ccpMult(moveTo, -1);                                               // 将moveTo的X，Y 都与－1相乘,得到原点将移动到新点位的值
    lastTouchLocation = currentTouchLocaion;                                    // 将现在点位更新为已经使用过的点位
    self.position = ccpAdd(self.position, moveTo);                              // 将本层原点向moveTo点位移动
}

#pragma mark 用户触摸事件结束后，本层内容恢复到原点
-(void)ccTouchEnded:(UITouch *)touch withEvent:(UIEvent *)event
{
    CCLOG(@"GameLayer: ccTouchEnded");
    CCMoveTo *move = [CCMoveTo actionWithDuration:1 position:gameLayerPosition];        // 返回原点
    CCEaseIn *ease = [CCEaseIn actionWithAction:move rate:0.5f];                        // 在0.5秒内完成move动作，且开始运行时是加速状态的
    ease.tag = ActionTagGameLayerMovesBack;                                             // 此加速动作的Tag ＝ ActionTagGameLayerMovesBack
    [self runAction:ease];
}
@end

#import <Foundation/Foundation.h>
#import "cocos2d.h"
#pragma mark 用户设置层

typedef enum
{
    UIlayerTagFrameSprite,
} UserInterfaceLayerTags;

@interface UserInterfaceLayer : CCLayer {
    
}
-(BOOL) isTouchMe:(CGPoint)touchLocation;
@end

#import "UserInterfaceLayer.h"
#import "MultiLayerScene.h"

@implementation UserInterfaceLayer
-(id)init
{
    if((self = [super init]))
    {
        CGSize screenSize = [[CCDirector sharedDirector] winSize];
        CCSprite *uiframe = [CCSprite spriteWithFile:@"ui-frame.png"];
        uiframe.position = CGPointMake(0,screenSize.height);
        uiframe.anchorPoint = CGPointMake(0, 1);
        [self addChild:uiframe z:0 tag:UIlayerTagFrameSprite];                  // 设置图片Tag ＝ UIlayerTagFrameSprite
        
        CCLabelTTF *label = [CCLabelTTF labelWithString:@"这里可以显示程序积分" fontName:@"Courier" fontSize:22];
        label.color = ccBLACK;
        label.position = CGPointMake(screenSize.width * 0.5,screenSize.height);
        label.anchorPoint = CGPointMake(0.5f, 1);
        [self addChild:label];
        self.isTouchEnabled = YES;
    }
    return self;
}

-(void) registerWithTouchDispatcher
{
    [[[CCDirector sharedDirector] touchDispatcher] addTargetedDelegate:self priority:-1 swallowsTouches:YES];
}
-(BOOL)isTouchMe:(CGPoint)touchLocation
{
    CCNode *node = [self getChildByTag:UIlayerTagFrameSprite];              // 查找到tag ＝ UIlayerTagFrameSprite 的精灵对象
    return CGRectContainsPoint([node boundingBox], touchLocation);          // 判断用户触摸点是否在node之中
}

#pragma mark 当用户触摸标题栏时，gameLayer进行一系列操作
-(BOOL)ccTouchBegan:(UITouch *)touch withEvent:(UIEvent *)event
{
    CGPoint location = [MultiLayerScene locationFromTouch:touch];                       // 得到用户点击的OpenGL坐标
    bool isTouchHandled = [self isTouchMe:location];                                    // 判断用户点击的是否为UserInteface层
    if(isTouchHandled)                                                                  // 如果 YES，那么事件将被吞没不向下层传递了

    {
        CCNode *node = [self getChildByTag:UIlayerTagFrameSprite];
        NSAssert([node isKindOfClass:[CCSprite class]], @"node is not a CCSprite");
        ((CCSprite *)node).color = ccRED;                                               // 将UserInterface层显示的字体改为红色
        
        CCScaleTo *scaleDown = [CCScaleTo actionWithDuration:2 scale:0];                // 在2秒内缩放为0，消失了
        CCScaleTo *scaleUp = [CCScaleTo actionWithDuration:2 scale:1];                  // 在2秒内还原为原来大小
        CCSequence *sequence = [CCSequence actions:scaleDown,scaleUp, nil];             // 定义包括二种缩放方式的动作序列
        sequence.tag = ActionTagGameLayerRotates;                                       // 将此序列的Tag ＝ ActionTagGameLayerRotates
        
        GameLayer *gameLayer = [MultiLayerScene sharedLayer].gameLayer;                 // 得到gameLayer层
        CCRotateBy *rotate = [CCRotateBy actionWithDuration:4 angle:360];               // 在4秒内旋转360度
        [gameLayer stopActionByTag:ActionTagGameLayerRotates];                          // 停止可能存在的缩放序列
        [gameLayer setRotation:0];                                                      // 初始化gameLayer层旋转角度为0
        [gameLayer setScale:1];                                                         // 初始化gameLayer层缩放比例为1倍，既原始大小
        [gameLayer runAction:rotate];                                                   // 执行旋转
        [gameLayer runAction:sequence];                                                 // 执行缩放
    }
    return isTouchHandled;
}

#pragma mark 用户触摸结束后恢复标题字体颜色
-(void)ccTouchEnded:(UITouch *)touch withEvent:(UIEvent *)event
{
    CCNode *node = [self getChildByTag:UIlayerTagFrameSprite];
    NSAssert([node isKindOfClass:[CCSprite class]], @"node is not a CCSprite");
    ((CCSprite *)node).color = ccWHITE;
}

-(void)dealloc
{
    CCLOG(@"%@: %@",NSStringFromSelector(_cmd),self);
    [super dealloc];
}
@end

#import <Foundation/Foundation.h>
#import "cocos2d.h"

// CCTargetedTouchDelegate，CCStandardTouchDelegate 协议将使对象支持触摸事件

@interface Spider : NSObject <CCTargetedTouchDelegate>  
{
    CCSprite *spiderSprite;         // 蜘蛛对象中有一个精灵对象
    int numUpdates;
}

+(id)spiderWithParentNode:(CCNode *)parentNode;
-(id)initWithParentNode:(CCNode *)parentNode;
@end

#import "Spider.h"
#import "MultiLayerScene.h"

@implementation Spider

#pragma mark 一个像 CCNode类一样的静态自动释放的初始化方法。这是在模仿 cocos2d 的内存管理方式。
+(id)spiderWithParentNode:(CCNode *)parentNode
{
    return [[[self alloc] initWithParentNode:parentNode] autorelease];
}

-(id)initWithParentNode:(CCNode *)parentNode
{
    if((self = [super init]))
    {
        CGSize screenSize = [[CCDirector sharedDirector] winSize];
        spiderSprite = [CCSprite spriteWithFile:@"spider.png"];
        spiderSprite.position = CGPointMake(CCRANDOM_0_1()*screenSize.width,CCRANDOM_0_1()*screenSize.height);
        [parentNode addChild:spiderSprite]; // 将预定好随机位置的蜘蛛加入到制定的节点对象(CCNode *)中
        
        // 自定义使用CCSchedule类手动预约更新方法
        [[[CCDirector sharedDirector] scheduler] scheduleUpdateForTarget:self
                                                                priority:0
                                                                  paused:NO];
        // 让这个类可以接收定向的触摸事件
        [[[CCDirector sharedDirector] touchDispatcher] addTargetedDelegate:self
                                                                  priority:-1 swallowsTouches:YES];
    }
    return self;
}

-(void)update:(ccTime)delta
{
    numUpdates ++;
    /*if(numUpdates > 50)
    {
        numUpdates = 0;
        [spiderSprite stopAllActions];
        CGPoint moveTo = CGPointMake(CCRANDOM_0_1()*200-100,CCRANDOM_0_1()*100 - 50);
        CCMoveBy *move = [CCMoveBy actionWithDuration:1 position:moveTo];
        [spiderSprite runAction:move];
    }*/
    if(numUpdates > 50)
    {
        numUpdates = 0;
        CGPoint moveTo = CGPointMake(CCRANDOM_0_1()*200-100,CCRANDOM_0_1()*100 - 50);
        [self moveAway:2 postion:moveTo];
    }
}

-(void)moveAway:(float)duration postion:(CGPoint)moveTo
{
    [spiderSprite stopAllActions];
    CCMoveBy *move = [CCMoveBy actionWithDuration:duration position:moveTo];
    [spiderSprite runAction:move];
}

- (BOOL)ccTouchBegan:(UITouch *)touch withEvent:(UIEvent *)event
{
    // CCLOG(@"Spride ccTouchBegan");
    CGPoint touchLocaion = [MultiLayerScene locationFromTouch:touch];
    BOOL isTouchHandled = CGRectContainsPoint([spiderSprite boundingBox], touchLocaion);
    if(isTouchHandled)
    {
        numUpdates = 0;
        CGPoint moveTo;
        float moveDistance = 60;
        float rand = CCRANDOM_0_1();
        if(rand < 0.25f)
        {
            moveTo = CGPointMake(moveDistance, moveDistance);
        }
        else if (rand < 0.5f)
        {
            moveTo = CGPointMake(-moveDistance, moveDistance);
        }
        else if (rand <0.75f)
        {
            moveTo = CGPointMake(moveDistance, -moveDistance);
        }
        else
        {
            moveTo = CGPointMake(-moveDistance, -moveDistance);
        }
        [self moveAway:0.1f postion:moveTo];
    }
    return isTouchHandled;
}

-(void)dealloc
{
    // scheduler要求在dealloc方法中手动解除预约的更新方法
    [[[CCDirector sharedDirector] scheduler] unscheduleUpdateForTarget:self];
    
    // CCTouchDispatcher(触摸调度程序) 也需要在dealloc方法中被移除。
    [[[CCDirector sharedDirector] touchDispatcher] removeDelegate:self];
    [super dealloc];
}