Autonomous Movement of Objects and Characters in a Game

Introduction

An "artificial intelligence" for a game can be done quite simply. We are talking here about making a character follow a path, moving decorative elements, displaying game help, etc.

You will find on https://philthebjob.wixsite.com/moteur3d-eco the source codes for the entire game, with a lot of other code, deferred shader display, particles, billboards, obj-mtl loader, etc.

How It Works

There are obviously several solutions. Here is mine: we put in a file the lines of code which will be read as for interpreted code.

Example: You want your character to go from position 0,0,0 to 5,0,0, at a speed of 0.05 per frame. You enter its identifier code (not the name of the character, a unique code), the action-verb "mvt", the parameters "0.05 / 5 0 0" and the link when the action is resolved.

In the program, the action will be read, the corresponding routine called, and the character's movement carried out, by a perso.setPosition().

For the character in the background, called Mossy, here is the text file:

(See file modJeu/common_jeu.h in the program, on the site.)

const std::string ia_perso2d[][2] = {
    //
    {"mossy", "000|end|null|000|000"},
    {"mossy", "001|tps|3|002|000"},
    {"mossy", "002|ani|ani walks 999|003|000"},
    {"mossy", "003|mvt|0.05 / -4 8 1|004|000"},
    {"mossy", "004|ani|ani jumps 1|005|000"},
    {"mossy", "005|bez|0.025 / -4.03 8 1 > -3.05 8 1.98 + -0.46 8 1 > -1.2 8 1.78 r 0 0 0|010|000"},
    {"mossy", "010|ani|ani walks 999|011|000"},
    {"mossy", "011|mvt|0.05 / 22.47 8 1|012|000"},
    {"mossy", "012|del|null|000|000"}
};

The character arrives from the left, moves to the right, jumps the "ravine", continues to the right and disappears.

The lines of code consist of a key (the code/key of the character, the object, etc.) and a line of actions. If we take the two lines:

"mossy", "001|tps|3|002|000"},
"mossy", "002|ani|ani walks 999|003|000"

We see that the action is a delay (tps) of 3 seconds, before connecting (yes) to line (002). The AI line therefore consists of a line index, a verb determining the action, a set of parameters (which you determine), and two connections, yes and no (it happens that we are dealing with a double condition: condition0 & condition1 => yes or no).

The second line launches an animation, animation runs, in a loop, and immediately goes to the third line.

For the elevator:

const std::string ia_meca[][2] = {
    //
    {"asc_00", "000|end|null|000|000"},
    {"asc_00", "001|tps|2|002|000"},
    {"asc_00", "002|mvt|0.05 / % % -10|003|000"}, // goes from vertical z -10 to -5
    {"asc_00", "003|mvt|0.05 / % % -5|002|000"},  // ! loop on the previous line!

Always this 2 second delay, before the elevator begins its movement, speed 0.05, vertically from -10 to -5, and loops back to line 002. Your elevator no longer stops!

For Help

const std::string ia_tuto[][2] = {
    //
    {"level_0", "000|end|null|000|000"},
    {"level_0", "001|msg|help.png 0 0 640 64 / 200 64 / 5000|002|000"},

    {"level_0", "020|obj|yellow container quantity ***|021|000"},
    {"level_0", "021|msg|aide.png 192 64 192 64 / 1600 370 / 5000|000|000"},

Here is a piece of the help.png file. This message cuts the title (0 0 640 64), displays it in position 200.64 (top screen - 64), for 5 seconds, before moving to line 002.

The other two lines wait until the yellow hat (code qte_jaune) has been reached by the player (the hat code changes to "***" following a collision test) before moving on to line 021. In my programs, the objects are managed by the container code. If the container code is null, the object is visible, on the ground. If the container code is "mossy", then the object belongs to mossy and is no longer visible (it is in its bag). "***" is a destroyed object.

All of this is loaded into a dedicated class and read constantly. So you can create the actions you want.

The Class

The class is a simple container of values. We will store for each line (index), the action, the parameters, and the links. The variables are free, it's up to you to use them as you wish. For example, the bool variable is essentially used to initialize the action (pass to true), then to block initialization during subsequent program loops. We use the OVec3_f (a floating xyz vector, like glm::vec3) to keep a position; uint64_t is used to keep a time value; etc.

First, load the lines (make a loop to send the lines of the ia_perso2d structure, check that the key is that of the character, add the lines):

/*
000|action-verbe|param|lien oui|lien non
*/
void Tia::add(std::string ligne)
{
    std::vector<std::string> strList;
    int idx;
    //ECO_error_set("Tia.add ligne > %s", ligne.c_str());

    strList.clear();
    // cuts the line taking into account the separators '|' (code below)
    ECO_strCut(strList, ligne, IA_SEP)   ;

    if (strList.size() != 5) // idx action param lien1 lien2
    {
        ECO_error_set("erreur code ordre : %s %s >Tia.add", strList[0].c_str(), strList[1].c_str());
        return;
    }

    idx = list_ia.size();

    // searches for the match of the verb/action (see gl_strAIA below)
    for (size_t i = 0; i < ECO_sizeOf(gl_strAIA); i++)
    {
        if (gl_strAIA[i] == strList[1])
        {
            //ECO_error_set("Tia.add > %s", strList[1].c_str());

            list_ia.push_back(s_ia());
            list_ia[idx].index = ECO_strToInt(strList[0]);	// str index devient int index
            list_ia[idx].action = i;
            list_ia[idx].param = strList[2];
            list_ia[idx].lien1 = ECO_strToInt(strList[3]);
            list_ia[idx].lien2 = ECO_strToInt(strList[4]);
            return;
        }
    }
    //ECO_error_set("erreur action : %s >Tia.add", strList[1].c_str());
}

for the line to find, we will proceed as follows:

void Tia::setLigne(int value)
{
    for (size_t i = 0; i < list_ia.size(); i++)
    {
        if (list_ia[i].index == value)
        {
            m_index = i;
            break;
        }
    }
}

Here is the header, the functions are just getSomething and setSomething which give a value or retrieve the value of the variable.

#include <string>
#include <vector>
#include <fstream>

#define IA_NULL     "null"
#define IA_REM      '#'
#define IA_SEP      '|'
#define IA_SEP_INTERNE ' '
#define gl_ordNull  "000|null|param|000|000"

// Verbs/actions (to be defined according to your requirement)
const std::string gl_strAIA[] = {
    "null",
    // delay / mouvement-deplacement / lance animation / bezier / son
    "tps", "mvt", "ani", "bez", "snd",
    // particule / visiblite (couche alpha) / scale / delete
    "prt", "vis", "sca", "del",
    "fin"
};

// action ia
enum {
    AIA_NULL,
    AIA_TPS, AIA_MVT, AIA_ANI, AIA_BEZ, AIA_SND,
    AIA_PRT, AIA_VIS, AIA_SCA, AIA_DEL,
    AIA_FIN
};

struct s_ia
{
    s_ia()
    {
        index = 0; action = 0; param = ""; lien1 = 0, lien2 = 0;
    }

    int         index;
    int         action;
    std::string param;
    int         lien1;
    int         lien2;
};

class Tia
{
public:
    Tia();
    ~Tia();

    void        	add(std::string ligne);

    void        	clear();
    void        	create(std::string folder, std::string file, int branchement = 1);

    int         	getAction();
    int         	getIndex();
    int         	getLien1();
    int         	getLien2();
    std::string 	getParam(int ligne = 0);
    //
    int         	getValue_bool();
    int         	getValueI();
    float       	getValueF();
    double      	getValueD();
    OVec3_f&  getValue_vec3();
    uint64_t    	getValueT64();

    void        	razValues();

    void        setLigne(int value);
    void        setValue_bool(int value);
    void        setValueI(int value);
    void        setValueF(float value);
    void        setValueD(double value);
    void        setValue_vec3(OVec3_f& value);
    void        setValue_vec3(float x, float y, float z);
    void        setValueT64(uint64_t value);

private:

    std::string 	m_fichier;
    std::vector<s_ia> list_ia;
    int         	m_index;

    // free storage values ​​/ reset to zero after use
    int         	m_value_bool;   // initiated action marker
    int         	m_valueI;
    float       	m_valueF;
    double      	m_valueD;
    OVec3_f      m_value_vec3;
    uint64_t    	m_value_tps;

public:

    //ONurb       nurb;
    OBezier     bezier;
};

The Decryption

In the character header, we declare a tactical class, based on the Tia class:

audience:
    Tia tactical;

When creating the character, we read its "associated AI file":

 // basic neutral position
 anim_start("neutral");

tactic.clear();
// we read the text file seen above
for (size_t i = 0; i < ECO_sizeOf(ia_perso2d); i++)
{
// m_code is the character code, here "mossy"
if (m_code == ia_perso2d[i][0]) tactic.add(ia_perso2d[i][1]);
}
tactics.setLine(m_ia_line); // the save indicates which line we are at!

When executing the program, for example, before display (draw or render), we call ia_tactic:

void TmodGame::ia_tactic()
{
    // for all 2d characters (here the character in the background)
    for (size_t i = 0; i < perso2d.size(); i++)
    {
        // the ia file is, for characters, called tactics
        // we therefore ask what is the expected action (according to the current line)
        switch(custom2d[i].tactic.getAction())
        {
        //case AIA_NULL:
        // break;
        box AIA_TPS:
            ia_perso2d_tps(i); // here we call the delay routine
            break;
        box AIA_MVT:
            ia_perso2d_mvt(i);
            break;
        box AIA_ANI:
            ia_perso2d_ani(i); // here we call the routine to launch an animation
            break;
        box AIA_BEZ:
            ia_perso2d_bezier(i);
            break;
        box AIA_DEL:
            ia_perso2d_del(i);
            break;
        }
    }
}

// 001|times|3|002|000
void TmodGame::ia_perso2d_tps(size_t ref)
{
    std::string str;
    uint64_t tps;

    // initialize the action
    if (personal2d[ref].tactic.getValue_bool() == 0)
    {
        personal2d[ref].tactic.setValue_bool(1); // blocked

        str = personal2d[ref].tactic.getParam(); // we know that this action 
                                                 // requires a value in seconds
        tps = ECO_strToInt(str);
        perso2d[ref].tactic.setValueT64(ECO_getTicks() + (tps*1000)); // we indicate the 
                                                                      // value to reach
    }
    // when the value is reached, we move to the next line
    // (ECO_getTicks() must be replaced by a frame counter 
    // if the game supports acceleration)
    if (ECO_getTicks() > perso2d[ref].tactic.getValueT64())
    {
        personal2d[ref].tactic.setLine(personal2d[ref].tactic.getLink1());
        personal2d[ref].tactic.razValues(); // especially clear all values!
    }
}

// the animation depends on your animation system, but the principle is the same

//002|ani|ani walks 1|003|000
void TmodGame::ia_perso2d_ani(size_t ref)
{
    std::vector<std::string> strList;
    std::string str;

    // split the parameter string, i.e.: strlist[0] = 
    // ani / strList[1] = march / strList[2] = "1" (the function is given below)
    ECO_strCut(strList, perso2d[ref].tactic.getParam(), IA_SEP_INTERNE);

    // ani for an animation (for me we also find cycle which is a series of 
    // several animations)
    if (strList[0] == gl_code_ani[ANI_ANI]) // it's "ani"
    {
        perso2d[ref].anim_start( strList[1], ECO_strToInt(strList[2]) ); // ref animation
                                                                         // and loop
    }
    //else if (strList[0] == gl_code_ani[ANI_CYC])
    //{
    // personal2d[ref].anim_start(strList[1], 9); // run the animation 9 times
    //}

    // the animation is started, moves to the next line
    personal2d[ref].tactic.setLine(personal2d[ref].tactic.getLink1());
    personal2d[ref].tactic.razValues();
}

// here is a simple movement in a straight line

// 002|mvt|0.05 / -10.5 0 -10|003|000
void TmodGame::ia_perso2d_mvt(size_t ref)
{
    std::vector<std::string> strList;
    std::string str;

    if (personal2d[ref].tactic.getValue_bool() == 0)
    {
        OVec3_f pos = perso2d[ref].getPos();

        personal2d[ref].tactic.setValue_bool(1);

        str = personal2d[ref].tactic.getParam();
        ECO_strCut(strList, str, IA_SEP_INTERNE);

        if (strList[2] != "%") pos.x = ECO_strToFloat(strList[2]);
        if (strList[3] != "%") pos.y = ECO_strToFloat(strList[3]);
        if (strList[4] != "%") pos.z = ECO_strToFloat(strList[4]);

        personal2d[ref].tactic.setValue_vec3(pos);
        perso2d[ref].tactic.setValueF( ECO_strToFloat(strList[0]) );
    }
    else
    {
        OVec3_f pos0, pos1, direction;
        //int ok = 0;
        float lives;

        lives = personal2d[ref].tactic.getValueF();
        pos0 = personal2d[ref].getPos();
        pos1 = personal2d[ref].tactic.getValue_vec3();
        direction = pos1 - pos0;
        pos0 += sens.normalized() * vit;

        if (ECO_distanceVF(pos0,pos1) <= vit)
        {
            personal2d[ref].setPos(pos1); // correctly replace the character2d
            personal2d[ref].tactic.setLine(personal2d[ref].tactic.getLink1());
            personal2d[ref].tactic.razValues();
        }
        else
        {
            personal2d[ref].setPos(pos0);
        }
    }
}

Additional Procedures

void ECO_strCut(std::vector<std::string>& array, std::string str, char separator)
{
    //#include <sstream>
    std::istringstream iss( str );
    std::string word;

    while (std::getline(iss, word, separator))
    {
        // if there are three spaces/separators to follow, 
        // we find a separator and two empty strings
        if (word != "")
            array.push_back(word);
    }
}

#define ECO_sizeOf(a) (sizeof(a)/sizeof(a[0]))

History

• 29^th February, 2024: Initial version