ai_interpret.c File Reference

#include "ai_interpret.h"
#include "entity.h"
#include "parseentity.h"
#include "parsepowerup.h"
#include "mystrings.h"
#include <stdio.h>
#include <stdlib.h>

Include dependency graph for ai_interpret.c:

Go to the source code of this file.

Functions
void	NothingAI (entity_t *ent)
void	MoveAI (entity_t *ent)
void	WalkAI (entity_t *ent)
void	JumpAI (entity_t *ent)
void	AttackAI (entity_t *ent)
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
ai_function_t *	gVariableAIs = NULL
ai_function_t *	gPresetAIs = NULL
char *	gAI_Variables [] = {"speed", "frames", "time", "damage", 0}
char *	gAI_Actions [] = {"nothing", "move", "walk", "jump", "attack", 0}
char *	gAI_Conditions [] = {"distance_player", "distance_object", "object_check", "link_ai", "link_action", 0}
void(*)(entity_t *)	GetFunctionAI (ai_function_t *data)

Function Documentation

void AttackAI

(

entity_t *

ent

)

AI for entity attacks, "spawns" a hit box / entity in front of Entity

Note

Currently Untested

Parameters

[in,out]

ent

If non-null, the ent.

Author

Anthony Rios

Date

3/29/2016

Definition at line 200 of file ai_interpret.c.

References AI_FLAG_GRAVITY, AI_VAR_DAMAGE, AI_VAR_DIR_X, AI_VAR_DIR_Y, AI_VAR_FRAMES, AI_VAR_TIME, COLLISION_TYPE_RAGDOLL, FindCachedEntity(), FRAME_DELAY, and Spawn().

{
        int flags;
        vec2_t temp_vec2;
        entity_t *temp_ent;
        if(!ent->mData || !ent)
        {
                printf("MoveAI given a null paramerter \n");
                return;
        }
        flags = ent->mData->mFlags;

        //Standard Vars
        ent->mCollisionType = COLLISION_TYPE_RAGDOLL;
        ent->mNextThink = SDL_GetTicks() + ent->mData->mVariables[AI_VAR_FRAMES]*FRAME_DELAY;
        ent->mDamage = ent->mData->mVariables[AI_VAR_DAMAGE];
        ent->mWeight = (flags & AI_FLAG_GRAVITY) ? 0 : FindCachedEntity(ent->mName)->mWeight;

        if(ent->mData->mObject)
        {
                temp_ent = FindCachedEntity(ent->mData->mObject);
                if(temp_ent)
                {
                        temp_ent->mVelocity.x = ent->mData->mVariables[AI_VAR_DIR_X];
                        temp_ent->mVelocity.y = ent->mData->mVariables[AI_VAR_DIR_Y];
                        Spawn(ent, temp_ent);
                }
                
        }

        //Check Data
        if( --ent->mData->mVariables[AI_VAR_TIME] == 0)
        {
                ent->mData->mVariables[AI_VAR_TIME] = 1;
                ent->mData = ent->mData->mLink;
        }
}

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;
}

void JumpAI

(

entity_t *

ent

)

AI to change velocity of the entity, defaults to a jumping movement.

Parameters

[in,out]

ent

If non-null, the ent.

Author

Anthony Rios

Date

3/29/2016

Definition at line 147 of file ai_interpret.c.

References AI_FLAG_GRAVITY, AI_VAR_DAMAGE, AI_VAR_DIR_X, AI_VAR_DIR_Y, AI_VAR_FRAMES, AI_VAR_SPEED, AI_VAR_TIME, COLLISION_TYPE_RAGDOLL, FindCachedEntity(), FRAME_DELAY, gCurrentTime, Vec2Add(), Vec2MultiplyScalar(), vec2_t::x, and vec2_t::y.

{
        int flags;
        vec2_t temp_vec2;
        if(!ent->mData || !ent)
        {
                printf("MoveAI given a null paramerter \n");
                return;
        }
        flags = ent->mData->mFlags;

        //Standard Vars
        ent->mCollisionType = COLLISION_TYPE_RAGDOLL;
        ent->mNextThink = gCurrentTime + ent->mData->mVariables[AI_VAR_FRAMES]*FRAME_DELAY;
        ent->mDamage = ent->mData->mVariables[AI_VAR_DAMAGE];
        ent->mWeight = (flags & AI_FLAG_GRAVITY) ? 0 : FindCachedEntity(ent->mName)->mWeight;

        //Move
        if(ent->mVelocity.y == 0)
        {
                temp_vec2.x = ent->mData->mVariables[AI_VAR_DIR_X];
                temp_vec2.y = ent->mData->mVariables[AI_VAR_DIR_Y];
                //TODO: normalize temp_vec2
                Vec2MultiplyScalar(&temp_vec2,ent->mData->mVariables[AI_VAR_SPEED],&temp_vec2);
                if( (ent->mVelocity.x == temp_vec2.x) & (ent->mVelocity.y == temp_vec2.y) )
                {
                        ;
                } else
                {
                        Vec2Add(&temp_vec2, &ent->mVelocity, &ent->mVelocity);
                }
                
        }

        //Check Data
        if( --ent->mData->mVariables[AI_VAR_TIME] == 0)
        {
                ent->mData->mVariables[AI_VAR_TIME] = 1;
                ent->mData = ent->mData->mLink;
        }
}

void MoveAI

(

entity_t *

ent

)

AI to Move ent from point A to B w/o collisions.

Parameters

[in,out]

ent

If non-null, the ent.

Author

Anthony Rios

Date

3/29/2016

Learn how to lerp.

Definition at line 61 of file ai_interpret.c.

References AI_FLAG_GRAVITY, AI_VAR_DAMAGE, AI_VAR_DIR_X, AI_VAR_DIR_Y, AI_VAR_FRAMES, AI_VAR_SPEED, AI_VAR_TIME, COLLISION_TYPE_CLIP, FindCachedEntity(), FRAME_DELAY, gCurrentTime, Vec2Add(), Vec2MultiplyScalar(), vec2_t::x, and vec2_t::y.

{
        int flags;
        vec2_t temp_vec2;
        if(!ent->mData || !ent)
        {
                printf("MoveAI given a null paramerter \n");
                return;
        }
        flags = ent->mData->mFlags;

        //Standard Vars
        ent->mCollisionType = COLLISION_TYPE_CLIP;
        ent->mNextThink = gCurrentTime + ent->mData->mVariables[AI_VAR_FRAMES]*FRAME_DELAY;
        ent->mDamage = ent->mData->mVariables[AI_VAR_DAMAGE];
        ent->mWeight = (flags & AI_FLAG_GRAVITY) ? 0 : FindCachedEntity(ent->mName)->mWeight;
        
        //Move
        temp_vec2.x = ent->mData->mVariables[AI_VAR_DIR_X];
        temp_vec2.y = ent->mData->mVariables[AI_VAR_DIR_Y];
        //TODO: normalize temp_vec2
        Vec2MultiplyScalar(&temp_vec2,ent->mData->mVariables[AI_VAR_SPEED],&temp_vec2);
        Vec2Add(&temp_vec2, &ent->mVelocity, &ent->mVelocity);

        //Check Data
        if( --ent->mData->mVariables[AI_VAR_TIME] == 0)
        {
                ent->mData->mVariables[AI_VAR_TIME] = 1;
                ent->mData = ent->mData->mLink;
        }
        

}

void NothingAI

(

entity_t *

ent

)

AI that does nothing for its think, except make sure values are set.

Parameters

[in,out]

ent

If non-null, the ent.

Author

Anthony Rios

Date

3/29/2016

Definition at line 25 of file ai_interpret.c.

References AI_FLAG_GRAVITY, AI_VAR_DAMAGE, AI_VAR_FRAMES, AI_VAR_TIME, COLLISION_TYPE_RAGDOLL, FindCachedEntity(), FRAME_DELAY, and gCurrentTime.

{
        int flags;
        vec2_t temp_vec2;
        if(!ent->mData || !ent)
        {
                printf("MoveAI given a null paramerter \n");
                return;
        }
        flags = ent->mData->mFlags;

        //Standard Vars
        ent->mCollisionType = COLLISION_TYPE_RAGDOLL;
        ent->mNextThink = gCurrentTime + ent->mData->mVariables[AI_VAR_FRAMES]*FRAME_DELAY;
        ent->mDamage = ent->mData->mVariables[AI_VAR_DAMAGE];
        ent->mWeight = (flags & AI_FLAG_GRAVITY) ? 0 : FindCachedEntity(ent->mName)->mWeight;

        //Check Data
        if( --ent->mData->mVariables[AI_VAR_TIME] == 0)
        {
                ent->mData->mVariables[AI_VAR_TIME] = 1;
                ent->mData = ent->mData->mLink;
        }
}

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;
}

void WalkAI

(

entity_t *

ent

)

AI to "walk" entity from point A to B w/ collisions.

Parameters

[in,out]

ent

If non-null, the ent.

Author

Anthony Rios

Date

3/29/2016

Todo:

Lerp

Definition at line 106 of file ai_interpret.c.

References AI_FLAG_GRAVITY, AI_VAR_DAMAGE, AI_VAR_DIR_X, AI_VAR_DIR_Y, AI_VAR_FRAMES, AI_VAR_SPEED, AI_VAR_TIME, COLLISION_TYPE_RAGDOLL, FindCachedEntity(), FRAME_DELAY, gCurrentTime, Vec2Add(), Vec2MultiplyScalar(), vec2_t::x, and vec2_t::y.

{
        int flags;
        vec2_t temp_vec2;
        if(!ent->mData || !ent)
        {
                printf("MoveAI given a null paramerter \n");
                return;
        }
        flags = ent->mData->mFlags;

        //Standard Vars
        ent->mCollisionType = COLLISION_TYPE_RAGDOLL;
        ent->mNextThink = gCurrentTime + ent->mData->mVariables[AI_VAR_FRAMES]*FRAME_DELAY;
        ent->mDamage = ent->mData->mVariables[AI_VAR_DAMAGE];
        ent->mWeight = (flags & AI_FLAG_GRAVITY) ? 0 : FindCachedEntity(ent->mName)->mWeight;

        //Move
        temp_vec2.x = ent->mData->mVariables[AI_VAR_DIR_X];
        temp_vec2.y = ent->mData->mVariables[AI_VAR_DIR_Y];
        //TODO: normalize temp_vec2
        Vec2MultiplyScalar(&temp_vec2,ent->mData->mVariables[AI_VAR_SPEED],&temp_vec2);
        Vec2Add(&temp_vec2, &ent->mVelocity, &ent->mVelocity);

        //Check Data
        if( --ent->mData->mVariables[AI_VAR_TIME] == 0)
        {
                ent->mData->mVariables[AI_VAR_TIME] = 1;
                ent->mData = ent->mData->mLink;
        }
}

Variable Documentation

char* gAI_Actions[] = {"nothing", "move", "walk", "jump", "attack", 0}

The actions that are related to ai functions

Definition at line 13 of file ai_interpret.c.

Referenced by ParseAI(), ParsePresetAI(), and StrToAI_Action().

char* gAI_Conditions[] = {"distance_player", "distance_object", "object_check", "link_ai", "link_action", 0}

The conditions for the ai function to be executed

Definition at line 14 of file ai_interpret.c.

Referenced by ParseAI(), ParsePresetAI(), and StrToAI_Condition().

char* gAI_Variables[] = {"speed", "frames", "time", "damage", 0}

The variables to be parsed for ai data

Definition at line 12 of file ai_interpret.c.

Referenced by ParseAI(), ParsePresetAI(), and StrToVariableType().

void(*)(entity_t *) GetFunctionAI(ai_function_t *data)

Returns a function pointer to the think function, given ai_function data.

Parameters

[in,out]

parameter1

If non-null, the first parameter.

Returns

null if it fails, else a GetFunctionAI(ai_function_t *data.

Author

Anthony Rios

Date

3/29/2016

Definition at line 238 of file ai_interpret.c.

Referenced by ThinkEnemy().

{
        if(!data)
        {
                return NULL;
        }
        switch(data->mAction)
        {
        case(AI_ACTION_NOTHING) : 
                return NothingAI;
        case(AI_ACTION_MOVE):
                return MoveAI;
        case(AI_ACTION_WALK): 
                return WalkAI;
        case(AI_ACTION_JUMP):
                return JumpAI;
        case(AI_ACTION_ATTACK):
                return AttackAI;
        default:
                return NULL;
        }
}

ai_function_t* gPresetAIs = NULL

The AI's of type preset

Definition at line 10 of file ai_interpret.c.

Referenced by InitAISystem(), and ShutdownAISystem().

ai_function_t* gVariableAIs = NULL

The AI's of type variable

Definition at line 9 of file ai_interpret.c.

Referenced by InitAISystem(), and ShutdownAISystem().