//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
int ReadValue(int source, float *value)
{
pc_token_t token;
if (!PC_ExpectAnyToken(source, &token)) return qfalse;
if (!strcmp(token.string, "-"))
{
PC_SourceWarning(source, "negative value set to zero");
if(!PC_ExpectAnyToken(source, &token))
{
PC_SourceError(source, "Missing return value");
return qfalse;
}
}
if (token.type != TT_NUMBER)
{
PC_SourceError(source, "invalid return value %s", token.string);
return qfalse;
}
*value = token.floatvalue;
return qtrue;
} //end of the function ReadValue
/*
=================
PC_Int_Parse
=================
*/
bool PC_Int_Parse( int handle, int *i )
{
pc_token_t token;
int negative = false;
if ( !trap_Parse_ReadToken( handle, &token ) )
{
return false;
}
if ( token.string[ 0 ] == '(' )
{
float f;
if ( PC_Expression_Parse( handle, &f ) )
{
*i = ( int ) f;
return true;
}
else
{
return false;
}
}
if ( token.string[ 0 ] == '-' )
{
if ( !trap_Parse_ReadToken( handle, &token ) )
{
return false;
}
negative = true;
}
if ( token.type != TT_NUMBER )
{
PC_SourceError( handle, "expected integer but found %s", token.string );
return false;
}
*i = token.intvalue;
if ( negative )
{
*i = -*i;
}
return true;
}
/*
=================
PC_Float_Parse
=================
*/
bool PC_Float_Parse( int handle, float *f )
{
pc_token_t token;
int negative = false;
if ( !trap_Parse_ReadToken( handle, &token ) )
{
return false;
}
if ( token.string[ 0 ] == '(' )
{
return PC_Expression_Parse( handle, f );
}
if ( token.string[ 0 ] == '-' )
{
if ( !trap_Parse_ReadToken( handle, &token ) )
{
return false;
}
negative = true;
}
if ( token.type != TT_NUMBER )
{
PC_SourceError( handle, "expected float but found %s", token.string );
return false;
}
if ( negative )
{
*f = -token.floatvalue;
}
else
{
*f = token.floatvalue;
}
return true;
}
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
weightconfig_t *ReadWeightConfig(char *filename)
{
int newindent, avail = 0, n;
pc_token_t token;
int source;
fuzzyseperator_t *fs;
weightconfig_t *config = NULL;
int starttime;
starttime = trap_Milliseconds();
if (!bot_reloadcharacters.integer)
{
avail = -1;
for( n = 0; n < MAX_WEIGHT_FILES; n++ )
{
config = weightFileList[n];
if( !config )
{
if( avail == -1 )
{
avail = n;
} //end if
continue;
} //end if
if( strcmp( filename, config->filename ) == 0 )
{
//BotAI_Print( PRT_MESSAGE, "retained %s\n", filename );
return config;
} //end if
} //end for
if( avail == -1 )
{
BotAI_Print( PRT_ERROR, "weightFileList was full trying to load %s\n", filename );
return NULL;
} //end if
} //end if
source = trap_PC_LoadSource(filename, BOTFILESBASEFOLDER);
if (!source)
{
BotAI_Print(PRT_ERROR, "counldn't load %s\n", filename);
return NULL;
} //end if
//
config = (weightconfig_t *) trap_HeapMalloc(sizeof(weightconfig_t));
config->numweights = 0;
Q_strncpyz( config->filename, filename, sizeof(config->filename) );
//parse the item config file
while(trap_PC_ReadToken(source, &token))
{
if (!strcmp(token.string, "weight"))
{
if (config->numweights >= MAX_WEIGHTS)
{
PC_SourceWarning(source, "too many fuzzy weights");
break;
} //end if
if (!PC_ExpectTokenType(source, TT_STRING, 0, &token))
{
FreeWeightConfig(config);
trap_PC_FreeSource(source);
return NULL;
} //end if
config->weights[config->numweights].name = (char *) trap_HeapMalloc(strlen(token.string) + 1);
strcpy(config->weights[config->numweights].name, token.string);
if (!PC_ExpectAnyToken(source, &token))
{
FreeWeightConfig(config);
trap_PC_FreeSource(source);
return NULL;
} //end if
newindent = qfalse;
if (!strcmp(token.string, "{"))
{
newindent = qtrue;
if (!PC_ExpectAnyToken(source, &token))
{
FreeWeightConfig(config);
trap_PC_FreeSource(source);
return NULL;
} //end if
} //end if
if (!strcmp(token.string, "switch"))
{
fs = ReadFuzzySeperators_r(source);
if (!fs)
{
FreeWeightConfig(config);
trap_PC_FreeSource(source);
return NULL;
} //end if
config->weights[config->numweights].firstseperator = fs;
} //end if
else if (!strcmp(token.string, "return"))
{
fs = (fuzzyseperator_t *) trap_HeapMalloc(sizeof(fuzzyseperator_t));
fs->index = 0;
fs->value = MAX_INVENTORYVALUE;
fs->next = NULL;
fs->child = NULL;
if (!ReadFuzzyWeight(source, fs))
{
trap_HeapFree(fs);
FreeWeightConfig(config);
trap_PC_FreeSource(source);
return NULL;
} //end if
config->weights[config->numweights].firstseperator = fs;
} //end else if
else
{
PC_SourceError(source, "invalid name %s", token.string);
FreeWeightConfig(config);
trap_PC_FreeSource(source);
return NULL;
} //end else
if (newindent)
{
if (!PC_ExpectTokenString(source, "}"))
{
FreeWeightConfig(config);
trap_PC_FreeSource(source);
return NULL;
} //end if
} //end if
config->numweights++;
} //end if
else
{
PC_SourceError(source, "invalid name %s", token.string);
FreeWeightConfig(config);
trap_PC_FreeSource(source);
return NULL;
} //end else
} //end while
//free the source at the end of a pass
trap_PC_FreeSource(source);
//if the file was located in a pak file
BotAI_Print(PRT_DEVELOPER, "loaded %s\n", filename);
BotAI_Print(PRT_DEVELOPER, "weights loaded in %d msec\n", trap_Milliseconds() - starttime);
//
if (!bot_reloadcharacters.integer)
{
weightFileList[avail] = config;
} //end if
//
return config;
} //end of the function ReadWeightConfig
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
fuzzyseperator_t *ReadFuzzySeperators_r(int source)
{
int newindent, index, def, founddefault;
pc_token_t token;
fuzzyseperator_t *fs, *lastfs, *firstfs;
founddefault = qfalse;
firstfs = NULL;
lastfs = NULL;
if (!PC_ExpectTokenString(source, "(")) return NULL;
if (!PC_ExpectTokenType(source, TT_NUMBER, TT_INTEGER, &token)) return NULL;
index = token.intvalue;
if (!PC_ExpectTokenString(source, ")")) return NULL;
if (!PC_ExpectTokenString(source, "{")) return NULL;
if (!PC_ExpectAnyToken(source, &token)) return NULL;
do
{
def = !strcmp(token.string, "default");
if (def || !strcmp(token.string, "case"))
{
fs = (fuzzyseperator_t *) trap_HeapMalloc(sizeof(fuzzyseperator_t));
fs->index = index;
if (lastfs) lastfs->next = fs;
else firstfs = fs;
lastfs = fs;
if (def)
{
if (founddefault)
{
PC_SourceError(source, "switch already has a default");
FreeFuzzySeperators_r(firstfs);
return NULL;
} //end if
fs->value = MAX_INVENTORYVALUE;
founddefault = qtrue;
} //end if
else
{
if (!PC_ExpectTokenType(source, TT_NUMBER, TT_INTEGER, &token))
{
FreeFuzzySeperators_r(firstfs);
return NULL;
} //end if
fs->value = token.intvalue;
} //end else
if (!PC_ExpectTokenString(source, ":") || !PC_ExpectAnyToken(source, &token))
{
FreeFuzzySeperators_r(firstfs);
return NULL;
} //end if
newindent = qfalse;
if (!strcmp(token.string, "{"))
{
newindent = qtrue;
if (!PC_ExpectAnyToken(source, &token))
{
FreeFuzzySeperators_r(firstfs);
return NULL;
} //end if
} //end if
if (!strcmp(token.string, "return"))
{
if (!ReadFuzzyWeight(source, fs))
{
FreeFuzzySeperators_r(firstfs);
return NULL;
} //end if
} //end if
else if (!strcmp(token.string, "switch"))
{
fs->child = ReadFuzzySeperators_r(source);
if (!fs->child)
{
FreeFuzzySeperators_r(firstfs);
return NULL;
} //end if
} //end else if
else
{
PC_SourceError(source, "invalid name %s", token.string);
return NULL;
} //end else
if (newindent)
{
if (!PC_ExpectTokenString(source, "}"))
{
FreeFuzzySeperators_r(firstfs);
return NULL;
} //end if
} //end if
} //end if
else
{
FreeFuzzySeperators_r(firstfs);
PC_SourceError(source, "invalid name %s", token.string);
return NULL;
} //end else
if (!PC_ExpectAnyToken(source, &token))
{
FreeFuzzySeperators_r(firstfs);
return NULL;
} //end if
} while(strcmp(token.string, "}"));
//
if (!founddefault)
{
PC_SourceWarning(source, "switch without default");
fs = (fuzzyseperator_t *) trap_HeapMalloc(sizeof(fuzzyseperator_t));
fs->index = index;
fs->value = MAX_INVENTORYVALUE;
fs->weight = 0;
fs->next = NULL;
fs->child = NULL;
if (lastfs) lastfs->next = fs;
else firstfs = fs;
} //end if
//
return firstfs;
} //end of the function ReadFuzzySeperators_r
//===========================================================================
//
// Parameter: -
// Returns: -
// Changes Globals: -
//===========================================================================
qboolean BotLoadCharacterFromFile(char *charfile, int skill, bot_character_t *ch)
{
int indent, index, foundcharacter;
int source;
pc_token_t token;
foundcharacter = qfalse;
//a bot character is parsed in two phases
source = trap_PC_LoadSource(charfile, BOTFILESBASEFOLDER);
if (!source)
{
BotAI_Print(PRT_ERROR, "counldn't load %s\n", charfile);
return qfalse;
} //end if
strcpy(ch->filename, charfile);
while(trap_PC_ReadToken(source, &token))
{
if (!strcmp(token.string, "skill"))
{
if (!PC_ExpectTokenType(source, TT_NUMBER, 0, &token))
{
trap_PC_FreeSource(source);
BotFreeCharacterStrings(ch);
return qfalse;
} //end if
if (!PC_ExpectTokenString(source, "{"))
{
trap_PC_FreeSource(source);
BotFreeCharacterStrings(ch);
return qfalse;
} //end if
//if it's the correct skill
if (skill < 0 || token.intvalue == skill)
{
foundcharacter = qtrue;
ch->skill = token.intvalue;
while(PC_ExpectAnyToken(source, &token))
{
if (!strcmp(token.string, "}")) break;
if (token.type != TT_NUMBER || !(token.subtype & TT_INTEGER))
{
PC_SourceError(source, "expected integer index, found %s", token.string);
trap_PC_FreeSource(source);
BotFreeCharacterStrings(ch);
return qfalse;
} //end if
index = token.intvalue;
if (index < 0 || index > MAX_CHARACTERISTICS)
{
PC_SourceError(source, "characteristic index out of range [0, %d]", MAX_CHARACTERISTICS);
trap_PC_FreeSource(source);
BotFreeCharacterStrings(ch);
return qfalse;
} //end if
if (ch->c[index].type)
{
PC_SourceError(source, "characteristic %d already initialized", index);
trap_PC_FreeSource(source);
BotFreeCharacterStrings(ch);
return qfalse;
} //end if
if (!PC_ExpectAnyToken(source, &token))
{
trap_PC_FreeSource(source);
BotFreeCharacterStrings(ch);
return qfalse;
} //end if
if (token.type == TT_NUMBER)
{
if (token.subtype & TT_FLOAT)
{
ch->c[index].value._float = token.floatvalue;
ch->c[index].type = CT_FLOAT;
} //end if
else
{
ch->c[index].value.integer = token.intvalue;
ch->c[index].type = CT_INTEGER;
} //end else
} //end if
else if (token.type == TT_STRING)
{
// ZTM: FIXME: ### I think I made this be done in the engine
//StripDoubleQuotes(token.string);
ch->c[index].value.string = trap_Alloc(strlen(token.string)+1, NULL);
strcpy(ch->c[index].value.string, token.string);
ch->c[index].type = CT_STRING;
} //end else if
else
{
PC_SourceError(source, "expected integer, float or string, found %s", token.string);
trap_PC_FreeSource(source);
BotFreeCharacterStrings(ch);
return qfalse;
} //end else
} //end if
break;
} //end if
else
{
indent = 1;
while(indent)
{
if (!PC_ExpectAnyToken(source, &token))
{
trap_PC_FreeSource(source);
BotFreeCharacterStrings(ch);
return qfalse;
} //end if
if (!strcmp(token.string, "{")) indent++;
else if (!strcmp(token.string, "}")) indent--;
} //end while
} //end else
} //end if
else
{
PC_SourceError(source, "unknown definition %s", token.string);
trap_PC_FreeSource(source);
BotFreeCharacterStrings(ch);
return qfalse;
} //end else
} //end while
trap_PC_FreeSource(source);
//
if (!foundcharacter)
{
BotFreeCharacterStrings(ch);
return qfalse;
} //end if
return qtrue;
} //end of the function BotLoadCharacterFromFile
