void CCFileUtils::setRelativePath(const char* pszRelativePath)
{
NSAssert(pszRelativePath != NULL, "[FileUtils setRelativePath] -- wrong relative path");
if (! pszRelativePath)
{
return;
}
m_sRelativePath = pszRelativePath;
// if the path is not ended with '/', append it
if (m_sRelativePath.find("/") != (strlen(m_sRelativePath.c_str()) - 1))
{
m_sRelativePath += "/";
}
}
void plist_startElement(void *ctx, const xmlChar *name, const xmlChar **atts)
{
CCDictMaker *pMaker = (CCDictMaker*)(ctx);
std::string sName((char*)name);
if( sName == "dict" )
{
NSDictionary<std::string, NSObject*> *pNewDict = new NSDictionary<std::string, NSObject*>();
if(! pMaker->m_pRootDict)
{
pMaker->m_pRootDict = pNewDict;
pNewDict->autorelease();
}
else
{
NSAssert(pMaker->m_pCurDict && !pMaker->m_sCurKey.empty(), "");
pMaker->m_pCurDict->setObject(pNewDict, pMaker->m_sCurKey);
pNewDict->release();
pMaker->m_sCurKey.clear();
}
pMaker->m_pCurDict = pNewDict;
pMaker->m_tDictStack.push(pMaker->m_pCurDict);
pMaker->m_tState = SAX_DICT;
}
else if(sName == "key")
{
pMaker->m_tState = SAX_KEY;
}
else if(sName == "integer")
{
pMaker->m_tState = SAX_INT;
}
else if(sName == "real")
{
pMaker->m_tState = SAX_REAL;
}
else if(sName == "string")
{
pMaker->m_tState = SAX_STRING;
}
else
{
pMaker->m_tState = SAX_NONE;
}
}
void CCBMFontConfiguration::parseImageFileName(std::string line, const char *fntFile)
{
//////////////////////////////////////////////////////////////////////////
// line to parse:
// page id=0 file="bitmapFontTest.png"
//////////////////////////////////////////////////////////////////////////
// page ID. Sanity check
int index = line.find('=')+1;
int index2 = line.find(' ', index);
std::string value = line.substr(index, index2-index);
NSAssert(atoi(value.c_str()) == 0, "BitmapFontAtlas file could not be found");
// file
index = line.find('"')+1;
index2 = line.find('"', index);
value = line.substr(index, index2-index);
m_sAtlasName = CCFileUtils::fullPathFromRelativeFile(value.c_str(), fntFile);
}
/** Inserts a value at a certain position. Behavior undefined if array doesn't have enough capacity */
void nsCArrayInsertValueAtIndex( nsCArray *arr, void* value, unsigned int index)
{
NSAssert( index < arr->max, "nsCArrayInsertValueAtIndex: invalid index");
unsigned int remaining = arr->num - index;
// make sure it has enough capacity
if (arr->num + 1 == arr->max)
{
nsCArrayDoubleCapacity(arr);
}
// last Value doesn't need to be moved
if( remaining > 0) {
// tex coordinates
memmove((void *)&arr->arr[index+1], (void *)&arr->arr[index], sizeof(void*) * remaining );
}
arr->num++;
arr->arr[index] = value;
}
bool CCLabelBMFont::initWithString(const char *theString, const char *fntFile)
{
assert(theString != NULL);
CCX_SAFE_RELEASE(m_pConfiguration);// allow re-init
m_pConfiguration = FNTConfigLoadFile(fntFile);
m_pConfiguration->retain();
NSAssert( m_pConfiguration, "Error creating config for BitmapFontAtlas");
if (CCSpriteBatchNode::initWithFile(m_pConfiguration->m_sAtlasName.c_str(), strlen(theString)))
{
m_cOpacity = 255;
m_tColor = ccWHITE;
m_tContentSize = CGSizeZero;
m_bIsOpacityModifyRGB = m_pobTextureAtlas->getTexture()->getHasPremultipliedAlpha();
m_tAnchorPoint = ccp(0.5f, 0.5f);
this->setString(theString);
return true;
}
return false;
}
void nsArrayShrink(nsArray *arr)
{
unsigned int newSize = 0;
//only resize when necessary
if (arr->max > arr->num && !(arr->num==0 && arr->max==1))
{
if (arr->num!=0)
{
newSize=arr->num;
arr->max=arr->num;
}
else
{//minimum capacity of 1, with 0 elements the array would be free'd by realloc
newSize=1;
arr->max=1;
}
arr->arr = (NSObject**)realloc(arr->arr,newSize * sizeof(NSObject*) );
NSAssert(arr->arr!=NULL,"could not reallocate the memory");
}
}
void CCSpriteBatchNode::addQuadFromSprite(CCSprite *sprite, unsigned int index)
{
NSAssert( sprite != NULL, "Argument must be non-nil");
/// @todo NSAssert( [sprite isKindOfClass:[CCSprite class]], @"CCSpriteSheet only supports CCSprites as children");
while(index >= m_pobTextureAtlas->getCapacity() || m_pobTextureAtlas->getCapacity() == m_pobTextureAtlas->getTotalQuads())
{
this->increaseAtlasCapacity();
}
//
// update the quad directly. Don't add the sprite to the scene graph
//
sprite->useBatchNode(this);
sprite->setAtlasIndex(index);
ccV3F_C4B_T2F_Quad quad = sprite->getQuad();
m_pobTextureAtlas->insertQuad(&quad, index);
// XXX: updateTransform will update the textureAtlas too using updateQuad.
// XXX: so, it should be AFTER the insertQuad
sprite->setDirty(true);
sprite->updateTransform();
}
CGPoint CCParticleSystem::getGravity()
{
NSAssert( m_nEmitterMode == kCCParticleModeGravity, "Particle Mode should be Gravity");
return modeA.gravity;
}
void CCParticleSystem::setSpeedVar(float speedVar)
{
NSAssert( m_nEmitterMode == kCCParticleModeGravity, "Particle Mode should be Gravity");
modeA.speedVar = speedVar;
}
float CCParticleSystem::getRadialAccelVar()
{
NSAssert( m_nEmitterMode == kCCParticleModeGravity, "Particle Mode should be Gravity");
return modeA.radialAccelVar;
}
void CCParticleSystem::setGravity(CGPoint g)
{
NSAssert( m_nEmitterMode == kCCParticleModeGravity, "Particle Mode should be Gravity");
modeA.gravity = g;
}
float CCParticleSystem::getTangentialAccel()
{
NSAssert( m_nEmitterMode == kCCParticleModeGravity, "Particle Mode should be Gravity");
return modeA.tangentialAccel;
}
void CCParticleSystem::setRadialAccelVar(float t)
{
NSAssert( m_nEmitterMode == kCCParticleModeGravity, "Particle Mode should be Gravity");
modeA.radialAccelVar = t;
}
float CCParticleSystem::getRotatePerSecondVar()
{
NSAssert( m_nEmitterMode == kCCParticleModeRadius, "Particle Mode should be Radius");
return modeB.rotatePerSecondVar;
}
void EJHttpClient::destroyInstance() {
NSAssert(s_pHttpClient, "");
s_pHttpClient->release();
}
void CCParticleSystem::setStartRadiusVar(float startRadiusVar)
{
NSAssert( m_nEmitterMode == kCCParticleModeRadius, "Particle Mode should be Radius");
modeB.startRadiusVar = startRadiusVar;
}
float CCParticleSystem::getEndRadiusVar()
{
NSAssert( m_nEmitterMode == kCCParticleModeRadius, "Particle Mode should be Radius");
return modeB.endRadiusVar;
}
//
// SIZE > 64 IS NOT SUPPORTED
//
void CCParticleSystemPoint::setStartSize(float size)
{
NSAssert(size >= 0 && size <= CC_MAX_PARTICLE_SIZE, "PointParticleSystem only supports 0 <= size <= 64");
CCParticleSystem::setStartSize(size);
}
void CCParticleSystemPoint::setEndSize(float size)
{
NSAssert( (size == kCCParticleStartSizeEqualToEndSize) ||
( size >= 0 && size <= CC_MAX_PARTICLE_SIZE), "PointParticleSystem only supports 0 <= size <= 64");
CCParticleSystem::setEndSize(size);
}
// Worker thread
static void* networkThread(void *data) {
EJHttpRequest *request = NULL;
while (true) {
if (need_quit) {
break;
}
// step 1: send http request if the requestQueue isn't empty
request = NULL;
pthread_mutex_lock(&s_requestQueueMutex); //Get request task from queue
if (0 != s_requestQueue->count()) {
request = dynamic_cast<EJHttpRequest*>(s_requestQueue->objectAtIndex(0));
s_requestQueue->removeObjectAtIndex(0);
// request's refcount = 1 here
}
pthread_mutex_unlock(&s_requestQueueMutex);
if (NULL == request) {
// Wait for http request tasks from main thread
pthread_cond_wait(&s_SleepCondition, &s_SleepMutex);
continue;
}
// step 2: libcurl sync access
// Create a HttpResponse object, the default setting is http access failed
EJHttpResponse *response = new EJHttpResponse(request);
// request's refcount = 2 here, it's retained by HttpRespose constructor
request->release();
// ok, refcount = 1 now, only HttpResponse hold it.
int32_t responseCode = -1;
int retValue = 0;
// Process the request -> get response packet
switch (request->getRequestType()) {
case EJHttpRequest::kHttpGet: // HTTP GET
retValue = processGetTask(request,
writeData,
response->getResponseData(),
&responseCode);
break;
case EJHttpRequest::kHttpPost: // HTTP POST
retValue = processPostTask(request,
writeData,
response->getResponseData(),
&responseCode);
break;
case EJHttpRequest::kHttpPut:
retValue = processPutTask(request,
writeData,
response->getResponseData(),
&responseCode);
break;
case EJHttpRequest::kHttpDelete:
retValue = processDeleteTask(request,
writeData,
response->getResponseData(),
&responseCode);
break;
default:
NSAssert(true, "EJHttpClient: unkown request type, only GET and POSt are supported");
break;
}
// write data to HttpResponse
response->setResponseCode(responseCode);
if (retValue != 0) {
response->setSucceed(false);
response->setErrorBuffer(s_errorBuffer);
} else {
response->setSucceed(true);
}
// add response packet into queue
pthread_mutex_lock(&s_responseQueueMutex);
s_responseQueue->addObject(response);
pthread_mutex_unlock(&s_responseQueueMutex);
// resume dispatcher selector
//EJDirector::sharedDirector()->getScheduler()->resumeTarget(EJHttpClient::getInstance());
}
// cleanup: if worker thread received quit signal, clean up un-completed request queue
pthread_mutex_lock(&s_requestQueueMutex);
s_requestQueue->removeAllObjects();
pthread_mutex_unlock(&s_requestQueueMutex);
s_asyncRequestCount -= s_requestQueue->count();
if (s_requestQueue != NULL) {
pthread_mutex_destroy(&s_requestQueueMutex);
pthread_mutex_destroy(&s_responseQueueMutex);
pthread_mutex_destroy(&s_SleepMutex);
pthread_cond_destroy(&s_SleepCondition);
s_requestQueue->release();
s_requestQueue = NULL;
s_responseQueue->release();
s_responseQueue = NULL;
}
pthread_exit(NULL);
return 0;
}
float CCParticleSystem::getSpeedVar()
{
NSAssert( m_nEmitterMode == kCCParticleModeGravity, "Particle Mode should be Gravity");
return modeA.speedVar;
}
void CCParticleSystemPoint::setEndSpinVar(float var)
{
NSAssert(var == 0, "PointParticleSystem doesn't support spinning");
CCParticleSystem::setEndSpinVar(var);
}
float CCParticleSystem::getStartRadius()
{
NSAssert( m_nEmitterMode == kCCParticleModeRadius, "Particle Mode should be Radius");
return modeB.startRadius;
}
void CCSpriteFrameCache::addSpriteFramesWithDictionary(NSDictionary<std::string, NSObject*> *dictionary, CCTexture2D *pobTexture)
{
/*
Supported Zwoptex Formats:
enum {
ZWTCoordinatesListXMLFormat_Legacy = 0
ZWTCoordinatesListXMLFormat_v1_0,
};
*/
NSDictionary<std::string, NSObject*> *metadataDict = (NSDictionary<std::string, NSObject*>*)dictionary->objectForKey(std::string("metadata"));
NSDictionary<std::string, NSObject*> *framesDict = (NSDictionary<std::string, NSObject*>*)dictionary->objectForKey(std::string("frames"));
int format = 0;
// get the format
if(metadataDict != NULL)
{
format = atoi(valueForKey("format", metadataDict));
}
// check the format
if(format < 0 || format > 1)
{
NSAssert(0, "cocos2d: WARNING: format is not supported for CCSpriteFrameCache addSpriteFramesWithDictionary:texture:");
return;
}
framesDict->begin();
std::string key = "";
NSDictionary<std::string, NSObject*> *frameDict = NULL;
while( frameDict = (NSDictionary<std::string, NSObject*>*)framesDict->next(&key) )
{
CCSpriteFrame *spriteFrame = m_pSpriteFrames->objectForKey(key);
if (spriteFrame)
{
continue;
}
if(format == 0)
{
float x = (float)atof(valueForKey("x", frameDict));
float y = (float)atof(valueForKey("y", frameDict));
float w = (float)atof(valueForKey("width", frameDict));
float h = (float)atof(valueForKey("height", frameDict));
float ox = (float)atof(valueForKey("offsetX", frameDict));
float oy = (float)atof(valueForKey("offsetY", frameDict));
int ow = atoi(valueForKey("originalWidth", frameDict));
int oh = atoi(valueForKey("originalHeight", frameDict));
// check ow/oh
if(!ow || !oh)
{
CCLOG("cocos2d: WARNING: originalWidth/Height not found on the CCSpriteFrame. AnchorPoint won't work as expected. Regenrate the .plist");
}
// abs ow/oh
ow = abs(ow);
oh = abs(oh);
// create frame
spriteFrame = CCSpriteFrame::frameWithTexture(pobTexture, CGRectMake(x, y, w, h), CGPointMake(ox, oy), CGSizeMake((float)ow, (float)oh));
}
else if(format == 1)
{
/** @todo
CGRect frame = CGRectFromString([frameDict objectForKey:@"frame"]);
CGPoint offset = CGPointFromString([frameDict objectForKey:@"offset"]);
CGSize sourceSize = CGSizeFromString([frameDict objectForKey:@"sourceSize"]);
// create frame
spriteFrame = [CCSpriteFrame frameWithTexture:texture rect:frame offset:offset originalSize:sourceSize];
*/
}
else
{
CCLOG("cocos2d: Unsupported Zwoptex version. Update cocos2d.");
}
// add sprite frame
m_pSpriteFrames->setObject(spriteFrame, key);
}
}
void CCParticleSystem::setEndRadiusVar(float endRadiusVar)
{
NSAssert( m_nEmitterMode == kCCParticleModeRadius, "Particle Mode should be Radius");
modeB.endRadiusVar = endRadiusVar;
}
NSObject* NSString::copyWithZone(NSZone* pZone)
{
NSAssert(pZone == NULL, "NSString should not be inherited.");
NSString* pStr = new NSString(m_sString.c_str());
return pStr;
}
void CCParticleSystem::setRotatePerSecondVar(float degrees)
{
NSAssert( m_nEmitterMode == kCCParticleModeRadius, "Particle Mode should be Radius");
modeB.rotatePerSecondVar = degrees;
}
bool CCParticleSystem::initWithDictionary(NSDictionary<std::string, NSObject*> *dictionary)
{
bool bRet = false;
unsigned char *buffer = NULL;
unsigned char *deflated = NULL;
UIImage *image = NULL;
do
{
int maxParticles = atoi(valueForKey("maxParticles", dictionary));
// self, not super
if(this->initWithTotalParticles(maxParticles))
{
// angle
m_fAngle = (float)atof(valueForKey("angle", dictionary));
m_fAngleVar = (float)atof(valueForKey("angleVariance", dictionary));
// duration
m_fDuration = (float)atof(valueForKey("duration", dictionary));
// blend function
m_tBlendFunc.src = atoi(valueForKey("blendFuncSource", dictionary));
m_tBlendFunc.dst = atoi(valueForKey("blendFuncDestination", dictionary));
// color
m_tStartColor.r = (float)atof(valueForKey("startColorRed", dictionary));
m_tStartColor.g = (float)atof(valueForKey("startColorGreen", dictionary));
m_tStartColor.b = (float)atof(valueForKey("startColorBlue", dictionary));
m_tStartColor.a = (float)atof(valueForKey("startColorAlpha", dictionary));
m_tStartColorVar.r = (float)atof(valueForKey("startColorVarianceRed", dictionary));
m_tStartColorVar.g = (float)atof(valueForKey("startColorVarianceGreen", dictionary));
m_tStartColorVar.b = (float)atof(valueForKey("startColorVarianceBlue", dictionary));
m_tStartColorVar.a = (float)atof(valueForKey("startColorVarianceAlpha", dictionary));
m_tEndColor.r = (float)atof(valueForKey("finishColorRed", dictionary));
m_tEndColor.g = (float)atof(valueForKey("finishColorGreen", dictionary));
m_tEndColor.b = (float)atof(valueForKey("finishColorBlue", dictionary));
m_tEndColor.a = (float)atof(valueForKey("finishColorAlpha", dictionary));
m_tEndColorVar.r = (float)atof(valueForKey("finishColorVarianceRed", dictionary));
m_tEndColorVar.g = (float)atof(valueForKey("finishColorVarianceGreen", dictionary));
m_tEndColorVar.b = (float)atof(valueForKey("finishColorVarianceBlue", dictionary));
m_tEndColorVar.a = (float)atof(valueForKey("finishColorVarianceAlpha", dictionary));
// particle size
m_fStartSize = (float)atof(valueForKey("startParticleSize", dictionary));
m_fStartSizeVar = (float)atof(valueForKey("startParticleSizeVariance", dictionary));
m_fEndSize = (float)atof(valueForKey("finishParticleSize", dictionary));
m_fEndSizeVar = (float)atof(valueForKey("finishParticleSizeVariance", dictionary));
// position
m_tPosition.x = (float)atof(valueForKey("sourcePositionx", dictionary));
m_tPosition.y = (float)atof(valueForKey("sourcePositiony", dictionary));
m_tPosVar.x = (float)atof(valueForKey("sourcePositionVariancex", dictionary));
m_tPosVar.y = (float)atof(valueForKey("sourcePositionVariancey", dictionary));
m_nEmitterMode = atoi(valueForKey("emitterType", dictionary));
// Mode A: Gravity + tangential accel + radial accel
if( m_nEmitterMode == kCCParticleModeGravity )
{
// gravity
modeA.gravity.x = (float)atof(valueForKey("gravityx", dictionary));
modeA.gravity.y = (float)atof(valueForKey("gravityy", dictionary));
// speed
modeA.speed = (float)atof(valueForKey("speed", dictionary));
modeA.speedVar = (float)atof(valueForKey("speedVariance", dictionary));
const char * pszTmp = NULL;
// radial acceleration
pszTmp = valueForKey("radialAcceleration", dictionary);
modeA.radialAccel = (pszTmp) ? (float)atof(pszTmp) : 0;
pszTmp = valueForKey("radialAccelVariance", dictionary);
modeA.radialAccelVar = (pszTmp) ? (float)atof(pszTmp) : 0;
// tangential acceleration
pszTmp = valueForKey("tangentialAcceleration", dictionary);
modeA.tangentialAccel = (pszTmp) ? (float)atof(pszTmp) : 0;
pszTmp = valueForKey("tangentialAccelVariance", dictionary);
modeA.tangentialAccelVar = (pszTmp) ? (float)atof(pszTmp) : 0;
}
// or Mode B: radius movement
else if( m_nEmitterMode == kCCParticleModeRadius )
{
modeB.startRadius = (float)atof(valueForKey("maxRadius", dictionary));
modeB.startRadiusVar = (float)atof(valueForKey("maxRadiusVariance", dictionary));
modeB.endRadius = (float)atof(valueForKey("minRadius", dictionary));
modeB.endRadiusVar = 0;
modeB.rotatePerSecond = (float)atof(valueForKey("rotatePerSecond", dictionary));
modeB.rotatePerSecondVar = (float)atof(valueForKey("rotatePerSecondVariance", dictionary));
} else {
NSAssert( false, "Invalid emitterType in config file");
CCX_BREAK_IF(true);
}
// life span
m_fLife = (float)atof(valueForKey("particleLifespan", dictionary));
m_fLifeVar = (float)atof(valueForKey("particleLifespanVariance", dictionary));
// emission Rate
m_fEmissionRate = m_nTotalParticles / m_fLife;
// texture
// Try to get the texture from the cache
char *textureName = (char *)valueForKey("textureFileName", dictionary);
std::string fullpath = CCFileUtils::fullPathFromRelativeFile(textureName, m_sPlistFile.c_str());
if (strlen(textureName) > 0)
{
// set not pop-up message box when load image failed
bool bNotify = UIImage::getIsPopupNotify();
UIImage::setIsPopupNotify(false);
this->m_pTexture = CCTextureCache::sharedTextureCache()->addImage(fullpath.c_str());
// reset the value of UIImage notify
UIImage::setIsPopupNotify(bNotify);
}
// if it fails, try to get it from the base64-gzipped data
char *textureData = NULL;
if ( ! m_pTexture &&
(textureData = (char *)valueForKey("textureImageData", dictionary)))
{
int dataLen = strlen(textureData);
if(dataLen != 0)
{
int decodeLen = base64Decode((unsigned char*)textureData, dataLen, &buffer);
NSAssert( buffer != NULL, "CCParticleSystem: error decoding textureImageData");
CCX_BREAK_IF(!buffer);
int deflatedLen = ZipUtils::ccInflateMemory(buffer, decodeLen, &deflated);
NSAssert( deflated != NULL, "CCParticleSystem: error ungzipping textureImageData");
CCX_BREAK_IF(!deflated);
image = new UIImage();
bool isOK = image->initWithData(deflated, deflatedLen);
NSAssert(isOK, "CCParticleSystem: error init image with Data");
CCX_BREAK_IF(!isOK);
m_pTexture = CCTextureCache::sharedTextureCache()->addUIImage(image, fullpath.c_str());
}
}
NSAssert( this->m_pTexture != NULL, "CCParticleSystem: error loading the texture");
CCX_BREAK_IF(!m_pTexture);
this->m_pTexture->retain();
bRet = true;
}
} while (0);
CCX_SAFE_DELETE_ARRAY(buffer);
CCX_SAFE_DELETE_ARRAY(deflated);
CCX_SAFE_DELETE(image);
return bRet;
}
void Paddle::ccTouchEnded(CCTouch* touch, UIEvent* event)
{
NSAssert(m_state == kPaddleStateGrabbed, L"Paddle - Unexpected state!");
m_state = kPaddleStateUngrabbed;
}
// ParticleSystem - Properties of Gravity Mode
void CCParticleSystem::setTangentialAccel(float t)
{
NSAssert( m_nEmitterMode == kCCParticleModeGravity, "Particle Mode should be Gravity");
modeA.tangentialAccel = t;
}
