Quake-III-Arena

be_ai_char.c (23168B)

---

 /*
 ===========================================================================
 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