Bobot_script.c

/*-----------------------------------------------------------------------------------------------------------
Joc : Script pour les nodes
-----------------------------------------------------------------------------------------------------------*/
#include "../game/g_local.h"
#include "bobot.h"
#include "bobot_script.h"
char *pScript;
node_trigger_t *pTeteTrigger;
qboolean PrintInfo=qfalse;                    // Pour afficher les messages de game play qtrue=oui qfalse=non
qboolean PrintError=qfalse;                    // Pour afficher les messages d'erreur qtrue=oui qfalse=non
qboolean PrintDebug=qfalse;                    // Pour afficher les message de debuggage qtrue=oui qfalse=non
char MessageNode[MAX_NODES][200];            // Liste des messages liés aux nodes

/*-----------------------------------------------------------------------------------------------------------
G_BobotNodeObjectifChange
lorsque le script fait un wm_objectifstatus on vérifie dans les trigger si il y en a un qui correspond
-----------------------------------------------------------------------------------------------------------*/
qboolean G_BobotNodeObjectifChange(int objectifNum,char* team,int status)
{    node_trigger_t    *trigger;
    int                iTeam;
    qboolean        resolve_all_path;

    if(objectifNum > number_of_nodes) 
    { return qfalse; }
    if (pTeteTrigger == NULL)
    { return qfalse; }
    if (team[0] == 'a')
    { iTeam = 1; }            //alliés retourné.
    else
    { iTeam = 0; }            //axis
    trigger = pTeteTrigger;
    resolve_all_path = qfalse;
    do
    {    if((trigger->NumObjectif == objectifNum) && (iTeam == trigger->Team) && (status == trigger->Status))
        {    G_Printf("\n^1BOBOT : Started wm_objectifstatus : ^$%i %i %i. ",trigger->NumObjectif,trigger->Team,trigger->Status);
            resolve_all_path = BobotNodeScriptDoAction(trigger,0);
        }
        trigger=trigger->next;
    }
    while(trigger != NULL);

    /*    Si on a ajouté ou supprimé une connexion il faut recalculer les chemins */
    if (resolve_all_path)
    { BOBOT_NODES_ResolveAllPaths(); }
    return qtrue;
}

/*-----------------------------------------------------------------------------------------------------------
Pav :
Fonction : G_BobotEvenementChange. Adaptation de la fonction G_BobotNodeObjectifChange
Description : Exécuter des évènements qui ne sont pas des objectifs primaires ou secondaires.
Lorsque le script exécute un evènement sur une entité, on vérifie dans les trigger s'il y en a un qui correspond.
Pour avoir un évènement du genre : footbridgeetatfinal, footbridgeetatdeath etc...,
footbridge(nom du trigger) "etat"(constante) death(valeur de l'état du trigger).
3 Zones pour garder la compatibilité avec les triggers 3 0 1 et ne pas devoir réécrire un truc pour ça.
Seuls sont intéressants et seront gardés, le nom du trigger et la valeur de son état.
Lancé par g_script.c fonction : G_Script_ScriptEvent.
-----------------------------------------------------------------------------------------------------------*/
qboolean G_BobotEvenementChange(char *TriggerName, char *eventStr, char *params)
{    node_trigger_t    *trigger;
    qboolean        resolve_all_path;
    char            BufChaine[300];
    int                x;
    char            even[300];
    //qboolean        TriggerOK=qfalse;

    if (pTeteTrigger == NULL)
    { return qfalse; }
    Q_strncpyz(even,TriggerName,sizeof(even));
    if (Q_stricmp(params, "") == 0)
    {    Q_strcat(even,sizeof(even),"etat");
        Q_strcat(even,sizeof(even),eventStr);
    }
    else if (Q_stricmp(eventStr, "trigger") == 0)
    {    Q_strcat(even,sizeof(even),"etat");
        Q_strcat(even,sizeof(even),params);
    }
    else
    {    Q_strcat(even,sizeof(even),eventStr);
        Q_strcat(even,sizeof(even),params);
    }
    trigger = pTeteTrigger;
    resolve_all_path = qfalse;
    if (Q_stricmp (even, "") != 0)
    {    for(x=0;x<=strlen(even);x++)    // Enlever les espaces éventuels dans la chaine even
        {    if (even[x]!=' ')
            { BufChaine[x]=even[x]; }
        }
        do
        {    if((Q_stricmp (trigger->Even,BufChaine)) == 0 || (Q_stricmp (trigger->Even,even) == 0))
            {    G_Printf("\n^1BOBOT : Started Trigger : ^$%s. ",trigger->Even);
                resolve_all_path = BobotNodeScriptDoAction(trigger,0);
                //TriggerOK=qtrue;
            }
            trigger=trigger->next;
        }
        while(trigger != NULL);
    }
    if (resolve_all_path)
    { BOBOT_NODES_ResolveAllPaths(); }

    /*if(TriggerOK==qtrue)
    {    G_Printf("adresse trigger %i \n",trigger);
        for (trigger = pTeteTrigger;trigger != NULL;trigger = trigger->next)
        { G_Printf("Trigger %i %i %i %s \nadresse %i",trigger->NumObjectif, trigger->Team, trigger->Status,trigger->Even,trigger); }   
        G_Printf("fin de la liste des trigger \n");
    }*/
    return qtrue;
}

/*-----------------------------------------------------------------------------------------------------------
BobotNodeScriptLoad  (was G_Script_ScriptLoad)
Charge le script de la map en cours dans le buffer
-----------------------------------------------------------------------------------------------------------*/
void BobotNodeScriptLoad( void )
{    char            filename[MAX_QPATH];
    vmCvar_t        mapname;
    fileHandle_t    f;
    int                len,i;
    char            info[5],debug[5],error[5];
   
    for (i=0;i<MAX_NODES;i++)
    { NodePris[i]=0; }
    trap_Cvar_Register(&mapname,"mapname","",CVAR_SERVERINFO | CVAR_ROM);
    Q_strncpyz(filename,"nodes/",sizeof(filename));
    Q_strcat( filename,sizeof(filename),mapname.string);
    Q_strcat( filename,sizeof(filename),".nodscript");
    len = trap_FS_FOpenFile(filename,&f,FS_READ);
    if(len < 0)
    {    G_Printf("\n^1BOBOT : Erreur : The script file %s is no found.",filename);
        return;
    }
    Q_strncpyz(info, "NO",sizeof(info));
    Q_strncpyz(error,"NO",sizeof(error));
    Q_strncpyz(debug,"NO",sizeof(debug));
    BOBOT_NODES_LoadNodes();
    pScript = G_Alloc( len + 1 );
    trap_FS_Read( pScript, len, f );
    *(pScript + len) = '\0';
    BobotNodeScriptParse();
    trap_FS_FCloseFile(f);
    if(PrintInfo)
    { Q_strncpyz(info,  "YES", sizeof(info)); }
    if(PrintError)
    { Q_strncpyz(error, "YES", sizeof(error)); }
    if(PrintDebug)
    { Q_strncpyz(debug, "YES", sizeof(debug)); }
    G_Printf("\n^1BOBOT : Script file %s loaded.\n",filename);
    //G_Printf("Game Message %s, Error Message %s, Debug Message %s\n",info,error,debug);
    BOBOT_NODES_LaunchController();            //joc lie les nodes à leur entité
}

/*-----------------------------------------------------------------------------------------------------------
BobotNodeScriptParse
Parses the script for the given entity
-----------------------------------------------------------------------------------------------------------*/
void BobotNodeScriptParse(void)
{    char            *token;
    char            AfficheToken[50];
    qboolean        inScript;
    int                wantTriggerParam,NbEven,IntDelta;
    int             actionNumber = 0;
    int             i,x;
    int                TailleChaine;
    char            BufChaine[300];
    node_trigger_t    *trigger;
    node_trigger_t     *pTeteTmp;
    qboolean        estInit;
    qboolean        multiset;
   
    wantTriggerParam = 1;
    NbEven = 0;
    inScript = qfalse;
    estInit = qfalse;
    multiset = qfalse;                                                                    //pour faire un set 0 to 50 par exemple ;)
    pTeteTmp = G_Alloc(sizeof(node_trigger_t));
    trigger = pTeteTmp;
    for (x=0;x<=MAX_NODES;x++)
    { MessageNode[x][0]='\0'; }                                                            //Message lié au node
    x=0;
    while (1)
    {    token = COM_Parse(&pScript );
        if (!token[0])
        {    if (wantTriggerParam == 0)
            {    G_Printf("\n^1BOBOT : Erreur : Vérifiez votre fichier script. Un } est attendu.");    }
            break;
        }

        /*    Fin du script */
        if (token[0] == '}')
        {    if (inScript)
            {    inScript = qfalse;
                wantTriggerParam = 1;                                                    //On attend un nouveau trigger
                if (estInit)
                {    BobotNodeScriptDoAction(trigger,0);                                    //Execute le trigger au moment ou on le charge
                    estInit = qfalse;
                    G_Printf("\n^1BOBOT : Nodes script initialisation (Trigger init)...");
                }
                continue;
            }
            if (wantTriggerParam > 0)
            {    G_Printf("\n^1BOBOT : Erreur : Vérifiez votre fichier script. On trouve } alors qu'un NOM est attendu.");    }
            wantTriggerParam = 1;
        }
        else if (token[0] == '{')
        {    if (wantTriggerParam > 0)
            {    G_Printf("\n^1BOBOT : Erreur : Vérifiez votre fichier script. On trouve { alors qu'un NOM est attendu.");
            }
        }
        else if (wantTriggerParam > 0)
        {    if(!Q_stricmp( token, "trigger"))
            {    trigger->next = G_Alloc(sizeof(node_trigger_t));
                trigger = trigger->next;
                trigger->next = NULL;
                actionNumber=-1;                                                        //attention on fait un actionNumber++ dès le début!
                IntDelta=0;
                /*    on initialise le trigger */
                for(i=0;i<NODE_MAX_ACTION_PAR_TRIGGER;i++)
                {    trigger->NodeNum[i] = -1;
                    trigger->NodeNum2[i] = -1;
                    trigger->NodeType[i] = 0;
                    trigger->Action[i] = TRIGGER_INVALID;
                }
                continue;
            }

            /*    trigger <objectif> <team> <status> team = 0(axis) ou 1(allies) status = 0(neutral) 1(success) 2(failed) */
            switch(wantTriggerParam)
            {
                case  1 :
                    if(!Q_stricmp( token, "init" ))// && !estInit)
                    {    wantTriggerParam = 0;
                        inScript = qtrue;
                        estInit = qtrue;
                        trigger->NumObjectif = -1;
                        trigger->Team = 0;
                        trigger->Status = 0;
                        break;
                    }
                    if(strlen(token)>=2)                                                    //Si chaine de caractère, alors évènement.
                    {    wantTriggerParam++;
                        NbEven++;
                        trigger->NumObjectif = -1;
                        trigger->Team = 0;
                        trigger->Status = 0;
                        Q_strncpyz(trigger->Even,token,sizeof(trigger->Even));
                        break;
                    }
                    trigger->NumObjectif = atoi(token);
                    wantTriggerParam++;
                    Q_strncpyz(AfficheToken,"Wm_ObjectiveStatus : ",sizeof(AfficheToken));
                    Q_strcat(AfficheToken,sizeof(AfficheToken),token);
                    Q_strcat(AfficheToken,sizeof(AfficheToken)," ");
                    break;
                case 2 :
                    if(strlen(token)>=2)                                                    //Si chaine de caractère, alors évènement.
                    {    wantTriggerParam++;
                        Q_strcat( trigger->Even,sizeof(trigger->Even),token);
                        break;
                    }
                    trigger->Team = atoi(token);
                    if(trigger->Team < 0 || trigger->Team > 1)
                    { trigger->Team = 0; }
                    Q_strcat(AfficheToken,sizeof(AfficheToken),token);
                    Q_strcat(AfficheToken,sizeof(AfficheToken)," ");
                    wantTriggerParam++;
                    break;
                case 3 :
                    trigger->Status = atoi(token);
                    if(trigger->Status < 0 || trigger->Status > 2)
                    { trigger->Status = 0; }
                    Q_strcat(AfficheToken,sizeof(AfficheToken),token);
                    wantTriggerParam = 0;
                    inScript = qtrue;
                    if (trigger->NumObjectif>0)
                    { G_Printf("\n^1BOBOT : %s",AfficheToken); }
                    if (NbEven>0)
                    {    NbEven=0;
                        Q_strcat( trigger->Even,sizeof(trigger->Even),token);
                        G_Printf("\n^1BOBOT : Trigger : %s",trigger->Even);
                    }
            }
        }
        else if (inScript)
        {    if( !Q_stricmp( token, "msg_gameplay"))                                        // Pav:Pour afficher les messages du game play
            { PrintInfo=qtrue; }
            if( !Q_stricmp( token, "msg_error"))                                        // Pav:Pour afficher les messages d'erreur
            { PrintError=qtrue; }
            if( !Q_stricmp( token, "msg_debug"))                                        // Pav:Pour afficher les messages de debug
            { PrintDebug=qtrue; }
           
            if( token[0]=='<')                                                            // Pav: Message (éventuellement) lié à un node
            {    BufChaine[0]='\0';
                TailleChaine=strlen(token);
                for(x=0;x<=strlen(token);x++)
                {    if (token[x]=='_' || token[x]=='<')
                    { BufChaine[x]=' '; }
                    else
                    { BufChaine[x]=token[x]; }
                }
                BufChaine[TailleChaine+1]='\0';
                if ((actionNumber>0) && (trigger->NodeNum[actionNumber] != INVALID))
                {    Q_strncpyz(MessageNode[trigger->NodeNum[actionNumber]],BufChaine,sizeof(BufChaine));    // Liste des messages liés aux nodes
                    //G_Printf("\nBOBOT. Node %i Message %s",trigger->NodeNum[actionNumber],MessageNode[trigger->NodeNum[actionNumber]]);
                }
            }
            else
            { BufChaine[0]='\0'; }

            /*    Change le type du node */
            if(!Q_stricmp(token, "set"))
            {    actionNumber++;
                if(actionNumber > NODE_MAX_ACTION_PAR_TRIGGER -1)
                {    G_Printf("\n^1BOBOT : Error : Too many actions on trigger, (%i maximum).\n",NODE_MAX_ACTION_PAR_TRIGGER);
                    return;
                }
                trigger->Action[actionNumber] = TRIGGER_SET;
                continue;
            }

            /*    Créer une connexion simple entre 2 nodes */
            if(!Q_stricmp( token, "create_connec"))
            {    actionNumber++;
                if(actionNumber > NODE_MAX_ACTION_PAR_TRIGGER -1)
                {    G_Printf("\n^1BOBOT : Error : Too many actions on trigger, (%i maximum).\n",NODE_MAX_ACTION_PAR_TRIGGER);
                    return;
                }
                trigger->Action[actionNumber] = TRIGGER_CREATE_CONNEC;
                continue;
            }

            /*    Pav:Connexion simple entre 2 nodes type échelle */
            if(!Q_stricmp( token, "create_connec_echelle"))
            {    actionNumber++;
                if(actionNumber > NODE_MAX_ACTION_PAR_TRIGGER -1)
                {    G_Printf("\n^1BOBOT : Error : Too many actions on trigger, (%i maximum).\n",NODE_MAX_ACTION_PAR_TRIGGER);
                    return;
                }
                trigger->Action[actionNumber] = TRIGGER_CREATE_CONNEC_ECHELLE;
                continue;
            }

            /*    Pav:Connexion simple entre 2 nodes type axis */
            if(!Q_stricmp( token, "create_connec_axis"))
            {    actionNumber++;
                if(actionNumber > NODE_MAX_ACTION_PAR_TRIGGER -1)
                {    G_Printf("\n^1BOBOT : Error : Too many actions on trigger, (%i maximum).\n",NODE_MAX_ACTION_PAR_TRIGGER);
                    return;
                }
                trigger->Action[actionNumber] = TRIGGER_CREATE_CONNEC_AXIS;
                continue;
            }
           
            /*    Pav:Connexion simple entre 2 nodes type allies */
            if(!Q_stricmp( token, "create_connec_allies"))
            {    actionNumber++;
                if(actionNumber > NODE_MAX_ACTION_PAR_TRIGGER -1)
                {    G_Printf("\n^1BOBOT : Error : Too many actions on trigger, (%i maximum).\n",NODE_MAX_ACTION_PAR_TRIGGER);
                    return;
                }
                trigger->Action[actionNumber] = TRIGGER_CREATE_CONNEC_ALLIES;
                continue;
            }

            /*    Pav:Connexion simple entre 2 nodes type basic */
            if(!Q_stricmp( token, "create_connec_basic"))
            {    actionNumber++;
                if(actionNumber > NODE_MAX_ACTION_PAR_TRIGGER -1)
                {    G_Printf("\n^1BOBOT : Error : Too many actions on trigger, (%i maximum).\n",NODE_MAX_ACTION_PAR_TRIGGER);
                    return;
                }
                trigger->Action[actionNumber] = TRIGGER_CREATE_CONNEC_TOUT_DROIT;
                continue;
            }

            /*    Pav:Connexion nodes type door */
            /*if(!Q_stricmp( token, "create_connec_door"))
            {    actionNumber++;
                if(actionNumber > NODE_MAX_ACTION_PAR_TRIGGER -1)
                {    G_Printf("Erreur : bobot_script.c - Fonction : BobotNodeScriptParse\n");
                    G_Printf("Trop d'actions sur un trigger, (%i au maximum).\n",
                    NODE_MAX_ACTION_PAR_TRIGGER);
                    return;
                }
                trigger->Action[actionNumber] = TRIGGER_CREATE_CONNEC_DOOR;
                continue;
            }*/

            /*    Supprimer une connexion simple entre 2 nodes */
            if(!Q_stricmp( token, "destroy_connec"))
            {    actionNumber++;
                if(actionNumber > NODE_MAX_ACTION_PAR_TRIGGER -1)
                {    G_Printf("\n^1BOBOT : Error : Too many actions on trigger, (%i maximum).\n",NODE_MAX_ACTION_PAR_TRIGGER);
                    return;
                }
                trigger->Action[actionNumber] = TRIGGER_DESTROY_CONNEC;
                continue;
            }

            /*    Faire une action à retardement */
            if(!Q_stricmp( token, "wait"))
            {    actionNumber++;
                if(actionNumber > NODE_MAX_ACTION_PAR_TRIGGER -1)
                {    G_Printf("\n^1BOBOT : Error : Too many actions on trigger, (%i maximum).\n",NODE_MAX_ACTION_PAR_TRIGGER);
                    return;
                }
                trigger->Action[actionNumber] = TRIGGER_WAIT;
                continue;
            }
            if(trigger->Action[actionNumber] == TRIGGER_SET)
            {    if (trigger->NodeNum[actionNumber] == -1)
                {    if(!Q_stricmp( token, "all"))                                        // Tous les nodes
                    {    if (PrintDebug)
                        { Bobot_Printf(" Set all\n"); }
                        trigger->NodeNum[actionNumber] = MAX_NODES*(MAX_NODES -1);
                    }
                    else
                    {    trigger->NodeNum[actionNumber] = atoi(token);                    // Le node passé en paramètre   
                        if(trigger->NodeNum[actionNumber] < 0 ||
                            trigger->NodeNum[actionNumber] > MAX_NODES)
                        { trigger->NodeNum[actionNumber] = 0; }
                    }
                }
                else if(!Q_stricmp(token, "to"))
                { multiset = qtrue; }
                else if(multiset)
                {    int n;
                    n = atoi(token);
                    if( n<0 || n >= MAX_NODES)
                    { n=0; }
                    trigger->NodeNum[actionNumber] += n*MAX_NODES;
                    multiset = qfalse;
                }
                else
                { trigger->NodeType[actionNumber] |= BobotNodeScriptCmd(token); }
                continue;
            }
            if(trigger->Action[actionNumber] == TRIGGER_CREATE_CONNEC ||
               trigger->Action[actionNumber] == TRIGGER_CREATE_CONNEC_ECHELLE ||
               trigger->Action[actionNumber] == TRIGGER_CREATE_CONNEC_AXIS ||
               trigger->Action[actionNumber] == TRIGGER_CREATE_CONNEC_ALLIES ||
               trigger->Action[actionNumber] == TRIGGER_CREATE_CONNEC_TOUT_DROIT ||
               trigger->Action[actionNumber] == TRIGGER_DESTROY_CONNEC)
               //|| trigger->Action[actionNumber] == TRIGGER_CREATE_CONNEC_DOOR)
            {   
                if (trigger->NodeNum[actionNumber] == -1)
                {    trigger->NodeNum[actionNumber] = atoi(token);
                    if(trigger->NodeNum[actionNumber] < 0 || trigger->NodeNum[actionNumber] > MAX_NODES)
                    { trigger->NodeNum[actionNumber] = 0; }
                }
                else if (trigger->NodeNum2[actionNumber]==-1)
                {    trigger->NodeNum2[actionNumber] = atoi(token);
                    if(trigger->NodeNum2[actionNumber] < 0 || trigger->NodeNum2[actionNumber] > MAX_NODES)
                    { trigger->NodeNum2[actionNumber] = 0; }
                }
                continue;
            }
            if(trigger->Action[actionNumber] == TRIGGER_WAIT)
            {    if (trigger->NodeNum[actionNumber] == -1)
                {    trigger->NodeNum[actionNumber] = atoi(token);
                    if(trigger->NodeNum[actionNumber] < 0 )
                    { trigger->NodeNum[actionNumber] = 0; }
                }
                continue;
            }
        }
    }
    pTeteTrigger = pTeteTmp;

    /*G_Printf("\n\nTrigger List (Memory Adress %i)",trigger);
    for (trigger = pTeteTrigger;trigger != NULL;trigger = trigger->next)
    {    G_Printf("\nTrigger : N° %i Team %i Status %i Even %s",
        trigger->NumObjectif, trigger->Team, trigger->Status,trigger->Even);
    }   
    G_Printf("\nEnd Triggers list\n");*/
}

/*-----------------------------------------------------------------------------------------------------------
Joc : retourne le type à partir du nom
-----------------------------------------------------------------------------------------------------------*/
int BobotNodeScriptCmd(char *cmd)
{
    if (!Q_stricmp( cmd, "move" ))
    { return NODE_MOVE; }
    else if (!Q_stricmp( cmd, "objectif_pri" ))
    { return NODE_OBJECTIF_PRIM; }
    else if (!Q_stricmp( cmd, "objectif_sec" ))
    { return NODE_OBJECTIF_SEC; }
    else if (!Q_stricmp( cmd, "prone" ))
    { return NODE_PRONE; }
    else if (!Q_stricmp( cmd, "dynamite" ))
    { return NODE_DYNAMITE; }
    else if (!Q_stricmp( cmd, "drapeau" ))
    { return NODE_DRAPEAU; }
    else if (!Q_stricmp( cmd, "mobil" ))
    { return NODE_MOBIL; }
    else if (!Q_stricmp( cmd, "mine" ))
    { return NODE_MINE; }
    else if (!Q_stricmp( cmd, "protection" ))
    { return NODE_PROTECTION; }
    else if (!Q_stricmp( cmd, "construction" ))
    { return NODE_CONSTRUCTION; }
    else if (!Q_stricmp( cmd, "blockable" ))
    { return NODE_BLOCKABLE; }
    else if (!Q_stricmp( cmd, "allies" ))
    { return NODE_TEAM_ALLIES; }
    else if (!Q_stricmp( cmd, "axis" ))
    { return NODE_TEAM_AXIS; }
    else if (!Q_stricmp( cmd, "charge" ))
    { return NODE_CHARGE; }
    else if (!Q_stricmp( cmd, "echelle" ))
    { return NODE_ECHELLE; }
    else if (!Q_stricmp( cmd, "linked" ))
    { return NODE_LINKED; }
    else if (!Q_stricmp( cmd, "healer" ))
    { return NODE_HEALER; }
    else if (!Q_stricmp( cmd, "supplier" ))
    { return NODE_SUPPLIER; }
    else if (!Q_stricmp( cmd, "tank"))
    { return NODE_TANK; }
    else if (!Q_stricmp( cmd, "tankway"))
    { return NODE_TANK_WAY; }
    else if (!Q_stricmp( cmd, "take"))
    { return NODE_TAKE; }
    else if (!Q_stricmp( cmd, "heavy_machinegun"))
    { return NODE_HEAVY_MACHINGUN; }
    else if (!Q_stricmp( cmd, "jump"))
    { return NODE_JUMP; }
    /*else if (!Q_stricmp( cmd, "snipe"))
    { return NODE_SNIPE; }*/
    else if (!Q_stricmp( cmd, "duck"))
    { return NODE_DUCK; }
    else if (!Q_stricmp( cmd, "allteam"))
    { return NODE_ALLTEAM; }
    else
    { return atoi(cmd); }
}

/*-----------------------------------------------------------------------------------------------------------
Joc : Lance une entité qui gére les wait
-----------------------------------------------------------------------------------------------------------*/
void BobotNodeScriptWait(node_trigger_t *trigger,int i)
{
    gentity_t *ent;
   
    ent = G_Spawn();
    ent->inuse = qtrue;
    ent->think = BobotNodeScriptWait_Think;
    ent->nextthink = level.time  + trigger->NodeNum[i];
    ent->count    = trigger;
    ent->count2 = i+1;
    if (PrintDebug)
    { Bobot_Printf("ScriptWait: %i \n",trigger->NodeNum[i]); }
}

/*-----------------------------------------------------------------------------------------------------------
Joc : le Think pour l'entité Wait
-----------------------------------------------------------------------------------------------------------*/
void BobotNodeScriptWait_Think(gentity_t *ent)
{   
    BobotNodeScriptDoAction(ent->count,ent->count2);
    if (PrintDebug)
    { Bobot_Printf("Script_wait_think"); }
    G_FreeEntity(ent);
}

/*-----------------------------------------------------------------------------------------------------------
Joc : Fait l'action du trigger
-----------------------------------------------------------------------------------------------------------*/
qboolean BobotNodeScriptDoAction(node_trigger_t *trigger,int deb) 
{    int         i,j,nodenum;
    qboolean resolve_all_path = qfalse;
   
    for(i=deb;i < NODE_MAX_ACTION_PAR_TRIGGER;i++)
    {    switch(trigger->Action[i])
        {
            case TRIGGER_CREATE_CONNEC:                //Connexion normale (type neuronale)
                BOBOT_MAPPING_CreateNodeConnection(trigger->NodeNum[i],trigger->NodeNum2[i], CONNEC_NORMAL );
                resolve_all_path = qtrue;
                break;
            case TRIGGER_CREATE_CONNEC_ECHELLE:        //Connexion type échelle
                BOBOT_MAPPING_CreateNodeConnection(trigger->NodeNum[i],trigger->NodeNum2[i], CONNEC_ECHELLE );
                resolve_all_path = qtrue;
                break;
            case TRIGGER_CREATE_CONNEC_AXIS:        //Connexion type axis
                BOBOT_MAPPING_CreateNodeConnection(trigger->NodeNum[i],trigger->NodeNum2[i], CONNEC_AXIS );
                resolve_all_path = qtrue;
                break;
            case TRIGGER_CREATE_CONNEC_ALLIES:        //Connexion type alliés
                BOBOT_MAPPING_CreateNodeConnection(trigger->NodeNum[i],trigger->NodeNum2[i], CONNEC_ALLIES );
                resolve_all_path = qtrue;
                break;
            case TRIGGER_CREATE_CONNEC_TOUT_DROIT:    //Connexion type basic (tout droit) (géré dans le move)
                BOBOT_MAPPING_CreateNodeConnection(trigger->NodeNum[i],trigger->NodeNum2[i], CONNEC_TOUT_DROIT );
                resolve_all_path = qtrue;
                break;

            /*case TRIGGER_CREATE_CONNEC_DOOR:        //Connexion type door all team
                BOBOT_MAPPING_CreateNodeConnection(trigger->NodeNum[i],trigger->NodeNum2[i], CONNEC_DOOR );
                resolve_all_path = qtrue;
                break;*/

            case TRIGGER_DESTROY_CONNEC:            //Destruction d'une connexion
                BOBOT_MAPPING_DestroyNodeConnection(trigger->NodeNum[i],trigger->NodeNum2[i]);
                resolve_all_path = qtrue;
                break;
            case TRIGGER_SET:
                nodenum = trigger->NodeNum[i];
                if (nodenum>=MAX_NODES)                //Si on fait un set sur une plage de node (5 to 20 par exemple)
                {    //G_Printf("Nodes[%i,%i]\n",(nodenum % MAX_NODES),(nodenum / MAX_NODES));
                    for(j=(nodenum % MAX_NODES); j<=(nodenum / MAX_NODES); j++)
                    { nodes[j].type = trigger->NodeType[i]; }
                }
                else
                {    if (nodenum > -1)
                    {    nodes[trigger->NodeNum[i]].type = trigger->NodeType[i];    }
                }
                break;
            case TRIGGER_WAIT:
                BobotNodeScriptWait(trigger,i);
                i=NODE_MAX_ACTION_PAR_TRIGGER;
                break;
        }
    }
    return resolve_all_path;
}

Créer un site gratuit avec e-monsite - Signaler un contenu illicite sur ce site