When a data-, entity- or datalist resource requires another resource that has not yet been loaded the resource manager will load the required resource automatically. For this to work a resource that is required by another resource is referenced by it’s ID in the requesting resource by placing it into XML tags that end with an uppercase string ID. Because of this the name of property XML tags inside data resource files may only end with ID to mark a property that contains an ID to a referenced resource.

Sounds confusing enough? OK! What it all means is that if you write an XML tag with an uppercase ‘ID’ at the end of it’s name, that tag is recognized as containing a string which is an ID which references to another resource.

If the referenced resource is a text- or datalist resource the referring ID needs to be made up of two parts: first the ID of the text resource or the datalist resource and second the ID of the actual string as defined in the text resource file or the ID of the item in the datalist. These two parts need to be divided by a slash character ‘/’. To better understand this have a look at the structure of this example “infantry unit” entity definition:

<?xml version="1.0" encoding="UTF-8"?>
<data>
    <entity id="unitInfantry">
        <components>
            <component classID="tbsUnitPropertiesComponent">
                <nameID>textUnits/nameInfantryUnit</nameID>
                <descriptionID>textUnits/descInfantryUnit</descriptionID>
                <movementTypeID>movementTypes/movementTypeInfantry</movementTypeID>
                <price>1000</price>
            </component>
        </components>
    </entity>
</data>

… the component properties nameID and descriptionID are referencing to an ID of a text string nameInfantryUnit and descInfantryUnit which are both located in the text resource with ID textUnits. The movementTypeID property contains a referenced ID to a lookup-table datalist item with ID movementTypeInfantry in the datalist resource with ID movementTypes.

If a resource is already loaded and is then requested by a referencing resource, the resource is not loaded again but it’s refCount is increased.

In the tetragon engine resource files are categorized into several resource families. These families are:

• media – These are binary resource files. Basically every kind of assets file that is not XML-based, e.g. graphic files, audio files, binary files, 3D object files, SWF files, Shader files, etc.
• data – Data files are XML files that can contain any kind of custom data for use as data objects inside the engine. Every custom data format requires it’s own data parser so that the data from the XML file can successfully be transfered into data objects. These parsers should implement the IDataParser interface and may extend the DataParser class.
• entities – Entities are data objects that are utilized by tetragon’s Entity Component architecture. Entity data files are XML files that follow a certain structure so that they can be parsed in the same way by the engine. Entities are essentially abstract data objects that are made up of (and defined by) one or more entity components.
• lists – Data lists are objects that can store a list of properties and optionally a collection of datasets which in turn act as containers for a set of properties. Lists are typically used for such things like lookup tables whose contents are essentially static. They are defined in XML files with a certain structure.
• text – Text resources are XML files that follow a certain structure and only contain text data mapped by ID. They are used to separate text content from other data and the engine can process several text resource files that share the same ID but have different, localized text content.
• settings – Settings are XML files that contain global setting parameters for the application. They are read by the engine during application init and follow a certain structure.
• xml – XML resource files are an optional resource family that is used for XML files which should not be parsed into any data objects. Instead their data is provided to the engine as unprocessed, unparsed XML data.