#include "globals.h"
#include "parseobject.h"

Include dependency graph for ai_interpret.h:

This graph shows which files directly or indirectly include this file:

Data Structures
struct	ai_function_t

Macros
#define	MAX_AI 255

#define	AI_PATH "AI/"

#define	AI_FUNCTION_OBJECT "Think"

#define	AI_VAR_G_STR "Variables"

#define	AI_TYPE_STR "AI_Type"

#define	AI_TYPE_PRESET_STR "preset"

#define	AI_TYPE_VARIABLE_STR "variable"

#define	AI_TYPE_RECURSIVE_STR "AI_Recursive"

#define	AI_VAR_GRAVITY_STR "gravity"

#define	AI_VAR_STR "variables"

#define	AI_CHECK_STR "condition"

#define	AI_BASE_JUMP -5

#define	AI_BASE_SPEED 1

#define	AI_BASE_THINK_FRAMES 1

#define	AI_BASE_DAMAGE 5

Enumerations
enum	ai_type_t { AI_TYPE_NULL, AI_TYPE_PRESET = 0x1, AI_TYPE_VARIABLE, AI_TYPE_RECURSIVE }

enum	ai_variables_t { AI_VAR_SPEED, AI_VAR_FRAMES, AI_VAR_TIME, AI_VAR_DAMAGE, AI_VAR_DIR_X, AI_VAR_DIR_Y, AI_VAR_CHECK, AI_VAR_MAX }

enum	ai_flags_t { AI_FLAG_CHECK_PLAYER = 0x1, AI_FLAG_CHECK_OBJECT = 0x2, AI_FLAG_GRAVITY = 0x4 }

enum	ai_actions_t { AI_ACTION_NOTHING, AI_ACTION_MOVE, AI_ACTION_WALK, AI_ACTION_JUMP, AI_ACTION_ATTACK, AI_ACTION_MAX }

enum	ai_conditions_t { AI_CONDITION_PLAYER_DISTANCE, AI_CONDITION_OBJECT_DISTANCE, AI_CONDITION_OBJECT_NAME, AI_CONDITION_LINK_AI, AI_CONDITION_LINK_ACTION, AI_CONDITION_MAX }

Functions
ai_function_t *	ParseAI (object_t obj, char g_str, char **variables)

ai_function_t *	ParsePresetAI (object_t obj, char g_str)

void	SetAI_Var (ai_function_t function, char data_str, ai_variables_t var_type)

void	SetAI_Action (ai_function_t function, object_t obj, jsmntok_t tok, char g_str, ai_actions_t action_type)

void	SetAI_Check (ai_function_t function, char variables_str, char data_str, ai_conditions_t condition)

int	InitAISystem ()

void	ShutdownAISystem ()

ai_type_t	StrToAI_Type (const char *str)

ai_actions_t	StrToAI_Action (const char *str)

ai_conditions_t	StrToAI_Condition (const char *str)

ai_variables_t	StrToVariableType (const char *str)

Variables
char *	gAI_Variables []

char *	gAI_Actions []

char *	gAI_Conditions []

ai_function_t *	gVariableAIs

ai_function_t *	gPresetAIs

Macro Definition Documentation

#define AI_BASE_DAMAGE 5

Definition at line 29 of file ai_interpret.h.

Referenced by SetAI_Var().

#define AI_BASE_JUMP -5

Definition at line 26 of file ai_interpret.h.

Referenced by SetAI_Action().

#define AI_BASE_SPEED 1

Definition at line 27 of file ai_interpret.h.

Referenced by SetAI_Var().

#define AI_BASE_THINK_FRAMES 1

Definition at line 28 of file ai_interpret.h.

Referenced by SetAI_Var().

#define AI_CHECK_STR "condition"

Definition at line 23 of file ai_interpret.h.

#define AI_FUNCTION_OBJECT "Think"

Definition at line 10 of file ai_interpret.h.

Referenced by ParseAI(), and ParsePresetAI().

#define AI_PATH "AI/"

Definition at line 9 of file ai_interpret.h.

#define AI_TYPE_PRESET_STR "preset"

Definition at line 13 of file ai_interpret.h.

Referenced by StrToAI_Type().

#define AI_TYPE_RECURSIVE_STR "AI_Recursive"

Definition at line 15 of file ai_interpret.h.

#define AI_TYPE_STR "AI_Type"

Definition at line 12 of file ai_interpret.h.

Referenced by ParseAI(), and ParsePresetAI().

#define AI_TYPE_VARIABLE_STR "variable"

Definition at line 14 of file ai_interpret.h.

Referenced by StrToAI_Type().

#define AI_VAR_G_STR "Variables"

Definition at line 11 of file ai_interpret.h.

#define AI_VAR_GRAVITY_STR "gravity"

Definition at line 16 of file ai_interpret.h.

#define AI_VAR_STR "variables"

Definition at line 18 of file ai_interpret.h.

Referenced by ParseAI(), and ParsePresetAI().

#define MAX_AI 255

Definition at line 8 of file ai_interpret.h.

Referenced by InitAISystem().

Enumeration Type Documentation

enum ai_actions_t

Defines the enum for action types

Enumerator
AI_ACTION_NOTHING
AI_ACTION_MOVE
AI_ACTION_WALK
AI_ACTION_JUMP
AI_ACTION_ATTACK
AI_ACTION_MAX

Definition at line 64 of file ai_interpret.h.

 {
         AI_ACTION_NOTHING,
         AI_ACTION_MOVE,
         AI_ACTION_WALK,
         AI_ACTION_JUMP,
         AI_ACTION_ATTACK,
         AI_ACTION_MAX
 
 }ai_actions_t;

enum ai_conditions_t

Enumerator
AI_CONDITION_PLAYER_DISTANCE
AI_CONDITION_OBJECT_DISTANCE
AI_CONDITION_OBJECT_NAME
AI_CONDITION_LINK_AI
AI_CONDITION_LINK_ACTION
AI_CONDITION_MAX

Definition at line 75 of file ai_interpret.h.

 {
         AI_CONDITION_PLAYER_DISTANCE,
         AI_CONDITION_OBJECT_DISTANCE,
         AI_CONDITION_OBJECT_NAME,
         AI_CONDITION_LINK_AI,
         AI_CONDITION_LINK_ACTION,
         AI_CONDITION_MAX
 
 }ai_conditions_t;

enum ai_flags_t

Defines the enum for what flags are set on the ai

Enumerator
AI_FLAG_CHECK_PLAYER
AI_FLAG_CHECK_OBJECT
AI_FLAG_GRAVITY

Definition at line 55 of file ai_interpret.h.

 {
         AI_FLAG_CHECK_PLAYER = 0x1,
         AI_FLAG_CHECK_OBJECT = 0x2,
         AI_FLAG_GRAVITY = 0x4,
 
 }ai_flags_t;

enum ai_type_t

Defines the enum for ai_types

Enumerator
AI_TYPE_NULL
AI_TYPE_PRESET	An enum constant representing the ai type preset option
AI_TYPE_VARIABLE	An enum constant representing the ai type variable , which states there needs to be more values given
AI_TYPE_RECURSIVE	An enum constant representing the ai type recursive option, which values turn into more functions

Definition at line 32 of file ai_interpret.h.

 {
         AI_TYPE_NULL,
         AI_TYPE_PRESET = 0x1,   /**< An enum constant representing the ai type preset option */
         AI_TYPE_VARIABLE,   /**< An enum constant representing the ai type variable , which states there needs to be more values given */
         AI_TYPE_RECURSIVE   /**< An enum constant representing the ai type recursive option, which values turn into more functions */
 }ai_type_t;

enum ai_variables_t

Defines the enum for the variables in mVariables

Enumerator
AI_VAR_SPEED	An enum constant representing the ai variable speed option
AI_VAR_FRAMES	An enum constant representing the ai variable for the amount of frames this action happens
AI_VAR_TIME	An enum constant representing the ai variable for the amount of times to repeat this action
AI_VAR_DAMAGE	An enum constant representing the ai variable for the damage this action should be
AI_VAR_DIR_X	An enum constant representing the ai variable for the x direction
AI_VAR_DIR_Y	An enum constant representing the ai variable for the y direction
AI_VAR_CHECK	An enum constant representing the ai variable for whether there is a condition that needs to be met b4 the action can be done
AI_VAR_MAX

Definition at line 41 of file ai_interpret.h.

 {
         AI_VAR_SPEED,   /**< An enum constant representing the ai variable speed option */
         AI_VAR_FRAMES,  /**< An enum constant representing the ai variable for the amount of frames this action happens*/
         AI_VAR_TIME,    /**< An enum constant representing the ai variable for the amount of times to repeat this action */
         AI_VAR_DAMAGE,  /**< An enum constant representing the ai variable for the damage this action should be */
         AI_VAR_DIR_X,   /**< An enum constant representing the ai variable for the x direction */
         AI_VAR_DIR_Y,   /**< An enum constant representing the ai variable for the y direction */
         AI_VAR_CHECK,   /**< An enum constant representing the ai variable for whether there is a condition that needs to be met b4 the action can be done */
         AI_VAR_MAX
 
 }ai_variables_t;

Function Documentation

int InitAISystem ( )

Init AI system, similar to Entity init, for now....

Returns: An int.

Author: Anthony Rios

Date: 3/29/2016

Definition at line 646 of file ai_interpret.c.

References gPresetAIs, gVariableAIs, MAX_AI, and ShutdownAISystem().

Referenced by Setup().

 {
         if(gVariableAIs)
         {
                 printf("Tried to init AI system, while already inited \n");
                 return -1;
         }
         gVariableAIs = (ai_function_t*) malloc(sizeof(ai_function_t)*(MAX_AI+1));
         gPresetAIs = (ai_function_t*) malloc(sizeof(ai_function_t)*(MAX_AI+1));
 
         if(!gVariableAIs || !gPresetAIs)
         {
                 printf("AI malloc error \n");
                 return -1;
         }
 
         memset(gVariableAIs, 0, sizeof(ai_function_t)*(MAX_AI+1));
         memset(gPresetAIs, 0, sizeof(ai_function_t)*(MAX_AI+1));
         atexit(ShutdownAISystem);
         return 0;
 }

ai_function_t* ParseAI	(	object_t *	obj,
		char *	g_str,
		char **	variables
	)

Parses AI behavior using the variables given and the AI obj/file specified.

Parameters

[in,out]	obj	If non-null, the object.
[in,out]	g_str	If non-null, the string.
[in,out]	variables	If non-null, the variables.

Returns: null if it fails, else a pointer to an ai_function_t.

Author: Anthony Rios

Date: 3/29/2016

Definition at line 261 of file ai_interpret.c.

References AI_CONDITION_OBJECT_NAME, AI_FLAG_CHECK_OBJECT, AI_FLAG_GRAVITY, AI_FUNCTION_OBJECT, AI_TYPE_STR, AI_VAR_STR, CountMem(), CountObjectMembers(), FindKey(), FindObject(), FindValue(), gAI_Actions, gAI_Conditions, gAI_Variables, JsmnToString(), SetAI_Action(), SetAI_Check(), SetAI_Var(), StrToAI_Type(), and StrToInt().

Referenced by LoadLevel(), and SetAI_Check().

 {
         int i, j, k,children, position, variables_i, gravity;
         ai_function_t *retVal;
         jsmntok_t *temp_tok, *action_tok;
         object_t *temp_obj, *action_obj, *variables_obj;
         char *temp_str, *type_str, *cond_str,**variables_str;
         if(!obj || !g_str)
         {
                 return NULL;
         }
         
         if(FindObject(obj, AI_VAR_STR))
         {
                 gravity = 1;
         } else
         {
                 gravity = 0;
         }
 
         temp_obj = FindObject(obj, AI_FUNCTION_OBJECT);
         if(!temp_obj)
         {
                 printf("No thinks in ai : %s \n", obj->name);
                 return NULL;
         }
 
         type_str = FindValue(obj, AI_TYPE_STR, g_str);
         if(!type_str)
         {
                 printf("No types in ai : %s \n", obj->name);
                 return NULL;
         }
 
         children = CountMem(temp_obj->children, sizeof(object_t));
         retVal = (ai_function_t*) malloc(sizeof(ai_function_t)*(children+1));
         memset(retVal, 0, sizeof(ai_function_t)*(children+1));
         for(i = 0; i < children; i++)
         {
                 for(j = 0; gAI_Variables[j]; j++ )
                 {
                         temp_str = FindValue(&temp_obj->children[i], gAI_Variables[j], g_str);
                         SetAI_Var(&retVal[i], variables[StrToInt(temp_str)], (ai_variables_t)j );
                         if(temp_str) free(temp_str);
                         temp_str = NULL;
                 }
                 for(j = 0; gAI_Actions[j]; j++ )
                 {       
                         action_obj = FindObject(&temp_obj->children[i], gAI_Actions[j]);
                         action_tok = FindKey(temp_obj->children[i].keys, gAI_Actions[j], g_str);
                         if(!action_obj && !action_tok)
                         {
                                 continue;
                         }
 
                         SetAI_Action(&retVal[i],action_obj, action_tok, g_str, (ai_actions_t)j );
                 }
                 for(j = 0; gAI_Conditions[j]; j++)
                 {
                         cond_str = FindValue(&temp_obj->children[i], gAI_Conditions[j], g_str);
                         if(!cond_str)
                         {
                                 continue;
                         }
                         variables_obj = FindObject(&temp_obj->children[i], AI_VAR_STR);
                         if(!variables_obj)
                         {
                                 variables_str = NULL;
                         } else
                         {
                                 variables_i = CountObjectMembers(variables_obj, g_str);
                                 variables_str = (char**) malloc(sizeof(char*)*(variables_i+1));
                                 variables_str[variables_i] = NULL;
                                 for(k = 0; k < variables_i; k++)
                                 {
                                         temp_str = JsmnToString(&variables_obj->values[k], g_str);
                                         variables_str[k] = temp_str ? variables[StrToInt(temp_str)] : NULL;
                                         if(temp_str) free(temp_str);
                                         temp_str = NULL;
                                 }
                         }
 
                         SetAI_Check(&retVal[i], variables_str, variables[StrToInt(cond_str)], (ai_conditions_t)j );
                         if(cond_str) free(cond_str);
                         cond_str = NULL;
                 }
                 retVal[i].mFlags |= gravity ? AI_FLAG_GRAVITY : 0;
                 retVal[i].mType = StrToAI_Type(type_str);
         }
 
         //Linking and conditionals
         for(i = 0; i < children; i++)
         {
                 if(retVal[i].mLink)
                 {
                         continue;
                 } else
                 {
                         retVal[i].mLink = (i+1 == children) ? retVal: &retVal[i+1];
                 }
                 if(retVal[i].mFlags & AI_FLAG_CHECK_OBJECT)
                 {
                         temp_str = FindValue(&temp_obj->children[i], gAI_Conditions[AI_CONDITION_OBJECT_NAME], g_str);
                         if(!temp_str)
                         {
                                 continue;
                         }
                         retVal[i].mObjectCheck = temp_str;
                 }
         }
         return retVal;
 }

ai_function_t* ParsePresetAI	(	object_t *	obj,
		char *	g_str
	)

Parse a preset AI, with values determined by whats in the file.

Parameters

[in,out]	obj	If non-null, the object.
[in,out]	g_str	If non-null, the string.

Returns: null if it fails, else a pointer to an ai_function_t.

Author: Anthony Rios

Date: 3/29/2016

Definition at line 374 of file ai_interpret.c.

References AI_CONDITION_OBJECT_NAME, AI_FLAG_CHECK_OBJECT, AI_FLAG_GRAVITY, AI_FUNCTION_OBJECT, AI_TYPE_STR, AI_VAR_STR, CountMem(), CountObjectMembers(), FindKey(), FindObject(), FindValue(), gAI_Actions, gAI_Conditions, gAI_Variables, JsmnToString(), SetAI_Action(), SetAI_Check(), SetAI_Var(), and StrToAI_Type().

Referenced by LoadLevel().

 {
         int i, j, k,children, position, variables, gravity;
         ai_function_t *retVal;
         jsmntok_t *temp_tok, *action_tok;
         object_t *temp_obj, *action_obj, *variables_obj;
         char *temp_str, *type_str, **variables_str;
         if(!obj || !g_str)
         {
                 return NULL;
         }
         
         if(FindObject(obj, AI_VAR_STR))
         {
                 gravity = 1;
         } else
         {
                 gravity = 0;
         }
         temp_obj = FindObject(obj, AI_FUNCTION_OBJECT);
         if(!temp_obj)
         {
                 printf("No thinks in ai : %s \n", obj->name);
                 return NULL;
         }
         temp_tok = FindKey(obj->keys, AI_TYPE_STR, g_str);
         if(!temp_tok)
         {
                 printf("No types in ai : %s \n", obj->name);
                 return NULL;
         }
         position = temp_tok - obj->keys;
         type_str = JsmnToString(&obj->values[position], g_str);
         
         children = CountMem(temp_obj->children, sizeof(object_t));
         retVal = (ai_function_t*) malloc(sizeof(ai_function_t)*(children+1));
         memset(retVal, 0, sizeof(ai_function_t)*(children+1));
         for(i = 0; i < children; i++)
         {
                 for(j = 0; gAI_Variables[j]; j++ )
                 {
                         temp_str = FindValue(&temp_obj->children[i], gAI_Variables[j] ,g_str);
                         
                         SetAI_Var(&retVal[i], temp_str, (ai_variables_t)j );
                         if(temp_str) free(temp_str);
                         temp_str = NULL;
                 }
                 for(j = 0; gAI_Actions[j]; j++ )
                 {       
                         action_obj = FindObject(&temp_obj->children[i], gAI_Actions[j]);
                         action_tok = FindKey(temp_obj->children[i].keys, gAI_Actions[j], g_str);
                         if(!action_obj && !action_tok)
                         {
                                 continue;
                         }
                         SetAI_Action(&retVal[i],action_obj, action_tok, g_str, (ai_actions_t)j );
                 }
                 for(j = 0; gAI_Conditions[j]; j++)
                 {
                         temp_str = FindValue(&temp_obj->children[i], gAI_Conditions[j] ,g_str);
                         if(!temp_str)
                         {
                                 continue;
                         }
                         variables_obj = FindObject(&temp_obj->children[i], AI_VAR_STR);
                         if(!variables_obj)
                         {
                                 variables_str = NULL;
                         } else
                         {
                                 variables = CountObjectMembers(variables_obj, g_str);
                                 variables_str = (char**) malloc(sizeof(char*)*(variables+1));
                                 variables_str[variables] = NULL;
                                 for(k = 0; k < variables; k++)
                                 {
                                         variables_str[k] = JsmnToString(&variables_obj->values[k],g_str);
                                 }
                         }
 
                         SetAI_Check(&retVal[i], variables_str, temp_str, (ai_conditions_t)j );
                         if(temp_str) free(temp_str);
                         temp_str = NULL;
                 }
                 retVal[i].mFlags |= gravity ? AI_FLAG_GRAVITY : 0;
                 retVal[i].mType = StrToAI_Type(type_str);
         }
 
         //Linking and conditionals
         for(i = 0; i < children; i++)
         {
                 if(!retVal[i].mLink)
                 {
                         retVal[i].mLink = (i+1 == children) ? retVal: &retVal[i+1];
                 }
                 if(retVal[i].mFlags & AI_FLAG_CHECK_OBJECT)
                 {
                         temp_str = FindValue(&temp_obj->children[i], gAI_Conditions[AI_CONDITION_OBJECT_NAME], g_str);
                         if(!temp_str)
                         {
                                 continue;
                         }
                         retVal[i].mObjectCheck = temp_str;
                 }
         }
         return retVal;
 }

void SetAI_Action	(	ai_function_t *	function,
		object_t *	obj,
		jsmntok_t *	tok,
		char *	g_str,
		ai_actions_t	action_type
	)

Sets AI action defined in ai_actions to the ai_function

Parameters

[in,out]	function	If non-null, the function.
[in,out]	obj	If non-null, the object.
[in,out]	tok	If non-null, the tok.
[in,out]	g_str	If non-null, the string.
[in,out]	action_type	If non-null, the action type.

Author: Anthony Rios

Date: 3/29/2016

Definition at line 516 of file ai_interpret.c.

References AI_ACTION_ATTACK, AI_ACTION_JUMP, AI_ACTION_MOVE, AI_ACTION_NOTHING, AI_ACTION_WALK, AI_BASE_JUMP, AI_VAR_DIR_X, AI_VAR_DIR_Y, JsmnToString(), ParseToVec2(), vec2_t::x, and vec2_t::y.

Referenced by ParseAI(), and ParsePresetAI().

 {
         vec2_t *temp_vec2;
         if(!action_type || !function)
         {
                 return;
         }
         switch(action_type)
         {
         case AI_ACTION_NOTHING:
                 {
                         function->mAction = AI_ACTION_NOTHING;
                         break;
                 }
         case AI_ACTION_MOVE:
                 {
                         if(!obj)
                         {
                                 function->mVariables[AI_VAR_DIR_X] = 0;
                                 function->mVariables[AI_VAR_DIR_Y] = 0;
                         
                         } else if( (temp_vec2 = ParseToVec2(obj, g_str)) != NULL)
                         {
                                 function->mVariables[AI_VAR_DIR_X] = temp_vec2->x;
                                 function->mVariables[AI_VAR_DIR_X] = temp_vec2->y;
                         } else
                         {
                                 function->mVariables[AI_VAR_DIR_X] = 0;
                                 function->mVariables[AI_VAR_DIR_Y] = 0;
                         }
 
                         function->mAction = AI_ACTION_MOVE;
                                 break;
                         }
         case AI_ACTION_WALK:
                 {
                         if(!obj)
                         {
                                 function->mVariables[AI_VAR_DIR_X] = 0;
                                 function->mVariables[AI_VAR_DIR_Y] = 0;
                         
                         } else if( (temp_vec2 = ParseToVec2(obj, g_str)) != NULL)
                         {
                                 function->mVariables[AI_VAR_DIR_X] = temp_vec2->x;
                                 function->mVariables[AI_VAR_DIR_X] = temp_vec2->y;
                         } else
                         {
                                 function->mVariables[AI_VAR_DIR_X] = 0;
                                 function->mVariables[AI_VAR_DIR_Y] = 0;
                         }
 
                         function->mAction = AI_ACTION_WALK;
                         break;
                 }
         case AI_ACTION_JUMP:
                 {
                         if(!obj)
                         {
                                 function->mVariables[AI_VAR_DIR_X] = 0;
                                 function->mVariables[AI_VAR_DIR_Y] = AI_BASE_JUMP;
                         
                         } else if( (temp_vec2 = ParseToVec2(obj, g_str)) != NULL)
                         {
                                 function->mVariables[AI_VAR_DIR_X] = temp_vec2->x;
                                 function->mVariables[AI_VAR_DIR_X] = temp_vec2->y;
                         } else
                         {
                                 function->mVariables[AI_VAR_DIR_X] = 0;
                                 function->mVariables[AI_VAR_DIR_Y] = AI_BASE_JUMP;
                         }
 
                         function->mAction = AI_ACTION_JUMP;
                         break;
                 }
         case AI_ACTION_ATTACK:
                 {
                         function->mAction = AI_ACTION_ATTACK;
                         function->mObject = JsmnToString(tok, g_str);
                         break;
                 }
         default:
                 break;
         }
 }

void SetAI_Check	(	ai_function_t *	function,
		char **	variables_str,
		char *	data_str,
		ai_conditions_t	condition
	)

Sets checks that need to occur for the ai_function to be called.

Parameters

[in,out]	function	If non-null, the function.
[in,out]	variables_str	If non-null, the variables string.
[in,out]	data_str	If non-null, the data string.
[in,out]	check_str	If non-null, the condition type.

Author: Anthony Rios

Date: 3/29/2016

Definition at line 601 of file ai_interpret.c.

References AI_CONDITION_LINK_ACTION, AI_CONDITION_LINK_AI, AI_CONDITION_OBJECT_DISTANCE, AI_CONDITION_PLAYER_DISTANCE, AI_FLAG_CHECK_OBJECT, AI_FLAG_CHECK_PLAYER, AI_VAR_CHECK, ConvertFileToUseable(), ParseAI(), ParseToObject(), and StrToInt().

Referenced by ParseAI(), and ParsePresetAI().

 {
         ai_function_t *temp_ai;
         object_t *temp_obj;
         jsmntok_t *temp_tok;
         char *temp_str;
         if(!condition || !function)
         {
                 return;
         }
         switch(condition)
         {
         case AI_CONDITION_LINK_ACTION:
                 {
                         function->mVariables[AI_VAR_CHECK] = StrToInt(data_str);
                         break;
                 }
         case AI_CONDITION_PLAYER_DISTANCE:
                 {
                         function->mVariables[AI_VAR_CHECK] = StrToInt(data_str);
                         function->mFlags |= AI_FLAG_CHECK_PLAYER;
                         break;
                 }
         case AI_CONDITION_OBJECT_DISTANCE:
                 {
                         function->mVariables[AI_VAR_CHECK] = StrToInt(data_str);
                         function->mFlags |= AI_FLAG_CHECK_OBJECT;
                         break;
                 }
         case AI_CONDITION_LINK_AI:
                 {
                         ConvertFileToUseable(data_str, NULL, &temp_str, &temp_tok);
                         if(!temp_str || !temp_tok)
                         {
                                 return;
                         }
                         temp_obj = ParseToObject(temp_tok, temp_str);
                         function->mLink = ParseAI(temp_obj, temp_str, variables_str);
                         break;
                 }
         default:
                 break;
         }
 }

void SetAI_Var	(	ai_function_t *	function,
		char *	data_str,
		ai_variables_t	var_type
	)

Sets AI variables in ai_function->mVariables.

Parameters

[in,out]	function	If non-null, the function.
[in,out]	data_str	If non-null, the data string.
[in,out]	var_type	If non-null, the variable type.

Author: Anthony Rios

Date: 3/29/2016

Definition at line 481 of file ai_interpret.c.

References AI_BASE_DAMAGE, AI_BASE_SPEED, AI_BASE_THINK_FRAMES, AI_VAR_DAMAGE, AI_VAR_FRAMES, AI_VAR_SPEED, AI_VAR_TIME, and StrToInt().

Referenced by ParseAI(), and ParsePresetAI().

 {
         if(!var_type)
         {
                 return;
         }
 
         switch(var_type)
         {
         case AI_VAR_SPEED:
                 {
                         function->mVariables[AI_VAR_SPEED] = data_str ? StrToInt(data_str) : AI_BASE_SPEED;
                         break;
                 }
         case AI_VAR_FRAMES:
                 {
                         function->mVariables[AI_VAR_FRAMES] = data_str ? StrToInt(data_str) : AI_BASE_THINK_FRAMES;
                         break;
                 }
         case AI_VAR_TIME:
                 {
                         function->mVariables[AI_VAR_TIME] = data_str ? StrToInt(data_str) : 1;
                         break;
                 }
         case AI_VAR_DAMAGE:
                 {
                         function->mVariables[AI_VAR_DAMAGE] = data_str ? StrToInt(data_str) : AI_BASE_DAMAGE;
                         break;
                 }
         default:
                 break;
         }
 
 }

void ShutdownAISystem ( )

Shutdown AI system, just frees the global variables simple.

Author: Anthony Rios

Date: 3/30/2016

Definition at line 668 of file ai_interpret.c.

References gPresetAIs, and gVariableAIs.

Referenced by InitAISystem().

 {
         if(!gVariableAIs || !gPresetAIs)
         {
                 printf("AI not initialized before shutdown called \n");
                 return;
         }
         free(gVariableAIs);
         free(gPresetAIs);
 }

ai_actions_t StrToAI_Action ( const char * str )

Definition at line 691 of file ai_interpret.c.

References AI_ACTION_MAX, and gAI_Actions.

 {
         int i;
         for(i = 0; gAI_Actions[i]; i++)
         {
                 if(!strcmp(gAI_Actions[i], str))
                 {
                         return (ai_actions_t)i;
                 }
         }
         return  AI_ACTION_MAX;
 }

ai_conditions_t StrToAI_Condition ( const char * str )

Definition at line 704 of file ai_interpret.c.

References AI_CONDITION_MAX, and gAI_Conditions.

 {
         int i;
         for(i = 0; gAI_Conditions[i]; i++)
         {
                 if(!strcmp(gAI_Conditions[i], str))
                 {
                         return (ai_conditions_t)i;
                 }
         }
         return  AI_CONDITION_MAX;
 }

ai_type_t StrToAI_Type ( const char * str )

Converts a str to an AI type.

Parameters

str	The string.

Returns: str as an ai_type_t.

Author: Anthony Rios

Date: 3/29/2016

Definition at line 679 of file ai_interpret.c.

References AI_TYPE_NULL, AI_TYPE_PRESET, AI_TYPE_PRESET_STR, AI_TYPE_VARIABLE, and AI_TYPE_VARIABLE_STR.

Referenced by ParseAI(), and ParsePresetAI().

 {
         if(!strcmp(str, AI_TYPE_PRESET_STR))
         {
                 return AI_TYPE_PRESET;
         } else if(!strcmp(str, AI_TYPE_VARIABLE_STR))
         {
                 return AI_TYPE_VARIABLE;
         }
         return AI_TYPE_NULL;
 }

ai_variables_t StrToVariableType ( const char * str )

Definition at line 717 of file ai_interpret.c.

References AI_VAR_MAX, and gAI_Variables.

 {
         int i;
         for(i = 0; gAI_Variables[i]; i++)
         {
                 if(!strcmp(gAI_Variables[i], str))
                 {
                         return (ai_variables_t)i;
                 }
         }
         return  AI_VAR_MAX;
 }