Question

这可能需要一些解释，但在这里，非常感谢任何见解。

简短版本：我如何创建一个TouchableButton（它自己检测触摸），其CCSprite图像是另一个类中CCSpriteBatchNode的子代？（通常，CCSprite将是TouchableButton本身的子代）。

长版：

我正在使用Cocos2d构建游戏。游戏侧重于一个充满代理（类AgentView：CCNode）的环境（类EnvironmentView：CCLayer），它们相互运行并相互交互。

EnvironmentView维护一个AgentView对象列表，并根据需要创建/销毁它们（取决于它们如何交互）。

每个AgentView都有一个CCSprite @property，它被添加为CCBatchNode（EnvironmentView的@property）的子级，它被添加为EnvironmentView的子级。

我正在尝试实现一项功能，用户可以触摸代理并将其从一个地方移动到另一个地方。

因为在EnvironmentView中有很多代理移动我不想使用标准方法获取触摸位置并循环遍历所有AgentView CCSprites以查看触摸是否触及其中一个（这会降低帧速率）请相信：对推广这种方法的答案不感兴趣）。

相反，我想将每个AgentView变成一个可触摸的节点（一个知道它何时被触摸的节点，而不是一个被触及的节点（上面提到的方法））。

基本上我想用某种TouchableButton对象替换或扩充每个AgentView的CCSprite。

我正在使用一个类（我们称之为TouchableButton），它将这种方法用于游戏中与UI相关的按钮，他们知道何时触摸它们而不在其父层中实现任何CCTouchesBegan方法。但是我一直无法使TouchableButton适应这个用例，原因如下：

TouchableButtons将CCSprite作为init参数。此CCSprite设置为按钮的可触摸部分，并添加为按钮本身的子项。因为我还将CCSprite添加为EnvironmentView中CCSpriteBatchNode的子代，所以我得到一个错误（无法将两个孩子的内容添加到两个不同的父对象中）。我如何构建事物以避免这种冲突？

提前感谢您的帮助！

Answer 1

简短回答：你不能。

答案很长：你可以得到同样的效果，但不是一样的。

CCSpriteBatchNode的工作原理是在一个glDrawElements调用中使用一个通用纹理（精灵表）绘制所有CCSprite子元素，这样就可以获得良好的性能。但结果是，每个孩子必须是一个精灵，如果你把一个孩子添加到一个精灵，它将被忽略。

所以，你现在唯一的办法是将CCSprite子类化为一个按钮并复制很多功能，如下所示：

ButtonSprite.h：

//
//  ButtonSprite.h
//  TestButtonSprite
//
//  Created by Karl Stenerud on 9/1/11.
//

#import "cocos2d.h"

@class ButtonSprite;

typedef void (^ButtonPressCallback)(ButtonSprite* button);

/**
 * A sprite that can respond to touches.
 * Most of this code was taken from CCLayer.
 */
@interface ButtonSprite : CCSprite <CCStandardTouchDelegate, CCTargetedTouchDelegate>
{
    BOOL touchEnabled_;
    int touchPriority_;
    BOOL swallowTouches_;
    BOOL registeredWithDispatcher_;

    BOOL touchInProgress_;
    BOOL buttonWasDown_;

    ButtonPressCallback onButtonPressedCallback_;
}

/** Priority position in which this node will be handled (lower = sooner) */
@property(nonatomic,readwrite,assign) int touchPriority;

/** If true, no other node will respond to touches this one responds to */
@property(nonatomic,readwrite,assign) BOOL swallowTouches;

/** If true, this node responds to touches. */
@property(nonatomic,readwrite,assign) BOOL touchEnabled;

/** Called whenever a full touch completes */
@property(nonatomic,readwrite,copy) ButtonPressCallback onButtonPressedCallback;

/** Called when a button press is detected. */
- (void) onButtonPressed;

/** Called when a button is pushed down. */
- (void) onButtonDown;

/** Called when a button is released. */
- (void) onButtonUp;

- (BOOL) touchHitsSelf:(UITouch*) touch;

- (BOOL) touch:(UITouch*) touch hitsNode:(CCNode*) node;

@end

ButtonSprite.m：

//
//  ButtonSprite.m
//  TestButtonSprite
//
//  Created by Karl Stenerud on 9/1/11.
//

#import "ButtonSprite.h"


@interface ButtonSprite ()

- (void) registerWithTouchDispatcher;
- (void) unregisterWithTouchDispatcher;

@end

@implementation ButtonSprite

@synthesize touchEnabled = touchEnabled_;
@synthesize touchPriority = touchPriority_;
@synthesize swallowTouches = swallowTouches_;
@synthesize onButtonPressedCallback = onButtonPressedCallback_;

- (id) init
{
    if(nil != (self = [super init]))
    {
        touchPriority_ = 0;
        swallowTouches_ = YES;
        touchEnabled_ = YES;

        self.isRelativeAnchorPoint = YES;
        self.anchorPoint = ccp(0.5, 0.5);
    }
    return self;
}

- (void) dealloc
{
    [self unregisterWithTouchDispatcher];
    [onButtonPressedCallback_ release];

    [super dealloc];
}

- (void) registerWithTouchDispatcher
{
    [self unregisterWithTouchDispatcher];

    [[CCTouchDispatcher sharedDispatcher] addTargetedDelegate:self priority:self.touchPriority swallowsTouches:self.swallowTouches];
    registeredWithDispatcher_ = YES;
}

- (void) unregisterWithTouchDispatcher
{
    if(registeredWithDispatcher_)
    {
        [[CCTouchDispatcher sharedDispatcher] removeDelegate:self];
        registeredWithDispatcher_ = NO;
    }
}

- (void) setSwallowTouches:(BOOL) value
{
    if(swallowTouches_ != value)
    {
        swallowTouches_ = value;

        if(isRunning_ && touchEnabled_)
        {
            [self registerWithTouchDispatcher];
        }
    }
}

- (void) setTouchPriority:(int) value
{
    if(touchPriority_ != value)
    {
        touchPriority_ = value;
        if(isRunning_ && touchEnabled_)
        {
            [self registerWithTouchDispatcher];
        }
    }
}

-(void) setTouchEnabled:(BOOL)enabled
{
    if( touchEnabled_ != enabled )
    {
        touchEnabled_ = enabled;
        if( isRunning_ )
        {
            if( touchEnabled_ )
            {
                [self registerWithTouchDispatcher];
            }
            else
            {
                [self unregisterWithTouchDispatcher];
            }
        }
    }
}

- (void)cleanup
{
    self.touchEnabled = NO;
}

#pragma mark TouchableNode - Callbacks
-(void) onEnter
{
    // register 'parent' nodes first
    // since events are propagated in reverse order
    if (self.touchEnabled)
    {
        [self registerWithTouchDispatcher];
    }

    // then iterate over all the children
    [super onEnter];
}

-(void) onExit
{
    if(self.touchEnabled)
    {
        [self unregisterWithTouchDispatcher];
    }

    [super onExit];
}

-(BOOL) ccTouchBegan:(UITouch *)touch withEvent:(UIEvent *)event
{
    if([self touchHitsSelf:touch])
    {
        touchInProgress_ = YES;
        buttonWasDown_ = YES;
        [self onButtonDown];
        return YES;
    }
    return NO;
}

-(void) ccTouchMoved:(UITouch *)touch withEvent:(UIEvent *)event
{   
    if(touchInProgress_)
    {
        if([self touchHitsSelf:touch])
        {
            if(!buttonWasDown_)
            {
                [self onButtonDown];
            }
        }
        else
        {
            if(buttonWasDown_)
            {
                [self onButtonUp];
            }
        }
    }
}

-(void) ccTouchEnded:(UITouch *)touch withEvent:(UIEvent *)event
{   
    if(buttonWasDown_)
    {
        [self onButtonUp];
    }
    if(touchInProgress_ && [self touchHitsSelf:touch])
    {
        touchInProgress_ = NO;
        [self onButtonPressed];
    }
}

-(void) ccTouchCancelled:(UITouch *)touch withEvent:(UIEvent *)event
{
    if(buttonWasDown_)
    {
        [self onButtonUp];
    }
    touchInProgress_ = NO;
}

- (void) onButtonDown
{
    buttonWasDown_ = YES;
}

- (void) onButtonUp
{
    buttonWasDown_ = NO;
}

- (void) onButtonPressed
{
    self.onButtonPressedCallback(self);
}


- (BOOL) touchHitsSelf:(UITouch*) touch
{
    return [self touch:touch hitsNode:self];
}

- (BOOL) touch:(UITouch*) touch hitsNode:(CCNode*) node
{
    CGRect r = CGRectMake(0, 0, node.contentSize.width, node.contentSize.height);
    CGPoint local = [node convertTouchToNodeSpace:touch];

    return CGRectContainsPoint(r, local);
}

@end

像这样使用它：

    ButtonSprite* myButton = [ButtonSprite spriteWithFile:@"button_image.png"];
    myButton.onButtonPressedCallback = ^(ButtonSprite* button)
    {
        NSLog(@"Pressed!");
    };
    [self addChild: myButton];

请注意，如果您在批处理节点中使用此类，则它必须没有自己的子级！

Answer 2

我自己也在努力解决这个问题，我的结论是这是不可能的，你必须为每个按钮使用单独的图像文件。

我希望这个功能会出现在1.0中，但我认为没有。

但是，希望我错了！：）

创建可触摸CCNode的问题，其CCSprites是CCBatchNode的子级

2 个答案: