void* LoadingLayer::updateInfo(void* args)
{
// 开线程加载plist文件，将plist加载到CCSpriteFrameCache
CCSpriteFrameCache *cache = CCSpriteFrameCache::sharedSpriteFrameCache();
CCTextureCache* teCache = CCTextureCache::sharedTextureCache();
for (int i=0; i<m_staticYPlist->count() * 0.5; i++)
{
const char* m_pngFullPath = ((CCString* )m_staticYPlist->objectAtIndex(i))->getCString();
const char* m_plistFullPath = ((CCString* )m_staticYPlist->objectAtIndex(i + m_staticYPlist->count() * 0.5))->getCString();
// CCLog("m_pngFullPath:%s", m_pngFullPath);
// CCLog("m_plistFullPath:%s", m_plistFullPath);
CCTexture2D* texture = teCache->textureForKey(m_pngFullPath);
cache->addSpriteFramesWithFile(m_plistFullPath, texture);
// 删除纹理
teCache->removeTextureForKey(m_pngFullPath);
}
// 可以异步加载数据 m_target为空，就跳过
if (m_instance->m_target)
{
if (m_instance->m_callFuncData)
{
(m_instance->m_target->*m_instance->m_callFuncData)();
}
}
m_instance->isOver = true;
// m_taxiBus->runAction(CCSequence::create(
// CCMoveTo::create(0.7, ccp(m_moveLength, m_taxiBus->getPosition().y)),
// CCCallFunc::create(m_instance, callfunc_selector(LoadingLayer::loadingSuccessful)),
// NULL));
return NULL;
}
// on "init" you need to initialize your instance
bool HelloWorld::init()
{
//////////////////////////////
// 1. super init first
if ( !CCLayer::init() )
{
return false;
}
CCTextureCache *cache = CCTextureCache::sharedTextureCache();
//support spx
spx = CCSPXSprite::create("spx_test.sprite", cache->addImage("spx_test.png"), 0);
spx->setPosition(ccp(200,200));
addChild(spx);
//support spx3
spx3 = CCSPX3Sprite::create("spx3_test.sprite", 0, cache->addImage("spx3_test.png"),NULL);
spx3->setPosition(ccp(200, 100));
spx3->setLoopCount(-1);
addChild(spx3);
setTouchEnabled(true);
scheduleUpdate();
return true;
}
bool CImageWidget::setPorperty( const std::string& key,const std::string& strvalue )
{
bool ret = true;
do
{
ret = CBaseWidget::setPorperty(key,strvalue);
if (ret)
{
break;
}
if (key == CImageWidget::IMAGE_PIC)
{
CCTextureCache* pCache = CCTextureCache::sharedTextureCache();
CCTexture2D* pPic = pCache->addImage(strvalue.c_str());
this->setPic(pPic);
}
else
{
ret = false;
}
} while (0);
return ret;
}
//------------------------------------------------------------------
//
// Clip Mapping (Aurora GT)
//
//------------------------------------------------------------------
void AnimClipMappingAuroraGT::onEnter()
{
AnimDemo::onEnter();
// surface
CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize();
CCPoint origin = CCDirector::sharedDirector()->getVisibleOrigin();
// texture
CCTextureCache* tc = CCTextureCache::sharedTextureCache();
CCTexture2D* tex = tc->addImage("Files/prince.png");
// animation 1
m_sprite1 = CCAuroraSprite::create("Files/prince.bsprite", 78, tex, NULL);
m_sprite1->setLoopCount(-1);
m_sprite1->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height / 2));
m_sprite1->setUnitInterval(0.1f);
m_sprite1->setDebugDrawFrameRect(true);
m_sprite1->setDebugDrawCollisionRect(true);
addChild(m_sprite1);
// create clip mapping and add them to sprite
CCAFCClipMapping* mapping = CCAFCClipMapping::createWithAuroraGT(1, "Files/prince_m00.mmp");
m_sprite1->addClipMapping(mapping);
mapping = CCAFCClipMapping::createWithAuroraGT(2, "Files/prince_m01.mmp");
m_sprite1->addClipMapping(mapping);
mapping = CCAFCClipMapping::createWithAuroraGT(3, "Files/prince_m02.mmp");
m_sprite1->addClipMapping(mapping);
mapping = CCAFCClipMapping::createWithAuroraGT(4, "Files/prince_m03.mmp");
m_sprite1->addClipMapping(mapping);
mapping = CCAFCClipMapping::createWithAuroraGT(5, "Files/prince_m04.mmp");
m_sprite1->addClipMapping(mapping);
mapping = CCAFCClipMapping::createWithAuroraGT(6, "Files/prince_m05.mmp");
m_sprite1->addClipMapping(mapping);
mapping = CCAFCClipMapping::createWithAuroraGT(7, "Files/prince_m06.mmp");
m_sprite1->addClipMapping(mapping);
mapping = CCAFCClipMapping::createWithAuroraGT(8, "Files/prince_m07.mmp");
m_sprite1->addClipMapping(mapping);
CCLabelTTF* label = CCLabelTTF::create("Switch Clip Mapping", "Helvetica", 16);
CCMenuItemLabel* item = CCMenuItemLabel::create(label,
this,
menu_selector(AnimClipMappingAuroraGT::onSwitchClipMapping));
item->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height / 7));
CCMenu* menu = CCMenu::create(item, NULL);
menu->setPosition(CCPointZero);
addChild(menu);
scheduleUpdate();
setTouchEnabled(true);
setTouchMode(kCCTouchesOneByOne);
}
/* 释放本技能相关 ui 资源 */
void SkillItem::releaseUI() {
CCTextureCache* pTextureCache = CCTextureCache::sharedTextureCache();
CCSpriteFrameCache* pSpriteFrameCache = CCSpriteFrameCache::sharedSpriteFrameCache();
// 获取大文件名
std::string c = getC();
std::string pvrFile = c + ".pvr.ccz";
std::string plistFile = c + ".plist";
pTextureCache->removeTextureForKey(pvrFile.c_str());
pSpriteFrameCache->removeSpriteFramesFromFile(plistFile.c_str());
}
void StartLayer::loadResources()
{
CCTextureCache * textureCache = CCTextureCache::sharedTextureCache();
CCDictionary* dir = CCDictionary::createWithContentsOfFile("load.plist");
_textures = (CCArray*)dir->objectForKey("texture");
_textures->retain();
for (int i = 0; i < _textures->count(); ++i)
{
string str = ((CCString*)_textures->objectAtIndex(i))->getCString();
textureCache->addImageAsync(str.c_str(), this, callfuncO_selector(StartLayer::loadCallback));
}
}
////////////////////////////////////////////////////////
//
// TextureTest
//
////////////////////////////////////////////////////////
void TextureTest::performTestsPNG(const char* filename)
{
struct timeval now;
CCTexture2D *texture;
CCTextureCache *cache = CCTextureCache::sharedTextureCache();
CCLog("RGBA 8888");
CCTexture2D::setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_RGBA8888);
gettimeofday(&now, NULL);
texture = cache->addImage(filename);
if( texture )
CCLog(" ms:%f\n", calculateDeltaTime(&now) );
else
CCLog(" ERROR\n");
cache->removeTexture(texture);
//CCLog("RGBA 4444");
//CCTexture2D::setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_RGBA4444);
//gettimeofday(&now, NULL);
//texture = cache->addImage(filename);
//if( texture )
// CCLog(" ms:%f\n", calculateDeltaTime(&now) );
//else
// CCLog(" ERROR\n");
//cache->removeTexture(texture);
/* CCLog("RGBA 5551");
CCTexture2D::setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_RGB5A1);
gettimeofday(&now, NULL);
texture = cache->addImage(filename);
if( texture )
CCLog(" ms:%f\n", calculateDeltaTime(&now) );
else
CCLog(" ERROR\n");
cache->removeTexture(texture);*/
CCLog("RGB 565");
CCTexture2D::setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_RGB565);
gettimeofday(&now, NULL);
texture = cache->addImage(filename);
if( texture )
CCLog(" ms:%f\n", calculateDeltaTime(&now) );
else
CCLog(" ERROR\n");
cache->removeTexture(texture);
// restore default
CCTexture2D::setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_Default);
}
//------------------------------------------------------------------
//
// Arctic
//
//------------------------------------------------------------------
void AnimArctic::onEnter()
{
AnimDemo::onEnter();
// surface
CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize();
CCPoint origin = CCDirector::sharedDirector()->getVisibleOrigin();
// texture
CCTextureCache* tc = CCTextureCache::sharedTextureCache();
CCTexture2D* tex1 = tc->addImage("Files/fighterboby001.png");
CCTexture2D* tex2 = tc->addImage("Files/fighterarmor001.png");
CCTexture2D* tex3 = tc->addImage("Files/fighterweapon001.png");
// animation 1
m_sprite1 = CCArcticSprite::create("Files/fighter.aspr", 0, tex1, tex2, tex3, NULL);
m_sprite1->setLoopCount(-1);
m_sprite1->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height * 3 / 4));
m_sprite1->setUnitInterval(0.1f);
m_sprite1->setDebugDrawFrameRect(true);
m_sprite1->setDebugDrawCollisionRect(true);
addChild(m_sprite1);
// animation 2
m_sprite2 = CCArcticSprite::create("Files/fighter.aspr", 1, tex1, tex2, tex3, NULL);
m_sprite2->setLoopCount(-1);
m_sprite2->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height * 2 / 4));
m_sprite2->setUnitInterval(0.1f);
m_sprite2->setDebugDrawFrameRect(true);
m_sprite2->setDebugDrawCollisionRect(true);
addChild(m_sprite2);
// animation 3
m_sprite3 = CCArcticSprite::create("Files/fighter.aspr", 2, tex1, tex2, tex3, NULL);
m_sprite3->setLoopCount(-1);
m_sprite3->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height / 4));
m_sprite3->setUnitInterval(0.1f);
m_sprite3->setDebugDrawFrameRect(true);
m_sprite3->setDebugDrawCollisionRect(true);
addChild(m_sprite3);
scheduleUpdate();
setTouchEnabled(true);
setTouchMode(kCCTouchesOneByOne);
}
//------------------------------------------------------------------
//
// Aurora GT
//
//------------------------------------------------------------------
void AnimAuroraGT::onEnter()
{
AnimDemo::onEnter();
// surface
CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize();
CCPoint origin = CCDirector::sharedDirector()->getVisibleOrigin();
// texture
CCTextureCache* tc = CCTextureCache::sharedTextureCache();
CCTexture2D* tex = tc->addImage("Files/prince.png");
// animation 1
m_sprite1 = CCAuroraSprite::create("Files/prince.bsprite", 78, tex, NULL);
m_sprite1->setLoopCount(-1);
m_sprite1->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height * 3 / 4));
m_sprite1->setUnitInterval(0.1f);
m_sprite1->setDebugDrawFrameRect(true);
m_sprite1->setDebugDrawCollisionRect(true);
addChild(m_sprite1);
// animation 2
m_sprite2 = CCAuroraSprite::create("Files/prince.bsprite", 99, tex, NULL);
m_sprite2->setLoopCount(-1);
m_sprite2->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height * 2 / 4));
m_sprite2->setUnitInterval(0.1f);
m_sprite2->setDebugDrawFrameRect(true);
m_sprite2->setDebugDrawCollisionRect(true);
addChild(m_sprite2);
// animation 3
m_sprite3 = CCAuroraSprite::create("Files/prince.bsprite", 66, tex, NULL);
m_sprite3->setLoopCount(-1);
m_sprite3->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height / 4));
m_sprite3->setUnitInterval(0.1f);
m_sprite3->setDebugDrawFrameRect(true);
m_sprite3->setDebugDrawCollisionRect(true);
addChild(m_sprite3);
scheduleUpdate();
setTouchEnabled(true);
setTouchMode(kCCTouchesOneByOne);
}
void ArmatureDataManager::removeUnusedAnimations(){
if( m_pArmatureFileInfoDic ){
CCTextureCache * tc = CCTextureCache::sharedTextureCache();
CCSpriteFrameCache * sfc = CCSpriteFrameCache::sharedSpriteFrameCache();
std::vector<std::string> cleanlist;
CCDictElement* pElement = NULL;
CCDICT_FOREACH(m_pArmatureFileInfoDic, pElement){
const std::string file = pElement->getStrKey();
ArmatureFileInfo * _fileInfo = (ArmatureFileInfo*)pElement->getObject();
if (_fileInfo && _fileInfo->retainCount() == 1) {
//清理 m_pAnimationDatas、m_pArmarureDatas、m_pTextureDatas 信息
if( m_pAnimationDatas ){
m_pAnimationDatas->removeObjectForKey(_fileInfo->configFilePath);
}
if( m_pArmarureDatas ){
m_pArmarureDatas->removeObjectForKey(_fileInfo->configFilePath);
}
if( m_pTextureDatas ){
m_pTextureDatas->removeObjectForKey(_fileInfo->configFilePath);
}
//清理精灵帧、纹理和标记需要清理的ArmatureFile
for (std::vector<ImageInfo>::iterator it = _fileInfo->imageInfoVector.begin();
it != _fileInfo->imageInfoVector.end();
it++){
const std::string & plist = it->plistPath;
const std::string & texture = it->imagePath;
sfc->removeSpriteFramesFromFile(plist.c_str());
tc->removeTextureForKey(texture.c_str());
cleanlist.push_back(file);
}
}
}
int size = cleanlist.size();
for(int i = 0; i < size; i++) {
m_pArmatureFileInfoDic->removeObjectForKey(cleanlist[i]);
}
cleanlist.clear();
}
}
void CCSprite::didReceiveFile(HttpRequest* r, char *data, uint32 len) {
if(r == mRequest){
CCImage* img = new CCImage;
img->initWithImageData(data, len);
CCTextureCache *cache = CCTextureCache::sharedTextureCache();
CCTexture2D* texture = cache->addUIImage(img, r->mURL->getCString());
setTextureAndSize(texture);
mRequest = NULL;
delete img;
if(mDelegate)
mDelegate->didSpriteReceiveFile(this);
}
}
void SwarmGame::transformToZombie(EntitySprite& entity)
{
EntityType toType;
if (transformToType(entity.m_entity->type(), toType))
{
MobileEntity* zombie = static_cast<MobileEntity*>(EntityFactory::instance().createEntity(toType));
if ( NULL != zombie )
{
m_ZombieSwarm.addEntity(zombie);
CCTexture2D* entityTexture = NULL;
CCTextureCache* textureCache = CCTextureCache::sharedTextureCache();
entityTexture = textureCache->textureForKey(xmlDataManager::instance().getEntitySprite (toType));
int mapHeight = m_map.height() * c_blockSize;
//create new sprite
SpriteEntity* sprite = SpriteEntity::spriteWithEntity(zombie);
sprite->setAnchorPoint(entity.m_sprite->getAnchorPoint());
sprite->setScaleX(entity.m_sprite->getScaleX());
sprite->setScaleY(entity.m_sprite->getScaleY());
sprite->setPosition(entity.m_sprite->getPosition());
m_mapLayer->removeChild(entity.m_sprite, true);
entity.m_sprite = sprite;
entity.m_sprite->setMaxHealth( zombie->hitPoints() );
entity.m_sprite->setIsVisible(true);
m_mapLayer->addChild(entity.m_sprite);
//TODO: add more properties
m_map.removeEntity(entity.m_entity);
m_map.placeEntity(zombie, entity.m_entity->x(), entity.m_entity->y());
m_ZombieSwarm.removeTarget(entity.m_entity);
m_HumanSwarm.removeEntity(entity.m_entity, true);
//m_map->removeEntity(entity.m_entity);
m_HumanSwarm.addTarget (zombie);
entity.m_entity = zombie;
}
}
}
void CCSprite::setImageFromImage() {
if(mWillSetImage && mWillSetImage->mPath && mCountShow <= 0) {
if(mFilePath && strcmp(mFilePath->getCString(), mWillSetImage->mPath->getCString()) )
return;
CCTextureCache *cache = CCTextureCache::sharedTextureCache();
CCTexture2D* texture = cache->addUIImage((CCImage*)mWillSetImage, mWillSetImage->mPath->getCString());
if(texture){
setTextureAndSize(texture);
if(mDelegate)
mDelegate->didSpriteReceiveFile(this);
}else{
// broken texture so delete it
s3eFileDelete(mWillSetImage->mPath->getCString());
if(mDelegate)
mDelegate->didSpriteReceiveError(this);
}
delete mWillSetImage;
mWillSetImage = NULL;
}
}
/*
* 析构函数
*/
LoginLayer::~LoginLayer() {
CCTextureCache* pTextureCache = CCTextureCache::sharedTextureCache();
pTextureCache->removeTextureForKey("GAME_NAME.png");
pTextureCache->removeTextureForKey("bg_big.png");
pTextureCache->removeTextureForKey("pre.png");
pTextureCache->removeTextureForKey("def.png");
pTextureCache->removeTextureForKey("start.png");
pTextureCache->removeTextureForKey("LG_nor.png");
pTextureCache->removeTextureForKey("LG_sel.png");
}
void CCDirector::createStatsLabel()
{
CCTexture2D *texture = NULL;
CCTextureCache *textureCache = CCTextureCache::sharedTextureCache();
if( m_pFPSLabel && m_pSPFLabel )
{
CC_SAFE_RELEASE_NULL(m_pFPSLabel);
CC_SAFE_RELEASE_NULL(m_pSPFLabel);
CC_SAFE_RELEASE_NULL(m_pDrawsLabel);
textureCache->removeTextureForKey("cc_fps_images");
CCFileUtils::sharedFileUtils()->purgeCachedEntries();
}
CCTexture2DPixelFormat currentFormat = CCTexture2D::defaultAlphaPixelFormat();
CCTexture2D::setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_RGBA4444);
unsigned char *data = NULL;
unsigned int data_len = 0;
getFPSImageData(&data, &data_len);
CCImage* image = new CCImage();
bool isOK = image->initWithImageData(data, data_len);
if (!isOK) {
CCLOGERROR("%s", "Fails: init fps_images");
return;
}
texture = textureCache->addUIImage(image, "cc_fps_images");
CC_SAFE_RELEASE(image);
/*
We want to use an image which is stored in the file named ccFPSImage.c
for any design resolutions and all resource resolutions.
To achieve this,
Firstly, we need to ignore 'contentScaleFactor' in 'CCAtlasNode' and 'CCLabelAtlas'.
So I added a new method called 'setIgnoreContentScaleFactor' for 'CCAtlasNode',
this is not exposed to game developers, it's only used for displaying FPS now.
Secondly, the size of this image is 480*320, to display the FPS label with correct size,
a factor of design resolution ratio of 480x320 is also needed.
*/
float factor = 1.0f; // CCEGLView::sharedOpenGLView()->getDesignResolutionSize().height / 320.0f;
m_pFPSLabel = new CCLabelAtlas();
m_pFPSLabel->setIgnoreContentScaleFactor(true);
m_pFPSLabel->initWithString("00.0", texture, 12, 32 , '.');
m_pFPSLabel->setScale(factor);
m_pSPFLabel = new CCLabelAtlas();
m_pSPFLabel->setIgnoreContentScaleFactor(true);
m_pSPFLabel->initWithString("0.000", texture, 12, 32, '.');
m_pSPFLabel->setScale(factor);
m_pDrawsLabel = new CCLabelAtlas();
m_pDrawsLabel->setIgnoreContentScaleFactor(true);
m_pDrawsLabel->initWithString("000", texture, 12, 32, '.');
m_pDrawsLabel->setScale(factor);
CCTexture2D::setDefaultAlphaPixelFormat(currentFormat);
m_pDrawsLabel->setPosition(ccpAdd(ccp(0, 34*factor), CC_DIRECTOR_STATS_POSITION));
m_pSPFLabel->setPosition(ccpAdd(ccp(0, 17*factor), CC_DIRECTOR_STATS_POSITION));
m_pFPSLabel->setPosition(CC_DIRECTOR_STATS_POSITION);
}
/*
* 析构函数
*/
Demo::~Demo() {
CCTextureCache* pTextureCache = CCTextureCache::sharedTextureCache();
pTextureCache->removeTextureForKey("des.png");
pTextureCache->removeTextureForKey("desfont.png");
}
/**
* 初始化操作
*/
bool YJTabTitle::initWithString(const char* normalImageName, const char* selectedImageName, YJTabTitleState state,
const char* displayText, const char *fontName, float fontSize, CCObject* target, SEL_CallFuncN selector)
{
if(!normalImageName)
{
return false ;
}
if(!selectedImageName)
{
return false ;
}
if(kStateNormal!=state && kStateSelected!=state)
{
return false ;
}
if(!displayText)
{
return false ;
}
if(!fontName)
{
return false ;
}
this->normalImageName = normalImageName ;
this->selectedImageName = selectedImageName ;
this->displayText = displayText ;
this->fontName = fontName ;
this->fontSize = fontSize ;
this->state = state ; // 设置状态
this->setTarget(target, selector) ; // 设置回到函数
CCTextureCache* textureCache = CCTextureCache::sharedTextureCache() ;
std::string initImageName ;
if( kStateNormal == state)
{
initImageName = normalImageName ;
}
else if(kStateSelected == state)
{
initImageName = selectedImageName ;
}
this->bgSprite = CCSprite::createWithTexture(textureCache->addImage(initImageName.c_str())) ;
this->bgSprite->setAnchorPoint(ccp(0, 0)) ;
this->bgSprite->setPosition(ccp(0, 0)) ;
this->setContentSize(this->bgSprite->getContentSize()) ;
this->addChild(this->bgSprite, 0) ;
this->label = CCLabelTTF::create(this->displayText.c_str(), this->fontName.c_str(), this->fontSize) ;
this->label->setAnchorPoint(ccp(0.5, 0.5)) ;
this->label->setPosition(ccp(this->getContentSize().width/2, this->getContentSize().height/2)) ;
this->addChild(this->label, 1) ;
return true ;
}
//------------------------------------------------------------------
//
// SpriteX 2011
//
//------------------------------------------------------------------
void AnimSpriteX2011::onEnter()
{
AnimDemo::onEnter();
// surface
CCSize visibleSize = CCDirector::sharedDirector()->getVisibleSize();
CCPoint origin = CCDirector::sharedDirector()->getVisibleOrigin();
// texture
CCTextureCache* tc = CCTextureCache::sharedTextureCache();
CCTexture2D* tex = tc->addImage("Files/spx3_test.png");
// animation 1
// SpriteX doesn't support tick mode, but you can use setForceTickMode
// to enforce using tick mode. this animation use a large unit interval
// so the animation plays slow
m_sprite1 = CCSPX3Sprite::create("Files/spx3_test.sprite", 0, tex, NULL);
m_sprite1->setLoopCount(-1);
m_sprite1->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height * 7 / 8));
m_sprite1->setForceTickMode(true);
m_sprite1->setUnitInterval(0.5f);
addChild(m_sprite1);
// animation 2
m_sprite2 = CCSPX3Sprite::create("Files/spx3_test.sprite", 1, tex, NULL);
m_sprite2->setLoopCount(-1);
m_sprite2->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height * 6 / 8));
addChild(m_sprite2);
// animation 3, 反着放
m_sprite3 = CCSPX3Sprite::create("Files/spx3_test.sprite", 2, tex, NULL);
m_sprite3->setLoopCount(-1);
m_sprite3->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height * 5 / 8));
m_sprite3->setReverse(true);
addChild(m_sprite3);
// animation 4
m_sprite4 = CCSPX3Sprite::create("Files/spx3_test.sprite", 3, tex, NULL);
m_sprite4->setLoopCount(-1);
m_sprite4->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height * 4 / 8));
addChild(m_sprite4);
// animation 5, y轴倒转播放
m_sprite5 = CCSPX3Sprite::create("Files/spx3_test.sprite", 4, tex, NULL);
m_sprite5->setLoopCount(-1);
m_sprite5->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height * 3 / 8));
m_sprite5->setFlipY(true);
addChild(m_sprite5);
// animation 6
m_sprite6 = CCSPX3Sprite::create("Files/spx3_test.sprite", 5, tex, NULL);
m_sprite6->setLoopCount(-1);
m_sprite6->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height * 2 / 8));
addChild(m_sprite6);
// animation 7
m_sprite7 = CCSPX3Sprite::create("Files/spx3_test.sprite", 6, tex, NULL);
m_sprite7->setLoopCount(-1);
m_sprite7->setPosition(ccp(origin.x + visibleSize.width / 2,
origin.y + visibleSize.height / 8));
addChild(m_sprite7);
scheduleUpdate();
setTouchEnabled(true);
setTouchMode(kCCTouchesOneByOne);
}
void CCSprite::setUrl(const char *url) {
#ifdef THREAD_IMAGE
if(!g_ListenThread){
mSpriteProcessArray = CCArray::create();
mSpriteProcessArray->retain(); // never release
g_ThreadQueueLock = s3eThreadLockCreate();
g_ListenThread = s3eThreadCreate(SpriteListenThread, NULL, NULL);
}
unschedule(schedule_selector(CCSprite::setImageFromImage));
schedule(schedule_selector(CCSprite::setImageFromImage));
#endif
setVisible(false);
if(!mOriginalPosSet){
mOriginalX = getPositionX();
mOriginalY = getPositionY();
mOriginalPosSet = true;
}
if(mRequest){
mRequest->stop();
mRequest = NULL;
}
CCTextureCache *cache = CCTextureCache::sharedTextureCache();
#ifdef THREAD_IMAGE
const char *filePath = getFilePathFromURL(url);
if(mFilePath)
mFilePath->release();
mFilePath = CCString::create(filePath);
mFilePath->retain();
CCTexture2D* texture = cache->textureForKey(filePath);
#else
CCTexture2D* texture = cache->textureForKey(url);
#endif
if(texture){
int tmp = mCountShow;
mCountShow = 0;
setTextureAndSize(texture);
mCountShow = tmp;
if(mDelegate)
mDelegate->didSpriteReceiveFile(this);
return;
}
#ifdef THREAD_IMAGE
// Find in disk
// still crash in device dont know why
if(s3eFileCheckExists(filePath)){
if(mWillSetImage)
delete mWillSetImage;
mWillSetImage = NULL;
//scheduleOnce(schedule_selector(CCSprite::createNewSpriteProcess), 0.0f);
createNewSpriteProcess(CCString::create(filePath));
return;
}
#endif
mRequest = HttpRequest::create();
mRequest->delegate = this;
#ifdef THREAD_IMAGE
mRequest->mSaveFile = new CCString(filePath);
mRequest->mType = HTTP_REQUEST_SAVE_FILE;
#else
mRequest->mType = HTTP_REQUEST_FILE;
#endif
mRequest->callURL(url);
}
void SubTest::initWithSubTest(int nSubTest, CCNode* p)
{
subtestNumber = nSubTest;
parent = p;
batchNode = NULL;
/*
* Tests:
* 1: 1 (32-bit) PNG sprite of 52 x 139
* 2: 1 (32-bit) PNG Batch Node using 1 sprite of 52 x 139
* 3: 1 (16-bit) PNG Batch Node using 1 sprite of 52 x 139
* 4: 1 (4-bit) PVRTC Batch Node using 1 sprite of 52 x 139
* 5: 14 (32-bit) PNG sprites of 85 x 121 each
* 6: 14 (32-bit) PNG Batch Node of 85 x 121 each
* 7: 14 (16-bit) PNG Batch Node of 85 x 121 each
* 8: 14 (4-bit) PVRTC Batch Node of 85 x 121 each
* 9: 64 (32-bit) sprites of 32 x 32 each
*10: 64 (32-bit) PNG Batch Node of 32 x 32 each
*11: 64 (16-bit) PNG Batch Node of 32 x 32 each
*12: 64 (4-bit) PVRTC Batch Node of 32 x 32 each
*/
// purge textures
CCTextureCache *mgr = CCTextureCache::sharedTextureCache();
// [mgr removeAllTextures];
mgr->removeTexture(mgr->addImage("Images/grossinis_sister1.png"));
mgr->removeTexture(mgr->addImage("Images/grossini_dance_atlas.png"));
mgr->removeTexture(mgr->addImage("Images/spritesheet1.png"));
switch ( subtestNumber)
{
case 1:
case 4:
case 7:
break;
///
case 2:
CCTexture2D::setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_RGBA8888);
batchNode = CCSpriteBatchNode::create("Images/grossinis_sister1.png", 100);
p->addChild(batchNode, 0);
break;
case 3:
CCTexture2D::setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_RGBA4444);
batchNode = CCSpriteBatchNode::create("Images/grossinis_sister1.png", 100);
p->addChild(batchNode, 0);
break;
///
case 5:
CCTexture2D::setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_RGBA8888);
batchNode = CCSpriteBatchNode::create("Images/grossini_dance_atlas.png", 100);
p->addChild(batchNode, 0);
break;
case 6:
CCTexture2D::setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_RGBA4444);
batchNode = CCSpriteBatchNode::create("Images/grossini_dance_atlas.png", 100);
p->addChild(batchNode, 0);
break;
///
case 8:
CCTexture2D::setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_RGBA8888);
batchNode = CCSpriteBatchNode::create("Images/spritesheet1.png", 100);
p->addChild(batchNode, 0);
break;
case 9:
CCTexture2D::setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_RGBA4444);
batchNode = CCSpriteBatchNode::create("Images/spritesheet1.png", 100);
p->addChild(batchNode, 0);
break;
default:
break;
}
if (batchNode)
{
batchNode->retain();
}
CCTexture2D::setDefaultAlphaPixelFormat(kCCTexture2DPixelFormat_Default);
}
void SwarmGame::initialiseSwarm (EntityType type, int numEntities)
{
CCTextureCache* textureCache = CCTextureCache::sharedTextureCache();
CCSize size( float(m_map.width()), float(m_map.height()) );
EntityFactory& factory = EntityFactory::instance();
MobileEntity* entity = NULL, *mapEntity = NULL;
MapNode* node = NULL;
int x, y;
int mapHeight = m_map.height() * c_blockSize;
for ( int i = 0; i < numEntities; i++ )
{
if ( (entity = static_cast<MobileEntity*>(factory.createEntity (type))) )
{
// random position
x = rand() % static_cast<int>(size.width);
y = rand() % static_cast<int>(size.height);
if ( (node = m_map.nodeAt(x, y)) )
{
if ( node->isBlocking() )
{
// if we chose a spot that already has an entity, try again...
i--;
delete entity;
continue;
}
}
// if we get here, we can place the new entity
m_map.placeEntity<MobileEntity>(entity, x, y);
// add it to the swarm
CCTexture2D* entityTexture = NULL;
if (entity->isHuman())
m_HumanSwarm.addEntity(entity);
else
{
m_ZombieSwarm.addEntity(entity);
m_HumanSwarm.addTarget(entity);
}
// create an entity sprite structure for the visualisation
EntitySprite es;
entityTexture = textureCache->textureForKey(xmlDataManager::instance().getEntitySprite (entity->type()));
es.m_entity = dynamic_cast<MobileEntity*>(entity);
es.m_sprite = SpriteEntity::spriteWithEntity(entity);
es.m_sprite->setAnchorPoint( ccp(0.5, 0.5) );
es.m_sprite->setScaleX( c_blockSize/es.m_sprite->getContentSize().width );
es.m_sprite->setScaleY( c_blockSize/es.m_sprite->getContentSize().height );
es.m_sprite->setPosition( ccp(es.m_entity->x() * c_blockSize + c_blockSize/2, mapHeight - ((es.m_entity->y()+1) * c_blockSize + c_blockSize/2)) );
es.m_sprite->setMaxHealth( entity->hitPoints() );
m_mapLayer->addChild(es.m_sprite);
m_entitySprites.push_back(es);
}
}
}
