bool SHSceneNode::initSceneNodeWithContentOfFile(const std::string& sceneFile) {

#if COCOS2D_VERSION >= 0x00020000
    std::string fullPath = CCFileUtils::sharedFileUtils()->fullPathFromRelativePath(sceneFile.c_str());
    LHDictionary* dictionary = (LHDictionary*)LHDictionary::createWithContentsOfFile(fullPath.c_str());
#else
    std::string fullPath = CCFileUtils::fullPathFromRelativePath(sceneFile.c_str());
    LHDictionary* dictionary = (LHDictionary*)CCFileUtils::dictionaryWithContentsOfFile(fullPath.c_str());
#endif

    LHArray* sheetsList = dictionary->arrayForKey("SHEETS_INFO");

    for(int i = 0; i < sheetsList->count(); ++i) {
        LHDictionary* dic = sheetsList->dictAtIndex(i);
        sheets->setObject(dic, dic->stringForKey("SheetName"));
    }


    LHArray* animList = dictionary->arrayForKey("SH_ANIMATIONS_LIST");

    for(int i = 0; i< animList->count(); ++i) {

        LHDictionary* dic = animList->dictAtIndex(i);
        animations->setObject(dic, dic->stringForKey("UniqueName"));
    }

    return true;
}
LHAnimationNode::LHAnimationNode(LHDictionary* dictionary, LHSprite* spr, std::string shScene){
    
    frames= NULL;
    sprite= NULL;
    activeFrame= NULL;
    oldBatch= NULL;
    oldTexture= NULL;
    
    //this info will be from the spritehelper document
    //the info from the level is loaded by LHSprite
    shSceneName = std::string(shScene);
    uniqueName  = std::string(dictionary->stringForKey("UniqueName"));
    sheetName   = std::string(dictionary->stringForKey("SheetName"));
    restoreOriginalFrame = dictionary->boolForKey("RestoreOriginalFrame");
    repetitions = dictionary->intForKey("Repetitions");
    delayPerUnit= dictionary->floatForKey("DelayPerUnit");
    loop = dictionary->boolForKey("Loop");
    sprite = spr;
    oldRect = sprite->getTextureRect();

#if COCOS2D_VERSION >= 0x00020000
    oldSpriteFrame = sprite->displayFrame();
#else
    oldSpriteFrame = sprite->displayedFrame();
#endif
    oldSpriteFrame->retain();
    
    repetitionsPerformed = 0;
    currentFrame = 0;
    elapsedFrameTime = 0.0f;
    LHArray* framesInfo = dictionary->arrayForKey("Frames");
    
#if COCOS2D_VERSION >= 0x00020000
    frames = CCArray::create();
#else
    frames = CCArray::array();
#endif
    
    frames->retain();
    
    for(int i = 0; i< framesInfo->count(); ++i){
        
        LHDictionary* frmInfo = framesInfo->dictAtIndex(i);
        frames->addObject(LHAnimationFrameInfo::frameWithDictionary(frmInfo, sprite));
    }
    
    paused = true;
}
bool LHCameraActivateProperty::initWithDictionary(LHDictionary* dict, LHAnimation* anim)
{
    if(dict == NULL)return true; //special case for children subproperties
    
    if(LHAnimationProperty::initWithDictionary(dict, anim))
    {
        LHArray* framesInfo = dict->arrayForKey("Frames");
        
        for(int i = 0; i < framesInfo->count(); ++i)
        {
            LHDictionary* frmInfo = framesInfo->dictAtIndex(i);
            
            LHFrame* frm = LHFrame::createWithDictionary(frmInfo, this);
            addKeyFrame(frm);
        }
        return true;
    }
    return false;
}
Пример #4
0
bool LHLayer::initWithDictionary(LHDictionary* dictionary){
    
    isMainLayer = false;
    
    uniqueName = dictionary->stringForKey("UniqueName");
    
    if(uniqueName == ""){
        uniqueName = "UntitledLayer_" + stringFromInt(untitledLayersCount);
        ++untitledLayersCount;
    }
    
    setTag(dictionary->intForKey("Tag"));
    m_nZOrder = dictionary->intForKey("ZOrder");
    
    loadUserCustomInfoFromDictionary(dictionary->dictForKey("CustomClassInfo"));
    
    LHArray* childrenInfo = dictionary->arrayForKey("Children");
    for(int i = 0; i< childrenInfo->count(); ++i){
        LHDictionary* childDict = childrenInfo->dictAtIndex(i);
        addChildFromDictionary(childDict);
    }
    
    return true;
}
Пример #5
0
void LHShape::loadShapeFromDictionary(LHDictionary* dict, LHScene* scene)
{
    _tile = dict->boolForKey("tileTexture");
    _tileScale = dict->sizeForKey("tileScale");

    
    Size size = this->getContentSize();
    float alpha = dict->floatForKey("alpha");
    
    LHDrawNode* shape = LHDrawNode::create();
    this->addChild(shape);
    shape->setPosition(Point(size.width*0.5, size.height*0.5));
    
    _drawNode = shape;
    
    Texture2D* texture = NULL;
    
    if(dict->objectForKey("relativeImagePath"))
    {
        std::string imgRelPath = dict->stringForKey("relativeImagePath");
        
        std::string filename = LHUtils::getLastPathComponent(imgRelPath);
        std::string foldername = LHUtils::removeLastPathComponent(imgRelPath);
        foldername = LHUtils::getLastPathComponent(foldername);
        
        
        std::string imagePath = LHUtils::getImagePathWithFilename(filename,
                                                                  foldername,
                                                                  scene->getCurrentDeviceSuffix());
        
        texture = Director::getInstance()->getTextureCache()->addImage(imagePath);
        
        if(texture){
            Texture2D::TexParams texParams = {GL_NEAREST, GL_NEAREST, GL_REPEAT, GL_REPEAT};
            if(_tile){
                texParams = {GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, GL_REPEAT, GL_REPEAT};
            }
            
            texture->setTexParameters(texParams);
            _drawNode->setTexture(texture);
        }
    }
    
    
    
    LHArray* triangles = dict->arrayForKey("triangles");
    
    Color3B overlay = dict->colorForKey("colorOverlay");
    
    Color4F c4(overlay.r/255.0f,
               overlay.g/255.0f,
               overlay.b/255.0f,
               alpha/255.0f);
    
    
    LHArray* points = dict->arrayForKey("points");
    
    for(int i = 0; i < points->count(); ++i)
    {
        LHDictionary* dict = points->dictAtIndex(i);
        Point pt = dict->pointForKey("point");
        pt.y = -pt.y;
        _outline.push_back(pt);
    }
    
    __Array* shapeTriangles = __Array::create();
    __Array* uvPoints       = __Array::create();
    __Array* colors         = __Array::create();
    
    float scaleX = this->getScaleX();
    float scaleY = this->getScaleY();
    
    Size imageSize;
    if(texture)
        imageSize = Size(texture->getPixelsWide(), texture->getPixelsHigh());

    for(int i = 0; i < triangles->count(); i+=3)
    {
        LHDictionary* dictA = triangles->dictAtIndex(i);
        LHDictionary* dictB = triangles->dictAtIndex(i+1);
        LHDictionary* dictC = triangles->dictAtIndex(i+2);
        
        Color4F c4A;
        Color4F c4B;
        Color4F c4C;
        
        if(!texture){
            c4A = c4;
            c4B = c4;
            c4C = c4;
        }
        else{
            
            float alpha= dictA->floatForKey("alpha");
            Color3B color = dictA->colorForKey("color");
            c4A     = Color4F(color.r/255.0f,
                              color.g/255.0f,
                              color.b/255.0f,
                              alpha/255.0f);
            
            alpha   = dictB->floatForKey("alpha");
            color   = dictB->colorForKey("color");
            c4B     = Color4F(color.r/255.0f,
                              color.g/255.0f,
                              color.b/255.0f,
                              alpha/255.0f);
            
            alpha   = dictC->floatForKey("alpha");
            color   = dictC->colorForKey("color");
            c4C     = Color4F(color.r/255.0f,
                              color.g/255.0f,
                              color.b/255.0f,
                              alpha/255.0f);
        }
        
        Point posA = dictA->pointForKey("point");
        posA.y = -posA.y;
        Point uvA = dictA->pointForKey("uv");
        
        Point posB = dictB->pointForKey("point");
        posB.y = -posB.y;
        Point uvB = dictB->pointForKey("uv");
        
        Point posC = dictC->pointForKey("point");
        posC.y = -posC.y;
        Point uvC = dictC->pointForKey("uv");
        
        if(_tile && texture){
            
            uvA.x = (posA.x/imageSize.width)*(_tileScale.width);
            uvA.y = -(posA.y/imageSize.height)*(_tileScale.height);
            
            uvB.x = (posB.x/imageSize.width)*(_tileScale.width);
            uvB.y = -(posB.y/imageSize.height)*(_tileScale.height);
            
            uvC.x = (posC.x/imageSize.width)*(_tileScale.width);
            uvC.y = -(posC.y/imageSize.height)*(_tileScale.height);
        }

        
        posA.x *= scaleX;
        posA.y *= scaleY;
        
        posB.x *= scaleX;
        posB.y *= scaleY;
        
        posC.x *= scaleX;
        posC.y *= scaleY;
        
        
        _triangles.push_back(posA);
        _triangles.push_back(posB);
        _triangles.push_back(posC);
        
        
        shapeTriangles->addObject(LHValue::create(posA));
        shapeTriangles->addObject(LHValue::create(posB));
        shapeTriangles->addObject(LHValue::create(posC));
        
        if(!texture){
            uvA = Point();
            uvB = Point();
            uvC = Point();
        }
        
        uvPoints->addObject(LHValue::create(uvA));
        uvPoints->addObject(LHValue::create(uvB));
        uvPoints->addObject(LHValue::create(uvC));

        
        colors->addObject(LHValue::create(c4A));
        colors->addObject(LHValue::create(c4B));
        colors->addObject(LHValue::create(c4C));
    }
    
    _drawNode->setShapeTriangles(shapeTriangles, uvPoints, colors);
}