To the extent possible under law, BrashMonkey, LLC
has waived all copyright and related or neighboring rights to the

.Scml Sample Pseudo-Code Implementation
(left column - below)

ScmlObject
{
    Folder folders[]; // <folder> tags
    Entity entities[]; // <entity> tags  
    Folder activeCharacterMap[];

    int currentEntity; 
    int currentAnimation; 

    float currentTime;    

    SpatialInfo characterInfo()
    {
	// Fill a SpatialInfo class with the 
        // x,y,angle,etc of this character in game
	
        // To avoid distortion the character keep 
        // scaleX and scaleY values equal

	// Make scaleX or scaleY negative to flip on that axis
		
	// Examples (scaleX,scaleY)
	// (1,1) Normal size
        // (-2.5,2.5) 2.5x the normal size, and flipped on the x axis
    }		
    void setCurrentTime(float newTime)
    {
        Entity currentEnt=entities[currentEntity];
	Animation currentAnim=currentEnt.animations[currentAnimation];
	currentAnim.setCurrentTime(newTime);
    }		
    void applyCharacterMap(CharacterMap charMap, bool reset)
    {
	if(reset)
	{
	    activeCharacterMap=folders;
	}
        for(m in charMap.maps[])
	{
	    MapInstruction currentMap=charMap.maps[m];
	    if(currentMap.tarFolder>-1&&currentMap.tarFile>-1)
	    {
	        Folder targetFolder=activeCharacterMap[currentMap.tarFolder];
		File targetFile=targetFolder.files[currentMap.tarFile];
		activeCharacterMap[folder].files[file]=targetFile;
 	    }
	}
    }		
}      

Folder
{
    string name;
    File files[]; // <file> tags
}

File
{
    string name; 
    float pivotX=0;
    float pivotY=1;
    (engine specific type) fileReference;
    // a reference to the image store in this file
}      

Entity
{
    string name;
    CharacterMap characterMaps[]; // <character_map> tags
    Animation animations[]; // <animation> tags
}

CharacterMap
{
    string name;
    MapInstruction maps[]; // <map> tags
}

MapInstruction
{
    int folder;
    int file;
    int tarFolder=-1;
    int tarFile=-1;
}

Animation
{
    string name;
    int length;
    int loopType=LOOPING; // enum : NO_LOOPING,LOOPING
    MainlineKey mainlineKeys[]; // <key> tags within a single <mainline> tag
    Timeline timelines[]; // <timeline> tags

    void setCurrentTime(float newTime)
    {
        if(loopType==NO_LOOPING)
        {
            newTime=min(newTime,length);
        }
        else if(loopType==LOOPING)
        {
            newTime=newTime%length;
        }

        updateCharacter(mainlineKeyFromTime(newTime),newTime);
    }
    void updateCharacter(MainlineKey mainKey,int newTime)
    {
        BoneTimelineKey transformedBoneKeys[];
        for(b in mainKey.boneRefs[])
        {
            SpatialInfo parentInfo;
            Ref currentRef=mainKey.boneRefs[b]; 
            if(currentRef.parent>=0)
            {
                parentInfo=transformBoneKeys[currentRef.parent].info;
            }
            else
            {
                parentInfo=characterInfo;
            }

            TimelineKey currentKey=keyFromRef(currentRef,newTime);
            currentKey.info=currentKey.info.unmapFromParent(parentInfo);
            transformBoneKeys.push(currentKey);
        }

        TimelineKey objectKeys[];
        for(o in mainKey.objRefs[])
        {
            SpatialInfo parentInfo;
            Ref currentRef=mainKey.objRefs[b];

            if(currentRef.parent>=0)
            {
                parentInfo=transformBoneKeys[currentRef.parent].info;
            }
            else
            {
                parentInfo=characterInfo;
            }

            TimelineKey currentKey=keyFromRef(currentRef,newTime);
            currentKey.info=currentKey.info.unmapFromParent(parentInfo);
            objectKeys.push(currentKey);
        }

        // <expose objectKeys to api users to retrieve AND replace objectKeys>

        for(k in objectKeys)
        {            
            objectKeys[k].paint();
        }
    }
    MainlineKey mainlineKeyFromTime(int time)
    {
        int currentMainKey=0;
        for(m in mainlineKeys)
        {
            if(mainlineKeys[m].time<=currentTime)
            {
                currentMainKey=m;
            }
            if(mainlineKeys[m]>=currentTime)
            {
                break;
            }
        }
        return mainlineKeys[currentMainKey];
    }	
   
    TimelineKey keyFromRef(Ref ref,int newTime)
    {
        Timeline timeline=timelines[ref.timeline];
        TimelineKey keyA=timeline.keys[ref.key];
        
        if(timeline.keys.size()==1)
        {
            return keyA;
        }
        
        int nextKeyIndex=ref.key+1;
        
        if(nextKeyIndex>=timeline.keys.size())
        {
            if(loopType=LOOPING)
            {
                nextKeyIndex=0; 
            }
            else
            {
                return keyA;
            }
        }
  
        TimelineKey keyB=timeline.keys[nextKeyIndex];
        int keyBTime=keyB.time;

        if(keyBTime<keyA.time)
        {
            keyBTime=keyBTime+length;
        }

        return keyA.interpolate(keyB,keyBTime,newTime);
    }	
}     

        <animation 
                id="0" 
                name="animation name" 
                length="<length in milliseconds>"
                looping="true,false"> 

MainlineKey
{
    int time=0;
    Ref boneRefs[]; // <bone_ref> tags
    Ref objectRefs[]; // <object_ref> tags      

Ref
{   
    int parent=-1; // -1==no parent - uses ScmlObject spatialInfo as parentInfo
    int timeline;
    int key;   
}

// edittime features
// -----------------
// Sometimes an implementation is for a development tool with a visual editor.
// When levels are editted visually in the target environment, and you want
// to allow users to position a visual Spriter character, but full animation 
// and bone support may be overkill.

// Sometimes the editor runs on a separate engine from the game runtime, 
// is written by a different developer, or written in a different language.

// The abs_ values in the first mainline key of each animation are there
// to provide developers of edittime support a way to draw the first frame
// of each animation with minimal parsing of the scml, and without having 
// to worry about things like default pivot points or bone transformations.

// First fill a dom with the <folder> and <file> 'name's

Folder folders[];  // <folder>

Folder  
{
   string fileNames[]; // <file name="">
}

// the first <mainline> <key> in each <animation> 
void drawAtEdittime()
{
    for(o in <object_ref>)
    {
        if(<object_ref>[o] contains attribute 'folder') 
        {
            // using the image from the file at <folder>[folder].fileNames[file]
            // draw the image using a pivot of abs_pivot_x,abs_pivot_y
            // at abs_x,abs_y,abs_angle(counter clockwise)
	    // draw the image at it's original width * abs_scale_x
            // and it's original height * abs_scale_y
            // and with an opacity of abs_a (0.0 - 1.0)==(transparent - opaque)
        }
    }
}
 

Timeline
{
    string name;
    int objectType; // enum : SPRITE,BONE,BOX,POINT,SOUND,ENTITY,VARIABLE
    TimelineKey keys[]; // <key> tags within <timeline> tags    
}     

TimelineKey
{
    int time=0;
    int curveType=LINEAR; // enum : INSTANT,LINEAR,QUADRATIC,CUBIC
    float c1; 
    float c2; 
    
    TimelineKey interpolate(TimelineKey nextKey,int nextKeyTime,float currentTime)
    {
        return linear(nextKey,getTWithNextKey(nextKey,nextKeyTime,currentTime));
    }           
    float getTWithNextKey(TimelineKey nextKey,int nextKeyTime,float currentTime)
    {
        if(curveType==INSTANT || time==nextKey.time)
        {
            return 0;
        }
        
        float t=(currentTime-time)/(nextKey.time-time);

        if(curveType==LINEAR)
        {
            return t;        
        }
        else if(curveType==QUADRATIC)
        {
            return(quadratic(0.0,c1,1.0,t));
        }
        else if(curveType==CUBIC)
        {  
            return(cubic(0.0,c1,c2,1.0,t));
        }
    
        return 0; // Runtime should never reach here        
    }	
    TimelineKey linear(TimelineKey keyB,t)
    {
        // overridden in inherited types  return linear(this,keyB,t);
    }
}

SpatialTimelineKey : TimelineKey
{
    SpatialInfo info;
    void paint();
}

SpatialInfo
{
    float x=0; 
    float y=0; 
    float angle=0;
    float scaleX=1; 
    float scaleY=1; 
    float a=1;
    int spin=1;

    SpatialInfo unmapFromParent(SpatialInfo parentInfo)
    {
        SpatialInfo unmappedObj=this;
        unmappedObj.angle+=parentInfo.angle;
        unmappedObj.scaleX*=parentInfo.scaleX;
        unmappedObj.scaleY*=parentInfo.scaleY;
        unmappedObj.a*=parentInfo.a;

        if(x!=0||y!=0)  
        {
            preMultX=x*parentInfo.xScale;
            preMultY=y*parentInfo.yScale;
            float s = sin(toRadians(parentInfo.angle));
            float c = cos(toRadians(parentInfo.angle));
            unmappedObj.x = (preMultX * c) - (preMultY * s);
            unmappedObj.y = (preMultX * s) + (preMultY * c);
            unmappedObj.x+=parentInfo.x;
            unmappedObj.y+=parentInfo.y;
        }
        else 
        {
            // Mandatory optimization for future features           
            unmappedObj.x=parentInfo.x;
            unmappedObj.y=parentInfo.y;
        }

        return unmappedObj;
    }
}

BoneTimelineKey : SpatialTimelineKey
{
    // unimplemented in Spriter
    int length=200;
    int height=10;

    // override paint if you want debug visuals for bones
    void paint()
    {
        if(paintDebugBones)
        {
            float drawLength=length*scaleX;
            float drawHeight=height*scaleY;
            // paint debug bone representation 
            // e.g. line starting at x,y,at angle, 
            // of length drawLength, and height drawHeight
         }
    }           
    TimelineKey linear(TimelineKey keyB,float t)
    // keyB must be BoneTimelineKeys
    {
        BoneTimelineKey returnKey=this;
        returnKey.info=linear(info,keyB.info,spin,t);

        if(paintDebugBones)
        {
            returnKey.length=linear(length,keyB.length,t);
            returnKey.width=linear(width,keyB.width,t);
        }

        return returnKey;
    }
}

SpriteTimelineKey : SpatialTimelineKey
{
    int folder; // index of the folder within the ScmlObject
    int file;  
    bool useDefaultPivot; // true if missing pivot_x and pivot_y in object tag
    float pivot_x=0;
    float pivot_y=1;

    void paint()
    {
        int paintPivotX;
        int paintPivotY;
        if(useDefaultPivot)
        {
            paintPivotX=ScmlObject.activeCharacterMap[folder].files[file].pivotX;
            paintPivotY=ScmlObject.activeCharacterMap[folder].files[file].pivotY;
        }
        else
        {
            paintPivotX=pivot_x;
            paintPivotY=pivot_y;
        }
          
        // paint image represented by
        // ScmlObject.activeCharacterMap[folder].files[file],fileReference 
        // at x,y,angle (counter-clockwise), offset by paintPivotX,paintPivotY
    }
    TimelineKey linear(TimelineKey keyB,float t)
    // keyB must be SpriteTimelineKey
    {
        SpriteTimelineKey returnKey=this;
        returnKey.info=linear(info,keyB.info,spin,t);
        if(!useDefaultPoint)
        {
            returnKey.pivot_x=linear(pivot_x,keyB.pivot_x,t);
            returnKey.pivot_y=linear(pivot_y,keyB.pivot_y,t);
        }

        return returnKey;
    }
}    

float linear(float a,float b,float t)
{
    return ((b-a)*t)+a;
}
SpatialInfo linear(SpatialInfo infoA,SpatialInfo infoB,int spin,float t)
{
    SpatialInfo resultInfo;
    resultInfo.x=linear(infoA.x,infoB.x,t); 
    resultInfo.y=linear(infoA.y,infoB.y,t);  
    resultInfo.angle=angleLinear(infoA.angle,infoB.angle,spin,t); 
    resultInfo.scaleX=linear(infoA.scaleX,infoB.scaleX,t); 
    resultInfo.scaleY=linear(infoA.scaleY,infoB.scaleY,t); 
    resultInfo.a=linear(infoA.a,infoB.a,t); 
}
float angleLinear(float angleA,float angleB,int spin,float t)
{
    if(spin==0)
    {
        return angleA;
    }
    if(spin>0)
    {
        if((angleB-angleA)<0)
        {
            angleB+=360;
        }
    }
    else if(spin<0)
    {
        if((angleB-angleA)>0)
        {    
            angleB-=360;
        }
    }

    return linear(angleA,angleB,t);
}
float quadratic(float a,float b,float c,float t)
{
    return linear(linear(a,b,t),linear(b,c,t),t);
}
float cubic(float a,float b,float c,float d,float t)
{
    return linear(quadratic(a,b,c,t),quadratic(b,c,d,t),t);
}