db8ca37fa3
git-svn-id: https://svn.code.sf.net/p/q3cellshading/code/trunk@2 db09e94b-7117-0410-a7e6-85ae5ff6e0e9
790 lines
23 KiB
C
790 lines
23 KiB
C
/*
|
|
===========================================================================
|
|
Copyright (C) 1999-2005 Id Software, Inc.
|
|
|
|
This file is part of Quake III Arena source code.
|
|
|
|
Quake III Arena source code is free software; you can redistribute it
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the License,
|
|
or (at your option) any later version.
|
|
|
|
Quake III Arena source code is distributed in the hope that it will be
|
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Foobar; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
|
|
/*****************************************************************************
|
|
* name: be_ai_char.c
|
|
*
|
|
* desc: bot characters
|
|
*
|
|
* $Archive: /MissionPack/code/botlib/be_ai_char.c $
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#include "../game/q_shared.h"
|
|
#include "l_log.h"
|
|
#include "l_memory.h"
|
|
#include "l_utils.h"
|
|
#include "l_script.h"
|
|
#include "l_precomp.h"
|
|
#include "l_struct.h"
|
|
#include "l_libvar.h"
|
|
#include "aasfile.h"
|
|
#include "../game/botlib.h"
|
|
#include "../game/be_aas.h"
|
|
#include "be_aas_funcs.h"
|
|
#include "be_interface.h"
|
|
#include "../game/be_ai_char.h"
|
|
|
|
#define MAX_CHARACTERISTICS 80
|
|
|
|
#define CT_INTEGER 1
|
|
#define CT_FLOAT 2
|
|
#define CT_STRING 3
|
|
|
|
#define DEFAULT_CHARACTER "bots/default_c.c"
|
|
|
|
//characteristic value
|
|
union cvalue
|
|
{
|
|
int integer;
|
|
float _float;
|
|
char *string;
|
|
};
|
|
//a characteristic
|
|
typedef struct bot_characteristic_s
|
|
{
|
|
char type; //characteristic type
|
|
union cvalue value; //characteristic value
|
|
} bot_characteristic_t;
|
|
|
|
//a bot character
|
|
typedef struct bot_character_s
|
|
{
|
|
char filename[MAX_QPATH];
|
|
float skill;
|
|
bot_characteristic_t c[1]; //variable sized
|
|
} bot_character_t;
|
|
|
|
bot_character_t *botcharacters[MAX_CLIENTS + 1];
|
|
|
|
//========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//========================================================================
|
|
bot_character_t *BotCharacterFromHandle(int handle)
|
|
{
|
|
if (handle <= 0 || handle > MAX_CLIENTS)
|
|
{
|
|
botimport.Print(PRT_FATAL, "character handle %d out of range\n", handle);
|
|
return NULL;
|
|
} //end if
|
|
if (!botcharacters[handle])
|
|
{
|
|
botimport.Print(PRT_FATAL, "invalid character %d\n", handle);
|
|
return NULL;
|
|
} //end if
|
|
return botcharacters[handle];
|
|
} //end of the function BotCharacterFromHandle
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void BotDumpCharacter(bot_character_t *ch)
|
|
{
|
|
int i;
|
|
|
|
Log_Write("%s", ch->filename);
|
|
Log_Write("skill %d\n", ch->skill);
|
|
Log_Write("{\n");
|
|
for (i = 0; i < MAX_CHARACTERISTICS; i++)
|
|
{
|
|
switch(ch->c[i].type)
|
|
{
|
|
case CT_INTEGER: Log_Write(" %4d %d\n", i, ch->c[i].value.integer); break;
|
|
case CT_FLOAT: Log_Write(" %4d %f\n", i, ch->c[i].value._float); break;
|
|
case CT_STRING: Log_Write(" %4d %s\n", i, ch->c[i].value.string); break;
|
|
} //end case
|
|
} //end for
|
|
Log_Write("}\n");
|
|
} //end of the function BotDumpCharacter
|
|
//========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//========================================================================
|
|
void BotFreeCharacterStrings(bot_character_t *ch)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_CHARACTERISTICS; i++)
|
|
{
|
|
if (ch->c[i].type == CT_STRING)
|
|
{
|
|
FreeMemory(ch->c[i].value.string);
|
|
} //end if
|
|
} //end for
|
|
} //end of the function BotFreeCharacterStrings
|
|
//========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//========================================================================
|
|
void BotFreeCharacter2(int handle)
|
|
{
|
|
if (handle <= 0 || handle > MAX_CLIENTS)
|
|
{
|
|
botimport.Print(PRT_FATAL, "character handle %d out of range\n", handle);
|
|
return;
|
|
} //end if
|
|
if (!botcharacters[handle])
|
|
{
|
|
botimport.Print(PRT_FATAL, "invalid character %d\n", handle);
|
|
return;
|
|
} //end if
|
|
BotFreeCharacterStrings(botcharacters[handle]);
|
|
FreeMemory(botcharacters[handle]);
|
|
botcharacters[handle] = NULL;
|
|
} //end of the function BotFreeCharacter2
|
|
//========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//========================================================================
|
|
void BotFreeCharacter(int handle)
|
|
{
|
|
if (!LibVarGetValue("bot_reloadcharacters")) return;
|
|
BotFreeCharacter2(handle);
|
|
} //end of the function BotFreeCharacter
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void BotDefaultCharacteristics(bot_character_t *ch, bot_character_t *defaultch)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < MAX_CHARACTERISTICS; i++)
|
|
{
|
|
if (ch->c[i].type) continue;
|
|
//
|
|
if (defaultch->c[i].type == CT_FLOAT)
|
|
{
|
|
ch->c[i].type = CT_FLOAT;
|
|
ch->c[i].value._float = defaultch->c[i].value._float;
|
|
} //end if
|
|
else if (defaultch->c[i].type == CT_INTEGER)
|
|
{
|
|
ch->c[i].type = CT_INTEGER;
|
|
ch->c[i].value.integer = defaultch->c[i].value.integer;
|
|
} //end else if
|
|
else if (defaultch->c[i].type == CT_STRING)
|
|
{
|
|
ch->c[i].type = CT_STRING;
|
|
ch->c[i].value.string = (char *) GetMemory(strlen(defaultch->c[i].value.string)+1);
|
|
strcpy(ch->c[i].value.string, defaultch->c[i].value.string);
|
|
} //end else if
|
|
} //end for
|
|
} //end of the function BotDefaultCharacteristics
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
bot_character_t *BotLoadCharacterFromFile(char *charfile, int skill)
|
|
{
|
|
int indent, index, foundcharacter;
|
|
bot_character_t *ch;
|
|
source_t *source;
|
|
token_t token;
|
|
|
|
foundcharacter = qfalse;
|
|
//a bot character is parsed in two phases
|
|
PC_SetBaseFolder(BOTFILESBASEFOLDER);
|
|
source = LoadSourceFile(charfile);
|
|
if (!source)
|
|
{
|
|
botimport.Print(PRT_ERROR, "counldn't load %s\n", charfile);
|
|
return NULL;
|
|
} //end if
|
|
ch = (bot_character_t *) GetClearedMemory(sizeof(bot_character_t) +
|
|
MAX_CHARACTERISTICS * sizeof(bot_characteristic_t));
|
|
strcpy(ch->filename, charfile);
|
|
while(PC_ReadToken(source, &token))
|
|
{
|
|
if (!strcmp(token.string, "skill"))
|
|
{
|
|
if (!PC_ExpectTokenType(source, TT_NUMBER, 0, &token))
|
|
{
|
|
FreeSource(source);
|
|
BotFreeCharacterStrings(ch);
|
|
FreeMemory(ch);
|
|
return NULL;
|
|
} //end if
|
|
if (!PC_ExpectTokenString(source, "{"))
|
|
{
|
|
FreeSource(source);
|
|
BotFreeCharacterStrings(ch);
|
|
FreeMemory(ch);
|
|
return NULL;
|
|
} //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))
|
|
{
|
|
SourceError(source, "expected integer index, found %s\n", token.string);
|
|
FreeSource(source);
|
|
BotFreeCharacterStrings(ch);
|
|
FreeMemory(ch);
|
|
return NULL;
|
|
} //end if
|
|
index = token.intvalue;
|
|
if (index < 0 || index > MAX_CHARACTERISTICS)
|
|
{
|
|
SourceError(source, "characteristic index out of range [0, %d]\n", MAX_CHARACTERISTICS);
|
|
FreeSource(source);
|
|
BotFreeCharacterStrings(ch);
|
|
FreeMemory(ch);
|
|
return NULL;
|
|
} //end if
|
|
if (ch->c[index].type)
|
|
{
|
|
SourceError(source, "characteristic %d already initialized\n", index);
|
|
FreeSource(source);
|
|
BotFreeCharacterStrings(ch);
|
|
FreeMemory(ch);
|
|
return NULL;
|
|
} //end if
|
|
if (!PC_ExpectAnyToken(source, &token))
|
|
{
|
|
FreeSource(source);
|
|
BotFreeCharacterStrings(ch);
|
|
FreeMemory(ch);
|
|
return NULL;
|
|
} //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)
|
|
{
|
|
StripDoubleQuotes(token.string);
|
|
ch->c[index].value.string = GetMemory(strlen(token.string)+1);
|
|
strcpy(ch->c[index].value.string, token.string);
|
|
ch->c[index].type = CT_STRING;
|
|
} //end else if
|
|
else
|
|
{
|
|
SourceError(source, "expected integer, float or string, found %s\n", token.string);
|
|
FreeSource(source);
|
|
BotFreeCharacterStrings(ch);
|
|
FreeMemory(ch);
|
|
return NULL;
|
|
} //end else
|
|
} //end if
|
|
break;
|
|
} //end if
|
|
else
|
|
{
|
|
indent = 1;
|
|
while(indent)
|
|
{
|
|
if (!PC_ExpectAnyToken(source, &token))
|
|
{
|
|
FreeSource(source);
|
|
BotFreeCharacterStrings(ch);
|
|
FreeMemory(ch);
|
|
return NULL;
|
|
} //end if
|
|
if (!strcmp(token.string, "{")) indent++;
|
|
else if (!strcmp(token.string, "}")) indent--;
|
|
} //end while
|
|
} //end else
|
|
} //end if
|
|
else
|
|
{
|
|
SourceError(source, "unknown definition %s\n", token.string);
|
|
FreeSource(source);
|
|
BotFreeCharacterStrings(ch);
|
|
FreeMemory(ch);
|
|
return NULL;
|
|
} //end else
|
|
} //end while
|
|
FreeSource(source);
|
|
//
|
|
if (!foundcharacter)
|
|
{
|
|
BotFreeCharacterStrings(ch);
|
|
FreeMemory(ch);
|
|
return NULL;
|
|
} //end if
|
|
return ch;
|
|
} //end of the function BotLoadCharacterFromFile
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
int BotFindCachedCharacter(char *charfile, float skill)
|
|
{
|
|
int handle;
|
|
|
|
for (handle = 1; handle <= MAX_CLIENTS; handle++)
|
|
{
|
|
if ( !botcharacters[handle] ) continue;
|
|
if ( strcmp( botcharacters[handle]->filename, charfile ) == 0 &&
|
|
(skill < 0 || fabs(botcharacters[handle]->skill - skill) < 0.01) )
|
|
{
|
|
return handle;
|
|
} //end if
|
|
} //end for
|
|
return 0;
|
|
} //end of the function BotFindCachedCharacter
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
int BotLoadCachedCharacter(char *charfile, float skill, int reload)
|
|
{
|
|
int handle, cachedhandle, intskill;
|
|
bot_character_t *ch = NULL;
|
|
#ifdef DEBUG
|
|
int starttime;
|
|
|
|
starttime = Sys_MilliSeconds();
|
|
#endif //DEBUG
|
|
|
|
//find a free spot for a character
|
|
for (handle = 1; handle <= MAX_CLIENTS; handle++)
|
|
{
|
|
if (!botcharacters[handle]) break;
|
|
} //end for
|
|
if (handle > MAX_CLIENTS) return 0;
|
|
//try to load a cached character with the given skill
|
|
if (!reload)
|
|
{
|
|
cachedhandle = BotFindCachedCharacter(charfile, skill);
|
|
if (cachedhandle)
|
|
{
|
|
botimport.Print(PRT_MESSAGE, "loaded cached skill %f from %s\n", skill, charfile);
|
|
return cachedhandle;
|
|
} //end if
|
|
} //end else
|
|
//
|
|
intskill = (int) (skill + 0.5);
|
|
//try to load the character with the given skill
|
|
ch = BotLoadCharacterFromFile(charfile, intskill);
|
|
if (ch)
|
|
{
|
|
botcharacters[handle] = ch;
|
|
//
|
|
botimport.Print(PRT_MESSAGE, "loaded skill %d from %s\n", intskill, charfile);
|
|
#ifdef DEBUG
|
|
if (bot_developer)
|
|
{
|
|
botimport.Print(PRT_MESSAGE, "skill %d loaded in %d msec from %s\n", intskill, Sys_MilliSeconds() - starttime, charfile);
|
|
} //end if
|
|
#endif //DEBUG
|
|
return handle;
|
|
} //end if
|
|
//
|
|
botimport.Print(PRT_WARNING, "couldn't find skill %d in %s\n", intskill, charfile);
|
|
//
|
|
if (!reload)
|
|
{
|
|
//try to load a cached default character with the given skill
|
|
cachedhandle = BotFindCachedCharacter(DEFAULT_CHARACTER, skill);
|
|
if (cachedhandle)
|
|
{
|
|
botimport.Print(PRT_MESSAGE, "loaded cached default skill %d from %s\n", intskill, charfile);
|
|
return cachedhandle;
|
|
} //end if
|
|
} //end if
|
|
//try to load the default character with the given skill
|
|
ch = BotLoadCharacterFromFile(DEFAULT_CHARACTER, intskill);
|
|
if (ch)
|
|
{
|
|
botcharacters[handle] = ch;
|
|
botimport.Print(PRT_MESSAGE, "loaded default skill %d from %s\n", intskill, charfile);
|
|
return handle;
|
|
} //end if
|
|
//
|
|
if (!reload)
|
|
{
|
|
//try to load a cached character with any skill
|
|
cachedhandle = BotFindCachedCharacter(charfile, -1);
|
|
if (cachedhandle)
|
|
{
|
|
botimport.Print(PRT_MESSAGE, "loaded cached skill %f from %s\n", botcharacters[cachedhandle]->skill, charfile);
|
|
return cachedhandle;
|
|
} //end if
|
|
} //end if
|
|
//try to load a character with any skill
|
|
ch = BotLoadCharacterFromFile(charfile, -1);
|
|
if (ch)
|
|
{
|
|
botcharacters[handle] = ch;
|
|
botimport.Print(PRT_MESSAGE, "loaded skill %f from %s\n", ch->skill, charfile);
|
|
return handle;
|
|
} //end if
|
|
//
|
|
if (!reload)
|
|
{
|
|
//try to load a cached character with any skill
|
|
cachedhandle = BotFindCachedCharacter(DEFAULT_CHARACTER, -1);
|
|
if (cachedhandle)
|
|
{
|
|
botimport.Print(PRT_MESSAGE, "loaded cached default skill %f from %s\n", botcharacters[cachedhandle]->skill, charfile);
|
|
return cachedhandle;
|
|
} //end if
|
|
} //end if
|
|
//try to load a character with any skill
|
|
ch = BotLoadCharacterFromFile(DEFAULT_CHARACTER, -1);
|
|
if (ch)
|
|
{
|
|
botcharacters[handle] = ch;
|
|
botimport.Print(PRT_MESSAGE, "loaded default skill %f from %s\n", ch->skill, charfile);
|
|
return handle;
|
|
} //end if
|
|
//
|
|
botimport.Print(PRT_WARNING, "couldn't load any skill from %s\n", charfile);
|
|
//couldn't load any character
|
|
return 0;
|
|
} //end of the function BotLoadCachedCharacter
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
int BotLoadCharacterSkill(char *charfile, float skill)
|
|
{
|
|
int ch, defaultch;
|
|
|
|
defaultch = BotLoadCachedCharacter(DEFAULT_CHARACTER, skill, qfalse);
|
|
ch = BotLoadCachedCharacter(charfile, skill, LibVarGetValue("bot_reloadcharacters"));
|
|
|
|
if (defaultch && ch)
|
|
{
|
|
BotDefaultCharacteristics(botcharacters[ch], botcharacters[defaultch]);
|
|
} //end if
|
|
|
|
return ch;
|
|
} //end of the function BotLoadCharacterSkill
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
int BotInterpolateCharacters(int handle1, int handle2, float desiredskill)
|
|
{
|
|
bot_character_t *ch1, *ch2, *out;
|
|
int i, handle;
|
|
float scale;
|
|
|
|
ch1 = BotCharacterFromHandle(handle1);
|
|
ch2 = BotCharacterFromHandle(handle2);
|
|
if (!ch1 || !ch2)
|
|
return 0;
|
|
//find a free spot for a character
|
|
for (handle = 1; handle <= MAX_CLIENTS; handle++)
|
|
{
|
|
if (!botcharacters[handle]) break;
|
|
} //end for
|
|
if (handle > MAX_CLIENTS) return 0;
|
|
out = (bot_character_t *) GetClearedMemory(sizeof(bot_character_t) +
|
|
MAX_CHARACTERISTICS * sizeof(bot_characteristic_t));
|
|
out->skill = desiredskill;
|
|
strcpy(out->filename, ch1->filename);
|
|
botcharacters[handle] = out;
|
|
|
|
scale = (float) (desiredskill - ch1->skill) / (ch2->skill - ch1->skill);
|
|
for (i = 0; i < MAX_CHARACTERISTICS; i++)
|
|
{
|
|
//
|
|
if (ch1->c[i].type == CT_FLOAT && ch2->c[i].type == CT_FLOAT)
|
|
{
|
|
out->c[i].type = CT_FLOAT;
|
|
out->c[i].value._float = ch1->c[i].value._float +
|
|
(ch2->c[i].value._float - ch1->c[i].value._float) * scale;
|
|
} //end if
|
|
else if (ch1->c[i].type == CT_INTEGER)
|
|
{
|
|
out->c[i].type = CT_INTEGER;
|
|
out->c[i].value.integer = ch1->c[i].value.integer;
|
|
} //end else if
|
|
else if (ch1->c[i].type == CT_STRING)
|
|
{
|
|
out->c[i].type = CT_STRING;
|
|
out->c[i].value.string = (char *) GetMemory(strlen(ch1->c[i].value.string)+1);
|
|
strcpy(out->c[i].value.string, ch1->c[i].value.string);
|
|
} //end else if
|
|
} //end for
|
|
return handle;
|
|
} //end of the function BotInterpolateCharacters
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
int BotLoadCharacter(char *charfile, float skill)
|
|
{
|
|
int firstskill, secondskill, handle;
|
|
|
|
//make sure the skill is in the valid range
|
|
if (skill < 1.0) skill = 1.0;
|
|
else if (skill > 5.0) skill = 5.0;
|
|
//skill 1, 4 and 5 should be available in the character files
|
|
if (skill == 1.0 || skill == 4.0 || skill == 5.0)
|
|
{
|
|
return BotLoadCharacterSkill(charfile, skill);
|
|
} //end if
|
|
//check if there's a cached skill
|
|
handle = BotFindCachedCharacter(charfile, skill);
|
|
if (handle)
|
|
{
|
|
botimport.Print(PRT_MESSAGE, "loaded cached skill %f from %s\n", skill, charfile);
|
|
return handle;
|
|
} //end if
|
|
if (skill < 4.0)
|
|
{
|
|
//load skill 1 and 4
|
|
firstskill = BotLoadCharacterSkill(charfile, 1);
|
|
if (!firstskill) return 0;
|
|
secondskill = BotLoadCharacterSkill(charfile, 4);
|
|
if (!secondskill) return firstskill;
|
|
} //end if
|
|
else
|
|
{
|
|
//load skill 4 and 5
|
|
firstskill = BotLoadCharacterSkill(charfile, 4);
|
|
if (!firstskill) return 0;
|
|
secondskill = BotLoadCharacterSkill(charfile, 5);
|
|
if (!secondskill) return firstskill;
|
|
} //end else
|
|
//interpolate between the two skills
|
|
handle = BotInterpolateCharacters(firstskill, secondskill, skill);
|
|
if (!handle) return 0;
|
|
//write the character to the log file
|
|
BotDumpCharacter(botcharacters[handle]);
|
|
//
|
|
return handle;
|
|
} //end of the function BotLoadCharacter
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
int CheckCharacteristicIndex(int character, int index)
|
|
{
|
|
bot_character_t *ch;
|
|
|
|
ch = BotCharacterFromHandle(character);
|
|
if (!ch) return qfalse;
|
|
if (index < 0 || index >= MAX_CHARACTERISTICS)
|
|
{
|
|
botimport.Print(PRT_ERROR, "characteristic %d does not exist\n", index);
|
|
return qfalse;
|
|
} //end if
|
|
if (!ch->c[index].type)
|
|
{
|
|
botimport.Print(PRT_ERROR, "characteristic %d is not initialized\n", index);
|
|
return qfalse;
|
|
} //end if
|
|
return qtrue;
|
|
} //end of the function CheckCharacteristicIndex
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
float Characteristic_Float(int character, int index)
|
|
{
|
|
bot_character_t *ch;
|
|
|
|
ch = BotCharacterFromHandle(character);
|
|
if (!ch) return 0;
|
|
//check if the index is in range
|
|
if (!CheckCharacteristicIndex(character, index)) return 0;
|
|
//an integer will be converted to a float
|
|
if (ch->c[index].type == CT_INTEGER)
|
|
{
|
|
return (float) ch->c[index].value.integer;
|
|
} //end if
|
|
//floats are just returned
|
|
else if (ch->c[index].type == CT_FLOAT)
|
|
{
|
|
return ch->c[index].value._float;
|
|
} //end else if
|
|
//cannot convert a string pointer to a float
|
|
else
|
|
{
|
|
botimport.Print(PRT_ERROR, "characteristic %d is not a float\n", index);
|
|
return 0;
|
|
} //end else if
|
|
// return 0;
|
|
} //end of the function Characteristic_Float
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
float Characteristic_BFloat(int character, int index, float min, float max)
|
|
{
|
|
float value;
|
|
bot_character_t *ch;
|
|
|
|
ch = BotCharacterFromHandle(character);
|
|
if (!ch) return 0;
|
|
if (min > max)
|
|
{
|
|
botimport.Print(PRT_ERROR, "cannot bound characteristic %d between %f and %f\n", index, min, max);
|
|
return 0;
|
|
} //end if
|
|
value = Characteristic_Float(character, index);
|
|
if (value < min) return min;
|
|
if (value > max) return max;
|
|
return value;
|
|
} //end of the function Characteristic_BFloat
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
int Characteristic_Integer(int character, int index)
|
|
{
|
|
bot_character_t *ch;
|
|
|
|
ch = BotCharacterFromHandle(character);
|
|
if (!ch) return 0;
|
|
//check if the index is in range
|
|
if (!CheckCharacteristicIndex(character, index)) return 0;
|
|
//an integer will just be returned
|
|
if (ch->c[index].type == CT_INTEGER)
|
|
{
|
|
return ch->c[index].value.integer;
|
|
} //end if
|
|
//floats are casted to integers
|
|
else if (ch->c[index].type == CT_FLOAT)
|
|
{
|
|
return (int) ch->c[index].value._float;
|
|
} //end else if
|
|
else
|
|
{
|
|
botimport.Print(PRT_ERROR, "characteristic %d is not a integer\n", index);
|
|
return 0;
|
|
} //end else if
|
|
// return 0;
|
|
} //end of the function Characteristic_Integer
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
int Characteristic_BInteger(int character, int index, int min, int max)
|
|
{
|
|
int value;
|
|
bot_character_t *ch;
|
|
|
|
ch = BotCharacterFromHandle(character);
|
|
if (!ch) return 0;
|
|
if (min > max)
|
|
{
|
|
botimport.Print(PRT_ERROR, "cannot bound characteristic %d between %d and %d\n", index, min, max);
|
|
return 0;
|
|
} //end if
|
|
value = Characteristic_Integer(character, index);
|
|
if (value < min) return min;
|
|
if (value > max) return max;
|
|
return value;
|
|
} //end of the function Characteristic_BInteger
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void Characteristic_String(int character, int index, char *buf, int size)
|
|
{
|
|
bot_character_t *ch;
|
|
|
|
ch = BotCharacterFromHandle(character);
|
|
if (!ch) return;
|
|
//check if the index is in range
|
|
if (!CheckCharacteristicIndex(character, index)) return;
|
|
//an integer will be converted to a float
|
|
if (ch->c[index].type == CT_STRING)
|
|
{
|
|
strncpy(buf, ch->c[index].value.string, size-1);
|
|
buf[size-1] = '\0';
|
|
return;
|
|
} //end if
|
|
else
|
|
{
|
|
botimport.Print(PRT_ERROR, "characteristic %d is not a string\n", index);
|
|
return;
|
|
} //end else if
|
|
return;
|
|
} //end of the function Characteristic_String
|
|
//===========================================================================
|
|
//
|
|
// Parameter: -
|
|
// Returns: -
|
|
// Changes Globals: -
|
|
//===========================================================================
|
|
void BotShutdownCharacters(void)
|
|
{
|
|
int handle;
|
|
|
|
for (handle = 1; handle <= MAX_CLIENTS; handle++)
|
|
{
|
|
if (botcharacters[handle])
|
|
{
|
|
BotFreeCharacter2(handle);
|
|
} //end if
|
|
} //end for
|
|
} //end of the function BotShutdownCharacters
|
|
|