/* AnimatioinクラスhitAnimation関数定義
* 返却型 : CCFiniteTimeAction
* 仮引数 : int型変数count
*/
CCFiniteTimeAction* Animation::hitAnimation(int count) {
CCDelayTime* delay = CCDelayTime::create(4); //2秒ディレイ test用
CCArray *animFrames = CCArray::create(); //CCArray型配列を初期化
CCSpriteFrameCache *cache = CCSpriteFrameCache::sharedSpriteFrameCache(); //キャッシュより指定したファイル名のインスタンスを取得しCCSpriteFrame型のオブジェクトframeに代入
/* 初期値0のint型変数iが
* count未満の間
* インクリメント
*/
for(int i=0; i<count; i++) {
CCString* fileName =
CCString::createWithFormat(count == 14 ? "hit%d.png" : "defeat%d.png", i); //countが13と同値であればhit%d.pngの、違う場合はdefeat%d.pngのファイルネームを取得しfileNameに代入
CCSpriteFrame *frame = cache->spriteFrameByName(fileName->getCString()); //キャッシュからインスタンスを取得
//インスタンスが取得できない場合(初回読み込み時まだインスタンスが生成されていない為)
if(!frame) {
CCTexture2D *texture = CCTextureCache::sharedTextureCache()->addImage(fileName->getCString()); //fileNameに一致するファイルの取得
CCRect bounds = CCRectMake(0, 0, texture->getContentSize().width, texture->getContentSize().height); //インスタンスの座標とサイズを取得
frame = CCSpriteFrame::createWithTexture(texture, bounds); //テクスチャをframeに代入
}
animFrames->addObject(frame); //インスタンスを配列に追加
}
CCAnimation* animation = CCAnimation::createWithSpriteFrames(animFrames, 0.1); //CCSpriteFrameCacheクラスの配列を引数にCCAnimationクラスのインスタンスの生成 第二引数は1フレームの時間
return CCAnimate::create(animation); //CCAnimateクラスのアクションを生成して返却
}
bool ItemLadderLR::init(CCDictionary* dict)
{
Item::init();
_type = Item::IT_LadderLR;
setPositionByProperty(dict);
// 梯子的显示
CCTexture2D* texture = CCTextureCache::sharedTextureCache()->addImage("ladder.png");
setTexture(texture);
setTextureRect(CCRectMake(0, 0, texture->getContentSize().width, texture->getContentSize().height));
Common::moveNode(this, ccp(-texture->getContentSize().width / 2, 0));
// 属性
_LorR = 1-dict->valueForKey("LorR")->intValue(); // 一开始向左还是向右
_ladderDis = dict->valueForKey("ladderDis")->intValue(); // 摆动的幅度
// 梯子一个回合已经移动过的距离
_dis = 0;
// 梯子移动速度
_speed = 20;
// 标记mario在我这个梯子上
_marioOnThisLadder = false;
return true;
}
void Image::replaceTexture(const char* filename, bool keepExactSize, bool async, bool keepRatio)
{
if(async)
{
//Note : async will be done on next update to avoid the performance drop because of the overhead of addImageAsync,
//and in case the image already exists (which loads the image synchronously)
loadingImageFile = filename;
loadingKeepExactSize = keepExactSize;
loadingKeepRatio = keepRatio;
}
else
{
std::string originalImageFile = imageFile;
imageFile = filename;
CCSprite* sprite = (CCSprite*)this->getNode();
CCSize initialSize = CCSizeMake(sprite->getContentSize().width * sprite->getScaleX(), sprite->getContentSize().height * sprite->getScaleY());
CCTexture2D* newTexture = CCTextureCache::sharedTextureCache()->addImage(imageFile.append(".png").c_str());
imageFile.erase(imageFile.length() - 4, 4);
if(newTexture == NULL)
{
newTexture = CCTextureCache::sharedTextureCache()->addImage(imageFile.append(".jpg").c_str());
imageFile.erase(imageFile.length() - 4, 4);
}
if(newTexture == NULL)
{
#if VERBOSE_WARNING
CCLog("Warning : Problem with asset : %s, texture not replaced", filename);
#endif
imageFile = originalImageFile;
return;
}
sprite->setTexture(newTexture);
CCRect textureRect = CCRectMake(0, 0, newTexture->getContentSize().width, newTexture->getContentSize().height);
//Change the textureRect to crop it if necessary
if(keepRatio && initialSize.width / initialSize.height != textureRect.size.width / textureRect.size.height)
{
//initial is wider, crop top and bottom
if(initialSize.width / initialSize.height > textureRect.size.width / textureRect.size.height)
{
float excessHeight = textureRect.size.height - initialSize.height / initialSize.width * textureRect.size.width;
textureRect.origin.y = excessHeight/2;
textureRect.size.height -= excessHeight;
}
//initial is taller, crop the sides
else
{
float excessWidth = textureRect.size.width - initialSize.width / initialSize.height * textureRect.size.height;
textureRect.origin.x = excessWidth/2;
textureRect.size.width -= excessWidth;
}
}
sprite->setTextureRect(textureRect);
if(keepExactSize)
{
sprite->setScale(MIN(initialSize.width / sprite->getContentSize().width,
initialSize.height / sprite->getContentSize().height));
}
}
}
void Rope::changeImageByStatus(int _status, Hanger * _hanger)
{
status = _status;
CCTexture2D *pTexture;
CCRect rect;
// 添加根据状态换图的代码 (注意添加这里width 和 height跟随图片的宽高变换)
switch(status)
{
case ROPE_STATUS_NORMAL:
pTexture = CCTextureCache::sharedTextureCache()->addImage("youxi/shenzi.png");
if (pTexture)
{
rect = CCRectZero;
rect.size = pTexture->getContentSize();
setTexture(pTexture);
setTextureRect(rect);
}
lengthOriginal = getContentSize().height * 0.8;
break;
case ROPE_STATUS_THROW:
pTexture = CCTextureCache::sharedTextureCache()->addImage("youxi/shenzi2.png");
if (pTexture)
{
rect = CCRectZero;
rect.size = pTexture->getContentSize();
setTexture(pTexture);
setTextureRect(rect);
}
lengthOriginal = getContentSize().height * 0.8;
scaleExchange = ROPE_EXCHANGE_CONTROL_THROW;
break;
case ROPE_STATUS_INTERSECT:
pTexture = CCTextureCache::sharedTextureCache()->addImage("youxi/shenzi3.png");
if (pTexture)
{
rect = CCRectZero;
rect.size = pTexture->getContentSize();
setTexture(pTexture);
setTextureRect(rect);
}
lengthOriginal = getContentSize().height * 0.8;
break;
case ROPE_STATUS_PULL:
pTexture = CCTextureCache::sharedTextureCache()->addImage("youxi/shenzi4.png");
if (pTexture)
{
rect = CCRectZero;
rect.size = pTexture->getContentSize();
setTexture(pTexture);
setTextureRect(rect);
}
lengthOriginal = getContentSize().height * 0.8;
break;
default:
break;
}
changePosition(_hanger);
}
void _AtlasPage_createTexture (AtlasPage* self, const char* path) {
CCTexture2D* texture = CCTextureCache::sharedTextureCache()->addImage(path);
CCTextureAtlas* textureAtlas = CCTextureAtlas::createWithTexture(texture, 4);
textureAtlas->retain();
self->rendererObject = textureAtlas;
// Using getContentSize to make it supports the strategy of loading resources in cocos2d-x.
// self->width = texture->getPixelsWide();
// self->height = texture->getPixelsHigh();
self->width = texture->getContentSize().width;
self->height = texture->getContentSize().height;
}
void UICenterItem::startProcess()
{
valid = false;
// 创建一个动画 自身播放时间到后将valid 设置为true
CCAnimation* animation = CCAnimation::create();
std::string frameNames[] = {
std::string("skill_p_00000.png"),
std::string("skill_p_00001.png"),
std::string("skill_p_00002.png"),
std::string("skill_p_00003.png"),
std::string("skill_p_00004.png"),
std::string("skill_p_00005.png"),
};
for (int i = 0; i < 3; i++)
{
CCTexture2D *texture = CCTextureCache::sharedTextureCache()->addImage(frameNames[i].c_str());
CCSpriteFrame *frame = CCSpriteFrame::frameWithTexture(texture,CCRectMake(0,0,texture->getContentSize().width,texture->getContentSize().height));
animation->addSpriteFrame(frame);
}
CCSprite * temp = CCSprite::create();
this->getParent()->addChild(temp);
temp->setPosition(this->getPosition());
animation->setDelayPerUnit(1.5f / 2);
animation->setRestoreOriginalFrame(true);
temp->runAction(CCSequence::create(CCAnimate::create(animation),
CCCallFuncND::create(this, callfuncND_selector(UICenterItem::actionEnd_setValid), (void*)temp),NULL));
}
ToyBrick* ToyLayer::CreateBrick_Circle()
{
int num = CommonHelper::GetRandomNum(1, 30);
//image && texture
char path[255];
sprintf(path, "Images/ToyBrick/Circle/%d.png", num);
CCImage *img = new CCImage();
img->autorelease();
if (!img->initWithImageFile(path, cocos2d::CCImage::kFmtPng))
{
return NULL;
}
CCTexture2D *texture = new CCTexture2D();
texture->autorelease();
if (!texture->initWithImage(img))
{
return NULL;
}
//
ToyBrick *brick = ToyBrick::create();
CCSize size = texture->getContentSize();
brick->Init(texture, CCRectMake(0, 0, size.width, size.height));
brick->SetAsCircle(64);
return brick;
}
bool HeXieBag::init(const CCSize &size,const char *pngName)
{
this->_eachHeight = 64;
this->_eachWidth = 64;
this->_width = size.width;
this->_height = size.height;
_items.resize(this->_width* this->_height);
_eachLeftSpan = 1;
_eachUpSpan = 1;
// 将图片打乱放置于BAG上
CCTexture2D *pTexture = CCTextureCache::sharedTextureCache()->addImage(pngName);
CCSize imgSize = pTexture->getContentSize();
eachSize = CCSizeMake(imgSize.width / this->_width,imgSize.height / this->_height);
for (int i = 0; i < size.width ;i++)
for (int j = 0; j < size.height;j++)
{
HeXieItem*item = HeXieItem::create(pTexture,
CCRectMake(i * eachSize.width,j * eachSize.height,eachSize.width,eachSize.height));
int id = (size.height - j -1) * size.width + i;
this->setItem(item,id);
item->positionId = id;
}
show();
return true;
}
CCSpriteFrame * UICenterItem::getFrameByFileName(const char *pngName)
{
CCTexture2D *texture = CCTextureCache::sharedTextureCache()->addImage(pngName);
CCSpriteFrame *frame = CCSpriteFrame::frameWithTexture(texture,CCRectMake(0,0,texture->getContentSize().width,texture->getContentSize().height));
return frame;
}
ToyBrick* DancingBoneLayer::CreateArm()
{
//image && texture
char path[255];
sprintf(path, "Images/DancingBone/arm.png");
CCImage *img = new CCImage();
img->autorelease();
if (!img->initWithImageFile(path, CCImage::kFmtPng))
{
return NULL;
}
CCTexture2D *texture = new CCTexture2D();
texture->autorelease();
if (!texture->initWithImage(img))
{
return NULL;
}
//
ToyBrick *brick = ToyBrick::create();
CCSize size = texture->getContentSize();
brick->Init(texture, CCRectMake(0, 0, size.width, size.height));
//vector (24, 102)
CCPointArray *vector = CCPointArray::create(4);
vector->addControlPoint(ccp(-12, -50));
vector->addControlPoint(ccp(12, -50));
vector->addControlPoint(ccp(12, 50));
vector->addControlPoint(ccp(-12, 50));
brick->SetAsPolygon(vector);
return brick;
}
void CCAnimation::addFrameWithFileName(const char *pszFileName)
{
CCTexture2D *pTexture = CCTextureCache::sharedTextureCache()->addImage(pszFileName);
CCRect rect = CCRectZero;
rect.size = pTexture->getContentSize();
CCSpriteFrame *pFrame = CCSpriteFrame::frameWithTexture(pTexture, rect);
m_pobFrames->addObject(pFrame);
}
bool ItemFlagPoint::init(CCDictionary* dict)
{
Item::init();
_Flag = this;
_type = Item::IT_flagpoint;
setPositionByProperty(dict);
CCTexture2D* texture = CCTextureCache::sharedTextureCache()->addImage("flag.png");
setTexture(texture);
setTextureRect(CCRect(0, 0, texture->getContentSize().width, texture->getContentSize().height));
Common::moveNode(this, ccp(-texture->getContentSize().width / 2, 0));
return true;
}
void VRope::createRope(cocos2d::CCPoint pointA, cocos2d::CCPoint pointB, float ropeLenght) {
float distance;
if (ropeLenght < 0) {
distance = ccpDistance(pointA,pointB);
}else{
distance = ropeLenght;
}
int segmentFactor = RopeSegmentFactor; //increase value to have less segments per rope, decrease to have more segments
numPoints = distance/segmentFactor;
mRopeLength = segmentFactor * numPoints;
CCPoint diffVector = ccpSub(pointB,pointA);
float multiplier = distance / (numPoints-1);
antiSagHack = 0.1f; //HACK: scale down rope points to cheat sag. set to 0 to disable, max suggested value 0.1
for(int i=0;i<numPoints;i++) {
CCPoint tmpVector = ccpAdd(pointA, ccpMult(ccpNormalize(diffVector),multiplier*i*(1-antiSagHack)));
VPoint* tmpPoint = new VPoint;
tmpPoint->setPos(tmpVector.x, tmpVector.y);
vPoints.insert(vPoints.end(), tmpPoint);
}
for(int i=0;i<numPoints-1;i++) {
VStick tmpStick;
tmpStick.initWith(vPoints[i], vPoints[i+1]);
vSticks.insert(vSticks.end(), tmpStick);
}
if(spriteSheet!=NULL) {
for(int i=0;i<numPoints-1;i++) {
VPoint* point1 = vSticks[i].getPointA();
VPoint* point2 = vSticks[i].getPointB();
CCPoint stickVector = ccpSub(ccp(point1->x,point1->y),ccp(point2->x,point2->y));
float stickAngle = ccpToAngle(stickVector);
CCTexture2D* texture = spriteSheet->getTexture();
RecordSprite* tmpSprite = new RecordSprite;
tmpSprite->setTag(Tag_Box_RopeBatchSprite);
tmpSprite->autorelease();
tmpSprite->initWithTexture(texture, CCRectMake(0,0,multiplier,texture->getContentSize().height));
ccTexParams params = {GL_LINEAR,GL_LINEAR,GL_REPEAT,GL_REPEAT};
tmpSprite->getTexture()->setTexParameters(¶ms);
tmpSprite->setPosition(ccpMidpoint(ccp(point1->x,point1->y),ccp(point2->x,point2->y)));
tmpSprite->setRotation(-1 * CC_RADIANS_TO_DEGREES(stickAngle));
spriteSheet->addChild(tmpSprite);
ropeSprites.insert(ropeSprites.end(), tmpSprite);
}
//// LiFeng 添加
//ropeSprites[ropeSprites.size()-1]->setOpacity(100);
}else{
CCAssert(false, "not init");
}
}
void MyTableViewCell::setImagePath(const char* path)
{
CCTexture2D *tex = CCTextureCache::sharedTextureCache()->addImage(path);
m_imageSprite->setTexture(tex);
CCSize contentSize = tex->getContentSize();
m_imageSprite->setTextureRect(CCRectMake(0, 0,
contentSize.width, contentSize.height));
needsLayout();
}
void AchievementNotification::showImmediately(Achievement a)
{
mShowing = true;
CCTexture2D* tex = CCTextureCache::sharedTextureCache()->textureForKey(fileName.c_str());
if (tex == NULL)
{
tex = CCTextureCache::sharedTextureCache()->addImage(fileName.c_str());
}
CCSize winSize = CCDirector::sharedDirector()->getWinSize();
CCScale9Sprite* pBoard = CCScale9Sprite::create(CCRectMake(tex->getContentSize().width/2, 0, 2, tex->getContentSize().height), fileName.c_str());
addChild(pBoard,0,Tag_Board);
pBoard->setPosition(ccp(winSize.width/2,winSize.height + pBoard->getContentSize().height) );
CCSprite* pJinBei = CCSprite::create(ResManager::getManager()->getFilePath(g_public+"CJ_icon_jiangbei.png").c_str());
pBoard->addChild(pJinBei, 1);
pJinBei->setPosition(ccp(pJinBei->getContentSize().width, pBoard->getContentSize().height/2));
CCLabelTTF* pName = CCLabelTTF::create(a.name.c_str(), fontStr_KlavikaBold, 40);
pName->setColor(fontColor_Acheivement_TTF);
CCSprite* pIcon = CCSprite::create(ResManager::getManager()->getFilePath(g_public+"CJ_icon_wancheng.png").c_str());
int x = pName->getContentSize().width + pIcon->getContentSize().width - 420;
if (x > 0)
{
pBoard->setContentSize(ccp(pBoard->getContentSize().width+x, pBoard->getContentSize().height));
}
pBoard->addChild(pName);
int xoffset = 10;
pName->setPosition(ccp(pBoard->getContentSize().width/2 + pIcon->getContentSize().width/2 + xoffset, pBoard->getContentSize().height/2));
pBoard->addChild(pIcon);
pIcon->setPosition(ccp(pName->getPositionX() - pName->getContentSize().width/2 - pIcon->getContentSize().width/2 - xoffset, pName->getPositionY()));
Achievement* achievementCopy = new Achievement(a);
// *achievementCopy = a;
temp_Must_Delete.insert(temp_Must_Delete.end(),achievementCopy);
pBoard->runAction(CCSequence::create(
CCMoveTo::create(0.5f,ccp(pBoard->getPositionX(),winSize.height-pBoard->getContentSize().height/2)),
CCDelayTime::create(0.1f),
CCCallFuncND::create(this,SEL_CallFuncND(&AchievementNotification::boardShowing),achievementCopy),
CCDelayTime::create(1.3f),
CCMoveTo::create(0.2f,ccp(pBoard->getPositionX(),winSize.height+pBoard->getContentSize().height)),
CCFadeTo::create(0.1f,0),
CCCallFuncN::create(this,SEL_CallFuncN(&AchievementNotification::boardShowEnd)),NULL));
createPar(ccp(winSize.width/2,winSize.height),parFileName.c_str(),pBoard->getContentSize().width * 1.2f,pBoard->getContentSize().height);
Music::sharedMusicPlayer()->playEffectSound("achievement.wav");
CCLog("AchievementNotification::showImmediately name = %s" ,a.name.c_str());
}
void CSharpTollgate::setStageList(const vector<CStage>& stageList, int chapter, int openChapter)
{
m_stageList = stageList;
m_chapter = chapter;
m_openChapter = openChapter;
m_tableView->setCountOfCell(stageList.size());
m_tableView->reloadData();
CTableViewCell *cell = m_tableView->cellAtIndex(3);
cell->setPositionX(cell->getPositionX()+115);
CImageView *name = (CImageView*)(m_ui->findWidgetById("name"));
CCTexture2D *texture = CCTextureCache::sharedTextureCache()->addImage(CCString::createWithFormat("tollgate/chapter_%d.png",chapter)->getCString());
if(!texture)
{
texture = CCTextureCache::sharedTextureCache()->addImage("tollgate/chapter_1.png");
}
name->setTexture(texture);
name->setTextureRect(CCRectMake(0,0,texture->getContentSize().width,texture->getContentSize().height));
}
bool ItemFireString::init(CCDictionary * dict)
{
Item::init();
_type = IT_FIRESTRING;
setPositionByProperty(dict);
CCTexture2D * bossBullet = CCTextureCache::sharedTextureCache()->addImage("bossBullet.png");
setTexture(bossBullet);
setTextureRect(CCRectMake(0, 0, bossBullet->getContentSize().width, bossBullet->getContentSize().height));
setScale(.6f);
setAnchorPoint(ccp(0, 0.5f));
int begAngle = dict->valueForKey("begAngle")->intValue();
setRotation(begAngle);
int time = dict->valueForKey("time")->intValue();
runAction(CCRepeatForever::create(CCRotateBy::create(time, 360)));
return true;
}
CCMenuItemImage* TMenuItemImage::create(const char *img, CCObject* target, SEL_MenuHandler selector)
{
CCMenuItemImage *pRet = new TMenuItemImage();
CCTexture2D* ptex = CCTextureCache::sharedTextureCache()->addImage( img );
int tw = ptex->getContentSize().width / 4;
int th = ptex->getContentSize().height;
CCNode* normal = CCSprite::createWithTexture( ptex, CCRect(0, 0, tw, th ) );
CCNode *selected = CCSprite::createWithTexture(ptex, CCRect( tw*2, 0, tw, th) );
CCNode *disabled = CCSprite::createWithTexture( ptex, CCRect( tw*3, 0, tw, th) );
pRet->initWithNormalSprite(normal, selected, disabled, target, selector);
pRet->autorelease();
return pRet;
}
// on "init" you need to initialize your instance
bool MainMenuScene::init()
{
CCSprite *fondo = CCSprite::create("fondo.png");
fondo->setPosition(VisibleRect::center());
addChild(fondo);
CCSprite *leftGrass = CCSprite::create("grass_left.png");
leftGrass->setAnchorPoint(ccp(0,0));
leftGrass->setPosition(VisibleRect::leftBottom());
addChild(leftGrass);
CCSprite *rightGrass = CCSprite::create("grass_right.png");
rightGrass->setAnchorPoint(ccp(1,0));
rightGrass->setPosition(VisibleRect::rightBottom());
addChild(rightGrass);
CCSprite *spriteLogo = CCSprite::create("logo_opciones.png");
spriteLogo->setPosition(ccp(VisibleRect::center().x, (VisibleRect::top().y - (spriteLogo->getContentSize().height / 2) - 20)));
addChild(spriteLogo);
int mySize = VisibleRect::center().y / 3;
CCTexture2D *texture = CCTextureCache::sharedTextureCache()->addImage("botoia_normal.png");
CCPoint anchorPoint = ccp(0.5f, 0.5f);
CCLabelTTF *pLabel1 = CCLabelTTF::create("Jokatu", "fonts/PT_Sans-Web-Bold.ttf", 30.0);
CCLabelTTF *pLabel2 = CCLabelTTF::create("Sailkapena", "fonts/PT_Sans-Web-Bold.ttf", 30.0);
CCLabelTTF *pLabel3 = CCLabelTTF::create("Honi Buruz", "fonts/PT_Sans-Web-Bold.ttf", 30.0);
// Button JOKATU
SpriteButton *pButton1 = SpriteButton::create(texture ,this, callfuncO_selector(MainMenuScene::menuSelector), 1.0f);
pButton1->setTag(1);
pButton1->setAnchorPoint(anchorPoint);
pButton1->setPosition(ccp(VisibleRect::center().x, (mySize * 3) - texture->getContentSize().height /2));
pLabel1->setPosition(ccp(VisibleRect::center().x, (mySize * 3) - texture->getContentSize().height /2));
// Button SAILKAPENA
SpriteButton *pButton2 = SpriteButton::create(texture ,this, callfuncO_selector(MainMenuScene::menuSelector), 1.0f);
pButton2->setTag(2);
pButton2->setAnchorPoint(anchorPoint);
pButton2->setPosition(ccp(VisibleRect::center().x, (mySize * 2) - texture->getContentSize().height /2));
pLabel2->setPosition(ccp(VisibleRect::center().x, (mySize * 2) - texture->getContentSize().height /2));
// Button HONI BURUZ
SpriteButton *pButton3 = SpriteButton::create(texture ,this, callfuncO_selector(MainMenuScene::menuSelector), 1.0f);
pButton3->setTag(3);
pButton3->setAnchorPoint(anchorPoint);
pButton3->setPosition(ccp(VisibleRect::center().x, mySize - texture->getContentSize().height /2));
pLabel3->setPosition(ccp(VisibleRect::center().x, mySize - texture->getContentSize().height /2));
addChild(pButton1);
addChild(pLabel1);
addChild(pButton2);
addChild(pLabel2);
addChild(pButton3);
addChild(pLabel3);
return true;
}
bool BlurSprite::initWithFile(const char* filename)
{
CCAssert(filename != NULL, "Invalid filename for sprite");
CCTexture2D *pTexture = CCTextureCache::sharedTextureCache()->addImage(filename);
if (pTexture)
{
CCRect rect = CCRectZero;
rect.size = pTexture->getContentSize();
return initWithTexture(pTexture, rect);
}
return false;
}
CCSpriteFrame * CCNodeLoader::parsePropTypeSpriteFrame(CCNode * pNode, CCNode * pParent, CCBReader * pCCBReader, const char *pPropertyName)
{
CCString * spriteSheet = pCCBReader->readCachedString();
CCString * spriteFile = pCCBReader->readCachedString();
CCSpriteFrame *spriteFrame = NULL;
if (spriteFile->length() != 0)
{
if (spriteSheet->length() == 0)
{
CCTexture2D * texture = CCTextureCache::sharedTextureCache()->addImage(spriteFile->getCString());
CCRect bounds = CCRectMake(0, 0, texture->getContentSize().width, texture->getContentSize().height);
spriteFrame = CCSpriteFrame::createWithTexture(texture, bounds);
}
else
{
CCSpriteFrameCache * frameCache = CCSpriteFrameCache::sharedSpriteFrameCache();
// Load the sprite sheet only if it is not loaded
if (pCCBReader->getLoadedSpriteSheet().find(spriteSheet->getCString()) == pCCBReader->getLoadedSpriteSheet().end())
{
frameCache->addSpriteFramesWithFile(spriteSheet->getCString());
pCCBReader->getLoadedSpriteSheet().insert(spriteSheet->getCString());
}
spriteFrame = frameCache->spriteFrameByName(spriteFile->getCString());
}
if (pCCBReader->getAnimatedProperties()->find(pPropertyName) != pCCBReader->getAnimatedProperties()->end())
{
pCCBReader->getAnimationManager()->setBaseValue(spriteFrame, pNode, pPropertyName);
}
}
return spriteFrame;
}
bool CCSprite::initWithFile(const char *pszFilename)
{
CCAssert(pszFilename != NULL, "Invalid filename for sprite");
CCTexture2D *pTexture = CCTextureCache::sharedTextureCache()->addImage(pszFilename);
if (pTexture)
{
CCRect rect = CCRectZero;
rect.size = pTexture->getContentSize();
return initWithTexture(pTexture, rect);
}
// don't release here.
// when load texture failed, it's better to get a "transparent" sprite then a crashed program
// this->release();
return false;
}
NS_CC_BEGIN
void TFFrameInfo::getFrames(std::vector<CCSpriteFrame*> &frames)
{
frames.clear();
for ( std::vector<std::string>::iterator iter = pngs.begin(); iter != pngs.end();++iter)
{
std::string &pngName = *iter;
CCTexture2D *texture = CCTextureCache::sharedTextureCache()->addImage(pngName.c_str());
CCSpriteFrame *frame = CCSpriteFrame::frameWithTexture(texture,CCRectMake(0,0,texture->getContentSize().width,texture->getContentSize().height));
if (frame)
{
frames.push_back(frame);
frame->retain();
frame->setOffset(ccp(0,0));
}
}
}
bool DefaultLayer::init()
{
if (!CCLayer::init())
return false;
// ask director the window size
CCSize window_size = CCDirector::sharedDirector()->getWinSize();
CCImage* temp_img = new CCImage();
temp_img->initWithImageFile("atlas.png");
CCTexture2D* texture = new CCTexture2D();
texture->initWithImage(temp_img);
texture->autorelease();
delete temp_img;
// this will have a capacity for 4 sprites instead of the default which is 20
CCSpriteBatchNode* batch = CCSpriteBatchNode::createWithTexture(texture, 4);
// Since I don't have HD versions of the image but I've set enableRetinaDisplay to true, the framework
// is using a scaling factor of 2 to divide the image by. This is because it thinks the image was from the low resolution
// version, which would mean that running in retina (i.e. 2x larger screen) should make the image look half as big. By calling
// getContentSize over getContentSizeInPixels I'm getting the size of the image as it is represented for the appropriate
// draw mode. If I actually had HD art, I believe I could just call getContentSizeInPixels and that they'd both be the same.
CCSize tex_size(texture->getContentSize());
for (int i = 0; i < 4; i++)
{
CCSprite* sprite = CCSprite::create();
// The texture rect coords are luckily normal and just like a Photoshop canvas
CCRect r((i % 2) == 0 ? 0 : tex_size.width / 2.0f, (i / 2) == 0 ? 0 : tex_size.height / 2.0f, tex_size.width/2.0f, tex_size.height/2.0f);
sprite->initWithTexture(texture, r);
sprite->setPosition(ccp(sprite->getContentSize().width / 2.0f + (i % 2)*200, sprite->getContentSize().height + (i/2)*150));
batch->addChild(sprite);
}
addChild(batch);
return true;
}
CCTexture2D* getTexture(std::string theImageFullPath, CCRect& theTextureRect){
// try to load from sprite sheet
std::string anImageFileName;
int aLastSlashIndex = MAX((int)theImageFullPath.find_last_of('/'), (int)theImageFullPath.find_last_of('\\'));
if (aLastSlashIndex != std::string::npos) {
anImageFileName = theImageFullPath.substr(aLastSlashIndex + 1);
} else {
anImageFileName = theImageFullPath;
}
CCSpriteFrame *aSpriteFrame = CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(anImageFileName.c_str());
if (aSpriteFrame) {
theTextureRect = aSpriteFrame->getRect();
return aSpriteFrame->getTexture();
}
CCTexture2D* aTexture = CCTextureCache::sharedTextureCache()->addImage(theImageFullPath.c_str());
theTextureRect.origin = CCPointZero;
theTextureRect.size = aTexture->getContentSize();
return aTexture;
}
// Loads a texture frame from a file
CCSpriteFrame *CocosTile::loadSpriteFrame(std::string filename)
{
// First attempt to get it from the frame cache, in case it was already loaded from an atlas
CCSpriteFrame *retVal = CCSpriteFrameCache::sharedSpriteFrameCache()->spriteFrameByName(filename.c_str());
// If not found, create the frame by loading texture
if (!retVal)
{
CCTexture2D *frameTexture = CCTextureCache::sharedTextureCache()->addImage(filename.c_str());
if (frameTexture)
{
retVal = CCSpriteFrame::frameWithTexture(frameTexture,
CCRect(0, 0, frameTexture->getContentSize().width, frameTexture->getContentSize().height));
// Add to frame cache
CCSpriteFrameCache::sharedSpriteFrameCache()->addSpriteFrame(retVal, filename.c_str());
}
}
return retVal;
}
ToyBrick* ToyLayer::CreateBrick_Rectangle()
{
int num = CommonHelper::GetRandomNum(1, 20);
//image && texture
char path[255];
sprintf(path, "Images/ToyBrick/Rectangle/%d.png", num);
CCImage *img = new CCImage();
img->autorelease();
if (!img->initWithImageFile(path, cocos2d::CCImage::kFmtPng))
{
return NULL;
}
CCTexture2D *texture = new CCTexture2D();
texture->autorelease();
if (!texture->initWithImage(img))
{
return NULL;
}
//
ToyBrick *brick = ToyBrick::create();
CCSize size = texture->getContentSize();
brick->Init(texture, CCRectMake(0, 0, size.width, size.height));
//vector
CCPointArray *vector = CCPointArray::create(4);
vector->addControlPoint(ccp(-52, -52));
vector->addControlPoint(ccp(52, -52));
vector->addControlPoint(ccp(52, 52));
vector->addControlPoint(ccp(-52, 52));
brick->SetAsPolygon(vector);
return brick;
}
InputPad() {
_pad = CCSprite::create(s_InputPad);
this->addChild(_pad,Z_INPUTPAD);
CCTexture2D* gridTexture = CCTextureCache::sharedTextureCache()->addImage(s_GridUp);
CCSize s = gridTexture->getContentSize();
CCPoint gridOrigin(ccp(0,0));
for(int i=0;i<ROW_NUM;i++) {
for(int j=0;j<COL_NUM;j++) {
Grid* pGrid = Grid::GridWithTexture(gridTexture,(i*COL_NUM+j+1),true);
float x = gridOrigin.x+j*(g_gridSize.width+1)+1;
float y = gridOrigin.y+i*(g_gridSize.height+1)+1;
//CCLOG("input grid:x:%0.1f, y:%0.1f",x,y);
pGrid->GetNode()->setPosition(ccp(x,y));
pGrid->GetNode()->setAnchorPoint(ccp(0.0f,0.0f));
_pad->addChild(pGrid->GetNode(), Z_INPUT_GRID_NUMBER);
}
}
//CCLayerColor* pBackGround = CCLayerColor::create(ccc4(255,255,0,255),90,90);
//this->addChild(pBackGround,0);
}
void Recipe44::makeSprite() {
CCSize size = CCDirector::sharedDirector()->getWinSize();
// 元画像のテクスチャを作成
CCTexture2D *pTexture = CCTextureCache::sharedTextureCache()->addImage("sample.png");
// 元画像のサイズを取得
CCRect rect = CCRectZero;
rect.size = pTexture->getContentSize();
// 左半分のスプライトを生成
CCRect leftRect = CCRectMake(rect.origin.x, rect.origin.y, rect.size.width/2.0f, rect.size.height);
CCSprite* spriteL = CCSprite::createWithTexture(pTexture, leftRect);
CCPoint pointL = ccp(spriteL->getContentSize().width/2, size.height/4*3);
spriteL->setPosition(pointL);
this->addChild(spriteL);
// 右半分のスプライトを生成
CCRect rightRect = CCRectMake(rect.origin.x+rect.size.width/2, rect.origin.y, rect.size.width/2.0f, rect.size.height);
CCSprite* spriteR = CCSprite::createWithTexture(pTexture, rightRect);
CCPoint pointR = ccp(size.width-spriteR->getContentSize().width/2, size.height/4*3);
spriteR->setPosition(pointR);
this->addChild(spriteR);
}
void SpriteStone::initStone(int id)
{
struct
{
TYPE type;
int row;
int col;
} proper[9] = {
{ CHE, 0, 0 },
{ MA, 0, 1 },
{ XIANG, 0, 2 },
{ SHI, 0, 3 },
{ BING, 3, 2 },
{ BING, 3, 0 },
{ PAO, 2, 1 },
{ JIANG, 0, 4 },
{ BING, 3, 4 }
};
_id = id;
_red = id < 16;
if (id <= 8)
{
this->_row = proper[id].row;
this->_col = proper[id].col;
this->_type = proper[id].type;
}
if (id > 8 && id < 16)
{
int index = id - 9;
this->_row = proper[index].row;
this->_col = 8 - proper[index].col;
this->_type = proper[index].type;
}
if (id >= 16)
{
int index = id - 16;
if (index <= 8)
{
this->_row = 9 - proper[index].row;
this->_col = 8 - proper[index].col;
this->_type = proper[index].type;
}
if (index > 8)
{
index -= 9;
this->_row = 9 - proper[index].row;
this->_col = proper[index].col;
this->_type = proper[index].type;
}
}
// 显示在屏幕上
CCTexture2D * texture;
switch (_type)
{
case SpriteStone::CHE:
if (_red)
texture = CCTextureCache::sharedTextureCache()->addImage("rche.png");
else
texture = CCTextureCache::sharedTextureCache()->addImage("bche.png");
break;
case SpriteStone::MA:
if (_red)
texture = CCTextureCache::sharedTextureCache()->addImage("rma.png");
else
texture = CCTextureCache::sharedTextureCache()->addImage("bma.png");
break;
case SpriteStone::PAO:
if (_red)
texture = CCTextureCache::sharedTextureCache()->addImage("rpao.png");
else
texture = CCTextureCache::sharedTextureCache()->addImage("bpao.png");
break;
case SpriteStone::BING:
if (_red)
texture = CCTextureCache::sharedTextureCache()->addImage("rbing.png");
else
texture = CCTextureCache::sharedTextureCache()->addImage("bzu.png");
break;
case SpriteStone::JIANG:
if (_red)
texture = CCTextureCache::sharedTextureCache()->addImage("rshuai.png");
else
texture = CCTextureCache::sharedTextureCache()->addImage("bjiang.png");
break;
case SpriteStone::SHI:
if (_red)
texture = CCTextureCache::sharedTextureCache()->addImage("rshi.png");
else
texture = CCTextureCache::sharedTextureCache()->addImage("bshi.png");
break;
case SpriteStone::XIANG:
if (_red)
texture = CCTextureCache::sharedTextureCache()->addImage("rxiang.png");
else
texture = CCTextureCache::sharedTextureCache()->addImage("bxiang.png");
break;
}
// 显示纹理
setTexture(texture);
setTextureRect(CCRectMake(0, 0, texture->getContentSize().width, texture->getContentSize().height));
// 设置位置
setPosition(fromPlate());
// 缩放
setScale(_scaleValue);
}
