Example #1
0
Material* Material::createWithFilename(const std::string& filepath)
{
    auto validfilename = FileUtils::getInstance()->fullPathForFilename(filepath);
    if (validfilename.size() > 0) {
        auto mat = new (std::nothrow) Material();
        if (mat && mat->initWithFile(validfilename))
        {
            mat->autorelease();
            return mat;
        }
    }

    return nullptr;
}
SpriteRenderTextureBug::SimpleSprite* SpriteRenderTextureBug::SimpleSprite::create(const char* filename, const Rect &rect)
{
    auto sprite = new (std::nothrow) SimpleSprite();
    if (sprite && sprite->initWithFile(filename, rect))
    {
        sprite->autorelease();
    }
    else
    {
        CC_SAFE_DELETE(sprite);
    }
    
    return sprite;
}
Example #3
0
Status *Status::create()
{
	auto ref = new Status();
    if (ref->init())
    {
        ref->autorelease();
        return ref;
    }
    else
    {
        CC_SAFE_DELETE(ref);
        return nullptr;
    }
}
Example #4
0
EffectSprite3D* EffectSprite3D::create(const std::string &path)
{
    if (path.length() < 4)
        CCASSERT(false, "improper name specified when creating Sprite3D");
    
    auto sprite = new (std::nothrow) EffectSprite3D();
    if (sprite && sprite->initWithFile(path))
    {
        sprite->autorelease();
        return sprite;
    }
    CC_SAFE_DELETE(sprite);
    return nullptr;
}
Example #5
0
StoreSelectLayer * StoreSelectLayer::create(int money)
{
	auto storeSelectLayer = new StoreSelectLayer();
	if (storeSelectLayer && storeSelectLayer->init(money))
	{
		storeSelectLayer->autorelease();
        return storeSelectLayer;
	}
	else
	{
		CC_SAFE_DELETE(storeSelectLayer);
		return nullptr;
	}
}
ComponentLua* ComponentLua::create(const std::string& scriptFileName)
{
    CC_ASSERT(!scriptFileName.empty());
    
    initClass();
    
    auto componentLua = new(std::nothrow) ComponentLua(scriptFileName);
    if (componentLua)
    {
        componentLua->autorelease();
    }
    
    return componentLua;
}
Example #7
0
Sprite3D* Sprite3D::create(const std::string& modelPath)
{
    CCASSERT(modelPath.length() >= 4, "invalid filename for Sprite3D");
    
    auto sprite = new (std::nothrow) Sprite3D();
    if (sprite && sprite->initWithFile(modelPath))
    {
        sprite->_contentSize = sprite->getBoundingBox().size;
        sprite->autorelease();
        return sprite;
    }
    CC_SAFE_DELETE(sprite);
    return nullptr;
}
Example #8
0
PerfectMenu *PerfectMenu::createWithArray(const Vector<MenuItem*>& arrayOfItems)
{
    auto ret = new PerfectMenu();
    if (ret && ret->initWithArray(arrayOfItems))
    {
        ret->autorelease();
    }
    else
    {
        CC_SAFE_DELETE(ret);
    }
    
    return ret;
}
Example #9
0
fireBullet * fireBullet::create(){
    auto obj = new fireBullet();
    if(obj->initWithFile("bullet.png")){
        auto cirle = PhysicsBody::createCircle(obj->getContentSize().width,PhysicsMaterial(0,1,0));
        obj->setPhysicsBody(cirle);
        cirle->setContactTestBitmask(true);
        obj->autorelease();
       
        //obj->addChild(sp);
    }
    
    
    return obj;
}
Example #10
0
CrushNode* CrushNode::createByType(int pType,int x ,int y)
{
	auto t_node = new CrushNode();
	if (t_node && t_node->init(pType,x,y))
	{
		t_node->autorelease();
		return t_node;
	}
	else
	{
		CC_SAFE_DELETE(t_node);
		return nullptr;
	}
}
Example #11
0
NS_CC_BEGIN

Primitive* Primitive::create(VertexData* verts, IndexBuffer* indices, int type)
{
    auto result = new (std::nothrow) Primitive();
    if( result && result->init(verts, indices, type))
    {
        result->autorelease();
        return result;
    }
    
    CC_SAFE_DELETE(result);
    return  nullptr;
}
Example #12
0
FrameSprite *FrameSprite::create(const std::string& strImgFile, unsigned uXFrames, unsigned uYFrames, unsigned uFrameIdx)
{
	auto pRet = new FrameSprite;
	if (pRet->init(strImgFile, uXFrames, uYFrames, uFrameIdx))
	{
		pRet->autorelease();
	}
	else
	{
		delete pRet;
		pRet = nullptr;
	}
	return pRet;
}
MenuItemScale9Sprite *MenuItemScale9Sprite::create(unsigned index,cocos2d::Size contentSize,const cocos2d::ccMenuCallback& callback)
{
	auto pRet = new MenuItemScale9Sprite();
	if (pRet->init(sButtonPath[index][0],sButtonPath[index][1], sButtonPath[index][2],sBtRect[index][0],sBtRect[index][1],contentSize,callback))
	{
		pRet->autorelease();
	}
	else
	{
		delete pRet;
		pRet = nullptr;
	}
	return pRet;
}
Example #14
0
TableViewCell* CombineView::tableCellAtIndex(TableView *table, ssize_t idx)
{
	auto cell = table->dequeueCell();
	auto cellSize = this->tableCellSizeForIndex(table, idx);
	auto tag = table->getTag();

	if (!cell)
	{
		cell = new TableViewCell();
		cell->autorelease();
		Sprite * pCellBg = NULL;
		Label * pNum = NULL;
		Sprite * pIcon = NULL;
		switch (tag)
		{
		case Table_Left:
			{
				pCellBg = Sprite::create("cell.png");
				pNum = Label::createWithSystemFont("1","Arial",20);
				pIcon = Sprite::create("book.png");
			}
			break;
		case Table_Center:
			{
				pCellBg = Sprite::create("cell2.png");
				pNum = Label::createWithSystemFont("2","Arial",20);
				pIcon = Sprite::create("plane.png");
			}
			break;
		case Table_Right:
			{
				pCellBg = Sprite::create("cell3.png");
				pNum = Label::createWithSystemFont("3","Arial",20);
				pIcon = Sprite::create("setting.png");
			}
		default:
			break;
		}
		pCellBg->setPosition(Vec2(cellSize.width / 2,cellSize.height / 2));
		cell->addChild(pCellBg);
		pNum->setColor(Color3B(255,0,0));
		pNum->setPosition(Vec2(cellSize.width * 0.1,cellSize.height / 2));
		cell->addChild(pNum);
		pIcon->setPosition(Vec2(cellSize.width * 0.85,cellSize.height / 2));
		pIcon->setScale(0.2);
		cell->addChild(pIcon);
	}
	return cell;
}
void GameScene_02::creatBricks()
{
    bricks = new Vector<Brick*>;
    auto brick = Brick::create();
    float b_w = brick->getContentSize().width;
    float b_h = brick->getContentSize().height;
    int num_line = visibleSize.width / b_w;
    float offset = (visibleSize.width - num_line * b_w) / 2;
    int num_row = visibleSize.height / b_h / 2;
    int brickBf = random<int>(1, 6);
    for ( int i=0; i<num_line; i++)
    {
        for ( int j=0; j<num_row; j++)
        {
            brick->setPosition(offset + i*b_w + b_w/2, visibleSize.height - j*b_h - b_h/2 - 80 );
            int brickBf = random<int>(1, 5);
            switch (brickBf)
            {
            case 1:
                brick->setBrickBuff(NORMAL);
                break;
            case 2:
                brick->setBrickBuff(UP_SPEED);
                break;
            case 3:
                brick->setBrickBuff(DOWN_SPEED);
                break;
            case 4:
                brick->setBrickBuff(ADD_LENGTH);
                break;
            case 5:
                brick->setBrickBuff(SUB_LENGTH);
                break;
            case 6:
                brick->setBrickBuff(ADD_BALL);
            default:
                break;
            }
            bricks->pushBack(brick);
            brick->autorelease();
            brick = Brick::create();
        }
    }

    for (auto iter = bricks->begin(); iter!= bricks->end(); iter++)
    {
        this->addChild(*iter);
    }
}
Example #16
0
CallFunc * CallFunc::clone() const
    {
    // no copy constructor
    auto a = new (std::nothrow) CallFunc();
    if( _selectorTarget) {
        a->initWithTarget(_selectorTarget);
        a->_callFunc = _callFunc;
    }
    else if( _function ){
        a->initWithFunction(_function);
    }

    a->autorelease();
    return a;
}
Example #17
0
CallFuncN * CallFuncN::clone() const
{
	// no copy constructor
	auto a = new (std::nothrow) CallFuncN();

    if( _selectorTarget) {
        a->initWithTarget(_selectorTarget, _callFuncN);
    }
    else if( _functionN ){
        a->initWithFunction(_functionN);
    }

	a->autorelease();
	return a;
}
Example #18
0
RenderTargetDepthStencil* RenderTargetDepthStencil::create(unsigned int width, unsigned int height)
{
    auto result = new (std::nothrow) RenderTargetDepthStencil();
    
    if(result && result->init(width, height))
    {
        result->autorelease();
        return result;
    }
    else
    {
        CC_SAFE_DELETE(result);
        return nullptr;
    }
}
NS_CC_BEGIN

AnimationFrame* AnimationFrame::create(SpriteFrame* spriteFrame, float delayUnits, const ValueMap& userInfo)
{
    auto ret = new (std::nothrow) AnimationFrame();
    if (ret && ret->initWithSpriteFrame(spriteFrame, delayUnits, userInfo))
    {
        ret->autorelease();
    }
    else
    {
        CC_SAFE_DELETE(ret);
    }
    return ret;
}
Physics3D6DofConstraint* Physics3D6DofConstraint::create(Physics3DRigidBody* rbA, Physics3DRigidBody* rbB, const cocos2d::Mat4& frameInA, const cocos2d::Mat4& frameInB, bool useLinearReferenceFrameA)
{
    auto ret = new Physics3D6DofConstraint();
    ret->_bodyA = rbA;
    ret->_bodyB = rbB;
    rbA->retain();
    rbB->retain();
    
    auto frameA = convertMat4TobtTransform(frameInA);
    auto frameB = convertMat4TobtTransform(frameInB);
    ret->_constraint = new btGeneric6DofConstraint(*rbA->getRigidBody(), *rbB->getRigidBody(), frameA, frameB, useLinearReferenceFrameA);
    
    ret->autorelease();
    return ret;
}
Example #21
0
	PlayNoteRenderer::PlayNoteRenderer(const PlayChannelPlayer* player, Sprite* baseSprite):
		mChannelPlayer(player),
		mBaseSprite(baseSprite)
	{
		scheduleUpdate();
		autorelease();

		auto dispatcher = Director::getInstance()->getEventDispatcher();
		dispatcher->addCustomEventListener(Event::BpmEvent::CHANGED, std::bind(&PlayNoteRenderer::onBpmChanged, this, std::placeholders::_1));
		dispatcher->addCustomEventListener(Event::JudgeEvent::JUDGE, std::bind(&PlayNoteRenderer::onJudge, this, std::placeholders::_1));
		dispatcher->addCustomEventListener(Event::SpeedEvent::CHANGED, std::bind(&PlayNoteRenderer::onSpeedChanged, this, std::placeholders::_1));

		mBaseSprite->retain();
		setContentSize(Size(mBaseSprite->getContentSize().width, 0));
	}
Example #22
0
Panda *Panda::create()
{
    auto panda = new Panda();
    if(panda&&panda->initWithSpriteFrameName("taopaoxiongmao00000.png"))
    {
        panda->autorelease();
        panda->setAnchorPoint(Point::ANCHOR_MIDDLE_BOTTOM);
        panda->initAnimations();
        panda->runAction(RepeatForever::create(Animate::create(AnimationCache::getInstance()->getAnimation("taopaoxiongmao"))));
        panda->setDisplayFrameWithAnimationName("taopaoxiongmao", 1);
        return panda;
    }
    CC_SAFE_FREE(panda);
    return nullptr;
}
Example #23
0
GameOverLayer* GameOverLayer::create(bool win, int stage, int time, int kill, int loss, int newFlight)
{
    auto pRet = new GameOverLayer();
    if (pRet && pRet->init(win, stage, time, kill, loss, newFlight))
    {
        pRet->autorelease();
        return pRet;
    }
    else
    {
        delete pRet;
        pRet = NULL;
        return NULL;
    }
}
EventListenerAcceleration* EventListenerAcceleration::clone()
{
    auto ret = new (std::nothrow) EventListenerAcceleration();
    
    if (ret && ret->init(onAccelerationEvent))
    {
        ret->autorelease();
    }
    else
    {
        CC_SAFE_DELETE(ret);
    }
    
    return ret;
}
Example #25
0
Block* Block::create( TYPE type ,int x,int y)
{
	auto b = new Block();
	if (b&&b->init(type,x,y))
	{
		b->autorelease();
		return b;
	}
	else
	{
		delete b;
		b=nullptr;
		return nullptr;
	}
}
Example #26
0
UpgradeUILayer* UpgradeUILayer::create(BasePanel basePanel, int index)
{
    auto pRet = new UpgradeUILayer();
    if (pRet && pRet->init(basePanel, index))
    {
        pRet->autorelease();
        return pRet;
    }
    else
    {
        delete pRet;
        pRet = NULL;
        return NULL;
    }
}
Example #27
0
NS_CC_BEGIN

Technique* Technique::createWithGLProgramState(Material* parent, GLProgramState* state)
{
    auto technique = new (std::nothrow) Technique();
    if (technique && technique->init(parent))
    {
        auto pass = Pass::createWithGLProgramState(technique, state);
        technique->addPass(pass);

        technique->autorelease();
        return technique;
    }
    return  nullptr;
}
Example #28
0
SpriteButton* SpriteButton::create(const char* pImage , std::function<void(Ref*)> selector ,bool SwallowTouch , bool selectedStastus )
{
    auto pRet = new SpriteButton();
    if(pRet->init(pImage,selector,SwallowTouch,selectedStastus))
    {
        pRet->autorelease();
        return pRet;
    }
    else
    {
        delete pRet;
        pRet = nullptr;
        return nullptr;
    }
}
Example #29
0
Monster* Monster::create(int ID)
{
    auto monster = new Monster();
    
    if(monster && monster->init(ID)) 
    {
    	monster->autorelease();
    }
    else
    {
    	CC_SAFE_DELETE(monster);
    }
    
    return monster;
}
EventStageScene::Listener* EventStageScene::Listener::clone()
{
	auto ret = new EventStageScene::Listener;
	if (ret && ret->init())
	{
		ret->autorelease();
		ret->onLostFocus = onLostFocus;
		ret->onGainFocus = onGainFocus;
	}
	else
	{
		CC_SAFE_DELETE(ret);
	}
	return ret;
}