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; }