Classes
struct	AIEvresult
	A struct indicating an event that may or may not be executed. More...

struct	ElemAttrMap

Functions
void	GeneralAIEventBegin (void userData, const XML_Char name, const XML_Char **atts)

void	GeneralAIEventEnd (void userData, const XML_Char name)

void	LoadAI (const char *filename, ElemAttrMap &result, const string &faction)

void	LoadAI (const char *filename, ElemAttrMap &result, const std::string &faction)

Variables
const int	AIUNKNOWN = 0

const int	AIMIN = 1

const int	AIMAX = 2

const int	AISCRIPT = 3

const int	AINOT = 4

const int	TIMEIT = 5

const int	OBEDIENCE = 6

const int	TIMETOINTERRUPT = 7

const int	PRIORITY = 8

const XMLSupport::EnumMap::Pair	AIattribute_names []

const XMLSupport::EnumMap	attr_map (AIattribute_names, 9)

Detailed Description

General namespace that does nothing on its own, but Deals with the parsing of an XML file tha tcontains a number of event "if" statements Each statement can have a minimum, max value and a "not" flag to invert it and the type references the enum in the class using this one, and is eventually only used for the "not" tag

Function Documentation

void AIEvents::GeneralAIEventBegin	(	void *	userData,
		const XML_Char *	name,
		const XML_Char **	atts
	)

Definition at line 82 of file event_xml.cpp.

References AIMAX, AIMIN, AINOT, AISCRIPT, attr_map, AIEvents::ElemAttrMap::element_map, float, AIEvents::ElemAttrMap::level, XMLSupport::EnumMap::lookup(), max(), AIEvents::ElemAttrMap::maxtime, min(), AIEvents::ElemAttrMap::obedience, OBEDIENCE, XMLSupport::parse_float(), PRIORITY, AIEvents::ElemAttrMap::result, TIMEIT, and TIMETOINTERRUPT.

Referenced by LoadAI().

 {
     AttributeList attributes( atts );
     string aiscriptname( "" );
     float  min = -FLT_MAX;
     float  max = FLT_MAX;
     ElemAttrMap *eam = ( (ElemAttrMap*) userData );
     float  timetofinish    = eam->maxtime;
     float  timetointerrupt = 0;
     int    elem     = eam->element_map.lookup( name );
     AttributeList::const_iterator iter;
     float  priority = 4;
     eam->level++;
     if (elem == 0) {
         eam->result.push_back( std::list< AIEvresult > () );
         eam->result.push_back( std::list< AIEvresult > () );
         for (iter = attributes.begin(); iter != attributes.end(); iter++) {
             switch ( attr_map.lookup( (*iter).name ) )
             {
             case TIMEIT:
                 eam->maxtime   = (short) XMLSupport::parse_float( (*iter).value );
                 break;
             case OBEDIENCE:
                 eam->obedience = (float) ( XMLSupport::parse_float( (*iter).value ) );
             }
         }
     } else {
         assert( eam->level != 1 && eam->result.size() >= 2 );         //might not have a back on result();
         if ( eam->result.back().size() != eam->result[eam->result.size()-2].size() )
             eam->result.push_back( eam->result.back() );
         for (iter = attributes.begin(); iter != attributes.end(); iter++) {
             switch ( attr_map.lookup( (*iter).name ) )
             {
             case AINOT:
                 elem = -elem;                 //since elem can't be 0 (see above) this will save the "not" info
                 break;
             case AIMIN:
                 min  = XMLSupport::parse_float( (*iter).value );
                 break;
             case AIMAX:
                 max  = XMLSupport::parse_float( (*iter).value );
                 break;
             case AISCRIPT:
                 aiscriptname    = (*iter).value;
                 break;
             case TIMEIT:
                 timetofinish    = XMLSupport::parse_float( (*iter).value );
                 break;
             case TIMETOINTERRUPT:
                 timetointerrupt = XMLSupport::parse_float( (*iter).value );
                 break;
             case PRIORITY:
                 priority = XMLSupport::parse_float( (*iter).value );
                 break;
             default:
                 break;
             }
         }
         AIEvresult newelem( elem, min, max, timetofinish, timetointerrupt, priority, aiscriptname );
         eam->result.back().push_back( newelem );
         eam->result[eam->result.size()-2].push_back( newelem );
     }
 }

void AIEvents::GeneralAIEventEnd	(	void *	userData,
		const XML_Char *	name
	)

Definition at line 146 of file event_xml.cpp.

References AIEvents::ElemAttrMap::level, and AIEvents::ElemAttrMap::result.

Referenced by LoadAI().

 {
     ElemAttrMap *eam = ( (ElemAttrMap*) userData );
     eam->level--;
     if (eam->result.back().size() == 0) {
         eam->result.pop_back();
         assert( eam->level == 0 );
     } else {
         eam->result.back().pop_back();
     }
 }

void AIEvents::LoadAI	(	const char *	filename,
		ElemAttrMap &	result,
		const std::string &	faction
	)

void AIEvents::LoadAI	(	const char *	filename,
		ElemAttrMap &	result,
		const string &	faction
	)

Definition at line 158 of file event_xml.cpp.

References VSFileSystem::AiFile, f, fprintf, GeneralAIEventBegin(), GeneralAIEventEnd(), VegaConfig::getVariable(), AIEvents::ElemAttrMap::level, AIEvents::ElemAttrMap::maxtime, AIEvents::ElemAttrMap::obedience, VSFileSystem::Ok, XMLSupport::parse_float(), and vs_config.

Referenced by getLogicOrInterrupt().

 {
     //returns obedience
     using namespace VSFileSystem;
     static float cfg_obedience = XMLSupport::parse_float( vs_config->getVariable( "AI",
                                                                                   "Targetting",
                                                                                   "obedience",
                                                                                   ".99" ) );
     result.obedience = cfg_obedience;
     result.maxtime   = 10;
     VSFile  f;
     VSError err;
     err = f.OpenReadOnly( filename, AiFile );
     if (err > Ok) {
         printf( "ai file %s not found\n", filename );
         string full_filename    = filename;
         full_filename = full_filename.substr( 0, strlen( filename )-4 );
         string::size_type where = full_filename.find_last_of( "." );
         string type = ".agg.xml";
         if (where != string::npos) {
             type = full_filename.substr( where );
             full_filename = full_filename.substr( 0, where )+".agg.xml";
             err  = f.OpenReadOnly( full_filename, AiFile );
         }
         if (err > Ok) {
             printf( "ai file %s again not found\n", full_filename.c_str() );
             full_filename  = "default";
             full_filename += type;
             err = f.OpenReadOnly( full_filename, AiFile );
         }
         if (err > Ok) {
             printf( "ai file again %s again not found\n", full_filename.c_str() );
             err = f.OpenReadOnly( "default.agg.xml", AiFile );
             if (err > Ok) {
                 fprintf( stderr, "ai file again default.agg.xml again not found\n" );
                 return;                 //Who knows what will happen now? Crash?
             }
         }
     }
     XML_Parser parser = XML_ParserCreate( NULL );
     XML_SetUserData( parser, &result );
     XML_SetElementHandler( parser, &GeneralAIEventBegin, &GeneralAIEventEnd );
     XML_Parse( parser, ( f.ReadFull() ).c_str(), f.Size(), 1 );
     f.Close();
     XML_ParserFree( parser );
     if (result.level != 0)
         fprintf( stderr, "Error loading AI script %s for faction %s. Final count not zero.\n", filename, faction.c_str() );
     result.level = 0;
 }

Variable Documentation

const XMLSupport::EnumMap::Pair AIEvents::AIattribute_names[]

Initial value:

= {
    EnumMap::Pair( "UNKNOWN",         AIUNKNOWN ),
    EnumMap::Pair( "min",             AIMIN ),
    EnumMap::Pair( "max",             AIMAX ),
    EnumMap::Pair( "not",             AINOT ),
    EnumMap::Pair( "Script",          AISCRIPT ),
    EnumMap::Pair( "time",            TIMEIT ),
    EnumMap::Pair( "obedience",       OBEDIENCE ),
    EnumMap::Pair( "timetointerrupt", TIMETOINTERRUPT ),
    EnumMap::Pair( "priority",        PRIORITY )
}