Bobot.h (1)

/*"IamSoldier","IamMedic","IamLieutenant","IamEngineer","LetsGo","FireInTheHole","Thanks","WhereTo","NeedEngineer","CoverMe"
"Negative","Hi","Sorry","Yeah","EnemyWeak","HoldFire","TakingFire","Incoming","NeedAmmo","Medic","Welcome","HealMe","NeedBackup"
"DynamitePlanted","GreatShot","FollowMe","DropFlag","AggressionLow","AggressionMed","AggressionHigh","AggressionCycle","AutonomyLow",
"AutonomyMed","AutonomyHigh",,"AutonomyCycle","HoldPosition","Prone","Crouch","Stand","PositionCycle","FireteamA","FireteamB",
"FireteamC","ReviveMe","HealTeam","TeamAmmo","CycleWeapon","BestWeapon","HelpMe","HelpTeam",

trap_Cvar_VariableStringBuffer("g_gametype", buf, sizeof(buf)); ai_main.c

// look for cg_hitsounds G_client.c : void ClientUserinfoChanged( int clientNum )
    s = Info_ValueForKey(userinfo, "cg_hitsounds");
    if(*s) client->pers.hitsounds = atoi(s);
    else client->pers.hitsounds = 1;

*/

#ifndef _BOBOT_H
#define _BOBOT_H
#include "bobot_ai.h"
#include "bobot_nn.h"

/*------------------------------------------------------------------------------------
  ___       __ _      _ _   _            
 |   \ ___ / _(_)_ _ (_) |_(_)___ _ _  ___
 | |) / -_)  _| | ' \| |  _| / _ \ ' \(_-<
 |___/\___|_| |_|_||_|_|\__|_\___/_||_/__/

 ------------------------------------------------------------------------------------*/
//#define MAX_NODES         300            //(déplacé dans g_local.h)
#define MAX_CONNEXIONS         2000        // Maximum connexions.
#define MAX_VISIBLENODES    150
#define NODE_DENSITY          10000        // Node Density
#define MAX_NODELINKS       12          // Maximum Node Links (12)
#define INVALID             -1          // Invalid Node Link
#define NO_CONNECTION        9999999.0f    // qd les nodes ne sont pas connectés
#define MAX_SKILL            6            // joc : skill de 0 à 5
#define MAX_CABINETS        20
extern  cvar_t              *botchat;   // Bot Chat, off/on (0,1)
extern  cvar_t              *showpath;  // Show bot paths
#define    MOVE_PRONE_TIME        5000        // Temps max prone en mouvement
#define    MGNEST_TIME            30000        // Temps max sur un mg42 (30 secondes au minimum)
//#define    NODE_TIME            180000        // Temps max sur un node 3 minutes avant un autokill
/*------------------------------------------------------------------------------------
  _  _         _       _____                 
 | \| |___  __| |___  |_   _|  _ _ __  ___ ___
 | .` / _ \/ _` / -_)   | || || | '_ \/ -_|_-<
 |_|\_\___/\__,_\___|   |_| \_, | .__/\___/__/
                            |__/|_| 
------------------------------------------------------------------------------------*/
#define NODE_INVALID            0x00000000            //si le node n'existe pas
#define    NODE_MOVE                0x00000001            //tous les nodes sont des points de passage !
#define    NODE_OBJECTIF_PRIM        0x00000002            //Objectif primaire
#define    NODE_OBJECTIF_SEC        0x00000004            //Objectif secondaire
#define NODE_PRONE                0x00000008            //le bot peut se coucher à cet endroit
#define NODE_DYNAMITE            0x00000010            //il faut poser une dynamite sur ce node
#define NODE_MINE                0x00000020            //il faut poser une mine sur ce node
#define NODE_DRAPEAU            0x00000040            //il est important que le bot aille au centre de ce node pour capturer le drapeau
#define    NODE_MOBIL                0x00000080            //Node se déplaçant en même temps q'un véhicule
#define    NODE_PROTECTION            0x00000100            //objectif à defendre
#define    NODE_CONSTRUCTION        0x00000200            //Construire sur ce node
#define    NODE_MG42                0x00000400            //pour toutes les MG42 fixe
#define NODE_TEAM_ALLIES        0x00000800            //si le node appartient aux alliés
#define NODE_TEAM_AXIS            0x00001000            //si le node appartient aux axis
#define    NODE_ALLTEAM            0x00002000            //Toutes les teams
#define NODE_ECHELLE            0x00004000            //une echelle il faut la monter ou la descendre sans se peter la gueule
#define NODE_LINKED                0x00008000            //si on lie le node à une entité
#define NODE_HEALER                0x00010000            //armoire de soins
#define NODE_SUPPLIER            0x00020000            //armoire de munitions
#define NODE_TANK                0x00040000            //pour les véhicule
#define NODE_HEAVY_MACHINGUN    0x00080000            //pour les mg42 ou le tank signifie qu'on peut utiliser la machingun si elle est réparé...
#define NODE_TANK_WAY            0x00100000            //les nodes qui sont sur le chemin emprunte par le véhicule
#define NODE_ALL                0xFFFFFFFF            //For selecting all nodes
#define NODE_TAKE                0x00200000            //Objet à se saisir, poute à ouvrir toute team.
#define NODE_CHARGE                0x00400000            //Pour les coverts
#define NODE_JUMP                0x00800000            //jump
#define NODE_DUCK                0x01000000            //ducker
#define    NODE_BLOCKABLE            0x02000000            //pour bloquer un bot sur un node

/*    Connexions */
#define    CONNEC_NORMAL            0x00000000            //connection neuronale
#define    CONNEC_ALLIES            0x00000001            //porte alliés
#define    CONNEC_AXIS                0x00000002            //porte axis
#define CONNEC_ECHELLE            0x00000004            //le bot monte à l'échelle
#define CONNEC_TOUT_DROIT        0x00000008            //le bot doit aller droit
//#define CONNEC_DOOR            0x00000009            //Pour les portes toutes teams. (reste : 3,5,6,7 : on ne peut pas dépasser 9)

/*----------------------------------------------------------------------------------------------
Vision du Bobot
fait par Joc
pour améliorer la rapidité et la précision du bot on augmente le gain FTBO et le frein appliqué
prévoir plusieurs valeurs selon le skill du bobot
-----------------------------------------------------------------------------------------------*/
#define BOBOT_VIEW_MAX_ACCEL        30                // accélération maximum de la vue du bobot
#define BOBOT_VIEW_MAX_SPEED        100                // vitesse max de la vue du bobot (100 degré par frame (soit 1000 degré par seconde))

/* joc Skill  */
#define BOBOT_VIEW_PRECISION_TIR    10                // si on est à moins de 10 degré de la tete de l'enemy on tire !!
#define BOBOT_DETECT_MAX_ITEM        32                // Nombre maximal d'objets detectés
#define BOBOT_DETECT_MAX_ENEMIES    32                // Nombre maximal d'ennemis détectés par le bobot en meme temps.
#define BOBOT_DETECT_MAX_TEAMMATES    BOBOT_DETECT_MAX_ENEMIES
#define BOBOT_DIST_GIVE_PACK        10000            // distance à laquelle medic et field ops larguent un pack
#define BOBOT_DIST_CARRY_PACK        40000            // distance à laquelle medic et field ops sortent le pack avant de le donner
#define BOBOT_MEDIC_DIST_REVIVE        10000            // distance à laquelle le medic se deplace tout droit vers le gars qu'il va ressuciter
#define BOBOT_DIST_TAKE_PACK        40000            // distance à laquelle le bot se déplace tout droit vers un pack
#define BOBOT_FIELDOPS_MIN_MUNI        0.4f            //on donne des muni si muni_total/munimax < 0.4
#define UNLIMITED                    1000000

/* priorités de certaines actions (entre 0 et 100).
    Les autres actions ont des priorités variables, déterminées par des règles floues.*/

#define GO_TO_LR_OBJ_PRIORITY            40            // priorité du LR goal. pour l'instant c'est une  constante. On fera peut-être mieux si nécessaire.
#define BOBOT_PLANT_DYNAMITE_PRIORITY    60            // Ici c'est pas gênant que ça soit des constantes
#define BOBOT_PLANT_MINE_PRIORITY        50            // Ici c'est pas gênant que ça soit des constantes
#define BOBOT_CONSTRUCT_PRIORITY        60            // car l'action est toujours faite tout près de la cible
#define    BOBOT_DEFUSE_DYNAMITE_PRIORITY    90            // donc la priorité ne dépend pas de la distance (élément fondamental)
#define NB_MAX_ACTIONS_IN_STACK            20            // nb max d'actions dans la pile d'attente des actions interrompues
#define BOBOT_DETECT_MAX_PACKS            10            // max packs de soin et max packs de munis
#define MAX_DETECTION_ITEM_DISTANCE        1000.0f        // distance max à laquelle un bot pourra voir un item (pack par ex.)
#define MAX_KNOWLEDGE_CABINET_DISTANCE    4000.0f        // distance max de prise en compte d'une armoire
#define    BOBOT_TEAMMATES_MAX_DIST        1500.0f        // distance max de prise en compte de ses coéquipiers
#define NB_DIRECTIONS_EVALUATED_TO_GET_COVER 10.0f
//#define PROB_GO_TO_LR_OBJ_PRIORITY        5000000.0f
/*------------------------------------------------------------------------------------
  ___      _     ___ _____ _ _____ ___
 | _ ) ___| |_  / __|_   _/_\_   _| __|
 | _ \/ _ \  _| \__ \ | |/ _ \| | | _|
 |___/\___/\__| |___/ |_/_/ \_\_| |___|

 ------------------------------------------------------------------------------------*/
typedef enum
{
    BOT_STATE_STAND,                                // Bot Standing
    BOT_STATE_MOVE,                                    // Bot Moving
    BOT_STATE_ATTACK,                                // Bot Attacking
    BOT_STATE_WANDER,                                // Bot Wandering
    BOT_STATE_FLEE,                                    // Bot Fleeing
    BOT_STATE_POSITION,                                // Bot Position
    BOT_STATE_GETFLAG,                                // Bot on flag 'recap' duty
    BOT_STATE_SPECIAL_MOVE,                            // Bot monte une echelle
    BOT_STATE_CONSTRUCT,                            // Bot Constructs
    BOT_STATE_DYNAMITE,                                // Bot pose une dyna
    BOT_STATE_ARMING_DYNA,                            // Bot arme la dyna
    BOT_STATE_DEFUSE,                                // Bot defuse la dyna
    BOT_STATE_REVIVE,                                // Bot revive un coequipier
    BOT_STATE_GIVE_HEALTH,                            // Bot donne de la vie
    BOT_STATE_GIVE_AMMO,                            // Bot donne des pack de muni
    BOT_STATE_TAKE_PACK,                            // le bot prend un pack
    BOT_STATE_DEFEND_POSITION,                         // le bot défend sa position face à un ennemi
    BOT_STATE_CHASE_ENEMY,                            // le bot poursuit un ennemi
    BOT_STATE_BACKUP_TEAMMATE,                        // le bot vient en renfort d'un équipier
    BOT_STATE_PROTECT_FROM_ENEMY_WHILE_RELOADING,    // le bot se met à couvert
    BOT_STATE_PROTECT_FROM_ENEMY,                    // le bot se met à couvert
    BOT_STATE_TOUT_DROIT,                            // Bot va tout droit
    BOT_STATE_MINE,                                    // Poser une mine
    BOT_STATE_ARMING_MINE,                            // Armorcer une mine
    BOT_STATE_FOLLOW_TEAMMATE,                        // Suivre un teammate
    BOT_STATE_BACKUP,
    BOT_STATE_DEGUISE,
}state_t;

#define ACTION_DEFAULT        0
#define ACTION_FLAGRECAP    1
#define ACTION_FLAGCAPTURE    2
#define ACTION_KILLCARRIER    3
#define BOT_MOVE_LEFT       0                        // Bot Move Left
#define BOT_MOVE_RIGHT      1                        // Bot Move Right
#define BOT_MOVE_FORWARD    2                        // Bot Move Forward
#define BOT_MOVE_BACK       3                        // Bot Move Back

/*------------------------------------------------------------------------------------
    _  _         _       ___     _         _ _    _
   | \| |___  __| |___  | _ \___| |__ _  _(_) |__| |
   | .` / _ \/ _` / -_) |   / -_) '_ \ || | | / _` |
   |_|\_\___/\__,_\___| |_|_\___|_.__/\_,_|_|_\__,_|

   ------------------------------------------------------------------------------------*/

extern qboolean    shownodes;
#define BOBOT_MEDIC_ReviveRADIUS    500

/*------------------------------------------------------------------------------------
  _  _         _       _    _      _     ___ _               _               
 | \| |___  __| |___  | |  (_)_ _ | |__ / __| |_ _ _ _  _ __| |_ _  _ _ _ ___
 | .` / _ \/ _` / -_) | |__| | ' \| / / \__ \  _| '_| || / _|  _| || | '_/ -_)
 |_|\_\___/\__,_\___| |____|_|_||_|_\_\ |___/\__|_|  \_,_\__|\__|\_,_|_| \___|

------------------------------------------------------------------------------------*/

typedef struct nodelink_s                            // Node Link Structure
{
       short int   targetNode;                            // Target Node
    int            type;                                // Connectype
       float       cost;                                  // Cost for PathSearch algorithm
}nodelink_t;                                           // Node Link Typedef

typedef struct nodelink2_s                             // Node Link Structure
{
    short int   targetNode;                         // Target Node
    int            type;
    float       cost;                               // Cost for PathSearch algorithm
}nodelink2_t;

/*-----------------------------------------------------------------------------------
  _  _         _       ___ _               _               
 | \| |___  __| |___  / __| |_ _ _ _  _ __| |_ _  _ _ _ ___
 | .` / _ \/ _` / -_) \__ \  _| '_| || / _|  _| || | '_/ -_)
 |_|\_\___/\__,_\___| |___/\__|_|  \_,_\__|\__|\_,_|_| \___|

------------------------------------------------------------------------------------*/
typedef struct node_s                               // Node Structure
{
    vec3_t      origin;                             // Node Origin
    int         type;                               // Node Type
    short int   enodenum;                            // Mostly just number of players around this node
    nodelink_t  links[MAX_NODELINKS];                // Store all links
    float radius;                                    // joc_node. Rayon de la sphere
} node_t;                                           // Node Typedef

typedef struct node2_s                              // Node Structure
{
    vec3_t             origin;                            // Node Origin
    int             type;                           // Node Type
    short int       enodenum;                        // Mostly just number of players around this node
    nodelink2_t      links[MAX_NODELINKS];            // Store all links
    float            radius;                            // joc_node. Rayon de la sphere
} node2_t;                                           // Node Typedef

/*    Joc je le laisse mais je sais pas si ca sert */
typedef struct flagstate_s
{
    qboolean    dropped;
    qboolean    valid;                                // Can be invalid if the flag is not reachable f.i.
    qboolean    stolen;
    int            node;                                // Number of the node closest to the flag
    int            entityNum;                            // Index number of the entity for this flag
    int            carrier;                            // Playernumber of the player carrying the flag

} flagstate_t;

typedef struct botai_s
{
    qboolean    ctf;                                // Is true if we have to capture flag, docs, gold or something
    flagstate_t flagstate[TEAM_NUM_TEAMS];
} botai_t;

extern botai_t botai;

/*------------------------------------------------------------------------------------
  ___      _     ___ _               _               
 | _ ) ___| |_  / __| |_ _ _ _  _ __| |_ _  _ _ _ ___
 | _ \/ _ \  _| \__ \  _| '_| || / _|  _| || | '_/ -_)
 |___/\___/\__| |___/\__|_|  \_,_\__|\__|\_,_|_| \___|

 ------------------------------------------------------------------------------------*/

/*    structure pour detecter les clients et les objets */
typedef struct det_client_s
{
    gentity_t    *ent;
    team_t        team;
    qboolean    isVisible;
    float        dist;
} det_client_t;

typedef struct det_item_s
{
    gentity_t    *ent;
    qboolean    isVisible;
    float        dist;
} det_item_t;

typedef struct known_cabinet_s
{
    gentity_t    *ent;
    int            node;
} known_cabinet_t;

/*    actions réquisitionnant le déplacement */
typedef enum
{
    GO_TO_LR_GOAL = 0,                                // aller à son objectif à long terme
    GO_TO_CABINET_HEAL,                                // aller se soigner à une armoire dont on connaît la position (un node)
    TAKE_HEALTH_PACK,                                // aller récupérer un pack de soin visible
    GO_TO_CABINET_SUPPLY,                            // aller se ravitailler en munition à une armoire dont le bot connait la position
    TAKE_AMMO_PACK,                                    // aller récupérer un pack de munitions visible
    DEFEND_POSITION,                                // défendre une position (~camping)
    CHASE_ENEMY,                                    // poursuivre un ennemi qu'on ne voit plus
    BACKUP_TEAMMATE,                                // venir en renfort à un équipier qui se bat contre un ennemi
    PROTECT_FROM_ENEMY,                                // se mettre à couvert
    PROTECT_FROM_ENEMY_WHILE_RELOADING,
    /*     actions supplémentaires pour l'ingénieur */
    CONSTRUCT,                                        // construire à un node de construction
    PLANT_DYNAMITE,                                    // poser une dynamite
    ARM_DYNAMITE,                                    // amorcer une dynamite
    DEFUSE_DYNAMITE,                                // désamorcer une dynamite
    /*    actions supplémentaires pour le medic */
    GIVE_HEALTH,                                    // se déplacer vers un équipier et lui déposer un pack de soin sur lui
    GIVE_MYSELF_HEALTH,                                // se donner à soi même un pack de soin
    REVIVE,                                            // se déplacer vers un équipier et lui administrer une piqure d'adrénaline
    /*    actions supplémentaires pour le field ops */
    GIVE_AMMO,                                        // se déplacer vers un équipier et lui déposer un pack de munitions sur lui
    GIVE_MYSELF_AMMO,                                // se donner à soi même un pack de munitions
    /*    actions supplémentaires pour l'ingénieur */
    PLANT_MINE,                                        // planter une mine
    ARM_MINE,                                        // armer une mine
    FOLLOW_TEAMMATE,
    BACKUP,
    DEGUISE,
    NB_COMMON_OBJECTIVES,                            // nombre d'objectifs
} objective_t;

/*    les actions concernant la protection face à un ennemi */
typedef enum
{
    NOT_NECESSARY,
    NOT_POSSIBLE,
    DUCK,
    PRONE,
    GO_TO_COVERED_POINT,
} protection_action_t;

/*    actions des bras du bot */
typedef enum
{
    BOBOT_LOOK_AROUND = NB_COMMON_OBJECTIVES,        // guêter d'éventuels ennemis
    BOBOT_FIRE,                                        // tirer sur un ennemi
    BOBOT_OBEY_TO_ACTION,                            // se faire guider par l'action de plus haut niveau en cours
} action_bras_t;

typedef struct action_s
{
    int            type;                                // son type
    int            priority;                            // sa priorité
    vec3_t        lastKnownPos;                        // dernier endroit connu de la cible de l'action (par ex. pack, ennemi, etc.)
    vec3_t        predictedPos;                        // position prédite (enfin on fait comme si) de la position de la cible
    int            node;                                // le node cible de l'action (INVALID si la cible est une entité)
    gentity_t    *ent;                                // l'entité cible de l'action (NULL si la cible est un node)
    int            timeOut;                            // dépend de la durée de validité de l'action
    int            timeOutWhenHidden;                    // dépend de la durée de validité de l'action quand sa cible est cachée
}action_t;

/*    structures pour l'IA du bobot
    nodes : current_node est déclaré dans g_local.h car un joueur humain en a besoin quand il construit les waypoints */

typedef struct Sbobot
{      qboolean                is_jumping;                // Is Bot Jumping?
    float                    teamPauseTime;            // To stop the centipede effect and seperate the team out a little
       vec3_t                    move_vector;            // Move Vector
       float                    wander_timeout;            // Wander Timeout
       int                        goal_node;                // Goal Node
       int                        next_node;                // Next Node
    vec3_t                     next_node_noise;        // Bruit apporté à la localisation du prochain node (next ou goal)
    int                        last_node;                // Last Node
    int                        node_timeout;            // Node Timeout
       int                        tries;                    // Number of Tries
       int                        state;                    // Bot State
       int                        action;                    // Bot action it is undertaking
    int                        skill;                    // Bot Skill Level Choice
    gentity_t                *goalentity;
       int                        lastMedicVoiceChat;   
       int                        myteam;
    int                        otherteam;
    /* concernant l'apprentissage des BOBOTs :
    le réseau de neurones chargé des mouvements du bobot */
    CNeuralNet                itsMoveBrain;
    vec_t                    last_seeUp,last_seeRight;
    int                        last_health;
    double                    last_moveOutputs[BOBOT_MOVE_BRAIN__NUM_OUTPUTS];
    vec_t                    maxDistanceFromNextNode;
    vec_t                    lastDistanceFromNextNode;
    vec_t                    minDistanceFromNextNode;
    vec3_t                    move_angles;
    double                    moveFitness;            // le score du bobot dans la génération courante
    /* le réseau de neurones chargé de la direction du regard du bobot */
    CNeuralNet                itsLookBrain;
    vec_t                    last_lookUp,last_lookRight;
    vec3_t                    teammatesVector[BOBOT_LOOK_BRAIN__MAX_TEAMMATES]; // localisation des équipiers proches
    double                    last_lookOutputs[BOBOT_MOVE_BRAIN__NUM_OUTPUTS];
    qboolean                frag;                    // annonce si un frag vient de se produire. utilisé pour le fitness
    qboolean                killed;                    // annonce si le bot vient de se faire tuer. utilisé pour le fitness
    double                    lookFitness;            // le score du bobot dans la génération courante
    /* le look sans réseau de neurones */
    int                        nextChangeNodeToLook;
    int                        chosenNodeToLook;
    int                        myNodesToLook[MAX_NODES];
    /*    Joc lissage de la visée */
    vec3_t                    vitesse_angle;            //vitesse de rotation de l'angle de visée
    int                        classe;                    // classe du bot
    qboolean                passeporte;                // si il passe à travers une porte il doit appuyer pou ouvrir ;)
    /*    PAV ----------------------------*/
    qboolean                DansTank;                // Vrai s'il est dans un tank ou s'il a pris un MG42, sinon faux.
    int                        BlokedNode;                // sur quel node le bot est bloqué (voulu)
    qboolean                Bloked;                    // Bloqué oui/non (blockage voulu)
    int                        TimeOnStuckNode;        // Temps passé sur un même node
    int                        StuckedNode;            // sur quel node le bot est bloqué (non voulu)
    int                        Ducked;                    // Duck oui/non
    int                        TimeSatchel;            // Temps avant de déclenché le satchel
    int                        MessageNode;            // Dernier Message dit
    qboolean                dit;                    // Si Dernier Message dit
    qboolean                prone;                    // Prone oui/non
    int                        TimeUseObject;            // Temps utilisation d'un node ou autre objet
    int                        TimeNode;                // Temps de libération d'un node
    int                        HitByTeammate;
    int                        DelayFireOnTeammate;
    int                        TimeFollow;
    /*----------------------------------*/
    int                        flicker;                //    utiliser pour ne pas faire le detect_client à chaque fois
    int                        cadence;
    /*    3emeType, détection */
    det_client_t            enemies[BOBOT_DETECT_MAX_ENEMIES];        // ennemis visibles
    det_client_t            teammates[BOBOT_DETECT_MAX_TEAMMATES];    // équipiers visibles
    det_item_t                healthPacks[BOBOT_DETECT_MAX_PACKS];    // health packs visibles
    det_item_t                ammoPacks[BOBOT_DETECT_MAX_PACKS];        // ammo packs visibles
    /*    3emeType, FUZZY LOGIC PART */
    action_t                actions[NB_COMMON_OBJECTIVES];             // actions possibles du bot à un tps donné, avec leur priorité.
    action_t                currentAction;                             // action courante
    action_t                armsAction;                             // action des bras du bot (indépendante de l'action courante)
    protection_action_t        protectionAction;                        // action de protection
    vec3_t                    protectionPoint;                         // lieu où il peut se protéger
    action_t                actionsStack[NB_MAX_ACTIONS_IN_STACK];    // pile des actions interrompues
    int                        sp;                                        // stack pointer (pointe le sommet de la pile des actions interrompues)
     known_cabinet_t            cabinets_heal[MAX_CABINETS];            // Connaissances des emplacements des cabinet de soins
    known_cabinet_t            cabinets_supply[MAX_CABINETS];            // Connaissances des emplacements des cabinet de munitions
    int                        UseGrenade;
    int                        TimeLanceGrenade;
    /* Inutilisés
    int                        weaponchoice;        // Bot Weapon Choice
    qboolean                bot_client;            // Bot Client
    float                    next_move_time;     // Next Move Time
    float                    suicide_timeout;    // Suicide Timeout
       float                    shooting_timeout;   // Shoot Timeout
    float                    yaw_speed;
    int                        mynum;
    gentity_t                *movetarget; */
}Sbobot;

/*------------------------------------------------End part 1 look at part 2

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