gParser Class Reference

#include <gParser.h>

Collaboration diagram for gParser:

[legend]

List of all members.

Public Member Functions
	gParser (gArena *anArena, eGrid *aGrid)
void	setSizeMultiplier (REAL aSizeMultiplier)
void	Parse ()
Protected Member Functions
bool	trueOrFalse (char *str)
char *	myxmlGetProp (xmlNodePtr cur, const char *name)
int	myxmlGetPropInt (xmlNodePtr cur, const char *name)
float	myxmlGetPropFloat (xmlNodePtr cur, const char *name)
bool	myxmlGetPropBool (xmlNodePtr cur, const char *name)
void	myxmlGetDirection (xmlNodePtr cur, float &x, float &y)
bool	isElement (const xmlChar *elementName, const xmlChar *searchedElement, const xmlChar *keyword=NULL)
bool	isValidAlternative (xmlNodePtr cur, const xmlChar *keyword=NULL)
void	processSubAlt (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword=NULL)
bool	isValidCodeName (const xmlChar *version)
bool	isValidDotNumber (const xmlChar *version)
bool	validateVersionSubRange (const xmlChar *subRange, const xmlChar *codeName, const xmlChar *dotVersion)
bool	xmlCharSearchReplace (xmlChar *&original, const xmlChar *searchPattern, const xmlChar *replace)
int	validateVersionRange (xmlChar *version, const xmlChar *codeName, const xmlChar *dotVersion)
void	endElementAlternative (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword)
void	parseAxes (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword)
void	parseSpawn (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword)
void	parseZone (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword)
bool	parseZoneArthemis_v1 (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword)
void	parseWall (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword)
bool	parseShapeCircle (eGrid *grid, xmlNodePtr cur, float &x, float &y, float &radius, float &growth, const xmlChar *keyword)
void	parseField (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword)
void	parseWorld (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword=NULL)
void	parseMap (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword=NULL)
void	parseSettings (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword=NULL)
void	parseSetting (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword)
void	parseAlternativeContent (eGrid *grid, xmlNodePtr cur)
void	parseWallLine (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword)
void	parseWallRect (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword)
void	parseObstacleWall (eGrid *grid, xmlNodePtr cur, const xmlChar *keyword)
Protected Attributes
float	sizeMultiplier
Private Member Functions
ePoint *	DrawRim (eGrid *grid, ePoint *start, eCoord const &stop, REAL h=10000)
Private Attributes
gArena *	theArena
eGrid *	theGrid
REAL	rimTexture

---

Detailed Description

Definition at line 35 of file gParser.h.

---

Constructor & Destructor Documentation

gParser::gParser	(	gArena *	anArena,
		eGrid *	aGrid
	)

Definition at line 100 of file gParser.cpp.

References NULL.

                                             :
        theArena(anArena),
        theGrid(aGrid),
        rimTexture(0),
        sizeMultiplier(0.0)
{
    m_Doc = NULL;

    // HACK - philippeqc
    // This seems as inconvenient as any other place to load the
    // static tables of variables and functions available.
    // It's run once per map loading, between round, so its basically
    // cost less vs the real structural mess that it cause ;)

    //  vars[tString("sizeMultiplier")] = &sizeMultiplier; // BAD dont use other than as an example, non static content

    //    tValue::Expr::functions[tString("time")] = &tSysTimeHack;
#ifdef DEBUG_ZONE_SYNC
    tValue::Expr::functions[tString("time2")] = &tSysTimeHack2;
#endif //DEBUG_ZONE_SYNC
    //    tValue::Expr::functions[tString("sizeMultiplier")] = &gArena::GetSizeMultiplierHack; // static

}

---

Member Function Documentation

ePoint * gParser::DrawRim	(	eGrid *	grid,
		ePoint *	start,
		eCoord const &	stop,
		REAL	h = 10000
	)			[private]

Definition at line 1689 of file gParser.cpp.

References eGrid::DrawLine(), REAL, rimTexture, and tNEW.

Referenced by parseObstacleWall(), parseWall(), parseWallLine(), and parseWallRect().

{
    // calculate the wall's length and the rim wall textures
    REAL length = (stop-(*start)).Norm();
    REAL rimTextureStop = rimTexture + length;

    // create wall
    tJUST_CONTROLLED_PTR< gWallRim > newWall = tNEW( gWallRim )(grid, rimTexture, rimTextureStop, h);

    // update rim texture
    rimTexture = rimTextureStop;

    // draw line with wall
    return grid->DrawLine( start, stop, newWall, 0 );

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::setSizeMultiplier

(

REAL

aSizeMultiplier

)

Definition at line 2160 of file gParser.cpp.

Referenced by gArena::PrepareGrid().

{
    // BOP
    sizeMultiplier = aSizeMultiplier;

Here is the caller graph for this function:

void gParser::Parse

(

)

Definition at line 2168 of file gParser.cpp.

References con, isElement(), isValidAlternative(), NULL, parseAlternativeContent(), parseMap(), parseWorld(), rimTexture, sg_Deprecated(), and theGrid.

Referenced by gArena::PrepareGrid().

{
    rimTexture = 0;
    xmlNodePtr cur;
    cur = xmlDocGetRootElement(m_Doc);

#ifdef ENABLE_ZONESV2
    monitors.clear();
#endif
#ifdef DEBUG_ZONE_SYNC
    newGameRound = true;
#endif //DEBUG_ZONE_SYNC

    if (cur == NULL) {
        con << "ERROR: Map file is blank\n";
        return;
    }

    if (isElement(cur->name, (const xmlChar *) "Resource")) {
        if (xmlStrcmp((const xmlChar *) "aamap", xmlGetProp(cur, (const xmlChar *) "type"))) {
            con << "Type aamap expected, found " << xmlGetProp(cur, (const xmlChar *) "type") << " instead\n";
            con << "formalise this message\n";
        }
        else {
            cur = cur->xmlChildrenNode;
            while (cur != NULL) {
                if (!xmlStrcmp(cur->name, (const xmlChar *)"text") || !xmlStrcmp(cur->name, (const xmlChar *)"comment")) {
                    /* Do nothing, but is required to eliminate all Text element */
                    /* text elements are half of any other elements, drop them here rather than perform countless test */
                }
                else if (isElement(cur->name, (const xmlChar *)"Map")) {
                    parseMap(theGrid, cur);
                }
                else if (isElement(cur->name, (const xmlChar *)"Alternative")) {
                    if (isValidAlternative(cur)) {
                        parseAlternativeContent(theGrid, cur);
                    }
                }
                cur = cur ? cur->next : NULL;
            }
        }
    }
    else if (isElement(cur->name, (const xmlChar *) "World")) {
        // Legacy code to support version 0.1 of the DTDs
        sg_Deprecated();

        cur = cur->xmlChildrenNode;
        while (cur != NULL) {
            if (!xmlStrcmp(cur->name, (const xmlChar *)"text") || !xmlStrcmp(cur->name, (const xmlChar *)"comment")) {}
            else if (isElement(cur->name, (const xmlChar *)"Map")) {
                // Map and world got swapped in the current DTD, that's why this looks a little strange.
                parseWorld (theGrid, cur);
            }
            else if (isElement(cur->name, (const xmlChar *)"Alternative")) {
                if (isValidAlternative(cur)) {
                    parseAlternativeContent(theGrid, cur);
                }
            }
            cur = cur->next;
        }
    }

#ifdef ENABLE_ZONESV2
    mapZones.clear();
#endif

    //        fprintf(stderr,"ERROR: Map file is missing root \'Resources\' node");

Here is the call graph for this function:

Here is the caller graph for this function:

bool gParser::trueOrFalse

(

char *

str

)

[protected]

Definition at line 125 of file gParser.cpp.

Referenced by myxmlGetPropBool().

{
    // This will work with true/false/yes/no/1/-1/0/etc
    return (!strncasecmp(str, "t", 1) || !strncasecmp(str, "y", 1) || atoi(str));
}

Here is the caller graph for this function:

char * gParser::myxmlGetProp	(	xmlNodePtr	cur,
		const char *	name
	)			[protected]

Definition at line 132 of file gParser.cpp.

Referenced by myxmlGetPropBool(), myxmlGetPropFloat(), myxmlGetPropInt(), and parseSetting().

                                                      {
    return (char *)xmlGetProp(cur, (const xmlChar *)name);
}

Here is the caller graph for this function:

int gParser::myxmlGetPropInt	(	xmlNodePtr	cur,
		const char *	name
	)			[protected]

Definition at line 137 of file gParser.cpp.

References myxmlGetProp(), and NULL.

Referenced by parseAxes(), and parseMap().

                                                         {
    char *v = myxmlGetProp(cur, name);
    if (v == NULL)      return 0;
    int r = atoi(v);
    xmlFree(v);
    return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

float gParser::myxmlGetPropFloat	(	xmlNodePtr	cur,
		const char *	name
	)			[protected]

Definition at line 174 of file gParser.cpp.

References myxmlGetProp(), and NULL.

Referenced by myxmlGetDirection(), parseAxes(), parseObstacleWall(), parseShapeCircle(), parseSpawn(), parseWall(), parseWallLine(), and parseWallRect().

                                                           {
    char *v = myxmlGetProp(cur, name);
    if (v == NULL)      return 0.;
    float r = atof(v);
    xmlFree(v);
    return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool gParser::myxmlGetPropBool	(	xmlNodePtr	cur,
		const char *	name
	)			[protected]

Definition at line 183 of file gParser.cpp.

References myxmlGetProp(), NULL, and trueOrFalse().

Referenced by parseAxes().

                                                          {
    char *v = myxmlGetProp(cur, name);
    if (v == NULL)      return false;
    bool r = trueOrFalse(v);
    xmlFree(v);
    return r;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::myxmlGetDirection	(	xmlNodePtr	cur,
		float &	x,
		float &	y
	)			[protected]

Definition at line 426 of file gParser.cpp.

References cosf(), M_PI, myxmlGetPropFloat(), myxmlHasProp, and sinf().

Referenced by parseAxes(), and parseSpawn().

{
    if (myxmlHasProp(cur, "angle")) {
        float angle = myxmlGetPropFloat(cur, "angle") * M_PI / 180.0;
        float speed = myxmlGetPropFloat(cur, "length");
        x = cosf(angle) * speed;
        y = sinf(angle) * speed;
    } else {
        x = myxmlGetPropFloat(cur, "xdir");
        y = myxmlGetPropFloat(cur, "ydir");
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool gParser::isElement	(	const xmlChar *	elementName,
		const xmlChar *	searchedElement,
		const xmlChar *	keyword = NULL
	)			[protected]

Definition at line 213 of file gParser.cpp.

References NULL.

Referenced by endElementAlternative(), isValidAlternative(), Parse(), parseAlternativeContent(), parseAxes(), parseField(), parseMap(), parseObstacleWall(), parseSettings(), parseShapeCircle(), parseWall(), parseWorld(), and parseZoneArthemis_v1().

                                                                                                      {
    bool valid = false;
    if (xmlStrcmp(elementName, searchedElement) == 0) {
        valid = true;
    }
    else {
        if (keyword != NULL) {
            xmlChar * searchedElementAndKeyword = xmlStrdup(searchedElement);
            searchedElementAndKeyword = xmlStrcat(searchedElementAndKeyword, keyword);
            if (xmlStrcmp(elementName, searchedElementAndKeyword) == 0) {
                valid = true;
            }
            xmlFree (searchedElementAndKeyword);
        }
    }

    return valid;
}

Here is the caller graph for this function:

bool gParser::isValidAlternative	(	xmlNodePtr	cur,
		const xmlChar *	keyword = NULL
	)			[protected]

Definition at line 239 of file gParser.cpp.

References isElement(), NULL, and validateVersionRange().

Referenced by endElementAlternative(), Parse(), parseAlternativeContent(), parseAxes(), parseField(), parseMap(), parseObstacleWall(), parseSettings(), parseShapeCircle(), parseWall(), parseWorld(), parseZoneArthemis_v1(), and processSubAlt().

                                                                   {
    xmlChar *version = xmlGetProp(cur, (const xmlChar *) "version");
    /*
     * Find non empty version and
     * Alternative element, ie those having a name starting by "Alternative" and
     * only the Alternative elements that are for our version, ie Arthemis
     */
    return ((version != NULL) && isElement(cur->name, (const xmlChar *)"Alternative", keyword) && validateVersionRange(version, (const xmlChar*)"Artemis", (const xmlChar*)"0.2.8.0") );
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::processSubAlt	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword = NULL
	)			[protected]

Definition at line 1832 of file gParser.cpp.

References isValidAlternative(), NULL, and parseAlternativeContent().

                                                                           {
    cur = cur->xmlChildrenNode;
    /* Quickly goes through all the sub element until a valid Alternative is found */
    while ( cur != NULL) {
        if (!xmlStrcmp(cur->name, (const xmlChar *)"text") || !xmlStrcmp(cur->name, (const xmlChar *)"comment")) {}
        else if (isValidAlternative(cur, keyword)) {
            parseAlternativeContent(grid, cur);
            return; /*We process only the first matching one*/
        }
        cur = cur->next;
    }

Here is the call graph for this function:

bool gParser::isValidCodeName

(

const xmlChar *

version

)

[protected]

Definition at line 250 of file gParser.cpp.

Referenced by validateVersionSubRange().

{
    const int NUMBER_NAMES = 24;
    xmlChar const *const names [] = { (const xmlChar*) "Artemis", (const xmlChar*) "Bachus", (const xmlChar*) "Cronus", (const xmlChar*) "Demeter", (const xmlChar*) "Epimetheus", (const xmlChar*) "Furiae", (const xmlChar*) "Gaia", (const xmlChar*) "Hades", (const xmlChar*) "Iapetos", (const xmlChar*) "Juno", (const xmlChar*) "Koios", (const xmlChar*) "Leto", (const xmlChar*) "Mars", (const xmlChar*) "Neptune", (const xmlChar*) "Okeanos", (const xmlChar*) "Prometheus", (const xmlChar*) "Rheia", (const xmlChar*) "Selene", (const xmlChar*) "Thanatos", (const xmlChar*) "Uranus", (const xmlChar*) "Vulcan", (const xmlChar*) "Wodan", (const xmlChar*) "Yggdrasil", (const xmlChar*) "Zeus"};
    /* Is is a valid codename*/
    int i;
    for (i=0; i<NUMBER_NAMES; i++)
    {
        if (xmlStrcmp(version, names[i]) == 0)
            return true;
    }

    return false;
}

Here is the caller graph for this function:

bool gParser::isValidDotNumber

(

const xmlChar *

version

)

[protected]

Definition at line 266 of file gParser.cpp.

Referenced by validateVersionSubRange().

{
    char * work = (char *) xmlStrdup(version);
    char * start = work;
    char * end = work;
    bool valid = false;
    /* Check that we have at least i.j.k.xxx */
    for (int i=0; i<3; i++)
    {
        strtol(start, &end, 10);
        if (start != end) {
            valid = true;
            start = end +1;
        }
        else {
            valid = false;
            break;
        }
    }
    xmlFree(work);
    return valid;
}

Here is the caller graph for this function:

bool gParser::validateVersionSubRange	(	const xmlChar *	subRange,
		const xmlChar *	codeName,
		const xmlChar *	dotVersion
	)			[protected]

Definition at line 291 of file gParser.cpp.

References isValidCodeName(), and isValidDotNumber().

Referenced by validateVersionRange().

{
    bool valid = false;
    int posDelimiter = xmlUTF8Strloc(subRange, (const xmlChar *) "-");
    if (posDelimiter != -1)
    {
        xmlChar * pre = xmlUTF8Strsub(subRange, 0, posDelimiter);
        xmlChar * post = xmlUTF8Strsub(subRange, posDelimiter + 1, xmlUTF8Strlen(subRange) - posDelimiter - 1 );

        if (xmlStrlen(pre) == 0)
            /* The range is of type <empty>-<something>, so we pass the first part */
            valid = true;
        else
        {
            if (isValidCodeName(pre))
                valid = ( xmlStrcmp(pre, codeName) <= 0 );
            else if (isValidDotNumber(pre))
                valid = ( xmlStrcmp(pre, dotVersion) <= 0 );
        }

        if (xmlStrlen(post) == 0)
            /* Reject ranges of types <something>-<empty>*/
            valid = true;
        else
        {
            if (isValidCodeName(post))
                valid &= ( xmlStrcmp(post, codeName) >= 0 );
            else if (isValidDotNumber(post))
                valid &= ( xmlStrcmp(post, dotVersion) >= 0 );
        }
    }
    else
    {
        if (isValidCodeName(subRange))
            valid = ( xmlStrcmp(subRange, codeName) == 0 );
        else if (isValidDotNumber(subRange))
            valid = ( xmlStrcmp(subRange, dotVersion) == 0 );
    }

    return valid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool gParser::xmlCharSearchReplace	(	xmlChar *&	original,
		const xmlChar *	searchPattern,
		const xmlChar *	replace
	)			[protected]

Definition at line 337 of file gParser.cpp.

References pos.

Referenced by validateVersionRange().

{
    int pos;

    int lenSearchPattern = xmlUTF8Strlen(searchPattern); /* number of character */
    int sizeSearchPattern = xmlUTF8Strsize(searchPattern, lenSearchPattern); /* number of bytes required*/

    /* Ugly hack as many function are lacking in string manipulation for xmlChar * */
    /* xmlUTF8Strloc can only find the location of a single character, and no xmlUTF8Str... function
       can return the location of a string in character position */
    /* We are looking for the first instance searchPattern and want its position in character */
    for (pos=0; pos<xmlUTF8Strlen(original); pos++)
    {
        if ( xmlStrncmp( xmlUTF8Strpos(original, pos), searchPattern, sizeSearchPattern) == 0 )
        {
            int count = xmlUTF8Strlen(original);
            xmlChar * pre = xmlUTF8Strsub(original, 0, pos);
            xmlChar * post = xmlUTF8Strsub(original, pos + lenSearchPattern, count - pos - lenSearchPattern );

            xmlFree(original);
            pre = xmlStrcat ( pre, replace);
            original = xmlStrcat ( pre, post );
            xmlFree(post);
            return true;
        }
    }

    return false;
}

Here is the caller graph for this function:

int gParser::validateVersionRange	(	xmlChar *	version,
		const xmlChar *	codeName,
		const xmlChar *	dotVersion
	)			[protected]

Definition at line 370 of file gParser.cpp.

References pos, validateVersionSubRange(), and xmlCharSearchReplace().

Referenced by isValidAlternative().

{
    xmlChar * copy = xmlStrdup(version);

    /* We allow numerical version to be expressed with . or _, cut down one to simplify treatment */
    while ( xmlCharSearchReplace(copy, (const xmlChar *) "_", (const xmlChar *) ".") ) {} ;

    /* Eliminate all the white space */
    while ( xmlCharSearchReplace(copy, (const xmlChar *) " ", (const xmlChar *) "") ) {} ;

    xmlChar * remain = copy;
    bool valid = false;
    int pos=0;
    while (xmlStrlen(remain) && valid == false)
    {
        if ( ( pos = xmlUTF8Strloc(remain, (const xmlChar *) ",")) == -1)
        {
            /* This is the last sub-range to explore */
            pos = xmlUTF8Strlen(remain);
        }
        xmlChar * subRange = xmlUTF8Strndup(remain, pos);

        /* Is the current version in the presented range */
        valid |= validateVersionSubRange(subRange, codeName, dotVersion);
        xmlFree(subRange);

        /* Move away from the zone explored*/
        remain = const_cast<xmlChar *>( xmlUTF8Strpos(remain, pos + 1) );
    }

    xmlFree(copy);
    return valid;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::endElementAlternative	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword
	)			[protected]

Definition at line 410 of file gParser.cpp.

References isElement(), isValidAlternative(), NULL, and parseAlternativeContent().

Referenced by parseAxes(), parseObstacleWall(), parseSetting(), parseShapeCircle(), parseSpawn(), parseWall(), parseWallLine(), and parseWallRect().

                                                                                   {
    /* Verify if any sub elements are included, and if they contain any Alt
       Sub elements of Spawn arent defined in the current version*/
    cur = cur->xmlChildrenNode;
    while ( cur != NULL) {
        if (!xmlStrcmp(cur->name, (const xmlChar *)"text") || !xmlStrcmp(cur->name, (const xmlChar *)"comment")) {}
        else if (isElement(cur->name, (const xmlChar *)"Alternative", keyword)) {
            if (isValidAlternative(cur, keyword)) {
                parseAlternativeContent(grid, cur);
            }
        }
        cur = cur->next;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::parseAxes	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword
	)			[protected]

Definition at line 440 of file gParser.cpp.

References con, eCoord, endElementAlternative(), free, isElement(), isValidAlternative(), malloc, myxmlGetDirection(), myxmlGetPropBool(), myxmlGetPropFloat(), myxmlGetPropInt(), NULL, parseAlternativeContent(), and eGrid::SetWinding().

Referenced by parseAlternativeContent(), and parseField().

{
    int number;
    int normalize;

    number = myxmlGetPropInt(cur, "number");
    if (number < 1)
        return; // 1 axis is one-way. Keep it.

    normalize = myxmlGetPropBool(cur, "normalize");

    grid->SetWinding(number);

    cur = cur->xmlChildrenNode;
    if (cur != NULL)
    {
        int index = 0;
        eCoord *axisDir;
        axisDir = (eCoord *)malloc(sizeof(eCoord) * number);
        for (int i=0; i<number; i++){
            axisDir[i] = eCoord(1,0);
        }

        while (cur!= NULL) {
            if (!xmlStrcmp(cur->name, (const xmlChar *)"text") || !xmlStrcmp(cur->name, (const xmlChar *)"comment")) {}
            else if (isElement(cur->name, (const xmlChar *)"Axis", keyword)) {
                if (index < number) {
                    myxmlGetDirection(cur, axisDir[index].x, axisDir[index].y);
                    index++;
                }
                else {
                    con << "Invalid index #" << index << "\n";
                }
                /* Verify if any sub elements are included, and if they contain any Alt
                   Sub elements of Point arent defined in the current version*/
                endElementAlternative(grid, cur, keyword);
            }
            else if (isElement(cur->name, (const xmlChar *)"Point", keyword)) {
                if (index < number) {
                    axisDir[index].x = myxmlGetPropFloat(cur, "x");
                    axisDir[index].y = myxmlGetPropFloat(cur, "y");
                    index++;
                }
                else {
                    con << "Invalid index #" << index << "\n";
                }
                /* Verify if any sub elements are included, and if they contain any Alt
                   Sub elements of Point arent defined in the current version*/
                endElementAlternative(grid, cur, keyword);
            }
            else if (isElement(cur->name, (const xmlChar *)"Alternative", keyword)) {
                if (isValidAlternative(cur, keyword)) {
                    parseAlternativeContent(grid, cur);
                }
            }
            cur = cur->next;
        }
        grid->SetWinding(number, axisDir, normalize);
        free(axisDir);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::parseSpawn	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword
	)			[protected]

Definition at line 503 of file gParser.cpp.

References eCoord, endElementAlternative(), myxmlGetDirection(), myxmlGetPropFloat(), gArena::NewSpawnPoint(), and theArena.

Referenced by parseAlternativeContent(), and parseField().

{
    float x, y, xdir, ydir;

    x = myxmlGetPropFloat(cur, "x");
    y = myxmlGetPropFloat(cur, "y");
    myxmlGetDirection(cur, xdir, ydir);

    theArena->NewSpawnPoint(eCoord(x, y), eCoord(xdir, ydir));

    endElementAlternative(grid, cur, keyword);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::parseZone	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword
	)			[protected]

Definition at line 1568 of file gParser.cpp.

References mapVersion, and parseZoneArthemis_v1().

Referenced by parseAlternativeContent(), and parseField().

{
#ifdef ENABLE_ZONESV2
    switch (mapVersion)
    {
    case 1:
        // was, technically, without zones IIRC. But let's parse it anyway
    case 2:
        // switch to v2 when some sort of emulation layer is ready
        // we should probably check for the DTD, too; v1 zones are only possible
        // for 0.2.x dtds and 0.3.1-b and later, and v2 zones only for 0.3.1-a and
        // later.
        if( !parseZoneArthemis_v1(grid, cur, keyword) )
        {
            parseZoneBachus(grid, cur, keyword);
        }
        break;
    case 3:
        // well, the above is a really ugly hack to keep things working, better
        // let users of pure zone v2 maps upgrade them to map version 3.
        parseZoneBachus(grid, cur, keyword);
        break;
    default:
        parseZoneBachus(grid, cur, keyword);
        break;
    }
#else
    parseZoneArthemis_v1(grid, cur, keyword);
#endif

Here is the call graph for this function:

Here is the caller graph for this function:

bool gParser::parseZoneArthemis_v1	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword
	)			[protected]

Definition at line 1517 of file gParser.cpp.

References eCoord, isElement(), isValidAlternative(), nCLIENT, NULL, parseAlternativeContent(), parseShapeCircle(), nNetObject::RequestSync(), gZone::SetExpansionSpeed(), gZone::SetRadius(), gZone::SetRotationSpeed(), sn_GetNetState(), and tNEW.

Referenced by parseAlternativeContent(), parseField(), and parseZone().

{
    float x, y, radius, growth;
    bool shapeFound = false;
    xmlNodePtr shape = cur->xmlChildrenNode;

    while(shape != NULL && shapeFound==false) {
        if (!xmlStrcmp(cur->name, (const xmlChar *)"text") || !xmlStrcmp(cur->name, (const xmlChar *)"comment")) {}
        else if (isElement(shape->name, (const xmlChar *)"ShapeCircle", keyword)) {
            shapeFound = parseShapeCircle(grid, shape, x, y, radius, growth, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Alternative", keyword)) {
            if (isValidAlternative(cur, keyword)) {
                parseAlternativeContent(grid, cur);
            }
        }
        shape = shape->next;
    }

    if ( !shapeFound )
    {
        return false;
    }

    gZone * zone = NULL;
    if (sn_GetNetState() != nCLIENT )
    {
        if (!xmlStrcmp(xmlGetProp(cur, (const xmlChar *)"effect"), (const xmlChar *)"win")) {
            zone = tNEW( gWinZoneHack) ( grid, eCoord(x*sizeMultiplier,y*sizeMultiplier) );
        }
        else if (!xmlStrcmp(xmlGetProp(cur, (const xmlChar *)"effect"), (const xmlChar *)"death")) {
            zone = tNEW( gDeathZoneHack) ( grid, eCoord(x*sizeMultiplier,y*sizeMultiplier) );
        }
        else if (!xmlStrcmp(xmlGetProp(cur, (const xmlChar *)"effect"), (const xmlChar *)"fortress")) {
            zone = tNEW( gBaseZoneHack) ( grid, eCoord(x*sizeMultiplier,y*sizeMultiplier) );
        }

        // leaving zone undeleted is no memory leak here, the grid takes control of it
        if ( zone )
        {
            zone->SetRadius( radius*sizeMultiplier );
            zone->SetExpansionSpeed( growth*sizeMultiplier );
            zone->SetRotationSpeed( .3f );
            zone->RequestSync();
        }
    }

    return zone;

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::parseWall	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword
	)			[protected]

Definition at line 1741 of file gParser.cpp.

References DrawRim(), eCoord, endElementAlternative(), height, eGrid::Insert(), isElement(), isValidAlternative(), myxmlGetPropFloat(), NULL, parseAlternativeContent(), parseWallLine(), parseWallRect(), and REAL.

Referenced by parseAlternativeContent(), and parseField().

{
    ePoint *R = NULL, *sR = NULL;
    REAL ox, oy, x, y;

    REAL height = myxmlGetPropFloat(cur, "height");
    if ( height <= 0 )
        height = 10000;

    cur = cur->xmlChildrenNode;

    while (cur != NULL) {
        if (!xmlStrcmp(cur->name, (const xmlChar *)"text") || !xmlStrcmp(cur->name, (const xmlChar *)"comment")) {}
        else if (isElement(cur->name, (const xmlChar *)"Point", keyword)) {
            x = myxmlGetPropFloat(cur, "x");
            y = myxmlGetPropFloat(cur, "y");

            if (R == NULL)
                R = grid->Insert(eCoord(x, y) * sizeMultiplier);
            else
                R = this->DrawRim(grid, R, eCoord(x, y) * sizeMultiplier, height);

            // TODO-Alt:
            // if this function returns a point, use it in the wall. Otherwise, ignore what comes out.
            endElementAlternative(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"SavePos", keyword)) {
            sR = R;
            endElementAlternative(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"RestorePos", keyword)) {
            R = sR;
            endElementAlternative(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Line", keyword)) {
            parseWallLine(grid, cur, keyword);
            endElementAlternative(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Rectangle", keyword)) {
            parseWallRect(grid, cur, keyword);
            endElementAlternative(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Alternative", keyword)) {
            if (isValidAlternative(cur, keyword)) {
                parseAlternativeContent(grid, cur);
            }
        }
        cur = cur->next;
        ox = x;
        oy = y;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

bool gParser::parseShapeCircle	(	eGrid *	grid,
		xmlNodePtr	cur,
		float &	x,
		float &	y,
		float &	radius,
		float &	growth,
		const xmlChar *	keyword
	)			[protected]

Definition at line 1490 of file gParser.cpp.

References endElementAlternative(), isElement(), isValidAlternative(), myxmlGetPropFloat(), NULL, and parseAlternativeContent().

Referenced by parseZoneArthemis_v1().

{
    radius = myxmlGetPropFloat(cur, "radius");
    growth = myxmlGetPropFloat(cur, "growth");

    cur = cur->xmlChildrenNode;
    while( cur != NULL) {
        if (!xmlStrcmp(cur->name, (const xmlChar *)"text") || !xmlStrcmp(cur->name, (const xmlChar *)"comment")) {}
        else if (isElement(cur->name, (const xmlChar *)"Point", keyword)) {
            x = myxmlGetPropFloat(cur, "x");
            y = myxmlGetPropFloat(cur, "y");

            endElementAlternative(grid, cur, keyword);
            return true;
        }
        else if (isElement(cur->name, (const xmlChar *)"Alternative", keyword)) {
            if (isValidAlternative(cur, keyword)) {
                parseAlternativeContent(grid, cur);
            }
        }
        cur = cur->next;
    }
    return false;

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::parseField	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword
	)			[protected]

Definition at line 1928 of file gParser.cpp.

References isElement(), isValidAlternative(), NULL, parseAlternativeContent(), parseAxes(), parseObstacleWall(), parseSpawn(), parseWall(), parseWallLine(), parseWallRect(), parseZone(), and parseZoneArthemis_v1().

Referenced by parseAlternativeContent(), and parseWorld().

{
    cur = cur->xmlChildrenNode;
    while (cur != NULL) {
        if (!xmlStrcmp(cur->name, (const xmlChar *)"text") || !xmlStrcmp(cur->name, (const xmlChar *)"comment")) {}
        else if (isElement(cur->name, (const xmlChar *)"Axes", keyword)) {
            parseAxes(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Spawn", keyword)) {
            parseSpawn(grid, cur, keyword);
        }
#ifdef ENABLE_ZONESV2
        // Introduced in version 2, but no extra logic is required for it.
        else if (isElement(cur->name, (const xmlChar *)"Ownership", keyword)) {
            parseOwnership(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Monitor", keyword)) {
            parseMonitor(grid, cur, keyword);
        }
#endif
        else if (isElement(cur->name, (const xmlChar *)"Zone", keyword)) {
            parseZone(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Zone_v1", keyword)) {
            parseZoneArthemis_v1(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Wall", keyword)) {
            parseWall(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"ObstacleWall", keyword)) {
            parseObstacleWall(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Line", keyword)) {
            parseWallLine(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Rectangle", keyword)) {
            parseWallRect(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Alternative", keyword)) {
            if (isValidAlternative(cur, keyword)) {
                parseAlternativeContent(grid, cur);
            }
        }
        cur = cur->next;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::parseWorld	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword = NULL
	)			[protected]

Definition at line 2080 of file gParser.cpp.

References isElement(), isValidAlternative(), NULL, parseAlternativeContent(), and parseField().

Referenced by Parse(), parseAlternativeContent(), and parseMap().

{
    cur = cur->xmlChildrenNode;
    while (cur != NULL) {
        if (!xmlStrcmp(cur->name, (const xmlChar *)"text") || !xmlStrcmp(cur->name, (const xmlChar *)"comment")) {}
        else if (isElement(cur->name, (const xmlChar *)"Field", keyword)) {
            parseField(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Alternative", keyword)) {
            if (isValidAlternative(cur, keyword)) {
                parseAlternativeContent(grid, cur);
            }
        }
        cur = cur->next;

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::parseMap	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword = NULL
	)			[protected]

Definition at line 2137 of file gParser.cpp.

References isElement(), isValidAlternative(), mapVersion, myxmlGetPropInt(), NULL, parseAlternativeContent(), parseSettings(), parseWorld(), and theGrid.

Referenced by Parse(), and parseAlternativeContent().

{
    mapVersion = myxmlGetPropInt(cur, "version");

    cur = cur->xmlChildrenNode;
    while (cur != NULL) {
        if (!xmlStrcmp(cur->name, (const xmlChar *)"text") || !xmlStrcmp(cur->name, (const xmlChar *)"comment")) {}
        else if (isElement(cur->name, (const xmlChar *)"Settings", keyword)) {
            parseSettings (grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"World", keyword)) {
            parseWorld (theGrid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Alternative", keyword)) {
            if (isValidAlternative(cur, keyword)) {
                parseAlternativeContent(grid, cur);
            }
        }
        cur = cur->next;

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::parseSettings	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword = NULL
	)			[protected]

Definition at line 2116 of file gParser.cpp.

References gArena::GetSizeMultiplier(), isElement(), isValidAlternative(), NULL, parseAlternativeContent(), parseSetting(), and update_settings().

Referenced by parseAlternativeContent(), and parseMap().

{
    cur = cur->xmlChildrenNode;
    while (cur != NULL) {
        if (!xmlStrcmp(cur->name, (const xmlChar *)"text") || !xmlStrcmp(cur->name, (const xmlChar *)"comment")) {}
        else if (isElement(cur->name, (const xmlChar *)"Setting", keyword)) {
            parseSetting(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Alternative", keyword)) {
            if (isValidAlternative(cur, keyword)) {
                parseAlternativeContent(grid, cur);
            }
        }
        cur = cur->next;
    }

    update_settings();

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::parseSetting	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword
	)			[protected]

Definition at line 2098 of file gParser.cpp.

References endElementAlternative(), tRecorderBase::IsPlayingBack(), tConfItemBase::LoadAll(), tConfItemBase::LoadPlayback(), myxmlGetProp(), nCLIENT, sn_GetNetState(), and ss.

Referenced by parseAlternativeContent(), and parseSettings().

{
    if (strlen(myxmlGetProp(cur, "name")) && strlen(myxmlGetProp(cur, "value")) && sn_GetNetState() != nCLIENT )
    {
        std::stringstream ss;
        /* Yes it is ackward to generate a string that will be decifered on the other end*/
        ss << myxmlGetProp(cur, "name")  << " " << myxmlGetProp(cur, "value");
        if ( tRecorder::IsPlayingBack() )
            tConfItemBase::LoadPlayback( true );
        else
            tConfItemBase::LoadAll(ss);
    }
    /* Verify if any sub elements are included, and if they contain any Alt
       Sub elements of Point arent defined in the current version*/

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::parseAlternativeContent	(	eGrid *	grid,
		xmlNodePtr	cur
	)			[protected]

Definition at line 1847 of file gParser.cpp.

References isElement(), isValidAlternative(), NULL, parseAxes(), parseField(), parseMap(), parseObstacleWall(), parseSetting(), parseSettings(), parseSpawn(), parseWall(), parseWallLine(), parseWallRect(), parseWorld(), parseZone(), and parseZoneArthemis_v1().

Referenced by endElementAlternative(), Parse(), parseAxes(), parseField(), parseMap(), parseObstacleWall(), parseSettings(), parseShapeCircle(), parseWall(), parseWorld(), parseZoneArthemis_v1(), and processSubAlt().

{
    const xmlChar * keyword = xmlGetProp(cur, (const xmlChar *) "keyword");

    cur = cur->xmlChildrenNode;

    while (cur != NULL) {
        if (!xmlStrcmp(cur->name, (const xmlChar *)"text") || !xmlStrcmp(cur->name, (const xmlChar *)"comment")) {
            /* Do nothing, but is required to eliminate all Text and Comment element */
            /* text elements are half of any other elements, drop them here rather than perform countless test */
        }
        /* The elements of Field */
        else if (isElement(cur->name, (const xmlChar *)"Axes", keyword)) {
            parseAxes(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Spawn", keyword)) {
            parseSpawn(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Zone", keyword)) {
            parseZone(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Zone_v1", keyword)) {
            parseZoneArthemis_v1(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Wall", keyword)) {
            parseWall(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"ObstacleWall", keyword)) {
            parseObstacleWall(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Line", keyword)) {
            parseWallLine(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Rectangle", keyword)) {
            parseWallRect(grid, cur, keyword);
        }
        /* The settings */
        else if (isElement(cur->name, (const xmlChar *)"Settings", keyword)) {
            parseSettings(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Setting", keyword)) {
            parseSetting(grid, cur, keyword);
        }
        /* The big holders*/
        else if (isElement(cur->name, (const xmlChar *)"Map", keyword)) {
            parseMap(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"World", keyword)) {
            parseWorld(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Field", keyword)) {
            parseField(grid, cur, keyword);
        }
        /* Those that cant affect the instance directly. They should return something */
        else if (isElement(cur->name, (const xmlChar *)"Axis", keyword)) {
            // TODO-Alt2: A method to read in Axis data and return an "Axis object" to be captured at some other level.
            // The same method could be used inside of the parseAxes
            //            parseAxis(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Point", keyword)) {
            // TODO-Alt2: A method to read in Point data and return an "Point object" to be captured at some other level.
            // The same method could be used to read all "Point" in the code
            //            parsePoint(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"ShapeCircle", keyword)) {
            // TODO-Alt2: parseShapeCircle should be modified to return an "ShapeCircle object" to be captured at some other level.
            // The same method could be used inside of the parseZone
            //            parseShapeCircle(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Alternative", keyword)) {
            if (isValidAlternative(cur, keyword)) {
                parseAlternativeContent(grid, cur);
            }
        }


        cur = cur->next;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::parseWallLine	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword
	)			[protected]

Definition at line 1706 of file gParser.cpp.

References DrawRim(), eCoord, endElementAlternative(), eGrid::Insert(), myxmlGetPropFloat(), REAL, and sg_Deprecated().

Referenced by parseAlternativeContent(), parseField(), and parseWall().

                                                                           {
    REAL ox, oy, x, y;
    ePoint *R;

    ox = myxmlGetPropFloat(cur, "startx");
    oy = myxmlGetPropFloat(cur, "starty");
    x = myxmlGetPropFloat(cur,   "endx");
    y = myxmlGetPropFloat(cur,   "endy");
    R = grid->Insert(eCoord(ox, oy) * sizeMultiplier);
    R = this->DrawRim(grid, R, eCoord(x, y) * sizeMultiplier);
    sg_Deprecated();

    endElementAlternative(grid, cur, keyword);

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::parseWallRect	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword
	)			[protected]

Definition at line 1722 of file gParser.cpp.

References DrawRim(), eCoord, endElementAlternative(), eGrid::Insert(), myxmlGetPropFloat(), REAL, and sg_Deprecated().

Referenced by parseAlternativeContent(), parseField(), and parseWall().

                                                                           {
    REAL ox, oy, x, y;
    ePoint *R;

    ox = myxmlGetPropFloat(cur, "startx");
    oy = myxmlGetPropFloat(cur, "starty");
    x = myxmlGetPropFloat(cur,   "endx");
    y = myxmlGetPropFloat(cur,   "endy");
    R = grid->Insert(eCoord(ox, oy) * sizeMultiplier);
    R = this->DrawRim( grid, R, eCoord( x, oy) * sizeMultiplier);
    R = this->DrawRim( grid, R, eCoord( x,  y) * sizeMultiplier);
    R = this->DrawRim( grid, R, eCoord(ox,  y) * sizeMultiplier);
    R = this->DrawRim( grid, R, eCoord(ox, oy) * sizeMultiplier);
    sg_Deprecated();

    endElementAlternative(grid, cur, keyword);

Here is the call graph for this function:

Here is the caller graph for this function:

void gParser::parseObstacleWall	(	eGrid *	grid,
		xmlNodePtr	cur,
		const xmlChar *	keyword
	)			[protected]

Definition at line 1795 of file gParser.cpp.

References DrawRim(), eCoord, endElementAlternative(), height, eGrid::Insert(), isElement(), isValidAlternative(), myxmlGetPropFloat(), NULL, parseAlternativeContent(), REAL, and sg_Deprecated().

Referenced by parseAlternativeContent(), and parseField().

{
    ePoint *R = NULL;
    REAL x, y;

    REAL height = myxmlGetPropFloat(cur, "height");
    cur = cur->xmlChildrenNode;

    while (cur != NULL) {
        if (!xmlStrcmp(cur->name, (const xmlChar *)"text") || !xmlStrcmp(cur->name, (const xmlChar *)"comment")) {}
        else if (isElement(cur->name, (const xmlChar *)"Point", keyword)) {
            x = myxmlGetPropFloat(cur, "x");
            y = myxmlGetPropFloat(cur, "y");

            if (R == NULL)
                R = grid->Insert(eCoord(x, y) * sizeMultiplier);
            else
                R = this->DrawRim(grid, R, eCoord(x, y) * sizeMultiplier, height );
            endElementAlternative(grid, cur, keyword);
        }
        else if (isElement(cur->name, (const xmlChar *)"Alternative", keyword)) {
            if (isValidAlternative(cur, keyword)) {
                parseAlternativeContent(grid, cur);
            }
        }
        cur = cur->next;
    }
    sg_Deprecated();

Here is the call graph for this function:

Here is the caller graph for this function:

---

Member Data Documentation

gArena* gParser::theArena [private]

Definition at line 37 of file gParser.h.

Referenced by parseSpawn().

eGrid* gParser::theGrid [private]

Definition at line 38 of file gParser.h.

Referenced by Parse(), and parseMap().

REAL gParser::rimTexture [private]

Definition at line 40 of file gParser.h.

Referenced by DrawRim(), and Parse().

float gParser::sizeMultiplier [protected]

Definition at line 128 of file gParser.h.

---

The documentation for this class was generated from the following files:

• src/tron/gParser.h
• src/tron/gParser.cpp

---